ReactOS  0.4.14-dev-317-g96040ec
wql.tab.c File Reference
#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wbemcli.h"
#include "wbemprox_private.h"
#include "wine/list.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include <stddef.h>
Include dependency graph for wql.tab.c:

Go to the source code of this file.

Classes

struct  parser
 
struct  string
 
union  YYSTYPE
 
union  yyalloc
 
struct  keyword
 

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.0"
 
#define YYSKELETON_NAME   "yacc.c"
 
#define YYPURE   1
 
#define YYPUSH   0
 
#define YYPULL   1
 
#define yyparse   wql_parse
 
#define yylex   wql_lex
 
#define yyerror   wql_error
 
#define yydebug   wql_debug
 
#define yynerrs   wql_nerrs
 
#define PARSER_BUBBLE_UP_VIEW(parser, result, current_view)
 
#define YY_NULL   0
 
#define YYERROR_VERBOSE   1
 
#define YY_WQL_E_REACTOSSYNC_GCC_DLL_WIN32_WBEMPROX_WQL_TAB_H_INCLUDED
 
#define YYDEBUG   0
 
#define YYTOKENTYPE
 
#define YYSTYPE_IS_TRIVIAL   1
 
#define YYSTYPE_IS_DECLARED   1
 
#define YYSIZE_T   size_t
 
#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
 
#define YY_(Msgid)   Msgid
 
#define __attribute__(Spec)   /* empty */
 
#define YYUSE(E)   ((void) (E))
 
#define YY_INITIAL_VALUE(Value)   Value
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
 
#define YYSTACK_ALLOC   YYMALLOC
 
#define YYSTACK_FREE   YYFREE
 
#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
 
#define YYMALLOC   malloc
 
#define YYFREE   free
 
#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
 
#define YYSTACK_BYTES(N)
 
#define YYCOPY_NEEDED   1
 
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
 
#define YYCOPY(Dst, Src, Count)
 
#define YYFINAL   9
 
#define YYLAST   85
 
#define YYNTOKENS   32
 
#define YYNNTS   10
 
#define YYNRULES   40
 
#define YYNSTATES   74
 
#define YYUNDEFTOK   2
 
#define YYMAXUTOK   286
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -23
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-23)))
 
#define YYTABLE_NINF   -1
 
#define yytable_value_is_error(Yytable_value)   0
 
#define yyerrok   (yyerrstatus = 0)
 
#define yyclearin   (yychar = YYEMPTY)
 
#define YYEMPTY   (-2)
 
#define YYEOF   0
 
#define YYACCEPT   goto yyacceptlab
 
#define YYABORT   goto yyabortlab
 
#define YYERROR   goto yyerrorlab
 
#define YYRECOVERING()   (!!yyerrstatus)
 
#define YYBACKUP(Token, Value)
 
#define YYTERROR   1
 
#define YYERRCODE   256
 
#define YYDPRINTF(Args)
 
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 
#define YY_STACK_PRINT(Bottom, Top)
 
#define YY_REDUCE_PRINT(Rule)
 
#define YYINITDEPTH   200
 
#define YYMAXDEPTH   10000
 
#define YYCASE_(N, S)
 
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
#define YYSYNTAX_ERROR
 
#define MAX_TOKEN_LEN   6
 

Typedefs

typedef union YYSTYPE YYSTYPE
 
typedef unsigned char yytype_uint8
 
typedef signed char yytype_int8
 
typedef unsigned short int yytype_uint16
 
typedef short int yytype_int16
 

Enumerations

