ReactOS  0.4.14-dev-98-gb0d4763
parser.tab.c File Reference
#include "vbscript.h"
#include "parse.h"
#include "wine/debug.h"
#include <stddef.h>
Include dependency graph for parser.tab.c:

Go to the source code of this file.

Classes

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   parser_parse
 
#define yylex   parser_lex
 
#define yyerror   parser_error
 
#define yydebug   parser_debug
 
#define yynerrs   parser_nerrs
 
#define STORAGE_IS_PRIVATE   1
 
#define STORAGE_IS_DEFAULT   2
 
#define CHECK_ERROR   if(((parser_ctx_t*)ctx)->hres != S_OK) YYABORT
 
#define YY_NULL   0
 
#define YYERROR_VERBOSE   0
 
#define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_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   5
 
#define YYLAST   944
 
#define YYNTOKENS   87
 
#define YYNNTS   60
 
#define YYNRULES   169
 
#define YYNSTATES   343
 
#define YYUNDEFTOK   2
 
#define YYMAXUTOK   325
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -205
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-205)))
 
#define YYTABLE_NINF   -153
 
#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 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 (vbscript)
 
static int parser_error (parser_ctx_t *, const char *)
 
static void parse_complete (parser_ctx_t *, BOOL)
 
static void source_add_statement (parser_ctx_t *, statement_t *)
 
static void source_add_class (parser_ctx_t *, class_decl_t *)
 
static voidnew_expression (parser_ctx_t *, expression_type_t, size_t)
 
static expression_tnew_bool_expression (parser_ctx_t *, VARIANT_BOOL)
 
static expression_tnew_string_expression (parser_ctx_t *, const WCHAR *)
 
static expression_tnew_long_expression (parser_ctx_t *, expression_type_t, LONG)
 
static expression_tnew_double_expression (parser_ctx_t *, double)
 
static expression_tnew_unary_expression (parser_ctx_t *, expression_type_t, expression_t *)
 
static expression_tnew_binary_expression (parser_ctx_t *, expression_type_t, expression_t *, expression_t *)
 
static expression_tnew_new_expression (parser_ctx_t *, const WCHAR *)
 
static member_expression_tnew_member_expression (parser_ctx_t *, expression_t *, const WCHAR *)
 
static voidnew_statement (parser_ctx_t *, statement_type_t, size_t)
 
static statement_tnew_call_statement (parser_ctx_t *, BOOL, member_expression_t *)
 
static statement_tnew_assign_statement (parser_ctx_t *, member_expression_t *, expression_t *)
 
static statement_tnew_set_statement (parser_ctx_t *, member_expression_t *, expression_t *)
 
static statement_tnew_dim_statement (parser_ctx_t *, dim_decl_t *)
 
static statement_tnew_while_statement (parser_ctx_t *, statement_type_t, expression_t *, statement_t *)
 
static statement_tnew_forto_statement (parser_ctx_t *, const WCHAR *, expression_t *, expression_t *, expression_t *, statement_t *)
 
static statement_tnew_foreach_statement (parser_ctx_t *, const WCHAR *, expression_t *, statement_t *)
 
static statement_tnew_if_statement (parser_ctx_t *, expression_t *, statement_t *, elseif_decl_t *, statement_t *)
 
static statement_tnew_function_statement (parser_ctx_t *, function_decl_t *)
 
static statement_tnew_onerror_statement (parser_ctx_t *, BOOL)
 
static statement_tnew_const_statement (parser_ctx_t *, const_decl_t *)
 
static statement_tnew_select_statement (parser_ctx_t *, expression_t *, case_clausule_t *)
 
static dim_decl_tnew_dim_decl (parser_ctx_t *, const WCHAR *, BOOL, dim_list_t *)
 
static dim_list_tnew_dim (parser_ctx_t *, unsigned, dim_list_t *)
 
static elseif_decl_tnew_elseif_decl (parser_ctx_t *, expression_t *, statement_t *)
 
static function_decl_tnew_function_decl (parser_ctx_t *, const WCHAR *, function_type_t, unsigned, arg_decl_t *, statement_t *)
 
static arg_decl_tnew_argument_decl (parser_ctx_t *, const WCHAR *, BOOL)
 
static const_decl_tnew_const_decl (parser_ctx_t *, const WCHAR *, expression_t *)
 
static case_clausule_tnew_case_clausule (parser_ctx_t *, expression_t *, statement_t *, case_clausule_t *)
 
static class_decl_tnew_class_decl (parser_ctx_t *)
 
static class_decl_tadd_class_function (parser_ctx_t *, class_decl_t *, function_decl_t *)
 
static class_decl_tadd_dim_prop (parser_ctx_t *, class_decl_t *, dim_decl_t *, unsigned)
 
static statement_tlink_statements (statement_t *, statement_t *)
 
int parser_parse (parser_ctx_t *ctx)
 
voidmalloc (YYSIZE_T)
 
void free (void *)
 
static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_ctx_t *ctx)
 
int yyparse (parser_ctx_t *ctx)
 
voidparser_alloc (parser_ctx_t *ctx, size_t size)
 
HRESULT parse_script (parser_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter)
 
void parser_release (parser_ctx_t *ctx)
 

Variables

static const WCHAR propertyW [] = {'p','r','o','p','e','r','t','y',0}
 
static const yytype_uint8 yytranslate []
 
static const yytype_int16 yypact []
 
static const yytype_uint8 yydefact []
 
static const yytype_int16 yypgoto []
 
static const yytype_int16 yydefgoto []
 
static const yytype_int16 yytable []
 
static const yytype_int16 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 340 of file parser.tab.c.

◆ CHECK_ERROR

#define CHECK_ERROR   if(((parser_ctx_t*)ctx)->hres != S_OK) YYABORT

Definition at line 132 of file parser.tab.c.

◆ STORAGE_IS_DEFAULT

#define STORAGE_IS_DEFAULT   2

Definition at line 130 of file parser.tab.c.

◆ STORAGE_IS_PRIVATE

#define STORAGE_IS_PRIVATE   1

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

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 332 of file parser.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 363 of file parser.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 364 of file parser.tab.c.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 360 of file parser.tab.c.

◆ YY_NULL

#define YY_NULL   0

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

◆ YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_TAB_H_INCLUDED

#define YY_PARSER_E_REACTOSSYNC_GCC_DLL_WIN32_VBSCRIPT_PARSER_TAB_H_INCLUDED

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

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 1200 of file parser.tab.c.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 1199 of file parser.tab.c.

◆ YY_SYMBOL_PRINT

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

Definition at line 1198 of file parser.tab.c.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 1044 of file parser.tab.c.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 1043 of file parser.tab.c.

◆ YYBACKUP

