ReactOS  0.4.13-dev-259-g5ca9c9c
ppy.tab.c File Reference
#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
#include "wpp_private.h"
#include <stddef.h>
Include dependency graph for ppy.tab.c:

Go to the source code of this file.

Classes

union  YYSTYPE
 
union  yyalloc
 

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.0.2"
 
#define YYSKELETON_NAME   "yacc.c"
 
#define YYPURE   0
 
#define YYPUSH   0
 
#define YYPULL   1
 
#define yyparse   ppy_parse
 
#define yylex   ppy_lex
 
#define yyerror   ppy_error
 
#define yydebug   ppy_debug
 
#define yynerrs   ppy_nerrs
 
#define yylval   ppy_lval
 
#define yychar   ppy_char
 
#define UNARY_OP(r, v, OP)
 
#define cv_signed(v)   ((v.type & FLAG_SIGNED) != 0)
 
#define BIN_OP_INT(r, v1, v2, OP)
 
#define BIN_OP_LONG(r, v1, v2, OP)
 
#define BIN_OP_LONGLONG(r, v1, v2, OP)
 
#define BIN_OP(r, v1, v2, OP)
 
#define YY_NULLPTR   0
 
#define YYERROR_VERBOSE   0
 
#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 YY_ATTRIBUTE(Spec)   /* empty */
 
#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
 
#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))
 
#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))
 
#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   2
 
#define YYLAST   303
 
#define YYNTOKENS   62
 
#define YYNNTS   13
 
#define YYNRULES   84
 
#define YYNSTATES   153
 
#define YYUNDEFTOK   2
 
#define YYMAXUTOK   300
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -27
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-27)))
 
#define YYTABLE_NINF   -1
 
#define yytable_value_is_error(Yytable_value)   0
 
#define yyerrok   (yyerrstatus = 0)
 
#define yyclearin   (yychar = YYEMPTY)
 
#define YYEMPTY   (-2)
 
#define YYEOF   0
 
#define YYACCEPT   goto yyacceptlab
 
#define YYABORT   goto yyabortlab
 
#define YYERROR   goto yyerrorlab
 
#define YYRECOVERING()   (!!yyerrstatus)
 
#define YYBACKUP(Token, Value)
 
#define YYTERROR   1
 
#define YYERRCODE   256
 
#define YYDPRINTF(Args)
 
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 
#define YY_STACK_PRINT(Bottom, Top)
 
#define YY_REDUCE_PRINT(Rule)
 
#define YYINITDEPTH   200
 
#define YYMAXDEPTH   10000
 
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
#define cv_sizeof(v)   ((int)(v->type & SIZE_MASK))
 

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

static int boolean (cval_t *v)
 
static void promote_equal_size (cval_t *v1, cval_t *v2)
 
static void cast_to_sint (cval_t *v)
 
static void cast_to_uint (cval_t *v)
 
static void cast_to_slong (cval_t *v)
 
static void cast_to_ulong (cval_t *v)
 
static void cast_to_sll (cval_t *v)
 
static void cast_to_ull (cval_t *v)
 
static marg_tnew_marg (char *str, def_arg_t type)
 
static marg_tadd_new_marg (char *str, def_arg_t type)
 
static int marg_index (char *id)
 
static mtext_tnew_mtext (char *str, int idx, def_exp_t type)
 
static mtext_tcombine_mtext (mtext_t *tail, mtext_t *mtp)
 
static charmerge_text (char *s1, char *s2)
 
int ppy_parse (void)
 
voidmalloc (YYSIZE_T)
 
void free (void *)
 
static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 
int yyparse (void)
 

Variables

static marg_t ** macro_args
 
static int nmacro_args
 
YYSTYPE ppy_lval
 
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_uint8 yytable []
 
static const yytype_uint8 yycheck []
 
static const yytype_uint8 yystos []
 
static const yytype_uint8 yyr1 []
 
static const yytype_uint8 yyr2 []
 
int yychar
 
YYSTYPE yylval
 
int yynerrs
 

Macro Definition Documentation

◆ _Noreturn

#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))

Definition at line 361 of file ppy.tab.c.

◆ BIN_OP

#define BIN_OP (   r,
  v1,
  v2,
  OP 
)
Value:
switch(v1.type & SIZE_MASK) \
{ \
case SIZE_INT: BIN_OP_INT(r, v1, v2, OP); break; \
case SIZE_LONG: BIN_OP_LONG(r, v1, v2, OP); break; \
case SIZE_LONGLONG: BIN_OP_LONGLONG(r, v1, v2, OP); break; \
default: pp_internal_error(__FILE__, __LINE__, "Invalid type indicator (0x%04x)", v1.type); \
}
#define SIZE_LONGLONG
Definition: wpp_private.h:162
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
void pp_internal_error(const char *file, int line, const char *s,...)
Definition: preproc.c:754
#define SIZE_MASK
Definition: wpp_private.h:163
#define BIN_OP_INT(r, v1, v2, OP)
Definition: ppy.tab.c:101
#define BIN_OP_LONGLONG(r, v1, v2, OP)
Definition: ppy.tab.c:123
#define OP(a, b)
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
#define SIZE_LONG
Definition: wpp_private.h:161
#define BIN_OP_LONG(r, v1, v2, OP)
Definition: ppy.tab.c:112
GLfloat GLfloat v1
Definition: glext.h:6062
#define SIZE_INT
Definition: wpp_private.h:160

Definition at line 134 of file ppy.tab.c.

◆ BIN_OP_INT

#define BIN_OP_INT (   r,
  v1,
  v2,
  OP 
)
Value:
r.type = v1.type; \
if(cv_signed(v1) && cv_signed(v2)) \
r.val.si = v1.val.si OP v2.val.si; \
else if(cv_signed(v1) && !cv_signed(v2)) \
r.val.si = v1.val.si OP (signed) v2.val.ui; \
else if(!cv_signed(v1) && cv_signed(v2)) \
r.val.si = (signed) v1.val.ui OP v2.val.si; \
else \
r.val.ui = v1.val.ui OP v2.val.ui;
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define signed
Definition: prototyp.h:114
#define OP(a, b)
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
#define cv_signed(v)
Definition: ppy.tab.c:99
GLfloat GLfloat v1
Definition: glext.h:6062

Definition at line 101 of file ppy.tab.c.

◆ BIN_OP_LONG

#define BIN_OP_LONG (   r,
  v1,
  v2,
  OP 
)
Value:
r.type = v1.type; \
if(cv_signed(v1) && cv_signed(v2)) \
r.val.sl = v1.val.sl OP v2.val.sl; \
else if(cv_signed(v1) && !cv_signed(v2)) \
r.val.sl = v1.val.sl OP (signed long) v2.val.ul; \
else if(!cv_signed(v1) && cv_signed(v2)) \
r.val.sl = (signed long) v1.val.ul OP v2.val.sl; \
else \
r.val.ul = v1.val.ul OP v2.val.ul;
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define OP(a, b)
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
#define long
Definition: qsort.c:33
#define cv_signed(v)
Definition: ppy.tab.c:99
GLfloat GLfloat v1
Definition: glext.h:6062

Definition at line 112 of file ppy.tab.c.

◆ BIN_OP_LONGLONG

#define BIN_OP_LONGLONG (   r,
  v1,
  v2,
  OP 
)
Value:
r.type = v1.type; \
if(cv_signed(v1) && cv_signed(v2)) \
r.val.sll = v1.val.sll OP v2.val.sll; \
else if(cv_signed(v1) && !cv_signed(v2)) \
r.val.sll = v1.val.sll OP (wrc_sll_t) v2.val.ull; \
else if(!cv_signed(v1) && cv_signed(v2)) \
r.val.sll = (wrc_sll_t) v1.val.ull OP v2.val.sll; \
else \
r.val.ull = v1.val.ull OP v2.val.ull;
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define OP(a, b)
long wrc_sll_t
Definition: wpp_private.h:154
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
#define cv_signed(v)
Definition: ppy.tab.c:99
GLfloat GLfloat v1
Definition: glext.h:6062

Definition at line 123 of file ppy.tab.c.

◆ cv_signed

#define cv_signed (   v)    ((v.type & FLAG_SIGNED) != 0)

Definition at line 99 of file ppy.tab.c.

◆ cv_sizeof

#define cv_sizeof (   v)    ((int)(v->type & SIZE_MASK))

◆ UNARY_OP

#define UNARY_OP (   r,
  v,
  OP 
)
Value:
switch(v.type) \
{ \
case cv_sint: r.val.si = OP v.val.si; break; \
case cv_uint: r.val.ui = OP v.val.ui; break; \
case cv_slong: r.val.sl = OP v.val.sl; break; \
case cv_ulong: r.val.ul = OP v.val.ul; break; \
case cv_sll: r.val.sll = OP v.val.sll; break; \
case cv_ull: r.val.ull = OP v.val.ull; break; \
}
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define OP(a, b)
const GLdouble * v
Definition: gl.h:2040

Definition at line 88 of file ppy.tab.c.

◆ YY_

#define YY_ (   Msgid)    Msgid

Definition at line 334 of file ppy.tab.c.

◆ YY_ATTRIBUTE

#define YY_ATTRIBUTE (   Spec)    /* empty */

Definition at line 344 of file ppy.tab.c.

◆ YY_ATTRIBUTE_PURE

#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))

Definition at line 349 of file ppy.tab.c.

◆ YY_ATTRIBUTE_UNUSED

#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))

Definition at line 353 of file ppy.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 384 of file ppy.tab.c.

◆ YY_IGNORE_MAYBE_UNINITIALIZED_END

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 385 of file ppy.tab.c.