enum  yytokentype {
  INSTR_ADD = 258, INSTR_NOP = 259, INSTR_MOV = 260, INSTR_SUB = 261,
  INSTR_MAD = 262, INSTR_MUL = 263, INSTR_RCP = 264, INSTR_RSQ = 265,
  INSTR_DP3 = 266, INSTR_DP4 = 267, INSTR_MIN = 268, INSTR_MAX = 269,
  INSTR_SLT = 270, INSTR_SGE = 271, INSTR_ABS = 272, INSTR_EXP = 273,
  INSTR_LOG = 274, INSTR_EXPP = 275, INSTR_LOGP = 276, INSTR_DST = 277,
  INSTR_LRP = 278, INSTR_FRC = 279, INSTR_POW = 280, INSTR_CRS = 281,
  INSTR_SGN = 282, INSTR_NRM = 283, INSTR_SINCOS = 284, INSTR_M4x4 = 285,
  INSTR_M4x3 = 286, INSTR_M3x4 = 287, INSTR_M3x3 = 288, INSTR_M3x2 = 289,
  INSTR_DCL = 290, INSTR_DEF = 291, INSTR_DEFB = 292, INSTR_DEFI = 293,
  INSTR_REP = 294, INSTR_ENDREP = 295, INSTR_IF = 296, INSTR_ELSE = 297,
  INSTR_ENDIF = 298, INSTR_BREAK = 299, INSTR_BREAKP = 300, INSTR_CALL = 301,
  INSTR_CALLNZ = 302, INSTR_LOOP = 303, INSTR_RET = 304, INSTR_ENDLOOP = 305,
  INSTR_LABEL = 306, INSTR_SETP = 307, INSTR_TEXLDL = 308, INSTR_LIT = 309,
  INSTR_MOVA = 310, INSTR_CND = 311, INSTR_CMP = 312, INSTR_DP2ADD = 313,
  INSTR_TEXCOORD = 314, INSTR_TEXCRD = 315, INSTR_TEXKILL = 316, INSTR_TEX = 317,
  INSTR_TEXLD = 318, INSTR_TEXBEM = 319, INSTR_TEXBEML = 320, INSTR_TEXREG2AR = 321,
  INSTR_TEXREG2GB = 322, INSTR_TEXREG2RGB = 323, INSTR_TEXM3x2PAD = 324, INSTR_TEXM3x2TEX = 325,
  INSTR_TEXM3x3PAD = 326, INSTR_TEXM3x3SPEC = 327, INSTR_TEXM3x3VSPEC = 328, INSTR_TEXM3x3TEX = 329,
  INSTR_TEXDP3TEX = 330, INSTR_TEXM3x2DEPTH = 331, INSTR_TEXDP3 = 332, INSTR_TEXM3x3 = 333,
  INSTR_TEXDEPTH = 334, INSTR_BEM = 335, INSTR_DSX = 336, INSTR_DSY = 337,
  INSTR_TEXLDP = 338, INSTR_TEXLDB = 339, INSTR_TEXLDD = 340, INSTR_PHASE = 341,
  REG_TEMP = 342, REG_OUTPUT = 343, REG_INPUT = 344, REG_CONSTFLOAT = 345,
  REG_CONSTINT = 346, REG_CONSTBOOL = 347, REG_TEXTURE = 348, REG_SAMPLER = 349,
  REG_TEXCRDOUT = 350, REG_OPOS = 351, REG_OFOG = 352, REG_OPTS = 353,
  REG_VERTEXCOLOR = 354, REG_FRAGCOLOR = 355, REG_FRAGDEPTH = 356, REG_VPOS = 357,
  REG_VFACE = 358, REG_ADDRESS = 359, REG_LOOP = 360, REG_PREDICATE = 361,
  REG_LABEL = 362, VER_VS10 = 363, VER_VS11 = 364, VER_VS20 = 365,
  VER_VS2X = 366, VER_VS30 = 367, VER_PS10 = 368, VER_PS11 = 369,
  VER_PS12 = 370, VER_PS13 = 371, VER_PS14 = 372, VER_PS20 = 373,
  VER_PS2X = 374, VER_PS30 = 375, SHIFT_X2 = 376, SHIFT_X4 = 377,
  SHIFT_X8 = 378, SHIFT_D2 = 379, SHIFT_D4 = 380, SHIFT_D8 = 381,
  MOD_SAT = 382, MOD_PP = 383, MOD_CENTROID = 384, COMP_GT = 385,
  COMP_LT = 386, COMP_GE = 387, COMP_LE = 388, COMP_EQ = 389,
  COMP_NE = 390, SMOD_BIAS = 391, SMOD_SCALEBIAS = 392, SMOD_DZ = 393,
  SMOD_DW = 394, SMOD_ABS = 395, SMOD_NOT = 396, SAMPTYPE_1D = 397,
  SAMPTYPE_2D = 398, SAMPTYPE_CUBE = 399, SAMPTYPE_VOLUME = 400, USAGE_POSITION = 401,
  USAGE_BLENDWEIGHT = 402, USAGE_BLENDINDICES = 403, USAGE_NORMAL = 404, USAGE_PSIZE = 405,
  USAGE_TEXCOORD = 406, USAGE_TANGENT = 407, USAGE_BINORMAL = 408, USAGE_TESSFACTOR = 409,
  USAGE_POSITIONT = 410, USAGE_COLOR = 411, USAGE_FOG = 412, USAGE_DEPTH = 413,
  USAGE_SAMPLE = 414, COMPONENT = 415, IMMVAL = 416, IMMBOOL = 417,
  INSTR_ADD = 258, INSTR_NOP = 259, INSTR_MOV = 260, INSTR_SUB = 261,
  INSTR_MAD = 262, INSTR_MUL = 263, INSTR_RCP = 264, INSTR_RSQ = 265,
  INSTR_DP3 = 266, INSTR_DP4 = 267, INSTR_MIN = 268, INSTR_MAX = 269,
  INSTR_SLT = 270, INSTR_SGE = 271, INSTR_ABS = 272, INSTR_EXP = 273,
  INSTR_LOG = 274, INSTR_EXPP = 275, INSTR_LOGP = 276, INSTR_DST = 277,
  INSTR_LRP = 278, INSTR_FRC = 279, INSTR_POW = 280, INSTR_CRS = 281,
  INSTR_SGN = 282, INSTR_NRM = 283, INSTR_SINCOS = 284, INSTR_M4x4 = 285,
  INSTR_M4x3 = 286, INSTR_M3x4 = 287, INSTR_M3x3 = 288, INSTR_M3x2 = 289,
  INSTR_DCL = 290, INSTR_DEF = 291, INSTR_DEFB = 292, INSTR_DEFI = 293,
  INSTR_REP = 294, INSTR_ENDREP = 295, INSTR_IF = 296, INSTR_ELSE = 297,
  INSTR_ENDIF = 298, INSTR_BREAK = 299, INSTR_BREAKP = 300, INSTR_CALL = 301,
  INSTR_CALLNZ = 302, INSTR_LOOP = 303, INSTR_RET = 304, INSTR_ENDLOOP = 305,
  INSTR_LABEL = 306, INSTR_SETP = 307, INSTR_TEXLDL = 308, INSTR_LIT = 309,
  INSTR_MOVA = 310, INSTR_CND = 311, INSTR_CMP = 312, INSTR_DP2ADD = 313,
  INSTR_TEXCOORD = 314, INSTR_TEXCRD = 315, INSTR_TEXKILL = 316, INSTR_TEX = 317,
  INSTR_TEXLD = 318, INSTR_TEXBEM = 319, INSTR_TEXBEML = 320, INSTR_TEXREG2AR = 321,
  INSTR_TEXREG2GB = 322, INSTR_TEXREG2RGB = 323, INSTR_TEXM3x2PAD = 324, INSTR_TEXM3x2TEX = 325,
  INSTR_TEXM3x3PAD = 326, INSTR_TEXM3x3SPEC = 327, INSTR_TEXM3x3VSPEC = 328, INSTR_TEXM3x3TEX = 329,
  INSTR_TEXDP3TEX = 330, INSTR_TEXM3x2DEPTH = 331, INSTR_TEXDP3 = 332, INSTR_TEXM3x3 = 333,
  INSTR_TEXDEPTH = 334, INSTR_BEM = 335, INSTR_DSX = 336, INSTR_DSY = 337,
  INSTR_TEXLDP = 338, INSTR_TEXLDB = 339, INSTR_TEXLDD = 340, INSTR_PHASE = 341,
  REG_TEMP = 342, REG_OUTPUT = 343, REG_INPUT = 344, REG_CONSTFLOAT = 345,
  REG_CONSTINT = 346, REG_CONSTBOOL = 347, REG_TEXTURE = 348, REG_SAMPLER = 349,
  REG_TEXCRDOUT = 350, REG_OPOS = 351, REG_OFOG = 352, REG_OPTS = 353,
  REG_VERTEXCOLOR = 354, REG_FRAGCOLOR = 355, REG_FRAGDEPTH = 356, REG_VPOS = 357,
  REG_VFACE = 358, REG_ADDRESS = 359, REG_LOOP = 360, REG_PREDICATE = 361,
  REG_LABEL = 362, VER_VS10 = 363, VER_VS11 = 364, VER_VS20 = 365,
  VER_VS2X = 366, VER_VS30 = 367, VER_PS10 = 368, VER_PS11 = 369,
  VER_PS12 = 370, VER_PS13 = 371, VER_PS14 = 372, VER_PS20 = 373,
  VER_PS2X = 374, VER_PS30 = 375, SHIFT_X2 = 376, SHIFT_X4 = 377,
  SHIFT_X8 = 378, SHIFT_D2 = 379, SHIFT_D4 = 380, SHIFT_D8 = 381,
  MOD_SAT = 382, MOD_PP = 383, MOD_CENTROID = 384, COMP_GT = 385,
  COMP_LT = 386, COMP_GE = 387, COMP_LE = 388, COMP_EQ = 389,
  COMP_NE = 390, SMOD_BIAS = 391, SMOD_SCALEBIAS = 392, SMOD_DZ = 393,
  SMOD_DW = 394, SMOD_ABS = 395, SMOD_NOT = 396, SAMPTYPE_1D = 397,
  SAMPTYPE_2D = 398, SAMPTYPE_CUBE = 399, SAMPTYPE_VOLUME = 400, USAGE_POSITION = 401,
  USAGE_BLENDWEIGHT = 402, USAGE_BLENDINDICES = 403, USAGE_NORMAL = 404, USAGE_PSIZE = 405,
  USAGE_TEXCOORD = 406, USAGE_TANGENT = 407, USAGE_BINORMAL = 408, USAGE_TESSFACTOR = 409,
  USAGE_POSITIONT = 410, USAGE_COLOR = 411, USAGE_FOG = 412, USAGE_DEPTH = 413,
  USAGE_SAMPLE = 414, COMPONENT = 415, IMMVAL = 416, IMMBOOL = 417,
  KW_BLENDSTATE = 258, KW_BREAK = 259, KW_BUFFER = 260, KW_CBUFFER = 261,
  KW_COLUMN_MAJOR = 262, KW_COMPILE = 263, KW_CONST = 264, KW_CONTINUE = 265,
  KW_DEPTHSTENCILSTATE = 266, KW_DEPTHSTENCILVIEW = 267, KW_DISCARD = 268, KW_DO = 269,
  KW_DOUBLE = 270, KW_ELSE = 271, KW_EXTERN = 272, KW_FALSE = 273,
  KW_FOR = 274, KW_GEOMETRYSHADER = 275, KW_GROUPSHARED = 276, KW_IF = 277,
  KW_IN = 278, KW_INLINE = 279, KW_INOUT = 280, KW_MATRIX = 281,
  KW_NAMESPACE = 282, KW_NOINTERPOLATION = 283, KW_OUT = 284, KW_PASS = 285,
  KW_PIXELSHADER = 286, KW_PRECISE = 287, KW_RASTERIZERSTATE = 288, KW_RENDERTARGETVIEW = 289,
  KW_RETURN = 290, KW_REGISTER = 291, KW_ROW_MAJOR = 292, KW_SAMPLER = 293,
  KW_SAMPLER1D = 294, KW_SAMPLER2D = 295, KW_SAMPLER3D = 296, KW_SAMPLERCUBE = 297,
  KW_SAMPLER_STATE = 298, KW_SAMPLERCOMPARISONSTATE = 299, KW_SHARED = 300, KW_STATEBLOCK = 301,
  KW_STATEBLOCK_STATE = 302, KW_STATIC = 303, KW_STRING = 304, KW_STRUCT = 305,
  KW_SWITCH = 306, KW_TBUFFER = 307, KW_TECHNIQUE = 308, KW_TECHNIQUE10 = 309,
  KW_TEXTURE = 310, KW_TEXTURE1D = 311, KW_TEXTURE1DARRAY = 312, KW_TEXTURE2D = 313,
  KW_TEXTURE2DARRAY = 314, KW_TEXTURE2DMS = 315, KW_TEXTURE2DMSARRAY = 316, KW_TEXTURE3D = 317,
  KW_TEXTURE3DARRAY = 318, KW_TEXTURECUBE = 319, KW_TRUE = 320, KW_TYPEDEF = 321,
  KW_UNIFORM = 322, KW_VECTOR = 323, KW_VERTEXSHADER = 324, KW_VOID = 325,
  KW_VOLATILE = 326, KW_WHILE = 327, OP_INC = 328, OP_DEC = 329,
  OP_AND = 330, OP_OR = 331, OP_EQ = 332, OP_LEFTSHIFT = 333,
  OP_LEFTSHIFTASSIGN = 334, OP_RIGHTSHIFT = 335, OP_RIGHTSHIFTASSIGN = 336, OP_ELLIPSIS = 337,
  OP_LE = 338, OP_GE = 339, OP_NE = 340, OP_ADDASSIGN = 341,
  OP_SUBASSIGN = 342, OP_MULASSIGN = 343, OP_DIVASSIGN = 344, OP_MODASSIGN = 345,
  OP_ANDASSIGN = 346, OP_ORASSIGN = 347, OP_XORASSIGN = 348, OP_UNKNOWN1 = 349,
  OP_UNKNOWN2 = 350, OP_UNKNOWN3 = 351, OP_UNKNOWN4 = 352, PRE_LINE = 353,
  VAR_IDENTIFIER = 354, TYPE_IDENTIFIER = 355, NEW_IDENTIFIER = 356, STRING = 357,
  C_FLOAT = 358, C_INTEGER = 359, KW_BLENDSTATE = 258, KW_BREAK = 259,
  KW_BUFFER = 260, KW_CBUFFER = 261, KW_COLUMN_MAJOR = 262, KW_COMPILE = 263,
  KW_CONST = 264, KW_CONTINUE = 265, KW_DEPTHSTENCILSTATE = 266, KW_DEPTHSTENCILVIEW = 267,
  KW_DISCARD = 268, KW_DO = 269, KW_DOUBLE = 270, KW_ELSE = 271,
  KW_EXTERN = 272, KW_FALSE = 273, KW_FOR = 274, KW_GEOMETRYSHADER = 275,
  KW_GROUPSHARED = 276, KW_IF = 277, KW_IN = 278, KW_INLINE = 279,
  KW_INOUT = 280, KW_MATRIX = 281, KW_NAMESPACE = 282, KW_NOINTERPOLATION = 283,
  KW_OUT = 284, KW_PASS = 285, KW_PIXELSHADER = 286, KW_PRECISE = 287,
  KW_RASTERIZERSTATE = 288, KW_RENDERTARGETVIEW = 289, KW_RETURN = 290, KW_REGISTER = 291,
  KW_ROW_MAJOR = 292, KW_SAMPLER = 293, KW_SAMPLER1D = 294, KW_SAMPLER2D = 295,
  KW_SAMPLER3D = 296, KW_SAMPLERCUBE = 297, KW_SAMPLER_STATE = 298, KW_SAMPLERCOMPARISONSTATE = 299,
  KW_SHARED = 300, KW_STATEBLOCK = 301, KW_STATEBLOCK_STATE = 302, KW_STATIC = 303,
  KW_STRING = 304, KW_STRUCT = 305, KW_SWITCH = 306, KW_TBUFFER = 307,
  KW_TECHNIQUE = 308, KW_TECHNIQUE10 = 309, KW_TEXTURE = 310, KW_TEXTURE1D = 311,
  KW_TEXTURE1DARRAY = 312, KW_TEXTURE2D = 313, KW_TEXTURE2DARRAY = 314, KW_TEXTURE2DMS = 315,
  KW_TEXTURE2DMSARRAY = 316, KW_TEXTURE3D = 317, KW_TEXTURE3DARRAY = 318, KW_TEXTURECUBE = 319,
  KW_TRUE = 320, KW_TYPEDEF = 321, KW_UNIFORM = 322, KW_VECTOR = 323,
  KW_VERTEXSHADER = 324, KW_VOID = 325, KW_VOLATILE = 326, KW_WHILE = 327,
  OP_INC = 328, OP_DEC = 329, OP_AND = 330, OP_OR = 331,
  OP_EQ = 332, OP_LEFTSHIFT = 333, OP_LEFTSHIFTASSIGN = 334, OP_RIGHTSHIFT = 335,
  OP_RIGHTSHIFTASSIGN = 336, OP_ELLIPSIS = 337, OP_LE = 338, OP_GE = 339,
  OP_NE = 340, OP_ADDASSIGN = 341, OP_SUBASSIGN = 342, OP_MULASSIGN = 343,
  OP_DIVASSIGN = 344, OP_MODASSIGN = 345, OP_ANDASSIGN = 346, OP_ORASSIGN = 347,
  OP_XORASSIGN = 348, OP_UNKNOWN1 = 349, OP_UNKNOWN2 = 350, OP_UNKNOWN3 = 351,
  OP_UNKNOWN4 = 352, PRE_LINE = 353, VAR_IDENTIFIER = 354, TYPE_IDENTIFIER = 355,
  NEW_IDENTIFIER = 356, STRING = 357, C_FLOAT = 358, C_INTEGER = 359,
  tRCINCLUDE = 258, tIF = 259, tIFDEF = 260, tIFNDEF = 261,
  tELSE = 262, tELIF = 263, tENDIF = 264, tDEFINED = 265,
  tNL = 266, tINCLUDE = 267, tLINE = 268, tGCCLINE = 269,
  tERROR = 270, tWARNING = 271, tPRAGMA = 272, tPPIDENT = 273,
  tUNDEF = 274, tMACROEND = 275, tCONCAT = 276, tELIPSIS = 277,
  tSTRINGIZE = 278, tIDENT = 279, tLITERAL = 280, tMACRO = 281,
  tDEFINE = 282, tDQSTRING = 283, tSQSTRING = 284, tIQSTRING = 285,
  tUINT = 286, tSINT = 287, tULONG = 288, tSLONG = 289,
  tULONGLONG = 290, tSLONGLONG = 291, tRCINCLUDEPATH = 292, tLOGOR = 293,
  tLOGAND = 294, tEQ = 295, tNE = 296, tLTE = 297,
  tGTE = 298, tLSHIFT = 299, tRSHIFT = 300, tRCINCLUDE = 258,
  tIF = 259, tIFDEF = 260, tIFNDEF = 261, tELSE = 262,
  tELIF = 263, tENDIF = 264, tDEFINED = 265, tNL = 266,
  tINCLUDE = 267, tLINE = 268, tGCCLINE = 269, tERROR = 270,
  tWARNING = 271, tPRAGMA = 272, tPPIDENT = 273, tUNDEF = 274,
  tMACROEND = 275, tCONCAT = 276, tELIPSIS = 277, tSTRINGIZE = 278,
  tIDENT = 279, tLITERAL = 280, tMACRO = 281, tDEFINE = 282,
  tDQSTRING = 283, tSQSTRING = 284, tIQSTRING = 285, tUINT = 286,
  tSINT = 287, tULONG = 288, tSLONG = 289, tULONGLONG = 290,
  tSLONGLONG = 291, tRCINCLUDEPATH = 292, tLOGOR = 293, tLOGAND = 294,
  tEQ = 295, tNE = 296, tLTE = 297, tGTE = 298,
  tLSHIFT = 299, tRSHIFT = 300, tEQ = 258, tEQEQ = 259,
  tNEQ = 260, tNEQEQ = 261, tLSHIFT = 262, tRSHIFT = 263,
  tRRSHIFT = 264, tOR = 265, tAND = 266, tLEQ = 267,
  tGEQ = 268, tCCValue = 269, tEQ = 258, tEQEQ = 259,
  tNEQ = 260, tNEQEQ = 261, tLSHIFT = 262, tRSHIFT = 263,
  tRRSHIFT = 264, tOR = 265, tAND = 266, tLEQ = 267,
  tGEQ = 268, tCCValue = 269, kBREAK = 258, kCASE = 259,
  kCATCH = 260, kCONTINUE = 261, kDEFAULT = 262, kDELETE = 263,
  kDO = 264, kELSE = 265, kFUNCTION = 266, kIF = 267,
  kFINALLY = 268, kFOR = 269, kGET = 270, kIN = 271,
  kSET = 272, kINSTANCEOF = 273, kNEW = 274, kNULL = 275,
  kRETURN = 276, kSWITCH = 277, kTHIS = 278, kTHROW = 279,
  kTRUE = 280, kFALSE = 281, kTRY = 282, kTYPEOF = 283,
  kVAR = 284, kVOID = 285, kWHILE = 286, kWITH = 287,
  tANDAND = 288, tOROR = 289, tINC = 290, tDEC = 291,
  tHTMLCOMMENT = 292, kDIVEQ = 293, kDCOL = 294, tIdentifier = 295,
  tAssignOper = 296, tEqOper = 297, tShiftOper = 298, tRelOper = 299,
  tNumericLiteral = 300, tBooleanLiteral = 301, tStringLiteral = 302, tEOF = 303,
  LOWER_THAN_ELSE = 304, kBREAK = 258, kCASE = 259, kCATCH = 260,
  kCONTINUE = 261, kDEFAULT = 262, kDELETE = 263, kDO = 264,
  kELSE = 265, kFUNCTION = 266, kIF = 267, kFINALLY = 268,
  kFOR = 269, kGET = 270, kIN = 271, kSET = 272,
  kINSTANCEOF = 273, kNEW = 274, kNULL = 275, kRETURN = 276,
  kSWITCH = 277, kTHIS = 278, kTHROW = 279, kTRUE = 280,
  kFALSE = 281, kTRY = 282, kTYPEOF = 283, kVAR = 284,
  kVOID = 285, kWHILE = 286, kWITH = 287, tANDAND = 288,
  tOROR = 289, tINC = 290, tDEC = 291, tHTMLCOMMENT = 292,
  kDIVEQ = 293, kDCOL = 294, tIdentifier = 295, tAssignOper = 296,
  tEqOper = 297, tShiftOper = 298, tRelOper = 299, tNumericLiteral = 300,
  tBooleanLiteral = 301, tStringLiteral = 302, tEOF = 303, LOWER_THAN_ELSE = 304,
  COND_SPACE = 258, COND_EOF = 259, COND_OR = 260, COND_AND = 261,
  COND_NOT = 262, COND_XOR = 263, COND_IMP = 264, COND_EQV = 265,
  COND_LT = 266, COND_GT = 267, COND_EQ = 268, COND_NE = 269,
  COND_GE = 270, COND_LE = 271, COND_ILT = 272, COND_IGT = 273,
  COND_IEQ = 274, COND_INE = 275, COND_IGE = 276, COND_ILE = 277,
  COND_LPAR = 278, COND_RPAR = 279, COND_TILDA = 280, COND_SS = 281,
  COND_ISS = 282, COND_ILHS = 283, COND_IRHS = 284, COND_LHS = 285,
  COND_RHS = 286, COND_PERCENT = 287, COND_DOLLARS = 288, COND_QUESTION = 289,
  COND_AMPER = 290, COND_EXCLAM = 291, COND_IDENT = 292, COND_NUMBER = 293,
  COND_LITER = 294, COND_ERROR = 295, TK_ALTER = 258, TK_AND = 259,
  TK_BY = 260, TK_CHAR = 261, TK_COMMA = 262, TK_CREATE = 263,
  TK_DELETE = 264, TK_DROP = 265, TK_DISTINCT = 266, TK_DOT = 267,
  TK_EQ = 268, TK_FREE = 269, TK_FROM = 270, TK_GE = 271,
  TK_GT = 272, TK_HOLD = 273, TK_ADD = 274, TK_ID = 275,
  TK_ILLEGAL = 276, TK_INSERT = 277, TK_INT = 278, TK_INTEGER = 279,
  TK_INTO = 280, TK_IS = 281, TK_KEY = 282, TK_LE = 283,
  TK_LONG = 284, TK_LONGCHAR = 285, TK_LP = 286, TK_LT = 287,
  TK_LOCALIZABLE = 288, TK_MINUS = 289, TK_NE = 290, TK_NOT = 291,
  TK_NULL = 292, TK_OBJECT = 293, TK_OR = 294, TK_ORDER = 295,
  TK_PRIMARY = 296, TK_RP = 297, TK_SELECT = 298, TK_SET = 299,
  TK_SHORT = 300, TK_SPACE = 301, TK_STAR = 302, TK_STRING = 303,
  TK_TABLE = 304, TK_TEMPORARY = 305, TK_UPDATE = 306, TK_VALUES = 307,
  TK_WHERE = 308, TK_WILDCARD = 309, END_OF_FILE = 310, ILLEGAL = 311,
  SPACE = 312, UNCLOSED_STRING = 313, COMMENT = 314, FUNCTION = 315,
  COLUMN = 316, TK_LIKE = 318, TK_NEGATION = 319, TK_ALTER = 258,
  TK_AND = 259, TK_BY = 260, TK_CHAR = 261, TK_COMMA = 262,
  TK_CREATE = 263, TK_DELETE = 264, TK_DROP = 265, TK_DISTINCT = 266,
  TK_DOT = 267, TK_EQ = 268, TK_FREE = 269, TK_FROM = 270,
  TK_GE = 271, TK_GT = 272, TK_HOLD = 273, TK_ADD = 274,
  TK_ID = 275, TK_ILLEGAL = 276, TK_INSERT = 277, TK_INT = 278,
  TK_INTEGER = 279, TK_INTO = 280, TK_IS = 281, TK_KEY = 282,
  TK_LE = 283, TK_LONG = 284, TK_LONGCHAR = 285, TK_LP = 286,
  TK_LT = 287, TK_LOCALIZABLE = 288, TK_MINUS = 289, TK_NE = 290,
  TK_NOT = 291, TK_NULL = 292, TK_OBJECT = 293, TK_OR = 294,
  TK_ORDER = 295, TK_PRIMARY = 296, TK_RP = 297, TK_SELECT = 298,
  TK_SET = 299, TK_SHORT = 300, TK_SPACE = 301, TK_STAR = 302,
  TK_STRING = 303, TK_TABLE = 304, TK_TEMPORARY = 305, TK_UPDATE = 306,
  TK_VALUES = 307, TK_WHERE = 308, TK_WILDCARD = 309, END_OF_FILE = 310,
  ILLEGAL = 311, SPACE = 312, UNCLOSED_STRING = 313, COMMENT = 314,
  FUNCTION = 315, COLUMN = 316, TK_LIKE = 318, TK_NEGATION = 319,
  TOK_Parent = 258, TOK_Self = 259, TOK_DblFSlash = 260, TOK_FSlash = 261,
  TOK_Axis = 262, TOK_Colon = 263, TOK_OpAnd = 264, TOK_OpOr = 265,
  TOK_OpNot = 266, TOK_OpEq = 267, TOK_OpIEq = 268, TOK_OpNEq = 269,
  TOK_OpINEq = 270, TOK_OpLt = 271, TOK_OpILt = 272, TOK_OpGt = 273,
  TOK_OpIGt = 274, TOK_OpLEq = 275, TOK_OpILEq = 276, TOK_OpGEq = 277,
  TOK_OpIGEq = 278, TOK_OpAll = 279, TOK_OpAny = 280, TOK_NCName = 281,
  TOK_Literal = 282, TOK_Number = 283, tEOF = 258, tNL = 259,
  tREM = 260, tEMPTYBRACKETS = 261, tTRUE = 262, tFALSE = 263,
  tNOT = 264, tAND = 265, tOR = 266, tXOR = 267,
  tEQV = 268, tIMP = 269, tNEQ = 270, tIS = 271,
  tLTEQ = 272, tGTEQ = 273, tMOD = 274, tCALL = 275,
  tDIM = 276, tSUB = 277, tFUNCTION = 278, tPROPERTY = 279,
  tGET = 280, tLET = 281, tCONST = 282, tIF = 283,
  tELSE = 284, tELSEIF = 285, tEND = 286, tTHEN = 287,
  tEXIT = 288, tWHILE = 289, tWEND = 290, tDO = 291,
  tLOOP = 292, tUNTIL = 293, tFOR = 294, tTO = 295,
  tSTEP = 296, tEACH = 297, tIN = 298, tSELECT = 299,
  tCASE = 300, tBYREF = 301, tBYVAL = 302, tOPTION = 303,
  tEXPLICIT = 304, tSTOP = 305, tNOTHING = 306, tEMPTY = 307,
  tNULL = 308, tCLASS = 309, tSET = 310, tNEW = 311,
  tPUBLIC = 312, tPRIVATE = 313, tDEFAULT = 314, tME = 315,
  tERROR = 316, tNEXT = 317, tON = 318, tRESUME = 319,
  tGOTO = 320, tIdentifier = 321, tString = 322, tLong = 323,
  tShort = 324, tDouble = 325, tEOF = 258, tNL = 259,
  tREM = 260, tEMPTYBRACKETS = 261, tTRUE = 262, tFALSE = 263,
  tNOT = 264, tAND = 265, tOR = 266, tXOR = 267,
  tEQV = 268, tIMP = 269, tNEQ = 270, tIS = 271,
  tLTEQ = 272, tGTEQ = 273, tMOD = 274, tCALL = 275,
  tDIM = 276, tSUB = 277, tFUNCTION = 278, tPROPERTY = 279,
  tGET = 280, tLET = 281, tCONST = 282, tIF = 283,
  tELSE = 284, tELSEIF = 285, tEND = 286, tTHEN = 287,
  tEXIT = 288, tWHILE = 289, tWEND = 290, tDO = 291,
  tLOOP = 292, tUNTIL = 293, tFOR = 294, tTO = 295,
  tSTEP = 296, tEACH = 297, tIN = 298, tSELECT = 299,
  tCASE = 300, tBYREF = 301, tBYVAL = 302, tOPTION = 303,
  tEXPLICIT = 304, tSTOP = 305, tNOTHING = 306, tEMPTY = 307,
  tNULL = 308, tCLASS = 309, tSET = 310, tNEW = 311,
  tPUBLIC = 312, tPRIVATE = 313, tDEFAULT = 314, tME = 315,
  tERROR = 316, tNEXT = 317, tON = 318, tRESUME = 319,
  tGOTO = 320, tIdentifier = 321, tString = 322, tLong = 323,
  tShort = 324, tDouble = 325, TK_SELECT = 258, TK_FROM = 259,
  TK_STAR = 260, TK_COMMA = 261, TK_DOT = 262, TK_IS = 263,
  TK_LP = 264, TK_RP = 265, TK_NULL = 266, TK_FALSE = 267,
  TK_TRUE = 268, TK_INTEGER = 269, TK_WHERE = 270, TK_SPACE = 271,
  TK_MINUS = 272, TK_ILLEGAL = 273, TK_BY = 274, TK_STRING = 275,
  TK_ID = 276, TK_OR = 277, TK_AND = 278, TK_NOT = 279,
  TK_EQ = 280, TK_NE = 281, TK_LT = 282, TK_GT = 283,
  TK_LE = 284, TK_GE = 285, TK_LIKE = 286, TK_SELECT = 258,
  TK_FROM = 259, TK_STAR = 260, TK_COMMA = 261, TK_DOT = 262,
  TK_IS = 263, TK_LP = 264, TK_RP = 265, TK_NULL = 266,
  TK_FALSE = 267, TK_TRUE = 268, TK_INTEGER = 269, TK_WHERE = 270,
  TK_SPACE = 271, TK_MINUS = 272, TK_ILLEGAL = 273, TK_BY = 274,
  TK_STRING = 275, TK_ID = 276, TK_OR = 277, TK_AND = 278,
  TK_NOT = 279, TK_EQ = 280, TK_NE = 281, TK_LT = 282,
  TK_GT = 283, TK_LE = 284, TK_GE = 285, TK_LIKE = 286,
  aIDENTIFIER = 258, aPRAGMA = 259, aKNOWNTYPE = 260, aNUM = 261,
  aHEXNUM = 262, aDOUBLE = 263, aSTRING = 264, aWSTRING = 265,
  aSQSTRING = 266, aUUID = 267, aEOF = 268, aACF = 269,
  SHL = 270, SHR = 271, MEMBERPTR = 272, EQUALITY = 273,
  INEQUALITY = 274, GREATEREQUAL = 275, LESSEQUAL = 276, LOGICALOR = 277,
  LOGICALAND = 278, ELLIPSIS = 279, tAGGREGATABLE = 280, tALLOCATE = 281,
  tANNOTATION = 282, tAPPOBJECT = 283, tASYNC = 284, tASYNCUUID = 285,
  tAUTOHANDLE = 286, tBINDABLE = 287, tBOOLEAN = 288, tBROADCAST = 289,
  tBYTE = 290, tBYTECOUNT = 291, tCALLAS = 292, tCALLBACK = 293,
  tCASE = 294, tCDECL = 295, tCHAR = 296, tCOCLASS = 297,
  tCODE = 298, tCOMMSTATUS = 299, tCONST = 300, tCONTEXTHANDLE = 301,
  tCONTEXTHANDLENOSERIALIZE = 302, tCONTEXTHANDLESERIALIZE = 303, tCONTROL = 304, tCPPQUOTE = 305,
  tDECODE = 306, tDEFAULT = 307, tDEFAULTBIND = 308, tDEFAULTCOLLELEM = 309,
  tDEFAULTVALUE = 310, tDEFAULTVTABLE = 311, tDISABLECONSISTENCYCHECK = 312, tDISPLAYBIND = 313,
  tDISPINTERFACE = 314, tDLLNAME = 315, tDOUBLE = 316, tDUAL = 317,
  tENABLEALLOCATE = 318, tENCODE = 319, tENDPOINT = 320, tENTRY = 321,
  tENUM = 322, tERRORSTATUST = 323, tEXPLICITHANDLE = 324, tEXTERN = 325,
  tFALSE = 326, tFASTCALL = 327, tFAULTSTATUS = 328, tFLOAT = 329,
  tFORCEALLOCATE = 330, tHANDLE = 331, tHANDLET = 332, tHELPCONTEXT = 333,
  tHELPFILE = 334, tHELPSTRING = 335, tHELPSTRINGCONTEXT = 336, tHELPSTRINGDLL = 337,
  tHIDDEN = 338, tHYPER = 339, tID = 340, tIDEMPOTENT = 341,
  tIGNORE = 342, tIIDIS = 343, tIMMEDIATEBIND = 344, tIMPLICITHANDLE = 345,
  tIMPORT = 346, tIMPORTLIB = 347, tIN = 348, tIN_LINE = 349,
  tINLINE = 350, tINPUTSYNC = 351, tINT = 352, tINT32 = 353,
  tINT3264 = 354, tINT64 = 355, tINTERFACE = 356, tLCID = 357,
  tLENGTHIS = 358, tLIBRARY = 359, tLICENSED = 360, tLOCAL = 361,
  tLONG = 362, tMAYBE = 363, tMESSAGE = 364, tMETHODS = 365,
  tMODULE = 366, tNAMESPACE = 367, tNOCODE = 368, tNONBROWSABLE = 369,
  tNONCREATABLE = 370, tNONEXTENSIBLE = 371, tNOTIFY = 372, tNOTIFYFLAG = 373,
  tNULL = 374, tOBJECT = 375, tODL = 376, tOLEAUTOMATION = 377,
  tOPTIMIZE = 378, tOPTIONAL = 379, tOUT = 380, tPARTIALIGNORE = 381,
  tPASCAL = 382, tPOINTERDEFAULT = 383, tPRAGMA_WARNING = 384, tPROGID = 385,
  tPROPERTIES = 386, tPROPGET = 387, tPROPPUT = 388, tPROPPUTREF = 389,
  tPROXY = 390, tPTR = 391, tPUBLIC = 392, tRANGE = 393,
  tREADONLY = 394, tREF = 395, tREGISTER = 396, tREPRESENTAS = 397,
  tREQUESTEDIT = 398, tRESTRICTED = 399, tRETVAL = 400, tSAFEARRAY = 401,
  tSHORT = 402, tSIGNED = 403, tSIZEIS = 404, tSIZEOF = 405,
  tSMALL = 406, tSOURCE = 407, tSTATIC = 408, tSTDCALL = 409,
  tSTRICTCONTEXTHANDLE = 410, tSTRING = 411, tSTRUCT = 412, tSWITCH = 413,
  tSWITCHIS = 414, tSWITCHTYPE = 415, tTHREADING = 416, tTRANSMITAS = 417,
  tTRUE = 418, tTYPEDEF = 419, tUIDEFAULT = 420, tUNION = 421,
  tUNIQUE = 422, tUNSIGNED = 423, tUSESGETLASTERROR = 424, tUSERMARSHAL = 425,
  tUUID = 426, tV1ENUM = 427, tVARARG = 428, tVERSION = 429,
  tVIPROGID = 430, tVOID = 431, tWCHAR = 432, tWIREMARSHAL = 433,
  tAPARTMENT = 434, tNEUTRAL = 435, tSINGLE = 436, tFREE = 437,
  tBOTH = 438, CAST = 439, PPTR = 440, POS = 441,
  NEG = 442, ADDRESSOF = 443, aIDENTIFIER = 258, aPRAGMA = 259,
  aKNOWNTYPE = 260, aNUM = 261, aHEXNUM = 262, aDOUBLE = 263,
  aSTRING = 264, aWSTRING = 265, aSQSTRING = 266, aUUID = 267,
  aEOF = 268, aACF = 269, SHL = 270, SHR = 271,
  MEMBERPTR = 272, EQUALITY = 273, INEQUALITY = 274, GREATEREQUAL = 275,
  LESSEQUAL = 276, LOGICALOR = 277, LOGICALAND = 278, ELLIPSIS = 279,
  tAGGREGATABLE = 280, tALLOCATE = 281, tANNOTATION = 282, tAPPOBJECT = 283,
  tASYNC = 284, tASYNCUUID = 285, tAUTOHANDLE = 286, tBINDABLE = 287,
  tBOOLEAN = 288, tBROADCAST = 289, tBYTE = 290, tBYTECOUNT = 291,
  tCALLAS = 292, tCALLBACK = 293, tCASE = 294, tCDECL = 295,
  tCHAR = 296, tCOCLASS = 297, tCODE = 298, tCOMMSTATUS = 299,
  tCONST = 300, tCONTEXTHANDLE = 301, tCONTEXTHANDLENOSERIALIZE = 302, tCONTEXTHANDLESERIALIZE = 303,
  tCONTROL = 304, tCPPQUOTE = 305, tDECODE = 306, tDEFAULT = 307,
  tDEFAULTBIND = 308, tDEFAULTCOLLELEM = 309, tDEFAULTVALUE = 310, tDEFAULTVTABLE = 311,
  tDISABLECONSISTENCYCHECK = 312, tDISPLAYBIND = 313, tDISPINTERFACE = 314, tDLLNAME = 315,
  tDOUBLE = 316, tDUAL = 317, tENABLEALLOCATE = 318, tENCODE = 319,
  tENDPOINT = 320, tENTRY = 321, tENUM = 322, tERRORSTATUST = 323,
  tEXPLICITHANDLE = 324, tEXTERN = 325, tFALSE = 326, tFASTCALL = 327,
  tFAULTSTATUS = 328, tFLOAT = 329, tFORCEALLOCATE = 330, tHANDLE = 331,
  tHANDLET = 332, tHELPCONTEXT = 333, tHELPFILE = 334, tHELPSTRING = 335,
  tHELPSTRINGCONTEXT = 336, tHELPSTRINGDLL = 337, tHIDDEN = 338, tHYPER = 339,
  tID = 340, tIDEMPOTENT = 341, tIGNORE = 342, tIIDIS = 343,
  tIMMEDIATEBIND = 344, tIMPLICITHANDLE = 345, tIMPORT = 346, tIMPORTLIB = 347,
  tIN = 348, tIN_LINE = 349, tINLINE = 350, tINPUTSYNC = 351,
  tINT = 352, tINT32 = 353, tINT3264 = 354, tINT64 = 355,
  tINTERFACE = 356, tLCID = 357, tLENGTHIS = 358, tLIBRARY = 359,
  tLICENSED = 360, tLOCAL = 361, tLONG = 362, tMAYBE = 363,
  tMESSAGE = 364, tMETHODS = 365, tMODULE = 366, tNAMESPACE = 367,
  tNOCODE = 368, tNONBROWSABLE = 369, tNONCREATABLE = 370, tNONEXTENSIBLE = 371,
  tNOTIFY = 372, tNOTIFYFLAG = 373, tNULL = 374, tOBJECT = 375,
  tODL = 376, tOLEAUTOMATION = 377, tOPTIMIZE = 378, tOPTIONAL = 379,
  tOUT = 380, tPARTIALIGNORE = 381, tPASCAL = 382, tPOINTERDEFAULT = 383,
  tPRAGMA_WARNING = 384, tPROGID = 385, tPROPERTIES = 386, tPROPGET = 387,
  tPROPPUT = 388, tPROPPUTREF = 389, tPROXY = 390, tPTR = 391,
  tPUBLIC = 392, tRANGE = 393, tREADONLY = 394, tREF = 395,
  tREGISTER = 396, tREPRESENTAS = 397, tREQUESTEDIT = 398, tRESTRICTED = 399,
  tRETVAL = 400, tSAFEARRAY = 401, tSHORT = 402, tSIGNED = 403,
  tSIZEIS = 404, tSIZEOF = 405, tSMALL = 406, tSOURCE = 407,
  tSTATIC = 408, tSTDCALL = 409, tSTRICTCONTEXTHANDLE = 410, tSTRING = 411,
  tSTRUCT = 412, tSWITCH = 413, tSWITCHIS = 414, tSWITCHTYPE = 415,
  tTHREADING = 416, tTRANSMITAS = 417, tTRUE = 418, tTYPEDEF = 419,
  tUIDEFAULT = 420, tUNION = 421, tUNIQUE = 422, tUNSIGNED = 423,
  tUSESGETLASTERROR = 424, tUSERMARSHAL = 425, tUUID = 426, tV1ENUM = 427,
  tVARARG = 428, tVERSION = 429, tVIPROGID = 430, tVOID = 431,
  tWCHAR = 432, tWIREMARSHAL = 433, tAPARTMENT = 434, tNEUTRAL = 435,
  tSINGLE = 436, tFREE = 437, tBOTH = 438, CAST = 439,
  PPTR = 440, POS = 441, NEG = 442, ADDRESSOF = 443,
  tRCINCLUDE = 258, tIF = 259, tIFDEF = 260, tIFNDEF = 261,
  tELSE = 262, tELIF = 263, tENDIF = 264, tDEFINED = 265,
  tNL = 266, tINCLUDE = 267, tLINE = 268, tGCCLINE = 269,
  tERROR = 270, tWARNING = 271, tPRAGMA = 272, tPPIDENT = 273,
  tUNDEF = 274, tMACROEND = 275, tCONCAT = 276, tELIPSIS = 277,
  tSTRINGIZE = 278, tIDENT = 279, tLITERAL = 280, tMACRO = 281,
  tDEFINE = 282, tDQSTRING = 283, tSQSTRING = 284, tIQSTRING = 285,
  tUINT = 286, tSINT = 287, tULONG = 288, tSLONG = 289,
  tULONGLONG = 290, tSLONGLONG = 291, tRCINCLUDEPATH = 292, tLOGOR = 293,
  tLOGAND = 294, tEQ = 295, tNE = 296, tLTE = 297,
  tGTE = 298, tLSHIFT = 299, tRSHIFT = 300, tRCINCLUDE = 258,
  tIF = 259, tIFDEF = 260, tIFNDEF = 261, tELSE = 262,
  tELIF = 263, tENDIF = 264, tDEFINED = 265, tNL = 266,
  tINCLUDE = 267, tLINE = 268, tGCCLINE = 269, tERROR = 270,
  tWARNING = 271, tPRAGMA = 272, tPPIDENT = 273, tUNDEF = 274,
  tMACROEND = 275, tCONCAT = 276, tELIPSIS = 277, tSTRINGIZE = 278,
  tIDENT = 279, tLITERAL = 280, tMACRO = 281, tDEFINE = 282,
  tDQSTRING = 283, tSQSTRING = 284, tIQSTRING = 285, tUINT = 286,
  tSINT = 287, tULONG = 288, tSLONG = 289, tULONGLONG = 290,
  tSLONGLONG = 291, tRCINCLUDEPATH = 292, tLOGOR = 293, tLOGAND = 294,
  tEQ = 295, tNE = 296, tLTE = 297, tGTE = 298,
  tLSHIFT = 299, tRSHIFT = 300
}
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (wbemprox)
 