#define YYBACKUP (   Token,
  Value 
)
Value:
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (ctx, YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2343
#define YYEMPTY
Definition: parser.tab.c:1040
_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
int yychar
Definition: parser.tab.c:2353
#define YY_(Msgid)
Definition: parser.tab.c:332

Definition at line 1050 of file parser.tab.c.

◆ YYBISON

#define YYBISON   1

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

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.0"

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

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 1039 of file parser.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 487 of file parser.tab.c.

◆ YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 459 of file parser.tab.c.

◆ yydebug

#define yydebug   parser_debug

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

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 159 of file parser.tab.c.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 1197 of file parser.tab.c.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 1040 of file parser.tab.c.

◆ YYEOF

#define YYEOF   0

Definition at line 1041 of file parser.tab.c.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 1069 of file parser.tab.c.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 1038 of file parser.tab.c.

◆ yyerror

#define yyerror   parser_error

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

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 1045 of file parser.tab.c.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 150 of file parser.tab.c.

◆ YYFINAL

#define YYFINAL   5

Definition at line 500 of file parser.tab.c.

◆ YYFREE

#define YYFREE   free

Definition at line 430 of file parser.tab.c.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 1206 of file parser.tab.c.

◆ YYLAST

#define YYLAST   944

Definition at line 502 of file parser.tab.c.

◆ yylex

#define yylex   parser_lex

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

◆ YYMALLOC

#define YYMALLOC   malloc

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

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 1217 of file parser.tab.c.

◆ YYMAXUTOK

#define YYMAXUTOK   325

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

◆ yynerrs

#define yynerrs   parser_nerrs

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

◆ YYNNTS

#define YYNNTS   60

Definition at line 507 of file parser.tab.c.

◆ YYNRULES

#define YYNRULES   169

Definition at line 509 of file parser.tab.c.

◆ YYNSTATES

#define YYNSTATES   343

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

◆ YYNTOKENS

#define YYNTOKENS   87

Definition at line 505 of file parser.tab.c.

◆ YYPACT_NINF

#define YYPACT_NINF   -205

Definition at line 636 of file parser.tab.c.

◆ yypact_value_is_default

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

Definition at line 638 of file parser.tab.c.

◆ yyparse

#define yyparse   parser_parse

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

◆ YYPOPSTACK

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

◆ YYPULL

#define YYPULL   1

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

◆ YYPURE

#define YYPURE   1

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

◆ YYPUSH

#define YYPUSH   0

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

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 1048 of file parser.tab.c.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 322 of file parser.tab.c.

◆ YYSIZE_T

#define YYSIZE_T   size_t

Definition at line 316 of file parser.tab.c.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

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

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 410 of file parser.tab.c.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 413 of file parser.tab.c.

◆ YYSTACK_BYTES

#define YYSTACK_BYTES (   N)
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
short int yytype_int16
#define YYSTACK_GAP_MAXIMUM
Definition: parser.tab.c:451
union YYSTYPE YYSTYPE
Definition: parser.tab.c:281

Definition at line 455 of file parser.tab.c.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 411 of file parser.tab.c.

◆ YYSTACK_GAP_MAXIMUM

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

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

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

◆ YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

Definition at line 268 of file parser.tab.c.

◆ YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 267 of file parser.tab.c.

◆ YYTABLE_NINF

#define YYTABLE_NINF   -153

Definition at line 641 of file parser.tab.c.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

Definition at line 643 of file parser.tab.c.

◆ YYTERROR

#define YYTERROR   1

Definition at line 1068 of file parser.tab.c.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 167 of file parser.tab.c.

◆ YYTRANSLATE

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

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

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 515 of file parser.tab.c.

◆ YYUSE

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

Definition at line 346 of file parser.tab.c.

Typedef Documentation

◆ YYSTYPE

typedef union YYSTYPE YYSTYPE

Definition at line 243 of file parser.tab.c.

◆ yytype_int16

Definition at line 306 of file parser.tab.c.

◆ yytype_int8

Definition at line 294 of file parser.tab.c.

◆ yytype_uint16

typedef unsigned short int yytype_uint16

Definition at line 300 of file parser.tab.c.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 288 of file parser.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 168 of file parser.tab.c.

169  {
170  tEOF = 258,
171  tNL = 259,
172  tREM = 260,
173  tEMPTYBRACKETS = 261,
174  tTRUE = 262,
175  tFALSE = 263,
176  tNOT = 264,
177  tAND = 265,
178  tOR = 266,
179  tXOR = 267,
180  tEQV = 268,
181  tIMP = 269,
182  tNEQ = 270,
183  tIS = 271,
184  tLTEQ = 272,
185  tGTEQ = 273,
186  tMOD = 274,
187  tCALL = 275,
188  tDIM = 276,
189  tSUB = 277,
190  tFUNCTION = 278,
191  tPROPERTY = 279,
192  tGET = 280,
193  tLET = 281,
194  tCONST = 282,
195  tIF = 283,
196  tELSE = 284,
197  tELSEIF = 285,
198  tEND = 286,
199  tTHEN = 287,
200  tEXIT = 288,
201  tWHILE = 289,
202  tWEND = 290,
203  tDO = 291,
204  tLOOP = 292,
205  tUNTIL = 293,
206  tFOR = 294,
207  tTO = 295,
208  tSTEP = 296,
209  tEACH = 297,
210  tIN = 298,
211  tSELECT = 299,
212  tCASE = 300,
213  tBYREF = 301,
214  tBYVAL = 302,
215  tOPTION = 303,
216  tEXPLICIT = 304,
217  tSTOP = 305,
218  tNOTHING = 306,
219  tEMPTY = 307,
220  tNULL = 308,
221  tCLASS = 309,
222  tSET = 310,
223  tNEW = 311,
224  tPUBLIC = 312,
225  tPRIVATE = 313,
226  tDEFAULT = 314,
227  tME = 315,
228  tERROR = 316,
229  tNEXT = 317,
230  tON = 318,
231  tRESUME = 319,
232  tGOTO = 320,
233  tIdentifier = 321,
234  tString = 322,
235  tLong = 323,
236  tShort = 324,
237  tDouble = 325
238  };

Function Documentation

◆ add_class_function()

static class_decl_t * add_class_function ( parser_ctx_t ctx,
class_decl_t class_decl,
function_decl_t decl 
)
static

Definition at line 3322 of file parser.tab.c.

3323 {
3324  function_decl_t *iter;
3325 
3326  for(iter = class_decl->funcs; iter; iter = iter->next) {
3327  if(!strcmpiW(iter->name, decl->name)) {
3328  if(decl->type == FUNC_SUB || decl->type == FUNC_FUNCTION) {
3329  FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
3330  ctx->hres = E_FAIL;
3331  return NULL;
3332  }
3333 
3334  while(1) {
3335  if(iter->type == decl->type) {
3336  FIXME("Redefinition of %s::%s\n", debugstr_w(class_decl->name), debugstr_w(decl->name));
3337  ctx->hres = E_FAIL;
3338  return NULL;
3339  }
3340  if(!iter->next_prop_func)
3341  break;
3342  iter = iter->next_prop_func;
3343  }
3344 
3345  iter->next_prop_func = decl;
3346  return class_decl;
3347  }
3348  }
3349 
3350  decl->next = class_decl->funcs;
3351  class_decl->funcs = decl;
3352  return class_decl;
3353 }
const WCHAR * name
Definition: parse.h:169
struct _function_decl_t * next
Definition: parse.h:174
function_decl_t * funcs
Definition: parse.h:185
function_type_t type
Definition: parse.h:170
#define E_FAIL
Definition: ddrawi.h:102
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
struct _function_decl_t * next_prop_func
Definition: parse.h:175
const WCHAR * name
Definition: parse.h:184
#define strcmpiW(s1, s2)
Definition: unicode.h:39
HRESULT hres
Definition: parse.h:262

Referenced by yyparse().

◆ add_dim_prop()

static class_decl_t * add_dim_prop ( parser_ctx_t ctx,
class_decl_t class_decl,
dim_decl_t dim_decl,
unsigned  storage_flags 
)
static

Definition at line 3355 of file parser.tab.c.

3356 {
3357  if(storage_flags & STORAGE_IS_DEFAULT) {
3358  FIXME("variant prop van't be default value\n");
3359  ctx->hres = E_FAIL;
3360  return NULL;
3361  }
3362 
3363  dim_decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
3364  dim_decl->next = class_decl->props;
3365  class_decl->props = dim_decl;
3366  return class_decl;
3367 }
#define E_FAIL
Definition: ddrawi.h:102
#define STORAGE_IS_DEFAULT
Definition: parser.tab.c:130
BOOL is_public
Definition: parse.h:152
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
dim_decl_t * props
Definition: parse.h:186
#define STORAGE_IS_PRIVATE
Definition: parser.tab.c:129
struct _dim_decl_t * next
Definition: parse.h:154
HRESULT hres
Definition: parse.h:262

Referenced by yyparse().

◆ free()

void free ( void )

Definition at line 147 of file cabinet.c.

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

◆ link_statements()

static statement_t * link_statements ( statement_t head,
statement_t tail 
)
static

Definition at line 3395 of file parser.tab.c.

3396 {
3397  statement_t *iter;
3398 
3399  for(iter = head; iter->next; iter = iter->next);
3400  iter->next = tail;
3401 
3402  return head;
3403 }
struct outqueuenode * tail
Definition: adnsresfilter.c:66
struct outqueuenode * head
Definition: adnsresfilter.c:66
statement_t * next
Definition: parser.h:125

Referenced by yyparse().

◆ malloc()

void* malloc ( YYSIZE_T  )

◆ new_argument_decl()

static arg_decl_t * new_argument_decl ( parser_ctx_t ctx,
const WCHAR name,
BOOL  by_ref 
)
static

Definition at line 3253 of file parser.tab.c.

3254 {
3255  arg_decl_t *arg_decl;
3256 
3257  arg_decl = parser_alloc(ctx, sizeof(*arg_decl));
3258  if(!arg_decl)
3259  return NULL;
3260 
3261  arg_decl->name = name;
3262  arg_decl->by_ref = by_ref;
3263  arg_decl->next = NULL;
3264  return arg_decl;
3265 }
struct _arg_decl_t * next
Definition: parse.h:165
const WCHAR * name
Definition: parse.h:163
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
BOOL by_ref
Definition: parse.h:164
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ new_assign_statement()

static statement_t * new_assign_statement ( parser_ctx_t ctx,
member_expression_t left,
expression_t right 
)
static

Definition at line 3073 of file parser.tab.c.

3074 {
3076 
3077  stat = new_statement(ctx, STAT_ASSIGN, sizeof(*stat));
3078  if(!stat)
3079  return NULL;
3080 
3081  stat->member_expr = left;
3082  stat->value_expr = right;
3083  return &stat->stat;
3084 }
smooth NULL
Definition: ftsmooth.c:416
GLint left
Definition: glext.h:7726
GLdouble GLdouble right
Definition: glext.h:10859
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_binary_expression()

static expression_t * new_binary_expression ( parser_ctx_t ctx,
expression_type_t  type,
expression_t left,
expression_t right 
)
static

Definition at line 3008 of file parser.tab.c.

3009 {
3011 
3012  expr = new_expression(ctx, type, sizeof(*expr));
3013  if(!expr)
3014  return NULL;
3015 
3016  expr->left = left;
3017  expr->right = right;
3018  return &expr->expr;
3019 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
GLint left
Definition: glext.h:7726
GLdouble GLdouble right
Definition: glext.h:10859
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_bool_expression()

static expression_t * new_bool_expression ( parser_ctx_t ctx,
VARIANT_BOOL  value 
)
static

Definition at line 2948 of file parser.tab.c.

2949 {
2951 
2952  expr = new_expression(ctx, EXPR_BOOL, sizeof(*expr));
2953  if(!expr)
2954  return NULL;
2955 
2956  expr->value = value;
2957  return &expr->expr;
2958 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
GLsizei const GLfloat * value
Definition: glext.h:6069
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_call_statement()

static statement_t * new_call_statement ( parser_ctx_t ctx,
BOOL  is_strict,
member_expression_t expr 
)
static

Definition at line 3060 of file parser.tab.c.

3061 {
3063 
3064  stat = new_statement(ctx, STAT_CALL, sizeof(*stat));
3065  if(!stat)
3066  return NULL;
3067 
3068  stat->expr = expr;
3069  stat->is_strict = is_strict;
3070  return &stat->stat;
3071 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_case_clausule()

static case_clausule_t * new_case_clausule ( parser_ctx_t ctx,
expression_t expr,
statement_t stat,
case_clausule_t next 
)
static

Definition at line 3227 of file parser.tab.c.

3228 {
3230 
3231  ret = parser_alloc(ctx, sizeof(*ret));
3232  if(!ret)
3233  return NULL;
3234 
3235  ret->expr = expr;
3236  ret->stat = stat;
3237  ret->next = next;
3238  return ret;
3239 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
int ret
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by yyparse().

◆ new_class_decl()

static class_decl_t * new_class_decl ( parser_ctx_t ctx)
static

Definition at line 3308 of file parser.tab.c.

3309 {
3310  class_decl_t *class_decl;
3311 
3312  class_decl = parser_alloc(ctx, sizeof(*class_decl));
3313  if(!class_decl)
3314  return NULL;
3315 
3316  class_decl->funcs = NULL;
3317  class_decl->props = NULL;
3318  class_decl->next = NULL;
3319  return class_decl;
3320 }
struct _class_decl_t * next
Definition: parse.h:187
function_decl_t * funcs
Definition: parse.h:185
smooth NULL
Definition: ftsmooth.c:416
dim_decl_t * props
Definition: parse.h:186
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405

Referenced by yyparse().

◆ new_const_decl()

static const_decl_t * new_const_decl ( parser_ctx_t ctx,
const WCHAR name,
expression_t expr 
)
static

Definition at line 3369 of file parser.tab.c.

3370 {
3371  const_decl_t *decl;
3372 
3373  decl = parser_alloc(ctx, sizeof(*decl));
3374  if(!decl)
3375  return NULL;
3376 
3377  decl->name = name;
3378  decl->value_expr = expr;
3379  decl->next = NULL;
3380  return decl;
3381 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
expression_t * value_expr
Definition: parse.h:233
struct _const_decl_t * next
Definition: parse.h:234
const WCHAR * name
Definition: parse.h:232
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ new_const_statement()

static statement_t * new_const_statement ( parser_ctx_t ctx,
const_decl_t decls 
)
static

Definition at line 3383 of file parser.tab.c.

3384 {
3386 
3387  stat = new_statement(ctx, STAT_CONST, sizeof(*stat));
3388  if(!stat)
3389  return NULL;
3390 
3391  stat->decls = decls;
3392  return &stat->stat;
3393 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_dim()

static dim_list_t * new_dim ( parser_ctx_t ctx,
unsigned  val,
dim_list_t next 
)
static

Definition at line 3114 of file parser.tab.c.

3115 {
3116  dim_list_t *ret;
3117 
3118  ret = parser_alloc(ctx, sizeof(*ret));
3119  if(!ret)
3120  return NULL;
3121 
3122  ret->val = val;
3123  ret->next = next;
3124  return ret;
3125 }
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
GLuint GLfloat * val
Definition: glext.h:7180
int ret
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by yyparse().

◆ new_dim_decl()

static dim_decl_t * new_dim_decl ( parser_ctx_t ctx,
const WCHAR name,
BOOL  is_array,
dim_list_t dims 
)
static

Definition at line 3099 of file parser.tab.c.

3100 {
3101  dim_decl_t *decl;
3102 
3103  decl = parser_alloc(ctx, sizeof(*decl));
3104  if(!decl)
3105  return NULL;
3106 
3107  decl->name = name;
3108  decl->is_array = is_array;
3109  decl->dims = dims;
3110  decl->next = NULL;
3111  return decl;
3112 }
smooth NULL
Definition: ftsmooth.c:416
BOOL is_array
Definition: parse.h:151
static int is_array(const type_t *t)
Definition: header.h:64
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
const WCHAR * name
Definition: parse.h:150
struct _dim_decl_t * next
Definition: parse.h:154
dim_list_t * dims
Definition: parse.h:153
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ new_dim_statement()

static statement_t * new_dim_statement ( parser_ctx_t ctx,
dim_decl_t decls 
)
static

Definition at line 3127 of file parser.tab.c.

3128 {
3130 
3131  stat = new_statement(ctx, STAT_DIM, sizeof(*stat));
3132  if(!stat)
3133  return NULL;
3134 
3135  stat->dim_decls = decls;
3136  return &stat->stat;
3137 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_double_expression()

static expression_t * new_double_expression ( parser_ctx_t ctx,
double  value 
)
static

Definition at line 2984 of file parser.tab.c.

2985 {
2987 
2988  expr = new_expression(ctx, EXPR_DOUBLE, sizeof(*expr));
2989  if(!expr)
2990  return NULL;
2991 
2992  expr->value = value;
2993  return &expr->expr;
2994 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
GLsizei const GLfloat * value
Definition: glext.h:6069
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_elseif_decl()

static elseif_decl_t * new_elseif_decl ( parser_ctx_t ctx,
expression_t expr,
statement_t stat 
)
static

Definition at line 3139 of file parser.tab.c.

3140 {
3141  elseif_decl_t *decl;
3142 
3143  decl = parser_alloc(ctx, sizeof(*decl));
3144  if(!decl)
3145  return NULL;
3146 
3147  decl->expr = expr;
3148  decl->stat = stat;
3149  decl->next = NULL;
3150  return decl;
3151 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
struct _elseif_decl_t * next
Definition: parse.h:193
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
statement_t * stat
Definition: parse.h:192
expression_t * expr
Definition: parse.h:191
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_expression()

static void * new_expression ( parser_ctx_t ctx,
expression_type_t  type,
size_t  size 
)
static

Definition at line 2935 of file parser.tab.c.

2936 {
2937  expression_t *expr;
2938 
2939  expr = parser_alloc(ctx, size ? size : sizeof(*expr));
2940  if(expr) {
2941  expr->type = type;
2942  expr->next = NULL;
2943  }
2944 
2945  return expr;
2946 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: query.h:86
int type
Definition: query.h:88
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
GLsizeiptr size
Definition: glext.h:5919

Referenced by new_binary_expression(), new_bool_expression(), new_double_expression(), new_long_expression(), new_member_expression(), new_new_expression(), new_string_expression(), new_unary_expression(), and yyparse().

◆ new_foreach_statement()

static statement_t * new_foreach_statement ( parser_ctx_t ctx,
const WCHAR identifier,
expression_t group_expr,
statement_t body 
)
static

Definition at line 3183 of file parser.tab.c.

3185 {
3187 
3188  stat = new_statement(ctx, STAT_FOREACH, sizeof(*stat));
3189  if(!stat)
3190  return NULL;
3191 
3192  stat->identifier = identifier;
3193  stat->group_expr = group_expr;
3194  stat->body = body;
3195  return &stat->stat;
3196 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100

Referenced by yyparse().

◆ new_forto_statement()

static statement_t * new_forto_statement ( parser_ctx_t ctx,
const WCHAR identifier,
expression_t from_expr,
expression_t to_expr,
expression_t step_expr,
statement_t body 
)
static

Definition at line 3166 of file parser.tab.c.

3168 {
3170 
3171  stat = new_statement(ctx, STAT_FORTO, sizeof(*stat));
3172  if(!stat)
3173  return NULL;
3174 
3175  stat->identifier = identifier;
3176  stat->from_expr = from_expr;
3177  stat->to_expr = to_expr;
3178  stat->step_expr = step_expr;
3179  stat->body = body;
3180  return &stat->stat;
3181 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100

Referenced by yyparse().

◆ new_function_decl()

static function_decl_t * new_function_decl ( parser_ctx_t ctx,
const WCHAR name,
function_type_t  type,
unsigned  storage_flags,
arg_decl_t arg_decl,
statement_t body 
)
static

Definition at line 3267 of file parser.tab.c.

3269 {
3270  function_decl_t *decl;
3271 
3272  if(storage_flags & STORAGE_IS_DEFAULT) {
3273  if(type == FUNC_PROPGET) {
3274  type = FUNC_DEFGET;
3275  }else {
3276  FIXME("Invalid default property\n");
3277  ctx->hres = E_FAIL;
3278  return NULL;
3279  }
3280  }
3281 
3282  decl = parser_alloc(ctx, sizeof(*decl));
3283  if(!decl)
3284  return NULL;
3285 
3286  decl->name = name;
3287  decl->type = type;
3288  decl->is_public = !(storage_flags & STORAGE_IS_PRIVATE);
3289  decl->args = arg_decl;
3290  decl->body = body;
3291  decl->next = NULL;
3292  decl->next_prop_func = NULL;
3293  return decl;
3294 }
const WCHAR * name
Definition: parse.h:169
struct _function_decl_t * next
Definition: parse.h:174
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
function_type_t type
Definition: parse.h:170
#define E_FAIL
Definition: ddrawi.h:102
#define STORAGE_IS_DEFAULT
Definition: parser.tab.c:130
arg_decl_t * args
Definition: parse.h:172
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
struct _function_decl_t * next_prop_func
Definition: parse.h:175
BOOL is_public
Definition: parse.h:171
#define STORAGE_IS_PRIVATE
Definition: parser.tab.c:129
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100
statement_t * body
Definition: parse.h:173
HRESULT hres
Definition: parse.h:262
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ new_function_statement()

static statement_t * new_function_statement ( parser_ctx_t ctx,
function_decl_t decl 
)
static

Definition at line 3296 of file parser.tab.c.

3297 {
3299 
3300  stat = new_statement(ctx, STAT_FUNC, sizeof(*stat));
3301  if(!stat)
3302  return NULL;
3303 
3304  stat->func_decl = decl;
3305  return &stat->stat;
3306 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_if_statement()

static statement_t * new_if_statement ( parser_ctx_t ctx,
expression_t expr,
statement_t if_stat,
elseif_decl_t elseif_decl,
statement_t else_stat 
)
static

Definition at line 3198 of file parser.tab.c.

3200 {
3202 
3203  stat = new_statement(ctx, STAT_IF, sizeof(*stat));
3204  if(!stat)
3205  return NULL;
3206 
3207  stat->expr = expr;
3208  stat->if_stat = if_stat;
3209  stat->elseifs = elseif_decl;
3210  stat->else_stat = else_stat;
3211  return &stat->stat;
3212 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_long_expression()

static expression_t * new_long_expression ( parser_ctx_t ctx,
expression_type_t  type,
LONG  value 
)
static

Definition at line 2972 of file parser.tab.c.

2973 {
2975 
2976  expr = new_expression(ctx, type, sizeof(*expr));
2977  if(!expr)
2978  return NULL;
2979 
2980  expr->value = value;
2981  return &expr->expr;
2982 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
GLsizei const GLfloat * value
Definition: glext.h:6069
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_member_expression()

static member_expression_t * new_member_expression ( parser_ctx_t ctx,
expression_t obj_expr,
const WCHAR identifier 
)
static

Definition at line 3021 of file parser.tab.c.

3022 {
3024 
3025  expr = new_expression(ctx, EXPR_MEMBER, sizeof(*expr));
3026  if(!expr)
3027  return NULL;
3028 
3029  expr->obj_expr = obj_expr;
3030  expr->identifier = identifier;
3031  expr->args = NULL;
3032  return expr;
3033 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_new_expression()

static expression_t * new_new_expression ( parser_ctx_t ctx,
const WCHAR identifier 
)
static

Definition at line 3035 of file parser.tab.c.

3036 {
3038 
3039  expr = new_expression(ctx, EXPR_NEW, sizeof(*expr));
3040  if(!expr)
3041  return NULL;
3042 
3043  expr->value = identifier;
3044  return &expr->expr;
3045 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_onerror_statement()

static statement_t * new_onerror_statement ( parser_ctx_t ctx,
BOOL  resume_next 
)
static

Definition at line 3241 of file parser.tab.c.

3242 {
3244 
3245  stat = new_statement(ctx, STAT_ONERROR, sizeof(*stat));
3246  if(!stat)
3247  return NULL;
3248 
3249  stat->resume_next = resume_next;
3250  return &stat->stat;
3251 }
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_select_statement()

static statement_t * new_select_statement ( parser_ctx_t ctx,
expression_t expr,
case_clausule_t case_clausules 
)
static

Definition at line 3214 of file parser.tab.c.

3215 {
3217 
3218  stat = new_statement(ctx, STAT_SELECT, sizeof(*stat));
3219  if(!stat)
3220  return NULL;
3221 
3222  stat->expr = expr;
3223  stat->case_clausules = case_clausules;
3224  return &stat->stat;
3225 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_set_statement()

static statement_t * new_set_statement ( parser_ctx_t ctx,
member_expression_t left,
expression_t right 
)
static

Definition at line 3086 of file parser.tab.c.

3087 {
3089 
3090  stat = new_statement(ctx, STAT_SET, sizeof(*stat));
3091  if(!stat)
3092  return NULL;
3093 
3094  stat->member_expr = left;
3095  stat->value_expr = right;
3096  return &stat->stat;
3097 }
smooth NULL
Definition: ftsmooth.c:416
GLint left
Definition: glext.h:7726
GLdouble GLdouble right
Definition: glext.h:10859
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by yyparse().

◆ new_statement()

static void * new_statement ( parser_ctx_t ctx,
statement_type_t  type,
size_t  size 
)
static

Definition at line 3047 of file parser.tab.c.

3048 {
3049  statement_t *stat;
3050 
3051  stat = parser_alloc(ctx, size ? size : sizeof(*stat));
3052  if(stat) {
3053  stat->type = type;
3054  stat->next = NULL;
3055  }
3056 
3057  return stat;
3058 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
void * parser_alloc(parser_ctx_t *ctx, size_t size)
Definition: parser.tab.c:3405
GLsizeiptr size
Definition: glext.h:5919
Definition: stat.h:55
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345

Referenced by new_assign_statement(), new_call_statement(), new_const_statement(), new_dim_statement(), new_foreach_statement(), new_forto_statement(), new_function_statement(), new_if_statement(), new_onerror_statement(), new_select_statement(), new_set_statement(), new_while_statement(), and yyparse().

◆ new_string_expression()

static expression_t * new_string_expression ( parser_ctx_t ctx,
const WCHAR value 
)
static

Definition at line 2960 of file parser.tab.c.

2961 {
2963 
2964  expr = new_expression(ctx, EXPR_STRING, sizeof(*expr));
2965  if(!expr)
2966  return NULL;
2967 
2968  expr->value = value;
2969  return &expr->expr;
2970 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
GLsizei const GLfloat * value
Definition: glext.h:6069
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_unary_expression()

static expression_t * new_unary_expression ( parser_ctx_t ctx,
expression_type_t  type,
expression_t subexpr 
)
static

Definition at line 2996 of file parser.tab.c.

2997 {
2999 
3000  expr = new_expression(ctx, type, sizeof(*expr));
3001  if(!expr)
3002  return NULL;
3003 
3004  expr->subexpr = subexpr;
3005  return &expr->expr;
3006 }
struct complex_expr expr
Definition: query.h:91
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
Definition: query.h:86
smooth NULL
Definition: ftsmooth.c:416
static void * new_expression(parser_ctx_t *, expression_type_t, size_t)
Definition: parser.tab.c:2935

Referenced by yyparse().

◆ new_while_statement()

static statement_t * new_while_statement ( parser_ctx_t ctx,
statement_type_t  type,
expression_t expr,
statement_t body 
)
static

Definition at line 3153 of file parser.tab.c.

3154 {
3156 
3157  stat = new_statement(ctx, type, sizeof(*stat));
3158  if(!stat)
3159  return NULL;
3160 
3161  stat->expr = expr;
3162  stat->body = body;
3163  return &stat->stat;
3164 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
Definition: stat.h:55
static void * new_statement(parser_ctx_t *, statement_type_t, size_t)
Definition: parser.tab.c:3047
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
static const void * body(MD5_CTX *ctx, const void *data, unsigned long size)
Definition: md5.c:100

Referenced by yyparse().

◆ parse_complete()

static void parse_complete ( parser_ctx_t ctx,
BOOL  option_explicit 
)
static

Definition at line 2929 of file parser.tab.c.

2930 {
2931  ctx->parse_complete = TRUE;
2932  ctx->option_explicit = option_explicit;
2933 }
#define TRUE
Definition: types.h:120
BOOL option_explicit
Definition: parse.h:259
BOOL parse_complete
Definition: parse.h:260

Referenced by yyparse().

◆ parse_script()

HRESULT parse_script ( parser_ctx_t ctx,
const WCHAR code,
const WCHAR delimiter 
)

Definition at line 3415 of file parser.tab.c.

3416 {
3417  static const WCHAR html_delimiterW[] = {'<','/','s','c','r','i','p','t','>',0};
3418 
3419  ctx->code = ctx->ptr = code;
3420  ctx->end = ctx->code + strlenW(ctx->code);
3421 
3422  heap_pool_init(&ctx->heap);
3423 
3424  ctx->parse_complete = FALSE;
3425  ctx->hres = S_OK;
3426 
3427  ctx->last_token = tNL;
3428  ctx->last_nl = 0;
3429  ctx->stats = ctx->stats_tail = NULL;
3430  ctx->class_decls = NULL;
3431  ctx->option_explicit = FALSE;
3432  ctx->is_html = delimiter && !strcmpiW(delimiter, html_delimiterW);
3433 
3434  parser_parse(ctx);
3435 
3436  if(FAILED(ctx->hres))
3437  return ctx->hres;
3438  if(!ctx->parse_complete) {
3439  FIXME("parser failed around %s\n", debugstr_w(ctx->code+20 > ctx->ptr ? ctx->code : ctx->ptr-20));
3440  return E_FAIL;
3441  }
3442 
3443  return S_OK;
3444 }
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define E_FAIL
Definition: ddrawi.h:102
int parser_parse(parser_ctx_t *ctx)
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
const WCHAR * ptr
Definition: parse.h:256
smooth NULL
Definition: ftsmooth.c:416
const char * delimiter
Definition: string.c:1523
const WCHAR * code
Definition: parse.h:255
heap_pool_t heap
Definition: parse.h:271
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * end
Definition: parse.h:257
BOOL option_explicit
Definition: parse.h:259
int code
Definition: i386-dis.c:3591
void heap_pool_init(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:69
#define strcmpiW(s1, s2)
Definition: unicode.h:39
BOOL parse_complete
Definition: parse.h:260
#define S_OK
Definition: intsafe.h:59
statement_t * stats_tail
Definition: parse.h:268
unsigned last_nl
Definition: parse.h:265
statement_t * stats
Definition: parse.h:267
class_decl_t * class_decls
Definition: parse.h:269
HRESULT hres
Definition: parse.h:262
BOOL is_html
Definition: parse.h:261
int last_token
Definition: parse.h:264

Referenced by compile_script().

◆ parser_alloc()

void* parser_alloc ( parser_ctx_t ctx,
size_t  size 
)

Definition at line 3405 of file parser.tab.c.

3406 {
3407  void *ret;
3408 
3409  ret = heap_pool_alloc(&ctx->heap, size);
3410  if(!ret)
3411  ctx->hres = E_OUTOFMEMORY;
3412  return ret;
3413 }
void * heap_pool_alloc(heap_pool_t *, DWORD) __WINE_ALLOC_SIZE(2) DECLSPEC_HIDDEN
Definition: jsutils.c:75
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
heap_pool_t heap
Definition: parse.h:271
GLsizeiptr size
Definition: glext.h:5919
int ret
HRESULT hres
Definition: parse.h:262

Referenced by new_argument(), new_argument_decl(), new_array_element(), new_case_clausule(), new_catch_block(), new_class_decl(), new_const_decl(), new_dim(), new_dim_decl(), new_elseif_decl(), new_expression(), new_function_decl(), new_null_literal(), new_parameter(), new_property_definition(), new_source_elements(), new_statement(), new_string_literal(), and new_variable_declaration().

◆ parser_error()

static int parser_error ( parser_ctx_t ctx,
const char str 
)
static

Definition at line 2905 of file parser.tab.c.

2906 {
2907  return 0;
2908 }

◆ parser_parse()

int parser_parse ( parser_ctx_t ctx)

◆ parser_release()

void parser_release ( parser_ctx_t ctx)

Definition at line 3446 of file parser.tab.c.

3447 {
3448  heap_pool_free(&ctx->heap);
3449 }
heap_pool_t heap
Definition: parse.h:271
void heap_pool_free(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:167

Referenced by compile_script(), and release_compiler().

◆ source_add_class()

static void source_add_class ( parser_ctx_t ctx,
class_decl_t class_decl 
)
static

Definition at line 2923 of file parser.tab.c.

2924 {
2925  class_decl->next = ctx->class_decls;
2926  ctx->class_decls = class_decl;
2927 }
struct _class_decl_t * next
Definition: parse.h:187
class_decl_t * class_decls
Definition: parse.h:269

Referenced by yyparse().

◆ source_add_statement()

static void source_add_statement ( parser_ctx_t ctx,
statement_t stat 
)
static

Definition at line 2910 of file parser.tab.c.

2911 {
2912  if(!stat)
2913  return;
2914 
2915  if(ctx->stats) {
2916  ctx->stats_tail->next = stat;
2917  ctx->stats_tail = stat;
2918  }else {
2919  ctx->stats = ctx->stats_tail = stat;
2920  }
2921 }
statement_t * next
Definition: parser.h:125
Definition: stat.h:55
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
Definition: stat.h:345
statement_t * stats_tail
Definition: parse.h:268
statement_t * stats
Definition: parse.h:267

Referenced by yyparse().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( vbscript  )

◆ yydestruct()

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

Definition at line 1448 of file parser.tab.c.

1449 {
1450  YYUSE (yyvaluep);
1451  YYUSE (ctx);
1452  if (!yymsg)
1453  yymsg = "Deleting";
1454  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1455 
1457  YYUSE (yytype);
1459 }
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parser.tab.c:1198
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: parser.tab.c:364
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: parser.tab.c:363
#define YYUSE(E)
Definition: parser.tab.c:346

Referenced by yyparse().

◆ yyparse()

int yyparse ( parser_ctx_t ctx)

Definition at line 1469 of file parser.tab.c.

1470 {
1471 /* The lookahead symbol. */
1472 int yychar;
1473 
1474 
1475 /* The semantic value of the lookahead symbol. */
1476 /* Default value used for initialization, for pacifying older GCCs
1477  or non-GCC compilers. */
1478 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1479 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1480 
1481  /* Number of syntax errors so far. */
1482  int yynerrs;
1483 
1484  int yystate;
1485  /* Number of tokens to shift before error messages enabled. */
1486  int yyerrstatus;
1487 
1488  /* The stacks and their tools:
1489  'yyss': related to states.
1490  'yyvs': related to semantic values.
1491 
1492  Refer to the stacks through separate pointers, to allow yyoverflow
1493  to reallocate them elsewhere. */
1494 
1495  /* The state stack. */
1496  yytype_int16 yyssa[YYINITDEPTH];
1497  yytype_int16 *yyss;
1498  yytype_int16 *yyssp;
1499 
1500  /* The semantic value stack. */
1501  YYSTYPE yyvsa[YYINITDEPTH];
1502  YYSTYPE *yyvs;
1503  YYSTYPE *yyvsp;
1504 
1505  YYSIZE_T yystacksize;
1506 
1507  int yyn;
1508  int yyresult;
1509  /* Lookahead token as an internal (translated) token number. */
1510  int yytoken = 0;
1511  /* The variables used to return semantic value and location from the
1512  action routines. */
1513  YYSTYPE yyval;
1514 
1515 #if YYERROR_VERBOSE
1516  /* Buffer for error messages, and its allocated size. */
1517  char yymsgbuf[128];
1518  char *yymsg = yymsgbuf;
1519  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1520 #endif
1521 
1522 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1523 
1524  /* The number of symbols on the RHS of the reduced rule.
1525  Keep to zero when no symbol should be popped. */
1526  int yylen = 0;
1527 
1528  yyssp = yyss = yyssa;
1529  yyvsp = yyvs = yyvsa;
1530  yystacksize = YYINITDEPTH;
1531 
1532  YYDPRINTF ((stderr, "Starting parse\n"));
1533 
1534  yystate = 0;
1535  yyerrstatus = 0;
1536  yynerrs = 0;
1537  yychar = YYEMPTY; /* Cause a token to be read. */
1538  goto yysetstate;
1539 
1540 /*------------------------------------------------------------.
1541 | yynewstate -- Push a new state, which is found in yystate. |
1542 `------------------------------------------------------------*/
1543  yynewstate:
1544  /* In all cases, when you get here, the value and location stacks
1545  have just been pushed. So pushing a state here evens the stacks. */
1546  yyssp++;
1547 
1548  yysetstate:
1549  *yyssp = yystate;
1550 
1551  if (yyss + yystacksize - 1 <= yyssp)
1552  {
1553  /* Get the current used size of the three stacks, in elements. */
1554  YYSIZE_T yysize = yyssp - yyss + 1;
1555 
1556 #ifdef yyoverflow
1557  {
1558  /* Give user a chance to reallocate the stack. Use copies of
1559  these so that the &'s don't force the real ones into
1560  memory. */
1561  YYSTYPE *yyvs1 = yyvs;
1562  yytype_int16 *yyss1 = yyss;
1563 
1564  /* Each stack pointer address is followed by the size of the
1565  data in use in that stack, in bytes. This used to be a
1566  conditional around just the two extra args, but that might
1567  be undefined if yyoverflow is a macro. */
1568  yyoverflow (YY_("memory exhausted"),
1569  &yyss1, yysize * sizeof (*yyssp),
1570  &yyvs1, yysize * sizeof (*yyvsp),
1571  &yystacksize);
1572 
1573  yyss = yyss1;
1574  yyvs = yyvs1;
1575  }
1576 #else /* no yyoverflow */
1577 # ifndef YYSTACK_RELOCATE
1578  goto yyexhaustedlab;
1579 # else
1580  /* Extend the stack our own way. */
1581  if (YYMAXDEPTH <= yystacksize)
1582  goto yyexhaustedlab;
1583  yystacksize *= 2;
1584  if (YYMAXDEPTH < yystacksize)
1585  yystacksize = YYMAXDEPTH;
1586 
1587  {
1588  yytype_int16 *yyss1 = yyss;
1589  union yyalloc *yyptr =
1590  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1591  if (! yyptr)
1592  goto yyexhaustedlab;
1593  YYSTACK_RELOCATE (yyss_alloc, yyss);
1594  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1595 # undef YYSTACK_RELOCATE
1596  if (yyss1 != yyssa)
1597  YYSTACK_FREE (yyss1);
1598  }
1599 # endif
1600 #endif /* no yyoverflow */
1601 
1602  yyssp = yyss + yysize - 1;
1603  yyvsp = yyvs + yysize - 1;
1604 
1605  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1606  (unsigned long int) yystacksize));
1607 
1608  if (yyss + yystacksize - 1 <= yyssp)
1609  YYABORT;
1610  }
1611 
1612  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1613 
1614  if (yystate == YYFINAL)
1615  YYACCEPT;
1616 
1617  goto yybackup;
1618 
1619 /*-----------.
1620 | yybackup. |
1621 `-----------*/
1622 yybackup:
1623 
1624  /* Do appropriate processing given the current state. Read a
1625  lookahead token if we need one and don't already have one. */
1626 
1627  /* First try to decide what to do without reference to lookahead token. */
1628  yyn = yypact[yystate];
1629  if (yypact_value_is_default (yyn))
1630  goto yydefault;
1631 
1632  /* Not known => get a lookahead token if don't already have one. */
1633 
1634  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1635  if (yychar == YYEMPTY)
1636  {
1637  YYDPRINTF ((stderr, "Reading a token: "));
1638  yychar = yylex (&yylval, ctx);
1639  }
1640 
1641  if (yychar <= YYEOF)
1642  {
1643  yychar = yytoken = YYEOF;
1644  YYDPRINTF ((stderr, "Now at end of input.\n"));
1645  }
1646  else
1647  {
1648  yytoken = YYTRANSLATE (yychar);
1649  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1650  }
1651 
1652  /* If the proper action on seeing token YYTOKEN is to reduce or to
1653  detect an error, take that action. */
1654  yyn += yytoken;
1655  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1656  goto yydefault;
1657  yyn = yytable[yyn];
1658  if (yyn <= 0)
1659  {
1660  if (yytable_value_is_error (yyn))
1661  goto yyerrlab;
1662  yyn = -yyn;
1663  goto yyreduce;
1664  }
1665 
1666  /* Count tokens shifted since error; after three, turn off error
1667  status. */
1668  if (yyerrstatus)
1669  yyerrstatus--;
1670 
1671  /* Shift the lookahead token. */
1672  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1673 
1674  /* Discard the shifted token. */
1675  yychar = YYEMPTY;
1676 
1677  yystate = yyn;
1679  *++yyvsp = yylval;
1681 
1682  goto yynewstate;
1683 
1684 
1685 /*-----------------------------------------------------------.
1686 | yydefault -- do the default action for the current state. |
1687 `-----------------------------------------------------------*/
1688 yydefault:
1689  yyn = yydefact[yystate];
1690  if (yyn == 0)
1691  goto yyerrlab;
1692  goto yyreduce;
1693 
1694 
1695 /*-----------------------------.
1696 | yyreduce -- Do a reduction. |
1697 `-----------------------------*/
1698 yyreduce:
1699  /* yyn is the number of a rule to reduce with. */
1700  yylen = yyr2[yyn];
1701 
1702  /* If YYLEN is nonzero, implement the default value of the action:
1703  '$$ = $1'.
1704 
1705  Otherwise, the following line sets YYVAL to garbage.
1706  This behavior is undocumented and Bison
1707  users should not rely upon it. Assigning to YYVAL
1708  unconditionally makes the parser a bit smaller, and it avoids a
1709  GCC warning that YYVAL may be used uninitialized. */
1710  yyval = yyvsp[1-yylen];
1711 
1712 
1713  YY_REDUCE_PRINT (yyn);
1714  switch (yyn)
1715  {
1716  case 2:
1717 #line 147 "parser.y" /* yacc.c:1646 */
1718  { parse_complete(ctx, (yyvsp[-2].boolean)); }
1719 #line 1720 "parser.tab.c" /* yacc.c:1646 */
1720  break;
1721 
1722  case 3:
1723 #line 150 "parser.y" /* yacc.c:1646 */
1724  { (yyval.boolean) = FALSE; }
1725 #line 1726 "parser.tab.c" /* yacc.c:1646 */
1726  break;
1727 
1728  case 4:
1729 #line 151 "parser.y" /* yacc.c:1646 */
1730  { (yyval.boolean) = TRUE; }
1731 #line 1732 "parser.tab.c" /* yacc.c:1646 */
1732  break;
1733 
1734  case 6:
1735 #line 155 "parser.y" /* yacc.c:1646 */
1736  { source_add_statement(ctx, (yyvsp[0].statement)); }
1737 #line 1738 "parser.tab.c" /* yacc.c:1646 */
1738  break;
1739 
1740  case 7:
1741 #line 156 "parser.y" /* yacc.c:1646 */
1742  { source_add_class(ctx, (yyvsp[0].class_decl)); }
1743 #line 1744 "parser.tab.c" /* yacc.c:1646 */
1744  break;
1745 
1746  case 8:
1747 #line 159 "parser.y" /* yacc.c:1646 */
1748  { (yyval.statement) = NULL; }
1749 #line 1750 "parser.tab.c" /* yacc.c:1646 */
1750  break;
1751 
1752  case 9:
1753 #line 160 "parser.y" /* yacc.c:1646 */
1754  { (yyval.statement) = (yyvsp[0].statement); }
1755 #line 1756 "parser.tab.c" /* yacc.c:1646 */
1756  break;
1757 
1758  case 10:
1759 #line 163 "parser.y" /* yacc.c:1646 */
1760  { (yyval.statement) = (yyvsp[0].statement); }
1761 #line 1762 "parser.tab.c" /* yacc.c:1646 */
1762  break;
1763 
1764  case 11:
1765 #line 164 "parser.y" /* yacc.c:1646 */
1766  { (yyval.statement) = link_statements((yyvsp[-1].statement), (yyvsp[0].statement)); }
1767 #line 1768 "parser.tab.c" /* yacc.c:1646 */
1768  break;
1769 
1770  case 12:
1771 #line 167 "parser.y" /* yacc.c:1646 */
1772  { (yyval.statement) = (yyvsp[-1].statement); }
1773 #line 1774 "parser.tab.c" /* yacc.c:1646 */
1774  break;
1775 
1776  case 13:
1777 #line 170 "parser.y" /* yacc.c:1646 */
1778  { (yyval.statement) = NULL; }
1779 #line 1780 "parser.tab.c" /* yacc.c:1646 */
1780  break;
1781 
1782  case 14:
1783 #line 171 "parser.y" /* yacc.c:1646 */
1784  { (yyval.statement) = (yyvsp[0].statement); }
1785 #line 1786 "parser.tab.c" /* yacc.c:1646 */
1786  break;
1787 
1788  case 15:
1789 #line 172 "parser.y" /* yacc.c:1646 */
1790  { (yyval.statement) = (yyvsp[0].statement); }
1791 #line 1792 "parser.tab.c" /* yacc.c:1646 */
1792  break;
1793 
1794  case 16:
1795 #line 173 "parser.y" /* yacc.c:1646 */
1796  { (yyvsp[-2].statement)->next = (yyvsp[0].statement); (yyval.statement) = (yyvsp[-2].statement); }
1797 #line 1798 "parser.tab.c" /* yacc.c:1646 */
1798  break;
1799 
1800  case 17:
1801 #line 174 "parser.y" /* yacc.c:1646 */
1802  { (yyval.statement) = (yyvsp[-1].statement); }
1803 #line 1804 "parser.tab.c" /* yacc.c:1646 */
1804  break;
1805 
1806  case 18:
1807 #line 177 "parser.y" /* yacc.c:1646 */
1808  { (yyvsp[-1].member)->args = (yyvsp[0].expression); (yyval.statement) = new_call_statement(ctx, FALSE, (yyvsp[-1].member)); CHECK_ERROR; }
1809 #line 1810 "parser.tab.c" /* yacc.c:1646 */
1810  break;
1811 
1812  case 19:
1813 #line 178 "parser.y" /* yacc.c:1646 */
1814  { (yyvsp[-1].member)->args = (yyvsp[0].expression); (yyval.statement) = new_call_statement(ctx, TRUE, (yyvsp[-1].member)); CHECK_ERROR; }
1815 #line 1816 "parser.tab.c" /* yacc.c:1646 */
1816  break;
1817 
1818