◆ YY_INITIAL_VALUE

#define YY_INITIAL_VALUE (   Value)    Value

Definition at line 381 of file ppy.tab.c.

◆ YY_NULLPTR

#define YY_NULLPTR   0

Definition at line 175 of file ppy.tab.c.

◆ YY_REDUCE_PRINT

#define YY_REDUCE_PRINT (   Rule)

Definition at line 983 of file ppy.tab.c.

◆ YY_STACK_PRINT

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Definition at line 982 of file ppy.tab.c.

◆ YY_SYMBOL_PRINT

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

Definition at line 981 of file ppy.tab.c.

◆ YYABORT

#define YYABORT   goto yyabortlab

Definition at line 828 of file ppy.tab.c.

◆ YYACCEPT

#define YYACCEPT   goto yyacceptlab

Definition at line 827 of file ppy.tab.c.

◆ YYBACKUP

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

Definition at line 834 of file ppy.tab.c.

◆ YYBISON

#define YYBISON   1

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

◆ YYBISON_VERSION

#define YYBISON_VERSION   "3.0.2"

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

◆ yychar

#define yychar   ppy_char

Definition at line 70 of file ppy.tab.c.

◆ yyclearin

#define yyclearin   (yychar = YYEMPTY)

Definition at line 823 of file ppy.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 508 of file ppy.tab.c.

◆ YYCOPY_NEEDED

#define YYCOPY_NEEDED   1

Definition at line 480 of file ppy.tab.c.

◆ yydebug

#define yydebug   ppy_debug

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

◆ YYDEBUG

#define YYDEBUG   0

Definition at line 190 of file ppy.tab.c.

◆ YYDPRINTF

#define YYDPRINTF (   Args)

Definition at line 980 of file ppy.tab.c.

◆ YYEMPTY

#define YYEMPTY   (-2)

Definition at line 824 of file ppy.tab.c.

◆ YYEOF

#define YYEOF   0

Definition at line 825 of file ppy.tab.c.

◆ YYERRCODE

#define YYERRCODE   256

Definition at line 853 of file ppy.tab.c.

◆ yyerrok

#define yyerrok   (yyerrstatus = 0)

Definition at line 822 of file ppy.tab.c.

◆ yyerror

#define yyerror   ppy_error

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

◆ YYERROR

#define YYERROR   goto yyerrorlab

Definition at line 829 of file ppy.tab.c.

◆ YYERROR_VERBOSE

#define YYERROR_VERBOSE   0

Definition at line 184 of file ppy.tab.c.

◆ YYFINAL

#define YYFINAL   2

Definition at line 521 of file ppy.tab.c.

◆ YYFREE

#define YYFREE   free

Definition at line 451 of file ppy.tab.c.

◆ YYINITDEPTH

#define YYINITDEPTH   200

Definition at line 989 of file ppy.tab.c.

◆ YYLAST

#define YYLAST   303

Definition at line 523 of file ppy.tab.c.

◆ yylex

#define yylex   ppy_lex

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

◆ yylval

#define yylval   ppy_lval

Definition at line 69 of file ppy.tab.c.

◆ YYMALLOC

#define YYMALLOC   malloc

Definition at line 445 of file ppy.tab.c.

◆ YYMAXDEPTH

#define YYMAXDEPTH   10000

Definition at line 1000 of file ppy.tab.c.

◆ YYMAXUTOK

#define YYMAXUTOK   300

Definition at line 537 of file ppy.tab.c.

◆ yynerrs

#define yynerrs   ppy_nerrs

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

◆ YYNNTS

#define YYNNTS   13

Definition at line 528 of file ppy.tab.c.

◆ YYNRULES

#define YYNRULES   84

Definition at line 530 of file ppy.tab.c.

◆ YYNSTATES

#define YYNSTATES   153

Definition at line 532 of file ppy.tab.c.

◆ YYNTOKENS

#define YYNTOKENS   62

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

◆ YYPACT_NINF

#define YYPACT_NINF   -27

Definition at line 629 of file ppy.tab.c.

◆ yypact_value_is_default

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

Definition at line 631 of file ppy.tab.c.

◆ yyparse

#define yyparse   ppy_parse

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

◆ YYPOPSTACK

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

◆ YYPULL

#define YYPULL   1

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

◆ YYPURE

#define YYPURE   0

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

◆ YYPUSH

#define YYPUSH   0

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

◆ YYRECOVERING

#define YYRECOVERING ( )    (!!yyerrstatus)

Definition at line 832 of file ppy.tab.c.

◆ YYSIZE_MAXIMUM

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 324 of file ppy.tab.c.

◆ YYSIZE_T

#define YYSIZE_T   size_t

Definition at line 318 of file ppy.tab.c.

◆ YYSKELETON_NAME

#define YYSKELETON_NAME   "yacc.c"

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

◆ YYSTACK_ALLOC

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 431 of file ppy.tab.c.

◆ YYSTACK_ALLOC_MAXIMUM

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

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

◆ YYSTACK_BYTES

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

Definition at line 476 of file ppy.tab.c.

◆ YYSTACK_FREE

#define YYSTACK_FREE   YYFREE

Definition at line 432 of file ppy.tab.c.

◆ YYSTACK_GAP_MAXIMUM

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

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

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

◆ YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED   1

Definition at line 269 of file ppy.tab.c.

◆ YYSTYPE_IS_TRIVIAL

#define YYSTYPE_IS_TRIVIAL   1

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

◆ YYTABLE_NINF

#define YYTABLE_NINF   -1

Definition at line 634 of file ppy.tab.c.

◆ yytable_value_is_error

#define yytable_value_is_error (   Yytable_value)    0

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

◆ YYTERROR

#define YYTERROR   1

Definition at line 852 of file ppy.tab.c.

◆ YYTOKENTYPE

#define YYTOKENTYPE

Definition at line 198 of file ppy.tab.c.

◆ YYTRANSLATE

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

Definition at line 539 of file ppy.tab.c.

◆ YYUNDEFTOK

#define YYUNDEFTOK   2

Definition at line 536 of file ppy.tab.c.

◆ YYUSE

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

Definition at line 367 of file ppy.tab.c.

Typedef Documentation

◆ YYSTYPE

typedef union YYSTYPE YYSTYPE

Definition at line 249 of file ppy.tab.c.

◆ yytype_int16

Definition at line 308 of file ppy.tab.c.

◆ yytype_int8

Definition at line 296 of file ppy.tab.c.

◆ yytype_uint16

typedef unsigned short int yytype_uint16

Definition at line 302 of file ppy.tab.c.

◆ yytype_uint8

typedef unsigned char yytype_uint8

Definition at line 290 of file ppy.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 199 of file ppy.tab.c.

200  {
201  tRCINCLUDE = 258,
202  tIF = 259,
203  tIFDEF = 260,
204  tIFNDEF = 261,
205  tELSE = 262,
206  tELIF = 263,
207  tENDIF = 264,
208  tDEFINED = 265,
209  tNL = 266,
210  tINCLUDE = 267,
211  tLINE = 268,
212  tGCCLINE = 269,
213  tERROR = 270,
214  tWARNING = 271,
215  tPRAGMA = 272,
216  tPPIDENT = 273,
217  tUNDEF = 274,
218  tMACROEND = 275,
219  tCONCAT = 276,
220  tELIPSIS = 277,
221  tSTRINGIZE = 278,
222  tIDENT = 279,
223  tLITERAL = 280,
224  tMACRO = 281,
225  tDEFINE = 282,
226  tDQSTRING = 283,
227  tSQSTRING = 284,
228  tIQSTRING = 285,
229  tUINT = 286,
230  tSINT = 287,
231  tULONG = 288,
232  tSLONG = 289,
233  tULONGLONG = 290,
234  tSLONGLONG = 291,
235  tRCINCLUDEPATH = 292,
236  tLOGOR = 293,
237  tLOGAND = 294,
238  tEQ = 295,
239  tNE = 296,
240  tLTE = 297,
241  tGTE = 298,
242  tLSHIFT = 299,
243  tRSHIFT = 300
244  };
Definition: ppy.tab.c:209
Definition: ppy.tab.c:229
Definition: ppy.tab.c:211
Definition: ppy.tab.c:241
Definition: ppy.tab.c:202
Definition: ppy.tab.c:240
Definition: ppy.tab.c:238
Definition: ppy.tab.c:239
Definition: ppy.tab.c:205
Definition: ppy.tab.c:230
Definition: ppy.tab.c:206

Function Documentation

◆ add_new_marg()

static marg_t * add_new_marg ( char str,
def_arg_t  type 
)
static

Definition at line 2472 of file ppy.tab.c.

2473 {
2474  marg_t **new_macro_args;
2475  marg_t *ma;
2476  if(!str)
2477  return NULL;
2478  new_macro_args = pp_xrealloc(macro_args, (nmacro_args+1) * sizeof(macro_args[0]));
2479  if(!new_macro_args)
2480  return NULL;
2481  macro_args = new_macro_args;
2482  ma = new_marg(str, type);
2483  if(!ma)
2484  return NULL;
2485  macro_args[nmacro_args] = ma;
2486  nmacro_args++;
2487  return ma;
2488 }
static marg_t * new_marg(char *str, def_arg_t type)
Definition: ppy.tab.c:2461
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:91
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
static int nmacro_args
Definition: ppy.tab.c:166
static marg_t ** macro_args
Definition: ppy.tab.c:165

Referenced by yyparse().

◆ boolean()

static int boolean ( cval_t v)
static

Definition at line 2447 of file ppy.tab.c.