static voidalloc_mem (struct parser *parser, UINT size)
 
static struct propertyalloc_property (struct parser *parser, const WCHAR *class, const WCHAR *name)
 
static WCHARget_string (struct parser *parser, const struct string *str)
 
static int get_int (struct parser *parser)
 
static struct exprexpr_complex (struct parser *parser, struct expr *l, UINT op, struct expr *r)
 
static struct exprexpr_unary (struct parser *parser, struct expr *l, UINT op)
 
static struct exprexpr_ival (struct parser *parser, int val)
 
static struct exprexpr_sval (struct parser *parser, const struct string *str)
 
static struct exprexpr_bval (struct parser *parser, int val)
 
static struct exprexpr_propval (struct parser *parser, const struct property *prop)
 
static int wql_error (struct parser *parser, const char *str)
 
static int wql_lex (void *val, struct parser *parser)
 
int wql_parse (struct parser *ctx)
 
voidmalloc (YYSIZE_T)
 
void free (void *)
 
static YYSIZE_T yystrlen (const char *yystr)
 
static charyystpcpy (char *yydest, const char *yysrc)
 
static YYSIZE_T yytnamerr (char *yyres, const char *yystr)
 
static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
 
static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser *ctx)
 
int yyparse (struct parser *ctx)
 
HRESULT parse_query (const WCHAR *str, struct view **view, struct list *mem)
 
static int cmp_keyword (const void *arg1, const void *arg2)
 
static int keyword_type (const WCHAR *str, unsigned int len)
 
static int get_token (const WCHAR *s, int *token)
 

Variables

static const yytype_uint8 yytranslate []
 
static const char *const yytname []
 
static const yytype_int8 yypact []
 
static const yytype_uint8 yydefact []
 
static const yytype_int8 yypgoto []
 
static const yytype_int8 yydefgoto []
 
static const yytype_uint8 yytable []
 
static const yytype_int8 yycheck []
 
static const yytype_uint8 yystos []
 
static const yytype_uint8 yyr1 []
 
static const yytype_uint8 yyr2 []
 
static const char id_char []
 
static const WCHAR andW [] = {'A','N','D'}
 
static const WCHAR byW [] = {'B','Y'}
 
static const WCHAR falseW [] = {'F','A','L','S','E'}
 
static const WCHAR fromW [] = {'F','R','O','M'}
 
static const WCHAR isW [] = {'I','S'}
 
static const WCHAR likeW [] = {'L','I','K','E'}
 
static const WCHAR notW [] = {'N','O','T'}
 
static const WCHAR nullW [] = {'N','U','L','L'}
 
static const WCHAR orW [] = {'O','R'}
 
static const WCHAR selectW [] = {'S','E','L','E','C','T'}
 
static const WCHAR trueW [] = {'T','R','U','E'}
 
static const WCHAR whereW [] = {'W','H','E','R','E'}
 
static const struct keyword keyword_table []
 

Macro Definition Documentation

◆ __attribute__

#define __attribute__ (   Spec)    /* empty */

Definition at line 414 of file wql.tab.c.

◆ MAX_TOKEN_LEN

#define MAX_TOKEN_LEN   6

Definition at line 2141 of file wql.tab.c.

◆ PARSER_BUBBLE_UP_VIEW

#define PARSER_BUBBLE_UP_VIEW (   parser,
  result,
  current_view 
)
Value:
*parser->view = current_view; \
result = current_view
Definition: import.c:86
struct view ** view
Definition: wql.tab.c:112

Definition at line 253 of file wql.tab.c.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 406 of file wql.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 437 of file wql.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 438 of file wql.tab.c.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 434 of file wql.tab.c.

◆ YY_NULL

#define YY_NULL   0

Definition at line 264 of file wql.tab.c.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 946 of file wql.tab.c.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 945 of file wql.tab.c.

◆ YY_SYMBOL_PRINT

#define YY_SYMBOL_PRINT (   Title,
  Type,
  Value,
  Location 
)

Definition at line 944 of file wql.tab.c.

◆ YY_WQL_E_REACTOSSYNC_GCC_DLL_WIN32_WBEMPROX_WQL_TAB_H_INCLUDED

#define YY_WQL_E_REACTOSSYNC_GCC_DLL_WIN32_WBEMPROX_WQL_TAB_H_INCLUDED

Definition at line 279 of file wql.tab.c.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 790 of file wql.tab.c.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 789 of file wql.tab.c.

◆ YYBACKUP

#define YYBACKUP (   Token,
  Value 
)
Value:
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (ctx, YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2343
#define yychar
Definition: asmshader.tab.c:74
_IRQL_requires_same_ _In_ PLSA_STRING _In_ SECURITY_LOGON_TYPE _In_ ULONG _In_ ULONG _In_opt_ PTOKEN_GROUPS _In_ PTOKEN_SOURCE _Out_ PVOID _Out_ PULONG _Inout_ PLUID _Out_ PHANDLE Token
#define YY_(Msgid)
Definition: wql.tab.c:406
#define YYEMPTY
Definition: wql.tab.c:786
if(!(yy_init))
Definition: macro.lex.yy.c:714

Definition at line 796 of file wql.tab.c.

◆ YYBISON

#define YYBISON   1

Definition at line 44 of file wql.tab.c.

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.0"

Definition at line 47 of file wql.tab.c.

◆ YYCASE_

#define YYCASE_ (   N,
  S 
)
Value:
case N: \
yyformat = S; \
break
#define S(x)
Definition: test.h:190

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 785 of file wql.tab.c.

◆ YYCOPY

#define YYCOPY (   Dst,
  Src,
  Count 
)
Value:
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
#define Dst
Definition: mesh.h:153

Definition at line 561 of file wql.tab.c.

◆ YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 533 of file wql.tab.c.

◆ yydebug

#define yydebug   wql_debug

Definition at line 66 of file wql.tab.c.

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 282 of file wql.tab.c.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 943 of file wql.tab.c.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 786 of file wql.tab.c.

◆ YYEOF

#define YYEOF   0

Definition at line 787 of file wql.tab.c.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 815 of file wql.tab.c.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 784 of file wql.tab.c.

◆ yyerror

#define yyerror   wql_error

Definition at line 65 of file wql.tab.c.

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 791 of file wql.tab.c.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   1

Definition at line 273 of file wql.tab.c.

◆ YYFINAL

#define YYFINAL   9

Definition at line 574 of file wql.tab.c.

◆ YYFREE

#define YYFREE   free

Definition at line 504 of file wql.tab.c.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 952 of file wql.tab.c.

◆ YYLAST

#define YYLAST   85

Definition at line 576 of file wql.tab.c.

◆ yylex

#define yylex   wql_lex

Definition at line 64 of file wql.tab.c.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 498 of file wql.tab.c.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 963 of file wql.tab.c.

◆ YYMAXUTOK

#define YYMAXUTOK   286

Definition at line 590 of file wql.tab.c.

◆ yynerrs

#define yynerrs   wql_nerrs

Definition at line 67 of file wql.tab.c.

◆ YYNNTS

#define YYNNTS   10

Definition at line 581 of file wql.tab.c.

◆ YYNRULES

#define YYNRULES   40

Definition at line 583 of file wql.tab.c.

◆ YYNSTATES

#define YYNSTATES   74

Definition at line 585 of file wql.tab.c.

◆ YYNTOKENS

#define YYNTOKENS   32

Definition at line 579 of file wql.tab.c.

◆ YYPACT_NINF

#define YYPACT_NINF   -23

Definition at line 669 of file wql.tab.c.

◆ yypact_value_is_default

#define yypact_value_is_default (   Yystate)    (!!((Yystate) == (-23)))

Definition at line 671 of file wql.tab.c.

◆ yyparse

