ReactOS  0.4.13-dev-92-gf251225
cond.tab.c File Reference
#include "config.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "msi.h"
#include "msiquery.h"
#include "objbase.h"
#include "oleauto.h"
#include "msipriv.h"
#include "msiserver.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "wine/list.h"
#include <stddef.h>
Include dependency graph for cond.tab.c:

Go to the source code of this file.

Classes

struct  tag_yyinput
 
struct  cond_str
 
union  value
 
union  YYSTYPE
 
union  yyalloc
 

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   cond_parse
 
#define yylex   cond_lex
 
#define yyerror   cond_error
 
#define yydebug   cond_debug
 
#define yynerrs   cond_nerrs
 
#define COBJMACROS
 
#define YY_NULL   0
 
#define YYERROR_VERBOSE   0
 
#define YY_COND_E_REACTOSSYNC_GCC_DLL_WIN32_MSI_COND_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   24
 
#define YYLAST   67
 
#define YYNTOKENS   41
 
#define YYNNTS   8
 
#define YYNRULES   41
 
#define YYNSTATES   56
 
#define YYUNDEFTOK   2
 
#define YYMAXUTOK   295
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -45
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-45)))
 
#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 YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 

Typedefs

typedef struct tag_yyinput COND_input
 
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,
  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 (msi)
 
static LPWSTR COND_GetString (COND_input *info, const struct cond_str *str)
 
static LPWSTR COND_GetLiteral (COND_input *info, const struct cond_str *str)
 
static int cond_lex (void *COND_lval, COND_input *info)
 
static int cond_error (COND_input *info, const char *str)
 
static voidcond_alloc (COND_input *cond, unsigned int sz)
 
static voidcond_track_mem (COND_input *cond, void *ptr, unsigned int sz)
 
static void cond_free (void *ptr)
 
static INT compare_int (INT a, INT operator, INT b)
 
static INT compare_string (LPCWSTR a, INT operator, LPCWSTR b, BOOL convert)
 
static BOOL num_from_prop (LPCWSTR p, INT *val)
 
static void value_free (struct value val)
 
int cond_parse (COND_input *info)
 
voidmalloc (YYSIZE_T)
 
void free (void *)
 
static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, COND_input *info)
 
int yyparse (COND_input *info)
 
static int COND_IsAlpha (WCHAR x)
 
static int COND_IsNumber (WCHAR x)
 
static WCHARstrstriW (const WCHAR *str, const WCHAR *sub)
 
static BOOL str_is_number (LPCWSTR str)
 
static INT compare_substring (LPCWSTR a, INT operator, LPCWSTR b)
 
static int COND_IsIdent (WCHAR x)
 
static int COND_GetOperator (COND_input *cond)
 
static int COND_GetOne (struct cond_str *str, COND_input *cond)
 
MSICONDITION MSI_EvaluateConditionW (MSIPACKAGE *package, LPCWSTR szCondition)
 
MSICONDITION WINAPI MsiEvaluateConditionW (MSIHANDLE hInstall, LPCWSTR szCondition)
 
MSICONDITION WINAPI MsiEvaluateConditionA (MSIHANDLE hInstall, LPCSTR szCondition)
 

Variables

static const yytype_uint8 yytranslate []
 
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 []
 

Macro Definition Documentation

◆ __attribute__

#define __attribute__ (   Spec)    /* empty */

Definition at line 351 of file cond.tab.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 94 of file cond.tab.c.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 343 of file cond.tab.c.

◆ YY_COND_E_REACTOSSYNC_GCC_DLL_WIN32_MSI_COND_TAB_H_INCLUDED

#define YY_COND_E_REACTOSSYNC_GCC_DLL_WIN32_MSI_COND_TAB_H_INCLUDED

Definition at line 208 of file cond.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

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

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 375 of file cond.tab.c.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 371 of file cond.tab.c.

◆ YY_NULL

#define YY_NULL   0

Definition at line 193 of file cond.tab.c.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 878 of file cond.tab.c.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 877 of file cond.tab.c.

◆ YY_SYMBOL_PRINT

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

Definition at line 876 of file cond.tab.c.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 722 of file cond.tab.c.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 721 of file cond.tab.c.

◆ YYBACKUP

