From e05d4fbf0f9382933ee7b817930f4377ad87b742 Mon Sep 17 00:00:00 2001
From: Michal Krol <mjkrol@gmail.org>
Date: Wed, 3 Mar 2004 18:01:58 +0000
Subject: Added support for ARB_fragment_program_shadow.

---
 src/mesa/shader/arbprogram.syn | 2725 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2725 insertions(+)
 create mode 100644 src/mesa/shader/arbprogram.syn

(limited to 'src/mesa/shader/arbprogram.syn')

diff --git a/src/mesa/shader/arbprogram.syn b/src/mesa/shader/arbprogram.syn
new file mode 100644
index 00000000000..0fc03e734ac
--- /dev/null
+++ b/src/mesa/shader/arbprogram.syn
@@ -0,0 +1,2725 @@
+.syntax program;
+
+/*
+   This value must be incremented every time emit code values or structure of the production
+   array changes. This value is placed at the beginning of the production array. The loader
+   compares the value with its REVISION value. If they do not match, the loader is not up
+   to date.
+*/
+.emtcode REVISION                                   0x07
+
+/* program type */
+.emtcode FRAGMENT_PROGRAM                           0x01
+.emtcode VERTEX_PROGRAM                             0x02
+
+/* program section */
+.emtcode OPTION                                     0x01
+.emtcode INSTRUCTION                                0x02
+.emtcode DECLARATION                                0x03
+.emtcode END                                        0x04
+
+/* GL_ARB_fragment_program option flags */
+.emtcode ARB_PRECISION_HINT_FASTEST                 0x01
+.emtcode ARB_PRECISION_HINT_NICEST                  0x02
+.emtcode ARB_FOG_EXP                                0x04
+.emtcode ARB_FOG_EXP2                               0x08
+.emtcode ARB_FOG_LINEAR                             0x10
+
+/* GL_ARB_vertex_program option flags */
+.emtcode ARB_POSITION_INVARIANT                     0x20
+
+/* GL_ARB_fragment_program_shadow option flags */
+.emtcode ARB_FRAGMENT_PROGRAM_SHADOW                0x40
+
+/* GL_ARB_fragment_program instruction class */
+.emtcode OP_ALU_INST                                0x00
+.emtcode OP_TEX_INST                                0x01
+
+/* GL_ARB_vertex_program instruction class */
+/*       OP_ALU_INST */
+
+/* GL_ARB_fragment_program instruction type */
+.emtcode OP_ALU_VECTOR                               0x00
+.emtcode OP_ALU_SCALAR                               0x01
+.emtcode OP_ALU_BINSC                                0x02
+.emtcode OP_ALU_BIN                                  0x03
+.emtcode OP_ALU_TRI                                  0x04
+.emtcode OP_ALU_SWZ                                  0x05
+.emtcode OP_TEX_SAMPLE                               0x06
+.emtcode OP_TEX_KIL                                  0x07
+
+/* GL_ARB_vertex_program instruction type */
+.emtcode OP_ALU_ARL                                  0x08
+/*       OP_ALU_VECTOR */
+/*       OP_ALU_SCALAR */
+/*       OP_ALU_BINSC */
+/*       OP_ALU_BIN */
+/*       OP_ALU_TRI */
+/*       OP_ALU_SWZ */
+
+/* GL_ARB_fragment_program instruction code */
+.emtcode OP_ABS                                     0x00
+.emtcode OP_ABS_SAT                                 0x1B
+.emtcode OP_FLR                                     0x09
+.emtcode OP_FLR_SAT                                 0x26
+.emtcode OP_FRC                                     0x0A
+.emtcode OP_FRC_SAT                                 0x27
+.emtcode OP_LIT                                     0x0C
+.emtcode OP_LIT_SAT                                 0x2A
+.emtcode OP_MOV                                     0x11
+.emtcode OP_MOV_SAT                                 0x30
+.emtcode OP_COS                                     0x1F
+.emtcode OP_COS_SAT                                 0x20
+.emtcode OP_EX2                                     0x07
+.emtcode OP_EX2_SAT                                 0x25
+.emtcode OP_LG2                                     0x0B
+.emtcode OP_LG2_SAT                                 0x29
+.emtcode OP_RCP                                     0x14
+.emtcode OP_RCP_SAT                                 0x33
+.emtcode OP_RSQ                                     0x15
+.emtcode OP_RSQ_SAT                                 0x34
+.emtcode OP_SIN                                     0x38
+.emtcode OP_SIN_SAT                                 0x39
+.emtcode OP_SCS                                     0x35
+.emtcode OP_SCS_SAT                                 0x36
+.emtcode OP_POW                                     0x13
+.emtcode OP_POW_SAT                                 0x32
+.emtcode OP_ADD                                     0x01
+.emtcode OP_ADD_SAT                                 0x1C
+.emtcode OP_DP3                                     0x03
+.emtcode OP_DP3_SAT                                 0x21
+.emtcode OP_DP4                                     0x04
+.emtcode OP_DP4_SAT                                 0x22
+.emtcode OP_DPH                                     0x05
+.emtcode OP_DPH_SAT                                 0x23
+.emtcode OP_DST                                     0x06
+.emtcode OP_DST_SAT                                 0x24
+.emtcode OP_MAX                                     0x0F
+.emtcode OP_MAX_SAT                                 0x2E
+.emtcode OP_MIN                                     0x10
+.emtcode OP_MIN_SAT                                 0x2F
+.emtcode OP_MUL                                     0x12
+.emtcode OP_MUL_SAT                                 0x31
+.emtcode OP_SGE                                     0x16
+.emtcode OP_SGE_SAT                                 0x37
+.emtcode OP_SLT                                     0x17
+.emtcode OP_SLT_SAT                                 0x3A
+.emtcode OP_SUB                                     0x18
+.emtcode OP_SUB_SAT                                 0x3B
+.emtcode OP_XPD                                     0x1A
+.emtcode OP_XPD_SAT                                 0x43
+.emtcode OP_CMP                                     0x1D
+.emtcode OP_CMP_SAT                                 0x1E
+.emtcode OP_LRP                                     0x2B
+.emtcode OP_LRP_SAT                                 0x2C
+.emtcode OP_MAD                                     0x0E
+.emtcode OP_MAD_SAT                                 0x2D
+.emtcode OP_SWZ                                     0x19
+.emtcode OP_SWZ_SAT                                 0x3C
+.emtcode OP_TEX                                     0x3D
+.emtcode OP_TEX_SAT                                 0x3E
+.emtcode OP_TXB                                     0x3F
+.emtcode OP_TXB_SAT                                 0x40
+.emtcode OP_TXP                                     0x41
+.emtcode OP_TXP_SAT                                 0x42
+.emtcode OP_KIL                                     0x28
+
+/* GL_ARB_vertex_program instruction code */
+.emtcode OP_ARL                                     0x02
+/*       OP_ABS */
+/*       OP_FLR */
+/*       OP_FRC */
+/*       OP_LIT */
+/*       OP_MOV */
+/*       OP_EX2 */
+.emtcode OP_EXP                                     0x08
+/*       OP_LG2 */
+.emtcode OP_LOG                                     0x0D
+/*       OP_RCP */
+/*       OP_RSQ */
+/*       OP_POW */
+/*       OP_ADD */
+/*       OP_DP3 */
+/*       OP_DP4 */
+/*       OP_DPH */
+/*       OP_DST */
+/*       OP_MAX */
+/*       OP_MIN */
+/*       OP_MUL */
+/*       OP_SGE */
+/*       OP_SLT */
+/*       OP_SUB */
+/*       OP_XPD */
+/*       OP_MAD */
+/*       OP_SWZ */
+
+/* fragment attribute binding */
+.emtcode FRAGMENT_ATTRIB_COLOR                      0x01
+.emtcode FRAGMENT_ATTRIB_TEXCOORD                   0x02
+.emtcode FRAGMENT_ATTRIB_FOGCOORD                   0x03
+.emtcode FRAGMENT_ATTRIB_POSITION                   0x04
+
+/* vertex attribute binding */
+.emtcode VERTEX_ATTRIB_POSITION                     0x01
+.emtcode VERTEX_ATTRIB_WEIGHT                       0x02
+.emtcode VERTEX_ATTRIB_NORMAL                       0x03
+.emtcode VERTEX_ATTRIB_COLOR                        0x04
+.emtcode VERTEX_ATTRIB_FOGCOORD                     0x05
+.emtcode VERTEX_ATTRIB_TEXCOORD                     0x06
+.emtcode VERTEX_ATTRIB_MATRIXINDEX                  0x07
+.emtcode VERTEX_ATTRIB_GENERIC                      0x08
+
+/* fragment result binding */
+.emtcode FRAGMENT_RESULT_COLOR                      0x01
+.emtcode FRAGMENT_RESULT_DEPTH                      0x02
+
+/* vertex result binding */
+.emtcode VERTEX_RESULT_POSITION                     0x01
+.emtcode VERTEX_RESULT_COLOR                        0x02
+.emtcode VERTEX_RESULT_FOGCOORD                     0x03
+.emtcode VERTEX_RESULT_POINTSIZE                    0x04
+.emtcode VERTEX_RESULT_TEXCOORD                     0x05
+
+/* texture target */
+.emtcode TEXTARGET_1D                               0x01
+.emtcode TEXTARGET_2D                               0x02
+.emtcode TEXTARGET_3D                               0x03
+.emtcode TEXTARGET_RECT                             0x04
+.emtcode TEXTARGET_CUBE                             0x05
+/* GL_ARB_fragment_program_shadow */
+.emtcode TEXTARGET_SHADOW1D                         0x06
+.emtcode TEXTARGET_SHADOW2D                         0x07
+.emtcode TEXTARGET_SHADOWRECT                       0x08
+
+/* face type */
+.emtcode FACE_FRONT                                 0x00
+.emtcode FACE_BACK                                  0x01
+
+/* color type */
+.emtcode COLOR_PRIMARY                              0x00
+.emtcode COLOR_SECONDARY                            0x01
+
+/* component */
+.emtcode COMPONENT_X                                0x00
+.emtcode COMPONENT_Y                                0x01
+.emtcode COMPONENT_Z                                0x02
+.emtcode COMPONENT_W                                0x03
+.emtcode COMPONENT_0                                0x04
+.emtcode COMPONENT_1                                0x05
+
+/* array index type */
+.emtcode ARRAY_INDEX_ABSOLUTE                       0x00
+.emtcode ARRAY_INDEX_RELATIVE                       0x01
+
+/* matrix name */
+.emtcode MATRIX_MODELVIEW                           0x01
+.emtcode MATRIX_PROJECTION                          0x02
+.emtcode MATRIX_MVP                                 0x03
+.emtcode MATRIX_TEXTURE                             0x04
+.emtcode MATRIX_PALETTE                             0x05
+.emtcode MATRIX_PROGRAM                             0x06
+
+/* matrix modifier */
+.emtcode MATRIX_MODIFIER_IDENTITY                   0x00
+.emtcode MATRIX_MODIFIER_INVERSE                    0x01
+.emtcode MATRIX_MODIFIER_TRANSPOSE                  0x02
+.emtcode MATRIX_MODIFIER_INVTRANS                   0x03
+
+/* constant type */
+.emtcode CONSTANT_SCALAR                            0x01
+.emtcode CONSTANT_VECTOR                            0x02
+
+/* program param type */
+.emtcode PROGRAM_PARAM_ENV                          0x01
+.emtcode PROGRAM_PARAM_LOCAL                        0x02
+
+/* register type */
+.emtcode REGISTER_ATTRIB                            0x01
+.emtcode REGISTER_PARAM                             0x02
+.emtcode REGISTER_RESULT                            0x03
+.emtcode REGISTER_ESTABLISHED_NAME                  0x04
+
+/* param binding */
+.emtcode PARAM_NULL                                 0x00
+.emtcode PARAM_ARRAY_ELEMENT                        0x01
+.emtcode PARAM_STATE_ELEMENT                        0x02
+.emtcode PARAM_PROGRAM_ELEMENT                      0x03
+.emtcode PARAM_PROGRAM_ELEMENTS                     0x04
+.emtcode PARAM_CONSTANT                             0x05
+
+/* param state property */
+.emtcode STATE_MATERIAL                             0x01
+.emtcode STATE_LIGHT                                0x02
+.emtcode STATE_LIGHT_MODEL                          0x03
+.emtcode STATE_LIGHT_PROD                           0x04
+.emtcode STATE_FOG                                  0x05
+.emtcode STATE_MATRIX_ROWS                          0x06
+/* GL_ARB_fragment_program */
+.emtcode STATE_TEX_ENV                              0x07
+.emtcode STATE_DEPTH                                0x08
+/* GL_ARB_vertex_program */
+.emtcode STATE_TEX_GEN                              0x09
+.emtcode STATE_CLIP_PLANE                           0x0A
+.emtcode STATE_POINT                                0x0B
+
+/* state material property */
+.emtcode MATERIAL_AMBIENT                           0x01
+.emtcode MATERIAL_DIFFUSE                           0x02
+.emtcode MATERIAL_SPECULAR                          0x03
+.emtcode MATERIAL_EMISSION                          0x04
+.emtcode MATERIAL_SHININESS                         0x05
+
+/* state light property */
+.emtcode LIGHT_AMBIENT                              0x01
+.emtcode LIGHT_DIFFUSE                              0x02
+.emtcode LIGHT_SPECULAR                             0x03
+.emtcode LIGHT_POSITION                             0x04
+.emtcode LIGHT_ATTENUATION                          0x05
+.emtcode LIGHT_HALF                                 0x06
+.emtcode LIGHT_SPOT_DIRECTION                       0x07
+
+/* state light model property */
+.emtcode LIGHT_MODEL_AMBIENT                        0x01
+.emtcode LIGHT_MODEL_SCENECOLOR                     0x02
+
+/* state light product property */
+.emtcode LIGHT_PROD_AMBIENT                         0x01
+.emtcode LIGHT_PROD_DIFFUSE                         0x02
+.emtcode LIGHT_PROD_SPECULAR                        0x03
+
+/* state texture environment property */
+.emtcode TEX_ENV_COLOR                              0x01
+
+/* state texture generation coord property */
+.emtcode TEX_GEN_EYE                                0x01
+.emtcode TEX_GEN_OBJECT                             0x02
+
+/* state fog property */
+.emtcode FOG_COLOR                                  0x01
+.emtcode FOG_PARAMS                                 0x02
+
+/* state depth property */
+.emtcode DEPTH_RANGE                                0x01
+
+/* state point parameters property */
+.emtcode POINT_SIZE                                 0x01
+.emtcode POINT_ATTENUATION                          0x02
+
+/* declaration */
+.emtcode ATTRIB                                     0x01
+.emtcode PARAM                                      0x02
+.emtcode TEMP                                       0x03
+.emtcode OUTPUT                                     0x04
+.emtcode ALIAS                                      0x05
+/* GL_ARB_vertex_program */
+.emtcode ADDRESS                                    0x06
+
+/* error messages */
+.errtext UNKNOWN_PROGRAM_SIGNATURE                  "1001: '$e_signature$': unknown program signature"
+.errtext MISSING_END_OR_INVALID_STATEMENT           "1002: '$e_statement$': invalid statement"
+.errtext CODE_AFTER_END                             "1003: '$e_statement$': code after 'END' keyword"
+.errtext INVALID_PROGRAM_OPTION                     "1004: '$e_identifier$': invalid program option"
+.errtext EXT_SWIZ_COMP_EXPECTED                     "1005: extended swizzle component expected but '$e_token$' found"
+.errtext TEX_TARGET_EXPECTED                        "1006: texture target expected but '$e_token$' found"
+.errtext TEXTURE_EXPECTED                           "1007: 'texture' expected but '$e_identifier$' found"
+.errtext SOURCE_REGISTER_EXPECTED                   "1008: source register expected but '$e_token$' found"
+.errtext DESTINATION_REGISTER_EXPECTED              "1009: destination register expected but '$e_token$' found"
+.errtext INVALID_ADDRESS_COMPONENT                  "1010: '$e_identifier$': invalid address component"
+.errtext INVALID_ADDRESS_WRITEMASK                  "1011: '$e_identifier$': invalid address writemask"
+.errtext INVALID_COMPONENT                          "1012: '$e_charordigit$': invalid component"
+.errtext INVALID_SUFFIX                             "1013: '$e_identifier$': invalid suffix"
+.errtext INVALID_WRITEMASK                          "1014: '$e_identifier$': invalid writemask"
+.errtext FRAGMENT_EXPECTED                          "1015: 'fragment' expected but '$e_identifier$' found"
+.errtext VERTEX_EXPECTED                            "1016: 'vertex' expected but '$e_identifier$' found"
+.errtext INVALID_FRAGMENT_PROPERTY                  "1017: '$e_identifier$': invalid fragment property"
+.errtext INVALID_VERTEX_PROPERTY                    "1018: '$e_identifier$': invalid vertex property"
+.errtext INVALID_STATE_PROPERTY                     "1019: '$e_identifier$': invalid state property"
+.errtext INVALID_MATERIAL_PROPERTY                  "1020: '$e_identifier$': invalid material property"
+.errtext INVALID_LIGHT_PROPERTY                     "1021: '$e_identifier$': invalid light property"
+.errtext INVALID_SPOT_PROPERTY                      "1022: '$e_identifier$': invalid spot property"
+.errtext INVALID_LIGHTMODEL_PROPERTY                "1023: '$e_identifier$': invalid light model property"
+.errtext INVALID_LIGHTPROD_PROPERTY                 "1024: '$e_identifier$': invalid light product property"
+.errtext INVALID_TEXENV_PROPERTY                    "1025: '$e_identifier$': invalid texture environment property"
+.errtext INVALID_TEXGEN_PROPERTY                    "1026: '$e_identifier$': invalid texture generating property"
+.errtext INVALID_TEXGEN_COORD                       "1027: '$e_identifier$': invalid texture generating coord"
+.errtext INVALID_FOG_PROPERTY                       "1028: '$e_identifier$': invalid fog property"
+.errtext INVALID_DEPTH_PROPERTY                     "1029: '$e_identifier$': invalid depth property"
+.errtext INVALID_CLIPPLANE_PROPERTY                 "1030: '$e_identifier$': invalid clip plane property"
+.errtext INVALID_POINT_PROPERTY                     "1031: '$e_identifier$': invalid point property"
+.errtext MATRIX_ROW_SELECTOR_OR_MODIFIER_EXPECTED   "1032: matrix row selector or modifier expected but '$e_token$' found"
+.errtext INVALID_MATRIX_NAME                        "1033: '$e_identifier$': invalid matrix name"
+.errtext INVALID_PROGRAM_PROPERTY                   "1034: '$e_identifier$': invalid program property"
+.errtext RESULT_EXPECTED                            "1035: 'result' expected but '$e_token$' found"
+.errtext INVALID_RESULT_PROPERTY                    "1036: '$e_identifier$': invalid result property"
+.errtext INVALID_FACE_PROPERTY                      "1037: '$e_identifier$': invalid face property"
+.errtext INVALID_COLOR_PROPERTY                     "1038: '$e_identifier$': invalid color property"
+.errtext IDENTIFIER_EXPECTED                        "1039: identifier expected but '$e_token$' found"
+.errtext RESERVED_KEYWORD                           "1040: use of reserved keyword as an identifier"
+.errtext INTEGER_EXPECTED                           "1041: integer value expected but '$e_token$' found"
+.errtext MISSING_SEMICOLON                          "1042: ';' expected but '$e_token$' found"
+.errtext MISSING_COMMA                              "1043: ',' expected but '$e_token$' found"
+.errtext MISSING_LBRACKET                           "1044: '[' expected but '$e_token$' found"
+.errtext MISSING_RBRACKET                           "1045: ']' expected but '$e_token$' found"
+.errtext MISSING_DOT                                "1046: '.' expected but '$e_token$' found"
+.errtext MISSING_EQUAL                              "1047: '=' expected but '$e_token$' found"
+.errtext MISSING_LBRACE                             "1048: '{' expected but '$e_token$' found"
+.errtext MISSING_RBRACE                             "1049: '}' expected but '$e_token$' found"
+.errtext MISSING_DOTDOT                             "1050: '..' expected but '$e_token$' found"
+.errtext MISSING_FRACTION_OR_EXPONENT               "1051: missing fraction part or exponent"
+.errtext MISSING_DOT_OR_EXPONENT                    "1052: missing '.' or exponent"
+.errtext EXPONENT_VALUE_EXPECTED                    "1053: exponent value expected"
+.errtext INTEGER_OUT_OF_RANGE                       "1054: integer value out of range"
+.errtext OPERATION_NEEDS_DESTINATION_VARIABLE       "1055: operation needs destination variable"
+.errtext OPERATION_NEEDS_SOURCE_VARIABLE            "1056: operation needs source variable"
+.errtext ADDRESS_REGISTER_EXPECTED                  "1057: address register expected but '$e_token$' found"
+.errtext ADDRESS_REGISTER_OR_INTEGER_EXPECTED       "1058: address register or integer literal expected but '$e_token$' found"
+
+/* extension presence condition registers */
+
+/* GL_ARB_vertex_blend */
+/* GL_EXT_vertex_weighting */
+.regbyte vertex_blend                               0x00
+
+/* GL_ARB_matrix_palette */
+.regbyte matrix_palette                             0x00
+
+/* GL_ARB_point_parameters */
+/* GL_EXT_point_parameters */
+.regbyte point_parameters                           0x01
+
+/* GL_EXT_secondary_color */
+.regbyte secondary_color                            0x01
+
+/* GL_EXT_fog_coord */
+.regbyte fog_coord                                  0x01
+
+/* GL_EXT_texture_rectangle */
+/* GL_NV_texture_rectangle */
+.regbyte texture_rectangle                          0x01
+
+/* GL_ARB_fragment_program_shadow */
+.regbyte fragment_program_shadow                    0x00
+
+/* option presence condition registers */
+/* they are all initially set to zero - when a particular OPTION is encountered, the appropriate */
+/* register is set to 1 to indicate that the OPTION was specified. */
+
+/* GL_ARB_fragment_program */
+.regbyte ARB_precision_hint_fastest                 0x00
+.regbyte ARB_precision_hint_nicest                  0x00
+.regbyte ARB_fog_exp                                0x00
+.regbyte ARB_fog_exp2                               0x00
+.regbyte ARB_fog_linear                             0x00
+
+/* GL_ARB_vertex_program */
+.regbyte ARB_position_invariant                     0x00
+
+/* GL_ARB_fragment_program_shadow */
+.regbyte ARB_fragment_program_shadow                0x00
+
+/* program target condition register */
+/* this syntax script deals with two program targets - VERTEX_PROGRAM and FRAGMENT_PROGRAM. */
+/* to distinguish between them we need a register that will store for us the current target. */
+/* the client will typically set the register to apropriate value before parsing a particular */
+/* program. the mapping between program targets and their values is listed below. */
+/* */
+/* program target               register value    */
+/* ---------------------------------------------- */
+/* FRAGMENT_PROGRAM             0x10              */
+/* VERTEX_PROGRAM               0x20              */
+/* */
+/* the initial value of the register is 0 to catch potential errors with not setting the register */
+/* with the proper value. */
+.regbyte program_target                             0x00
+
+/*
+    <program>              ::= <optionSequence> <statementSequence> "END"
+*/
+program
+    programs .error UNKNOWN_PROGRAM_SIGNATURE .emit REVISION;
+programs
+    .if (program_target == 0x10) frag_program_1_0 .emit FRAGMENT_PROGRAM .emit 0x01 .emit 0x00 .or
+    .if (program_target == 0x20) vert_program_1_0 .emit VERTEX_PROGRAM .emit 0x01 .emit 0x00;
+frag_program_1_0
+    '!' .and '!' .and 'A' .and 'R' .and 'B' .and 'f' .and 'p' .and '1' .and '.' .and '0' .and
+    optional_space .and fp_optionSequence .and fp_statementSequence .and
+    "END" .error MISSING_END_OR_INVALID_STATEMENT .emit END .and optional_space .and
+    '\0' .error CODE_AFTER_END;
+vert_program_1_0
+    '!' .and '!' .and 'A' .and 'R' .and 'B' .and 'v' .and 'p' .and '1' .and '.' .and '0' .and
+    optional_space .and vp_optionSequence .and vp_statementSequence .and
+    "END" .error MISSING_END_OR_INVALID_STATEMENT .emit END .and optional_space .and
+    '\0' .error CODE_AFTER_END;
+
+/*
+    <optionSequence>       ::= <optionSequence> <option>
+                             | ""
+*/
+fp_optionSequence
+    .loop fp_option;
+vp_optionSequence
+    .loop vp_option;
+
+/*
+    <option>               ::= "OPTION" <identifier> ";"
+
+NOTE: options ARB_precision_hint_nicest and ARB_precision_hint_fastest are exclusive. When one of
+      these options is encountered, the other one is automatically disabled.
+      the same applies to options ARB_fog_exp, ARB_fog_exp2 and ARB_fog_linear.
+*/
+fp_option
+    "OPTION" .emit OPTION .and space .error IDENTIFIER_EXPECTED .and
+    fp_optionString .error INVALID_PROGRAM_OPTION .and semicolon;
+vp_option
+    "OPTION" .emit OPTION .and space .error IDENTIFIER_EXPECTED .and
+    vp_optionString .error INVALID_PROGRAM_OPTION .and semicolon;
+fp_optionString
+    .if (ARB_precision_hint_nicest == 0x00) "ARB_precision_hint_fastest"
+        .emit ARB_PRECISION_HINT_FASTEST .load ARB_precision_hint_fastest 0x01 .or
+    .if (ARB_precision_hint_fastest == 0x00) "ARB_precision_hint_nicest"
+        .emit ARB_PRECISION_HINT_NICEST .load ARB_precision_hint_nicest 0x01 .or
+    fp_ARB_fog_exp .emit ARB_FOG_EXP .load ARB_fog_exp 0x01 .or
+    fp_ARB_fog_exp2 .emit ARB_FOG_EXP2 .load ARB_fog_exp2 0x01 .or
+    fp_ARB_fog_linear .emit ARB_FOG_LINEAR .load ARB_fog_linear 0x01 .or
+    .if (fragment_program_shadow != 0x00) "ARB_fragment_program_shadow"
+        .emit ARB_FRAGMENT_PROGRAM_SHADOW .load ARB_fragment_program_shadow 0x01;
+vp_optionString
+    "ARB_position_invariant" .emit ARB_POSITION_INVARIANT .load ARB_position_invariant 0x01;
+fp_ARB_fog_exp
+    .if (ARB_fog_exp2 == 0x00) .true .and .if (ARB_fog_linear == 0x00) "ARB_fog_exp";
+fp_ARB_fog_exp2
+    .if (ARB_fog_exp == 0x00) .true .and .if (ARB_fog_linear == 0x00) "ARB_fog_exp2";
+fp_ARB_fog_linear
+    .if (ARB_fog_exp == 0x00) .true .and .if (ARB_fog_exp2 == 0x00) "ARB_fog_linear";
+
+/*
+    <statementSequence>    ::= <statementSequence> <statement>
+                             | ""
+*/
+fp_statementSequence
+    .loop fp_statement;
+vp_statementSequence
+    .loop vp_statement;
+
+/*
+    <statement>            ::= <instruction> ";"
+                             | <namingStatement> ";"
+
+NOTE: ".emit $" in the definitions below means that we output instruction position (offset of
+      the first character of instruction) for program debugging purposes.
+*/
+fp_statement
+    fp_statement_1 .or fp_statement_2;
+vp_statement
+    vp_statement_1 .or vp_statement_2;
+fp_statement_1
+    fp_instruction .emit INSTRUCTION .emit $ .and semicolon;
+fp_statement_2
+    fp_namingStatement .emit DECLARATION .and semicolon;
+vp_statement_1
+    vp_instruction .emit INSTRUCTION .emit $ .and semicolon;
+vp_statement_2
+    vp_namingStatement .emit DECLARATION .and semicolon;
+
+/*
+fragment program
+    <instruction>          ::= <ALUInstruction>
+                             | <TexInstruction>
+
+vertex program
+    <instruction>          ::= <ARL_instruction>
+                             | <VECTORop_instruction>
+                             | <SCALARop_instruction>
+                             | <BINSCop_instruction>
+                             | <BINop_instruction>
+                             | <TRIop_instruction>
+                             | <SWZ_instruction>
+*/
+fp_instruction
+    ALUInstruction .emit OP_ALU_INST .or
+    TexInstruction .emit OP_TEX_INST;
+vp_instruction
+    ARL_instruction .emit OP_ALU_ARL .or
+    vp_VECTORop_instruction .emit OP_ALU_VECTOR .or
+    vp_SCALARop_instruction .emit OP_ALU_SCALAR .or
+    vp_BINSCop_instruction .emit OP_ALU_BINSC .or
+    vp_BINop_instruction .emit OP_ALU_BIN .or
+    vp_TRIop_instruction .emit OP_ALU_TRI .or
+    vp_SWZ_instruction .emit OP_ALU_SWZ;
+
+/*
+fragment program
+    <ALUInstruction>       ::= <VECTORop_instruction>
+                             | <SCALARop_instruction>
+                             | <BINSCop_instruction>
+                             | <BINop_instruction>
+                             | <TRIop_instruction>
+                             | <SWZ_instruction>
+*/
+ALUInstruction
+    fp_VECTORop_instruction .emit OP_ALU_VECTOR .or
+    fp_SCALARop_instruction .emit OP_ALU_SCALAR .or
+    fp_BINSCop_instruction .emit OP_ALU_BINSC .or
+    fp_BINop_instruction .emit OP_ALU_BIN .or
+    fp_TRIop_instruction .emit OP_ALU_TRI .or
+    fp_SWZ_instruction .emit OP_ALU_SWZ;
+
+/*
+fragment program
+    <TexInstruction>       ::= <SAMPLE_instruction>
+                             | <KIL_instruction>
+*/
+TexInstruction
+    SAMPLE_instruction .emit OP_TEX_SAMPLE .or
+    KIL_instruction .emit OP_TEX_KIL;
+
+/*
+vertex program
+    <ARL_instruction>      ::= "ARL" <maskedAddrReg> "," <scalarSrcReg>
+*/
+ARL_instruction
+    "ARL" .emit OP_ARL .and space_dst .and maskedAddrReg .and comma .and vp_scalarSrcReg;
+
+/*
+fragment program
+    <VECTORop_instruction> ::= <VECTORop> <maskedDstReg> "," 
+                               <vectorSrcReg>
+
+vertex program
+    <VECTORop_instruction> ::= <VECTORop> <maskedDstReg> "," <swizzleSrcReg>
+*/
+fp_VECTORop_instruction
+    fp_VECTORop .and space_dst .and fp_maskedDstReg .and comma .and vectorSrcReg;
+vp_VECTORop_instruction
+    vp_VECTORop .and space_dst .and vp_maskedDstReg .and comma .and swizzleSrcReg;
+
+/*
+fragment program
+    <VECTORop>             ::= "ABS" | "ABS_SAT"
+                             | "FLR" | "FLR_SAT"
+                             | "FRC" | "FRC_SAT"
+                             | "LIT" | "LIT_SAT"
+                             | "MOV" | "MOV_SAT"
+
+vertex program
+    <VECTORop>             ::= "ABS"
+                             | "FLR"
+                             | "FRC"
+                             | "LIT"
+                             | "MOV"
+*/
+fp_VECTORop
+    "ABS" .emit OP_ABS .or "ABS_SAT" .emit OP_ABS_SAT .or
+    "FLR" .emit OP_FLR .or "FLR_SAT" .emit OP_FLR_SAT .or
+    "FRC" .emit OP_FRC .or "FRC_SAT" .emit OP_FRC_SAT .or
+    "LIT" .emit OP_LIT .or "LIT_SAT" .emit OP_LIT_SAT .or
+    "MOV" .emit OP_MOV .or "MOV_SAT" .emit OP_MOV_SAT;
+vp_VECTORop
+    "ABS" .emit OP_ABS .or
+    "FLR" .emit OP_FLR .or
+    "FRC" .emit OP_FRC .or
+    "LIT" .emit OP_LIT .or
+    "MOV" .emit OP_MOV;
+
+/*
+    <SCALARop_instruction> ::= <SCALARop> <maskedDstReg> "," <scalarSrcReg>
+*/
+fp_SCALARop_instruction
+    fp_SCALARop .and space_dst .and fp_maskedDstReg .and comma .and fp_scalarSrcReg;
+vp_SCALARop_instruction
+    vp_SCALARop .and space_dst .and vp_maskedDstReg .and comma .and vp_scalarSrcReg;
+
+/*
+fragment program
+    <SCALARop>             ::= "COS" | "COS_SAT"
+                             | "EX2" | "EX2_SAT"
+                             | "LG2" | "LG2_SAT"
+                             | "RCP" | "RCP_SAT"
+                             | "RSQ" | "RSQ_SAT"
+                             | "SIN" | "SIN_SAT"
+                             | "SCS" | "SCS_SAT"
+
+vertex program
+    <SCALARop>             ::= "EX2"
+                             | "EXP"
+                             | "LG2"
+                             | "LOG"
+                             | "RCP"
+                             | "RSQ"
+*/
+fp_SCALARop
+    "COS" .emit OP_COS .or "COS_SAT" .emit OP_COS_SAT .or
+    "EX2" .emit OP_EX2 .or "EX2_SAT" .emit OP_EX2_SAT .or
+    "LG2" .emit OP_LG2 .or "LG2_SAT" .emit OP_LG2_SAT .or
+    "RCP" .emit OP_RCP .or "RCP_SAT" .emit OP_RCP_SAT .or
+    "RSQ" .emit OP_RSQ .or "RSQ_SAT" .emit OP_RSQ_SAT .or
+    "SIN" .emit OP_SIN .or "SIN_SAT" .emit OP_SIN_SAT .or
+    "SCS" .emit OP_SCS .or "SCS_SAT" .emit OP_SCS_SAT;
+vp_SCALARop
+    "EX2" .emit OP_EX2 .or
+    "EXP" .emit OP_EXP .or
+    "LG2" .emit OP_LG2 .or
+    "LOG" .emit OP_LOG .or
+    "RCP" .emit OP_RCP .or
+    "RSQ" .emit OP_RSQ;
+
+/*
+    <BINSCop_instruction>  ::= <BINSCop> <maskedDstReg> "," <scalarSrcReg> ","
+                               <scalarSrcReg>
+*/
+fp_BINSCop_instruction
+    fp_BINSCop .and space_dst .and fp_maskedDstReg .and comma .and fp_scalarSrcReg .and comma .and
+    fp_scalarSrcReg;
+vp_BINSCop_instruction
+    vp_BINSCop .and space_dst .and vp_maskedDstReg .and comma .and vp_scalarSrcReg .and comma .and
+    vp_scalarSrcReg;
+
+/*
+fragment program
+    <BINSCop>              ::= "POW" | "POW_SAT"
+
+vertex program
+    <BINSCop>              ::= "POW"
+*/
+fp_BINSCop
+    "POW" .emit OP_POW .or "POW_SAT" .emit OP_POW_SAT;
+vp_BINSCop
+    "POW" .emit OP_POW;
+
+/*
+fragment program
+    <BINop_instruction>    ::= <BINop> <maskedDstReg> ","
+                               <vectorSrcReg> "," <vectorSrcReg>
+
+vertex program
+    <BINop_instruction>    ::= <BINop> <maskedDstReg> ","
+                               <swizzleSrcReg> "," <swizzleSrcReg>
+*/
+fp_BINop_instruction
+    fp_BINop .and space_dst .and fp_maskedDstReg .and comma .and vectorSrcReg .and comma .and
+    vectorSrcReg;
+vp_BINop_instruction
+    vp_BINop .and space_dst .and vp_maskedDstReg .and comma .and swizzleSrcReg .and comma .and
+    swizzleSrcReg;
+
+/*
+fragment program
+    <BINop>                ::= "ADD" | "ADD_SAT"
+                             | "DP3" | "DP3_SAT"
+                             | "DP4" | "DP4_SAT"
+                             | "DPH" | "DPH_SAT"
+                             | "DST" | "DST_SAT"
+                             | "MAX" | "MAX_SAT"
+                             | "MIN" | "MIN_SAT"
+                             | "MUL" | "MUL_SAT"
+                             | "SGE" | "SGE_SAT"
+                             | "SLT" | "SLT_SAT"
+                             | "SUB" | "SUB_SAT"
+                             | "XPD" | "XPD_SAT"
+
+vertex program
+    <BINop>                ::= "ADD"
+                             | "DP3"
+                             | "DP4"
+                             | "DPH"
+                             | "DST"
+                             | "MAX"
+                             | "MIN"
+                             | "MUL"
+                             | "SGE"
+                             | "SLT"
+                             | "SUB"
+                             | "XPD"
+*/
+fp_BINop
+    "ADD" .emit OP_ADD .or "ADD_SAT" .emit OP_ADD_SAT .or
+    "DP3" .emit OP_DP3 .or "DP3_SAT" .emit OP_DP3_SAT .or
+    "DP4" .emit OP_DP4 .or "DP4_SAT" .emit OP_DP4_SAT .or
+    "DPH" .emit OP_DPH .or "DPH_SAT" .emit OP_DPH_SAT .or
+    "DST" .emit OP_DST .or "DST_SAT" .emit OP_DST_SAT .or
+    "MAX" .emit OP_MAX .or "MAX_SAT" .emit OP_MAX_SAT .or
+    "MIN" .emit OP_MIN .or "MIN_SAT" .emit OP_MIN_SAT .or
+    "MUL" .emit OP_MUL .or "MUL_SAT" .emit OP_MUL_SAT .or
+    "SGE" .emit OP_SGE .or "SGE_SAT" .emit OP_SGE_SAT .or
+    "SLT" .emit OP_SLT .or "SLT_SAT" .emit OP_SLT_SAT .or
+    "SUB" .emit OP_SUB .or "SUB_SAT" .emit OP_SUB_SAT .or
+    "XPD" .emit OP_XPD .or "XPD_SAT" .emit OP_XPD_SAT;
+vp_BINop
+    "ADD" .emit OP_ADD .or
+    "DP3" .emit OP_DP3 .or
+    "DP4" .emit OP_DP4 .or
+    "DPH" .emit OP_DPH .or
+    "DST" .emit OP_DST .or
+    "MAX" .emit OP_MAX .or
+    "MIN" .emit OP_MIN .or
+    "MUL" .emit OP_MUL .or
+    "SGE" .emit OP_SGE .or
+    "SLT" .emit OP_SLT .or
+    "SUB" .emit OP_SUB .or
+    "XPD" .emit OP_XPD;
+
+/*
+fragment program
+    <TRIop_instruction>    ::= <TRIop> <maskedDstReg> ","
+                               <vectorSrcReg> "," <vectorSrcReg> ","
+                               <vectorSrcReg>
+
+vertex program
+    <TRIop_instruction>    ::= <TRIop> <maskedDstReg> ","
+                               <swizzleSrcReg> "," <swizzleSrcReg> ","
+                               <swizzleSrcReg>
+*/
+fp_TRIop_instruction
+    fp_TRIop .and space_dst .and fp_maskedDstReg .and comma .and vectorSrcReg .and comma .and
+    vectorSrcReg .and comma .and vectorSrcReg;
+vp_TRIop_instruction
+    vp_TRIop .and space_dst .and vp_maskedDstReg .and comma .and swizzleSrcReg .and comma .and
+    swizzleSrcReg .and comma .and swizzleSrcReg;
+
+/*
+fragment program
+    <TRIop>                ::= "CMP" | "CMP_SAT"
+                             | "LRP" | "LRP_SAT"
+                             | "MAD" | "MAD_SAT"
+
+vertex program
+    <TRIop>                ::= "MAD"
+*/
+fp_TRIop
+    "CMP" .emit OP_CMP .or "CMP_SAT" .emit OP_CMP_SAT .or
+    "LRP" .emit OP_LRP .or "LRP_SAT" .emit OP_LRP_SAT .or
+    "MAD" .emit OP_MAD .or "MAD_SAT" .emit OP_MAD_SAT;
+vp_TRIop
+    "MAD" .emit OP_MAD;
+
+/*
+fragment program
+    <SWZ_instruction>      ::= <SWZop> <maskedDstReg> "," 
+                               <srcReg> "," <extendedSwizzle>
+
+vertex program
+    <SWZ_instruction>      ::= "SWZ" <maskedDstReg> "," <srcReg> "," 
+                               <extendedSwizzle>
+*/
+fp_SWZ_instruction
+    SWZop .and space_dst .and fp_maskedDstReg .and comma .and fp_srcReg .and comma .and
+    fp_extendedSwizzle .error EXT_SWIZ_COMP_EXPECTED;
+vp_SWZ_instruction
+    "SWZ" .emit OP_SWZ .and space_dst .and vp_maskedDstReg .and comma .and vp_srcReg .and comma .and
+    vp_extendedSwizzle .error EXT_SWIZ_COMP_EXPECTED;
+
+/*
+fragment program
+    <SWZop>                ::= "SWZ" | "SWZ_SAT"
+*/
+SWZop
+    "SWZ" .emit OP_SWZ .or "SWZ_SAT" .emit OP_SWZ_SAT;
+
+/*
+fragment program
+    <SAMPLE_instruction>   ::= <SAMPLEop> <maskedDstReg> ","
+                               <vectorSrcReg> "," <texImageUnit> "," 
+                               <texTarget>
+*/
+SAMPLE_instruction
+    SAMPLEop .and space_dst .and fp_maskedDstReg .and comma .and vectorSrcReg .and comma .and
+    texImageUnit .and comma .and texTarget .error TEX_TARGET_EXPECTED;
+
+/*
+fragment program
+    <SAMPLEop>             ::= "TEX" | "TEX_SAT"
+                             | "TXP" | "TXP_SAT"
+                             | "TXB" | "TXB_SAT"
+*/
+SAMPLEop
+    "TEX" .emit OP_TEX .or "TEX_SAT" .emit OP_TEX_SAT .or
+    "TXB" .emit OP_TXB .or "TXB_SAT" .emit OP_TXB_SAT .or
+    "TXP" .emit OP_TXP .or "TXP_SAT" .emit OP_TXP_SAT;
+
+/*
+fragment program
+    <KIL_instruction>      ::= "KIL" <vectorSrcReg>
+*/
+KIL_instruction
+    "KIL" .emit OP_KIL .and space_src .and vectorSrcReg;
+
+/*
+fragment program
+    <texImageUnit>         ::= "texture" <optTexImageUnitNum>
+*/
+texImageUnit
+    "texture" .error TEXTURE_EXPECTED .and optTexImageUnitNum;
+
+/*
+fragment program
+    <texTarget>            ::= "1D"
+                             | "2D"
+                             | "3D"
+                             | "CUBE"
+                             | "RECT"
+                             | <shadowTarget> (if option ARB_fragment_program_shadow present)
+*/
+texTarget
+    "1D" .emit TEXTARGET_1D .or
+    "2D" .emit TEXTARGET_2D .or
+    "3D" .emit TEXTARGET_3D .or
+    .if (texture_rectangle != 0x00) "RECT" .emit TEXTARGET_RECT .or
+    "CUBE" .emit TEXTARGET_CUBE .or
+    .if (ARB_fragment_program_shadow != 0x00) shadowTarget;
+
+/*
+GL_ARB_fragment_program_shadow
+    <shadowTarget>         ::= "SHADOW1D"
+                             | "SHADOW2D"
+                             | "SHADOWRECT"
+*/
+shadowTarget
+    "SHADOW1D" .emit TEXTARGET_SHADOW1D .or
+    "SHADOW2D" .emit TEXTARGET_SHADOW2D .or
+    .if (texture_rectangle != 0x00) "SHADOWRECT" .emit TEXTARGET_SHADOWRECT;
+
+/*
+fragment program
+    <optTexImageUnitNum>   ::= ""
+                             | "[" <texImageUnitNum> "]"
+*/
+optTexImageUnitNum
+    optTexImageUnitNum_1 .or .true .emit 0x00;
+optTexImageUnitNum_1
+    lbracket_ne .and texImageUnitNum .and rbracket;
+
+/*
+fragment program
+    <texImageUnitNum>      ::= <integer> from 0 to 
+                               MAX_TEXTURE_IMAGE_UNITS_ARB-1
+*/
+texImageUnitNum
+    integer;
+
+/*
+    <scalarSrcReg>         ::= <optionalSign> <srcReg> <scalarSuffix>
+*/
+fp_scalarSrcReg
+    optionalSign .and fp_srcReg .and fp_scalarSuffix;
+vp_scalarSrcReg
+    optionalSign .and vp_srcReg .and vp_scalarSuffix;
+
+/*
+vertex program
+    <swizzleSrcReg>        ::= <optionalSign> <srcReg> <swizzleSuffix>
+*/
+swizzleSrcReg
+    optionalSign .and vp_srcReg .and swizzleSuffix;
+
+/*
+fragment program
+    <vectorSrcReg>         ::= <optionalSign> <srcReg> <optionalSuffix> 
+*/
+vectorSrcReg
+    optionalSign .and fp_srcReg .and optionalSuffix;
+
+/*
+    <maskedDstReg>         ::= <dstReg> <optionalMask>
+*/
+fp_maskedDstReg
+    fp_dstReg .and fp_optionalMask;
+vp_maskedDstReg
+    vp_dstReg .and vp_optionalMask;
+
+/*
+vertex program
+    <maskedAddrReg>        ::= <addrReg> <addrWriteMask>
+*/
+maskedAddrReg
+    addrReg .error ADDRESS_REGISTER_EXPECTED .and addrWriteMask;
+
+/*
+fragment program
+    <extendedSwizzle>      ::= <xyzwExtendedSwizzle>
+                             | <rgbaExtendedSwizzle>
+
+vertex program
+    <extendedSwizzle>      ::= <extSwizComp> "," <extSwizComp> "," 
+                                 <extSwizComp> "," <extSwizComp>
+
+NOTE: do NOT change the order of <rgbaExtendedSwizzle> and <xyzwExtendedSwizzle> rulez
+*/
+fp_extendedSwizzle
+    rgbaExtendedSwizzle .or xyzwExtendedSwizzle;
+vp_extendedSwizzle
+    extSwizComp .and comma .and
+    extSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    extSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    extSwizComp .error EXT_SWIZ_COMP_EXPECTED;
+
+/*
+fragment program
+    <xyzwExtendedSwizzle>  ::= <xyzwExtSwizComp> "," <xyzwExtSwizComp> "," 
+                               <xyzwExtSwizComp> "," <xyzwExtSwizComp>
+*/
+xyzwExtendedSwizzle
+    xyzwExtSwizComp .and comma .and
+    xyzwExtSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    xyzwExtSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    xyzwExtSwizComp .error EXT_SWIZ_COMP_EXPECTED;
+
+/*
+fragment program
+    <rgbaExtendedSwizzle>  ::= <rgbaExtSwizComp> "," <rgbaExtSwizComp> "," 
+                               <rgbaExtSwizComp> "," <rgbaExtSwizComp>
+*/
+rgbaExtendedSwizzle
+    rgbaExtendedSwizzle_1 .or rgbaExtendedSwizzle_2 .or rgbaExtendedSwizzle_3 .or
+    rgbaExtendedSwizzle_4;
+rgbaExtendedSwizzle_1
+    rgbaExtSwizComp_digit .and comma .and rgbaExtSwizComp_digit .and comma .and
+    rgbaExtSwizComp_digit .and comma .and rgbaExtSwizComp;
+rgbaExtendedSwizzle_2
+    rgbaExtSwizComp_digit .and comma .and rgbaExtSwizComp_digit .and comma .and
+    rgbaExtSwizComp_alpha .and comma .and rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED;
+rgbaExtendedSwizzle_3
+    rgbaExtSwizComp_digit .and comma .and rgbaExtSwizComp_alpha .and comma .and
+    rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED;
+rgbaExtendedSwizzle_4
+    rgbaExtSwizComp_alpha .and comma .and 
+    rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED .and comma .and
+    rgbaExtSwizComp .error EXT_SWIZ_COMP_EXPECTED;
+
+/*
+fragment program
+    <xyzwExtSwizComp>      ::= <optionalSign> <xyzwExtSwizSel>
+*/
+xyzwExtSwizComp
+    optionalSign .and xyzwExtSwizSel;
+
+/*
+fragment program
+    <rgbaExtSwizComp>      ::= <optionalSign> <rgbaExtSwizSel>
+*/
+rgbaExtSwizComp
+    optionalSign .and rgbaExtSwizSel;
+rgbaExtSwizComp_digit
+    optionalSign .and rgbaExtSwizSel_digit;
+rgbaExtSwizComp_alpha
+    optionalSign .and rgbaExtSwizSel_alpha;
+
+/*
+vertex program
+    <extSwizComp>          ::= <optionalSign> <extSwizSel>
+*/
+extSwizComp
+    optionalSign .and extSwizSel;
+
+/*
+fragment program
+    <xyzwExtSwizSel>       ::= "0" 
+                             | "1" 
+                             | <xyzwComponent>
+*/
+xyzwExtSwizSel
+    "0" .emit COMPONENT_0 .or "1" .emit COMPONENT_1 .or xyzwComponent_single;
+
+/*
+fragment program
+    <rgbaExtSwizSel>       ::= "0" 
+                             | "1" 
+                             | <rgbaComponent>
+*/
+rgbaExtSwizSel
+    rgbaExtSwizSel_digit .or rgbaExtSwizSel_alpha;
+rgbaExtSwizSel_digit
+    "0" .emit COMPONENT_0 .or "1" .emit COMPONENT_1;
+rgbaExtSwizSel_alpha
+    rgbaComponent_single;
+
+/*
+vertex program
+    <extSwizSel>           ::= "0" 
+                             | "1" 
+                             | <component>
+*/
+extSwizSel
+    "0" .emit COMPONENT_0 .or "1" .emit COMPONENT_1 .or vp_component_single;
+
+/*
+fragment program
+    <srcReg>               ::= <fragmentAttribReg>
+                             | <temporaryReg>
+                             | <progParamReg>
+
+vertex program
+    <srcReg>               ::= <vertexAttribReg>
+                             | <temporaryReg>
+                             | <progParamReg>
+*/
+fp_srcReg
+    fp_srcReg_1 .error SOURCE_REGISTER_EXPECTED;
+vp_srcReg
+    vp_srcReg_1 .error SOURCE_REGISTER_EXPECTED;
+fp_srcReg_1
+    fragmentAttribReg .emit REGISTER_ATTRIB .or
+    fp_progParamReg .emit REGISTER_PARAM .or
+    fp_temporaryReg .emit REGISTER_ESTABLISHED_NAME;
+vp_srcReg_1
+    vertexAttribReg .emit REGISTER_ATTRIB .or
+    vp_progParamReg .emit REGISTER_PARAM .or
+    vp_temporaryReg .emit REGISTER_ESTABLISHED_NAME;
+
+/*
+fragment program
+    <dstReg>               ::= <temporaryReg>
+                             | <fragmentResultReg>
+
+vertex program
+    <dstReg>               ::= <temporaryReg>
+                             | <vertexResultReg>
+*/
+fp_dstReg
+    fp_dstReg_1 .error DESTINATION_REGISTER_EXPECTED;
+vp_dstReg
+    vp_dstReg_1 .error DESTINATION_REGISTER_EXPECTED;
+fp_dstReg_1
+    fragmentResultReg .emit REGISTER_RESULT .or
+    fp_temporaryReg .emit REGISTER_ESTABLISHED_NAME;
+vp_dstReg_1
+    vertexResultReg .emit REGISTER_RESULT .or
+    vp_temporaryReg .emit REGISTER_ESTABLISHED_NAME;
+
+/*
+fragment program
+    <fragmentAttribReg>    ::= <establishedName>
+                             | <fragAttribBinding>
+
+NOTE: <establishedName> is driven by <temporaryReg> rule at the end of <srcReg>
+*/
+fragmentAttribReg
+    /*fp_establishedName .or */fragAttribBinding;
+
+/*
+vertex program
+    <vertexAttribReg>      ::= <establishedName>
+                             | <vtxAttribBinding>
+
+NOTE: <establishedName> is driven by <temporaryReg> rule at the end of <srcReg>
+*/
+vertexAttribReg
+    vtxAttribBinding;
+
+/*
+    <temporaryReg>         ::= <establishedName>
+*/
+fp_temporaryReg
+    fp_establishedName_no_error_on_identifier;
+vp_temporaryReg
+    vp_establishedName_no_error_on_identifier;
+
+/*
+fragment program
+    <progParamReg>         ::= <progParamSingle>
+                             | <progParamArray> "[" <progParamArrayAbs> "]"
+                             | <paramSingleItemUse>
+
+vertex program
+    <progParamReg>         ::= <progParamSingle>
+                             | <progParamArray> "[" <progParamArrayMem> "]"
+                             | <paramSingleItemUse>
+*/
+fp_progParamReg
+    fp_paramSingleItemUse .or fp_progParamReg_1 .or fp_progParamSingle;
+vp_progParamReg
+    vp_paramSingleItemUse .or vp_progParamReg_1 .or vp_progParamSingle;
+fp_progParamReg_1
+    fp_progParamArray .emit PARAM_ARRAY_ELEMENT .and lbracket_ne .and progParamArrayAbs .and
+    rbracket;
+vp_progParamReg_1
+    vp_progParamArray .emit PARAM_ARRAY_ELEMENT .and lbracket_ne .and progParamArrayMem .and
+    rbracket;
+
+/*
+    <progParamSingle>      ::= <establishedName>
+
+NOTE: <establishedName> is driven by <temporaryReg> rule at the end of <srcReg>
+*/
+fp_progParamSingle
+    .false;
+vp_progParamSingle
+    .false;
+
+/*
+    <progParamArray>       ::= <establishedName>
+*/
+fp_progParamArray
+    fp_establishedName_no_error_on_identifier;
+vp_progParamArray
+    vp_establishedName_no_error_on_identifier;
+
+/*
+vertex program
+    <progParamArrayMem>    ::= <progParamArrayAbs>
+                             | <progParamArrayRel>
+*/
+progParamArrayMem
+    progParamArrayAbs .or progParamArrayRel;
+
+/*
+    <progParamArrayAbs>    ::= <integer>
+*/
+progParamArrayAbs
+    integer_ne .emit ARRAY_INDEX_ABSOLUTE;
+
+/*
+vertex program
+    <progParamArrayRel>    ::= <addrReg> <addrComponent> <addrRegRelOffset>
+*/
+progParamArrayRel
+    addrReg .error ADDRESS_REGISTER_OR_INTEGER_EXPECTED .emit ARRAY_INDEX_RELATIVE .and
+    addrComponent .and addrRegRelOffset;
+
+/*
+vertex program
+    <addrRegRelOffset>     ::= ""
+                             | "+" <addrRegPosOffset>
+                             | "-" <addrRegNegOffset>
+*/
+addrRegRelOffset
+    addrRegRelOffset_1 .or addrRegRelOffset_2 .or .true .emit 0x00;
+addrRegRelOffset_1
+    plus_ne .and addrRegPosOffset;
+addrRegRelOffset_2
+    minus_ne .and addrRegNegOffset;
+
+/*
+vertex program
+    <addrRegPosOffset>     ::= <integer> from 0 to 63
+*/
+addrRegPosOffset
+    integer_0_63;
+
+/*
+vertex program
+    <addrRegNegOffset>     ::= <integer> from 0 to 64
+*/
+addrRegNegOffset
+    integer_0_64;
+
+/*
+fragment program
+    <fragmentResultReg>    ::= <establishedName>
+                             | <resultBinding>
+
+NOTE: <establishedName> is driven by <temporaryReg> rule at the end of <dstReg>
+*/
+fragmentResultReg
+    fp_resultBinding;
+
+/*
+vertex program
+    <vertexResultReg>      ::= <establishedName>
+                             | <resultBinding>
+
+NOTE: <establishedName> is driven by <temporaryReg> rule at the end of <dstReg>
+*/
+vertexResultReg
+    vp_resultBinding;
+
+/*
+vertex program
+    <addrReg>              ::= <establishedName>
+*/
+addrReg
+    vp_establishedName_no_error_on_identifier;
+
+/*
+vertex program
+    <addrComponent>        ::= "." "x"
+*/
+addrComponent
+    dot .and "x" .error INVALID_ADDRESS_COMPONENT .emit COMPONENT_X .emit COMPONENT_X
+    .emit COMPONENT_X .emit COMPONENT_X;
+
+/*
+vertex program
+    <addrWriteMask>        ::= "." "x"
+*/
+addrWriteMask
+    dot .and "x" .error INVALID_ADDRESS_WRITEMASK .emit 0x08;
+
+/*
+    <scalarSuffix>         ::= "." <component>
+*/
+fp_scalarSuffix
+    dot .and fp_component_single .error INVALID_COMPONENT;
+vp_scalarSuffix
+    dot .and vp_component_single .error INVALID_COMPONENT;
+
+/*
+vertex program
+    <swizzleSuffix>        ::= ""
+                             | "." <component>
+                             | "." <component> <component>
+                                   <component> <component>
+*/
+swizzleSuffix
+    swizzleSuffix_1 .or
+    .true .emit COMPONENT_X .emit COMPONENT_Y .emit COMPONENT_Z .emit COMPONENT_W;
+swizzleSuffix_1
+    dot_ne .and swizzleSuffix_2 .error INVALID_SUFFIX;
+swizzleSuffix_2
+    swizzleSuffix_3 .or swizzleSuffix_4;
+swizzleSuffix_3
+    vp_component_multi .and vp_component_multi .and vp_component_multi .error INVALID_COMPONENT .and
+    vp_component_multi .error INVALID_COMPONENT;
+swizzleSuffix_4
+    "x" .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .or
+    "y" .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .or
+    "z" .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .or
+    "w" .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W;
+
+/*
+fragment program
+    <optionalSuffix>       ::= "" 
+                             | "." <component> 
+                             | "." <xyzwComponent> <xyzwComponent>
+                                   <xyzwComponent> <xyzwComponent>
+                             | "." <rgbaComponent> <rgbaComponent>
+                                   <rgbaComponent> <rgbaComponent>
+*/
+optionalSuffix
+    optionalSuffix_1 .or
+    .true .emit COMPONENT_X .emit COMPONENT_Y .emit COMPONENT_Z .emit COMPONENT_W;
+optionalSuffix_1
+    dot_ne .and optionalSuffix_2 .error INVALID_SUFFIX;
+optionalSuffix_2
+    optionalSuffix_3 .or optionalSuffix_4 .or optionalSuffix_5;
+optionalSuffix_3
+    xyzwComponent_multi .and xyzwComponent_multi .and
+    xyzwComponent_multi .error INVALID_COMPONENT .and xyzwComponent_multi .error INVALID_COMPONENT;
+optionalSuffix_4
+    rgbaComponent_multi .and rgbaComponent_multi .and
+    rgbaComponent_multi .error INVALID_COMPONENT .and rgbaComponent_multi .error INVALID_COMPONENT;
+optionalSuffix_5
+    "x" .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .or
+    "y" .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .or
+    "z" .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .or
+    "w" .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W .or
+    "r" .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .emit COMPONENT_X .or
+    "g" .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .emit COMPONENT_Y .or
+    "b" .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .emit COMPONENT_Z .or
+    "a" .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W .emit COMPONENT_W;
+
+/*
+fragment program
+    <component>            ::= <xyzwComponent>
+                             | <rgbaComponent>
+
+vertex program
+    <component>            ::= "x"
+                             | "y"
+                             | "z"
+                             | "w"
+*/
+fp_component_single
+    xyzwComponent_single .or rgbaComponent_single;
+vp_component_multi
+    'x' .emit COMPONENT_X .or 'y' .emit COMPONENT_Y .or 'z' .emit COMPONENT_Z .or
+    'w' .emit COMPONENT_W;
+vp_component_single
+    "x" .emit COMPONENT_X .or "y" .emit COMPONENT_Y .or "z" .emit COMPONENT_Z .or
+    "w" .emit COMPONENT_W;
+
+/*
+fragment program
+    <xyzwComponent>        ::= "x" | "y" | "z" | "w"
+*/
+xyzwComponent_multi
+    'x' .emit COMPONENT_X .or 'y' .emit COMPONENT_Y .or 'z' .emit COMPONENT_Z .or
+    'w' .emit COMPONENT_W;
+xyzwComponent_single
+    "x" .emit COMPONENT_X .or "y" .emit COMPONENT_Y .or "z" .emit COMPONENT_Z .or
+    "w" .emit COMPONENT_W;
+
+/*
+fragment program
+    <rgbaComponent>        ::= "r" | "g" | "b" | "a"
+*/
+rgbaComponent_multi
+    'r' .emit COMPONENT_X .or 'g' .emit COMPONENT_Y .or 'b' .emit COMPONENT_Z .or
+    'a' .emit COMPONENT_W;
+rgbaComponent_single
+    "r" .emit COMPONENT_X .or "g" .emit COMPONENT_Y .or "b" .emit COMPONENT_Z .or
+    "a" .emit COMPONENT_W;
+
+/*
+fragment program
+    <optionalMask>         ::= ""
+                             | <xyzwMask>
+                             | <rgbaMask>
+
+vertex program
+    <optionalMask>         ::= ""
+                             | "." "x"
+                             | "." "y"
+                             | "." "xy"
+                             | "." "z"
+                             | "." "xz"
+                             | "." "yz"
+                             | "." "xyz"
+                             | "." "w"
+                             | "." "xw"
+                             | "." "yw"
+                             | "." "xyw"
+                             | "." "zw"
+                             | "." "xzw"
+                             | "." "yzw"
+                             | "." "xyzw"
+
+NOTE: do NOT change the order of <rgbaMask> and <xyzwMask> rulez
+*/
+fp_optionalMask
+    rgbaMask .or xyzwMask .or .true .emit 0x0F;
+vp_optionalMask
+    xyzwMask .or .true .emit 0x0F;
+
+/*
+fragment program
+    <xyzwMask>             ::= "." "x"
+                             | "." "y"
+                             | "." "xy"
+                             | "." "z"
+                             | "." "xz"
+                             | "." "yz"
+                             | "." "xyz"
+                             | "." "w"
+                             | "." "xw"
+                             | "." "yw"
+                             | "." "xyw"
+                             | "." "zw"
+                             | "." "xzw"
+                             | "." "yzw"
+                             | "." "xyzw"
+
+NOTE: <xyzwMask> is also referenced by the vertex program symbol <optionalMask>.
+*/
+xyzwMask
+    dot_ne .and xyzwMask_1 .error INVALID_WRITEMASK;
+xyzwMask_1
+    "xyzw" .emit 0x0F .or "xyz" .emit 0x0E .or "xyw" .emit 0x0D .or "xy" .emit 0x0C .or
+    "xzw" .emit 0x0B .or "xz" .emit 0x0A .or "xw" .emit 0x09 .or "x" .emit 0x08 .or
+    "yzw" .emit 0x07 .or "yz" .emit 0x06 .or "yw" .emit 0x05 .or "y" .emit 0x04 .or
+    "zw" .emit 0x03 .or "z" .emit 0x02 .or "w" .emit 0x01;
+
+/*
+fragment program
+    <rgbaMask>             ::= "." "r"
+                             | "." "g"
+                             | "." "rg"
+                             | "." "b"
+                             | "." "rb"
+                             | "." "gb"
+                             | "." "rgb"
+                             | "." "a"
+                             | "." "ra"
+                             | "." "ga"
+                             | "." "rga"
+                             | "." "ba"
+                             | "." "rba"
+                             | "." "gba"
+                             | "." "rgba"
+*/
+rgbaMask
+    dot_ne .and rgbaMask_1;
+rgbaMask_1
+    "rgba" .emit 0x0F .or "rgb" .emit 0x0E .or "rga" .emit 0x0D .or "rg" .emit 0x0C .or
+    "rba" .emit 0x0B .or "rb" .emit 0x0A .or "ra" .emit 0x09 .or "r" .emit 0x08 .or
+    "gba" .emit 0x07 .or "gb" .emit 0x06 .or "ga" .emit 0x05 .or "g" .emit 0x04 .or
+    "ba" .emit 0x03 .or "b" .emit 0x02 .or "a" .emit 0x01;
+
+/*
+fragment program
+    <namingStatement>      ::= <ATTRIB_statement>
+                             | <PARAM_statement>
+                             | <TEMP_statement>
+                             | <OUTPUT_statement>
+                             | <ALIAS_statement>
+
+vertex program
+    <namingStatement>      ::= <ATTRIB_statement>
+                             | <PARAM_statement>
+                             | <TEMP_statement>
+                             | <ADDRESS_statement>
+                             | <OUTPUT_statement>
+                             | <ALIAS_statement>
+*/
+fp_namingStatement
+    fp_ATTRIB_statement .emit ATTRIB .or
+    fp_PARAM_statement .emit PARAM .or
+    fp_TEMP_statement .emit TEMP .or
+    fp_OUTPUT_statement .emit OUTPUT .or
+    fp_ALIAS_statement .emit ALIAS;
+vp_namingStatement
+    vp_ATTRIB_statement .emit ATTRIB .or
+    vp_PARAM_statement .emit PARAM .or
+    vp_TEMP_statement .emit TEMP .or
+    ADDRESS_statement .emit ADDRESS .or
+    vp_OUTPUT_statement .emit OUTPUT .or
+    vp_ALIAS_statement .emit ALIAS;
+
+/*
+fragment program
+    <ATTRIB_statement>     ::= "ATTRIB" <establishName> "="
+                                 <fragAttribBinding>
+
+vertex program
+    <ATTRIB_statement>     ::= "ATTRIB" <establishName> "="
+                                 <vtxAttribBinding>
+*/
+fp_ATTRIB_statement
+    "ATTRIB" .and space .and fp_establishName .and equal .and
+    fragAttribBinding .error FRAGMENT_EXPECTED;
+vp_ATTRIB_statement
+    "ATTRIB" .and space .and vp_establishName .and equal .and
+    vtxAttribBinding .error VERTEX_EXPECTED;
+
+/*
+fragment program
+    <fragAttribBinding>    ::= "fragment" "." <fragAttribItem>
+*/
+fragAttribBinding
+    "fragment" .and dot .and fragAttribItem .error INVALID_FRAGMENT_PROPERTY;
+
+/*
+vertex program
+    <vtxAttribBinding>     ::= "vertex" "." <vtxAttribItem>
+*/
+vtxAttribBinding
+    "vertex" .and dot .and vtxAttribItem .error INVALID_VERTEX_PROPERTY;
+
+/*
+fragment program
+    <fragAttribItem>       ::= "color" <optColorType>
+                             | "texcoord" <optTexCoordNum>
+                             | "fogcoord"
+                             | "position"
+*/
+fragAttribItem
+    fragAttribItem_1 .emit FRAGMENT_ATTRIB_COLOR .or
+    fragAttribItem_2 .emit FRAGMENT_ATTRIB_TEXCOORD .or
+    .if (fog_coord != 0x00) "fogcoord" .emit FRAGMENT_ATTRIB_FOGCOORD .or
+    "position" .emit FRAGMENT_ATTRIB_POSITION;
+fragAttribItem_1
+    "color" .and optColorType;
+fragAttribItem_2
+    "texcoord" .and optTexCoordNum;
+
+/*
+vertex program
+    <vtxAttribItem>        ::= "position"
+                             | "weight" <vtxOptWeightNum>
+                             | "normal"
+                             | "color" <optColorType>
+                             | "fogcoord"
+                             | "texcoord" <optTexCoordNum>
+                             | "matrixindex" "[" <vtxWeightNum> "]"
+                             | "attrib" "[" <vtxAttribNum> "]"
+*/
+vtxAttribItem
+    "position" .emit VERTEX_ATTRIB_POSITION .or
+    .if (vertex_blend != 0x00) vtxAttribItem_1 .emit VERTEX_ATTRIB_WEIGHT .or
+    "normal" .emit VERTEX_ATTRIB_NORMAL .or
+    vtxAttribItem_2 .emit VERTEX_ATTRIB_COLOR .or
+    "fogcoord" .emit VERTEX_ATTRIB_FOGCOORD .or
+    vtxAttribItem_3 .emit VERTEX_ATTRIB_TEXCOORD .or
+    .if (matrix_palette != 0x00) vtxAttribItem_4 .emit VERTEX_ATTRIB_MATRIXINDEX .or
+    vtxAttribItem_5 .emit VERTEX_ATTRIB_GENERIC;
+vtxAttribItem_1
+    "weight" .and vtxOptWeightNum;
+vtxAttribItem_2
+    "color" .and optColorType;
+vtxAttribItem_3
+    "texcoord" .and optTexCoordNum;
+vtxAttribItem_4
+    "matrixindex" .and lbracket .and vtxWeightNum .and rbracket;
+vtxAttribItem_5
+    "attrib" .and lbracket .and vtxAttribNum .and rbracket;
+
+/*
+vertex program
+    <vtxAttribNum>         ::= <integer> from 0 to MAX_VERTEX_ATTRIBS_ARB-1
+*/
+vtxAttribNum
+    integer;
+
+/*
+vertex program
+    <vtxOptWeightNum>      ::= ""
+                             | "[" <vtxWeightNum> "]"
+*/
+vtxOptWeightNum
+    vtxOptWeightNum_1 .or .true .emit 0x00;
+vtxOptWeightNum_1
+    lbracket_ne .and vtxWeightNum .and rbracket;
+
+/*
+vertex program
+    <vtxWeightNum>         ::= <integer> from 0 to MAX_VERTEX_UNITS_ARB-1,
+                                 must be divisible by four
+*/
+vtxWeightNum
+    integer;
+
+/*
+    <PARAM_statement>      ::= <PARAM_singleStmt>
+                             | <PARAM_multipleStmt>
+*/
+fp_PARAM_statement
+    fp_PARAM_multipleStmt .or fp_PARAM_singleStmt;
+vp_PARAM_statement
+    vp_PARAM_multipleStmt .or vp_PARAM_singleStmt;
+
+/*
+    <PARAM_singleStmt>     ::= "PARAM" <establishName> <paramSingleInit>
+*/
+fp_PARAM_singleStmt
+    "PARAM" .and space .and fp_establishName .and .true .emit 0x00 .and fp_paramSingleInit .and
+    .true .emit PARAM_NULL;
+vp_PARAM_singleStmt
+    "PARAM" .and space .and vp_establishName .and .true .emit 0x00 .and vp_paramSingleInit .and
+    .true .emit PARAM_NULL;
+
+/*
+    <PARAM_multipleStmt>   ::= "PARAM" <establishName> "[" <optArraySize> "]"
+                                   <paramMultipleInit>
+*/
+fp_PARAM_multipleStmt
+    "PARAM" .and space .and fp_establishName .and lbracket_ne .and optArraySize .and rbracket .and
+    fp_paramMultipleInit .and .true .emit PARAM_NULL;
+vp_PARAM_multipleStmt
+    "PARAM" .and space .and vp_establishName .and lbracket_ne .and optArraySize .and rbracket .and
+    vp_paramMultipleInit .and .true .emit PARAM_NULL;
+
+/*
+    <optArraySize>         ::= ""
+                             | <integer> from 1 to MAX_PROGRAM_PARAMETERS_ARB
+                                 (maximum number of allowed program 
+                                  parameter bindings)
+*/
+optArraySize
+    optional_integer;
+
+/*
+    <paramSingleInit>      ::= "=" <paramSingleItemDecl>
+*/
+fp_paramSingleInit
+    equal .and fp_paramSingleItemDecl;
+vp_paramSingleInit
+    equal .and vp_paramSingleItemDecl;
+
+/*
+    <paramMultipleInit>    ::= "=" "{" <paramMultInitList> "}"
+*/
+fp_paramMultipleInit
+    equal .and lbrace .and fp_paramMultInitList .and rbrace;
+vp_paramMultipleInit
+    equal .and lbrace .and vp_paramMultInitList .and rbrace;
+
+/*
+    <paramMultInitList>    ::= <paramMultipleItem>
+                             | <paramMultipleItem> "," <paramMultiInitList>
+*/
+fp_paramMultInitList
+    fp_paramMultInitList_1 .or fp_paramMultipleItem;
+vp_paramMultInitList
+    vp_paramMultInitList_1 .or vp_paramMultipleItem;
+fp_paramMultInitList_1
+    fp_paramMultipleItem .and comma_ne .and fp_paramMultInitList;
+vp_paramMultInitList_1
+    vp_paramMultipleItem .and comma_ne .and vp_paramMultInitList;
+
+/*
+    <paramSingleItemDecl>  ::= <stateSingleItem>
+                             | <programSingleItem>
+                             | <paramConstDecl>
+*/
+fp_paramSingleItemDecl
+    fp_stateSingleItem .emit PARAM_STATE_ELEMENT .or
+    programSingleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstDecl .emit PARAM_CONSTANT;
+vp_paramSingleItemDecl
+    vp_stateSingleItem .emit PARAM_STATE_ELEMENT .or
+    programSingleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstDecl .emit PARAM_CONSTANT;
+
+/*
+    <paramSingleItemUse>   ::= <stateSingleItem>
+                             | <programSingleItem>
+                             | <paramConstUse>
+*/
+fp_paramSingleItemUse
+    fp_stateSingleItem .emit PARAM_STATE_ELEMENT .or
+    programSingleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstUse .emit PARAM_CONSTANT;
+vp_paramSingleItemUse
+    vp_stateSingleItem .emit PARAM_STATE_ELEMENT .or
+    programSingleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstUse .emit PARAM_CONSTANT;
+
+/*
+    <paramMultipleItem>    ::= <stateMultipleItem>
+                             | <programMultipleItem>
+                             | <paramConstDecl>
+*/
+fp_paramMultipleItem
+    fp_stateMultipleItem .emit PARAM_STATE_ELEMENT .or
+    programMultipleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstDecl .emit PARAM_CONSTANT;
+vp_paramMultipleItem
+    vp_stateMultipleItem .emit PARAM_STATE_ELEMENT .or
+    programMultipleItem .emit PARAM_PROGRAM_ELEMENT .or
+    paramConstDecl .emit PARAM_CONSTANT;
+
+/*
+    <stateMultipleItem>    ::= <stateSingleItem>
+                             | "state" "." <stateMatrixRows>
+*/
+fp_stateMultipleItem
+    stateMultipleItem_1 .or fp_stateSingleItem;
+vp_stateMultipleItem
+    stateMultipleItem_1 .or vp_stateSingleItem;
+stateMultipleItem_1
+    "state" .and dot .and stateMatrixRows .emit STATE_MATRIX_ROWS;
+
+/*
+fragment program
+    <stateSingleItem>      ::= "state" "." <stateMaterialItem>
+                             | "state" "." <stateLightItem>
+                             | "state" "." <stateLightModelItem>
+                             | "state" "." <stateLightProdItem>
+                             | "state" "." <stateTexEnvItem>
+                             | "state" "." <stateFogItem>
+                             | "state" "." <stateDepthItem>
+                             | "state" "." <stateMatrixRow>
+
+vertex program
+    <stateSingleItem>      ::= "state" "." <stateMaterialItem>
+                             | "state" "." <stateLightItem>
+                             | "state" "." <stateLightModelItem>
+                             | "state" "." <stateLightProdItem>
+                             | "state" "." <stateTexGenItem>
+                             | "state" "." <stateFogItem>
+                             | "state" "." <stateClipPlaneItem>
+                             | "state" "." <statePointItem>
+                             | "state" "." <stateMatrixRow>
+*/
+fp_stateSingleItem
+    "state" .and dot .and fp_stateSingleItem_1 .error INVALID_STATE_PROPERTY;
+vp_stateSingleItem
+    "state" .and dot .and vp_stateSingleItem_1 .error INVALID_STATE_PROPERTY;
+fp_stateSingleItem_1
+    stateSingleItem_1 .or stateSingleItem_2 .or stateSingleItem_3 .or stateSingleItem_4 .or
+    stateSingleItem_5 .or stateSingleItem_7 .or stateSingleItem_8 .or stateSingleItem_11;
+vp_stateSingleItem_1
+    stateSingleItem_1 .or stateSingleItem_2 .or stateSingleItem_3 .or stateSingleItem_4 .or
+    stateSingleItem_6 .or stateSingleItem_7 .or stateSingleItem_9 .or stateSingleItem_10 .or
+    stateSingleItem_11;
+stateSingleItem_1
+    stateMaterialItem .emit STATE_MATERIAL;
+stateSingleItem_2
+    stateLightItem .emit STATE_LIGHT;
+stateSingleItem_3
+    stateLightModelItem .emit STATE_LIGHT_MODEL;
+stateSingleItem_4
+    stateLightProdItem .emit STATE_LIGHT_PROD;
+stateSingleItem_5
+    stateTexEnvItem .emit STATE_TEX_ENV;
+stateSingleItem_6
+    stateTexGenItem .emit STATE_TEX_GEN;
+stateSingleItem_7
+    stateFogItem .emit STATE_FOG;
+stateSingleItem_8
+    stateDepthItem .emit STATE_DEPTH;
+stateSingleItem_9
+    stateClipPlaneItem .emit STATE_CLIP_PLANE;
+stateSingleItem_10
+    statePointItem .emit STATE_POINT;
+stateSingleItem_11
+    stateMatrixRow .emit STATE_MATRIX_ROWS;
+
+/*
+    <stateMaterialItem>    ::= "material" <optFaceType> "." <stateMatProperty>
+*/
+stateMaterialItem
+    "material" .and optFaceType .and dot .and stateMatProperty .error INVALID_MATERIAL_PROPERTY;
+
+/*
+    <stateMatProperty>     ::= "ambient"
+                             | "diffuse"
+                             | "specular"
+                             | "emission"
+                             | "shininess"
+*/
+stateMatProperty
+    "ambient" .emit MATERIAL_AMBIENT .or
+    "diffuse" .emit MATERIAL_DIFFUSE .or
+    "specular" .emit MATERIAL_SPECULAR .or
+    "emission" .emit MATERIAL_EMISSION .or
+    "shininess" .emit MATERIAL_SHININESS;
+
+/*
+    <stateLightItem>       ::= "light" "[" <stateLightNumber> "]" "." 
+                                 <stateLightProperty>
+*/
+stateLightItem
+    "light" .and lbracket .and stateLightNumber .and rbracket .and dot .and
+    stateLightProperty .error INVALID_LIGHT_PROPERTY;
+
+/*
+    <stateLightProperty>   ::= "ambient"
+                             | "diffuse" 
+                             | "specular"
+                             | "position"
+                             | "attenuation"
+                             | "spot" "." <stateSpotProperty>
+                             | "half"
+*/
+stateLightProperty
+    "ambient" .emit LIGHT_AMBIENT .or
+    "diffuse" .emit LIGHT_DIFFUSE .or
+    "specular" .emit LIGHT_SPECULAR .or
+    "position" .emit LIGHT_POSITION .or
+    "attenuation" .emit LIGHT_ATTENUATION .or
+    stateLightProperty_1 .emit LIGHT_SPOT_DIRECTION .or
+    "half" .emit LIGHT_HALF;
+stateLightProperty_1
+    "spot" .and dot .and stateSpotProperty .error INVALID_SPOT_PROPERTY;
+
+/*
+    <stateSpotProperty>    ::= "direction" 
+*/
+stateSpotProperty
+    "direction";
+
+/*
+    <stateLightModelItem>  ::= "lightmodel" <stateLModProperty>
+*/
+stateLightModelItem
+    "lightmodel" .and stateLModProperty .error INVALID_LIGHTMODEL_PROPERTY;
+
+/*
+    <stateLModProperty>    ::= "." "ambient"
+                             | <optFaceType> "." "scenecolor"
+*/
+stateLModProperty
+    stateLModProperty_1 .or stateLModProperty_2;
+stateLModProperty_1
+    dot .and "ambient" .emit LIGHT_MODEL_AMBIENT;
+stateLModProperty_2
+    stateLModProperty_3 .emit LIGHT_MODEL_SCENECOLOR;
+stateLModProperty_3
+    optFaceType .and dot .and "scenecolor";
+
+/*
+    <stateLightProdItem>   ::= "lightprod" "[" <stateLightNumber> "]"
+                                 <optFaceType> "." <stateLProdProperty>
+*/
+stateLightProdItem
+    "lightprod" .and lbracket .and stateLightNumber .and rbracket .and optFaceType .and dot .and
+    stateLProdProperty .error INVALID_LIGHTPROD_PROPERTY;
+
+/*
+    <stateLProdProperty>   ::= "ambient"
+                             | "diffuse"
+                             | "specular"
+*/
+stateLProdProperty
+    "ambient" .emit LIGHT_PROD_AMBIENT .or
+    "diffuse" .emit LIGHT_PROD_DIFFUSE .or
+    "specular" .emit LIGHT_PROD_SPECULAR;
+
+/*
+    <stateLightNumber>     ::= <integer> from 0 to MAX_LIGHTS-1
+*/
+stateLightNumber
+    integer;
+
+/*
+fragment program
+    <stateTexEnvItem>      ::= "texenv" <optLegacyTexUnitNum> "." 
+                                 <stateTexEnvProperty>
+*/
+stateTexEnvItem
+    "texenv" .and optLegacyTexUnitNum .and dot .and
+    stateTexEnvProperty .error INVALID_TEXENV_PROPERTY;
+
+/*
+fragment program
+    <stateTexEnvProperty>  ::= "color"
+*/
+stateTexEnvProperty
+    "color" .emit TEX_ENV_COLOR;
+
+/*
+fragment program
+    <optLegacyTexUnitNum>  ::= ""
+                             | "[" <legacyTexUnitNum> "]"
+
+NOTE: <optLegaceTexUnitNum> is not optional.
+*/
+optLegacyTexUnitNum
+    lbracket_ne .and legacyTexUnitNum .and rbracket;
+
+/*
+fragment program
+    <legacyTexUnitNum>     ::= <integer> from 0 to MAX_TEXTURE_UNITS-1
+*/
+legacyTexUnitNum
+    integer;
+
+/*
+vertex program
+    <stateTexGenItem>      ::= "texgen" <optTexCoordNum> "."
+                                 <stateTexGenType> "." <stateTexGenCoord>
+*/
+stateTexGenItem
+    "texgen" .and optTexCoordNum .and dot .and stateTexGenType .error INVALID_TEXGEN_PROPERTY .and
+    dot .and stateTexGenCoord .error INVALID_TEXGEN_COORD;
+
+/*
+vertex program
+    <stateTexGenType>      ::= "eye"
+                             | "object"
+*/
+stateTexGenType
+    "eye" .emit TEX_GEN_EYE .or
+    "object" .emit TEX_GEN_OBJECT;
+
+/*
+vertex program
+    <stateTexGenCoord>     ::= "s"
+                             | "t"
+                             | "r"
+                             | "q"
+*/
+stateTexGenCoord
+    "s" .emit COMPONENT_X .or
+    "t" .emit COMPONENT_Y .or
+    "r" .emit COMPONENT_Z .or
+    "q" .emit COMPONENT_W;
+
+/*
+    <stateFogItem>         ::= "fog" "." <stateFogProperty>
+*/
+stateFogItem
+    "fog" .and dot .and stateFogProperty .error INVALID_FOG_PROPERTY;
+
+/*
+    <stateFogProperty>     ::= "color"
+                             | "params"
+*/
+stateFogProperty
+    "color" .emit FOG_COLOR .or
+    "params" .emit FOG_PARAMS;
+
+/*
+fragment program
+    <stateDepthItem>       ::= "depth" "." <stateDepthProperty>
+*/
+stateDepthItem
+    "depth" .and dot .and stateDepthProperty .error INVALID_DEPTH_PROPERTY;
+
+/*
+fragment program
+    <stateDepthProperty>   ::= "range"
+*/
+stateDepthProperty
+    "range" .emit DEPTH_RANGE;
+
+/*
+vertex program
+    <stateClipPlaneItem>   ::= "clip" "[" <stateClipPlaneNum> "]" "." "plane"
+*/
+stateClipPlaneItem
+    "clip" .and lbracket .and stateClipPlaneNum .and rbracket .and dot .and
+    "plane" .error INVALID_CLIPPLANE_PROPERTY;
+
+/*
+vertex program
+    <stateClipPlaneNum>    ::= <integer> from 0 to MAX_CLIP_PLANES-1
+*/
+stateClipPlaneNum
+    integer;
+
+/*
+vertex program
+    <statePointItem>       ::= "point" . <statePointProperty>
+*/
+statePointItem
+    "point" .and dot .and statePointProperty .error INVALID_POINT_PROPERTY;
+
+/*
+vertex program
+    <statePointProperty>   ::= "size"
+                             | "attenuation"
+*/
+statePointProperty
+    "size" .emit POINT_SIZE .or
+    .if (point_parameters != 0x00) "attenuation" .emit POINT_ATTENUATION;
+
+/*
+    <stateMatrixRow>       ::= <stateMatrixItem> "." "row" "[" 
+                                  <stateMatrixRowNum> "]"
+*/
+stateMatrixRow
+    stateMatrixItem .and dot .and "row" .error MATRIX_ROW_SELECTOR_OR_MODIFIER_EXPECTED .and
+    lbracket .and stateMatrixRowNum .and rbracket .emit 0x0;
+
+/*
+    <stateMatrixRows>      ::= <stateMatrixItem> <optMatrixRows>
+*/
+stateMatrixRows
+    stateMatrixItem .and optMatrixRows;
+
+/*
+    <optMatrixRows>        ::= ""
+                             | "." "row" "[" <stateMatrixRowNum> ".." 
+                                  <stateMatrixRowNum> "]"
+*/
+optMatrixRows
+    optMatrixRows_1 .or .true .emit 0x0 .emit '3' .emit 0x0 .emit $;
+optMatrixRows_1
+    dot_ne .and "row" .error MATRIX_ROW_SELECTOR_OR_MODIFIER_EXPECTED .and lbracket .and
+    stateMatrixRowNum .and dotdot .and stateMatrixRowNum .and rbracket;
+
+/*
+    <stateMatrixItem>      ::= "matrix" . <stateMatrixName> 
+                               <stateOptMatModifier>
+*/
+stateMatrixItem
+    "matrix" .and dot .and stateMatrixName .error INVALID_MATRIX_NAME .and stateOptMatModifier;
+
+/*
+    <stateOptMatModifier>  ::= ""
+                             | "." <stateMatModifier>
+*/
+stateOptMatModifier
+    stateOptMatModifier_1 .or .true .emit MATRIX_MODIFIER_IDENTITY;
+stateOptMatModifier_1
+    dot_ne .and stateMatModifier;
+
+/*
+    <stateMatModifier>     ::= "inverse" 
+                             | "transpose" 
+                             | "invtrans"
+*/
+stateMatModifier
+    "inverse" .emit MATRIX_MODIFIER_INVERSE .or
+    "transpose" .emit MATRIX_MODIFIER_TRANSPOSE .or
+    "invtrans" .emit MATRIX_MODIFIER_INVTRANS;
+
+/*
+    <stateMatrixRowNum>    ::= <integer> from 0 to 3
+*/
+stateMatrixRowNum
+    integer_0_3;
+
+/*
+    <stateMatrixName>      ::= "modelview" <stateOptModMatNum>
+                             | "projection"
+                             | "mvp"
+                             | "texture" <optTexCoordNum>
+                             | "palette" "[" <statePaletteMatNum> "]"
+                             | "program" "[" <stateProgramMatNum> "]"
+*/
+stateMatrixName
+    stateMatrixName_1_1 .emit MATRIX_MODELVIEW .or
+    "projection" .emit MATRIX_PROJECTION .or
+    "mvp" .emit MATRIX_MVP .or
+    stateMatrixName_1_2 .emit MATRIX_TEXTURE .or
+    .if (matrix_palette != 0x00) stateMatrixName_1_3 .emit MATRIX_PALETTE .or
+    stateMatrixName_1_4 .emit MATRIX_PROGRAM;
+stateMatrixName_1_1
+    "modelview" .and stateOptModMatNum;
+stateMatrixName_1_2
+    "texture" .and optTexCoordNum;
+stateMatrixName_1_3
+    "palette" .and lbracket .and statePaletteMatNum .and rbracket;
+stateMatrixName_1_4
+    "program" .and lbracket .and stateProgramMatNum .and rbracket;
+
+/*
+    <stateOptModMatNum>    ::= ""
+                             | "[" <stateModMatNum> "]"
+*/
+stateOptModMatNum
+    .if (vertex_blend != 0x00) stateOptModMatNum_1 .or
+    .true .emit 0x00;
+stateOptModMatNum_1
+    lbracket_ne .and stateModMatNum .and rbracket;
+
+/*
+    <stateModMatNum>       ::= <integer> from 0 to MAX_VERTEX_UNITS_ARB-1
+*/
+stateModMatNum
+    integer;
+
+/*
+    <optTexCoordNum>       ::= ""
+                             | "[" <texCoordNum> "]"
+*/
+optTexCoordNum
+    optTexCoordNum_1 .or .true .emit 0x00;
+optTexCoordNum_1
+    lbracket_ne .and texCoordNum .and rbracket;
+
+/*
+    <texCoordNum>          ::= <integer> from 0 to MAX_TEXTURE_COORDS_ARB-1
+*/
+texCoordNum
+    integer;
+
+/*
+    <statePaletteMatNum>   ::= <integer> from 0 to MAX_PALETTE_MATRICES_ARB-1
+*/
+statePaletteMatNum
+    integer;
+
+/*
+    <stateProgramMatNum>   ::= <integer> from 0 to MAX_PROGRAM_MATRICES_ARB-1
+*/
+stateProgramMatNum
+    integer;
+
+/*
+    <programSingleItem>    ::= <progEnvParam>
+                             | <progLocalParam>
+
+NOTE: <programSingleItem> has been modified for correct error handling. If program property
+      is neither "env" nor "local" INVALID_PROGRAM_PROPERTY is generated.
+*/
+programSingleItem
+    "program" .and dot .and programSingleItem_1 .error INVALID_PROGRAM_PROPERTY;
+programSingleItem_1
+    progEnvParam .or progLocalParam;
+
+/*
+    <programMultipleItem>  ::= <progEnvParams>
+                             | <progLocalParams>
+
+NOTE: <programMultipleItem> has been modified for correct error handling. If program property
+      is neither "env" nor "local" INVALID_PROGRAM_PROPERTY is generated.
+*/
+programMultipleItem
+    "program" .and dot .and programMultipleItem_1 .error INVALID_PROGRAM_PROPERTY;
+programMultipleItem_1
+    progEnvParams .or progLocalParams;
+
+/*
+    <progEnvParams>        ::= "program" "." "env" 
+                                 "[" <progEnvParamNums> "]"
+
+NOTE: "program" "." has been moved to <programMultipleItem>.
+*/
+progEnvParams
+    "env" .emit PROGRAM_PARAM_ENV .and lbracket .and progEnvParamNums .and rbracket;
+
+/*
+    <progEnvParamNums>     ::= <progEnvParamNum>
+                             | <progEnvParamNum> ".." <progEnvParamNum>
+*/
+progEnvParamNums
+    progEnvParamNums_1 .or progEnvParamNums_2;
+progEnvParamNums_1
+    progEnvParamNum .and dotdot_ne .and progEnvParamNum;
+progEnvParamNums_2
+    progEnvParamNum .and .true .emit 0x00;
+
+/*
+    <progEnvParam>         ::= "program" "." "env" 
+                                 "[" <progEnvParamNum> "]"
+
+NOTE: "program" "." has been moved to <programSingleItem>.
+*/
+progEnvParam
+    "env" .emit PROGRAM_PARAM_ENV .and lbracket .and progEnvParamNum .and rbracket .emit 0x00;
+
+/*
+    <progLocalParams>      ::= "program" "." "local" 
+                                 "[" <progLocalParamNums> "]"
+
+NOTE: "program" "." has been moved to <programMultipleItem>.
+*/
+progLocalParams
+    "local" .emit PROGRAM_PARAM_LOCAL .and lbracket .and progLocalParamNums .and rbracket;
+
+/*
+    <progLocalParamNums>   ::= <progLocalParamNum>
+                             | <progLocalParamNum> ".." <progLocalParamNum>
+*/
+progLocalParamNums
+    progLocalParamNums_1 .or progLocalParamNums_2;
+progLocalParamNums_1
+    progLocalParamNum .and dotdot_ne .and progLocalParamNum;
+progLocalParamNums_2
+    progLocalParamNum .and .true .emit 0x00;
+
+/*
+    <progLocalParam>       ::= "program" "." "local" 
+                                 "[" <progLocalParamNum> "]"
+
+NOTE: "program" "." has been moved to <programSingleItem>.
+*/
+progLocalParam
+    "local" .emit PROGRAM_PARAM_LOCAL .and lbracket .and progLocalParamNum .and rbracket .emit 0x00;
+
+/*
+    <progEnvParamNum>      ::= <integer> from 0 to
+                               MAX_PROGRAM_ENV_PARAMETERS_ARB - 1
+*/
+progEnvParamNum
+    integer;
+
+/*
+    <progLocalParamNum>    ::= <integer> from 0 to
+                               MAX_PROGRAM_LOCAL_PARAMETERS_ARB - 1
+*/
+progLocalParamNum
+    integer;
+
+/*
+    <paramConstDecl>       ::= <paramConstScalarDecl>
+                             | <paramConstVector>
+*/
+paramConstDecl
+    paramConstScalarDecl .emit CONSTANT_SCALAR .or paramConstVector .emit CONSTANT_VECTOR;
+
+/*
+    <paramConstUse>        ::= <paramConstScalarUse>
+                             | <paramConstVector>
+*/
+paramConstUse
+    paramConstScalarUse .emit CONSTANT_SCALAR .or paramConstVector .emit CONSTANT_VECTOR;
+
+/*
+    <paramConstScalarDecl> ::= <signedFloatConstant>
+*/
+paramConstScalarDecl
+    signedFloatConstant;
+
+/*
+    <paramConstScalarUse>  ::= <floatConstant>
+*/
+paramConstScalarUse
+    floatConstant;
+
+/*
+    <paramConstVector>     ::= "{" <signedFloatConstant> "}"
+                             | "{" <signedFloatConstant> "," 
+                                   <signedFloatConstant> "}"
+                             | "{" <signedFloatConstant> "," 
+                                   <signedFloatConstant> ","
+                                   <signedFloatConstant> "}"
+                             | "{" <signedFloatConstant> "," 
+                                   <signedFloatConstant> ","
+                                   <signedFloatConstant> "," 
+                                   <signedFloatConstant> "}"
+*/
+paramConstVector
+    paramConstVector_4 .emit 0x04 .or paramConstVector_3 .emit 0x03 .or
+    paramConstVector_2 .emit 0x02 .or paramConstVector_1 .emit 0x01;
+paramConstVector_1
+    lbrace_ne .and signedFloatConstant .and rbrace;
+paramConstVector_2
+    lbrace_ne .and signedFloatConstant .and comma_ne .and signedFloatConstant .and rbrace;
+paramConstVector_3
+    lbrace_ne .and signedFloatConstant .and comma_ne .and signedFloatConstant .and comma_ne .and
+    signedFloatConstant .and rbrace;
+paramConstVector_4
+    lbrace_ne .and signedFloatConstant .and comma_ne .and signedFloatConstant .and comma_ne .and
+    signedFloatConstant .and comma_ne .and signedFloatConstant .and rbrace;
+
+/*
+    <signedFloatConstant>  ::= <optionalSign> <floatConstant>
+*/
+signedFloatConstant
+    optionalSign .and floatConstant;
+
+/*
+    <floatConstant>        ::= see text
+    The <floatConstant> rule matches a floating-point constant consisting
+    of an integer part, a decimal point, a fraction part, an "e" or
+    "E", and an optionally signed integer exponent.  The integer and
+    fraction parts both consist of a sequence of one or more digits ("0"
+    through "9").  Either the integer part or the fraction parts (not
+    both) may be missing; either the decimal point or the "e" (or "E")
+    and the exponent (not both) may be missing.
+*/
+floatConstant
+    float;
+
+/*
+    <optionalSign>         ::= ""
+                             | "-"
+                             | "+"
+*/
+optionalSign
+    optional_sign_ne;
+
+/*
+    <TEMP_statement>       ::= "TEMP" <varNameList>
+*/
+fp_TEMP_statement
+    "TEMP" .and space .and fp_varNameList .and .true .emit 0x00;
+vp_TEMP_statement
+    "TEMP" .and space .and vp_varNameList .and .true .emit 0x00;
+
+/*
+vertex program
+    <ADDRESS_statement>    ::= "ADDRESS" <varNameList>
+*/
+ADDRESS_statement
+    "ADDRESS" .and space .and vp_varNameList .and .true .emit 0x00;
+
+/*
+    <varNameList>          ::= <establishName>
+                             | <establishName> "," <varNameList>
+*/
+fp_varNameList
+    fp_varNameList_1 .or fp_establishName;
+vp_varNameList
+    vp_varNameList_1 .or vp_establishName;
+fp_varNameList_1
+    fp_establishName .and comma_ne .and fp_varNameList;
+vp_varNameList_1
+    vp_establishName .and comma_ne .and vp_varNameList;
+
+/*
+    <OUTPUT_statement>     ::= "OUTPUT" <establishName> "="
+                                 <resultBinding>
+*/
+fp_OUTPUT_statement
+    "OUTPUT" .and space .and fp_establishName .and equal .and
+    fp_resultBinding .error RESULT_EXPECTED;
+vp_OUTPUT_statement
+    "OUTPUT" .and space .and vp_establishName .and equal .and
+    vp_resultBinding .error RESULT_EXPECTED;
+
+/*
+fragment program
+    <resultBinding>        ::= "result" "." "color"
+                             | "result" "." "depth"
+
+vertex program
+    <resultBinding>        ::= "result" "." "position"
+                             | "result" "." <resultColBinding>
+                             | "result" "." "fogcoord"
+                             | "result" "." "pointsize"
+                             | "result" "." "texcoord" <optTexCoordNum>
+*/
+fp_resultBinding
+    "result" .and dot .and fp_resultBinding_1 .error INVALID_RESULT_PROPERTY;
+vp_resultBinding
+    "result" .and dot .and vp_resultBinding_1 .error INVALID_RESULT_PROPERTY;
+fp_resultBinding_1
+    "color" .emit FRAGMENT_RESULT_COLOR .or
+    "depth" .emit FRAGMENT_RESULT_DEPTH;
+vp_resultBinding_1
+    .if (ARB_position_invariant == 0x00) "position" .emit VERTEX_RESULT_POSITION .or
+    resultColBinding .emit VERTEX_RESULT_COLOR .or
+    "fogcoord" .emit VERTEX_RESULT_FOGCOORD .or
+    "pointsize" .emit VERTEX_RESULT_POINTSIZE .or
+    vp_resultBinding_2 .emit VERTEX_RESULT_TEXCOORD;
+vp_resultBinding_2
+    "texcoord" .and optTexCoordNum;
+
+/*
+vertex program
+    <resultColBinding>     ::= "color" <optFaceType> <optColorType>
+*/
+resultColBinding
+    "color" .and optFaceType .and optColorType;
+
+/*
+    <optFaceType>          ::= ""
+                             | "." "front"
+                             | "." "back"
+*/
+optFaceType
+    FaceType .or .true .emit FACE_FRONT;
+FaceType
+    dot_ne .and FaceProperty;
+FaceProperty
+    "front" .emit FACE_FRONT .or "back" .emit FACE_BACK;
+
+/*
+    <optColorType>         ::= ""
+                             | "." "primary"
+                             | "." "secondary"
+*/
+optColorType
+    ColorType .or .true .emit COLOR_PRIMARY;
+ColorType
+    dot_ne .and ColorProperty;
+ColorProperty
+    "primary" .emit COLOR_PRIMARY .or
+    .if (secondary_color != 0x00) "secondary" .emit COLOR_SECONDARY;
+
+/*
+    <ALIAS_statement>      ::= "ALIAS" <establishName> "="
+                                 <establishedName>
+*/
+fp_ALIAS_statement
+    "ALIAS" .and fp_ALIAS_statement_1 .error IDENTIFIER_EXPECTED .and equal .and fp_establishedName;
+vp_ALIAS_statement
+    "ALIAS" .and vp_ALIAS_statement_1 .error IDENTIFIER_EXPECTED .and equal .and vp_establishedName;
+fp_ALIAS_statement_1
+    space .and fp_establishName;
+vp_ALIAS_statement_1
+    space .and vp_establishName;
+
+/*
+    <establishName>        ::= <identifier>
+*/
+fp_establishName
+    fp_identifier;
+vp_establishName
+    vp_identifier;
+
+/*
+    <establishedName>      ::= <identifier>
+*/
+fp_establishedName
+    fp_identifier;
+vp_establishedName
+    vp_identifier;
+fp_establishedName_no_error_on_identifier
+    fp_identifier_ne;
+vp_establishedName_no_error_on_identifier
+    vp_identifier_ne;
+
+/*
+fragment program
+    <identifier>           ::= see text
+    The <identifier> rule matches a sequence of one or more letters ("A"
+    through "Z", "a" through "z"), digits ("0" through "9), underscores 
+    ("_"), or dollar signs ("$"); the first character must not be a 
+    number.  Upper and lower case letters are considered different 
+    (names are case-sensitive).  The following strings are reserved 
+    keywords and may not be used as identifiers:
+
+        ABS, ABS_SAT, ADD, ADD_SAT, ALIAS, ATTRIB, CMP, CMP_SAT, COS,
+        COS_SAT, DP3, DP3_SAT, DP4, DP4_SAT, DPH, DPH_SAT, DST, DST_SAT, 
+        END, EX2, EX2_SAT, FLR, FLR_SAT, FRC, FRC_SAT, KIL, LG2, 
+        LG2_SAT, LIT, LIT_SAT, LRP, LRP_SAT, MAD, MAD_SAT, MAX, MAX_SAT, 
+        MIN, MIN_SAT, MOV, MOV_SAT, MUL, MUL_SAT, OPTION, OUTPUT, PARAM, 
+        POW, POW_SAT, RCP, RCP_SAT, RSQ, RSQ_SAT, SIN, SIN_SAT, SCS, 
+        SCS_SAT, SGE, SGE_SAT, SLT, SLT_SAT, SUB, SUB_SAT, SWZ, SWZ_SAT, 
+        TEMP, TEX, TEX_SAT, TXB, TXB_SAT, TXP, TXP_SAT, XPD, XPD_SAT, 
+        fragment, program, result, state, and texture.
+
+vertex program
+    <identifier>           ::= see text
+    The <identifier> rule matches a sequence of one or more letters ("A"
+    through "Z", "a" through "z"), digits ("0" through "9), underscores ("_"),
+    or dollar signs ("$"); the first character must not be a number.  Upper
+    and lower case letters are considered different (names are
+    case-sensitive).  The following strings are reserved keywords and may not
+    be used as identifiers:
+
+        ABS, ADD, ADDRESS, ALIAS, ARL, ATTRIB, DP3, DP4, DPH, DST, END, EX2,
+        EXP, FLR, FRC, LG2, LIT, LOG, MAD, MAX, MIN, MOV, MUL, OPTION, OUTPUT,
+        PARAM, POW, RCP, RSQ, SGE, SLT, SUB, SWZ, TEMP, XPD, program, result,
+        state, and vertex.
+*/
+fp_identifier
+    fp_identifier_ne .error IDENTIFIER_EXPECTED;
+vp_identifier
+    vp_identifier_ne .error IDENTIFIER_EXPECTED;
+fp_identifier_ne
+    fp_not_reserved_identifier .and identifier_ne;
+vp_identifier_ne
+    vp_not_reserved_identifier .and identifier_ne;
+
+fp_not_reserved_identifier
+    fp_not_reserved_identifier_1 .or .true;
+fp_not_reserved_identifier_1
+    fp_reserved_identifier .and .false .error RESERVED_KEYWORD;
+vp_not_reserved_identifier
+    vp_not_reserved_identifier_1 .or .true;
+vp_not_reserved_identifier_1
+    vp_reserved_identifier .and .false .error RESERVED_KEYWORD;
+
+fp_reserved_identifier
+    "ABS" .or "ABS_SAT" .or "ADD" .or "ADD_SAT" .or "ALIAS" .or "ATTRIB" .or "CMP" .or "CMP_SAT" .or
+    "COS" .or "COS_SAT" .or "DP3" .or "DP3_SAT" .or "DP4" .or "DP4_SAT" .or "DPH" .or "DPH_SAT" .or
+    "DST" .or "DST_SAT" .or "END" .or "EX2" .or "EX2_SAT" .or "FLR" .or "FLR_SAT" .or "FRC" .or
+    "FRC_SAT" .or "KIL" .or "LG2" .or "LG2_SAT" .or "LIT" .or "LIT_SAT" .or "LRP" .or "LRP_SAT" .or
+    "MAD" .or "MAD_SAT" .or "MAX" .or "MAX_SAT" .or "MIN" .or "MIN_SAT" .or "MOV" .or "MOV_SAT" .or
+    "MUL" .or "MUL_SAT" .or "OPTION" .or "OUTPUT" .or "PARAM" .or "POW" .or "POW_SAT" .or "RCP" .or
+    "RCP_SAT" .or "RSQ" .or "RSQ_SAT" .or "SIN" .or "SIN_SAT" .or "SCS" .or "SCS_SAT" .or "SGE" .or
+    "SGE_SAT" .or "SLT" .or "SLT_SAT" .or "SUB" .or "SUB_SAT" .or "SWZ" .or "SWZ_SAT" .or "TEMP" .or
+    "TEX" .or "TEX_SAT" .or "TXB" .or "TXB_SAT" .or "TXP" .or "TXP_SAT" .or "XPD" .or "XPD_SAT" .or
+    "fragment" .or "program" .or "result" .or "state" .or "texture";
+vp_reserved_identifier
+    "ABS" .or "ADD" .or "ADDRESS" .or "ALIAS" .or "ARL" .or "ATTRIB" .or "DP3" .or "DP4" .or
+    "DPH" .or "DST" .or "END" .or "EX2" .or "EXP" .or "FLR" .or "FRC" .or "LG2" .or "LIT" .or
+    "LOG" .or "MAD" .or "MAX" .or "MIN" .or "MOV" .or "MUL" .or "OPTION" .or "OUTPUT" .or
+    "PARAM" .or "POW" .or "RCP" .or "RSQ" .or "SGE" .or "SLT" .or "SUB" .or "SWZ" .or "TEMP" .or
+    "XPD" .or "program" .or "result" .or "state" .or "vertex";
+
+/*
+    The <integer> rule matches an integer constant.  The integer consists
+    of a sequence of one or more digits ("0" through "9").
+*/
+integer
+    integer_ne .error INTEGER_EXPECTED;
+
+zero
+    '0';
+
+leading_zeroes
+    .loop zero;
+
+no_digit
+    no_digit_1 .or .true;
+no_digit_1
+    digit10 .and .false .error INTEGER_OUT_OF_RANGE;
+
+all_zeroes
+    all_zeroes_1 .or no_digit_1;
+all_zeroes_1
+    '0' .and .loop zero .and no_digit;
+
+integer_0_3
+    integer_0_3_1 .error INTEGER_EXPECTED .and .true .emit 0x00 .emit $;
+integer_0_3_1
+    integer_0_3_2 .or all_zeroes .emit '0';
+integer_0_3_2       /* [1, 3] */
+    leading_zeroes .and '1'-'3' .emit * .and no_digit;
+
+integer_0_63
+    integer_0_63_1 .error INTEGER_EXPECTED .and .true .emit 0x00 .emit $;
+integer_0_63_1
+    integer_0_63_2 .or integer_0_63_3 .or integer_0_63_4 .or integer_0_63_5 .or
+    all_zeroes .emit '0';
+integer_0_63_2      /* [7, 9] */
+    leading_zeroes .and '7'-'9' .emit * .and no_digit;
+integer_0_63_3      /* [10, 59] */
+    leading_zeroes .and '1'-'5' .emit * .and '0'-'9' .emit * .and no_digit;
+integer_0_63_4      /* [60, 63] */
+    leading_zeroes .and '6' .emit * .and '0'-'3' .emit * .and no_digit;
+integer_0_63_5      /* [1, 6] */
+    leading_zeroes .and '1'-'6' .emit * .and no_digit;
+
+integer_0_64
+    integer_0_64_1 .error INTEGER_EXPECTED .and .true .emit 0x00 .emit $;
+integer_0_64_1
+    integer_0_64_2 .or integer_0_64_3 .or integer_0_64_4 .or integer_0_64_5 .or
+    all_zeroes .emit '0';
+integer_0_64_2      /* [7, 9] */
+    leading_zeroes .and '7'-'9' .emit * .and no_digit;
+integer_0_64_3      /* [10, 59] */
+    leading_zeroes .and '1'-'5' .emit * .and '0'-'9' .emit * .and no_digit;
+integer_0_64_4      /* [60, 64] */
+    leading_zeroes .and '6' .emit * .and '0'-'4' .emit * .and no_digit;
+integer_0_64_5      /* [1, 6] */
+    leading_zeroes .and '1'-'6' .emit * .and no_digit;
+
+optional_space
+    space .or .true;
+
+space_dst
+    space .error OPERATION_NEEDS_DESTINATION_VARIABLE;
+
+space_src
+    space .error OPERATION_NEEDS_SOURCE_VARIABLE;
+
+space
+    single_space .and .loop single_space;
+
+single_space
+    white_char .or comment_block;
+
+white_char
+    ' ' .or '\t' .or '\n' .or '\r';
+
+comment_block
+    '#' .and .loop comment_char .and new_line;
+
+/* All ASCII characters except '\r', '\n' and '\0' */
+comment_char
+    '\x0E'-'\xFF' .or '\x01'-'\x09' .or '\x0B'-'\x0C';
+
+new_line
+    '\n' .or crlf .or '\0';
+
+crlf
+    '\r' .and '\n';
+
+semicolon
+    optional_space .and ';' .error MISSING_SEMICOLON .and optional_space;
+
+comma
+    optional_space .and ',' .error MISSING_COMMA .and optional_space;
+
+comma_ne
+    optional_space .and ',' .and optional_space;
+
+lbracket
+    optional_space .and '[' .error MISSING_LBRACKET .and optional_space;
+
+lbracket_ne
+    optional_space .and '[' .and optional_space;
+
+rbracket
+    optional_space .and ']' .error MISSING_RBRACKET .and optional_space;
+
+dot
+    optional_space .and '.' .error MISSING_DOT .and optional_space;
+
+dot_ne
+    optional_space .and '.' .and optional_space;
+
+equal
+    optional_space .and '=' .error MISSING_EQUAL .and optional_space;
+
+lbrace
+    optional_space .and '{' .error MISSING_LBRACE .and optional_space;
+
+lbrace_ne
+    optional_space .and '{' .and optional_space;
+
+rbrace
+    optional_space .and '}' .error MISSING_RBRACE .and optional_space;
+
+dotdot
+    optional_space .and '.' .and '.' .error MISSING_DOTDOT .and optional_space;
+
+dotdot_ne
+    optional_space .and '.' .and '.' .and optional_space;
+
+/*
+    The definition below accepts the following floating point number formats:
+    .99 .99e99 99. 99.99 99.99e99 99.e99 99e99
+    Also 99 format was considered and accepted because of a large number of existing program
+    strings with such a format.
+*/
+float
+    float_1 .or float_2 .or float_legacy;
+float_1
+    '.' .emit 0x00 .and integer_ne .error MISSING_FRACTION_OR_EXPONENT .and optional_exponent;
+float_2
+    integer_ne .and float_3;
+float_3
+    float_4 .or float_5;
+float_4
+    '.' .and optional_integer .and optional_exponent;
+float_5
+    exponent .emit 0x00;
+float_legacy
+    integer_ne .and .true .emit 0x00 .emit 0x00;
+
+/*
+    Below is a correct version of <float> definiton.
+*/
+/*
+float
+    float_1 .or float_2;
+float_1
+    '.' .emit 0x00 .and integer_ne .error MISSING_FRACTION_OR_EXPONENT .and optional_exponent;
+float_2
+    integer_ne .and float_3 .error MISSING_DOT_OR_EXPONENT;
+float_3
+    float_4 .or float_5;
+float_4
+    '.' .and optional_integer .and optional_exponent;
+float_5
+    exponent .emit 0x00;
+*/
+
+integer_ne
+    integer_ne_1 .and .true .emit 0x00 .emit $;
+integer_ne_1
+    digit10 .emit * .and .loop digit10 .emit *;
+
+optional_integer
+    integer_ne .or .true .emit 0x00;
+
+/*
+NOTE: If exponent part is omited we treat it as if it was "E+1".
+*/
+optional_exponent
+    exponent .or .true .emit 0x00;
+
+exponent
+    exponent_1 .and optional_sign_ne .and integer_ne .error EXPONENT_VALUE_EXPECTED;
+exponent_1
+    'e' .or 'E';
+
+optional_sign_ne
+    minus_ne .or plus_ne .or .true;
+
+plus_ne
+    optional_space .and '+' .and optional_space;
+
+minus_ne
+    optional_space .and '-' .emit '-' .and optional_space;
+
+identifier_ne
+    first_idchar .emit * .and .loop follow_idchar .emit * .and .true .emit 0x00 .emit $;
+
+follow_idchar
+    first_idchar .or digit10;
+
+first_idchar
+    'a'-'z' .or 'A'-'Z' .or '_' .or '$';
+
+digit10
+    '0'-'9';
+
+/*
+    string filtering - if a string is encountered in grammar ("blabla"), the symbol below is
+    executed to create the string. The symbol must not throw any errors and emit bytes - it should
+    stop if it encounters invalid character. After this the resulting string (from starting
+    position up to the invalid character (but without it) is compared with the grammar string.
+*/
+.string __string_filter;
+
+__string_filter
+    .loop __identifier_char;
+
+__identifier_char
+    'a'-'z' .or 'A'-'Z' .or '_' .or '$' .or '0'-'9';
+
+/*
+    error token filtering
+*/
+e_signature
+    e_signature_char .and .loop e_signature_char;
+e_signature_char
+    '!' .or '.' .or 'A'-'Z' .or 'a'-'z' .or '0'-'9';
+
+e_statement
+    .loop e_statement_not_term;
+/* All ASCII characters to one of '\r', '\n', '\0' and ';' */
+e_statement_not_term
+    '\x3C'-'\xFF' .or '\x0E'-'\x3A' .or '\x01'-'\x09' .or '\x0B'-'\x0C';
+
+e_identifier
+    e_identifier_first .and .loop e_identifier_next;
+e_identifier_first
+    'a'-'z' .or 'A'-'Z' .or '_' .or '$';
+e_identifier_next
+    e_identifier_first .or '0'-'9';
+
+e_token
+    e_identifier .or e_token_number .or '[' .or ']' .or '.' .or '{' .or '}' .or '=' .or '+' .or
+    '-' .or ',' .or ';';
+e_token_number
+    e_token_digit .and .loop e_token_digit;
+e_token_digit
+    '0'-'9';
+
+e_charordigit
+    'A'-'Z' .or 'a'-'z' .or '0'-'9';
+
-- 
cgit v1.2.3