#define yyparse   wql_parse

Definition at line 63 of file wql.tab.c.

◆ YYPOPSTACK

#define YYPOPSTACK (   N)    (yyvsp -= (N), yyssp -= (N))

◆ YYPULL

#define YYPULL   1

Definition at line 59 of file wql.tab.c.

◆ YYPURE

#define YYPURE   1

Definition at line 53 of file wql.tab.c.

◆ YYPUSH

#define YYPUSH   0

Definition at line 56 of file wql.tab.c.

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 794 of file wql.tab.c.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 396 of file wql.tab.c.

◆ YYSIZE_T

#define YYSIZE_T   size_t

Definition at line 390 of file wql.tab.c.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

Definition at line 50 of file wql.tab.c.

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 484 of file wql.tab.c.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 487 of file wql.tab.c.

◆ YYSTACK_BYTES

#define YYSTACK_BYTES (   N)
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
short yytype_int16
union YYSTYPE YYSTYPE
Definition: wql.tab.c:327
#define YYSTACK_GAP_MAXIMUM
Definition: wql.tab.c:525

Definition at line 529 of file wql.tab.c.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 485 of file wql.tab.c.

◆ YYSTACK_GAP_MAXIMUM

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)

Definition at line 525 of file wql.tab.c.

◆ YYSTACK_RELOCATE

#define YYSTACK_RELOCATE (   Stack_alloc,
  Stack 
)
Value:
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
#define YYSTACK_GAP_MAXIMUM
Definition: wql.tab.c:525

Definition at line 540 of file wql.tab.c.

◆ YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

Definition at line 342 of file wql.tab.c.

◆ YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 341 of file wql.tab.c.

◆ YYSYNTAX_ERROR

#define YYSYNTAX_ERROR
Value:
yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: wql.tab.c:1062

◆ YYTABLE_NINF

#define YYTABLE_NINF   -1

Definition at line 674 of file wql.tab.c.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

Definition at line 676 of file wql.tab.c.

◆ YYTERROR

#define YYTERROR   1

Definition at line 814 of file wql.tab.c.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 290 of file wql.tab.c.

◆ YYTRANSLATE

#define YYTRANSLATE (   YYX)    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Definition at line 592 of file wql.tab.c.

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 589 of file wql.tab.c.

◆ YYUSE

#define YYUSE (   E)    ((void) (E))

Definition at line 420 of file wql.tab.c.

Typedef Documentation

◆ YYSTYPE

typedef union YYSTYPE YYSTYPE

Definition at line 327 of file wql.tab.c.

◆ yytype_int16

Definition at line 380 of file wql.tab.c.

◆ yytype_int8

Definition at line 368 of file wql.tab.c.

◆ yytype_uint16

typedef unsigned short int yytype_uint16

Definition at line 374 of file wql.tab.c.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 362 of file wql.tab.c.

Enumeration Type Documentation

◆ yytokentype