#define YYBACKUP (   Token,
  Value 
)
Value:
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (info, YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2327
#define yychar
Definition: asmshader.tab.c:70
_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
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define YYEMPTY
Definition: cond.tab.c:718
#define YY_(Msgid)
Definition: cond.tab.c:343

Definition at line 728 of file cond.tab.c.

◆ YYBISON

#define YYBISON   1

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

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.0"

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

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 717 of file cond.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 498 of file cond.tab.c.

◆ YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 470 of file cond.tab.c.

◆ yydebug

#define yydebug   cond_debug

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

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 211 of file cond.tab.c.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 875 of file cond.tab.c.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 718 of file cond.tab.c.

◆ YYEOF

#define YYEOF   0

Definition at line 719 of file cond.tab.c.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 747 of file cond.tab.c.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 716 of file cond.tab.c.

◆ yyerror

#define yyerror   cond_error

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

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 723 of file cond.tab.c.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 202 of file cond.tab.c.

◆ YYFINAL

#define YYFINAL   24

Definition at line 511 of file cond.tab.c.

◆ YYFREE

#define YYFREE   free

Definition at line 441 of file cond.tab.c.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 884 of file cond.tab.c.

◆ YYLAST

#define YYLAST   67

Definition at line 513 of file cond.tab.c.

◆ yylex

#define yylex   cond_lex

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

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 435 of file cond.tab.c.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 895 of file cond.tab.c.

◆ YYMAXUTOK

#define YYMAXUTOK   295

Definition at line 527 of file cond.tab.c.

◆ yynerrs

#define yynerrs   cond_nerrs

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

◆ YYNNTS

#define YYNNTS   8

Definition at line 518 of file cond.tab.c.

◆ YYNRULES

#define YYNRULES   41

Definition at line 520 of file cond.tab.c.

◆ YYNSTATES

#define YYNSTATES   56

Definition at line 522 of file cond.tab.c.

◆ YYNTOKENS

#define YYNTOKENS   41

Definition at line 516 of file cond.tab.c.

◆ YYPACT_NINF

#define YYPACT_NINF   -45

Definition at line 611 of file cond.tab.c.

◆ yypact_value_is_default

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

Definition at line 613 of file cond.tab.c.

◆ yyparse

#define yyparse   cond_parse

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

◆ YYPOPSTACK

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

◆ YYPULL

#define YYPULL   1

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

◆ YYPURE

#define YYPURE   1

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

◆ YYPUSH

#define YYPUSH   0

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

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 726 of file cond.tab.c.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 333 of file cond.tab.c.

◆ YYSIZE_T

#define YYSIZE_T   size_t

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

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

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

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 421 of file cond.tab.c.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 424 of file cond.tab.c.

◆ YYSTACK_BYTES

#define YYSTACK_BYTES (   N)
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
union YYSTYPE YYSTYPE
Definition: cond.tab.c:265
short int yytype_int16
Definition: bidi.c:97
#define YYSTACK_GAP_MAXIMUM
Definition: cond.tab.c:462

Definition at line 466 of file cond.tab.c.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 422 of file cond.tab.c.

◆ YYSTACK_GAP_MAXIMUM

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

Definition at line 462 of file cond.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: cond.tab.c:462

Definition at line 477 of file cond.tab.c.

◆ YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

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

◆ YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 278 of file cond.tab.c.

◆ YYTABLE_NINF

#define YYTABLE_NINF   -1

Definition at line 616 of file cond.tab.c.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

Definition at line 618 of file cond.tab.c.

◆ YYTERROR

#define YYTERROR   1

Definition at line 746 of file cond.tab.c.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 219 of file cond.tab.c.

◆ YYTRANSLATE

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

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

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 526 of file cond.tab.c.

◆ YYUSE

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

Definition at line 357 of file cond.tab.c.

Typedef Documentation

◆ COND_input

◆ YYSTYPE

typedef union YYSTYPE YYSTYPE

Definition at line 265 of file cond.tab.c.

◆ yytype_int16

Definition at line 317 of file cond.tab.c.

◆ yytype_int8

Definition at line 305 of file cond.tab.c.

◆ yytype_uint16

typedef unsigned short int yytype_uint16

Definition at line 311 of file cond.tab.c.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 299 of file cond.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 
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 220 of file cond.tab.c.

221  {
222  COND_SPACE = 258,
223  COND_EOF = 259,
224  COND_OR = 260,
225  COND_AND = 261,
226  COND_NOT = 262,
227  COND_XOR = 263,
228  COND_IMP = 264,
229  COND_EQV = 265,
230  COND_LT = 266,
231  COND_GT = 267,
232  COND_EQ = 268,
233  COND_NE = 269,
234  COND_GE = 270,
235  COND_LE = 271,
236  COND_ILT = 272,
237  COND_IGT = 273,
238  COND_IEQ = 274,
239  COND_INE = 275,
240  COND_IGE = 276,
241  COND_ILE = 277,
242  COND_LPAR = 278,
243  COND_RPAR = 279,
244  COND_TILDA = 280,
245  COND_SS = 281,
246  COND_ISS = 282,
247  COND_ILHS = 283,
248  COND_IRHS = 284,
249  COND_LHS = 285,
250  COND_RHS = 286,
251  COND_PERCENT = 287,
252  COND_DOLLARS = 288,
253  COND_QUESTION = 289,
254  COND_AMPER = 290,
255  COND_EXCLAM = 291,
256  COND_IDENT = 292,
257  COND_NUMBER = 293,
258  COND_LITER = 294,
259  COND_ERROR = 295
260  };

Function Documentation

◆ compare_int()

static INT compare_int ( INT  a,
INT  operator,
INT  b 
)
static

Definition at line 2179 of file cond.tab.c.

2180 {
2181  switch (operator)
2182  {
2183  case COND_LT:
2184  case COND_ILT:
2185  return a < b;
2186  case COND_GT:
2187  case COND_IGT:
2188  return a > b;
2189  case COND_EQ:
2190  case COND_IEQ:
2191  return a == b;
2192  case COND_NE:
2193  case COND_INE:
2194  return a != b;
2195  case COND_GE:
2196  case COND_IGE:
2197  return a >= b;
2198  case COND_LE:
2199  case COND_ILE:
2200  return a <= b;
2201  case COND_SS:
2202  case COND_ISS:
2203  return ( a & b ) ? 1 : 0;
2204  case COND_RHS:
2205  return ( ( a & 0xffff ) == b ) ? 1 : 0;
2206  case COND_LHS:
2207  return ( ( (a>>16) & 0xffff ) == b ) ? 1 : 0;
2208  default:
2209  ERR("invalid integer operator\n");
2210  return 0;
2211  }
2212  return 0;
2213 }
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define ERR(fmt,...)
Definition: debug.h:109
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

Referenced by compare_string(), compare_substring(), and yyparse().

◆ compare_string()

static INT compare_string ( LPCWSTR  a,
INT  operator,
LPCWSTR  b,
BOOL  convert 
)
static

Definition at line 2132 of file cond.tab.c.

2133 {
2134  if (operator >= COND_SS && operator <= COND_RHS)
2135  return compare_substring( a, operator, b );
2136 
2137  /* null and empty string are equivalent */
2138  if (!a) a = szEmpty;
2139  if (!b) b = szEmpty;
2140 
2141  if (convert && str_is_number(a) && str_is_number(b))
2142  return compare_int( atoiW(a), operator, atoiW(b) );
2143 
2144  /* a or b may be NULL */
2145  switch (operator)
2146  {
2147  case COND_LT:
2148  return strcmpW( a, b ) < 0;
2149  case COND_GT:
2150  return strcmpW( a, b ) > 0;
2151  case COND_EQ:
2152  return strcmpW( a, b ) == 0;
2153  case COND_NE:
2154  return strcmpW( a, b ) != 0;
2155  case COND_GE:
2156  return strcmpW( a, b ) >= 0;
2157  case COND_LE:
2158  return strcmpW( a, b ) <= 0;
2159  case COND_ILT:
2160  return strcmpiW( a, b ) < 0;
2161  case COND_IGT:
2162  return strcmpiW( a, b ) > 0;
2163  case COND_IEQ:
2164  return strcmpiW( a, b ) == 0;
2165  case COND_INE:
2166  return strcmpiW( a, b ) != 0;
2167  case COND_IGE:
2168  return strcmpiW( a, b ) >= 0;
2169  case COND_ILE:
2170  return strcmpiW( a, b ) <= 0;
2171  default:
2172  ERR("invalid string operator\n");
2173  return 0;
2174  }
2175  return 0;
2176 }
static INT compare_int(INT a, INT operator, INT b)
Definition: cond.tab.c:2179
static BOOL str_is_number(LPCWSTR str)
Definition: cond.tab.c:2059
static const WCHAR szEmpty[]
Definition: provider.c:47
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
int convert
Definition: msacm.c:1362
#define strcmpiW(s1, s2)
Definition: unicode.h:39
#define ERR(fmt,...)
Definition: debug.h:109
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: unicode.h:229
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
WINE_UNICODE_INLINE int atoiW(const WCHAR *str)
Definition: unicode.h:315
static INT compare_substring(LPCWSTR a, INT operator, LPCWSTR b)
Definition: cond.tab.c:2073

Referenced by yyparse().

◆ compare_substring()

static INT compare_substring ( LPCWSTR  a,
INT  operator,
LPCWSTR  b 
)
static

Definition at line 2073 of file cond.tab.c.

2074 {
2075  int lhs, rhs;
2076 
2077  /* substring operators return 0 if LHS is missing */
2078  if (!a || !*a)
2079  return 0;
2080 
2081  /* substring operators return 1 if RHS is missing */
2082  if (!b || !*b)
2083  return 1;
2084 
2085  /* if both strings contain only numbers, use integer comparison */
2086  lhs = atoiW(a);
2087  rhs = atoiW(b);
2088  if (str_is_number(a) && str_is_number(b))
2089  return compare_int( lhs, operator, rhs );
2090 
2091  switch (operator)
2092  {
2093  case COND_SS:
2094  return strstrW( a, b ) != 0;
2095  case COND_ISS:
2096  return strstriW( a, b ) != 0;
2097  case COND_LHS:
2098  {
2099  int l = strlenW( a );
2100  int r = strlenW( b );
2101  if (r > l) return 0;
2102  return !strncmpW( a, b, r );
2103  }
2104  case COND_RHS:
2105  {
2106  int l = strlenW( a );
2107  int r = strlenW( b );
2108  if (r > l) return 0;
2109  return !strncmpW( a + (l - r), b, r );
2110  }
2111  case COND_ILHS:
2112  {
2113  int l = strlenW( a );
2114  int r = strlenW( b );
2115  if (r > l) return 0;
2116  return !strncmpiW( a, b, r );
2117  }
2118  case COND_IRHS:
2119  {
2120  int l = strlenW( a );
2121  int r = strlenW( b );
2122  if (r > l) return 0;
2123  return !strncmpiW( a + (l - r), b, r );
2124  }
2125  default:
2126  ERR("invalid substring operator\n");
2127  return 0;
2128  }
2129  return 0;
2130 }
static INT compare_int(INT a, INT operator, INT b)
Definition: cond.tab.c:2179
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static BOOL str_is_number(LPCWSTR str)
Definition: cond.tab.c:2059
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
Definition: unicode.h:235
#define strstrW(d, s)
Definition: unicode.h:32
static WCHAR * strstriW(const WCHAR *str, const WCHAR *sub)
Definition: cond.tab.c:2046
r l[0]
Definition: byte_order.h:167
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define ERR(fmt,...)
Definition: debug.h:109
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
WINE_UNICODE_INLINE int atoiW(const WCHAR *str)
Definition: unicode.h:315

Referenced by compare_string().

◆ cond_alloc()

static void * cond_alloc ( COND_input cond,
unsigned int  sz 
)
static

Definition at line 2394 of file cond.tab.c.

2395 {
2396  struct list *mem;
2397 
2398  mem = msi_alloc( sizeof (struct list) + sz );
2399  if( !mem )
2400  return NULL;
2401 
2402  list_add_head( &(cond->mem), mem );
2403  return mem + 1;
2404 }
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
smooth NULL
Definition: ftsmooth.c:416
struct list mem
Definition: cond.tab.c:124
Definition: _list.h:228
Definition: mem.c:156
static void * msi_alloc(size_t len) __WINE_ALLOC_SIZE(1)
Definition: msipriv.h:1204

Referenced by COND_GetLiteral(), COND_GetString(), cond_track_mem(), and yyparse().

◆ cond_error()

static int cond_error ( COND_input info,
const char str 
)
static

Definition at line 2436 of file cond.tab.c.

2437 {
2438  TRACE("%s\n", str );
2439  return 0;
2440 }
const WCHAR * str
#define TRACE(s)
Definition: solgame.cpp:4

◆ cond_free()

static void cond_free ( void ptr)
static

Definition at line 2425 of file cond.tab.c.

2426 {
2427  struct list *mem = (struct list *)ptr - 1;
2428 
2429  if( ptr )
2430  {
2431  list_remove( mem );
2432  msi_free( mem );
2433  }
2434 }
static PVOID ptr
Definition: dispmode.c:27
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
Definition: _list.h:228
Definition: mem.c:156
static BOOL msi_free(void *mem)
Definition: msipriv.h:1227

Referenced by MSI_EvaluateConditionW(), value_free(), and yyparse().

◆ COND_GetLiteral()

static LPWSTR COND_GetLiteral ( COND_input info,
const struct cond_str str 
)
static

Definition at line 2380 of file cond.tab.c.

2381 {
2382  LPWSTR ret;
2383 
2384  ret = cond_alloc( cond, (str->len-1) * sizeof (WCHAR) );
2385  if( ret )
2386  {
2387  memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
2388  ret[str->len - 2]=0;
2389  }
2390  TRACE("Got literal %s\n",debugstr_w(ret));
2391  return ret;
2392 }
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
static void * cond_alloc(COND_input *cond, unsigned int sz)
Definition: cond.tab.c:2394
#define debugstr_w
Definition: kernel32.h:32
const WCHAR * str
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by yyparse().

◆ COND_GetOne()

static int COND_GetOne ( struct cond_str str,
COND_input cond 
)
static

Definition at line 2261 of file cond.tab.c.

2262 {
2263  int rc, len = 1;
2264  WCHAR ch;
2265 
2266  str->data = &cond->str[cond->n];
2267 
2268  ch = str->data[0];
2269 
2270  switch( ch )
2271  {
2272  case 0: return 0;
2273  case '(': rc = COND_LPAR; break;
2274  case ')': rc = COND_RPAR; break;
2275  case '&': rc = COND_AMPER; break;
2276  case '!': rc = COND_EXCLAM; break;
2277  case '$': rc = COND_DOLLARS; break;
2278  case '?': rc = COND_QUESTION; break;
2279  case '%': rc = COND_PERCENT; break;
2280  case ' ': rc = COND_SPACE; break;
2281  case '=': rc = COND_EQ; break;
2282 
2283  case '~':
2284  case '<':
2285  case '>':
2286  rc = COND_GetOperator( cond );
2287  if (!rc)
2288  rc = COND_ERROR;
2289  return rc;
2290  default:
2291  rc = 0;
2292  }
2293 
2294  if ( rc )
2295  {
2296  cond->n += len;
2297  return rc;
2298  }
2299 
2300  if (ch == '"' )
2301  {
2302  LPCWSTR p = strchrW( str->data + 1, '"' );
2303  if (!p) return COND_ERROR;
2304  len = p - str->data + 1;
2305  rc = COND_LITER;
2306  }
2307  else if( COND_IsAlpha( ch ) )
2308  {
2309  static const WCHAR szNot[] = {'N','O','T',0};
2310  static const WCHAR szAnd[] = {'A','N','D',0};
2311  static const WCHAR szXor[] = {'X','O','R',0};
2312  static const WCHAR szEqv[] = {'E','Q','V',0};
2313  static const WCHAR szImp[] = {'I','M','P',0};
2314  static const WCHAR szOr[] = {'O','R',0};
2315 
2316  while( COND_IsIdent( str->data[len] ) )
2317  len++;
2318  rc = COND_IDENT;
2319 
2320  if ( len == 3 )
2321  {
2322  if ( !strncmpiW( str->data, szNot, len ) )
2323  rc = COND_NOT;
2324  else if( !strncmpiW( str->data, szAnd, len ) )
2325  rc = COND_AND;
2326  else if( !strncmpiW( str->data, szXor, len ) )
2327  rc = COND_XOR;
2328  else if( !strncmpiW( str->data, szEqv, len ) )
2329  rc = COND_EQV;
2330  else if( !strncmpiW( str->data, szImp, len ) )
2331  rc = COND_IMP;
2332  }
2333  else if( (len == 2) && !strncmpiW( str->data, szOr, len ) )
2334  rc = COND_OR;
2335  }
2336  else if( COND_IsNumber( ch ) )
2337  {
2338  while( COND_IsNumber( str->data[len] ) )
2339  len++;
2340  rc = COND_NUMBER;
2341  }
2342  else
2343  {
2344  ERR("Got unknown character %c(%x)\n",ch,ch);
2345  return COND_ERROR;
2346  }
2347 
2348  cond->n += len;
2349  str->len = len;
2350 
2351  return rc;
2352 }
static int COND_IsAlpha(WCHAR x)
Definition: cond.tab.c:2034
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:248
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
static int COND_IsNumber(WCHAR x)
Definition: cond.tab.c:2041
static int COND_IsIdent(WCHAR x)
Definition: cond.tab.c:2216
const WCHAR * str
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLenum GLsizei len
Definition: glext.h:6722
#define ERR(fmt,...)
Definition: debug.h:109
static int COND_GetOperator(COND_input *cond)
Definition: cond.tab.c:2222
LPCWSTR str
Definition: cond.tab.c:121
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by cond_lex().

◆ COND_GetOperator()

static int COND_GetOperator ( COND_input cond)
static

Definition at line 2222 of file cond.tab.c.

2223 {
2224  static const struct {
2225  const WCHAR str[4];
2226  int id;
2227  } table[] = {
2228  { {'~','<','=',0}, COND_ILE },
2229  { {'~','>','<',0}, COND_ISS },
2230  { {'~','>','>',0}, COND_IRHS },
2231  { {'~','<','>',0}, COND_INE },
2232  { {'~','>','=',0}, COND_IGE },
2233  { {'~','<','<',0}, COND_ILHS },
2234  { {'~','=',0}, COND_IEQ },
2235  { {'~','<',0}, COND_ILT },
2236  { {'~','>',0}, COND_IGT },
2237  { {'>','=',0}, COND_GE },
2238  { {'>','<',0}, COND_SS },
2239  { {'<','<',0}, COND_LHS },
2240  { {'<','>',0}, COND_NE },
2241  { {'<','=',0}, COND_LE },
2242  { {'>','>',0}, COND_RHS },
2243  { {'>',0}, COND_GT },
2244  { {'<',0}, COND_LT },
2245  { {0}, 0 }
2246  };
2247  LPCWSTR p = &cond->str[cond->n];
2248  int i = 0, len;
2249 
2250  while ( 1 )
2251  {
2252  len = lstrlenW( table[i].str );
2253  if ( !len || 0 == strncmpW( table[i].str, p, len ) )
2254  break;
2255  i++;
2256  }
2257  cond->n += len;
2258  return table[i].id;
2259 }
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define lstrlenW
Definition: compat.h:407
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
Definition: unicode.h:235
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 * str
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLenum GLsizei len
Definition: glext.h:6722
LPCWSTR str
Definition: cond.tab.c:121
GLenum GLuint id
Definition: glext.h:5579
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by COND_GetOne().

◆ COND_GetString()

static LPWSTR COND_GetString ( COND_input info,
const struct cond_str str 
)
static

Definition at line 2366 of file cond.tab.c.

2367 {
2368  LPWSTR ret;
2369 
2370  ret = cond_alloc( cond, (str->len+1) * sizeof (WCHAR) );
2371  if( ret )
2372  {
2373  memcpy( ret, str->data, str->len * sizeof(WCHAR));
2374  ret[str->len]=0;
2375  }
2376  TRACE("Got identifier %s\n",debugstr_w(ret));
2377  return ret;
2378 }
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
static void * cond_alloc(COND_input *cond, unsigned int sz)
Definition: cond.tab.c:2394
#define debugstr_w
Definition: kernel32.h:32
const WCHAR * str
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by yyparse().

◆ COND_IsAlpha()

static int COND_IsAlpha ( WCHAR  x)
static

Definition at line 2034 of file cond.tab.c.

2035 {
2036  return( ( ( x >= 'A' ) && ( x <= 'Z' ) ) ||
2037  ( ( x >= 'a' ) && ( x <= 'z' ) ) ||
2038  ( ( x == '_' ) ) );
2039 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

Referenced by COND_GetOne(), and COND_IsIdent().

◆ COND_IsIdent()

static int COND_IsIdent ( WCHAR  x)
static

Definition at line 2216 of file cond.tab.c.

2217 {
2218  return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' )
2219  || ( x == '#' ) || (x == '.') );
2220 }
static int COND_IsAlpha(WCHAR x)
Definition: cond.tab.c:2034
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
static int COND_IsNumber(WCHAR x)
Definition: cond.tab.c:2041

Referenced by COND_GetOne().

◆ COND_IsNumber()

static int COND_IsNumber ( WCHAR  x)
static

Definition at line 2041 of file cond.tab.c.

2042 {
2043  return( (( x >= '0' ) && ( x <= '9' )) || (x =='-') || (x =='.') );
2044 }
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

Referenced by COND_GetOne(), and COND_IsIdent().

◆ cond_lex()

static int cond_lex ( void COND_lval,
COND_input info 
)
static

Definition at line 2354 of file cond.tab.c.

2355 {
2356  int rc;
2357  struct cond_str *str = COND_lval;
2358 
2359  do {
2360  rc = COND_GetOne( str, cond );
2361  } while (rc == COND_SPACE);
2362 
2363  return rc;
2364 }
static int COND_GetOne(struct cond_str *str, COND_input *cond)
Definition: cond.tab.c:2261
const WCHAR * str

◆ cond_parse()

int cond_parse ( COND_input info)

Referenced by MSI_EvaluateConditionW().

◆ cond_track_mem()

static void * cond_track_mem ( COND_input cond,
void ptr,
unsigned int  sz 
)
static

Definition at line 2406 of file cond.tab.c.

2407 {
2408  void *new_ptr;
2409 
2410  if( !ptr )
2411  return ptr;
2412 
2413  new_ptr = cond_alloc( cond, sz );
2414  if( !new_ptr )
2415  {
2416  msi_free( ptr );
2417  return NULL;
2418  }
2419 
2420  memcpy( new_ptr, ptr, sz );
2421  msi_free( ptr );
2422  return new_ptr;
2423 }
static void * cond_alloc(COND_input *cond, unsigned int sz)
Definition: cond.tab.c:2394
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static BOOL msi_free(void *mem)
Definition: msipriv.h:1227

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:603
static PVOID ptr
Definition: dispmode.c:27
HANDLE ProcessHeap
Definition: servman.c:15

◆ malloc()

void* malloc ( YYSIZE_T  )

◆ MSI_EvaluateConditionW()

MSICONDITION MSI_EvaluateConditionW ( MSIPACKAGE package,
LPCWSTR  szCondition 
)

Definition at line 2442 of file cond.tab.c.

2443 {
2444  COND_input cond;
2445  MSICONDITION r;
2446  struct list *mem, *safety;
2447 
2448  TRACE("%s\n", debugstr_w( szCondition ) );
2449 
2450  if (szCondition == NULL) return MSICONDITION_NONE;
2451 
2452  cond.package = package;
2453  cond.str = szCondition;
2454  cond.n = 0;
2455  cond.result = MSICONDITION_ERROR;
2456 
2457  list_init( &cond.mem );
2458 
2459  if ( !cond_parse( &cond ) )
2460  r = cond.result;
2461  else
2463 
2464  LIST_FOR_EACH_SAFE( mem, safety, &cond.mem )
2465  {
2466  /* The tracked memory lives directly after the list struct */
2467  void *ptr = mem + 1;
2468  if ( r != MSICONDITION_ERROR )
2469  WARN( "condition parser failed to free up some memory: %p\n", ptr );
2470  cond_free( ptr );
2471  }
2472 
2473  TRACE("%i <- %s\n", r, debugstr_w(szCondition));
2474  return r;
2475 }
#define LIST_FOR_EACH_SAFE(cursor, cursor2, list)
Definition: list.h:192
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define WARN(fmt,...)
Definition: debug.h:111
int cond_parse(COND_input *info)
#define debugstr_w
Definition: kernel32.h:32
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
MSICONDITION result
Definition: cond.tab.c:123
#define TRACE(s)
Definition: solgame.cpp:4
struct list mem
Definition: cond.tab.c:124
MSIPACKAGE * package
Definition: cond.tab.c:120
int MSICONDITION
Definition: msiserver.idl:33
Definition: _list.h:228
static void cond_free(void *ptr)
Definition: cond.tab.c:2425
LPCWSTR str
Definition: cond.tab.c:121
Definition: mem.c:156
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149

Referenced by ACTION_CostFinalize(), ACTION_PerformActionSequence(), ITERATE_Actions(), ITERATE_CostFinalizeConditions(), ITERATE_LaunchConditions(), msi_dialog_control_event(), msi_dialog_set_control_condition(), and MsiEvaluateConditionW().

◆ MsiEvaluateConditionA()

MSICONDITION WINAPI MsiEvaluateConditionA ( MSIHANDLE  hInstall,
LPCSTR  szCondition 
)

Definition at line 2521 of file cond.tab.c.

2522 {
2523  LPWSTR szwCond = NULL;
2524  MSICONDITION r;
2525 
2526  szwCond = strdupAtoW( szCondition );
2527  if( szCondition && !szwCond )
2528  return MSICONDITION_ERROR;
2529 
2530  r = MsiEvaluateConditionW( hInstall, szwCond );
2531  msi_free( szwCond );
2532  return r;
2533 }
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
MSICONDITION WINAPI MsiEvaluateConditionW(MSIHANDLE hInstall, LPCWSTR szCondition)
Definition: cond.tab.c:2477
smooth NULL
Definition: ftsmooth.c:416
int MSICONDITION
Definition: msiserver.idl:33
static BOOL msi_free(void *mem)
Definition: msipriv.h:1227
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static WCHAR * strdupAtoW(const char *str)
Definition: main.c:67

Referenced by test_condition().

◆ MsiEvaluateConditionW()

MSICONDITION WINAPI MsiEvaluateConditionW ( MSIHANDLE  hInstall,
LPCWSTR  szCondition 
)

Definition at line 2477 of file cond.tab.c.

2478 {
2479  MSIPACKAGE *package;
2480  UINT ret;
2481 
2482  package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
2483  if( !package )
2484  {
2485  HRESULT hr;
2486  BSTR condition;
2487  IWineMsiRemotePackage *remote_package;
2488 
2489  remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
2490  if (!remote_package)
2491  return MSICONDITION_ERROR;
2492 
2493  condition = SysAllocString( szCondition );
2494  if (!condition)
2495  {
2496  IWineMsiRemotePackage_Release( remote_package );
2497  return ERROR_OUTOFMEMORY;
2498  }
2499 
2500  hr = IWineMsiRemotePackage_EvaluateCondition( remote_package, condition );
2501 
2503  IWineMsiRemotePackage_Release( remote_package );
2504 
2505  if (FAILED(hr))
2506  {
2508  return HRESULT_CODE(hr);
2509 
2510  return ERROR_FUNCTION_FAILED;
2511  }
2512 
2513  return ERROR_SUCCESS;
2514  }
2515 
2516  ret = MSI_EvaluateConditionW( package, szCondition );
2517  msiobj_release( &package->hdr );
2518  return ret;
2519 }
#define ERROR_SUCCESS
Definition: deptool.c:10
HRESULT hr
Definition: shlfolder.c:183
MSIOBJECTHDR hdr
Definition: msipriv.h:385
OLECHAR * BSTR
Definition: compat.h:1934
#define ERROR_FUNCTION_FAILED
Definition: winerror.h:985
#define HRESULT_FACILITY(hr)
Definition: winerror.h:79
GLenum condition
Definition: glext.h:9255
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:241
LONG HRESULT
Definition: typedefs.h:77
int msiobj_release(MSIOBJECTHDR *info)
Definition: handle.c:242
int ret
#define FACILITY_WIN32
Definition: winerror.h:27
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:274
unsigned int UINT
Definition: ndis.h:50
#define HRESULT_CODE(hr)
Definition: winerror.h:76
MSICONDITION MSI_EvaluateConditionW(MSIPACKAGE *package, LPCWSTR szCondition)
Definition: cond.tab.c:2442
IUnknown * msi_get_remote(MSIHANDLE handle)
Definition: handle.c:182
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

Referenced by mrp_EvaluateCondition(), MsiEvaluateConditionA(), session_invoke(), and test_condition().

◆ num_from_prop()

static BOOL num_from_prop ( LPCWSTR  p,
INT val 
)
static

Definition at line 156 of file cond.tab.c.

157 {
158  INT ret = 0, sign = 1;
159 
160  if (!p)
161  return FALSE;
162  if (*p == '-')
163  {
164  sign = -1;
165  p++;
166  }
167  if (!*p)
168  return FALSE;
169  while (*p)
170  {
171  if( *p < '0' || *p > '9' )
172  return FALSE;
173  ret = ret*10 + (*p - '0');
174  p++;
175  }
176  *val = ret*sign;
177  return TRUE;
178 }
static size_t double int int int * sign
Definition: printf.c:64
#define TRUE
Definition: types.h:120
int32_t INT
Definition: typedefs.h:56
GLuint GLfloat * val
Definition: glext.h:7180
int ret
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by yyparse().

◆ str_is_number()

static BOOL str_is_number ( LPCWSTR  str)
static

Definition at line 2059 of file cond.tab.c.

2060 {
2061  int i;
2062 
2063  if (!*str)
2064  return FALSE;
2065 
2066  for (i = 0; i < lstrlenW( str ); i++)
2067  if (!isdigitW(str[i]))
2068  return FALSE;
2069 
2070  return TRUE;
2071 }
#define TRUE
Definition: types.h:120
#define lstrlenW
Definition: compat.h:407
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 * str
WINE_UNICODE_INLINE int isdigitW(WCHAR wc)
Definition: unicode.h:170

Referenced by compare_string(), and compare_substring().

◆ strstriW()

static WCHAR* strstriW ( const WCHAR str,
const WCHAR sub 
)
static

Definition at line 2046 of file cond.tab.c.

2047 {
2048  LPWSTR strlower, sublower, r;
2049  strlower = CharLowerW( strdupW( str ) );
2050  sublower = CharLowerW( strdupW( sub ) );
2051  r = strstrW( strlower, sublower );
2052  if (r)
2053  r = (LPWSTR)str + (r - strlower);
2054  msi_free( strlower );
2055  msi_free( sublower );
2056  return r;
2057 }
static WCHAR * strdupW(const WCHAR *src)
Definition: main.c:92
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
LPWSTR WINAPI CharLowerW(_Inout_ LPWSTR)
const WCHAR * str
#define strstrW(d, s)
Definition: unicode.h:32
static BOOL msi_free(void *mem)
Definition: msipriv.h:1227
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by compare_substring().

◆ value_free()

static void value_free ( struct value  val)
static

Definition at line 180 of file cond.tab.c.

181 {
182  if (val.type != VALUE_INTEGER)
183  cond_free( val.u.string );
184 }
GLuint GLfloat * val
Definition: glext.h:7180
static void cond_free(void *ptr)
Definition: cond.tab.c:2425

Referenced by yyparse().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( msi  )

◆ yydestruct()

static void yydestruct ( const char yymsg,
int  yytype,
YYSTYPE yyvaluep,
COND_input info 
)
static

Definition at line 1126 of file cond.tab.c.

1127 {
1128  YYUSE (yyvaluep);
1129  YYUSE (info);
1130  if (!yymsg)
1131  yymsg = "Deleting";
1132  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1133 
1135  YYUSE (yytype);
1137 }
#define YYUSE(E)
Definition: cond.tab.c:357
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: cond.tab.c:375
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: cond.tab.c:876
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: cond.tab.c:374

Referenced by yyparse().

◆ yyparse()

int yyparse ( COND_input info)

Definition at line 1147 of file cond.tab.c.

1148 {
1149 /* The lookahead symbol. */
1150 int yychar;
1151 
1152 
1153 /* The semantic value of the lookahead symbol. */
1154 /* Default value used for initialization, for pacifying older GCCs
1155  or non-GCC compilers. */
1156 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1157 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1158 
1159  /* Number of syntax errors so far. */
1160  int yynerrs;
1161 
1162  int yystate;
1163  /* Number of tokens to shift before error messages enabled. */
1164  int yyerrstatus;
1165 
1166  /* The stacks and their tools:
1167  'yyss': related to states.
1168  'yyvs': related to semantic values.
1169 
1170  Refer to the stacks through separate pointers, to allow yyoverflow
1171  to reallocate them elsewhere. */
1172 
1173  /* The state stack. */
1174  yytype_int16 yyssa[YYINITDEPTH];
1175  yytype_int16 *yyss;
1176  yytype_int16 *yyssp;
1177 
1178  /* The semantic value stack. */
1179  YYSTYPE yyvsa[YYINITDEPTH];
1180  YYSTYPE *yyvs;
1181  YYSTYPE *yyvsp;
1182 
1183  YYSIZE_T yystacksize;
1184 
1185  int yyn;
1186  int yyresult;
1187  /* Lookahead token as an internal (translated) token number. */
1188  int yytoken = 0;
1189  /* The variables used to return semantic value and location from the
1190  action routines. */
1191  YYSTYPE yyval;
1192 
1193 #if YYERROR_VERBOSE
1194  /* Buffer for error messages, and its allocated size. */
1195  char yymsgbuf[128];
1196  char *yymsg = yymsgbuf;
1197  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1198 #endif
1199 
1200 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1201 
1202  /* The number of symbols on the RHS of the reduced rule.
1203  Keep to zero when no symbol should be popped. */
1204  int yylen = 0;
1205 
1206  yyssp = yyss = yyssa;
1207  yyvsp = yyvs = yyvsa;
1208  yystacksize = YYINITDEPTH;
1209 
1210  YYDPRINTF ((stderr, "Starting parse\n"));
1211 
1212  yystate = 0;
1213  yyerrstatus = 0;
1214  yynerrs = 0;
1215  yychar = YYEMPTY; /* Cause a token to be read. */
1216  goto yysetstate;
1217 
1218 /*------------------------------------------------------------.
1219 | yynewstate -- Push a new state, which is found in yystate. |
1220 `------------------------------------------------------------*/
1221  yynewstate:
1222  /* In all cases, when you get here, the value and location stacks
1223  have just been pushed. So pushing a state here evens the stacks. */
1224  yyssp++;
1225 
1226  yysetstate:
1227  *yyssp = yystate;
1228 
1229  if (yyss + yystacksize - 1 <= yyssp)
1230  {
1231  /* Get the current used size of the three stacks, in elements. */
1232  YYSIZE_T yysize = yyssp - yyss + 1;
1233 
1234 #ifdef yyoverflow
1235  {
1236  /* Give user a chance to reallocate the stack. Use copies of
1237  these so that the &'s don't force the real ones into
1238  memory. */
1239  YYSTYPE *yyvs1 = yyvs;
1240  yytype_int16 *yyss1 = yyss;
1241 
1242  /* Each stack pointer address is followed by the size of the
1243  data in use in that stack, in bytes. This used to be a
1244  conditional around just the two extra args, but that might
1245  be undefined if yyoverflow is a macro. */
1246  yyoverflow (YY_("memory exhausted"),
1247  &yyss1, yysize * sizeof (*yyssp),
1248  &yyvs1, yysize * sizeof (*yyvsp),
1249  &yystacksize);
1250 
1251  yyss = yyss1;
1252  yyvs = yyvs1;
1253  }
1254 #else /* no yyoverflow */
1255 # ifndef YYSTACK_RELOCATE
1256  goto yyexhaustedlab;
1257 # else
1258  /* Extend the stack our own way. */
1259  if (YYMAXDEPTH <= yystacksize)
1260  goto yyexhaustedlab;
1261  yystacksize *= 2;
1262  if (YYMAXDEPTH < yystacksize)
1263  yystacksize = YYMAXDEPTH;
1264 
1265  {
1266  yytype_int16 *yyss1 = yyss;
1267  union yyalloc *yyptr =
1268  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1269  if (! yyptr)
1270  goto yyexhaustedlab;
1271  YYSTACK_RELOCATE (yyss_alloc, yyss);
1272  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1273 # undef YYSTACK_RELOCATE
1274  if (yyss1 != yyssa)
1275  YYSTACK_FREE (yyss1);
1276  }
1277 # endif
1278 #endif /* no yyoverflow */
1279 
1280  yyssp = yyss + yysize - 1;
1281  yyvsp = yyvs + yysize - 1;
1282 
1283  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1284  (unsigned long int) yystacksize));
1285 
1286  if (yyss + yystacksize - 1 <= yyssp)
1287  YYABORT;
1288  }
1289 
1290  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1291 
1292  if (yystate == YYFINAL)
1293  YYACCEPT;
1294 
1295  goto yybackup;
1296 
1297 /*-----------.
1298 | yybackup. |
1299 `-----------*/
1300 yybackup:
1301 
1302  /* Do appropriate processing given the current state. Read a
1303  lookahead token if we need one and don't already have one. */
1304 
1305  /* First try to decide what to do without reference to lookahead token. */
1306  yyn = yypact[yystate];
1307  if (yypact_value_is_default (yyn))
1308  goto yydefault;
1309 
1310  /* Not known => get a lookahead token if don't already have one. */
1311 
1312  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1313  if (yychar == YYEMPTY)
1314  {
1315  YYDPRINTF ((stderr, "Reading a token: "));
1316  yychar = yylex (&yylval, info);
1317  }
1318 
1319  if (yychar <= YYEOF)
1320  {
1321  yychar = yytoken = YYEOF;
1322  YYDPRINTF ((stderr, "Now at end of input.\n"));
1323  }
1324  else
1325  {
1326  yytoken = YYTRANSLATE (yychar);
1327  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1328  }
1329 
1330  /* If the proper action on seeing token YYTOKEN is to reduce or to
1331  detect an error, take that action. */
1332  yyn += yytoken;
1333  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1334  goto yydefault;
1335  yyn = yytable[yyn];
1336  if (yyn <= 0)
1337  {
1338  if (yytable_value_is_error (yyn))
1339  goto yyerrlab;
1340  yyn = -yyn;
1341  goto yyreduce;
1342  }
1343 
1344  /* Count tokens shifted since error; after three, turn off error
1345  status. */
1346  if (yyerrstatus)
1347  yyerrstatus--;
1348 
1349  /* Shift the lookahead token. */
1350  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1351 
1352  /* Discard the shifted token. */
1353  yychar = YYEMPTY;
1354 
1355  yystate = yyn;
1357  *++yyvsp = yylval;
1359 
1360  goto yynewstate;
1361 
1362 
1363 /*-----------------------------------------------------------.
1364 | yydefault -- do the default action for the current state. |
1365 `-----------------------------------------------------------*/
1366 yydefault:
1367  yyn = yydefact[yystate];
1368  if (yyn == 0)
1369  goto yyerrlab;
1370  goto yyreduce;
1371 
1372 
1373 /*-----------------------------.
1374 | yyreduce -- Do a reduction. |
1375 `-----------------------------*/
1376 yyreduce:
1377  /* yyn is the number of a rule to reduce with. */
1378  yylen = yyr2[yyn];
1379 
1380  /* If YYLEN is nonzero, implement the default value of the action:
1381  '$$ = $1'.
1382 
1383  Otherwise, the following line sets YYVAL to garbage.
1384  This behavior is undocumented and Bison
1385  users should not rely upon it. Assigning to YYVAL
1386  unconditionally makes the parser a bit smaller, and it avoids a
1387  GCC warning that YYVAL may be used uninitialized. */
1388  yyval = yyvsp[1-yylen];
1389 
1390 
1391  YY_REDUCE_PRINT (yyn);
1392  switch (yyn)
1393  {
1394  case 2:
1395 #line 150 "cond.y" /* yacc.c:1646 */
1396  {
1397  COND_input* cond = (COND_input*) info;
1398  cond->result = (yyvsp[0].bool);
1399  }
1400 #line 1401 "cond.tab.c" /* yacc.c:1646 */
1401  break;
1402 
1403  case 3:
1404 #line 155 "cond.y" /* yacc.c:1646 */
1405  {
1406  COND_input* cond = (COND_input*) info;
1407  cond->result = MSICONDITION_NONE;
1408  }
1409 #line 1410 "cond.tab.c" /* yacc.c:1646 */
1410  break;
1411 
1412  case 4:
1413 #line 163 "cond.y" /* yacc.c:1646 */
1414  {
1415  (yyval.bool) = (yyvsp[0].bool);
1416  }
1417 #line 1418 "cond.tab.c" /* yacc.c:1646 */
1418  break;
1419 
1420  case 5:
1421 #line 167 "cond.y" /* yacc.c:1646 */
1422  {
1423  (yyval.bool) = (yyvsp[-2].bool) || (yyvsp[0].bool);
1424  }
1425 #line 1426 "cond.tab.c" /* yacc.c:1646 */
1426  break;
1427 
1428  case 6:
1429 #line 171 "cond.y" /* yacc.c:1646 */
1430  {
1431  (yyval.bool) = !(yyvsp[-2].bool) || (yyvsp[0].bool);
1432  }
1433 #line 1434 "cond.tab.c" /* yacc.c:1646 */
1434  break;
1435 
1436  case 7:
1437 #line 175 "cond.y" /* yacc.c:1646 */
1438  {
1439  (yyval.bool) = ( (yyvsp[-2].bool) || (yyvsp[0].bool) ) && !( (yyvsp[-2].bool) && (yyvsp[0].bool) );
1440  }
1441 #line 1442 "cond.tab.c" /* yacc.c:1646 */
1442  break;
1443 
1444  case 8:
1445 #line 179 "cond.y" /* yacc.c:1646 */
1446  {
1447  (yyval.bool) = ( (yyvsp[-2].bool) && (yyvsp[0].bool) ) || ( !(yyvsp[-2].bool) && !(yyvsp[0].bool) );
1448  }
1449 #line 1450 "cond.tab.c" /* yacc.c:1646 */
1450  break;
1451 
1452  case 9:
1453 #line 186 "cond.y" /* yacc.c:1646 */
1454  {
1455  (yyval.bool) = (yyvsp[0].bool);
1456  }
1457 #line 1458 "cond.tab.c" /* yacc.c:1646 */
1458  break;
1459 
1460  case 10:
1461 #line 190 "cond.y" /* yacc.c:1646 */
1462  {
1463  (yyval.bool) = (yyvsp[-2].bool) && (yyvsp[0].bool);
1464  }
1465 #line 1466 "cond.tab.c" /* yacc.c:1646 */
1466  break;
1467 
1468  case 11:
1469 #line 197 "cond.y" /* yacc.c:1646 */
1470  {
1471  (yyval.bool) = !(yyvsp[0].bool);
1472  }
1473 #line 1474 "cond.tab.c" /* yacc.c:1646 */
1474  break;
1475 
1476  case 12:
1477 #line 201 "cond.y" /* yacc.c:1646 */
1478  {
1479  if ((yyvsp[0].value).type == VALUE_INTEGER)
1480  (yyval.bool) = (yyvsp[0].value).u.integer ? 1 : 0;
1481  else
1482  (yyval.bool) = (yyvsp[0].value).u.string && (yyvsp[0].value).u.string[0];
1483  value_free( (yyvsp[0].value) );
1484  }
1485 #line 1486 "cond.tab.c" /* yacc.c:1646 */
1486  break;
1487 
1488  case 13:
1489 #line 209 "cond.y" /* yacc.c:1646 */
1490  {
1491  if ((yyvsp[-2].value).type == VALUE_INTEGER && (yyvsp[0].value).type == VALUE_INTEGER)
1492  {
1493  (yyval.bool) = compare_int((yyvsp[-2].value).u.integer, (yyvsp[-1].operator), (yyvsp[0].value).u.integer);
1494  }
1495  else if ((yyvsp[-2].value).type != VALUE_INTEGER && (yyvsp[0].value).type != VALUE_INTEGER)
1496  {
1497  (yyval.bool) = compare_string((yyvsp[-2].value).u.string, (yyvsp[-1].operator), (yyvsp[0].value).u.string,
1498  (yyvsp[-2].value).type == VALUE_SYMBOL || (yyvsp[0].value).type == VALUE_SYMBOL);
1499  }
1500  else if ((yyvsp[-2].value).type == VALUE_LITERAL || (yyvsp[0].value).type == VALUE_LITERAL)
1501  {
1502  (yyval.bool) = FALSE;
1503  }
1504  else if ((yyvsp[-2].value).type == VALUE_SYMBOL) /* symbol operator integer */
1505  {
1506  int num;
1507  if (num_from_prop( (yyvsp[-2].value).u.string, &num ))
1508  (yyval.bool) = compare_int( num, (yyvsp[-1].operator), (yyvsp[0].value).u.integer );
1509  else
1510  (yyval.bool) = ((yyvsp[-1].operator) == COND_NE || (yyvsp[-1].operator) == COND_INE );
1511  }
1512  else /* integer operator symbol */
1513  {
1514  int num;
1515  if (num_from_prop( (yyvsp[0].value).u.string, &num ))
1516  (yyval.bool) = compare_int( (yyvsp[-2].value).u.integer, (yyvsp[-1].operator), num );
1517  else
1518  (yyval.bool) = ((yyvsp[-1].operator) == COND_NE || (yyvsp[-1].operator) == COND_INE );
1519  }
1520 
1521  value_free( (yyvsp[-2].value) );
1522  value_free( (yyvsp[0].value) );
1523  }
1524 #line 1525 "cond.tab.c" /* yacc.c:1646 */
1525  break;
1526 
1527  case 14:
1528 #line 244 "cond.y" /* yacc.c:1646 */
1529  {
1530  (yyval.bool) = (yyvsp[-1].bool);
1531  }
1532 #line 1533 "cond.tab.c" /* yacc.c:1646 */
1533  break;
1534 
1535  case 15:
1536 #line 251 "cond.y" /* yacc.c:1646 */
1537  { (yyval.operator) = COND_EQ; }
1538 #line 1539 "cond.tab.c" /* yacc.c:1646 */
1539  break;
1540 
1541  case 16:
1542 #line 252 "cond.y" /* yacc.c:1646 */
1543  { (yyval.operator) = COND_NE; }
1544 #line 1545 "cond.tab.c" /* yacc.c:1646 */
1545  break;
1546 
1547  case 17:
1548 #line 253 "cond.y" /* yacc.c:1646 */
1549  { (yyval.operator) = COND_LT; }
1550 #line 1551 "cond.tab.c" /* yacc.c:1646 */
1551  break;
1552 
1553  case 18:
1554 #line 254 "cond.y" /* yacc.c:1646 */
1555  { (yyval.operator) = COND_GT; }
1556 #line 1557 "cond.tab.c" /* yacc.c:1646 */
1557  break;
1558 
1559  case 19:
1560 #line 255 "cond.y" /* yacc.c:1646 */
1561  { (yyval.operator) = COND_LE; }
1562 #line 1563 "cond.tab.c" /* yacc.c:1646 */
1563  break;
1564 
1565  case 20:
1566 #line 256 "cond.y" /* yacc.c:1646 */
1567  { (yyval.operator) = COND_GE; }
1568 #line 1569 "cond.tab.c" /* yacc.c:1646 */
1569  break;
1570 
1571  case 21:
1572 #line 257 "cond.y" /* yacc.c:1646 */
1573  { (yyval.operator) = COND_SS; }
1574 #line 1575 "cond.tab.c" /* yacc.c:1646 */
1575  break;
1576 
1577  case 22:
1578 #line 258 "cond.y" /* yacc.c:1646 */
1579  { (yyval.operator) = COND_IEQ; }
1580 #line 1581 "cond.tab.c" /* yacc.c:1646 */
1581  break;
1582 
1583  case 23:
1584 #line 259 "cond.y" /* yacc.c:1646 */
1585  { (yyval.operator) = COND_INE; }
1586 #line 1587 "cond.tab.c" /* yacc.c:1646 */
1587  break;
1588 
1589  case 24:
1590 #line 260 "cond.y" /* yacc.c:1646 */
1591  { (yyval.operator) = COND_ILT; }
1592 #line 1593 "cond.tab.c" /* yacc.c:1646 */
1593  break;
1594 
1595  case 25:
1596 #line 261 "cond.y" /* yacc.c:1646 */
1597  { (yyval.operator) = COND_IGT; }
1598 #line 1599 "cond.tab.c" /* yacc.c:1646 */
1599  break;
1600 
1601  case 26:
1602 #line 262 "cond.y" /* yacc.c:1646 */
1603  { (yyval.operator) = COND_ILE; }
1604 #line 1605 "cond.tab.c" /* yacc.c:1646 */
1605  break;
1606 
1607  case 27:
1608 #line 263 "cond.y" /* yacc.c:1646 */
1609  { (yyval.operator) = COND_IGE; }
1610 #line 1611 "cond.tab.c" /* yacc.c:1646 */
1611  break;
1612 
1613  case 28:
1614 #line 264 "cond.y" /* yacc.c:1646 */
1615  { (yyval.operator) = COND_ISS; }
1616 #line 1617 "cond.tab.c" /* yacc.c:1646 */
1617  break;
1618 
1619  case 29:
1620 #line 265 "cond.y" /* yacc.c:1646 */
1621  { (yyval.operator) = COND_LHS; }
1622 #line 1623 "cond.tab.c" /* yacc.c:1646 */
1623  break;
1624 
1625  case 30:
1626 #line 266 "cond.y" /* yacc.c:1646 */
1627  { (yyval.operator) = COND_RHS; }
1628 #line 1629 "cond.tab.c" /* yacc.c:1646 */
1629  break;
1630 
1631  case 31:
1632 #line 267 "cond.y" /* yacc.c:1646 */
1633  { (yyval.operator) = COND_ILHS; }
1634 #line 1635 "cond.tab.c" /* yacc.c:1646 */
1635  break;
1636 
1637  case 32:
1638 #line 268 "cond.y" /* yacc.c:1646 */
1639  { (yyval.operator) = COND_IRHS; }
1640 #line 1641 "cond.tab.c" /* yacc.c:1646 */
1641  break;
1642 
1643  case 33:
1644 #line 273 "cond.y" /* yacc.c:1646 */
1645  {
1646  COND_input* cond = (COND_input*) info;
1647  UINT len;
1648 
1649  (yyval.value).type = VALUE_SYMBOL;
1650  (yyval.value).u.string = msi_dup_property( cond->package->db, (yyvsp[0].identifier) );
1651  if ((yyval.value).u.string)
1652  {
1653  len = (lstrlenW((yyval.value).u.string) + 1) * sizeof (WCHAR);
1654  (yyval.value).u.string = cond_track_mem( cond, (yyval.value).u.string, len );
1655  }
1656  cond_free( (yyvsp[0].identifier) );
1657  }
1658 #line 1659 "cond.tab.c" /* yacc.c:1646 */
1659  break;
1660 
1661  case 34:
1662 #line 287 "cond.y" /* yacc.c:1646 */
1663  {
1664  COND_input* cond = (COND_input*) info;
1665  UINT len = GetEnvironmentVariableW( (yyvsp[0].identifier), NULL, 0 );
1666  (yyval.value).type = VALUE_SYMBOL;
1667  (yyval.value).u.string = NULL;
1668  if (len++)
1669  {
1670  (yyval.value).u.string = cond_alloc( cond, len*sizeof (WCHAR) );
1671  if( !(yyval.value).u.string )
1672  YYABORT;
1673  GetEnvironmentVariableW( (yyvsp[0].identifier), (yyval.value).u.string, len );
1674  }
1675  cond_free( (yyvsp[0].identifier) );
1676  }
1677 #line 1678 "cond.tab.c" /* yacc.c:1646 */
1678  break;
1679 
1680  case 35:
1681 #line 302 "cond.y" /* yacc.c:1646 */
1682  {
1683  COND_input* cond = (COND_input*) info;
1684  (yyval.value).type = VALUE_LITERAL;
1685  (yyval.value).u.string = COND_GetLiteral( cond, &(yyvsp[0].str) );
1686  if( !(yyval.value).u.string )
1687  YYABORT;
1688  }
1689 #line 1690 "cond.tab.c" /* yacc.c:1646 */
1690  break;
1691 
1692  case 36:
1693 #line 310 "cond.y" /* yacc.c:1646 */
1694  {
1695  COND_input* cond = (COND_input*) info;
1696  LPWSTR szNum = COND_GetString( cond, &(yyvsp[0].str) );
1697  if( !szNum )
1698  YYABORT;
1699  (yyval.value).type = VALUE_INTEGER;
1700  (yyval.value).u.integer = atoiW( szNum );
1701  cond_free( szNum );
1702  }
1703 #line 1704 "cond.tab.c" /* yacc.c:1646 */
1704  break;
1705 
1706  case 37:
1707 #line 320 "cond.y" /* yacc.c:1646 */
1708  {
1709  COND_input* cond = (COND_input*) info;
1711 
1712  if(MSI_GetComponentStateW(cond->package, (yyvsp[0].identifier), &install, &action ) != ERROR_SUCCESS)
1713  {
1714  (yyval.value).type = VALUE_LITERAL;
1715  (yyval.value).u.string = NULL;
1716  }
1717  else
1718  {
1719  (yyval.value).type = VALUE_INTEGER;
1720  (yyval.value).u.integer = action;
1721  }
1722  cond_free( (yyvsp[0].identifier) );
1723  }
1724 #line 1725 "cond.tab.c" /* yacc.c:1646 */
1725  break;
1726 
1727  case 38:
1728 #line 337 "cond.y" /* yacc.c:1646 */
1729  {
1730  COND_input* cond = (COND_input*) info;
1732 
1733  if(MSI_GetComponentStateW(cond->package, (yyvsp[0].identifier), &install, &action ) != ERROR_SUCCESS)
1734  {
1735  (yyval.value).type = VALUE_LITERAL;
1736  (yyval.value).u.string = NULL;
1737  }
1738  else
1739  {
1740  (yyval.value).type = VALUE_INTEGER;
1741  (yyval.value).u.integer = install;
1742  }
1743  cond_free( (yyvsp[0].identifier) );
1744  }
1745 #line 1746 "cond.tab.c" /* yacc.c:1646 */
1746  break;
1747 
1748  case 39:
1749 #line 354 "cond.y" /* yacc.c:1646 */
1750  {
1751  COND_input* cond = (COND_input*) info;
1753 
1754  if (MSI_GetFeatureStateW(cond->package, (yyvsp[0].identifier), &install, &action ) != ERROR_SUCCESS)
1755  {
1756  (yyval.value).type = VALUE_LITERAL;
1757  (yyval.value).u.string = NULL;
1758  }
1759  else
1760  {
1761  (yyval.value).type = VALUE_INTEGER;
1762  (yyval.value).u.integer = action;
1763  }
1764  cond_free( (yyvsp[0].identifier) );
1765  }
1766 #line 1767 "cond.tab.c" /* yacc.c:1646 */
1767  break;
1768 
1769  case 40:
1770 #line 371 "cond.y" /* yacc.c:1646 */
1771  {
1772  COND_input* cond = (COND_input*) info;
1774 
1775  if(MSI_GetFeatureStateW(cond->package, (yyvsp[0].identifier), &install, &action ) != ERROR_SUCCESS)
1776  {
1777  (yyval.value).type = VALUE_LITERAL;
1778  (yyval.value).u.string = NULL;
1779  }
1780  else
1781  {
1782  (yyval.value).type = VALUE_INTEGER;
1783  (yyval.value).u.integer = install;
1784  }
1785  cond_free( (yyvsp[0].identifier) );
1786  }
1787 #line 1788 "cond.tab.c" /* yacc.c:1646 */
1788  break;
1789 
1790  case 41:
1791 #line 391 "cond.y" /* yacc.c:1646 */
1792  {
1793  COND_input* cond = (COND_input*) info;
1794  (yyval.identifier) = COND_GetString( cond, &(yyvsp[0].str) );
1795  if( !(yyval.identifier) )
1796  YYABORT;
1797  }
1798 #line 1799 "cond.tab.c" /* yacc.c:1646 */
1799  break;
1800 
1801 
1802 #line 1803 "cond.tab.c" /* yacc.c:1646 */
1803  default: break;
1804  }
1805  /* User semantic actions sometimes alter yychar, and that requires
1806  that yytoken be updated with the new translation. We take the
1807  approach of translating immediately before every use of yytoken.
1808  One alternative is translating here after every semantic action,
1809  but that translation would be missed if the semantic action invokes
1810  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1811  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1812  incorrect destructor might then be invoked immediately. In the
1813  case of YYERROR or YYBACKUP, subsequent parser actions might lead
1814  to an incorrect destructor call or verbose syntax error message
1815  before the lookahead is translated. */
1816  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1817 
1818  YYPOPSTACK (yylen);
1819  yylen = 0;
1820  YY_STACK_PRINT (yyss, yyssp);
1821 
1822  *++yyvsp = yyval;
1823 
1824  /* Now 'shift' the result of the reduction. Determine what state
1825  that goes to, based on the state we popped back to and the rule
1826  number reduced by. */
1827 
1828  yyn = yyr1[yyn];
1829 
1830  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1831  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1832  yystate = yytable[yystate];
1833  else
1834  yystate = yydefgoto[yyn - YYNTOKENS];
1835 
1836  goto yynewstate;
1837 
1838 
1839 /*--------------------------------------.
1840 | yyerrlab -- here on detecting error. |
1841 `--------------------------------------*/
1842 yyerrlab:
1843  /* Make sure we have latest lookahead translation. See comments at
1844  user semantic actions for why this is necessary. */
1845  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1846 
1847  /* If not already recovering from an error, report this error. */
1848  if (!yyerrstatus)
1849  {
1850  ++yynerrs;
1851 #if ! YYERROR_VERBOSE
1852  yyerror (info, YY_("syntax error"));
1853 #else
1854 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1855  yyssp, yytoken)
1856  {
1857  char const *yymsgp = YY_("syntax error");
1858  int yysyntax_error_status;
1859  yysyntax_error_status = YYSYNTAX_ERROR;
1860  if (yysyntax_error_status == 0)
1861  yymsgp = yymsg;
1862  else if (yysyntax_error_status == 1)
1863  {
1864  if (yymsg != yymsgbuf)
1865  YYSTACK_FREE (yymsg);
1866  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1867  if (!yymsg)
1868  {
1869  yymsg = yymsgbuf;
1870  yymsg_alloc = sizeof yymsgbuf;
1871  yysyntax_error_status = 2;
1872  }
1873  else
1874  {
1875  yysyntax_error_status = YYSYNTAX_ERROR;
1876  yymsgp = yymsg;
1877  }
1878  }
1879  yyerror (info, yymsgp);
1880  if (yysyntax_error_status == 2)
1881  goto yyexhaustedlab;
1882  }
1883 # undef YYSYNTAX_ERROR
1884 #endif
1885  }
1886 
1887 
1888 
1889  if (yyerrstatus == 3)
1890  {
1891  /* If just tried and failed to reuse lookahead token after an
1892  error, discard it. */
1893 
1894  if (yychar <= YYEOF)
1895  {
1896  /* Return failure if at end of input. */
1897  if (yychar == YYEOF)
1898  YYABORT;
1899  }
1900  else
1901  {
1902  yydestruct ("Error: discarding",
1903  yytoken, &yylval, info);
1904  yychar = YYEMPTY;
1905  }
1906  }
1907 
1908  /* Else will try to reuse lookahead token after shifting the error
1909  token. */
1910  goto yyerrlab1;
1911 
1912 
1913 /*---------------------------------------------------.
1914 | yyerrorlab -- error raised explicitly by YYERROR. |
1915 `---------------------------------------------------*/
1916 yyerrorlab:
1917 
1918  /* Pacify compilers like GCC when the user code never invokes
1919  YYERROR and the label yyerrorlab therefore never appears in user
1920  code. */
1921  if (/*CONSTCOND*/ 0)
1922  goto yyerrorlab;
1923 
1924  /* Do not reclaim the symbols of the rule whose action triggered
1925  this YYERROR. */
1926  YYPOPSTACK (yylen);
1927  yylen = 0;
1928  YY_STACK_PRINT (yyss, yyssp);
1929  yystate = *yyssp;
1930  goto yyerrlab1;
1931 
1932 
1933 /*-------------------------------------------------------------.
1934 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1935 `-------------------------------------------------------------*/
1936 yyerrlab1:
1937  yyerrstatus = 3; /* Each real token shifted decrements this. */
1938 
1939  for (;;)
1940  {
1941  yyn = yypact[yystate];
1942  if (!yypact_value_is_default (yyn))
1943  {
1944  yyn += YYTERROR;
1945  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1946  {
1947  yyn = yytable[yyn];
1948  if (0 < yyn)
1949  break;
1950  }
1951  }
1952 
1953  /* Pop the current state because it cannot handle the error token. */
1954  if (yyssp == yyss)
1955  YYABORT;
1956 
1957 
1958  yydestruct ("Error: popping",
1959  yystos[yystate], yyvsp, info);
1960  YYPOPSTACK (1);
1961  yystate = *yyssp;
1962  YY_STACK_PRINT (yyss, yyssp);
1963  }
1964 
1966  *++yyvsp = yylval;
1968 
1969 
1970  /* Shift the error token. */
1971  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1972 
1973  yystate = yyn;
1974  goto yynewstate;
1975 
1976 
1977 /*-------------------------------------.
1978 | yyacceptlab -- YYACCEPT comes here. |
1979 `-------------------------------------*/
1980 yyacceptlab:
1981  yyresult = 0;
1982  goto yyreturn;
1983 
1984 /*-----------------------------------.
1985 | yyabortlab -- YYABORT comes here. |
1986 `-----------------------------------*/
1987 yyabortlab:
1988  yyresult = 1;
1989  goto yyreturn;
1990 
1991 #if !defined yyoverflow || YYERROR_VERBOSE
1992 /*-------------------------------------------------.
1993 | yyexhaustedlab -- memory exhaustion comes here. |
1994 `-------------------------------------------------*/
1995 yyexhaustedlab:
1996  yyerror (info, YY_("memory exhausted"));
1997  yyresult = 2;
1998  /* Fall through. */
1999 #endif
2000 
2001 yyreturn:
2002  if (yychar != YYEMPTY)
2003  {
2004  /* Make sure we have latest lookahead translation. See comments at
2005  user semantic actions for why this is necessary. */
2006  yytoken = YYTRANSLATE (yychar);
2007  yydestruct ("Cleanup: discarding lookahead",