2448 {
2449  switch(v->type)
2450  {
2451  case cv_sint: return v->val.si != (int)0;
2452  case cv_uint: return v->val.ui != (unsigned int)0;
2453  case cv_slong: return v->val.sl != (long)0;
2454  case cv_ulong: return v->val.ul != (unsigned long)0;
2455  case cv_sll: return v->val.sll != (wrc_sll_t)0;
2456  case cv_ull: return v->val.ull != (wrc_ull_t)0;
2457  }
2458  return 0;
2459 }
unsigned long wrc_ull_t
Definition: wpp_private.h:155
long wrc_sll_t
Definition: wpp_private.h:154
const GLdouble * v
Definition: gl.h:2040
#define long
Definition: qsort.c:33
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

◆ cast_to_sint()

static void cast_to_sint ( cval_t v)
static

Definition at line 2326 of file ppy.tab.c.

2327 {
2328  switch(v->type)
2329  {
2330  case cv_sint: break;
2331  case cv_uint: break;
2332  case cv_slong: v->val.si = v->val.sl; break;
2333  case cv_ulong: v->val.si = v->val.ul; break;
2334  case cv_sll: v->val.si = v->val.sll; break;
2335  case cv_ull: v->val.si = v->val.ull; break;
2336  }
2337  v->type = cv_sint;
2338 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ cast_to_sll()

static void cast_to_sll ( cval_t v)
static

Definition at line 2382 of file ppy.tab.c.

2383 {
2384  switch(v->type)
2385  {
2386  case cv_sint: v->val.sll = v->val.si; break;
2387  case cv_uint: v->val.sll = v->val.ui; break;
2388  case cv_slong: v->val.sll = v->val.sl; break;
2389  case cv_ulong: v->val.sll = v->val.ul; break;
2390  case cv_sll: break;
2391  case cv_ull: break;
2392  }
2393  v->type = cv_sll;
2394 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ cast_to_slong()

static void cast_to_slong ( cval_t v)
static

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

2355 {
2356  switch(v->type)
2357  {
2358  case cv_sint: v->val.sl = v->val.si; break;
2359  case cv_uint: v->val.sl = v->val.ui; break;
2360  case cv_slong: break;
2361  case cv_ulong: break;
2362  case cv_sll: v->val.sl = v->val.sll; break;
2363  case cv_ull: v->val.sl = v->val.ull; break;
2364  }
2365  v->type = cv_slong;
2366 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ cast_to_uint()

static void cast_to_uint ( cval_t v)
static

Definition at line 2340 of file ppy.tab.c.

2341 {
2342  switch(v->type)
2343  {
2344  case cv_sint: break;
2345  case cv_uint: break;
2346  case cv_slong: v->val.ui = v->val.sl; break;
2347  case cv_ulong: v->val.ui = v->val.ul; break;
2348  case cv_sll: v->val.ui = v->val.sll; break;
2349  case cv_ull: v->val.ui = v->val.ull; break;
2350  }
2351  v->type = cv_uint;
2352 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ cast_to_ull()

static void cast_to_ull ( cval_t v)
static

Definition at line 2396 of file ppy.tab.c.

2397 {
2398  switch(v->type)
2399  {
2400  case cv_sint: v->val.ull = v->val.si; break;
2401  case cv_uint: v->val.ull = v->val.ui; break;
2402  case cv_slong: v->val.ull = v->val.sl; break;
2403  case cv_ulong: v->val.ull = v->val.ul; break;
2404  case cv_sll: break;
2405  case cv_ull: break;
2406  }
2407  v->type = cv_ull;
2408 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ cast_to_ulong()

static void cast_to_ulong ( cval_t v)
static

Definition at line 2368 of file ppy.tab.c.

2369 {
2370  switch(v->type)
2371  {
2372  case cv_sint: v->val.ul = v->val.si; break;
2373  case cv_uint: v->val.ul = v->val.ui; break;
2374  case cv_slong: break;
2375  case cv_ulong: break;
2376  case cv_sll: v->val.ul = v->val.sll; break;
2377  case cv_ull: v->val.ul = v->val.ull; break;
2378  }
2379  v->type = cv_ulong;
2380 }
const GLdouble * v
Definition: gl.h:2040

Referenced by promote_equal_size().

◆ combine_mtext()

static mtext_t * combine_mtext ( mtext_t tail,
mtext_t mtp 
)
static

Definition at line 2517 of file ppy.tab.c.

2518 {
2519  if(!tail)
2520  return mtp;
2521 
2522  if(!mtp)
2523  return tail;
2524 
2525  if(tail->type == exp_text && mtp->type == exp_text)
2526  {
2527  char *new_text;
2528  new_text = pp_xrealloc(tail->subst.text, strlen(tail->subst.text)+strlen(mtp->subst.text)+1);
2529  if(!new_text)
2530  return mtp;
2531  tail->subst.text = new_text;
2532  strcat(tail->subst.text, mtp->subst.text);
2533  free(mtp->subst.text);
2534  free(mtp);
2535  return tail;
2536  }
2537 
2538  if(tail->type == exp_concat && mtp->type == exp_concat)
2539  {
2540  free(mtp);
2541  return tail;
2542  }
2543 
2544  if(tail->type == exp_concat && mtp->type == exp_text)
2545  {
2546  int len = strlen(mtp->subst.text);
2547  while(len)
2548  {
2549 /* FIXME: should delete space from head of string */
2550  if(isspace(mtp->subst.text[len-1] & 0xff))
2551  mtp->subst.text[--len] = '\0';
2552  else
2553  break;
2554  }
2555 
2556  if(!len)
2557  {
2558  free(mtp->subst.text);
2559  free(mtp);
2560  return tail;
2561  }
2562  }
2563 
2564  if(tail->type == exp_text && mtp->type == exp_concat)
2565  {
2566  int len = strlen(tail->subst.text);
2567  while(len)
2568  {
2569  if(isspace(tail->subst.text[len-1] & 0xff))
2570  tail->subst.text[--len] = '\0';
2571  else
2572  break;
2573  }
2574 
2575  if(!len)
2576  {
2577  mtp->prev = tail->prev;
2578  mtp->next = tail->next;
2579  if(tail->prev)
2580  tail->prev->next = mtp;
2581  free(tail->subst.text);
2582  free(tail);
2583  return mtp;
2584  }
2585  }
2586 
2587  tail->next = mtp;
2588  mtp->prev = tail;
2589 
2590  return mtp;
2591 }
#define isspace(c)
Definition: acclib.h:69
struct outqueuenode * tail
Definition: adnsresfilter.c:66
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:91
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
struct mtext * prev
Definition: wpp_private.h:69
struct mtext * next
Definition: wpp_private.h:68
GLenum GLsizei len
Definition: glext.h:6722
def_exp_t type
Definition: wpp_private.h:70
char * text
Definition: wpp_private.h:72
void free(void *)
Definition: cabinet.c:147
union mtext::@4024 subst

Referenced by yyparse().

◆ free()

void free ( void )

Definition at line 147 of file cabinet.c.

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

Referenced by _aligned_free(), combine_mtext(), merge_text(), realloc(), START_TEST(), test_aligned_offset_realloc(), test_aligned_realloc(), test_calloc(), test_sbheap(), and yyparse().

◆ malloc()

void* malloc ( YYSIZE_T  )

◆ marg_index()

static int marg_index ( char id)
static

Definition at line 2490 of file ppy.tab.c.

2491 {
2492  int t;
2493  if(!id)
2494  return -1;
2495  for(t = 0; t < nmacro_args; t++)
2496  {
2497  if(!strcmp(id, macro_args[t]->arg))
2498  break;
2499  }
2500  return t < nmacro_args ? t : -1;
2501 }
GLdouble GLdouble t
Definition: gl.h:2047
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static int nmacro_args
Definition: ppy.tab.c:166
static marg_t ** macro_args
Definition: ppy.tab.c:165

Referenced by yyparse().

◆ merge_text()

static char * merge_text ( char s1,
char s2 
)
static

Definition at line 2593 of file ppy.tab.c.

2594 {
2595  int l1;
2596  int l2;
2597  char *snew;
2598  if(!s1)
2599  return s2;
2600  if(!s2)
2601  return s1;
2602  l1 = strlen(s1);
2603  l2 = strlen(s2);
2604  snew = pp_xrealloc(s1, l1+l2+1);
2605  if(!snew)
2606  {
2607  free(s2);
2608  return s1;
2609  }
2610  s1 = snew;
2611  memcpy(s1+l1, s2, l2+1);
2612  free(s2);
2613  return s1;
2614 }
struct S2 s2
void * pp_xrealloc(void *p, size_t size)
Definition: preproc.c:91
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
struct S1 s1
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
void free(void *)
Definition: cabinet.c:147

Referenced by yyparse().

◆ new_marg()

static marg_t * new_marg ( char str,
def_arg_t  type 
)
static

Definition at line 2461 of file ppy.tab.c.

2462 {
2463  marg_t *ma = pp_xmalloc(sizeof(marg_t));
2464  if(!ma)
2465  return NULL;
2466  ma->arg = str;
2467  ma->type = type;
2468  ma->nnl = 0;
2469  return ma;
2470 }
char * arg
Definition: wpp_private.h:53
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
void * pp_xmalloc(size_t size)
Definition: preproc.c:77
int nnl
Definition: wpp_private.h:54
def_arg_t type
Definition: wpp_private.h:52

Referenced by add_new_marg().

◆ new_mtext()

static mtext_t * new_mtext ( char str,
int  idx,
def_exp_t  type 
)
static

Definition at line 2503 of file ppy.tab.c.

2504 {
2505  mtext_t *mt = pp_xmalloc(sizeof(mtext_t));
2506  if(!mt)
2507  return NULL;
2508  if(str == NULL)
2509  mt->subst.argidx = idx;
2510  else
2511  mt->subst.text = str;
2512  mt->type = type;
2513  mt->next = mt->prev = NULL;
2514  return mt;
2515 }
struct mtext * prev
Definition: wpp_private.h:69
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
int argidx
Definition: wpp_private.h:73
struct mtext * next
Definition: wpp_private.h:68
unsigned int idx
Definition: utils.c:41
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
void * pp_xmalloc(size_t size)
Definition: preproc.c:77
def_exp_t type
Definition: wpp_private.h:70
char * text
Definition: wpp_private.h:72
union mtext::@4024 subst

Referenced by yyparse().

◆ ppy_parse()

int ppy_parse ( void  )

Referenced by wpp_parse().

◆ promote_equal_size()

static void promote_equal_size ( cval_t v1,
cval_t v2 
)
static

Definition at line 2411 of file ppy.tab.c.

2412 {
2413 #define cv_sizeof(v) ((int)(v->type & SIZE_MASK))
2414  int s1 = cv_sizeof(v1);
2415  int s2 = cv_sizeof(v2);
2416 #undef cv_sizeof
2417 
2418  if(s1 == s2)
2419  return;
2420  else if(s1 > s2)
2421  {
2422  switch(v1->type)
2423  {
2424  case cv_sint: cast_to_sint(v2); break;
2425  case cv_uint: cast_to_uint(v2); break;
2426  case cv_slong: cast_to_slong(v2); break;
2427  case cv_ulong: cast_to_ulong(v2); break;
2428  case cv_sll: cast_to_sll(v2); break;
2429  case cv_ull: cast_to_ull(v2); break;
2430  }
2431  }
2432  else
2433  {
2434  switch(v2->type)
2435  {
2436  case cv_sint: cast_to_sint(v1); break;
2437  case cv_uint: cast_to_uint(v1); break;
2438  case cv_slong: cast_to_slong(v1); break;
2439  case cv_ulong: cast_to_ulong(v1); break;
2440  case cv_sll: cast_to_sll(v1); break;
2441  case cv_ull: cast_to_ull(v1); break;
2442  }
2443  }
2444 }
static void cast_to_ulong(cval_t *v)
Definition: ppy.tab.c:2368
struct S2 s2
static void cast_to_ull(cval_t *v)
Definition: ppy.tab.c:2396
static void cast_to_uint(cval_t *v)
Definition: ppy.tab.c:2340
struct S1 s1
static void cast_to_slong(cval_t *v)
Definition: ppy.tab.c:2354
static void cast_to_sint(cval_t *v)
Definition: ppy.tab.c:2326
#define cv_sizeof(v)
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
static void cast_to_sll(cval_t *v)
Definition: ppy.tab.c:2382
GLfloat GLfloat v1
Definition: glext.h:6062

Referenced by yyparse().

◆ yydestruct()

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

Definition at line 1231 of file ppy.tab.c.

1232 {
1233  YYUSE (yyvaluep);
1234  if (!yymsg)
1235  yymsg = "Deleting";
1236  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1237 
1239  YYUSE (yytype);
1241 }
#define YYUSE(E)
Definition: ppy.tab.c:367
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: ppy.tab.c:384
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ppy.tab.c:981
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: ppy.tab.c:385

Referenced by yyparse().

◆ yyparse()

int yyparse ( void  )

Definition at line 1260 of file ppy.tab.c.

1261 {
1262  int yystate;
1263  /* Number of tokens to shift before error messages enabled. */
1264  int yyerrstatus;
1265 
1266  /* The stacks and their tools:
1267  'yyss': related to states.
1268  'yyvs': related to semantic values.
1269 
1270  Refer to the stacks through separate pointers, to allow yyoverflow
1271  to reallocate them elsewhere. */
1272 
1273  /* The state stack. */
1274  yytype_int16 yyssa[YYINITDEPTH];
1275  yytype_int16 *yyss;
1276  yytype_int16 *yyssp;
1277 
1278  /* The semantic value stack. */
1279  YYSTYPE yyvsa[YYINITDEPTH];
1280  YYSTYPE *yyvs;
1281  YYSTYPE *yyvsp;
1282 
1283  YYSIZE_T yystacksize;
1284 
1285  int yyn;
1286  int yyresult;
1287  /* Lookahead token as an internal (translated) token number. */
1288  int yytoken = 0;
1289  /* The variables used to return semantic value and location from the
1290  action routines. */
1291  YYSTYPE yyval;
1292 
1293 #if YYERROR_VERBOSE
1294  /* Buffer for error messages, and its allocated size. */
1295  char yymsgbuf[128];
1296  char *yymsg = yymsgbuf;
1297  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1298 #endif
1299 
1300 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1301 
1302  /* The number of symbols on the RHS of the reduced rule.
1303  Keep to zero when no symbol should be popped. */
1304  int yylen = 0;
1305 
1306  yyssp = yyss = yyssa;
1307  yyvsp = yyvs = yyvsa;
1308  yystacksize = YYINITDEPTH;
1309 
1310  YYDPRINTF ((stderr, "Starting parse\n"));
1311 
1312  yystate = 0;
1313  yyerrstatus = 0;
1314  yynerrs = 0;
1315  yychar = YYEMPTY; /* Cause a token to be read. */
1316  goto yysetstate;
1317 
1318 /*------------------------------------------------------------.
1319 | yynewstate -- Push a new state, which is found in yystate. |
1320 `------------------------------------------------------------*/
1321  yynewstate:
1322  /* In all cases, when you get here, the value and location stacks
1323  have just been pushed. So pushing a state here evens the stacks. */
1324  yyssp++;
1325 
1326  yysetstate:
1327  *yyssp = yystate;
1328 
1329  if (yyss + yystacksize - 1 <= yyssp)
1330  {
1331  /* Get the current used size of the three stacks, in elements. */
1332  YYSIZE_T yysize = yyssp - yyss + 1;
1333 
1334 #ifdef yyoverflow
1335  {
1336  /* Give user a chance to reallocate the stack. Use copies of
1337  these so that the &'s don't force the real ones into
1338  memory. */
1339  YYSTYPE *yyvs1 = yyvs;
1340  yytype_int16 *yyss1 = yyss;
1341 
1342  /* Each stack pointer address is followed by the size of the
1343  data in use in that stack, in bytes. This used to be a
1344  conditional around just the two extra args, but that might
1345  be undefined if yyoverflow is a macro. */
1346  yyoverflow (YY_("memory exhausted"),
1347  &yyss1, yysize * sizeof (*yyssp),
1348  &yyvs1, yysize * sizeof (*yyvsp),
1349  &yystacksize);
1350 
1351  yyss = yyss1;
1352  yyvs = yyvs1;
1353  }
1354 #else /* no yyoverflow */
1355 # ifndef YYSTACK_RELOCATE
1356  goto yyexhaustedlab;
1357 # else
1358  /* Extend the stack our own way. */
1359  if (YYMAXDEPTH <= yystacksize)
1360  goto yyexhaustedlab;
1361  yystacksize *= 2;
1362  if (YYMAXDEPTH < yystacksize)
1363  yystacksize = YYMAXDEPTH;
1364 
1365  {
1366  yytype_int16 *yyss1 = yyss;
1367  union yyalloc *yyptr =
1368  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1369  if (! yyptr)
1370  goto yyexhaustedlab;
1371  YYSTACK_RELOCATE (yyss_alloc, yyss);
1372  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1373 # undef YYSTACK_RELOCATE
1374  if (yyss1 != yyssa)
1375  YYSTACK_FREE (yyss1);
1376  }
1377 # endif
1378 #endif /* no yyoverflow */
1379 
1380  yyssp = yyss + yysize - 1;
1381  yyvsp = yyvs + yysize - 1;
1382 
1383  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1384  (unsigned long int) yystacksize));
1385 
1386  if (yyss + yystacksize - 1 <= yyssp)
1387  YYABORT;
1388  }
1389 
1390  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1391 
1392  if (yystate == YYFINAL)
1393  YYACCEPT;
1394 
1395  goto yybackup;
1396 
1397 /*-----------.
1398 | yybackup. |
1399 `-----------*/
1400 yybackup:
1401 
1402  /* Do appropriate processing given the current state. Read a
1403  lookahead token if we need one and don't already have one. */
1404 
1405  /* First try to decide what to do without reference to lookahead token. */
1406  yyn = yypact[yystate];
1407  if (yypact_value_is_default (yyn))
1408  goto yydefault;
1409 
1410  /* Not known => get a lookahead token if don't already have one. */
1411 
1412  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1413  if (yychar == YYEMPTY)
1414  {
1415  YYDPRINTF ((stderr, "Reading a token: "));
1416  yychar = yylex ();
1417  }
1418 
1419  if (yychar <= YYEOF)
1420  {
1421  yychar = yytoken = YYEOF;
1422  YYDPRINTF ((stderr, "Now at end of input.\n"));
1423  }
1424  else
1425  {
1426  yytoken = YYTRANSLATE (yychar);
1427  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1428  }
1429 
1430  /* If the proper action on seeing token YYTOKEN is to reduce or to
1431  detect an error, take that action. */
1432  yyn += yytoken;
1433  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1434  goto yydefault;
1435  yyn = yytable[yyn];
1436  if (yyn <= 0)
1437  {
1438  if (yytable_value_is_error (yyn))
1439  goto yyerrlab;
1440  yyn = -yyn;
1441  goto yyreduce;
1442  }
1443 
1444  /* Count tokens shifted since error; after three, turn off error
1445  status. */
1446  if (yyerrstatus)
1447  yyerrstatus--;
1448 
1449  /* Shift the lookahead token. */
1450  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1451 
1452  /* Discard the shifted token. */
1453  yychar = YYEMPTY;
1454 
1455  yystate = yyn;
1457  *++yyvsp = yylval;
1459 
1460  goto yynewstate;
1461 
1462 
1463 /*-----------------------------------------------------------.
1464 | yydefault -- do the default action for the current state. |
1465 `-----------------------------------------------------------*/
1466 yydefault:
1467  yyn = yydefact[yystate];
1468  if (yyn == 0)
1469  goto yyerrlab;
1470  goto yyreduce;
1471 
1472 
1473 /*-----------------------------.
1474 | yyreduce -- Do a reduction. |
1475 `-----------------------------*/
1476 yyreduce:
1477  /* yyn is the number of a rule to reduce with. */
1478  yylen = yyr2[yyn];
1479 
1480  /* If YYLEN is nonzero, implement the default value of the action:
1481  '$$ = $1'.
1482 
1483  Otherwise, the following line sets YYVAL to garbage.
1484  This behavior is undocumented and Bison
1485  users should not rely upon it. Assigning to YYVAL
1486  unconditionally makes the parser a bit smaller, and it avoids a
1487  GCC warning that YYVAL may be used uninitialized. */
1488  yyval = yyvsp[1-yylen];
1489 
1490 
1491  YY_REDUCE_PRINT (yyn);
1492  switch (yyn)
1493  {
1494  case 4:
1495 #line 186 "ppy.y" /* yacc.c:1646 */
1496  { pp_do_include((yyvsp[-1].cptr), 1); }
1497 #line 1498 "ppy.tab.c" /* yacc.c:1646 */
1498  break;
1499 
1500  case 5:
1501 #line 187 "ppy.y" /* yacc.c:1646 */
1502  { pp_do_include((yyvsp[-1].cptr), 0); }
1503 #line 1504 "ppy.tab.c" /* yacc.c:1646 */
1504  break;
1505 
1506  case 6:
1507 #line 188 "ppy.y" /* yacc.c:1646 */
1508  { pp_next_if_state(boolean(&(yyvsp[-1].cval))); }
1509 #line 1510 "ppy.tab.c" /* yacc.c:1646 */
1510  break;
1511 
1512  case 7:
1513 #line 189 "ppy.y" /* yacc.c:1646 */
1514  { pp_next_if_state(pplookup((yyvsp[-1].cptr)) != NULL); free((yyvsp[-1].cptr)); }
1515 #line 1516 "ppy.tab.c" /* yacc.c:1646 */
1516  break;
1517 
1518  case 8:
1519 #line 190 "ppy.y" /* yacc.c:1646 */
1520  {
1521  int t = pplookup((yyvsp[-1].cptr)) == NULL;
1522  if(pp_incl_state.state == 0 && t && !pp_incl_state.seen_junk)
1523  {
1524  pp_incl_state.state = 1;
1525  pp_incl_state.ppp = (yyvsp[-1].cptr);
1527  }
1528  else if(pp_incl_state.state != 1)
1529  {
1530  pp_incl_state.state = -1;
1531  free((yyvsp[-1].cptr));
1532  }
1533  else
1534  free((yyvsp[-1].cptr));
1536  if(pp_status.debug)
1537  fprintf(stderr, "tIFNDEF: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d\n",
1539  }
1540 #line 1541 "ppy.tab.c" /* yacc.c:1646 */
1541  break;
1542 
1543  case 9:
1544 #line 210 "ppy.y" /* yacc.c:1646 */
1545  {
1547  switch(s)
1548  {
1549  case if_true:
1550  case if_elif:
1552  break;
1553  case if_false:
1554  pp_push_if(boolean(&(yyvsp[-1].cval)) ? if_true : if_false);
1555  break;
1556  case if_ignore:
1558  break;
1559  case if_elsetrue:
1560  case if_elsefalse:
1561  ppy_error("#elif cannot follow #else");
1562  break;
1563  case if_error:
1564  break;
1565  default:
1566  pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #elif directive", s);
1567  }
1568  }
1569 #line 1570 "ppy.tab.c" /* yacc.c:1646 */
1570  break;
1571 
1572  case 10:
1573 #line 234 "ppy.y" /* yacc.c:1646 */
1574  {
1576  switch(s)
1577  {
1578  case if_true:
1580  break;
1581  case if_elif:
1583  break;
1584  case if_false:
1586  break;
1587  case if_ignore:
1589  break;
1590  case if_elsetrue:
1591  case if_elsefalse:
1592  ppy_error("#else clause already defined");
1593  break;
1594  case if_error:
1595  break;
1596  default:
1597  pp_internal_error(__FILE__, __LINE__, "Invalid pp_if_state (%d) in #else directive", s);
1598  }
1599  }
1600 #line 1601 "ppy.tab.c" /* yacc.c:1646 */
1601  break;
1602 
1603  case 11:
1604 #line 260 "ppy.y" /* yacc.c:1646 */
1605  {
1606  if(pp_pop_if() != if_error)
1607  {
1609  {
1610  pp_incl_state.state = 2;
1612  }
1613  else if(pp_incl_state.state != 1)
1614  {
1615  pp_incl_state.state = -1;
1616  }
1617  if(pp_status.debug)
1618  fprintf(stderr, "tENDIF: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d\n",
1620  }
1621  }
1622 #line 1623 "ppy.tab.c" /* yacc.c:1646 */
1623  break;
1624 
1625  case 12:
1626 #line 277 "ppy.y" /* yacc.c:1646 */
1627  { pp_del_define((yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1628 #line 1629 "ppy.tab.c" /* yacc.c:1646 */
1629  break;
1630 
1631  case 13:
1632 #line 278 "ppy.y" /* yacc.c:1646 */
1633  { pp_add_define((yyvsp[-2].cptr), (yyvsp[-1].cptr)); free((yyvsp[-2].cptr)); free((yyvsp[-1].cptr)); }
1634 #line 1635 "ppy.tab.c" /* yacc.c:1646 */
1635  break;
1636 
1637  case 14:
1638 #line 279 "ppy.y" /* yacc.c:1646 */
1639  {
1640  pp_add_macro((yyvsp[-5].cptr), macro_args, nmacro_args, (yyvsp[-1].mtext));
1641  }
1642 #line 1643 "ppy.tab.c" /* yacc.c:1646 */
1643  break;
1644 
1645  case 15:
1646 #line 282 "ppy.y" /* yacc.c:1646 */
1647  { if((yyvsp[-1].cptr)) pp_writestring("# %d %s\n", (yyvsp[-2].sint) , (yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1648 #line 1649 "ppy.tab.c" /* yacc.c:1646 */
1649  break;
1650 
1651  case 16:
1652 #line 283 "ppy.y" /* yacc.c:1646 */
1653  { if((yyvsp[-1].cptr)) pp_writestring("# %d %s\n", (yyvsp[-2].sint) , (yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1654 #line 1655 "ppy.tab.c" /* yacc.c:1646 */
1655  break;
1656 
1657  case 17:
1658 #line 285 "ppy.y" /* yacc.c:1646 */
1659  { if((yyvsp[-2].cptr)) pp_writestring("# %d %s %d\n", (yyvsp[-3].sint), (yyvsp[-2].cptr), (yyvsp[-1].sint)); free((yyvsp[-2].cptr)); }
1660 #line 1661 "ppy.tab.c" /* yacc.c:1646 */
1661  break;
1662 
1663  case 18:
1664 #line 287 "ppy.y" /* yacc.c:1646 */
1665  { if((yyvsp[-3].cptr)) pp_writestring("# %d %s %d %d\n", (yyvsp[-4].sint) ,(yyvsp[-3].cptr), (yyvsp[-2].sint), (yyvsp[-1].sint)); free((yyvsp[-3].cptr)); }
1666 #line 1667 "ppy.tab.c" /* yacc.c:1646 */
1667  break;
1668 
1669  case 19:
1670 #line 289 "ppy.y" /* yacc.c:1646 */
1671  { if((yyvsp[-4].cptr)) pp_writestring("# %d %s %d %d %d\n", (yyvsp[-5].sint) ,(yyvsp[-4].cptr) ,(yyvsp[-3].sint) ,(yyvsp[-2].sint), (yyvsp[-1].sint)); free((yyvsp[-4].cptr)); }
1672 #line 1673 "ppy.tab.c" /* yacc.c:1646 */
1673  break;
1674 
1675  case 20:
1676 #line 291 "ppy.y" /* yacc.c:1646 */
1677  { if((yyvsp[-5].cptr)) pp_writestring("# %d %s %d %d %d %d\n", (yyvsp[-6].sint) ,(yyvsp[-5].cptr) ,(yyvsp[-4].sint) ,(yyvsp[-3].sint), (yyvsp[-2].sint), (yyvsp[-1].sint)); free((yyvsp[-5].cptr)); }
1678 #line 1679 "ppy.tab.c" /* yacc.c:1646 */
1679  break;
1680 
1681  case 22:
1682 #line 293 "ppy.y" /* yacc.c:1646 */
1683  { ppy_error("#error directive: '%s'", (yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1684 #line 1685 "ppy.tab.c" /* yacc.c:1646 */
1685  break;
1686 
1687  case 23:
1688 #line 294 "ppy.y" /* yacc.c:1646 */
1689  { ppy_warning("#warning directive: '%s'", (yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1690 #line 1691 "ppy.tab.c" /* yacc.c:1646 */
1691  break;
1692 
1693  case 24:
1694 #line 295 "ppy.y" /* yacc.c:1646 */
1695  { pp_writestring("#pragma %s\n", (yyvsp[-1].cptr) ? (yyvsp[-1].cptr) : ""); free((yyvsp[-1].cptr)); }
1696 #line 1697 "ppy.tab.c" /* yacc.c:1646 */
1697  break;
1698 
1699  case 25:
1700 #line 296 "ppy.y" /* yacc.c:1646 */
1701  { if(pp_status.pedantic) ppy_warning("#ident ignored (arg: '%s')", (yyvsp[-1].cptr)); free((yyvsp[-1].cptr)); }
1702 #line 1703 "ppy.tab.c" /* yacc.c:1646 */
1703  break;
1704 
1705  case 26:
1706 #line 297 "ppy.y" /* yacc.c:1646 */
1707  {
1708  if((yyvsp[0].cptr))
1709  {
1710  int nl=strlen((yyvsp[0].cptr)) +3;
1711  char *fn=pp_xmalloc(nl);
1712  if(fn)
1713  {
1714  sprintf(fn,"\"%s\"",(yyvsp[0].cptr));
1715  pp_do_include(fn,1);
1716  }
1717  free((yyvsp[0].cptr));
1718  }
1719  }
1720 #line 1721 "ppy.tab.c" /* yacc.c:1646 */
1721  break;
1722 
1723  case 27:
1724 #line 310 "ppy.y" /* yacc.c:1646 */
1725  {
1726  pp_do_include((yyvsp[0].cptr),1);
1727  }
1728 #line 1729 "ppy.tab.c" /* yacc.c:1646 */
1729  break;
1730 
1731  case 28:
1732 #line 316 "ppy.y" /* yacc.c:1646 */
1733  { (yyval.cptr) = NULL; }
1734 #line 1735 "ppy.tab.c" /* yacc.c:1646 */
1735  break;
1736 
1737  case 29:
1738 #line 317 "ppy.y" /* yacc.c:1646 */
1739  { (yyval.cptr) = (yyvsp[0].cptr); }
1740 #line 1741 "ppy.tab.c" /* yacc.c:1646 */
1741  break;
1742 
1743  case 30:
1744 #line 320 "ppy.y" /* yacc.c:1646 */
1745  { (yyval.cptr) = (yyvsp[0].cptr); }
1746 #line 1747 "ppy.tab.c" /* yacc.c:1646 */
1747  break;
1748 
1749  case 31:
1750 #line 321 "ppy.y" /* yacc.c:1646 */
1751  { (yyval.cptr) = (yyvsp[0].cptr); }
1752 #line 1753 "ppy.tab.c" /* yacc.c:1646 */
1753  break;
1754 
1755  case 32:
1756 #line 322 "ppy.y" /* yacc.c:1646 */
1757  { (yyval.cptr) = (yyvsp[0].cptr); }
1758 #line 1759 "ppy.tab.c" /* yacc.c:1646 */
1759  break;
1760 
1761  case 33:
1762 #line 323 "ppy.y" /* yacc.c:1646 */
1763  { (yyval.cptr) = merge_text((yyvsp[-1].cptr), (yyvsp[0].cptr)); }
1764 #line 1765 "ppy.tab.c" /* yacc.c:1646 */
1765  break;
1766 
1767  case 34:
1768 #line 324 "ppy.y" /* yacc.c:1646 */
1769  { (yyval.cptr) = merge_text((yyvsp[-1].cptr), (yyvsp[0].cptr)); }
1770 #line 1771 "ppy.tab.c" /* yacc.c:1646 */
1771  break;
1772 
1773  case 35:
1774 #line 325 "ppy.y" /* yacc.c:1646 */
1775  { (yyval.cptr) = merge_text((yyvsp[-1].cptr), (yyvsp[0].cptr)); }
1776 #line 1777 "ppy.tab.c" /* yacc.c:1646 */
1777  break;
1778 
1779  case 36:
1780 #line 328 "ppy.y" /* yacc.c:1646 */
1781  { macro_args = NULL; nmacro_args = 0; }
1782 #line 1783 "ppy.tab.c" /* yacc.c:1646 */
1783  break;
1784 
1785  case 37:
1786 #line 331 "ppy.y" /* yacc.c:1646 */
1787  { (yyval.sint) = 0; macro_args = NULL; nmacro_args = 0; }
1788 #line 1789 "ppy.tab.c" /* yacc.c:1646 */
1789  break;
1790 
1791  case 38:
1792 #line 332 "ppy.y" /* yacc.c:1646 */
1793  { (yyval.sint) = nmacro_args; }
1794 #line 1795 "ppy.tab.c" /* yacc.c:1646 */
1795  break;
1796 
1797  case 39:
1798 #line 335 "ppy.y" /* yacc.c:1646 */
1799  { (yyval.marg) = (yyvsp[0].marg); }
1800 #line 1801 "ppy.tab.c" /* yacc.c:1646 */
1801  break;
1802 
1803  case 40:
1804 #line 336 "ppy.y" /* yacc.c:1646 */
1805  { (yyval.marg) = add_new_marg(NULL, arg_list); nmacro_args *= -1; }
1806 #line 1807 "ppy.tab.c" /* yacc.c:1646 */
1807  break;
1808 
1809  case 41:
1810 #line 339 "ppy.y" /* yacc.c:1646 */
1811  { (yyval.marg) = add_new_marg((yyvsp[0].cptr), arg_single); }
1812 #line 1813 "ppy.tab.c" /* yacc.c:1646 */
1813  break;
1814 
1815  case 42:
1816 #line 340 "ppy.y" /* yacc.c:1646 */
1817  { (yyval.marg) = add_new_marg((yyvsp[0].cptr), arg_single); }
1818 #line 1819 "ppy.tab.c" /* yacc.c:1646 */
1819  break;
1820 
1821  case 43:
1822 #line 344 "ppy.y" /* yacc.c:1646 */
1823  { (yyval.mtext) = NULL; }
1824 #line 1825 "ppy.tab.c" /* yacc.c:1646 */
1825  break;
1826 
1827  case 44:
1828 #line 345 "ppy.y" /* yacc.c:1646 */
1829  {
1830  for((yyval.mtext) = (yyvsp[0].mtext); (yyval.mtext) && (yyval.mtext)->prev; (yyval.mtext) = (yyval.mtext)->prev)
1831  ;
1832  }
1833 #line 1834 "ppy.tab.c" /* yacc.c:1646 */
1834  break;
1835 
1836  case 45:
1837 #line 351 "ppy.y" /* yacc.c:1646 */
1838  { (yyval.mtext) = (yyvsp[0].mtext); }
1839 #line 1840 "ppy.tab.c" /* yacc.c:1646 */
1840  break;
1841 
1842  case 46:
1843 #line 352 "ppy.y" /* yacc.c:1646 */
1844  { (yyval.mtext) = combine_mtext((yyvsp[-1].mtext), (yyvsp[0].mtext)); }
1845 #line 1846 "ppy.tab.c" /* yacc.c:1646 */
1846  break;
1847 
1848  case 47:
1849 #line 355 "ppy.y" /* yacc.c:1646 */
1850  { (yyval.mtext) = new_mtext((yyvsp[0].cptr), 0, exp_text); }
1851 #line 1852 "ppy.tab.c" /* yacc.c:1646 */
1852  break;
1853 
1854  case 48:
1855 #line 356 "ppy.y" /* yacc.c:1646 */
1856  { (yyval.mtext) = new_mtext((yyvsp[0].cptr), 0, exp_text); }
1857 #line 1858 "ppy.tab.c" /* yacc.c:1646 */
1858  break;
1859 
1860  case 49:
1861 #line 357 "ppy.y" /* yacc.c:1646 */
1862  { (yyval.mtext) = new_mtext((yyvsp[0].cptr), 0, exp_text); }
1863 #line 1864 "ppy.tab.c" /* yacc.c:1646 */
1864  break;
1865 
1866  case 50:
1867 #line 358 "ppy.y" /* yacc.c:1646 */
1868  { (yyval.mtext) = new_mtext(NULL, 0, exp_concat); }
1869 #line 1870 "ppy.tab.c" /* yacc.c:1646 */
1870  break;
1871 
1872  case 51:
1873 #line 359 "ppy.y" /* yacc.c:1646 */
1874  {
1875  int mat = marg_index((yyvsp[0].cptr));
1876  if(mat < 0)
1877  ppy_error("Stringification identifier must be an argument parameter");
1878  else
1879  (yyval.mtext) = new_mtext(NULL, mat, exp_stringize);
1880  }
1881 #line 1882 "ppy.tab.c" /* yacc.c:1646 */
1882  break;
1883 
1884  case 52:
1885 #line 366 "ppy.y" /* yacc.c:1646 */
1886  {
1887  int mat = marg_index((yyvsp[0].cptr));
1888  if(mat >= 0)
1889  (yyval.mtext) = new_mtext(NULL, mat, exp_subst);
1890  else if((yyvsp[0].cptr))
1891  (yyval.mtext) = new_mtext((yyvsp[0].cptr), 0, exp_text);
1892  }
1893 #line 1894 "ppy.tab.c" /* yacc.c:1646 */
1894  break;
1895 
1896  case 53:
1897 #line 375 "ppy.y" /* yacc.c:1646 */
1898  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = (yyvsp[0].sint); }
1899 #line 1900 "ppy.tab.c" /* yacc.c:1646 */
1900  break;
1901 
1902  case 54:
1903 #line 376 "ppy.y" /* yacc.c:1646 */
1904  { (yyval.cval).type = cv_uint; (yyval.cval).val.ui = (yyvsp[0].uint); }
1905 #line 1906 "ppy.tab.c" /* yacc.c:1646 */
1906  break;
1907 
1908  case 55:
1909 #line 377 "ppy.y" /* yacc.c:1646 */
1910  { (yyval.cval).type = cv_slong; (yyval.cval).val.sl = (yyvsp[0].slong); }
1911 #line 1912 "ppy.tab.c" /* yacc.c:1646 */
1912  break;
1913 
1914  case 56:
1915 #line 378 "ppy.y" /* yacc.c:1646 */
1916  { (yyval.cval).type = cv_ulong; (yyval.cval).val.ul = (yyvsp[0].ulong); }
1917 #line 1918 "ppy.tab.c" /* yacc.c:1646 */
1918  break;
1919 
1920  case 57:
1921 #line 379 "ppy.y" /* yacc.c:1646 */
1922  { (yyval.cval).type = cv_sll; (yyval.cval).val.sll = (yyvsp[0].sll); }
1923 #line 1924 "ppy.tab.c" /* yacc.c:1646 */
1924  break;
1925 
1926  case 58:
1927 #line 380 "ppy.y" /* yacc.c:1646 */
1928  { (yyval.cval).type = cv_ull; (yyval.cval).val.ull = (yyvsp[0].ull); }
1929 #line 1930 "ppy.tab.c" /* yacc.c:1646 */
1930  break;
1931 
1932  case 59:
1933 #line 381 "ppy.y" /* yacc.c:1646 */
1934  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = pplookup((yyvsp[0].cptr)) != NULL; }
1935 #line 1936 "ppy.tab.c" /* yacc.c:1646 */
1936  break;
1937 
1938  case 60:
1939 #line 382 "ppy.y" /* yacc.c:1646 */
1940  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = pplookup((yyvsp[-1].cptr)) != NULL; }
1941 #line 1942 "ppy.tab.c" /* yacc.c:1646 */
1942  break;
1943 
1944  case 61:
1945 #line 383 "ppy.y" /* yacc.c:1646 */
1946  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = 0; }
1947 #line 1948 "ppy.tab.c" /* yacc.c:1646 */
1948  break;
1949 
1950  case 62:
1951 #line 384 "ppy.y" /* yacc.c:1646 */
1952  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = boolean(&(yyvsp[-2].cval)) || boolean(&(yyvsp[0].cval)); }
1953 #line 1954 "ppy.tab.c" /* yacc.c:1646 */
1954  break;
1955 
1956  case 63:
1957 #line 385 "ppy.y" /* yacc.c:1646 */
1958  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = boolean(&(yyvsp[-2].cval)) && boolean(&(yyvsp[0].cval)); }
1959 #line 1960 "ppy.tab.c" /* yacc.c:1646 */
1960  break;
1961 
1962  case 64:
1963 #line 386 "ppy.y" /* yacc.c:1646 */
1964  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), ==); }
1965 #line 1966 "ppy.tab.c" /* yacc.c:1646 */
1966  break;
1967 
1968  case 65:
1969 #line 387 "ppy.y" /* yacc.c:1646 */
1970  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), !=); }
1971 #line 1972 "ppy.tab.c" /* yacc.c:1646 */
1972  break;
1973 
1974  case 66:
1975 #line 388 "ppy.y" /* yacc.c:1646 */
1976  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), <); }
1977 #line 1978 "ppy.tab.c" /* yacc.c:1646 */
1978  break;
1979 
1980  case 67:
1981 #line 389 "ppy.y" /* yacc.c:1646 */
1982  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), >); }
1983 #line 1984 "ppy.tab.c" /* yacc.c:1646 */
1984  break;
1985 
1986  case 68:
1987 #line 390 "ppy.y" /* yacc.c:1646 */
1988  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), <=); }
1989 #line 1990 "ppy.tab.c" /* yacc.c:1646 */
1990  break;
1991 
1992  case 69:
1993 #line 391 "ppy.y" /* yacc.c:1646 */
1994  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), >=); }
1995 #line 1996 "ppy.tab.c" /* yacc.c:1646 */
1996  break;
1997 
1998  case 70:
1999 #line 392 "ppy.y" /* yacc.c:1646 */
2000  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), +); }
2001 #line 2002 "ppy.tab.c" /* yacc.c:1646 */
2002  break;
2003 
2004  case 71:
2005 #line 393 "ppy.y" /* yacc.c:1646 */
2006  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), -); }
2007 #line 2008 "ppy.tab.c" /* yacc.c:1646 */
2008  break;
2009 
2010  case 72:
2011 #line 394 "ppy.y" /* yacc.c:1646 */
2012  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), ^); }
2013 #line 2014 "ppy.tab.c" /* yacc.c:1646 */
2014  break;
2015 
2016  case 73:
2017 #line 395 "ppy.y" /* yacc.c:1646 */
2018  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), &); }
2019 #line 2020 "ppy.tab.c" /* yacc.c:1646 */
2020  break;
2021 
2022  case 74:
2023 #line 396 "ppy.y" /* yacc.c:1646 */
2024  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), |); }
2025 #line 2026 "ppy.tab.c" /* yacc.c:1646 */
2026  break;
2027 
2028  case 75:
2029 #line 397 "ppy.y" /* yacc.c:1646 */
2030  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), *); }
2031 #line 2032 "ppy.tab.c" /* yacc.c:1646 */
2032  break;
2033 
2034  case 76:
2035 #line 398 "ppy.y" /* yacc.c:1646 */
2036  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), /); }
2037 #line 2038 "ppy.tab.c" /* yacc.c:1646 */
2038  break;
2039 
2040  case 77:
2041 #line 399 "ppy.y" /* yacc.c:1646 */
2042  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), <<); }
2043 #line 2044 "ppy.tab.c" /* yacc.c:1646 */
2044  break;
2045 
2046  case 78:
2047 #line 400 "ppy.y" /* yacc.c:1646 */
2048  { promote_equal_size(&(yyvsp[-2].cval), &(yyvsp[0].cval)); BIN_OP((yyval.cval), (yyvsp[-2].cval), (yyvsp[0].cval), >>); }
2049 #line 2050 "ppy.tab.c" /* yacc.c:1646 */
2050  break;
2051 
2052  case 79:
2053 #line 401 "ppy.y" /* yacc.c:1646 */
2054  { (yyval.cval) = (yyvsp[0].cval); }
2055 #line 2056 "ppy.tab.c" /* yacc.c:1646 */
2056  break;
2057 
2058  case 80:
2059 #line 402 "ppy.y" /* yacc.c:1646 */
2060  { UNARY_OP((yyval.cval), (yyvsp[0].cval), -); }
2061 #line 2062 "ppy.tab.c" /* yacc.c:1646 */
2062  break;
2063 
2064  case 81:
2065 #line 403 "ppy.y" /* yacc.c:1646 */
2066  { UNARY_OP((yyval.cval), (yyvsp[0].cval), ~); }
2067 #line 2068 "ppy.tab.c" /* yacc.c:1646 */
2068  break;
2069 
2070  case 82:
2071 #line 404 "ppy.y" /* yacc.c:1646 */
2072  { (yyval.cval).type = cv_sint; (yyval.cval).val.si = !boolean(&(yyvsp[0].cval)); }
2073 #line 2074 "ppy.tab.c" /* yacc.c:1646 */
2074  break;
2075 
2076  case 83:
2077 #line 405 "ppy.y" /* yacc.c:1646 */
2078  { (yyval.cval) = (yyvsp[-1].cval); }
2079 #line 2080 "ppy.tab.c" /* yacc.c:1646 */
2080  break;
2081 
2082  case 84:
2083 #line 406 "ppy.y" /* yacc.c:1646 */
2084  { (yyval.cval) = boolean(&(yyvsp[-4].cval)) ? (yyvsp[-2].cval) : (yyvsp[0].cval); }
2085 #line 2086 "ppy.tab.c" /* yacc.c:1646 */
2086  break;
2087 
2088 
2089 #line 2090 "ppy.tab.c" /* yacc.c:1646 */
2090  default: break;
2091  }
2092  /* User semantic actions sometimes alter yychar, and that requires
2093  that yytoken be updated with the new translation. We take the
2094  approach of translating immediately before every use of yytoken.
2095  One alternative is translating here after every semantic action,
2096  but that translation would be missed if the semantic action invokes
2097  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2098  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2099  incorrect destructor might then be invoked immediately. In the
2100  case of YYERROR or YYBACKUP, subsequent parser actions might lead
2101  to an incorrect destructor call or verbose syntax error message
2102  before the lookahead is translated. */
2103  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2104 
2105  YYPOPSTACK (yylen);
2106  yylen = 0;
2107  YY_STACK_PRINT (yyss, yyssp);
2108 
2109  *++yyvsp = yyval;
2110 
2111  /* Now 'shift' the result of the reduction. Determine what state
2112  that goes to, based on the state we popped back to and the rule
2113  number reduced by. */
2114 
2115  yyn = yyr1[yyn];
2116 
2117  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2118  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2119  yystate = yytable[yystate];
2120  else
2121  yystate = yydefgoto[yyn - YYNTOKENS];
2122 
2123  goto yynewstate;
2124 
2125 
2126 /*--------------------------------------.
2127 | yyerrlab -- here on detecting error. |
2128 `--------------------------------------*/
2129 yyerrlab:
2130  /* Make sure we have latest lookahead translation. See comments at
2131  user semantic actions for why this is necessary. */
2132  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2133 
2134  /* If not already recovering from an error, report this error. */
2135  if (!yyerrstatus)
2136  {
2137  ++yynerrs;
2138 #if ! YYERROR_VERBOSE
2139  yyerror (YY_("syntax error"));
2140 #else
2141 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2142  yyssp, yytoken)
2143  {
2144  char const *yymsgp = YY_("syntax error");
2145  int yysyntax_error_status;
2146  yysyntax_error_status = YYSYNTAX_ERROR;
2147  if (yysyntax_error_status == 0)
2148  yymsgp = yymsg;
2149  else if (yysyntax_error_status == 1)
2150  {
2151  if (yymsg != yymsgbuf)
2152  YYSTACK_FREE (yymsg);
2153  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2154  if (!yymsg)
2155  {
2156  yymsg = yymsgbuf;
2157  yymsg_alloc = sizeof yymsgbuf;
2158  yysyntax_error_status = 2;
2159  }
2160  else
2161  {
2162  yysyntax_error_status = YYSYNTAX_ERROR;
2163  yymsgp = yymsg;
2164  }
2165  }
2166  yyerror (yymsgp);
2167  if (yysyntax_error_status == 2)
2168  goto yyexhaustedlab;
2169  }
2170 # undef YYSYNTAX_ERROR
2171 #endif
2172  }
2173 
2174 
2175 
2176  if (yyerrstatus == 3)
2177  {
2178  /* If just tried and failed to reuse lookahead token after an
2179  error, discard it. */
2180 
2181  if (yychar <= YYEOF)
2182  {
2183  /* Return failure if at end of input. */
2184  if (yychar == YYEOF)
2185  YYABORT;
2186  }
2187  else
2188  {
2189  yydestruct ("Error: discarding",
2190  yytoken, &yylval);
2191  yychar = YYEMPTY;
2192  }
2193  }
2194 
2195  /* Else will try to reuse lookahead token after shifting the error
2196  token. */
2197  goto yyerrlab1;
2198 
2199 
2200 /*---------------------------------------------------.
2201 | yyerrorlab -- error raised explicitly by YYERROR. |
2202 `---------------------------------------------------*/
2203 yyerrorlab:
2204 
2205  /* Pacify compilers like GCC when the user code never invokes
2206  YYERROR and the label yyerrorlab therefore never appears in user
2207  code. */
2208  if (/*CONSTCOND*/ 0)
2209  goto yyerrorlab;
2210 
2211  /* Do not reclaim the symbols of the rule whose action triggered
2212  this YYERROR. */
2213  YYPOPSTACK (yylen);
2214  yylen = 0;
2215  YY_STACK_PRINT (yyss, yyssp);
2216  yystate = *yyssp;
2217  goto yyerrlab1;
2218 
2219 
2220 /*-------------------------------------------------------------.
2221 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2222 `-------------------------------------------------------------*/
2223 yyerrlab1:
2224  yyerrstatus = 3; /* Each real token shifted decrements this. */
2225 
2226  for (;;)
2227  {
2228  yyn = yypact[yystate];
2229  if (!yypact_value_is_default (yyn))
2230  {
2231  yyn += YYTERROR;
2232  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2233  {
2234  yyn = yytable[yyn];
2235  if (0 < yyn)
2236  break;
2237  }
2238  }
2239 
2240  /* Pop the current state because it cannot handle the error token. */
2241  if (yyssp == yyss)
2242  YYABORT;
2243 
2244 
2245  yydestruct ("Error: popping",
2246  yystos[yystate], yyvsp);
2247  YYPOPSTACK (1);
2248  yystate = *yyssp;
2249  YY_STACK_PRINT (yyss, yyssp);
2250  }
2251 
2253  *++yyvsp = yylval;
2255 
2256 
2257  /* Shift the error token. */
2258  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2259 
2260  yystate = yyn;
2261  goto yynewstate;
2262 
2263 
2264 /*-------------------------------------.
2265 | yyacceptlab -- YYACCEPT comes here. |
2266 `-------------------------------------*/
2267 yyacceptlab:
2268  yyresult = 0;
2269  goto yyreturn;
2270 
2271 /*-----------------------------------.
2272 | yyabortlab -- YYABORT comes here. |
2273 `-----------------------------------*/
2274 yyabortlab:
2275  yyresult = 1;
2276  goto yyreturn;
2277 
2278 #if !defined yyoverflow || YYERROR_VERBOSE
2279 /*-------------------------------------------------.
2280 | yyexhaustedlab -- memory exhaustion comes here. |
2281 `-------------------------------------------------*/
2282 yyexhaustedlab:
2283  yyerror (YY_("memory exhausted"));
2284  yyresult = 2;
2285  /* Fall through. */
2286 #endif
2287 
2288 yyreturn:
2289  if (yychar != YYEMPTY)
2290  {
2291  /* Make sure we have latest lookahead translation. See comments at
2292  user semantic actions for why this is necessary. */
2293  yytoken = YYTRANSLATE (yychar);
2294  yydestruct ("Cleanup: discarding lookahead",
2295  yytoken, &yylval);
2296  }
2297  /* Do not reclaim the symbols of the rule whose action triggered
2298  this YYABORT or YYACCEPT. */
2299  YYPOPSTACK (yylen);
2300  YY_STACK_PRINT (yyss, yyssp);
2301  while (yyssp != yyss)
2302  {
2303  yydestruct ("Cleanup: popping",
2304  yystos[*yyssp], yyvsp);
2305  YYPOPSTACK (1);
2306  }
2307 #ifndef yyoverflow
2308  if (yyss != yyssa)
2309  YYSTACK_FREE (yyss);
2310 #endif
2311 #if YYERROR_VERBOSE
2312  if (yymsg != yymsgbuf)
2313  YYSTACK_FREE (yymsg);
2314 #endif
2315  return yyresult;
2316 }
#define YYPOPSTACK(N)
pp_entry_t * pplookup(const char *ident)
Definition: preproc.c:221
static const yytype_uint8 yytable[]
Definition: ppy.tab.c:701
static const yytype_uint8 yyr2[]
Definition: ppy.tab.c:808
#define YYEMPTY
Definition: ppy.tab.c:824
static marg_t * add_new_marg(char *str, def_arg_t type)
Definition: ppy.tab.c:2472
static int marg_index(char *id)
Definition: ppy.tab.c:2490
static const yytype_uint8 yystos[]
Definition: ppy.tab.c:773
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
YYLTYPE yylloc
Definition: hlsl.tab.c:2412
void pp_internal_error(const char *file, int line, const char *s,...)
Definition: preproc.c:754
static mtext_t * new_mtext(char *str, int idx, def_exp_t type)
Definition: ppy.tab.c:2503
int line_number
Definition: wpp_private.h:233
#define YYSTACK_FREE
Definition: ppy.tab.c:432
GLdouble GLdouble t
Definition: gl.h:2047
static void promote_equal_size(cval_t *v1, cval_t *v2)
Definition: ppy.tab.c:2411
mtext_t * mtext
Definition: ppy.tab.c:264
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void pp_writestring(const char *format,...)
Definition: ppl.yy.c:1351
#define YYDPRINTF(Args)
Definition: ppy.tab.c:980
int pp_get_if_depth(void)
Definition: preproc.c:681
pp_if_state_t
Definition: wpp_private.h:110
static const MAT2 mat
Definition: font.c:66
#define yylex
Definition: ppy.tab.c:64
cval_t cval
Definition: ppy.tab.c:262
char * cptr
Definition: ppy.tab.c:261
pp_if_state_t pp_pop_if(void)
Definition: preproc.c:618
char * input
Definition: wpp_private.h:231
short int yytype_int16
#define YYMAXDEPTH
Definition: ppy.tab.c:1000
#define sprintf(buf, format,...)
Definition: sprintf.c:55
#define YYSTACK_BYTES(N)
Definition: ppy.tab.c:476
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define YYTERROR
Definition: ppy.tab.c:852
#define YY_REDUCE_PRINT(Rule)
Definition: ppy.tab.c:983
#define BIN_OP(r, v1, v2, OP)
Definition: ppy.tab.c:134
#define UNARY_OP(r, v, OP)
Definition: ppy.tab.c:88
include_state_t pp_incl_state
Definition: ppl.yy.c:1334
smooth NULL
Definition: ftsmooth.c:416
#define YYINITDEPTH
Definition: ppy.tab.c:989
static mtext_t * combine_mtext(mtext_t *tail, mtext_t *mtp)
Definition: ppy.tab.c:2517
#define YYFINAL
Definition: ppy.tab.c:521
#define yynerrs
Definition: ppy.tab.c:67
void * pp_xmalloc(size_t size)
Definition: preproc.c:77
static const yytype_int16 yypact[]
Definition: ppy.tab.c:641
GLuint GLfloat * val
Definition: glext.h:7180
int ppy_error(const char *s,...)
Definition: preproc.c:735
int ppy_warning(const char *s,...)
Definition: preproc.c:745
yytype_int16 yyss_alloc
void pp_push_if(pp_if_state_t s)
Definition: preproc.c:592
YYSTYPE yyvs_alloc
static const yytype_uint8 yycheck[]
Definition: ppy.tab.c:736
#define YYSYNTAX_ERROR
pp_entry_t * pp_add_define(const char *def, const char *text)
Definition: preproc.c:323
#define YY_(Msgid)
Definition: ppy.tab.c:334
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: ppy.tab.c:384
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ppy.tab.c:487
void pp_del_define(const char *name)
Definition: preproc.c:302
static char * merge_text(char *s1, char *s2)
Definition: ppy.tab.c:2593