Enumerator
INSTR_ADD 
INSTR_NOP 
INSTR_MOV 
INSTR_SUB 
INSTR_MAD 
INSTR_MUL 
INSTR_RCP 
INSTR_RSQ 
INSTR_DP3 
INSTR_DP4 
INSTR_MIN 
INSTR_MAX 
INSTR_SLT 
INSTR_SGE 
INSTR_ABS 
INSTR_EXP 
INSTR_LOG 
INSTR_EXPP 
INSTR_LOGP 
INSTR_DST 
INSTR_LRP 
INSTR_FRC 
INSTR_POW 
INSTR_CRS 
INSTR_SGN 
INSTR_NRM 
INSTR_SINCOS 
INSTR_M4x4 
INSTR_M4x3 
INSTR_M3x4 
INSTR_M3x3 
INSTR_M3x2 
INSTR_DCL 
INSTR_DEF 
INSTR_DEFB 
INSTR_DEFI 
INSTR_REP 
INSTR_ENDREP 
INSTR_IF 
INSTR_ELSE 
INSTR_ENDIF 
INSTR_BREAK 
INSTR_BREAKP 
INSTR_CALL 
INSTR_CALLNZ 
INSTR_LOOP 
INSTR_RET 
INSTR_ENDLOOP 
INSTR_LABEL 
INSTR_SETP 
INSTR_TEXLDL 
INSTR_LIT 
INSTR_MOVA 
INSTR_CND 
INSTR_CMP 
INSTR_DP2ADD 
INSTR_TEXCOORD 
INSTR_TEXCRD 
INSTR_TEXKILL 
INSTR_TEX 
INSTR_TEXLD 
INSTR_TEXBEM 
INSTR_TEXBEML 
INSTR_TEXREG2AR 
INSTR_TEXREG2GB 
INSTR_TEXREG2RGB 
INSTR_TEXM3x2PAD 
INSTR_TEXM3x2TEX 
INSTR_TEXM3x3PAD 
INSTR_TEXM3x3SPEC 
INSTR_TEXM3x3VSPEC 
INSTR_TEXM3x3TEX 
INSTR_TEXDP3TEX 
INSTR_TEXM3x2DEPTH 
INSTR_TEXDP3 
INSTR_TEXM3x3 
INSTR_TEXDEPTH 
INSTR_BEM 
INSTR_DSX 
INSTR_DSY 
INSTR_TEXLDP 
INSTR_TEXLDB 
INSTR_TEXLDD 
INSTR_PHASE 
REG_TEMP 
REG_OUTPUT 
REG_INPUT 
REG_CONSTFLOAT 
REG_CONSTINT 
REG_CONSTBOOL 
REG_TEXTURE 
REG_SAMPLER 
REG_TEXCRDOUT 
REG_OPOS 
REG_OFOG 
REG_OPTS 
REG_VERTEXCOLOR 
REG_FRAGCOLOR 
REG_FRAGDEPTH 
REG_VPOS 
REG_VFACE 
REG_ADDRESS 
REG_LOOP 
REG_PREDICATE 
REG_LABEL 
VER_VS10 
VER_VS11 
VER_VS20 
VER_VS2X 
VER_VS30 
VER_PS10 
VER_PS11 
VER_PS12 
VER_PS13 
VER_PS14 
VER_PS20 
VER_PS2X 
VER_PS30 
SHIFT_X2 
SHIFT_X4 
SHIFT_X8 
SHIFT_D2 
SHIFT_D4 
SHIFT_D8 
MOD_SAT 
MOD_PP 
MOD_CENTROID 
COMP_GT 
COMP_LT 
COMP_GE 
COMP_LE 
COMP_EQ 
COMP_NE 
SMOD_BIAS 
SMOD_SCALEBIAS 
SMOD_DZ 
SMOD_DW 
SMOD_ABS 
SMOD_NOT 
SAMPTYPE_1D 
SAMPTYPE_2D 
SAMPTYPE_CUBE 
SAMPTYPE_VOLUME 
USAGE_POSITION 
USAGE_BLENDWEIGHT 
USAGE_BLENDINDICES 
USAGE_NORMAL 
USAGE_PSIZE 
USAGE_TEXCOORD 
USAGE_TANGENT 
USAGE_BINORMAL 
USAGE_TESSFACTOR 
USAGE_POSITIONT 
USAGE_COLOR 
USAGE_FOG 
USAGE_DEPTH 
USAGE_SAMPLE 
COMPONENT 
IMMVAL 
IMMBOOL 
INSTR_ADD 
INSTR_NOP 
INSTR_MOV 
INSTR_SUB 
INSTR_MAD 
INSTR_MUL 
INSTR_RCP 
INSTR_RSQ 
INSTR_DP3 
INSTR_DP4 
INSTR_MIN 
INSTR_MAX 
INSTR_SLT 
INSTR_SGE 
INSTR_ABS 
INSTR_EXP 
INSTR_LOG 
INSTR_EXPP 
INSTR_LOGP 
INSTR_DST 
INSTR_LRP 
INSTR_FRC 
INSTR_POW 
INSTR_CRS 
INSTR_SGN 
INSTR_NRM 
INSTR_SINCOS 
INSTR_M4x4 
INSTR_M4x3 
INSTR_M3x4 
INSTR_M3x3 
INSTR_M3x2 
INSTR_DCL 
INSTR_DEF 
INSTR_DEFB 
INSTR_DEFI 
INSTR_REP 
INSTR_ENDREP 
INSTR_IF 
INSTR_ELSE 
INSTR_ENDIF 
INSTR_BREAK 
INSTR_BREAKP 
INSTR_CALL 
INSTR_CALLNZ 
INSTR_LOOP 
INSTR_RET 
INSTR_ENDLOOP 
INSTR_LABEL 
INSTR_SETP 
INSTR_TEXLDL 
INSTR_LIT 
INSTR_MOVA 
INSTR_CND 
INSTR_CMP 
INSTR_DP2ADD 
INSTR_TEXCOORD 
INSTR_TEXCRD 
INSTR_TEXKILL 
INSTR_TEX 
INSTR_TEXLD 
INSTR_TEXBEM 
INSTR_TEXBEML 
INSTR_TEXREG2AR 
INSTR_TEXREG2GB 
INSTR_TEXREG2RGB 
INSTR_TEXM3x2PAD 
INSTR_TEXM3x2TEX 
INSTR_TEXM3x3PAD 
INSTR_TEXM3x3SPEC 
INSTR_TEXM3x3VSPEC 
INSTR_TEXM3x3TEX 
INSTR_TEXDP3TEX 
INSTR_TEXM3x2DEPTH 
INSTR_TEXDP3 
INSTR_TEXM3x3 
INSTR_TEXDEPTH 
INSTR_BEM 
INSTR_DSX 
INSTR_DSY 
INSTR_TEXLDP 
INSTR_TEXLDB 
INSTR_TEXLDD 
INSTR_PHASE 
REG_TEMP 
REG_OUTPUT 
REG_INPUT 
REG_CONSTFLOAT 
REG_CONSTINT 
REG_CONSTBOOL 
REG_TEXTURE 
REG_SAMPLER 
REG_TEXCRDOUT 
REG_OPOS 
REG_OFOG 
REG_OPTS 
REG_VERTEXCOLOR 
REG_FRAGCOLOR 
REG_FRAGDEPTH 
REG_VPOS 
REG_VFACE 
REG_ADDRESS 
REG_LOOP 
REG_PREDICATE 
REG_LABEL 
VER_VS10 
VER_VS11 
VER_VS20 
VER_VS2X 
VER_VS30 
VER_PS10 
VER_PS11 
VER_PS12 
VER_PS13 
VER_PS14 
VER_PS20 
VER_PS2X 
VER_PS30 
SHIFT_X2 
SHIFT_X4 
SHIFT_X8 
SHIFT_D2 
SHIFT_D4 
SHIFT_D8 
MOD_SAT 
MOD_PP 
MOD_CENTROID 
COMP_GT 
COMP_LT 
COMP_GE 
COMP_LE 
COMP_EQ 
COMP_NE 
SMOD_BIAS 
SMOD_SCALEBIAS 
SMOD_DZ 
SMOD_DW 
SMOD_ABS 
SMOD_NOT 
SAMPTYPE_1D 
SAMPTYPE_2D 
SAMPTYPE_CUBE 
SAMPTYPE_VOLUME 
USAGE_POSITION 
USAGE_BLENDWEIGHT 
USAGE_BLENDINDICES 
USAGE_NORMAL 
USAGE_PSIZE 
USAGE_TEXCOORD 
USAGE_TANGENT 
USAGE_BINORMAL 
USAGE_TESSFACTOR 
USAGE_POSITIONT 
USAGE_COLOR 
USAGE_FOG 
USAGE_DEPTH 
USAGE_SAMPLE 
COMPONENT 
IMMVAL 
IMMBOOL 
KW_BLENDSTATE 
KW_BREAK 
KW_BUFFER 
KW_CBUFFER 
KW_COLUMN_MAJOR 
KW_COMPILE 
KW_CONST 
KW_CONTINUE 
KW_DEPTHSTENCILSTATE 
KW_DEPTHSTENCILVIEW 
KW_DISCARD 
KW_DO 
KW_DOUBLE 
KW_ELSE 
KW_EXTERN 
KW_FALSE 
KW_FOR 
KW_GEOMETRYSHADER 
KW_GROUPSHARED 
KW_IF 
KW_IN 
KW_INLINE 
KW_INOUT 
KW_MATRIX 
KW_NAMESPACE 
KW_NOINTERPOLATION 
KW_OUT 
KW_PASS 
KW_PIXELSHADER 
KW_PRECISE 
KW_RASTERIZERSTATE 
KW_RENDERTARGETVIEW 
KW_RETURN 
KW_REGISTER 
KW_ROW_MAJOR 
KW_SAMPLER 
KW_SAMPLER1D 
KW_SAMPLER2D 
KW_SAMPLER3D 
KW_SAMPLERCUBE 
KW_SAMPLER_STATE 
KW_SAMPLERCOMPARISONSTATE 
KW_SHARED 
KW_STATEBLOCK 
KW_STATEBLOCK_STATE 
KW_STATIC 
KW_STRING 
KW_STRUCT 
KW_SWITCH 
KW_TBUFFER 
KW_TECHNIQUE 
KW_TECHNIQUE10 
KW_TEXTURE 
KW_TEXTURE1D 
KW_TEXTURE1DARRAY 
KW_TEXTURE2D 
KW_TEXTURE2DARRAY 
KW_TEXTURE2DMS 
KW_TEXTURE2DMSARRAY 
KW_TEXTURE3D 
KW_TEXTURE3DARRAY 
KW_TEXTURECUBE 
KW_TRUE 
KW_TYPEDEF 
KW_UNIFORM 
KW_VECTOR 
KW_VERTEXSHADER 
KW_VOID 
KW_VOLATILE 
KW_WHILE 
OP_INC 
OP_DEC 
OP_AND 
OP_OR 
OP_EQ 
OP_LEFTSHIFT 
OP_LEFTSHIFTASSIGN 
OP_RIGHTSHIFT 
OP_RIGHTSHIFTASSIGN 
OP_ELLIPSIS 
OP_LE 
OP_GE 
OP_NE 
OP_ADDASSIGN 
OP_SUBASSIGN 
OP_MULASSIGN 
OP_DIVASSIGN 
OP_MODASSIGN 
OP_ANDASSIGN 
OP_ORASSIGN 
OP_XORASSIGN 
OP_UNKNOWN1 
OP_UNKNOWN2 
OP_UNKNOWN3 
OP_UNKNOWN4 
PRE_LINE 
VAR_IDENTIFIER 
TYPE_IDENTIFIER 
NEW_IDENTIFIER 
STRING 
C_FLOAT 
C_INTEGER 
KW_BLENDSTATE 
KW_BREAK 
KW_BUFFER 
KW_CBUFFER 
KW_COLUMN_MAJOR 
KW_COMPILE 
KW_CONST 
KW_CONTINUE 
KW_DEPTHSTENCILSTATE 
KW_DEPTHSTENCILVIEW 
KW_DISCARD 
KW_DO 
KW_DOUBLE 
KW_ELSE 
KW_EXTERN 
KW_FALSE 
KW_FOR 
KW_GEOMETRYSHADER 
KW_GROUPSHARED 
KW_IF 
KW_IN 
KW_INLINE 
KW_INOUT 
KW_MATRIX 
KW_NAMESPACE 
KW_NOINTERPOLATION 
KW_OUT 
KW_PASS 
KW_PIXELSHADER 
KW_PRECISE 
KW_RASTERIZERSTATE 
KW_RENDERTARGETVIEW 
KW_RETURN 
KW_REGISTER 
KW_ROW_MAJOR 
KW_SAMPLER 
KW_SAMPLER1D 
KW_SAMPLER2D 
KW_SAMPLER3D 
KW_SAMPLERCUBE 
KW_SAMPLER_STATE 
KW_SAMPLERCOMPARISONSTATE 
KW_SHARED 
KW_STATEBLOCK 
KW_STATEBLOCK_STATE 
KW_STATIC 
KW_STRING 
KW_STRUCT 
KW_SWITCH 
KW_TBUFFER 
KW_TECHNIQUE 
KW_TECHNIQUE10 
KW_TEXTURE 
KW_TEXTURE1D 
KW_TEXTURE1DARRAY 
KW_TEXTURE2D 
KW_TEXTURE2DARRAY 
KW_TEXTURE2DMS 
KW_TEXTURE2DMSARRAY 
KW_TEXTURE3D 
KW_TEXTURE3DARRAY 
KW_TEXTURECUBE 
KW_TRUE 
KW_TYPEDEF 
KW_UNIFORM 
KW_VECTOR 
KW_VERTEXSHADER 
KW_VOID 
KW_VOLATILE 
KW_WHILE 
OP_INC 
OP_DEC 
OP_AND 
OP_OR 
OP_EQ 
OP_LEFTSHIFT 
OP_LEFTSHIFTASSIGN 
OP_RIGHTSHIFT 
OP_RIGHTSHIFTASSIGN 
OP_ELLIPSIS 
OP_LE 
OP_GE 
OP_NE 
OP_ADDASSIGN 
OP_SUBASSIGN 
OP_MULASSIGN 
OP_DIVASSIGN 
OP_MODASSIGN 
OP_ANDASSIGN 
OP_ORASSIGN 
OP_XORASSIGN 
OP_UNKNOWN1 
OP_UNKNOWN2 
OP_UNKNOWN3 
OP_UNKNOWN4 
PRE_LINE 
VAR_IDENTIFIER 
TYPE_IDENTIFIER 
NEW_IDENTIFIER 
STRING 
C_FLOAT 
C_INTEGER 
tRCINCLUDE 
tIF 
tIFDEF 
tIFNDEF 
tELSE 
tELIF 
tENDIF 
tDEFINED 
tNL 
tINCLUDE 
tLINE 
tGCCLINE 
tERROR 
tWARNING 
tPRAGMA 
tPPIDENT 
tUNDEF 
tMACROEND 
tCONCAT 
tELIPSIS 
tSTRINGIZE 
tIDENT 
tLITERAL 
tMACRO 
tDEFINE 
tDQSTRING 
tSQSTRING 
tIQSTRING 
tUINT 
tSINT 
tULONG 
tSLONG 
tULONGLONG 
tSLONGLONG 
tRCINCLUDEPATH 
tLOGOR 
tLOGAND 
tEQ 
tNE 
tLTE 
tGTE 
tLSHIFT 
tRSHIFT 
tRCINCLUDE 
tIF 
tIFDEF 
tIFNDEF 
tELSE 
tELIF 
tENDIF 
tDEFINED 
tNL 
tINCLUDE 
tLINE 
tGCCLINE 
tERROR 
tWARNING 
tPRAGMA 
tPPIDENT 
tUNDEF 
tMACROEND 
tCONCAT 
tELIPSIS 
tSTRINGIZE 
tIDENT 
tLITERAL 
tMACRO 
tDEFINE 
tDQSTRING 
tSQSTRING 
tIQSTRING 
tUINT 
tSINT 
tULONG 
tSLONG 
tULONGLONG 
tSLONGLONG 
tRCINCLUDEPATH 
tLOGOR 
tLOGAND 
tEQ 
tNE 
tLTE 
tGTE 
tLSHIFT 
tRSHIFT 
tEQ 
tEQEQ 
tNEQ 
tNEQEQ 
tLSHIFT 
tRSHIFT 
tRRSHIFT 
tOR 
tAND 
tLEQ 
tGEQ 
tCCValue 
tEQ 
tEQEQ 
tNEQ 
tNEQEQ 
tLSHIFT 
tRSHIFT 
tRRSHIFT 
tOR 
tAND 
tLEQ 
tGEQ 
tCCValue 
kBREAK 
kCASE 
kCATCH 
kCONTINUE 
kDEFAULT 
kDELETE 
kDO 
kELSE 
kFUNCTION 
kIF 
kFINALLY 
kFOR 
kGET 
kIN 
kSET 
kINSTANCEOF 
kNEW 
kNULL 
kRETURN 
kSWITCH 
kTHIS 
kTHROW 
kTRUE 
kFALSE 
kTRY 
kTYPEOF 
kVAR 
kVOID 
kWHILE 
kWITH 
tANDAND 
tOROR 
tINC 
tDEC 
tHTMLCOMMENT 
kDIVEQ 
kDCOL 
tIdentifier 
tAssignOper 
tEqOper 
tShiftOper 
tRelOper 
tNumericLiteral 
tBooleanLiteral 
tStringLiteral 
tEOF 
LOWER_THAN_ELSE 
kBREAK 
kCASE 
kCATCH 
kCONTINUE 
kDEFAULT 
kDELETE 
kDO 
kELSE 
kFUNCTION 
kIF 
kFINALLY 
kFOR 
kGET 
kIN 
kSET 
kINSTANCEOF 
kNEW 
kNULL 
kRETURN 
kSWITCH 
kTHIS 
kTHROW 
kTRUE 
kFALSE 
kTRY 
kTYPEOF 
kVAR 
kVOID 
kWHILE 
kWITH 
tANDAND 
tOROR 
tINC 
tDEC 
tHTMLCOMMENT 
kDIVEQ 
kDCOL 
tIdentifier 
tAssignOper 
tEqOper 
tShiftOper 
tRelOper 
tNumericLiteral 
tBooleanLiteral 
tStringLiteral 
tEOF 
LOWER_THAN_ELSE 
COND_SPACE 
COND_EOF 
COND_OR 
COND_AND 
COND_NOT 
COND_XOR 
COND_IMP 
COND_EQV 
COND_LT 
COND_GT 
COND_EQ 
COND_NE 
COND_GE 
COND_LE 
COND_ILT 
COND_IGT 
COND_IEQ 
COND_INE 
COND_IGE 
COND_ILE 
COND_LPAR 
COND_RPAR 
COND_TILDA 
COND_SS 
COND_ISS 
COND_ILHS 
COND_IRHS 
COND_LHS 
COND_RHS 
COND_PERCENT 
COND_DOLLARS 
COND_QUESTION 
COND_AMPER 
COND_EXCLAM 
COND_IDENT 
COND_NUMBER 
COND_LITER 
COND_ERROR 
TK_ALTER 
TK_AND 
TK_BY 
TK_CHAR 
TK_COMMA 
TK_CREATE 
TK_DELETE 
TK_DROP 
TK_DISTINCT 
TK_DOT 
TK_EQ 
TK_FREE 
TK_FROM 
TK_GE 
TK_GT 
TK_HOLD 
TK_ADD 
TK_ID 
TK_ILLEGAL 
TK_INSERT 
TK_INT 
TK_INTEGER 
TK_INTO 
TK_IS 
TK_KEY 
TK_LE 
TK_LONG 
TK_LONGCHAR 
TK_LP 
TK_LT 
TK_LOCALIZABLE 
TK_MINUS 
TK_NE 
TK_NOT 
TK_NULL 
TK_OBJECT 
TK_OR 
TK_ORDER 
TK_PRIMARY 
TK_RP 
TK_SELECT 
TK_SET 
TK_SHORT 
TK_SPACE 
TK_STAR 
TK_STRING 
TK_TABLE 
TK_TEMPORARY 
TK_UPDATE 
TK_VALUES 
TK_WHERE 
TK_WILDCARD 
END_OF_FILE 
ILLEGAL 
SPACE 
UNCLOSED_STRING 
COMMENT 
FUNCTION 
COLUMN 
TK_LIKE 
TK_NEGATION 
TK_ALTER 
TK_AND 
TK_BY 
TK_CHAR 
TK_COMMA 
TK_CREATE 
TK_DELETE 
TK_DROP 
TK_DISTINCT 
TK_DOT 
TK_EQ 
TK_FREE 
TK_FROM 
TK_GE 
TK_GT 
TK_HOLD 
TK_ADD 
TK_ID 
TK_ILLEGAL 
TK_INSERT 
TK_INT 
TK_INTEGER 
TK_INTO 
TK_IS 
TK_KEY 
TK_LE 
TK_LONG 
TK_LONGCHAR 
TK_LP 
TK_LT 
TK_LOCALIZABLE 
TK_MINUS 
TK_NE 
TK_NOT 
TK_NULL 
TK_OBJECT 
TK_OR 
TK_ORDER 
TK_PRIMARY 
TK_RP 
TK_SELECT 
TK_SET 
TK_SHORT 
TK_SPACE 
TK_STAR 
TK_STRING 
TK_TABLE 
TK_TEMPORARY 
TK_UPDATE 
TK_VALUES 
TK_WHERE 
TK_WILDCARD 
END_OF_FILE 
ILLEGAL 
SPACE 
UNCLOSED_STRING 
COMMENT 
FUNCTION 
COLUMN 
TK_LIKE 
TK_NEGATION 
TOK_Parent 
TOK_Self 
TOK_DblFSlash 
TOK_FSlash 
TOK_Axis 
TOK_Colon 
TOK_OpAnd 
TOK_OpOr 
TOK_OpNot 
TOK_OpEq 
TOK_OpIEq 
TOK_OpNEq 
TOK_OpINEq 
TOK_OpLt 
TOK_OpILt 
TOK_OpGt 
TOK_OpIGt 
TOK_OpLEq 
TOK_OpILEq 
TOK_OpGEq 
TOK_OpIGEq 
TOK_OpAll 
TOK_OpAny 
TOK_NCName 
TOK_Literal 
TOK_Number 
tEOF 
tNL 
tREM 
tEMPTYBRACKETS 
tTRUE 
tFALSE 
tNOT 
tAND 
tOR 
tXOR 
tEQV 
tIMP 
tNEQ 
tIS 
tLTEQ 
tGTEQ 
tMOD 
tCALL 
tDIM 
tSUB 
tFUNCTION 
tPROPERTY 
tGET 
tLET 
tCONST 
tIF 
tELSE 
tELSEIF 
tEND 
tTHEN 
tEXIT 
tWHILE 
tWEND 
tDO 
tLOOP 
tUNTIL 
tFOR 
tTO 
tSTEP 
tEACH 
tIN 
tSELECT 
tCASE 
tBYREF 
tBYVAL 
tOPTION 
tEXPLICIT 
tSTOP 
tNOTHING 
tEMPTY 
tNULL 
tCLASS 
tSET 
tNEW 
tPUBLIC 
tPRIVATE 
tDEFAULT 
tME 
tERROR 
tNEXT 
tON 
tRESUME 
tGOTO 
tIdentifier 
tString 
tLong 
tShort 
tDouble 
tEOF 
tNL 
tREM 
tEMPTYBRACKETS 
tTRUE 
tFALSE 
tNOT 
tAND 
tOR 
tXOR 
tEQV 
tIMP 
tNEQ 
tIS 
tLTEQ 
tGTEQ 
tMOD 
tCALL 
tDIM 
tSUB 
tFUNCTION 
tPROPERTY 
tGET 
tLET 
tCONST 
tIF 
tELSE 
tELSEIF 
tEND 
tTHEN 
tEXIT 
tWHILE 
tWEND 
tDO 
tLOOP 
tUNTIL 
tFOR 
tTO 
tSTEP 
tEACH 
tIN 
tSELECT 
tCASE 
tBYREF 
tBYVAL 
tOPTION 
tEXPLICIT 
tSTOP 
tNOTHING 
tEMPTY 
tNULL 
tCLASS 
tSET 
tNEW 
tPUBLIC 
tPRIVATE 
tDEFAULT 
tME 
tERROR 
tNEXT 
tON 
tRESUME 
tGOTO 
tIdentifier 
tString 
tLong 
tShort 
tDouble 
TK_SELECT 
TK_FROM 
TK_STAR 
TK_COMMA 
TK_DOT 
TK_IS 
TK_LP 
TK_RP 
TK_NULL 
TK_FALSE 
TK_TRUE 
TK_INTEGER 
TK_WHERE 
TK_SPACE 
TK_MINUS 
TK_ILLEGAL 
TK_BY 
TK_STRING 
TK_ID 
TK_OR 
TK_AND 
TK_NOT 
TK_EQ 
TK_NE 
TK_LT 
TK_GT 
TK_LE 
TK_GE 
TK_LIKE 
TK_SELECT 
TK_FROM 
TK_STAR 
TK_COMMA 
TK_DOT 
TK_IS 
TK_LP 
TK_RP 
TK_NULL 
TK_FALSE 
TK_TRUE 
TK_INTEGER 
TK_WHERE 
TK_SPACE 
TK_MINUS 
TK_ILLEGAL 
TK_BY 
TK_STRING 
TK_ID 
TK_OR 
TK_AND 
TK_NOT 
TK_EQ 
TK_NE 
TK_LT 
TK_GT 
TK_LE 
TK_GE 
TK_LIKE 
aIDENTIFIER 
aPRAGMA 
aKNOWNTYPE 
aNUM 
aHEXNUM 
aDOUBLE 
aSTRING 
aWSTRING 
aSQSTRING 
aUUID 
aEOF 
aACF 
SHL 
SHR 
MEMBERPTR 
EQUALITY 
INEQUALITY 
GREATEREQUAL 
LESSEQUAL 
LOGICALOR 
LOGICALAND 
ELLIPSIS 
tAGGREGATABLE 
tALLOCATE 
tANNOTATION 
tAPPOBJECT 
tASYNC 
tASYNCUUID 
tAUTOHANDLE 
tBINDABLE 
tBOOLEAN 
tBROADCAST 
tBYTE 
tBYTECOUNT 
tCALLAS 
tCALLBACK 
tCASE 
tCDECL 
tCHAR 
tCOCLASS 
tCODE 
tCOMMSTATUS 
tCONST 
tCONTEXTHANDLE 
tCONTEXTHANDLENOSERIALIZE 
tCONTEXTHANDLESERIALIZE 
tCONTROL 
tCPPQUOTE 
tDECODE 
tDEFAULT 
tDEFAULTBIND 
tDEFAULTCOLLELEM 
tDEFAULTVALUE 
tDEFAULTVTABLE 
tDISABLECONSISTENCYCHECK 
tDISPLAYBIND 
tDISPINTERFACE 
tDLLNAME 
tDOUBLE 
tDUAL 
tENABLEALLOCATE 
tENCODE 
tENDPOINT 
tENTRY 
tENUM 
tERRORSTATUST 
tEXPLICITHANDLE 
tEXTERN 
tFALSE 
tFASTCALL 
tFAULTSTATUS 
tFLOAT 
tFORCEALLOCATE 
tHANDLE 
tHANDLET 
tHELPCONTEXT 
tHELPFILE 
tHELPSTRING 
tHELPSTRINGCONTEXT 
tHELPSTRINGDLL 
tHIDDEN 
tHYPER 
tID 
tIDEMPOTENT 
tIGNORE 
tIIDIS 
tIMMEDIATEBIND 
tIMPLICITHANDLE 
tIMPORT 
tIMPORTLIB 
tIN 
tIN_LINE 
tINLINE 
tINPUTSYNC 
tINT 
tINT32 
tINT3264 
tINT64 
tINTERFACE 
tLCID 
tLENGTHIS 
tLIBRARY 
tLICENSED 
tLOCAL 
tLONG 
tMAYBE 
tMESSAGE 
tMETHODS 
tMODULE 
tNAMESPACE 
tNOCODE 
tNONBROWSABLE 
tNONCREATABLE 
tNONEXTENSIBLE 
tNOTIFY 
tNOTIFYFLAG 
tNULL 
tOBJECT 
tODL 
tOLEAUTOMATION 
tOPTIMIZE 
tOPTIONAL 
tOUT 
tPARTIALIGNORE 
tPASCAL 
tPOINTERDEFAULT 
tPRAGMA_WARNING 
tPROGID 
tPROPERTIES 
tPROPGET 
tPROPPUT 
tPROPPUTREF 
tPROXY 
tPTR 
tPUBLIC 
tRANGE 
tREADONLY 
tREF 
tREGISTER 
tREPRESENTAS 
tREQUESTEDIT 
tRESTRICTED 
tRETVAL 
tSAFEARRAY 
tSHORT 
tSIGNED 
tSIZEIS 
tSIZEOF 
tSMALL 
tSOURCE 
tSTATIC 
tSTDCALL 
tSTRICTCONTEXTHANDLE 
tSTRING 
tSTRUCT 
tSWITCH 
tSWITCHIS 
tSWITCHTYPE 
tTHREADING 
tTRANSMITAS 
tTRUE 
tTYPEDEF 
tUIDEFAULT 
tUNION 
tUNIQUE 
tUNSIGNED 
tUSESGETLASTERROR 
tUSERMARSHAL 
tUUID 
tV1ENUM 
tVARARG 
tVERSION 
tVIPROGID 
tVOID 
tWCHAR 
tWIREMARSHAL 
tAPARTMENT 
tNEUTRAL 
tSINGLE 
tFREE 
tBOTH 
CAST 
PPTR 
POS 
NEG 
ADDRESSOF 
aIDENTIFIER 
aPRAGMA 
aKNOWNTYPE 
aNUM 
aHEXNUM 
aDOUBLE 
aSTRING 
aWSTRING 
aSQSTRING 
aUUID 
aEOF 
aACF 
SHL 
SHR 
MEMBERPTR 
EQUALITY 
INEQUALITY 
GREATEREQUAL 
LESSEQUAL 
LOGICALOR 
LOGICALAND 
ELLIPSIS 
tAGGREGATABLE 
tALLOCATE 
tANNOTATION 
tAPPOBJECT 
tASYNC 
tASYNCUUID 
tAUTOHANDLE 
tBINDABLE 
tBOOLEAN 
tBROADCAST 
tBYTE 
tBYTECOUNT 
tCALLAS 
tCALLBACK 
tCASE 
tCDECL 
tCHAR 
tCOCLASS 
tCODE 
tCOMMSTATUS 
tCONST 
tCONTEXTHANDLE 
tCONTEXTHANDLENOSERIALIZE 
tCONTEXTHANDLESERIALIZE 
tCONTROL 
tCPPQUOTE 
tDECODE 
tDEFAULT 
tDEFAULTBIND 
tDEFAULTCOLLELEM 
tDEFAULTVALUE 
tDEFAULTVTABLE 
tDISABLECONSISTENCYCHECK 
tDISPLAYBIND 
tDISPINTERFACE 
tDLLNAME 
tDOUBLE 
tDUAL 
tENABLEALLOCATE 
tENCODE 
tENDPOINT 
tENTRY 
tENUM 
tERRORSTATUST 
tEXPLICITHANDLE 
tEXTERN 
tFALSE 
tFASTCALL 
tFAULTSTATUS 
tFLOAT 
tFORCEALLOCATE 
tHANDLE 
tHANDLET 
tHELPCONTEXT 
tHELPFILE 
tHELPSTRING 
tHELPSTRINGCONTEXT 
tHELPSTRINGDLL 
tHIDDEN 
tHYPER 
tID 
tIDEMPOTENT 
tIGNORE 
tIIDIS 
tIMMEDIATEBIND 
tIMPLICITHANDLE 
tIMPORT 
tIMPORTLIB 
tIN 
tIN_LINE 
tINLINE 
tINPUTSYNC 
tINT 
tINT32 
tINT3264 
tINT64 
tINTERFACE 
tLCID 
tLENGTHIS 
tLIBRARY 
tLICENSED 
tLOCAL 
tLONG 
tMAYBE 
tMESSAGE 
tMETHODS 
tMODULE 
tNAMESPACE 
tNOCODE 
tNONBROWSABLE 
tNONCREATABLE 
tNONEXTENSIBLE 
tNOTIFY 
tNOTIFYFLAG 
tNULL 
tOBJECT 
tODL 
tOLEAUTOMATION 
tOPTIMIZE 
tOPTIONAL 
tOUT 
tPARTIALIGNORE 
tPASCAL 
tPOINTERDEFAULT 
tPRAGMA_WARNING 
tPROGID 
tPROPERTIES 
tPROPGET 
tPROPPUT 
tPROPPUTREF 
tPROXY 
tPTR 
tPUBLIC 
tRANGE 
tREADONLY 
tREF 
tREGISTER 
tREPRESENTAS 
tREQUESTEDIT 
tRESTRICTED 
tRETVAL 
tSAFEARRAY 
tSHORT 
tSIGNED 
tSIZEIS 
tSIZEOF 
tSMALL 
tSOURCE 
tSTATIC 
tSTDCALL 
tSTRICTCONTEXTHANDLE 
tSTRING 
tSTRUCT 
tSWITCH 
tSWITCHIS 
tSWITCHTYPE 
tTHREADING 
tTRANSMITAS 
tTRUE 
tTYPEDEF 
tUIDEFAULT 
tUNION 
tUNIQUE 
tUNSIGNED 
tUSESGETLASTERROR 
tUSERMARSHAL 
tUUID 
tV1ENUM 
tVARARG 
tVERSION 
tVIPROGID 
tVOID 
tWCHAR 
tWIREMARSHAL 
tAPARTMENT 
tNEUTRAL 
tSINGLE 
tFREE 
tBOTH 
CAST 
PPTR 
POS 
NEG 
ADDRESSOF 
tRCINCLUDE 
tIF 
tIFDEF 
tIFNDEF 
tELSE 
tELIF 
tENDIF 
tDEFINED 
tNL 
tINCLUDE 
tLINE 
tGCCLINE 
tERROR 
tWARNING 
tPRAGMA 
tPPIDENT 
tUNDEF 
tMACROEND 
tCONCAT 
tELIPSIS 
tSTRINGIZE 
tIDENT 
tLITERAL 
tMACRO 
tDEFINE 
tDQSTRING 
tSQSTRING 
tIQSTRING 
tUINT 
tSINT 
tULONG 
tSLONG 
tULONGLONG 
tSLONGLONG 
tRCINCLUDEPATH 
tLOGOR 
tLOGAND 
tEQ 
tNE 
tLTE 
tGTE 
tLSHIFT 
tRSHIFT 
tRCINCLUDE 
tIF 
tIFDEF 
tIFNDEF 
tELSE 
tELIF 
tENDIF 
tDEFINED 
tNL 
tINCLUDE 
tLINE 
tGCCLINE 
tERROR 
tWARNING 
tPRAGMA 
tPPIDENT 
tUNDEF 
tMACROEND 
tCONCAT 
tELIPSIS 
tSTRINGIZE 
tIDENT 
tLITERAL 
tMACRO 
tDEFINE 
tDQSTRING 
tSQSTRING 
tIQSTRING 
tUINT 
tSINT 
tULONG 
tSLONG 
tULONGLONG 
tSLONGLONG 
tRCINCLUDEPATH 
tLOGOR 
tLOGAND 
tEQ 
tNE 
tLTE 
tGTE 
tLSHIFT 
tRSHIFT 

Definition at line 291 of file wql.tab.c.

292  {
293  TK_SELECT = 258,
294  TK_FROM = 259,
295  TK_STAR = 260,
296  TK_COMMA = 261,
297  TK_DOT = 262,
298  TK_IS = 263,
299  TK_LP = 264,
300  TK_RP = 265,
301  TK_NULL = 266,
302  TK_FALSE = 267,
303  TK_TRUE = 268,
304  TK_INTEGER = 269,
305  TK_WHERE = 270,
306  TK_SPACE = 271,
307  TK_MINUS = 272,
308  TK_ILLEGAL = 273,
309  TK_BY = 274,
310  TK_STRING = 275,
311  TK_ID = 276,
312  TK_OR = 277,
313  TK_AND = 278,
314  TK_NOT = 279,
315  TK_EQ = 280,
316  TK_NE = 281,
317  TK_LT = 282,
318  TK_GT = 283,
319  TK_LE = 284,
320  TK_GE = 285,
321  TK_LIKE = 286
322  };
Definition: wql.tab.c:317
Definition: wql.tab.c:300
Definition: wql.tab.c:318
Definition: wql.tab.c:319
Definition: wql.tab.c:315
Definition: wql.tab.c:309
Definition: wql.tab.c:311
Definition: wql.tab.c:312
Definition: wql.tab.c:299
Definition: wql.tab.c:298
Definition: wql.tab.c:316
Definition: wql.tab.c:320

Function Documentation

◆ alloc_mem()

static void* alloc_mem ( struct parser parser,
UINT  size 
)
static

Definition at line 122 of file wql.tab.c.

123 {
124  struct list *mem = heap_alloc( sizeof(struct list) + size );
126  return &mem[1];
127 }
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
struct list * mem
Definition: wql.tab.c:113
GLsizeiptr size
Definition: glext.h:5919
Definition: _list.h:228
Definition: import.c:86
Definition: mem.c:156

Referenced by alloc_property(), expr_bval(), expr_complex(), expr_ival(), expr_propval(), expr_sval(), expr_unary(), and get_string().

◆ alloc_property()

static struct property* alloc_property ( struct parser parser,
const WCHAR class,
const WCHAR name 
)
static

Definition at line 129 of file wql.tab.c.

130 {
131  struct property *prop = alloc_mem( parser, sizeof(*prop) );
132  if (prop)
133  {
134  prop->name = name;
135  prop->class = class;
136  prop->next = NULL;
137  }
138  return prop;
139 }
const struct property * next
smooth NULL
Definition: ftsmooth.c:416
BSTR name
Definition: locator.c:109
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86
const WCHAR * class
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ cmp_keyword()

static int cmp_keyword ( const void arg1,
const void arg2 
)
static

Definition at line 2172 of file wql.tab.c.

2173 {
2174  const struct keyword *key1 = arg1, *key2 = arg2;
2175  int len = min( key1->len, key2->len );
2176  int ret;
2177 
2178  if ((ret = memicmpW( key1->name, key2->name, len ))) return ret;
2179  if (key1->len < key2->len) return -1;
2180  else if (key1->len > key2->len) return 1;
2181  return 0;
2182 }
GLuint64EXT GLuint GLuint GLenum GLenum GLuint GLuint GLenum GLuint GLuint key1
Definition: glext.h:10608
GLuint GLuint GLuint GLuint GLuint GLuint GLuint arg2
Definition: glext.h:9514
GLuint GLuint GLuint GLuint arg1
Definition: glext.h:9513
int ret
GLenum GLsizei len
Definition: glext.h:6722
#define min(a, b)
Definition: monoChain.cc:55
#define memicmpW(s1, s2, n)
Definition: unicode.h:27

Referenced by keyword_type().

◆ expr_bval()

static struct expr* expr_bval ( struct parser parser,
int  val 
)
static

Definition at line 228 of file wql.tab.c.

229 {
230  struct expr *e = alloc_mem( parser, sizeof *e );
231  if (e)
232  {
233  e->type = EXPR_BVAL;
234  e->u.ival = val;
235  }
236  return e;
237 }
Definition: query.h:86
#define e
Definition: ke_i.h:82
GLuint GLfloat * val
Definition: glext.h:7180
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86

Referenced by yyparse().

◆ expr_complex()

static struct expr* expr_complex ( struct parser parser,
struct expr l,
UINT  op,
struct expr r 
)
static

Definition at line 178 of file wql.tab.c.

179 {
180  struct expr *e = alloc_mem( parser, sizeof(*e) );
181  if (e)
182  {
183  e->type = EXPR_COMPLEX;
184  e->u.expr.left = l;
185  e->u.expr.op = op;
186  e->u.expr.right = r;
187  }
188  return e;
189 }
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
Definition: query.h:86
#define e
Definition: ke_i.h:82
r l[0]
Definition: byte_order.h:167
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86
UINT op
Definition: effect.c:223

Referenced by yyparse().

◆ expr_ival()

static struct expr* expr_ival ( struct parser parser,
int  val 
)
static

Definition at line 204 of file wql.tab.c.

205 {
206  struct expr *e = alloc_mem( parser, sizeof *e );
207  if (e)
208  {
209  e->type = EXPR_IVAL;
210  e->u.ival = val;
211  }
212  return e;
213 }
Definition: query.h:86
#define e
Definition: ke_i.h:82
GLuint GLfloat * val
Definition: glext.h:7180
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86

Referenced by yyparse().

◆ expr_propval()

static struct expr* expr_propval ( struct parser parser,
const struct property prop 
)
static

Definition at line 239 of file wql.tab.c.

240 {
241  struct expr *e = alloc_mem( parser, sizeof *e );
242  if (e)
243  {
244  e->type = EXPR_PROPVAL;
245  e->u.propval = prop;
246  }
247  return e;
248 }
Definition: query.h:86
#define e
Definition: ke_i.h:82
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86

Referenced by yyparse().

◆ expr_sval()

static struct expr* expr_sval ( struct parser parser,
const struct string str 
)
static

Definition at line 215 of file wql.tab.c.

216 {
217  struct expr *e = alloc_mem( parser, sizeof *e );
218  if (e)
219  {
220  e->type = EXPR_SVAL;
221  e->u.sval = get_string( parser, str );
222  if (!e->u.sval)
223  return NULL; /* e will be freed by query destructor */
224  }
225  return e;
226 }
Definition: query.h:86
#define e
Definition: ke_i.h:82
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
static WCHAR * get_string(struct parser *parser, const struct string *str)
Definition: wql.tab.c:141
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86

Referenced by yyparse().

◆ expr_unary()

static struct expr* expr_unary ( struct parser parser,
struct expr l,
UINT  op 
)
static

Definition at line 191 of file wql.tab.c.

192 {
193  struct expr *e = alloc_mem( parser, sizeof(*e) );
194  if (e)
195  {
196  e->type = EXPR_UNARY;
197  e->u.expr.left = l;
198  e->u.expr.op = op;
199  e->u.expr.right = NULL;
200  }
201  return e;
202 }
Definition: query.h:86
#define e
Definition: ke_i.h:82
smooth NULL
Definition: ftsmooth.c:416
r l[0]
Definition: byte_order.h:167
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86
UINT op
Definition: effect.c:223

Referenced by yyparse().

◆ free()

void free ( void )

Definition at line 147 of file cabinet.c.

148 {
150 }
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
static PVOID ptr
Definition: dispmode.c:27
HANDLE ProcessHeap
Definition: servman.c:15

◆ get_int()

static int get_int ( struct parser parser)
static

Definition at line 161 of file wql.tab.c.

162 {
163  const WCHAR *p = &parser->cmd[parser->idx];
164  int i, ret = 0;
165 
166  for (i = 0; i < parser->len; i++)
167  {
168  if (p[i] < '0' || p[i] > '9')
169  {
170  ERR("should only be numbers here!\n");
171  break;
172  }
173  ret = (p[i] - '0') + ret * 10;
174  }
175  return ret;
176 }
UINT idx
Definition: wql.tab.c:109
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const WCHAR * cmd
Definition: wql.tab.c:108
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
#define ERR(fmt,...)
Definition: debug.h:109
UINT len
Definition: wql.tab.c:110
Definition: import.c:86
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by yyparse().

◆ get_string()

static WCHAR* get_string ( struct parser parser,
const struct string str 
)
static

Definition at line 141 of file wql.tab.c.

142 {
143  const WCHAR *p = str->data;
144  int len = str->len;
145  WCHAR *ret;
146 
147  if ((p[0] == '\"' && p[len - 1] != '\"') ||
148  (p[0] == '\'' && p[len - 1] != '\'')) return NULL;
149  if ((p[0] == '\"' && p[len - 1] == '\"') ||
150  (p[0] == '\'' && p[len - 1] == '\''))
151  {
152  p++;
153  len -= 2;
154  }
155  if (!(ret = alloc_mem( parser, (len + 1) * sizeof(WCHAR) ))) return NULL;
156  memcpy( ret, p, len * sizeof(WCHAR) );
157  ret[len] = 0;
158  return ret;
159 }
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
static void * alloc_mem(struct parser *parser, UINT size)
Definition: wql.tab.c:122
Definition: import.c:86
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by expr_sval(), and yyparse().

◆ get_token()

static int get_token ( const WCHAR s,
int token 
)
static

Definition at line 2198 of file wql.tab.c.

2199 {
2200  int i;
2201 
2202  switch (*s)
2203  {
2204  case ' ':
2205  case '\t':
2206  case '\r':
2207  case '\n':
2208  for (i = 1; isspaceW( s[i] ); i++) {}
2209  *token = TK_SPACE;
2210  return i;
2211  case '-':
2212  if (!s[1]) return -1;
2213  *token = TK_MINUS;
2214  return 1;
2215  case '(':
2216  *token = TK_LP;
2217  return 1;
2218  case ')':
2219  *token = TK_RP;
2220  return 1;
2221  case '*':
2222  *token = TK_STAR;
2223  return 1;
2224  case '=':
2225  *token = TK_EQ;
2226  return 1;
2227  case '<':
2228  if (s[1] == '=' )
2229  {
2230  *token = TK_LE;
2231  return 2;
2232  }
2233  else if (s[1] == '>')
2234  {
2235  *token = TK_NE;
2236  return 2;
2237  }
2238  else
2239  {
2240  *token = TK_LT;
2241  return 1;
2242  }
2243  case '>':
2244  if (s[1] == '=')
2245  {
2246  *token = TK_GE;
2247  return 2;
2248  }
2249  else
2250  {
2251  *token = TK_GT;
2252  return 1;
2253  }
2254  case '!':
2255  if (s[1] != '=')
2256  {
2257  *token = TK_ILLEGAL;
2258  return 2;
2259  }
2260  else
2261  {
2262  *token = TK_NE;
2263  return 2;
2264  }
2265  case ',':
2266  *token = TK_COMMA;
2267  return 1;
2268  case '\"':
2269  case '\'':
2270  for (i = 1; s[i]; i++)
2271  {
2272  if (s[i] == s[0]) break;
2273  }
2274  if (s[i]) i++;
2275  *token = TK_STRING;
2276  return i;
2277  case '.':
2278  if (!isdigitW( s[1] ))
2279  {
2280  *token = TK_DOT;
2281  return 1;
2282  }
2283  /* fall through */
2284  case '0': case '1': case '2': case '3': case '4':
2285  case '5': case '6': case '7': case '8': case '9':
2286  *token = TK_INTEGER;
2287  for (i = 1; isdigitW( s[i] ); i++) {}
2288  return i;
2289  default:
2290  if (!id_char[*s]) break;
2291 
2292  for (i = 1; id_char[s[i]]; i++) {}
2293  *token = keyword_type( s, i );
2294  return i;
2295  }
2296  *token = TK_ILLEGAL;
2297  return 1;
2298 }
Definition: wql.tab.c:317
WINE_UNICODE_INLINE int isspaceW(WCHAR wc)
Definition: unicode.h:165
Definition: wql.tab.c:300
Definition: wql.tab.c:318
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
Definition: wql.tab.c:319
static const char id_char[]
Definition: wql.tab.c:2114
Definition: wql.tab.c:315
GLdouble s
Definition: gl.h:2039
Definition: wql.tab.c:299
WINE_UNICODE_INLINE int isdigitW(WCHAR wc)
Definition: unicode.h:170
Definition: wql.tab.c:316
Definition: wql.tab.c:320
static int keyword_type(const WCHAR *str, unsigned int len)
Definition: wql.tab.c:2184

Referenced by wql_lex().

◆ keyword_type()

static int keyword_type ( const WCHAR str,
unsigned int  len 
)
static

Definition at line 2184 of file wql.tab.c.

2185 {
2186  struct keyword key, *ret;
2187 
2188  if (len > MAX_TOKEN_LEN) return TK_ID;
2189 
2190  key.name = str;
2191  key.len = len;
2192  key.type = 0;
2194  if (ret) return ret->type;
2195  return TK_ID;
2196 }
WCHAR * name
Definition: path.c:44
static const struct keyword keyword_table[]
Definition: wql.tab.c:2156
const WCHAR * str
static int cmp_keyword(const void *arg1, const void *arg2)
Definition: wql.tab.c:2172
#define MAX_TOKEN_LEN
Definition: wql.tab.c:2141
int ret
Definition: wql.tab.c:311
GLenum GLsizei len
Definition: glext.h:6722
#define ARRAY_SIZE(a)
Definition: main.h:24
Definition: path.c:42
#define bsearch

Referenced by get_token().

◆ malloc()

void* malloc ( YYSIZE_T  )

◆ parse_query()

HRESULT parse_query ( const WCHAR str,
struct view **  view,
struct list mem 
)

Definition at line 2086 of file wql.tab.c.

2087 {
2088  struct parser parser;
2089  int ret;
2090 
2091  *view = NULL;
2092 
2093  parser.cmd = str;
2094  parser.idx = 0;
2095  parser.len = 0;
2097  parser.view = view;
2098  parser.mem = mem;
2099 
2100  ret = wql_parse( &parser );
2101  TRACE("wql_parse returned %d\n", ret);
2102  if (ret)
2103  {
2104  if (*parser.view)
2105  {
2106  destroy_view( *parser.view );
2107  *parser.view = NULL;
2108  }
2109  return parser.error;
2110  }
2111  return S_OK;
2112 }
UINT idx
Definition: wql.tab.c:109
struct list * mem
Definition: wql.tab.c:113
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
const WCHAR * cmd
Definition: wql.tab.c:108
#define TRACE(s)
Definition: solgame.cpp:4
void destroy_view(struct view *view)
Definition: query.c:48
int wql_parse(struct parser *ctx)
unsigned int error
Definition: inffile.c:97
int ret
#define S_OK
Definition: intsafe.h:59
UINT len
Definition: wql.tab.c:110
Definition: import.c:86
static IOleDocumentView * view
Definition: activex.c:1749
struct view ** view
Definition: wql.tab.c:112

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( wbemprox  )

◆ wql_error()

static int wql_error ( struct parser parser,
const char str 
)
static

Definition at line 2317 of file wql.tab.c.

2318 {
2319  ERR("%s\n", str);
2320  return 0;
2321 }
const WCHAR * str
#define ERR(fmt,...)
Definition: debug.h:109

◆ wql_lex()

static int wql_lex ( void val,
struct parser parser 
)
static

Definition at line 2300 of file wql.tab.c.

2301 {
2302  struct string *str = p;
2303  int token = -1;
2304  do
2305  {
2306  parser->idx += parser->len;
2307  if (!parser->cmd[parser->idx]) return 0;
2308  parser->len = get_token( &parser->cmd[parser->idx], &token );
2309  if (!parser->len) break;
2310 
2311  str->data = &parser->cmd[parser->idx];
2312  str->len = parser->len;
2313  } while (token == TK_SPACE);
2314  return token;
2315 }
UINT idx
Definition: wql.tab.c:109
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
const WCHAR * str
const WCHAR * cmd
Definition: wql.tab.c:108
static int get_token(const WCHAR *s, int *token)
Definition: wql.tab.c:2198
UINT len
Definition: wql.tab.c:110
Definition: import.c:86
GLfloat GLfloat p
Definition: glext.h:8902

◆ wql_parse()

int wql_parse ( struct parser ctx)

Referenced by parse_query().

◆ yydestruct()

static void yydestruct ( const char yymsg,
int  yytype,
YYSTYPE yyvaluep,
struct parser ctx 
)
static

Definition at line 1194 of file wql.tab.c.

1195 {
1196  YYUSE (yyvaluep);
1197  YYUSE (ctx);
1198  if (!yymsg)
1199  yymsg = "Deleting";
1200  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1201 
1203  YYUSE (yytype);
1205 }
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: wql.tab.c:438
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: wql.tab.c:944
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: wql.tab.c:437
#define YYUSE(E)
Definition: wql.tab.c:420

Referenced by yyparse().

◆ yyparse()

int yyparse ( struct parser ctx)

Definition at line 1215 of file wql.tab.c.

1216 {
1217 /* The lookahead symbol. */
1218 int yychar;
1219 
1220 
1221 /* The semantic value of the lookahead symbol. */
1222 /* Default value used for initialization, for pacifying older GCCs
1223  or non-GCC compilers. */
1224 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1225 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1226 
1227  /* Number of syntax errors so far. */
1228  int yynerrs;
1229 
1230  int yystate;
1231  /* Number of tokens to shift before error messages enabled. */
1232  int yyerrstatus;
1233 
1234  /* The stacks and their tools:
1235  'yyss': related to states.
1236  'yyvs': related to semantic values.
1237 
1238  Refer to the stacks through separate pointers, to allow yyoverflow
1239  to reallocate them elsewhere. */
1240 
1241  /* The state stack. */
1242  yytype_int16 yyssa[YYINITDEPTH];
1243  yytype_int16 *yyss;
1244  yytype_int16 *yyssp;
1245 
1246  /* The semantic value stack. */
1247  YYSTYPE yyvsa[YYINITDEPTH];
1248  YYSTYPE *yyvs;
1249  YYSTYPE *yyvsp;
1250 
1251  YYSIZE_T yystacksize;
1252 
1253  int yyn;
1254  int yyresult;
1255  /* Lookahead token as an internal (translated) token number. */
1256  int yytoken = 0;
1257  /* The variables used to return semantic value and location from the
1258  action routines. */
1259  YYSTYPE yyval;
1260 
1261 #if YYERROR_VERBOSE
1262  /* Buffer for error messages, and its allocated size. */
1263  char yymsgbuf[128];
1264  char *yymsg = yymsgbuf;
1265  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1266 #endif
1267 
1268 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1269 
1270  /* The number of symbols on the RHS of the reduced rule.
1271  Keep to zero when no symbol should be popped. */
1272  int yylen = 0;
1273 
1274  yyssp = yyss = yyssa;
1275  yyvsp = yyvs = yyvsa;
1276  yystacksize = YYINITDEPTH;
1277 
1278  YYDPRINTF ((stderr, "Starting parse\n"));
1279 
1280  yystate = 0;
1281  yyerrstatus = 0;
1282  yynerrs = 0;
1283  yychar = YYEMPTY; /* Cause a token to be read. */
1284  goto yysetstate;
1285 
1286 /*------------------------------------------------------------.
1287 | yynewstate -- Push a new state, which is found in yystate. |
1288 `------------------------------------------------------------*/
1289  yynewstate:
1290  /* In all cases, when you get here, the value and location stacks
1291  have just been pushed. So pushing a state here evens the stacks. */
1292  yyssp++;
1293 
1294  yysetstate:
1295  *yyssp = yystate;
1296 
1297  if (yyss + yystacksize - 1 <= yyssp)
1298  {
1299  /* Get the current used size of the three stacks, in elements. */
1300  YYSIZE_T yysize = yyssp - yyss + 1;
1301 
1302 #ifdef yyoverflow
1303  {
1304  /* Give user a chance to reallocate the stack. Use copies of
1305  these so that the &'s don't force the real ones into
1306  memory. */
1307  YYSTYPE *yyvs1 = yyvs;
1308  yytype_int16 *yyss1 = yyss;
1309 
1310  /* Each stack pointer address is followed by the size of the
1311  data in use in that stack, in bytes. This used to be a
1312  conditional around just the two extra args, but that might
1313  be undefined if yyoverflow is a macro. */
1314  yyoverflow (YY_("memory exhausted"),
1315  &yyss1, yysize * sizeof (*yyssp),
1316  &yyvs1, yysize * sizeof (*yyvsp),
1317  &yystacksize);
1318 
1319  yyss = yyss1;
1320  yyvs = yyvs1;
1321  }
1322 #else /* no yyoverflow */
1323 # ifndef YYSTACK_RELOCATE
1324  goto yyexhaustedlab;
1325 # else
1326  /* Extend the stack our own way. */
1327  if (YYMAXDEPTH <= yystacksize)
1328  goto yyexhaustedlab;
1329  yystacksize *= 2;
1330  if (YYMAXDEPTH < yystacksize)
1331  yystacksize = YYMAXDEPTH;
1332 
1333  {
1334  yytype_int16 *yyss1 = yyss;
1335  union yyalloc *yyptr =
1336  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1337  if (! yyptr)
1338  goto yyexhaustedlab;
1339  YYSTACK_RELOCATE (yyss_alloc, yyss);
1340  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1341 # undef YYSTACK_RELOCATE
1342  if (yyss1 != yyssa)
1343  YYSTACK_FREE (yyss1);
1344  }
1345 # endif
1346 #endif /* no yyoverflow */
1347 
1348  yyssp = yyss + yysize - 1;
1349  yyvsp = yyvs + yysize - 1;
1350 
1351  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1352  (unsigned long int) yystacksize));
1353 
1354  if (yyss + yystacksize - 1 <= yyssp)
1355  YYABORT;
1356  }
1357 
1358  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1359 
1360  if (yystate == YYFINAL)
1361  YYACCEPT;
1362 
1363  goto yybackup;
1364 
1365 /*-----------.
1366 | yybackup. |
1367 `-----------*/
1368 yybackup:
1369 
1370  /* Do appropriate processing given the current state. Read a
1371  lookahead token if we need one and don't already have one. */
1372 
1373  /* First try to decide what to do without reference to lookahead token. */
1374  yyn = yypact[yystate];
1375  if (yypact_value_is_default (yyn))
1376  goto yydefault;
1377 
1378  /* Not known => get a lookahead token if don't already have one. */
1379 
1380  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1381  if (yychar == YYEMPTY)
1382  {
1383  YYDPRINTF ((stderr, "Reading a token: "));
1384  yychar = yylex (&yylval, ctx);
1385  }
1386 
1387  if (yychar <= YYEOF)
1388  {
1389  yychar = yytoken = YYEOF;
1390  YYDPRINTF ((stderr, "Now at end of input.\n"));
1391  }
1392  else
1393  {
1394  yytoken = YYTRANSLATE (yychar);
1395  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1396  }
1397 
1398  /* If the proper action on seeing token YYTOKEN is to reduce or to
1399  detect an error, take that action. */
1400  yyn += yytoken;
1401  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1402  goto yydefault;
1403  yyn = yytable[yyn];
1404  if (yyn <= 0)
1405  {
1406  if (yytable_value_is_error (yyn))
1407  goto yyerrlab;
1408  yyn = -yyn;
1409  goto yyreduce;
1410  }
1411 
1412  /* Count tokens shifted since error; after three, turn off error
1413  status. */
1414  if (yyerrstatus)
1415  yyerrstatus--;
1416 
1417  /* Shift the lookahead token. */
1418  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1419 
1420  /* Discard the shifted token. */
1421  yychar = YYEMPTY;
1422 
1423  yystate = yyn;
1425  *++yyvsp = yylval;
1427 
1428  goto yynewstate;
1429 
1430 
1431 /*-----------------------------------------------------------.
1432 | yydefault -- do the default action for the current state. |
1433 `-----------------------------------------------------------*/
1434 yydefault:
1435  yyn = yydefact[yystate];
1436  if (yyn == 0)
1437  goto yyerrlab;
1438  goto yyreduce;
1439 
1440 
1441 /*-----------------------------.
1442 | yyreduce -- Do a reduction. |
1443 `-----------------------------*/
1444 yyreduce:
1445  /* yyn is the number of a rule to reduce with. */
1446  yylen = yyr2[yyn];
1447 
1448  /* If YYLEN is nonzero, implement the default value of the action:
1449  '$$ = $1'.
1450 
1451  Otherwise, the following line sets YYVAL to garbage.
1452  This behavior is undocumented and Bison
1453  users should not rely upon it. Assigning to YYVAL
1454  unconditionally makes the parser a bit smaller, and it avoids a
1455  GCC warning that YYVAL may be used uninitialized. */
1456  yyval = yyvsp[1-yylen];
1457 
1458 
1459  YY_REDUCE_PRINT (yyn);
1460  switch (yyn)
1461  {
1462  case 2:
1463 #line 222 "wql.y" /* yacc.c:1646 */
1464  {
1465  HRESULT hr;
1466  struct parser *parser = ctx;
1467  struct view *view;
1468 
1469  hr = create_view( NULL, (yyvsp[0].string), NULL, &view );
1470  if (hr != S_OK)
1471  YYABORT;
1472 
1473  PARSER_BUBBLE_UP_VIEW( parser, (yyval.view), view );
1474  }
1475 #line 1476 "wql.tab.c" /* yacc.c:1646 */
1476  break;
1477 
1478  case 3:
1479 #line 234 "wql.y" /* yacc.c:1646 */
1480  {
1481  HRESULT hr;
1482  struct parser *parser = ctx;
1483  struct view *view;
1484 
1485  hr = create_view( (yyvsp[-2].proplist), (yyvsp[0].string), NULL, &view );
1486  if (hr != S_OK)
1487  YYABORT;
1488 
1489  PARSER_BUBBLE_UP_VIEW( parser, (yyval.view), view );
1490  }
1491 #line 1492 "wql.tab.c" /* yacc.c:1646 */
1492  break;
1493 
1494  case 4:
1495 #line 246 "wql.y" /* yacc.c:1646 */
1496  {
1497  HRESULT hr;
1498  struct parser *parser = ctx;
1499  struct view *view;
1500 
1501  hr = create_view( (yyvsp[-4].proplist), (yyvsp[-2].string), (yyvsp[0].expr), &view );
1502  if (hr != S_OK)
1503  YYABORT;
1504 
1505  PARSER_BUBBLE_UP_VIEW( parser, (yyval.view), view );
1506  }
1507 #line 1508 "wql.tab.c" /* yacc.c:1646 */
1508  break;
1509 
1510  case 6:
1511 #line 262 "wql.y" /* yacc.c:1646 */
1512  {
1513  (yyvsp[-2].proplist)->next = (yyvsp[0].proplist);
1514  }
1515 #line 1516 "wql.tab.c" /* yacc.c:1646 */
1516  break;
1517 
1518  case 7:
1519 #line 266 "wql.y" /* yacc.c:1646 */
1520  {
1521  (yyval.proplist) = NULL;
1522  }
1523 #line 1524 "wql.tab.c" /* yacc.c:1646 */
1524  break;
1525 
1526  case 8:
1527 #line 273 "wql.y" /* yacc.c:1646 */
1528  {
1529  (yyval.proplist) = alloc_property( ctx, (yyvsp[-2].string), (yyvsp[0].string) );
1530  if (!(yyval.proplist))
1531  YYABORT;
1532  }
1533 #line 1534 "wql.tab.c" /* yacc.c:1646 */
1534  break;
1535 
1536  case 9:
1537 #line 279 "wql.y" /* yacc.c:1646 */
1538  {
1539  (yyval.proplist) = alloc_property( ctx, NULL, (yyvsp[0].string) );
1540  if (!(yyval.proplist))
1541  YYABORT;
1542  }
1543 #line 1544 "wql.tab.c" /* yacc.c:1646 */
1544  break;
1545 
1546  case 10:
1547 #line 288 "wql.y" /* yacc.c:1646 */
1548  {
1549  (yyval.string) = get_string( ctx, &(yyvsp[0].str) );
1550  if (!(yyval.string))
1551  YYABORT;
1552  }
1553 #line 1554 "wql.tab.c" /* yacc.c:1646 */
1554  break;
1555 
1556  case 11:
1557 #line 297 "wql.y" /* yacc.c:1646 */
1558  {
1559  (yyval.integer) = get_int( ctx );
1560  }
1561 #line 1562 "wql.tab.c" /* yacc.c:1646 */
1562  break;
1563 
1564  case 12:
1565 #line 304 "wql.y" /* yacc.c:1646 */
1566  {
1567  (yyval.expr) = (yyvsp[-1].expr);
1568  if (!(yyval.expr))
1569  YYABORT;
1570  }
1571 #line 1572 "wql.tab.c" /* yacc.c:1646 */
1572  break;
1573 
1574  case 13:
1575 #line 310 "wql.y" /* yacc.c:1646 */
1576  {
1577  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_AND, (yyvsp[0].expr) );
1578  if (!(yyval.expr))
1579  YYABORT;
1580  }
1581 #line 1582 "wql.tab.c" /* yacc.c:1646 */
1582  break;
1583 
1584  case 14:
1585 #line 316 "wql.y" /* yacc.c:1646 */
1586  {
1587  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_OR, (yyvsp[0].expr) );
1588  if (!(yyval.expr))
1589  YYABORT;
1590  }
1591 #line 1592 "wql.tab.c" /* yacc.c:1646 */
1592  break;
1593 
1594  case 15:
1595 #line 322 "wql.y" /* yacc.c:1646 */
1596  {
1597  (yyval.expr) = expr_unary( ctx, (yyvsp[0].expr), OP_NOT );
1598  if (!(yyval.expr))
1599  YYABORT;
1600  }
1601 #line 1602 "wql.tab.c" /* yacc.c:1646 */
1602  break;
1603 
1604  case 16:
1605 #line 328 "wql.y" /* yacc.c:1646 */
1606  {
1607  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_EQ, (yyvsp[0].expr) );
1608  if (!(yyval.expr))
1609  YYABORT;
1610  }
1611 #line 1612 "wql.tab.c" /* yacc.c:1646 */
1612  break;
1613 
1614  case 17:
1615 #line 334 "wql.y" /* yacc.c:1646 */
1616  {
1617  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_GT, (yyvsp[0].expr) );
1618  if (!(yyval.expr))
1619  YYABORT;
1620  }
1621 #line 1622 "wql.tab.c" /* yacc.c:1646 */
1622  break;
1623 
1624  case 18:
1625 #line 340 "wql.y" /* yacc.c:1646 */
1626  {
1627  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_LT, (yyvsp[0].expr) );
1628  if (!(yyval.expr))
1629  YYABORT;
1630  }
1631 #line 1632 "wql.tab.c" /* yacc.c:1646 */
1632  break;
1633 
1634  case 19:
1635 #line 346 "wql.y" /* yacc.c:1646 */
1636  {
1637  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_LE, (yyvsp[0].expr) );
1638  if (!(yyval.expr))
1639  YYABORT;
1640  }
1641 #line 1642 "wql.tab.c" /* yacc.c:1646 */
1642  break;
1643 
1644  case 20:
1645 #line 352 "wql.y" /* yacc.c:1646 */
1646  {
1647  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_GE, (yyvsp[0].expr) );
1648  if (!(yyval.expr))
1649  YYABORT;
1650  }
1651 #line 1652 "wql.tab.c" /* yacc.c:1646 */
1652  break;
1653 
1654  case 21:
1655 #line 358 "wql.y" /* yacc.c:1646 */
1656  {
1657  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_NE, (yyvsp[0].expr) );
1658  if (!(yyval.expr))
1659  YYABORT;
1660  }
1661 #line 1662 "wql.tab.c" /* yacc.c:1646 */
1662  break;
1663 
1664  case 22:
1665 #line 364 "wql.y" /* yacc.c:1646 */
1666  {
1667  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_EQ, (yyvsp[0].expr) );
1668  if (!(yyval.expr))
1669  YYABORT;
1670  }
1671 #line 1672 "wql.tab.c" /* yacc.c:1646 */
1672  break;
1673 
1674  case 23:
1675 #line 370 "wql.y" /* yacc.c:1646 */
1676  {
1677  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_GT, (yyvsp[0].expr) );
1678  if (!(yyval.expr))
1679  YYABORT;
1680  }
1681 #line 1682 "wql.tab.c" /* yacc.c:1646 */
1682  break;
1683 
1684  case 24:
1685 #line 376 "wql.y" /* yacc.c:1646 */
1686  {
1687  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_LT, (yyvsp[0].expr) );
1688  if (!(yyval.expr))
1689  YYABORT;
1690  }
1691 #line 1692 "wql.tab.c" /* yacc.c:1646 */
1692  break;
1693 
1694  case 25:
1695 #line 382 "wql.y" /* yacc.c:1646 */
1696  {
1697  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_LE, (yyvsp[0].expr) );
1698  if (!(yyval.expr))
1699  YYABORT;
1700  }
1701 #line 1702 "wql.tab.c" /* yacc.c:1646 */
1702  break;
1703 
1704  case 26:
1705 #line 388 "wql.y" /* yacc.c:1646 */
1706  {
1707  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_GE, (yyvsp[0].expr) );
1708  if (!(yyval.expr))
1709  YYABORT;
1710  }
1711 #line 1712 "wql.tab.c" /* yacc.c:1646 */
1712  break;
1713 
1714  case 27:
1715 #line 394 "wql.y" /* yacc.c:1646 */
1716  {
1717  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_NE, (yyvsp[0].expr) );
1718  if (!(yyval.expr))
1719  YYABORT;
1720  }
1721 #line 1722 "wql.tab.c" /* yacc.c:1646 */
1722  break;
1723 
1724  case 28:
1725 #line 400 "wql.y" /* yacc.c:1646 */
1726  {
1727  (yyval.expr) = expr_complex( ctx, (yyvsp[-2].expr), OP_LIKE, (yyvsp[0].expr) );
1728  if (!(yyval.expr))
1729  YYABORT;
1730  }
1731 #line 1732 "wql.tab.c" /* yacc.c:1646 */
1732  break;
1733 
1734  case 29:
1735 #line 406 "wql.y" /* yacc.c:1646 */
1736  {
1737  (yyval.expr) = expr_unary( ctx, (yyvsp[-2].expr), OP_ISNULL );
1738  if (!(yyval.expr))
1739  YYABORT;
1740  }
1741 #line 1742 "wql.tab.c" /* yacc.c:1646 */
1742  break;
1743 
1744  case 30:
1745 #line 412 "wql.y" /* yacc.c:1646 */
1746  {
1747  (yyval.expr) = expr_unary( ctx, (yyvsp[-3].expr), OP_NOTNULL );
1748  if (!(yyval.expr))
1749  YYABORT;
1750  }
1751 #line 1752 "wql.tab.c" /* yacc.c:1646 */
1752  break;
1753 
1754  case 31:
1755 #line 418 "wql.y" /* yacc.c:1646 */
1756  {
1757  (yyval.expr) = expr_unary( ctx, (yyvsp[-2].expr), OP_ISNULL );
1758  if (!(yyval.expr))
1759  YYABORT;
1760  }
1761 #line 1762 "wql.tab.c" /* yacc.c:1646 */
1762  break;
1763 
1764  case 32:
1765 #line 424 "wql.y" /* yacc.c:1646 */
1766  {
1767  (yyval.expr) = expr_unary( ctx, (yyvsp[0].expr), OP_ISNULL );
1768  if (!(yyval.expr))
1769  YYABORT;
1770  }
1771 #line 1772 "wql.tab.c" /* yacc.c:1646 */
1772  break;
1773 
1774  case 33:
1775 #line 430 "wql.y" /* yacc.c:1646 */
1776  {
1777  (yyval.expr) = expr_unary( ctx, (yyvsp[-2].expr), OP_NOTNULL );
1778  if (!(yyval.expr))
1779  YYABORT;
1780  }
1781 #line 1782 "wql.tab.c" /* yacc.c:1646 */
1782  break;
1783 
1784  case 34:
1785 #line 436 "wql.y" /* yacc.c:1646 */
1786  {
1787  (yyval.expr) = expr_unary( ctx, (yyvsp[0].expr), OP_NOTNULL );
1788  if (!(yyval.expr))
1789  YYABORT;
1790  }
1791 #line 1792 "wql.tab.c" /* yacc.c:1646 */
1792  break;
1793 
1794  case 35:
1795 #line 445 "wql.y" /* yacc.c:1646 */
1796  {
1797  (yyval.expr) = expr_sval( ctx, &(yyvsp[0].str) );
1798  if (!(yyval.expr))
1799  YYABORT;
1800  }
1801 #line 1802 "wql.tab.c" /* yacc.c:1646 */
1802  break;
1803 
1804  case 36:
1805 #line 454 "wql.y" /* yacc.c:1646 */
1806  {
1807  (yyval.expr) = expr_propval( ctx, (yyvsp[0].proplist) );
1808  if (!(yyval.expr))
1809  YYABORT;
1810  }
1811 #line 1812 "wql.tab.c" /* yacc.c:1646 */
1812  break;
1813 
1814  case 37:
1815 #line 463 "wql.y" /* yacc.c:1646 */
1816  {
1817  (yyval.expr) = expr_ival( ctx, (yyvsp[0].integer) );
1818  if (!(yyval.expr))
1819  YYABORT;
1820  }
1821 #line 1822 "wql.tab.c" /* yacc.c:1646 */
1822  break;
1823 
1824  case 38:
1825 #line 469 "wql.y" /* yacc.c:1646 */
1826  {
1827  (yyval.expr) = expr_sval( ctx, &(yyvsp[0].str) );
1828  if (!(yyval.expr))
1829  YYABORT;
1830  }
1831 #line 1832 "wql.tab.c" /* yacc.c:1646 */
1832  break;
1833 
1834  case 39:
1835 #line 475 "wql.y" /* yacc.c:1646 */
1836  {
1837  (yyval.expr) = expr_bval( ctx, -1 );
1838  if (!(yyval.expr))
1839  YYABORT;
1840  }
1841 #line 1842 "wql.tab.c" /* yacc.c:1646 */
1842  break;
1843 
1844  case 40:
1845 #line 481 "wql.y" /* yacc.c:1646 */
1846  {
1847  (yyval.expr) = expr_bval( ctx, 0 );
1848  if (!(yyval.expr))
1849  YYABORT;
1850  }
1851 #line 1852 "wql.tab.c" /* yacc.c:1646 */
1852  break;
1853 
1854 
1855 #line 1856 "wql.tab.c" /* yacc.c:1646 */
1856  default: break;
1857  }
1858  /* User semantic actions sometimes alter yychar, and that requires
1859  that yytoken be updated with the new translation. We take the
1860  approach of translating immediately before every use of yytoken.
1861  One alternative is translating here after every semantic action,
1862  but that translation would be missed if the semantic action invokes
1863  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1864  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1865  incorrect destructor might then be invoked immediately. In the
1866  case of YYERROR or YYBACKUP, subsequent parser actions might lead
1867  to an incorrect destructor call or verbose syntax error message
1868  before the lookahead is translated. */
1869  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1870 
1871  YYPOPSTACK (yylen);
1872  yylen = 0;
1873  YY_STACK_PRINT (yyss, yyssp);
1874 
1875  *++yyvsp = yyval;
1876 
1877  /* Now 'shift' the result of the reduction. Determine what state
1878  that goes to, based on the state we popped back to and the rule
1879  number reduced by. */
1880 
1881  yyn = yyr1[yyn];
1882 
1883  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1884  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1885  yystate = yytable[yystate];
1886  else
1887  yystate = yydefgoto[yyn - YYNTOKENS];
1888 
1889  goto yynewstate;
1890 
1891 
1892 /*--------------------------------------.
1893 | yyerrlab -- here on detecting error. |
1894 `--------------------------------------*/
1895 yyerrlab:
1896  /* Make sure we have latest lookahead translation. See comments at
1897  user semantic actions for why this is necessary. */
1898  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1899 
1900  /* If not already recovering from an error, report this error. */
1901  if (!yyerrstatus)
1902  {
1903  ++yynerrs;
1904 #if ! YYERROR_VERBOSE
1905  yyerror (ctx, YY_("syntax error"));
1906 #else
1907 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1908  yyssp, yytoken)
1909  {
1910  char const *yymsgp = YY_("syntax error");
1911  int yysyntax_error_status;
1912  yysyntax_error_status = YYSYNTAX_ERROR;
1913  if (yysyntax_error_status == 0)
1914  yymsgp = yymsg;
1915  else if (yysyntax_error_status == 1)
1916  {
1917  if (yymsg != yymsgbuf)
1918  YYSTACK_FREE (yymsg);
1919  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1920  if (!yymsg)
1921  {
1922  yymsg = yymsgbuf;
1923  yymsg_alloc = sizeof yymsgbuf;
1924  yysyntax_error_status = 2;
1925  }
1926  else
1927  {
1928  yysyntax_error_status = YYSYNTAX_ERROR;
1929  yymsgp = yymsg;
1930  }
1931  }
1932  yyerror (ctx, yymsgp);
1933  if (yysyntax_error_status == 2)
1934  goto yyexhaustedlab;
1935  }
1936 # undef YYSYNTAX_ERROR
1937 #endif
1938  }
1939 
1940 
1941 
1942  if (yyerrstatus == 3)
1943  {
1944  /* If just tried and failed to reuse lookahead token after an
1945  error, discard it. */
1946 
1947  if (yychar <= YYEOF)
1948  {
1949  /* Return failure if at end of input. */
1950  if (yychar == YYEOF)
1951  YYABORT;
1952  }
1953  else
1954  {
1955  yydestruct ("Error: discarding",
1956  yytoken, &yylval, ctx);
1957  yychar = YYEMPTY;
1958  }
1959  }
1960 
1961  /* Else will try to reuse lookahead token after shifting the error
1962  token. */
1963  goto yyerrlab1;
1964 
1965 
1966 /*---------------------------------------------------.
1967 | yyerrorlab -- error raised explicitly by YYERROR. |
1968 `---------------------------------------------------*/
1969 yyerrorlab:
1970 
1971  /* Pacify compilers like GCC when the user code never invokes
1972  YYERROR and the label yyerrorlab therefore never appears in user
1973  code. */
1974  if (/*CONSTCOND*/ 0)
1975  goto yyerrorlab;
1976 
1977  /* Do not reclaim the symbols of the rule whose action triggered
1978  this YYERROR. */
1979  YYPOPSTACK (yylen);
1980  yylen = 0;
1981  YY_STACK_PRINT (yyss, yyssp);
1982  yystate = *yyssp;
1983  goto yyerrlab1;
1984 
1985 
1986 /*-------------------------------------------------------------.
1987 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1988 `-------------------------------------------------------------*/
1989 yyerrlab1:
1990  yyerrstatus = 3; /* Each real token shifted decrements this. */
1991 
1992  for (;;)
1993  {
1994  yyn = yypact[yystate];
1995  if (!yypact_value_is_default (yyn))
1996  {
1997  yyn += YYTERROR;
1998  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1999  {
2000  yyn = yytable[yyn];
2001  if (0 < yyn)
2002  break;
2003  }
2004  }
2005 
2006  /* Pop the current state because it cannot handle the error token. */
2007  if (yyssp == yyss)
2008  YYABORT;
2009 
2010 
2011  yydestruct ("Error: popping",
2012  yystos[yystate], yyvsp, ctx);
2013  YYPOPSTACK (1);
2014  yystate = *yyssp;
2015  YY_STACK_PRINT (yyss, yyssp);
2016  }
2017 
2019  *++yyvsp = yylval;
2021 
2022 
2023  /* Shift the error token. */
2024  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2025 
2026  yystate = yyn;
2027  goto yynewstate;
2028 
2029 
2030 /*-------------------------------------.
2031 | yyacceptlab -- YYACCEPT comes here. |
2032 `-------------------------------------*/
2033 yyacceptlab:
2034  yyresult = 0;
2035  goto yyreturn;
2036 
2037 /*-----------------------------------.
2038 | yyabortlab -- YYABORT comes here. |
2039 `-----------------------------------*/
2040 yyabortlab:
2041  yyresult = 1;
2042  goto yyreturn;
2043 
2044 #if !defined yyoverflow || YYERROR_VERBOSE
2045 /*-------------------------------------------------.
2046 | yyexhaustedlab -- memory exhaustion comes here. |
2047 `-------------------------------------------------*/
2048 yyexhaustedlab:
2049  yyerror (ctx, YY_("memory exhausted"));
2050  yyresult = 2;
2051  /* Fall through. */
2052 #endif
2053 
2054 yyreturn:
2055  if (yychar != YYEMPTY)
2056  {
2057  /* Make sure we have latest lookahead translation. See comments at
2058  user semantic actions for why this is necessary. */
2059  yytoken = YYTRANSLATE (yychar);
2060  yydestruct ("Cleanup: discarding lookahead",
2061  yytoken, &yylval, ctx);
2062  }
2063  /* Do not reclaim the symbols of the rule whose action triggered
2064  this YYABORT or YYACCEPT. */
2065  YYPOPSTACK (yylen);
2066  YY_STACK_PRINT (yyss, yyssp);
2067  while (yyssp != yyss)
2068  {
2069  yydestruct ("Cleanup: popping",
2070  yystos[*yyssp], yyvsp, ctx);
2071  YYPOPSTACK (1);
2072  }
2073 #ifndef yyoverflow
2074  if (yyss != yyssa)
2075  YYSTACK_FREE (yyss);
2076 #endif
2077 #if YYERROR_VERBOSE
2078  if (yymsg != yymsgbuf)
2079  YYSTACK_FREE (yymsg);
2080 #endif
2081  return yyresult;
2082 }
#define PARSER_BUBBLE_UP_VIEW(parser, result, current_view)
Definition: wql.tab.c:253
#define YYINITDEPTH
Definition: wql.tab.c:952
#define YYSTACK_ALLOC
Definition: wql.tab.c:484
static struct expr * expr_bval(struct parser *parser, int val)
Definition: wql.tab.c:228
#define OP_EQ
Definition: query.h:36
#define OP_GE
Definition: query.h:42
#define yyerror
Definition: wql.tab.c:65
HRESULT hr
Definition: shlfolder.c:183
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: wql.tab.c:438
static const yytype_uint8 yyr1[]
Definition: wql.tab.c:764
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: wql.tab.c:944
YYLTYPE yylloc
Definition: hlsl.tab.c:2413
#define YYPOPSTACK(N)
#define YYEOF
Definition: wql.tab.c:787
#define YY_REDUCE_PRINT(Rule)
Definition: wql.tab.c:946
#define yychar
Definition: asmshader.tab.c:74
LPWSTR string
Definition: sql.tab.c:240
#define yynerrs
Definition: wql.tab.c:67
#define yylex
Definition: wql.tab.c:64
static const yytype_uint8 yytable[]
Definition: wql.tab.c:723
static struct expr * expr_ival(struct parser *parser, int val)
Definition: wql.tab.c:204
#define YY_(Msgid)
Definition: wql.tab.c:406
short yytype_int16
#define YYSTACK_BYTES(N)
Definition: wql.tab.c:529
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser *ctx)
Definition: wql.tab.c:1194
Definition: query.h:86
static int get_int(struct parser *parser)
Definition: wql.tab.c:161
BOOL integer
#define OP_AND
Definition: query.h:37
#define yylval
Definition: asmshader.tab.c:73
#define YYDPRINTF(Args)
Definition: wql.tab.c:943
static struct expr * expr_unary(struct parser *parser, struct expr *l, UINT op)
Definition: wql.tab.c:191
#define YY_INITIAL_VALUE(Value)
Definition: wql.tab.c:434
#define YYACCEPT
Definition: wql.tab.c:789
static const yytype_int8 yypgoto[]
Definition: wql.tab.c:709
static const yytype_int8 yypact[]
Definition: wql.tab.c:681
#define YYEMPTY
Definition: wql.tab.c:786
const WCHAR * str
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: wql.tab.c:437
static const yytype_uint8 yystos[]
Definition: wql.tab.c:751
#define yytable_value_is_error(Yytable_value)
Definition: wql.tab.c:676
smooth NULL
Definition: ftsmooth.c:416
static struct expr * expr_sval(struct parser *parser, const struct string *str)
Definition: wql.tab.c:215
#define OP_NE
Definition: query.h:43
static const yytype_uint8 yydefact[]
Definition: wql.tab.c:696
static struct expr * expr_complex(struct parser *parser, struct expr *l, UINT op, struct expr *r)
Definition: wql.tab.c:178
const struct property * proplist
yytype_int16 yyss_alloc
static const yytype_uint8 yyr2[]
Definition: wql.tab.c:774
LONG HRESULT
Definition: typedefs.h:77
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: wql.tab.c:540
YYSTYPE yyvs_alloc
#define YYMAXDEPTH
Definition: wql.tab.c:963
static const yytype_int8 yycheck[]
Definition: wql.tab.c:736
static struct property * alloc_property(struct parser *parser, const WCHAR *class, const WCHAR *name)
Definition: wql.tab.c:129
#define OP_LE
Definition: query.h:41
static const yytype_int8 yydefgoto[]
Definition: wql.tab.c:715
#define YYSIZE_T
Definition: wql.tab.c:390
#define YYSTACK_FREE
Definition: wql.tab.c:485
#define S_OK
Definition: intsafe.h:59
static WCHAR * get_string(struct parser *parser, const struct string *str)
Definition: wql.tab.c:141
static unsigned __int64 next
Definition: rand_nt.c:6
#define YYTRANSLATE(YYX)
Definition: wql.tab.c:592
expression_t * expr
Definition: parser.tab.c:302
static struct expr * expr_propval(struct parser *parser, const struct property *prop)
Definition: wql.tab.c:239
#define OP_OR
Definition: query.h:38
#define YYTERROR
Definition: wql.tab.c:814
Definition: import.c:86
#define YYABORT
Definition: wql.tab.c:790
#define yypact_value_is_default(Yystate)
Definition: wql.tab.c:671
FILE * stderr
static IOleDocumentView * view
Definition: activex.c:1749
#define YYLAST
Definition: wql.tab.c:576
#define YYSYNTAX_ERROR
struct view * view
Definition: wql.tab.c:335
struct property * proplist
Definition: wql.tab.c:334
#define YYFINAL
Definition: wql.tab.c:574
#define YYNTOKENS
Definition: wql.tab.c:579
#define YY_STACK_PRINT(Bottom, Top)
Definition: wql.tab.c:945
static HRESULT create_view(MSIHANDLE, IDispatch **)
Definition: automation.c:2511

◆ yystpcpy()

static char* yystpcpy ( char yydest,
const char yysrc 
)
static

Definition at line 992 of file wql.tab.c.

993 {
994  char *yyd = yydest;
995  const char *yys = yysrc;
996 
997  while ((*yyd++ = *yys++) != '\0')
998  continue;
999 
1000  return yyd - 1;
1001 }

Referenced by yytnamerr().

◆ yystrlen()

static YYSIZE_T yystrlen ( const char yystr)
static

Definition at line 975 of file wql.tab.c.

976 {
977  YYSIZE_T yylen;
978  for (yylen = 0; yystr[yylen]; yylen++)
979  continue;
980  return yylen;
981 }
#define YYSIZE_T
Definition: wql.tab.c:390

Referenced by yysyntax_error(), and yytnamerr().

◆ yysyntax_error()

static int yysyntax_error ( YYSIZE_T yymsg_alloc,
char **  yymsg,
yytype_int16 yyssp,
int  yytoken 
)
static

Definition at line 1062 of file wql.tab.c.

1064 {
1065  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1066  YYSIZE_T yysize = yysize0;
1067  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1068  /* Internationalized format string. */
1069  const char *yyformat = YY_NULL;
1070  /* Arguments of yyformat. */
1071  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1072  /* Number of reported tokens (one for the "unexpected", one per
1073  "expected"). */
1074  int yycount = 0;
1075 
1076  /* There are many possibilities here to consider:
1077  - If this state is a consistent state with a default action, then
1078  the only way this function was invoked is if the default action
1079  is an error action. In that case, don't check for expected
1080  tokens because there are none.
1081  - The only way there can be no lookahead present (in yychar) is if
1082  this state is a consistent state with a default action. Thus,
1083  detecting the absence of a lookahead is sufficient to determine
1084  that there is no unexpected or expected token to report. In that
1085  case, just report a simple "syntax error".
1086  - Don't assume there isn't a lookahead just because this state is a
1087  consistent state with a default action. There might have been a
1088  previous inconsistent state, consistent state with a non-default
1089  action, or user semantic action that manipulated yychar.
1090  - Of course, the expected token list depends on states to have
1091  correct lookahead information, and it depends on the parser not
1092  to perform extra reductions after fetching a lookahead from the
1093  scanner and before detecting a syntax error. Thus, state merging
1094  (from LALR or IELR) and default reductions corrupt the expected
1095  token list. However, the list is correct for canonical LR with
1096  one exception: it will still contain any token that will not be
1097  accepted due to an error action in a later state.
1098  */
1099  if (yytoken != YYEMPTY)
1100  {
1101  int yyn = yypact[*yyssp];
1102  yyarg[yycount++] = yytname[yytoken];
1103  if (!yypact_value_is_default (yyn))
1104  {
1105  /* Start YYX at -YYN if negative to avoid negative indexes in
1106  YYCHECK. In other words, skip the first -YYN actions for
1107  this state because they are default actions. */
1108  int yyxbegin = yyn < 0 ? -yyn : 0;
1109  /* Stay within bounds of both yycheck and yytname. */
1110  int yychecklim = YYLAST - yyn + 1;
1111  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1112  int yyx;
1113 
1114  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1115  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1116  && !yytable_value_is_error (yytable[yyx + yyn]))
1117  {
1118  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1119  {
1120  yycount = 1;
1121  yysize = yysize0;
1122  break;
1123  }
1124  yyarg[yycount++] = yytname[yyx];
1125  {
1126  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1127  if (! (yysize <= yysize1
1128  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1129  return 2;
1130  yysize = yysize1;
1131  }
1132  }
1133  }
1134  }
1135 
1136  switch (yycount)
1137  {
1138 # define YYCASE_(N, S) \
1139  case N: \
1140  yyformat = S; \
1141  break
1142  YYCASE_(0, YY_("syntax error"));
1143  YYCASE_(1, YY_("syntax error, unexpected %s"));
1144  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1145  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1146  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1147  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1148 # undef YYCASE_
1149  }
1150 
1151  {
1152  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1153  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1154  return 2;
1155  yysize = yysize1;
1156  }
1157 
1158  if (*yymsg_alloc < yysize)
1159  {
1160  *yymsg_alloc = 2 * yysize;
1161  if (! (yysize <= *yymsg_alloc
1162  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1163  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1164  return 1;
1165  }
1166 
1167  /* Avoid sprintf, as that infringes on the user's name space.
1168  Don't have undefined behavior even if the translation
1169  produced a string with the wrong number of "%s"s. */
1170  {
1171  char *yyp = *yymsg;
1172  int yyi = 0;
1173  while ((*yyp = *yyformat) != '\0')
1174  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1175  {
1176  yyp += yytnamerr (yyp, yyarg[yyi++]);
1177  yyformat += 2;
1178  }
1179  else
1180  {
1181  yyp++;
1182  yyformat++;
1183  }
1184  }
1185  return 0;
1186 }
static const yytype_uint8 yytable[]
Definition: wql.tab.c:723
#define YY_(Msgid)