diff --git a/src/mesa/main/arbvertparse.c b/src/mesa/main/arbvertparse.c
new file mode 100644
index 0000000..d21358b
--- /dev/null
+++ b/src/mesa/main/arbvertparse.c
@@ -0,0 +1,6629 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  5.1
+ *
+ * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "glheader.h"
+#include "context.h"
+#include "hash.h"
+#include "imports.h"
+#include "macros.h"
+#include "mtypes.h"
+#include "nvprogram.h"
+#include "nvvertparse.h"
+#include "nvvertprog.h"
+
+#include "arbvertparse.h"
+
+/**
+ * Overview:
+ *
+ * This is a simple top-down predictive parser. In a nutshell, there are two key
+ * elements to a predictive parser. First, is the 'look ahead' symbol. This is simply 
+ * the next token in the input stream. The other component is a stack of symbols. 
+ *
+ * Given the grammar, we can derive a look ahead table. This is just a 2D array, 
+ * where one axis is the non-terminal on top of the stack and the other axis is 
+ * the look ahead. Each entry in the array is the production to apply when the pair
+ * of stack symbol & look ahead is encountered. If no production is listed at 
+ * a given entry in the table, a parse error occurs if this combination
+ * is seen.
+ *
+ * Since we want to drive the parsing from a couple of huge tables, we have to
+ * save some information later on for processing (e.g. for code generation).
+ * For this, we explicitly recreate the parse tree representing the derivation. 
+ * We can then make several passes over the parse tree to perform all additional 
+ * processing, and we can be sure the the parse is valid.
+ *   
+ * The stack is initialized by pushing the start symbol onto it. The look ahead
+ * symbol is initially the first token in the program string. 
+ *
+ * If there is a non-terminal symbol on top of the stack, the look ahead table 
+ * is consulted to find if a production exists for the top of the stack
+ * and the look ahead.
+ * 
+ * When we find a matching production, we pop the non-terminal off the top of 
+ * the stack (the LHS of the production), and push the tokens on the RHS of 
+ * the production onto the stack. Note that we store a pointer to the parse_tree_node
+ * containing the LHS token on the stack. This way, we can setup the children in 
+ * the parse tree as we apply the production.
+ *   
+ * If there is a terminal symbol on top of the stack, we compare it with the
+ * look ahead symbol. If they match, or we don't care about the value of the
+ * terminal (e.g. we know its an integer, but don't necessairly care what 
+ * integer), the terminal symbol is popped off the stack and the look ahead 
+ * is advanced.
+ *
+ * There are a few special nasty cases of productions for which we make special 
+ * cases. These aren't found in the production/look-ahead tables, but listed 
+ * out explicitly.
+ * 
+ * After the parse tree has been constructed, we make several recusive passes 
+ * over it to perform various tasks.
+ *  
+ * The first pass is made to clean up the state bindings.  This is done in 
+ * parse_tree_fold_bindings(). The goal is to reduce the big mess of a parse tree
+ * created by strings such as:
+ * 
+ *           result.color.secondary
+ *
+ * and roll them up into one token and fill out some information in a symbol table.
+ * In this case, the token at the root of the derivation becomes BINDING_TOKEN,
+ * and the token attribute is an index into the binding table where this state
+ * is held.
+ *
+ * The next two passes go about associating variables with BINDING_TOKENs. This 
+ * takes care of the cases like:
+ *
+ *           OUTPUT foo = result.color.secondary;
+ *
+ * by inserting the index in the binding table for result.color.secondary into 
+ * the attr field in the identifier table where the 'foo' variable sits. 
+ * The second such pass deals with setting up arrays of program parameters, 
+ * while the first only deals with scalars.
+ * 
+ * We then examine all the information on variables and state that we have 
+ * gathered, and layout which 'register' each variable or bit-of-state should use.
+ *  
+ *
+ * Finally, we make a recursive pass of the parse tree and generate opcodes 
+ * for Mesa to interpret while executing the program.
+ * 
+ * It should be noted that each input/stack token has two parts, an 'identifier' 
+ * and an 'attribute'. The identifier tells what class the token is, e.g. INTEGER_TOKEN,
+ * or NT_PROGRAM_SINGLE_ITEM_TOKEN. For some tokens, e.g. INTEGER_TOKEN, ID_TOKEN,
+ * FLOAT_TOKEN, or BINDING_TOKEN, the attribute for the token is an index into a table
+ * giving various properties about the token.
+ * 
+ */
+
+/**
+ * Here are all of the structs used to hold parse state and symbol
+ * tables used.
+ *
+ * All strings which are not reserved words, floats, ints, or misc
+ * puncuation (ie .) are considered to be [potential] identifiers.
+ * When we encounter such a string while lex'ing, insert it into 
+ * the id symbol table, shown below. 
+ *
+ * Sometime later, we'll initialize the variable types for identifiers
+ * which really are variables. This gets shoved into the 'type' field.
+ *
+ * For variables, we'll need additional info (e.g. state it is bound to,
+ * variable we're aliased to, etc). This is stored in the 'attr' field.
+ * 	- For alias variables, the attr is the idx in the id table of
+ * 	   the variable we are bound to.
+ * 	- For other variables, we need a whole mess of info. This can be 
+ * 	   found in the binding symbol table, below. In this case, the
+ * 	   attr field is the idx into the binding table that describes us.
+ * 	- For uninitialized ids, attr is -1.
+ *
+ * The data field holds the string of the id.
+ *
+ * len is the number of identifiers in the table.
+ */
+typedef struct st_id_table
+{
+   GLint len;
+   GLint *type;
+   GLint *attr;
+   GLubyte **data;
+}
+id_table;
+
+/**
+ * For PARAM arrays, we need to record the contents for use when
+ * laying out registers and loading state. 
+ *
+ * len is the number of arrays in the table.
+ *
+ * num_elements[i] is the number of items in array i. In other words, this
+ * is the number of registers it would require when allocating.
+ *
+ * data[i][n] is the state bound to element n in array i. It is an idx into
+ * the binding table
+ */
+typedef struct st_array_table
+{
+   GLint len;
+   GLint *num_elements;
+   GLint **data;
+}
+array_table;
+
+/**
+ * For holding all of the data used to describe an identifier, we have the catch
+ * all binding symbol table.
+ *
+ * len is the number of bound items;
+ *
+ * type[i] tells what we are binding too, e.g. ATTRIB_POSITION, FOG_COLOR, or CONSTANT
+ *
+ * offset[i] gives the matrix number for matrix bindings, e.g. MATRIXROWS_MODELVIEW.
+ * Alternativly, it gives the number of the first parameter for PROGRAM_ENV_* and 
+ * PROGRAM_LOCAL_*.
+ *
+ * num_rows[i] gives the number of rows for multiple matrix rows, or the number 
+ * of parameters in a env/local array.
+ *
+ * consts gives the 4-GLfloat constant value for bindings of type CONSTANT
+ *
+ * reg_num gives the register number which this binding is held in.
+ */
+typedef struct st_binding_table
+{
+   GLint len;
+   GLint *type;
+   GLint *offset;
+   GLint *row;
+   GLint *num_rows;
+   GLfloat **consts;
+   GLint *reg_num;
+}
+binding_table;
+
+/**
+ * Integers and floats are stored here. 
+ */
+typedef struct st_int_table
+{
+   GLint len;
+   GLint *data;
+}
+int_table;
+
+typedef struct st_float_table
+{
+   GLint len;
+   GLdouble *data;
+}
+float_table;
+
+/**
+ * To avoid writing tons of mindless parser code, the parsing is driven by
+ * a few big tables of rules, plus a few special cases. However, this means
+ * that we have to do all of our analysis outside of the parsing step.
+ *
+ * So, the parser will contruct a parse tree describing the program string
+ * which we can then operate on to do things like code generation.
+ *
+ * This struct represents a node in the parse tree.
+ *
+ * If tok is a non-terminal token, tok_attr is not relevant.
+ * If tok is BINDING_TOKEN, tok_attr is the index into the binding table.
+ * if tok is INTEGER_TOKEN or FLOAT_TOKEN, tok_attr is the index in the integer/GLfloat table
+ *
+ * prod_applied is the production number applied to this token in the derivation of
+ * the program string. See arbvp_grammar.txt for a listing of the productions, and
+ * their numbers.
+ */
+typedef struct st_parse_tree_node
+{
+   GLint tok, tok_attr, is_terminal;
+   GLint prod_applied;
+   struct st_parse_tree_node *children[4];
+}
+parse_tree_node;
+
+/** This stores tokens that we lex out 
+ */
+typedef struct st_token_list
+{
+   GLint tok, tok_attr;
+   parse_tree_node *pt;
+
+   struct st_token_list *next;
+}
+token_list;
+
+/**
+ * This holds all of the productions in the grammar. 
+ *
+ * lhs is a non-terminal token, e.g. NT_PROGRAM_TOKEN.
+ * rhs is either NULL_TOKEN, another non-terminal token, or a terminal token.
+ * 	In some cases, we need the RHS to be a certain value, e.g. for the dst reg write masks.
+ * 	For this, key is used to specify the string. If we don't care about the key, just
+ * 	specify "".
+ * 	Int/floats are slightly different, "-1" specifies 'we don't care'.
+ *
+ * lhs is not very useful here, but is is convient for sanity sake when specifing productions.
+ */
+typedef struct st_prod_table
+{
+   GLint lhs;
+   GLint rhs[4];
+   GLubyte *key[4];
+}
+prod_table;
+
+/**
+ * This holds the look ahead table to drive the parser. We examine the token on 
+ * the top of the stack, as well as the next token in the input stream (the look ahead).
+ * We then match this against the table, and apply the approprate production. If nothing
+ * matches, we have a parse error.
+ *
+ * Here, LHS is the (non-terminal) token to match against the top of the stack.
+ *
+ * la is the token to match against the look ahead.
+ *
+ * If la is ID_TOKEN, we have to match a given keyword (e.g. 'ambient'). This is specified in 
+ * la_kw.
+ *
+ * prod_idx is the idx into the prod_table of the production that we are to apply if this
+ * rule matches.
+ */
+typedef struct st_look_ahead_table
+{
+   GLint lhs;
+   GLint la;
+   GLubyte *la_kw;
+   GLint prod_idx;
+}
+look_ahead_table;
+
+/**
+ * This is the general catch-all for the parse state 
+ */
+typedef struct st_parse_state
+{
+   GLubyte *str;
+   GLint len;
+
+   /* lex stuff ------ */
+   GLint start_pos, curr_pos;
+   GLint curr_state;
+   /* ---------------- */
+
+   id_table idents;
+   int_table ints;
+   float_table floats;
+   binding_table binds;
+   array_table arrays;
+
+   token_list *stack_head, *stack_free_list;
+
+   parse_tree_node *pt_head;
+}
+parse_state;
+
+/* local prototypes */
+static GLint float_table_add(float_table * tab, GLubyte * str, GLint start,
+			     GLint end);
+static GLint int_table_add(int_table * tab, GLubyte * str, GLint start,
+			   GLint end);
+static GLint id_table_add(id_table * tab, GLubyte * str, GLint start,
+			  GLint end);
+static void parse_tree_free_children(parse_tree_node * ptn);
+
+/** 
+ * Here we have a ton of defined terms that we use to identify productions, 
+ * terminals, and nonterminals.
+ */
+
+/**
+ * Terminal tokens
+ */
+#define EOF_TOKEN 		0
+#define ID_TOKEN			1
+#define ABS_TOKEN			2
+#define ADD_TOKEN			3
+#define ADDRESS_TOKEN	4
+#define ALIAS_TOKEN		5
+#define ARL_TOKEN			6
+#define ATTRIB_TOKEN		7
+
+#define DP3_TOKEN			8
+#define DP4_TOKEN			9
+#define DPH_TOKEN			10
+#define DST_TOKEN			11
+
+#define END_TOKEN			12
+#define EX2_TOKEN			13
+#define EXP_TOKEN			14
+
+#define FLR_TOKEN			15
+#define FRC_TOKEN			16
+
+#define LG2_TOKEN			17
+#define LIT_TOKEN			18
+#define LOG_TOKEN			19
+
+#define MAD_TOKEN			20
+#define MAX_TOKEN			21
+#define MIN_TOKEN			22
+#define MOV_TOKEN			23
+#define MUL_TOKEN			24
+
+#define OPTION_TOKEN    25
+#define OUTPUT_TOKEN		26
+
+#define PARAM_TOKEN		27
+#define POW_TOKEN			28
+
+#define RCP_TOKEN			29
+#define RSQ_TOKEN			30
+
+#define SGE_TOKEN			31
+#define SLT_TOKEN			32
+#define SUB_TOKEN			33
+#define SWZ_TOKEN			34
+
+#define TEMP_TOKEN		35
+
+#define XPD_TOKEN			36
+
+#define SEMICOLON_TOKEN	37
+#define COMMA_TOKEN		38
+#define PLUS_TOKEN		39
+#define MINUS_TOKEN		40
+#define PERIOD_TOKEN		41
+#define DOTDOT_TOKEN		42
+#define LBRACKET_TOKEN	43
+#define RBRACKET_TOKEN	44
+#define LBRACE_TOKEN		45
+#define RBRACE_TOKEN		46
+#define EQUAL_TOKEN		47
+
+#define INTEGER_TOKEN	48
+#define FLOAT_TOKEN		49
+
+#define PROGRAM_TOKEN	50
+#define RESULT_TOKEN		51
+#define STATE_TOKEN		52
+#define VERTEX_TOKEN		53
+
+#define NULL_TOKEN		54
+
+#define BINDING_TOKEN	55
+
+/** 
+ * Non-terminal tokens
+ */
+#define NT_PROGRAM_TOKEN					100
+#define NT_OPTION_SEQUENCE_TOKEN			101
+#define NT_OPTION_SEQUENCE2_TOKEN		102
+#define NT_OPTION_TOKEN						103
+#define NT_STATEMENT_SEQUENCE_TOKEN		104
+#define NT_STATEMENT_SEQUENCE2_TOKEN	105
+#define NT_STATEMENT_TOKEN					106
+
+#define NT_INSTRUCTION_TOKEN				107
+#define NT_ARL_INSTRUCTION_TOKEN			108
+#define NT_VECTOROP_INSTRUCTION_TOKEN	109
+#define NT_VECTOROP_TOKEN					110
+#define NT_SCALAROP_INSTRUCTION_TOKEN	111
+#define NT_SCALAROP_TOKEN					112
+#define NT_BINSCOP_INSTRUCTION_TOKEN	113
+#define NT_BINSCOP_INSTRUCTION2_TOKEN	114
+#define NT_BINSCOP_TOKEN					115
+#define NT_BINOP_INSTRUCTION_TOKEN		116
+#define NT_BINOP_INSTRUCTION2_TOKEN		117
+#define NT_BINOP_TOKEN						118
+#define NT_TRIOP_INSTRUCTION_TOKEN		119
+#define NT_TRIOP_INSTRUCTION2_TOKEN		120
+#define NT_TRIOP_INSTRUCTION3_TOKEN		121
+#define NT_TRIOP_TOKEN						122
+#define NT_SWZ_INSTRUCTION_TOKEN			123
+#define NT_SWZ_INSTRUCTION2_TOKEN		124
+
+#define NT_SCALAR_SRC_REG_TOKEN			130
+#define NT_SWIZZLE_SRC_REG_TOKEN			131
+#define NT_MASKED_DST_REG_TOKEN			132
+#define NT_MASKED_ADDR_REG_TOKEN			133
+#define NT_EXTENDED_SWIZZLE_TOKEN		134
+#define NT_EXTENDED_SWIZZLE2_TOKEN		135
+#define NT_EXT_SWIZ_COMP_TOKEN			136
+#define NT_EXT_SWIZ_SEL_TOKEN				137
+#define NT_SRC_REG_TOKEN					138
+#define NT_DST_REG_TOKEN					139
+#define NT_VERTEX_ATTRIB_REG_TOKEN		140
+
+#define NT_TEMPORARY_REG_TOKEN 			150
+#define NT_PROG_PARAM_REG_TOKEN			151
+#define NT_PROG_PARAM_SINGLE_TOKEN		152
+#define NT_PROG_PARAM_ARRAY_TOKEN		153
+#define NT_PROG_PARAM_ARRAY_MEM_TOKEN	154
+#define NT_PROG_PARAM_ARRAY_ABS_TOKEN	155
+#define NT_PROG_PARAM_ARRAY_REL_TOKEN	156
+
+#define NT_ADDR_REG_REL_OFFSET_TOKEN	157
+#define NT_ADDR_REG_POS_OFFSET_TOKEN	158
+#define NT_ADDR_REG_NEG_OFFSET_TOKEN	159
+
+#define NT_VERTEX_RESULT_REG_TOKEN		160
+#define NT_ADDR_REG_TOKEN					161
+#define NT_ADDR_COMPONENT_TOKEN			162
+#define NT_ADDR_WRITE_MASK_TOKEN			163
+#define NT_SCALAR_SUFFIX_TOKEN			164
+#define NT_SWIZZLE_SUFFIX_TOKEN			165
+
+#define NT_COMPONENT_TOKEN					166
+#define NT_OPTIONAL_MASK_TOKEN			167
+#define NT_OPTIONAL_MASK2_TOKEN			168
+#define NT_NAMING_STATEMENT_TOKEN		169
+
+#define NT_ATTRIB_STATEMENT_TOKEN		170
+#define NT_VTX_ATTRIB_BINDING_TOKEN		171
+#define NT_VTX_ATTRIB_ITEM_TOKEN			172
+#define NT_VTX_ATTRIB_NUM_TOKEN			173
+#define NT_VTX_OPT_WEIGHT_NUM_TOKEN		174
+#define NT_VTX_WEIGHT_NUM_TOKEN			175
+#define NT_PARAM_STATEMENT_TOKEN			176
+#define NT_PARAM_STATEMENT2_TOKEN		177
+#define NT_OPT_ARRAY_SIZE_TOKEN			178
+#define NT_PARAM_SINGLE_INIT_TOKEN		179
+#define NT_PARAM_MULTIPLE_INIT_TOKEN	180
+#define NT_PARAM_MULT_INIT_LIST_TOKEN	181
+#define NT_PARAM_MULT_INIT_LIST2_TOKEN	182
+#define NT_PARAM_SINGLE_ITEM_DECL_TOKEN 183
+#define NT_PARAM_SINGLE_ITEM_USE_TOKEN	184
+#define NT_PARAM_MULTIPLE_ITEM_TOKEN	185
+#define NT_STATE_MULTIPLE_ITEM_TOKEN	186
+#define NT_STATE_MULTIPLE_ITEM2_TOKEN	187
+#define NT_FOO_TOKEN							188
+#define NT_FOO2_TOKEN						189
+#define NT_FOO3_TOKEN						190
+#define NT_FOO35_TOKEN						191
+#define NT_FOO4_TOKEN						192
+#define NT_STATE_SINGLE_ITEM_TOKEN		193
+#define NT_STATE_SINGLE_ITEM2_TOKEN		194
+#define NT_STATE_MATERIAL_ITEM_TOKEN	195
+#define NT_STATE_MATERIAL_ITEM2_TOKEN	196
+#define NT_STATE_MAT_PROPERTY_TOKEN		197
+#define NT_STATE_LIGHT_ITEM_TOKEN		198
+#define NT_STATE_LIGHT_ITEM2_TOKEN		199
+#define NT_STATE_LIGHT_PROPERTY_TOKEN	200
+#define NT_STATE_SPOT_PROPERTY_TOKEN	201
+#define NT_STATE_LIGHT_MODEL_ITEM_TOKEN 202
+#define NT_STATE_LMOD_PROPERTY_TOKEN	 203
+#define NT_STATE_LMOD_PROPERTY2_TOKEN	 204
+
+#define NT_STATE_LIGHT_PROD_ITEM_TOKEN	   207
+#define NT_STATE_LIGHT_PROD_ITEM15_TOKEN	208
+#define NT_STATE_LIGHT_PROD_ITEM2_TOKEN	209
+#define NT_STATE_LPROD_PROPERTY_TOKEN	210
+#define NT_STATE_LIGHT_NUMBER_TOKEN		211
+#define NT_STATE_TEX_GEN_ITEM_TOKEN		212
+#define NT_STATE_TEX_GEN_ITEM2_TOKEN	213
+#define NT_STATE_TEX_GEN_TYPE_TOKEN		214
+#define NT_STATE_TEX_GEN_COORD_TOKEN	215
+#define NT_STATE_FOG_ITEM_TOKEN			216
+#define NT_STATE_FOG_PROPERTY_TOKEN		217
+
+#define NT_STATE_CLIP_PLANE_ITEM_TOKEN	218
+#define NT_STATE_CLIP_PLANE_ITEM2_TOKEN	219
+#define NT_STATE_CLIP_PLANE_NUM_TOKEN	220
+#define NT_STATE_POINT_ITEM_TOKEN		221
+#define NT_STATE_POINT_PROPERTY_TOKEN	222
+#define NT_STATE_MATRIX_ROW_TOKEN		223
+#define NT_STATE_MATRIX_ROW15_TOKEN		224
+#define NT_STATE_MATRIX_ROW2_TOKEN		225
+#define NT_STATE_MATRIX_ROW3_TOKEN		226
+#define NT_STATE_MAT_MODIFIER_TOKEN		227
+#define NT_STATE_MATRIX_ROW_NUM_TOKEN	228
+#define NT_STATE_MATRIX_NAME_TOKEN		229
+#define NT_STATE_OPT_MOD_MAT_NUM_TOKEN	230
+#define NT_STATE_MOD_MAT_NUM_TOKEN		231
+#define NT_STATE_PALETTE_MAT_NUM_TOKEN	232
+#define NT_STATE_PROGRAM_MAT_NUM_TOKEN	233
+
+#define NT_PROGRAM_SINGLE_ITEM_TOKEN	234
+#define NT_PROGRAM_SINGLE_ITEM2_TOKEN	235
+#define NT_PROGRAM_MULTIPLE_ITEM_TOKEN	236
+#define NT_PROGRAM_MULTIPLE_ITEM2_TOKEN	237
+#define NT_PROG_ENV_PARAMS_TOKEN			238
+#define NT_PROG_ENV_PARAM_NUMS_TOKEN	239
+#define NT_PROG_ENV_PARAM_NUMS2_TOKEN	240
+#define NT_PROG_ENV_PARAM_TOKEN			250
+#define NT_PROG_LOCAL_PARAMS_TOKEN		251
+#define NT_PROG_LOCAL_PARAM_NUMS_TOKEN	252
+#define NT_PROG_LOCAL_PARAM_NUMS2_TOKEN	253
+#define NT_PROG_LOCAL_PARAM_TOKEN		254
+#define NT_PROG_ENV_PARAM_NUM_TOKEN		255
+#define NT_PROG_LOCAL_PARAM_NUM_TOKEN	256
+
+#define NT_PARAM_CONST_DECL_TOKEN		257
+#define NT_PARAM_CONST_USE_TOKEN			258
+#define NT_PARAM_CONST_SCALAR_DECL_TOKEN	259
+#define NT_PARAM_CONST_SCALAR_USE_TOKEN	260
+#define NT_PARAM_CONST_VECTOR_TOKEN		261
+#define NT_PARAM_CONST_VECTOR2_TOKEN	262
+#define NT_PARAM_CONST_VECTOR3_TOKEN	263
+#define NT_PARAM_CONST_VECTOR4_TOKEN	264
+
+#define NT_SIGNED_FLOAT_CONSTANT_TOKEN	265
+#define NT_FLOAT_CONSTANT_TOKEN			266
+#define NT_OPTIONAL_SIGN_TOKEN			267
+
+#define NT_TEMP_STATEMENT_TOKEN			268
+#define NT_ADDRESS_STATEMENT_TOKEN		269
+#define NT_VAR_NAME_LIST_TOKEN			270
+#define NT_OUTPUT_STATEMENT_TOKEN		271
+#define NT_RESULT_BINDING_TOKEN			272
+#define NT_RESULT_BINDING2_TOKEN			273
+#define NT_RESULT_COL_BINDING_TOKEN		274
+#define NT_RESULT_COL_BINDING2_TOKEN	275
+#define NT_RESULT_COL_BINDING3_TOKEN	276
+#define NT_RESULT_COL_BINDING4_TOKEN	277
+#define NT_RESULT_COL_BINDING5_TOKEN	278
+
+#define NT_OPT_FACE_TYPE2_TOKEN			279
+#define NT_OPT_COLOR_TYPE_TOKEN			280
+#define NT_OPT_COLOR_TYPE2_TOKEN			281
+#define NT_OPT_TEX_COORD_NUM_TOKEN		282
+#define NT_TEX_COORD_NUM_TOKEN			283
+
+#define NT_ALIAS_STATEMENT_TOKEN			284
+#define NT_ESTABLISH_NAME_TOKEN			285
+#define NT_ESTABLISHED_NAME_TOKEN		286
+
+#define NT_SWIZZLE_SUFFIX2_TOKEN			287
+#define NT_COMPONENT4_TOKEN				288
+
+/**
+ * FSA States for lex
+ *
+ * XXX: These can be turned into enums 
+ */
+#define STATE_BASE		0
+#define STATE_IDENT		1
+
+#define STATE_A			2
+#define STATE_AB			3
+#define STATE_ABS			4
+#define STATE_AD			5
+#define STATE_ADD			6
+#define STATE_ADDR		7
+#define STATE_ADDRE		8
+#define STATE_ADDRES		9
+#define STATE_ADDRESS	10
+#define STATE_AL			11
+#define STATE_ALI			12
+#define STATE_ALIA		13
+#define STATE_ALIAS		14
+#define STATE_AR			15
+#define STATE_ARL			16
+#define STATE_AT			17
+#define STATE_ATT			18
+#define STATE_ATTR		19
+#define STATE_ATTRI		20
+#define STATE_ATTRIB		21
+
+#define STATE_D			22
+#define STATE_DP			23
+#define STATE_DP3			24
+#define STATE_DP4			25
+#define STATE_DPH			26
+#define STATE_DS			27
+#define STATE_DST			28
+
+#define STATE_E			29
+#define STATE_EN			30
+#define STATE_END			31
+#define STATE_EX			32
+#define STATE_EX2			33
+#define STATE_EXP			34
+
+#define STATE_F			35
+#define STATE_FL			36
+#define STATE_FLR			37
+#define STATE_FR			38
+#define STATE_FRC			39
+
+#define STATE_L			40
+#define STATE_LG			41
+#define STATE_LG2			42
+#define STATE_LI			43
+#define STATE_LIT			44
+#define STATE_LO			45
+#define STATE_LOG			46
+
+#define STATE_M			47
+#define STATE_MA			48
+#define STATE_MAD			49
+#define STATE_MAX			50
+#define STATE_MI			51
+#define STATE_MIN			52
+#define STATE_MO			53
+#define STATE_MOV			54
+#define STATE_MU			55
+#define STATE_MUL			56
+
+#define STATE_O			57
+#define STATE_OP			58
+#define STATE_OPT			59
+#define STATE_OPTI		60
+#define STATE_OPTIO		61
+#define STATE_OPTION		62
+#define STATE_OU			63
+#define STATE_OUT			64
+#define STATE_OUTP		65
+#define STATE_OUTPU		66
+#define STATE_OUTPUT		67
+
+#define STATE_P			68
+#define STATE_PA			69
+#define STATE_PAR			70
+#define STATE_PARA		71
+#define STATE_PARAM		72
+#define STATE_PO			73
+#define STATE_POW			74
+
+#define STATE_R			75
+#define STATE_RC			76
+#define STATE_RCP			77
+#define STATE_RS			78
+#define STATE_RSQ			79
+
+#define STATE_S			80
+#define STATE_SG			81
+#define STATE_SGE			82
+#define STATE_SL			83
+#define STATE_SLT			84
+#define STATE_SU			85
+#define STATE_SUB			86
+#define STATE_SW			87
+#define STATE_SWZ			88
+
+#define STATE_T			89
+#define STATE_TE			90
+#define STATE_TEM			91
+#define STATE_TEMP		92
+
+#define STATE_X			93
+#define STATE_XP			94
+#define STATE_XPD			95
+
+#define STATE_N1			96
+#define STATE_N2			97
+#define STATE_N3			98
+#define STATE_N4			99
+#define STATE_N5			100
+#define STATE_N6			101
+#define STATE_N7			102
+
+#define STATE_COMMENT	103
+
+/* LC == lower case, as in 'program' */
+#define STATE_LC_P		104
+#define STATE_LC_PR		105
+#define STATE_LC_PRO		106
+#define STATE_LC_PROG	107
+#define STATE_LC_PROGR	108
+#define STATE_LC_PROGRA	109
+
+#define STATE_LC_R		110
+#define STATE_LC_RE		111
+#define STATE_LC_RES		112
+#define STATE_LC_RESU	113
+#define STATE_LC_RESUL	114
+#define STATE_LC_RESULT	115
+
+#define STATE_LC_S		116
+#define STATE_LC_ST		117
+#define STATE_LC_STA		118
+#define STATE_LC_STAT	119
+#define STATE_LC_STATE	120
+
+#define STATE_LC_V			121
+#define STATE_LC_VE			122
+#define STATE_LC_VER			123
+#define STATE_LC_VERT		124
+#define STATE_LC_VERTE		125
+#define STATE_LC_VERTEX		126
+#define STATE_LC_PROGRAM	127
+
+/**
+ * Error codes 
+ */
+#define ARB_VP_ERROR			-1
+#define ARB_VP_SUCESS		 0
+
+/** 
+ * Variable types 
+ */
+#define TYPE_NONE				0
+#define TYPE_ATTRIB			1
+#define TYPE_PARAM			2
+#define TYPE_PARAM_SINGLE	3
+#define TYPE_PARAM_ARRAY	4
+#define TYPE_TEMP				5
+#define TYPE_ADDRESS			6
+#define TYPE_OUTPUT			7
+#define TYPE_ALIAS			8
+
+/** 
+ * Vertex Attrib Bindings
+ */
+#define ATTRIB_POSITION				1
+#define ATTRIB_WEIGHT				2
+#define ATTRIB_NORMAL				3
+#define ATTRIB_COLOR_PRIMARY		4
+#define ATTRIB_COLOR_SECONDARY	5
+#define ATTRIB_FOGCOORD				6
+#define ATTRIB_TEXCOORD				7
+#define ATTRIB_MATRIXINDEX			8
+#define ATTRIB_ATTRIB				9
+
+/** 
+ * Result Bindings
+ */
+#define RESULT_POSITION						10
+#define RESULT_FOGCOORD						11
+#define RESULT_POINTSIZE					12
+#define RESULT_COLOR_FRONT_PRIMARY		13
+#define RESULT_COLOR_FRONT_SECONDARY	14
+#define RESULT_COLOR_BACK_PRIMARY		15
+#define RESULT_COLOR_BACK_SECONDARY		16
+#define RESULT_TEXCOORD						17
+
+/** 
+ * Material Property Bindings
+ */
+#define MATERIAL_FRONT_AMBIENT			18
+#define MATERIAL_FRONT_DIFFUSE			19
+#define MATERIAL_FRONT_SPECULAR			20
+#define MATERIAL_FRONT_EMISSION			21
+#define MATERIAL_FRONT_SHININESS			22
+#define MATERIAL_BACK_AMBIENT				23
+#define MATERIAL_BACK_DIFFUSE				24
+#define MATERIAL_BACK_SPECULAR			25
+#define MATERIAL_BACK_EMISSION			26
+#define MATERIAL_BACK_SHININESS			27
+
+/** 
+ * Light Property Bindings
+ */
+#define LIGHT_AMBIENT						28
+#define LIGHT_DIFFUSE						29
+#define LIGHT_SPECULAR						30
+#define LIGHT_POSITION						31
+#define LIGHT_ATTENUATION					32
+#define LIGHT_SPOT_DIRECTION				33
+#define LIGHT_HALF							34
+#define LIGHTMODEL_AMBIENT					35
+#define LIGHTMODEL_FRONT_SCENECOLOR		36
+#define LIGHTMODEL_BACK_SCENECOLOR		37
+#define LIGHTPROD_FRONT_AMBIENT			38
+#define LIGHTPROD_FRONT_DIFFUSE			39
+#define LIGHTPROD_FRONT_SPECULAR			40
+#define LIGHTPROD_BACK_AMBIENT			41
+#define LIGHTPROD_BACK_DIFFUSE			42
+#define LIGHTPROD_BACK_SPECULAR			43
+
+/**
+ * Texgen Property Bindings
+ */
+#define TEXGEN_EYE_S							44
+#define TEXGEN_EYE_T							45
+#define TEXGEN_EYE_R							46
+#define TEXGEN_EYE_Q							47
+#define TEXGEN_OBJECT_S						48
+#define TEXGEN_OBJECT_T						49
+#define TEXGEN_OBJECT_R						50
+#define TEXGEN_OBJECT_Q						51
+
+/**
+ * Fog Property Bindings
+ */
+#define FOG_COLOR								52
+#define FOG_PARAMS							53
+
+/** 
+ * Clip Property Bindings
+ */
+#define CLIP_PLANE							54
+
+/** 
+ * Point Property Bindings
+ */
+#define POINT_SIZE							55
+#define POINT_ATTENUATION					56
+
+/**
+ * Matrix Row Property Bindings
+ */
+#define MATRIXROW_MODELVIEW					57
+#define MATRIXROW_MODELVIEW_INVERSE			58
+#define MATRIXROW_MODELVIEW_INVTRANS		59
+#define MATRIXROW_MODELVIEW_TRANSPOSE		60
+#define MATRIXROW_PROJECTION					61
+#define MATRIXROW_PROJECTION_INVERSE		62
+#define MATRIXROW_PROJECTION_INVTRANS		63
+#define MATRIXROW_PROJECTION_TRANSPOSE		64
+#define MATRIXROW_MVP							65
+#define MATRIXROW_MVP_INVERSE					66
+#define MATRIXROW_MVP_INVTRANS				67
+#define MATRIXROW_MVP_TRANSPOSE				68
+#define MATRIXROW_TEXTURE						69
+#define MATRIXROW_TEXTURE_INVERSE			70
+#define MATRIXROW_TEXTURE_INVTRANS			71
+#define MATRIXROW_TEXTURE_TRANSPOSE			72
+#define MATRIXROW_PALETTE						73
+#define MATRIXROW_PALETTE_INVERSE			74
+#define MATRIXROW_PALETTE_INVTRANS			75
+#define MATRIXROW_PALETTE_TRANSPOSE			76
+#define MATRIXROW_PROGRAM						77
+#define MATRIXROW_PROGRAM_INVERSE			78
+#define MATRIXROW_PROGRAM_INVTRANS			79
+#define MATRIXROW_PROGRAM_TRANSPOSE			80
+
+#define MATRIXROWS_MODELVIEW					81
+#define MATRIXROWS_MODELVIEW_INVERSE		82
+#define MATRIXROWS_MODELVIEW_INVTRANS		83
+#define MATRIXROWS_MODELVIEW_TRANSPOSE		84
+#define MATRIXROWS_PROJECTION					85
+#define MATRIXROWS_PROJECTION_INVERSE		86
+#define MATRIXROWS_PROJECTION_INVTRANS		87
+#define MATRIXROWS_PROJECTION_TRANSPOSE	88
+#define MATRIXROWS_MVP							89
+#define MATRIXROWS_MVP_INVERSE				90
+#define MATRIXROWS_MVP_INVTRANS				91
+#define MATRIXROWS_MVP_TRANSPOSE				92
+#define MATRIXROWS_TEXTURE						93
+#define MATRIXROWS_TEXTURE_INVERSE			94
+#define MATRIXROWS_TEXTURE_INVTRANS			95
+#define MATRIXROWS_TEXTURE_TRANSPOSE		96
+#define MATRIXROWS_PALETTE						97
+#define MATRIXROWS_PALETTE_INVERSE			98
+#define MATRIXROWS_PALETTE_INVTRANS			99
+#define MATRIXROWS_PALETTE_TRANSPOSE		100
+#define MATRIXROWS_PROGRAM						101
+#define MATRIXROWS_PROGRAM_INVERSE			102
+#define MATRIXROWS_PROGRAM_INVTRANS			103
+#define MATRIXROWS_PROGRAM_TRANSPOSE		104
+
+#define PROGRAM_ENV_SINGLE					105
+#define PROGRAM_LOCAL_SINGLE				106
+#define PROGRAM_ENV_MULTI					107
+#define PROGRAM_LOCAL_MULTI				108
+
+#define CONSTANT								109
+
+
+
+
+#define IS_WHITESPACE(c)	(c == ' ') || (c == '\t') || (c == '\n')
+#define IS_IDCHAR(c)			((c >= 'A') && (c <= 'Z')) || \
+									((c >= 'a') && (c <= 'z')) || \
+									(c == '_') || (c == '$')
+#define IS_DIGIT(c)			(c >= '0') && (c <= '9')
+#define IS_CD(c)				(IS_DIGIT(c)) || (IS_IDCHAR(c))
+
+#define ADV_TO_STATE(state) s->curr_state = state; s->curr_pos++;
+
+#define ADV_OR_FALLBACK(c, state) if (curr == c) { \
+                                     ADV_TO_STATE(state); \
+                                  } else {\
+                                     if (IS_CD(curr)) { \
+                                        ADV_TO_STATE(STATE_IDENT); \
+                                     } else \
+                                        s->curr_state = 1;\
+                                  }
+
+#define FINISH(tok) *token = tok; s->start_pos = s->curr_pos; s->curr_state = STATE_BASE; return ARB_VP_SUCESS;
+#define ADV_AND_FINISH(tok) *token = tok; s->start_pos = s->curr_pos+1; s->curr_pos++; \
+															s->curr_state = STATE_BASE; return ARB_VP_SUCESS;
+
+#define FINISH_OR_FALLBACK(tok) if (IS_CD(curr)) {\
+                                   ADV_TO_STATE(STATE_IDENT); \
+                                } else { \
+                                   FINISH(tok)\
+                                }
+
+#define NO_KW {"", "", "", ""}
+#define NULL2 NULL_TOKEN, NULL_TOKEN
+#define NULL3 NULL_TOKEN, NULL2
+#define NULL4 NULL2, NULL2
+
+/* This uglyness is the production table. See the prod_table struct definition for a description */
+prod_table ptab[] = {
+   {NT_PROGRAM_TOKEN,
+        {NT_OPTION_SEQUENCE_TOKEN, NT_STATEMENT_SEQUENCE_TOKEN, END_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_OPTION_SEQUENCE_TOKEN,  {NT_OPTION_SEQUENCE2_TOKEN, NULL3},                      NO_KW},
+   {NT_OPTION_SEQUENCE2_TOKEN, {NT_OPTION_TOKEN, NT_OPTION_SEQUENCE2_TOKEN, NULL2},     NO_KW},
+   {NT_OPTION_SEQUENCE2_TOKEN, {NULL4},                                                 NO_KW},
+   {NT_OPTION_TOKEN,           {OPTION_TOKEN, ID_TOKEN, SEMICOLON_TOKEN, NULL_TOKEN},   NO_KW},
+    
+
+   /* 5: */
+   {NT_STATEMENT_SEQUENCE_TOKEN,  {NT_STATEMENT_SEQUENCE2_TOKEN, NULL3},                     NO_KW},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, {NT_STATEMENT_TOKEN, NT_STATEMENT_SEQUENCE2_TOKEN, NULL2}, NO_KW},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, {NULL4},                                                   NO_KW},
+   {NT_STATEMENT_TOKEN, {NT_INSTRUCTION_TOKEN, SEMICOLON_TOKEN, NULL2},                      NO_KW},
+   {NT_STATEMENT_TOKEN, {NT_NAMING_STATEMENT_TOKEN, SEMICOLON_TOKEN, NULL2},                 NO_KW},
+
+   /* 10: */
+   {NT_INSTRUCTION_TOKEN, {NT_ARL_INSTRUCTION_TOKEN, NULL3},      NO_KW},
+   {NT_INSTRUCTION_TOKEN, {NT_VECTOROP_INSTRUCTION_TOKEN, NULL3}, NO_KW},
+   {NT_INSTRUCTION_TOKEN, {NT_SCALAROP_INSTRUCTION_TOKEN, NULL3}, NO_KW},
+   {NT_INSTRUCTION_TOKEN, {NT_BINSCOP_INSTRUCTION_TOKEN, NULL3},  NO_KW},
+   {NT_INSTRUCTION_TOKEN, {NT_BINOP_INSTRUCTION_TOKEN, NULL3},    NO_KW},
+
+   /* 15: */
+   {NT_INSTRUCTION_TOKEN,          {NT_TRIOP_INSTRUCTION_TOKEN, NULL3},      NO_KW},
+   {NT_INSTRUCTION_TOKEN,          {NT_SWZ_INSTRUCTION_TOKEN, NULL3},        NO_KW},
+   {NT_ARL_INSTRUCTION_TOKEN,      {ARL_TOKEN, NT_MASKED_ADDR_REG_TOKEN, 
+												  COMMA_TOKEN, NT_SCALAR_SRC_REG_TOKEN}, NO_KW},
+   {NT_VECTOROP_INSTRUCTION_TOKEN, {NT_VECTOROP_TOKEN, NT_MASKED_DST_REG_TOKEN, COMMA_TOKEN,
+                                     NT_SWIZZLE_SRC_REG_TOKEN},              NO_KW},
+   {NT_VECTOROP_TOKEN,             {ABS_TOKEN, NULL3},                       NO_KW},
+
+   /* 20: */
+   {NT_VECTOROP_TOKEN,             {FLR_TOKEN, NULL3}, NO_KW},
+   {NT_VECTOROP_TOKEN,             {FRC_TOKEN, NULL3}, NO_KW},
+   {NT_VECTOROP_TOKEN,             {LIT_TOKEN, NULL3}, NO_KW},
+   {NT_VECTOROP_TOKEN,             {MOV_TOKEN, NULL3}, NO_KW},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, {NT_SCALAROP_TOKEN, NT_MASKED_DST_REG_TOKEN, COMMA_TOKEN,
+                             NT_SCALAR_SRC_REG_TOKEN}, NO_KW},
+
+   /* 25: */
+   {NT_SCALAROP_TOKEN, {EX2_TOKEN, NULL3}, NO_KW},
+   {NT_SCALAROP_TOKEN, {EXP_TOKEN, NULL3}, NO_KW},
+   {NT_SCALAROP_TOKEN, {LG2_TOKEN, NULL3}, NO_KW},
+   {NT_SCALAROP_TOKEN, {LOG_TOKEN, NULL3}, NO_KW},
+   {NT_SCALAROP_TOKEN, {RCP_TOKEN, NULL3}, NO_KW},
+
+   /* 30: */
+   {NT_SCALAROP_TOKEN, {RSQ_TOKEN, NULL3},         NO_KW},
+   {NT_BINSCOP_INSTRUCTION_TOKEN,
+                       {NT_BINSCOP_TOKEN, NT_MASKED_DST_REG_TOKEN, NT_BINSCOP_INSTRUCTION2_TOKEN,
+                         NULL_TOKEN},              NO_KW},
+   {NT_BINSCOP_INSTRUCTION2_TOKEN,
+                       {COMMA_TOKEN, NT_SCALAR_SRC_REG_TOKEN, COMMA_TOKEN,
+                         NT_SCALAR_SRC_REG_TOKEN}, NO_KW},
+   {NT_BINSCOP_TOKEN,  {POW_TOKEN, NULL3},         NO_KW},
+   {NT_BINOP_INSTRUCTION_TOKEN,
+                       {NT_BINOP_TOKEN, NT_MASKED_DST_REG_TOKEN, NT_BINOP_INSTRUCTION2_TOKEN,
+                         NULL_TOKEN},              NO_KW},
+
+   /* 35: */
+   {NT_BINOP_INSTRUCTION2_TOKEN,
+                       {COMMA_TOKEN, NT_SWIZZLE_SRC_REG_TOKEN, COMMA_TOKEN,
+                        NT_SWIZZLE_SRC_REG_TOKEN}, NO_KW},
+   {NT_BINOP_TOKEN,    {ADD_TOKEN, NULL3},         NO_KW},
+   {NT_BINOP_TOKEN,    {DP3_TOKEN, NULL3},         NO_KW},
+   {NT_BINOP_TOKEN,    {DP4_TOKEN, NULL3},         NO_KW},
+   {NT_BINOP_TOKEN,    {DPH_TOKEN, NULL3},         NO_KW},
+
+   /* 40: */
+   {NT_BINOP_TOKEN, {DST_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {MAX_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {MIN_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {MUL_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {SGE_TOKEN, NULL3}, NO_KW},
+
+   /* 45: */
+   {NT_BINOP_TOKEN, {SLT_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {SUB_TOKEN, NULL3}, NO_KW},
+   {NT_BINOP_TOKEN, {XPD_TOKEN, NULL3}, NO_KW},
+   {NT_TRIOP_INSTRUCTION_TOKEN,
+                    {NT_TRIOP_TOKEN, NT_MASKED_DST_REG_TOKEN, NT_TRIOP_INSTRUCTION2_TOKEN,
+                      NULL_TOKEN},      NO_KW},
+   {NT_TRIOP_INSTRUCTION2_TOKEN,
+                    {COMMA_TOKEN, NT_SWIZZLE_SRC_REG_TOKEN, NT_TRIOP_INSTRUCTION3_TOKEN,
+                      NULL_TOKEN},      NO_KW},
+
+   /* 50: */
+   {NT_TRIOP_INSTRUCTION3_TOKEN,
+                     {COMMA_TOKEN, NT_SWIZZLE_SRC_REG_TOKEN, COMMA_TOKEN,
+                       NT_SWIZZLE_SRC_REG_TOKEN}, NO_KW},
+   {NT_TRIOP_TOKEN,  {MAD_TOKEN, NULL3},          NO_KW},
+   {NT_SWZ_INSTRUCTION_TOKEN,
+                     {SWZ_TOKEN, NT_MASKED_DST_REG_TOKEN, NT_SWZ_INSTRUCTION2_TOKEN,
+                       NULL_TOKEN},               NO_KW},
+   {NT_SWZ_INSTRUCTION2_TOKEN,
+                     {COMMA_TOKEN, NT_SRC_REG_TOKEN, COMMA_TOKEN, NT_EXTENDED_SWIZZLE_TOKEN},
+                                                  NO_KW},
+   {NT_SCALAR_SRC_REG_TOKEN,
+                     {NT_OPTIONAL_SIGN_TOKEN, NT_SRC_REG_TOKEN, NT_SCALAR_SUFFIX_TOKEN,
+                       NULL_TOKEN},               NO_KW},
+
+   /* 55 */
+   {NT_SWIZZLE_SRC_REG_TOKEN,
+                      {NT_OPTIONAL_SIGN_TOKEN, NT_SRC_REG_TOKEN, NT_SWIZZLE_SUFFIX_TOKEN,
+                        NULL_TOKEN},                                        NO_KW},
+   {NT_MASKED_DST_REG_TOKEN,
+                      {NT_DST_REG_TOKEN, NT_OPTIONAL_MASK_TOKEN, NULL2},    NO_KW},
+   {NT_MASKED_ADDR_REG_TOKEN,
+                      {NT_ADDR_REG_TOKEN, NT_ADDR_WRITE_MASK_TOKEN, NULL2}, NO_KW},
+   {NT_EXTENDED_SWIZZLE_TOKEN,
+                      {NT_EXT_SWIZ_COMP_TOKEN, COMMA_TOKEN, NT_EXT_SWIZ_COMP_TOKEN,
+                        NT_EXTENDED_SWIZZLE2_TOKEN},                        NO_KW},
+   {NT_EXTENDED_SWIZZLE2_TOKEN,
+                      {COMMA_TOKEN, NT_EXT_SWIZ_COMP_TOKEN, COMMA_TOKEN,
+                        NT_EXT_SWIZ_COMP_TOKEN},                            NO_KW},
+
+   /* 60 */
+   {NT_EXT_SWIZ_COMP_TOKEN,{NT_OPTIONAL_SIGN_TOKEN, NT_EXT_SWIZ_SEL_TOKEN, NULL2},
+                                                                NO_KW},
+   {NT_EXT_SWIZ_SEL_TOKEN, {INTEGER_TOKEN, NULL3},              {"0", "", "", ""}},
+   {NT_EXT_SWIZ_SEL_TOKEN, {INTEGER_TOKEN, NULL3},              {"1", "", "", ""}},
+   {NT_EXT_SWIZ_SEL_TOKEN, {NT_COMPONENT_TOKEN, NULL3},         NO_KW},
+   {NT_SRC_REG_TOKEN,      {NT_VERTEX_ATTRIB_REG_TOKEN, NULL3}, NO_KW},
+
+   /* 65: */
+   {NT_SRC_REG_TOKEN,           {NT_TEMPORARY_REG_TOKEN, NULL3},     NO_KW},
+   {NT_SRC_REG_TOKEN,           {NT_PROG_PARAM_REG_TOKEN, NULL3},    NO_KW},
+   {NT_DST_REG_TOKEN,           {NT_TEMPORARY_REG_TOKEN, NULL3},     NO_KW},
+   {NT_DST_REG_TOKEN,           {NT_VERTEX_RESULT_REG_TOKEN, NULL3}, NO_KW},
+   {NT_VERTEX_ATTRIB_REG_TOKEN, {NT_ESTABLISHED_NAME_TOKEN, NULL3},  NO_KW},
+
+   /* 70: */
+   {NT_VERTEX_ATTRIB_REG_TOKEN, {NT_VTX_ATTRIB_BINDING_TOKEN, NULL3},    NO_KW},
+   {NT_TEMPORARY_REG_TOKEN,     {NT_ESTABLISHED_NAME_TOKEN, NULL3},      NO_KW},
+   {NT_PROG_PARAM_REG_TOKEN,    {NT_PROG_PARAM_SINGLE_TOKEN, NULL3},     NO_KW},
+   {NT_PROG_PARAM_REG_TOKEN,
+                                {NT_PROG_PARAM_ARRAY_TOKEN, LBRACKET_TOKEN, NT_PROG_PARAM_ARRAY_MEM_TOKEN,
+                                  RBRACKET_TOKEN},                       NO_KW},
+   {NT_PROG_PARAM_REG_TOKEN,    {NT_PARAM_SINGLE_ITEM_USE_TOKEN, NULL3}, NO_KW},
+
+   /* 75: */
+   {NT_PROG_PARAM_SINGLE_TOKEN,    {NT_ESTABLISHED_NAME_TOKEN, NULL3},     NO_KW},
+   {NT_PROG_PARAM_ARRAY_TOKEN,     {NT_ESTABLISHED_NAME_TOKEN, NULL3},     NO_KW},
+   {NT_PROG_PARAM_ARRAY_MEM_TOKEN, {NT_PROG_PARAM_ARRAY_ABS_TOKEN, NULL3}, NO_KW},
+   {NT_PROG_PARAM_ARRAY_MEM_TOKEN, {NT_PROG_PARAM_ARRAY_REL_TOKEN, NULL3}, NO_KW},
+                                                                           /* -1 matches all */
+   {NT_PROG_PARAM_ARRAY_ABS_TOKEN, {INTEGER_TOKEN, NULL3},                 {"-1", "", "", ""}},	
+
+
+   /* 80: */
+   {NT_PROG_PARAM_ARRAY_REL_TOKEN,
+              {NT_ADDR_REG_TOKEN, NT_ADDR_COMPONENT_TOKEN, NT_ADDR_REG_REL_OFFSET_TOKEN,
+                NULL_TOKEN},                                      NO_KW},
+   {NT_ADDR_REG_REL_OFFSET_TOKEN, {NULL4},                        NO_KW},
+   {NT_ADDR_REG_REL_OFFSET_TOKEN,
+              {PLUS_TOKEN, NT_ADDR_REG_POS_OFFSET_TOKEN, NULL2},  NO_KW},
+   {NT_ADDR_REG_REL_OFFSET_TOKEN,
+              {MINUS_TOKEN, NT_ADDR_REG_NEG_OFFSET_TOKEN, NULL2}, NO_KW},
+   {NT_ADDR_REG_POS_OFFSET_TOKEN, {INTEGER_TOKEN, NULL3},         {"-1", "", "", ""}},
+
+   /* 85: */
+   {NT_ADDR_REG_NEG_OFFSET_TOKEN, {INTEGER_TOKEN, NULL3},             {"-1", "", "", ""}},
+   {NT_VERTEX_RESULT_REG_TOKEN,   {NT_ESTABLISHED_NAME_TOKEN, NULL3}, NO_KW},
+   {NT_VERTEX_RESULT_REG_TOKEN,   {NT_RESULT_BINDING_TOKEN, NULL3},   NO_KW},
+   {NT_ADDR_REG_TOKEN,            {NT_ESTABLISHED_NAME_TOKEN, NULL3}, NO_KW},
+   {NT_ADDR_COMPONENT_TOKEN,      {PERIOD_TOKEN, ID_TOKEN, NULL2},    {"", "x", "", ""}},
+    
+   /* 90: */
+   {NT_ADDR_WRITE_MASK_TOKEN, {PERIOD_TOKEN, ID_TOKEN, NULL2},            {"", "x", "", ""}},
+   {NT_SCALAR_SUFFIX_TOKEN,   {PERIOD_TOKEN, NT_COMPONENT_TOKEN, NULL2},  {"", "x", "", ""}},
+   {NT_SWIZZLE_SUFFIX_TOKEN,  {NULL4},                                    NO_KW},
+   {NT_COMPONENT_TOKEN,       {ID_TOKEN, NULL3},                          {"x", "", "", ""}},
+   {NT_COMPONENT_TOKEN,       {ID_TOKEN, NULL3},                          {"y", "", "", ""}},
+
+   /* 95: */
+   {NT_COMPONENT_TOKEN,      {ID_TOKEN, NULL3},                              {"z", "", "", ""}},
+   {NT_COMPONENT_TOKEN,      {ID_TOKEN, NULL3},                              {"w", "", "", ""}},
+   {NT_OPTIONAL_MASK_TOKEN,  {PERIOD_TOKEN, NT_OPTIONAL_MASK2_TOKEN, NULL2}, NO_KW},
+   {NT_OPTIONAL_MASK_TOKEN,  {NULL4},                                        NO_KW},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3},                              {"x", "", "", ""}},
+
+   /* 100: */
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"y", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"xy", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"z", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"xz", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"yz", "", "", ""}},
+
+   /* 105: */
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"xyz", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"w", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"xw", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"yw", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN, {ID_TOKEN, NULL3}, {"xyw", "", "", ""}},
+
+   /* 110: */
+   {NT_OPTIONAL_MASK2_TOKEN,  {ID_TOKEN, NULL3}, {"zw", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN,  {ID_TOKEN, NULL3}, {"xzw", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN,  {ID_TOKEN, NULL3}, {"yzw", "", "", ""}},
+   {NT_OPTIONAL_MASK2_TOKEN,  {ID_TOKEN, NULL3}, {"xyzw", "", "", ""}},
+   {NT_NAMING_STATEMENT_TOKEN, {NT_ATTRIB_STATEMENT_TOKEN, NULL3}, NO_KW},
+
+   /* 115: */
+   {NT_NAMING_STATEMENT_TOKEN, {NT_PARAM_STATEMENT_TOKEN, NULL3},   NO_KW},
+   {NT_NAMING_STATEMENT_TOKEN, {NT_TEMP_STATEMENT_TOKEN, NULL3},    NO_KW},
+   {NT_NAMING_STATEMENT_TOKEN, {NT_ADDRESS_STATEMENT_TOKEN, NULL3}, NO_KW},
+   {NT_NAMING_STATEMENT_TOKEN, {NT_OUTPUT_STATEMENT_TOKEN, NULL3},  NO_KW},
+   {NT_NAMING_STATEMENT_TOKEN, {NT_ALIAS_STATEMENT_TOKEN, NULL3},   NO_KW},
+
+   /* 120: */
+   {NT_ATTRIB_STATEMENT_TOKEN,
+           {ATTRIB_TOKEN, NT_ESTABLISH_NAME_TOKEN, EQUAL_TOKEN, NT_VTX_ATTRIB_BINDING_TOKEN}, NO_KW},
+   {NT_VTX_ATTRIB_BINDING_TOKEN,
+           {VERTEX_TOKEN, PERIOD_TOKEN, NT_VTX_ATTRIB_ITEM_TOKEN, NULL_TOKEN},                NO_KW},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NULL3},                             {"position", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NT_VTX_OPT_WEIGHT_NUM_TOKEN, NULL2},{"weight", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NULL3},                             {"normal", "", "", ""}},
+
+   /* 125: */
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NT_OPT_COLOR_TYPE_TOKEN, NULL2},
+                                                 {"color", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NULL3}, {"fogcoord", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, {ID_TOKEN, NT_OPT_TEX_COORD_NUM_TOKEN, NULL2},
+                                                 {"texcoord", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN,
+                              {ID_TOKEN, LBRACKET_TOKEN, NT_VTX_WEIGHT_NUM_TOKEN, RBRACKET_TOKEN},
+                                                 {"matrixindex", "", "", ""}},
+   {NT_VTX_ATTRIB_ITEM_TOKEN,
+                              {ID_TOKEN, LBRACKET_TOKEN, NT_VTX_ATTRIB_NUM_TOKEN, RBRACKET_TOKEN},
+                                                 {"attrib", "", "", ""}},
+
+   /* 130: */
+   {NT_VTX_ATTRIB_NUM_TOKEN,     {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, {NULL4},                NO_KW},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, {LBRACKET_TOKEN, NT_VTX_WEIGHT_NUM_TOKEN, RBRACKET_TOKEN, NULL_TOKEN},
+                                                         NO_KW},
+   {NT_VTX_WEIGHT_NUM_TOKEN,     {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_PARAM_STATEMENT_TOKEN,
+                                 {PARAM_TOKEN, NT_ESTABLISH_NAME_TOKEN, NT_PARAM_STATEMENT2_TOKEN,
+                                   NULL_TOKEN},          NO_KW},
+
+   /* 135: */
+   {NT_PARAM_STATEMENT2_TOKEN,  {NT_PARAM_SINGLE_INIT_TOKEN, NULL3},     NO_KW},
+   {NT_PARAM_STATEMENT2_TOKEN,  {LBRACKET_TOKEN, NT_OPT_ARRAY_SIZE_TOKEN, RBRACKET_TOKEN,
+                                    NT_PARAM_MULTIPLE_INIT_TOKEN},       NO_KW},
+   {NT_OPT_ARRAY_SIZE_TOKEN,    {NULL4},                                 NO_KW},
+   {NT_OPT_ARRAY_SIZE_TOKEN,    {INTEGER_TOKEN, NULL3},                  {"-1", "", "", ""}},
+   {NT_PARAM_SINGLE_INIT_TOKEN, {EQUAL_TOKEN, NT_PARAM_SINGLE_ITEM_DECL_TOKEN, NULL2}, 
+			                                                                NO_KW},
+    
+
+   /* 140: */
+   {NT_PARAM_MULTIPLE_INIT_TOKEN,
+                     {EQUAL_TOKEN, LBRACE_TOKEN, NT_PARAM_MULT_INIT_LIST_TOKEN, RBRACE_TOKEN},
+                                              NO_KW},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN,
+                     {NT_PARAM_MULTIPLE_ITEM_TOKEN, NT_PARAM_MULT_INIT_LIST2_TOKEN, NULL2},
+                                              NO_KW},
+   {NT_PARAM_MULT_INIT_LIST2_TOKEN,
+                     {COMMA_TOKEN, NT_PARAM_MULT_INIT_LIST_TOKEN, NULL2}, 
+							                         NO_KW},
+   {NT_PARAM_MULT_INIT_LIST2_TOKEN,  {NULL4}, NO_KW},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, {NT_STATE_SINGLE_ITEM_TOKEN, NULL3},
+                                              NO_KW},
+
+   /* 145: */
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, {NT_PROGRAM_SINGLE_ITEM_TOKEN, NULL3}, NO_KW},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, {NT_PARAM_CONST_DECL_TOKEN, NULL3},    NO_KW},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, {NT_STATE_SINGLE_ITEM_TOKEN, NULL3},    NO_KW},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, {NT_PROGRAM_SINGLE_ITEM_TOKEN, NULL3},  NO_KW},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, {NT_PARAM_CONST_USE_TOKEN, NULL3},      NO_KW},
+
+   /* 150: */
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, {NT_STATE_MULTIPLE_ITEM_TOKEN, NULL3},    NO_KW},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, {NT_PROGRAM_MULTIPLE_ITEM_TOKEN, NULL3},  NO_KW},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, {NT_PARAM_CONST_DECL_TOKEN, NULL3},       NO_KW},
+   {NT_STATE_MULTIPLE_ITEM_TOKEN,
+        {STATE_TOKEN, PERIOD_TOKEN, NT_STATE_MULTIPLE_ITEM2_TOKEN, NULL_TOKEN},
+                                                                            NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_MATERIAL_ITEM_TOKEN, NULL3},   NO_KW},
+
+   /* 155: */
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_LIGHT_ITEM_TOKEN, NULL3},       NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_LIGHT_MODEL_ITEM_TOKEN, NULL3}, NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_LIGHT_PROD_ITEM_TOKEN, NULL3},  NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_TEX_GEN_ITEM_TOKEN, NULL3},     NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_FOG_ITEM_TOKEN, NULL3},         NO_KW},
+
+   /* 160: */
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_CLIP_PLANE_ITEM_TOKEN, NULL3},  NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, {NT_STATE_POINT_ITEM_TOKEN, NULL3},       NO_KW},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN,
+                  {ID_TOKEN, PERIOD_TOKEN, NT_STATE_MATRIX_NAME_TOKEN, NT_FOO_TOKEN},
+                                                               {"matrix", "", "", ""}},
+   {NT_FOO_TOKEN, {PERIOD_TOKEN, NT_FOO2_TOKEN, NULL2},                      NO_KW},
+   {NT_FOO2_TOKEN, {NT_STATE_MAT_MODIFIER_TOKEN, NT_FOO3_TOKEN, NULL2},      NO_KW},
+
+   /* 165: */
+   {NT_FOO2_TOKEN,  {ID_TOKEN, LBRACKET_TOKEN, NT_STATE_MATRIX_ROW_NUM_TOKEN, NT_FOO4_TOKEN},
+                             {"row", "", "", ""}},
+   {NT_FOO3_TOKEN,  {NULL4}, NO_KW},
+   {NT_FOO3_TOKEN,  {PERIOD_TOKEN, ID_TOKEN, LBRACKET_TOKEN, NT_FOO35_TOKEN},
+                            {"", "row", "", ""}},
+   {NT_FOO35_TOKEN, {NT_STATE_MATRIX_ROW_NUM_TOKEN, NT_FOO4_TOKEN, NULL2},
+                            NO_KW},
+   {NT_FOO4_TOKEN,  {RBRACKET_TOKEN, NULL3}, NO_KW},
+
+   /* 170: */
+   {NT_FOO4_TOKEN, {DOTDOT_TOKEN, NT_STATE_MATRIX_ROW_NUM_TOKEN, RBRACKET_TOKEN, NULL_TOKEN},
+                     NO_KW},
+   {NT_STATE_SINGLE_ITEM_TOKEN,
+                   {STATE_TOKEN, PERIOD_TOKEN, NT_STATE_SINGLE_ITEM2_TOKEN, NULL_TOKEN},
+                     NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_MATERIAL_ITEM_TOKEN, NULL3},
+                     NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_LIGHT_ITEM_TOKEN, NULL3}, 
+			            NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_LIGHT_MODEL_ITEM_TOKEN, NULL3},
+                     NO_KW},
+
+   /* 175: */
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_LIGHT_PROD_ITEM_TOKEN, NULL3}, NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_TEX_GEN_ITEM_TOKEN, NULL3},    NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_FOG_ITEM_TOKEN, NULL3},        NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_CLIP_PLANE_ITEM_TOKEN, NULL3}, NO_KW},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_POINT_ITEM_TOKEN, NULL3},      NO_KW},
+
+   /* 180: */
+   {NT_STATE_SINGLE_ITEM2_TOKEN, {NT_STATE_MATRIX_ROW_TOKEN, NULL3}, NO_KW},
+   {NT_STATE_MATERIAL_ITEM_TOKEN,
+         {ID_TOKEN, PERIOD_TOKEN, NT_STATE_MATERIAL_ITEM2_TOKEN, NULL_TOKEN},
+                                                                     {"material", "", "", ""}},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, {NT_STATE_MAT_PROPERTY_TOKEN, NULL3},
+                                                                     NO_KW},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN,
+         {PERIOD_TOKEN, NT_OPT_FACE_TYPE2_TOKEN, PERIOD_TOKEN,
+            NT_STATE_MAT_PROPERTY_TOKEN},                            NO_KW},
+   {NT_STATE_MAT_PROPERTY_TOKEN, {ID_TOKEN, NULL3},                  {"ambient", "", "", ""}},
+
+   /* 185 */
+   {NT_STATE_MAT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"diffuse", "", "", ""}},
+   {NT_STATE_MAT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"specular", "", "", ""}},
+   {NT_STATE_MAT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"emission", "", "", ""}},
+   {NT_STATE_MAT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"shininess", "", "", ""}},
+   {NT_STATE_LIGHT_ITEM_TOKEN,
+                                 {ID_TOKEN, LBRACKET_TOKEN, NT_STATE_LIGHT_NUMBER_TOKEN,
+                      NT_STATE_LIGHT_ITEM2_TOKEN},  {"light", "", "", ""}},
+
+   /* 190: */
+   {NT_STATE_LIGHT_ITEM2_TOKEN, {RBRACKET_TOKEN, PERIOD_TOKEN, NT_STATE_LIGHT_PROPERTY_TOKEN, NULL_TOKEN},
+                                                      NO_KW},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"ambient", "", "", ""}},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"diffuse", "", "", ""}},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"specular", "", "", ""}},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"position", "", "", ""}},
+
+   /* 195: */
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"attenuation", "", "", ""}},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN,
+               {ID_TOKEN, PERIOD_TOKEN, NT_STATE_SPOT_PROPERTY_TOKEN, NULL_TOKEN},
+                                                      {"spot", "", "", ""}},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"half", "", "", ""}},
+   {NT_STATE_SPOT_PROPERTY_TOKEN,  {ID_TOKEN, NULL3}, {"direction", "", "", ""}},
+   {NT_STATE_LIGHT_MODEL_ITEM_TOKEN,
+     {ID_TOKEN, NT_STATE_LMOD_PROPERTY_TOKEN, NULL2}, {"lightmodel", "", "", ""}},
+						     
+   /* 200: */
+   {NT_STATE_LMOD_PROPERTY_TOKEN,  {PERIOD_TOKEN, NT_STATE_LMOD_PROPERTY2_TOKEN, NULL2}, NO_KW},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, {ID_TOKEN, NULL3}, {"ambient", "", "", ""}},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, {ID_TOKEN, NULL3}, {"scenecolor", "", "", ""}},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN,
+                 {NT_OPT_FACE_TYPE2_TOKEN, PERIOD_TOKEN, ID_TOKEN, NULL_TOKEN},
+                                                      {"scenecolor", "", "", ""}},
+   {NT_STATE_LIGHT_PROD_ITEM_TOKEN,
+                 {ID_TOKEN, LBRACKET_TOKEN, NT_STATE_LIGHT_NUMBER_TOKEN,
+                   NT_STATE_LIGHT_PROD_ITEM15_TOKEN}, {"lightprod", "", "", ""}},
+
+   /* 205: */
+   {NT_STATE_LIGHT_PROD_ITEM15_TOKEN,
+    {RBRACKET_TOKEN, PERIOD_TOKEN, NT_STATE_LIGHT_PROD_ITEM2_TOKEN, NULL_TOKEN},        NO_KW},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, {NT_STATE_LPROD_PROPERTY_TOKEN, NULL3},            NO_KW},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN,
+   {NT_OPT_FACE_TYPE2_TOKEN, PERIOD_TOKEN, NT_STATE_LPROD_PROPERTY_TOKEN, NULL_TOKEN},  NO_KW},
+   {NT_STATE_LPROD_PROPERTY_TOKEN, {ID_TOKEN, NULL3},  {"diffuse", "", "", ""}},
+   {NT_STATE_LPROD_PROPERTY_TOKEN, {ID_TOKEN, NULL3},  {"ambient", "", "", ""}},
+    
+   /* 210: */
+   {NT_STATE_LPROD_PROPERTY_TOKEN, {ID_TOKEN, NULL3},    {"specular", "", "", ""}},
+   {NT_STATE_LIGHT_NUMBER_TOKEN, {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_STATE_TEX_GEN_ITEM_TOKEN, {ID_TOKEN, NT_OPT_TEX_COORD_NUM_TOKEN, 
+              NT_STATE_TEX_GEN_ITEM2_TOKEN, NULL_TOKEN}, {"texgen", "", "", ""}},
+   {NT_STATE_TEX_GEN_ITEM2_TOKEN,{PERIOD_TOKEN, NT_STATE_TEX_GEN_TYPE_TOKEN, PERIOD_TOKEN,
+                          NT_STATE_TEX_GEN_COORD_TOKEN}, NO_KW},
+   {NT_STATE_TEX_GEN_TYPE_TOKEN, {ID_TOKEN, NULL3},      {"eye", "", "", ""}},
+
+   /* 215: */
+   {NT_STATE_TEX_GEN_TYPE_TOKEN,  {ID_TOKEN, NULL3}, {"object", "", "", ""}},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, {ID_TOKEN, NULL3}, {"s", "", "", ""}},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, {ID_TOKEN, NULL3}, {"t", "", "", ""}},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, {ID_TOKEN, NULL3}, {"r", "", "", ""}},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, {ID_TOKEN, NULL3}, {"q", "", "", ""}},
+
+   /* 220: */
+   {NT_STATE_FOG_ITEM_TOKEN,     {ID_TOKEN, PERIOD_TOKEN, NT_STATE_FOG_PROPERTY_TOKEN, NULL_TOKEN},
+                                                    {"fog", "","",""}},
+   {NT_STATE_FOG_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"color", "", "", ""}},
+   {NT_STATE_FOG_PROPERTY_TOKEN, {ID_TOKEN, NULL3}, {"params", "", "", ""}},
+   {NT_STATE_CLIP_PLANE_ITEM_TOKEN,
+                {ID_TOKEN, LBRACKET_TOKEN, NT_STATE_CLIP_PLANE_NUM_TOKEN,
+                  NT_STATE_CLIP_PLANE_ITEM2_TOKEN}, {"clip", "", "", ""}},
+   {NT_STATE_CLIP_PLANE_ITEM2_TOKEN,
+                {RBRACKET_TOKEN, PERIOD_TOKEN, ID_TOKEN, NULL_TOKEN}, 
+					                                     {"", "", "plane", ""}},
+																	 
+   /* 225: */
+   {NT_STATE_CLIP_PLANE_NUM_TOKEN,{INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_STATE_POINT_ITEM_TOKEN,    {ID_TOKEN, PERIOD_TOKEN, NT_STATE_POINT_PROPERTY_TOKEN, NULL_TOKEN},
+                                                          {"point", "", "", ""}},
+   {NT_STATE_POINT_PROPERTY_TOKEN, {ID_TOKEN, NULL3},     {"size", "", "", ""}},
+   {NT_STATE_POINT_PROPERTY_TOKEN, {ID_TOKEN, NULL3},     {"attenuation", "", "", ""}},
+   {NT_STATE_MATRIX_ROW_TOKEN,     {ID_TOKEN, PERIOD_TOKEN, NT_STATE_MATRIX_NAME_TOKEN,
+                            NT_STATE_MATRIX_ROW15_TOKEN}, {"matrix", "", "", ""}},
+
+   /* 230: */
+   {NT_STATE_MATRIX_ROW15_TOKEN, {PERIOD_TOKEN, NT_STATE_MATRIX_ROW2_TOKEN, NULL2}, NO_KW},
+   {NT_STATE_MATRIX_ROW2_TOKEN,  {ID_TOKEN, LBRACKET_TOKEN, 
+                           NT_STATE_MATRIX_ROW_NUM_TOKEN, RBRACKET_TOKEN},         
+									{"row", "", "", ""}},
+   {NT_STATE_MATRIX_ROW2_TOKEN, {NT_STATE_MAT_MODIFIER_TOKEN, PERIOD_TOKEN, ID_TOKEN,
+                           NT_STATE_MATRIX_ROW3_TOKEN}, 
+									{"", "", "row", ""}},
+   {NT_STATE_MATRIX_ROW3_TOKEN, {LBRACKET_TOKEN, NT_STATE_MATRIX_ROW_NUM_TOKEN, RBRACKET_TOKEN,
+                          NULL_TOKEN}, NO_KW},
+   {NT_STATE_MAT_MODIFIER_TOKEN, {ID_TOKEN, NULL3}, {"inverse", "", "", ""}},
+
+   /* 235: */
+   {NT_STATE_MAT_MODIFIER_TOKEN,   {ID_TOKEN, NULL3},      {"transpose", "", "", ""}},
+   {NT_STATE_MAT_MODIFIER_TOKEN,   {ID_TOKEN, NULL3},      {"invtrans", "", "", ""}},
+   {NT_STATE_MATRIX_ROW_NUM_TOKEN, {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_STATE_MATRIX_NAME_TOKEN,    {ID_TOKEN, NT_STATE_OPT_MOD_MAT_NUM_TOKEN, NULL2},
+			                                                  {"modelview", "", "", ""}},
+   {NT_STATE_MATRIX_NAME_TOKEN, {ID_TOKEN, NULL3},         {"projection", "", "", ""}},
+
+   /* 240: */
+   {NT_STATE_MATRIX_NAME_TOKEN, {ID_TOKEN, NULL3}, {"mvp", "", "", ""}},
+   {NT_STATE_MATRIX_NAME_TOKEN, {ID_TOKEN, NT_OPT_TEX_COORD_NUM_TOKEN, NULL2},
+                                                   {"texture", "", "", ""}},
+   {NT_STATE_MATRIX_NAME_TOKEN, {ID_TOKEN, LBRACKET_TOKEN, NT_STATE_PALETTE_MAT_NUM_TOKEN,
+                                  RBRACKET_TOKEN}, {"palette", "", "", ""}},
+   {NT_STATE_MATRIX_NAME_TOKEN, {PROGRAM_TOKEN, LBRACKET_TOKEN, NT_STATE_PROGRAM_MAT_NUM_TOKEN,
+                                  RBRACKET_TOKEN}, NO_KW},
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN, {NULL4},       NO_KW},
+
+   /* 245: */
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN,
+    {LBRACKET_TOKEN, NT_STATE_MOD_MAT_NUM_TOKEN, RBRACKET_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_STATE_MOD_MAT_NUM_TOKEN, {INTEGER_TOKEN, NULL3},                       {"-1", "", "", ""}},
+   {NT_STATE_PALETTE_MAT_NUM_TOKEN, {INTEGER_TOKEN, NULL3},                   {"-1", "", "", ""}},
+   {NT_STATE_PROGRAM_MAT_NUM_TOKEN, {INTEGER_TOKEN, NULL3},                   {"-1", "", "", ""}},
+   {NT_PROGRAM_SINGLE_ITEM_TOKEN, 
+     {PROGRAM_TOKEN, PERIOD_TOKEN, NT_PROGRAM_SINGLE_ITEM2_TOKEN, NULL_TOKEN}, NO_KW},
+
+   /* 250: */
+   {NT_PROGRAM_SINGLE_ITEM2_TOKEN, {NT_PROG_ENV_PARAM_TOKEN, NULL3},            NO_KW},
+   {NT_PROGRAM_SINGLE_ITEM2_TOKEN, {NT_PROG_LOCAL_PARAM_TOKEN, NULL3},          NO_KW},
+   {NT_PROGRAM_MULTIPLE_ITEM_TOKEN,
+    {PROGRAM_TOKEN, PERIOD_TOKEN, NT_PROGRAM_MULTIPLE_ITEM2_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_PROGRAM_MULTIPLE_ITEM2_TOKEN, {NT_PROG_ENV_PARAMS_TOKEN, NULL3},         NO_KW},
+   {NT_PROGRAM_MULTIPLE_ITEM2_TOKEN, {NT_PROG_LOCAL_PARAMS_TOKEN, NULL3},       NO_KW},
+
+   /* 255: */
+   {NT_PROG_ENV_PARAMS_TOKEN, {ID_TOKEN, LBRACKET_TOKEN, NT_PROG_ENV_PARAM_NUMS_TOKEN, RBRACKET_TOKEN},
+                                   {"env", "", "", ""}},
+   {NT_PROG_ENV_PARAM_NUMS_TOKEN, {NT_PROG_ENV_PARAM_NUM_TOKEN, NT_PROG_ENV_PARAM_NUMS2_TOKEN, NULL2},
+                                   NO_KW},
+   {NT_PROG_ENV_PARAM_NUMS2_TOKEN, {DOTDOT_TOKEN, NT_PROG_ENV_PARAM_NUM_TOKEN, NULL2}, NO_KW},
+   {NT_PROG_ENV_PARAM_NUMS2_TOKEN, {NULL4},                                            NO_KW},
+   {NT_PROG_ENV_PARAM_TOKEN,
+     {ID_TOKEN, LBRACKET_TOKEN, NT_PROG_ENV_PARAM_NUM_TOKEN, RBRACKET_TOKEN},
+                                   {"env", "", "", ""}},
+
+   /* 260: */
+   {NT_PROG_LOCAL_PARAMS_TOKEN, {ID_TOKEN, LBRACKET_TOKEN, NT_PROG_LOCAL_PARAM_NUMS_TOKEN,
+                  RBRACKET_TOKEN}, {"local", "", "", ""}},
+   {NT_PROG_LOCAL_PARAM_NUMS_TOKEN,
+    {NT_PROG_LOCAL_PARAM_NUM_TOKEN, NT_PROG_LOCAL_PARAM_NUMS2_TOKEN, NULL2},
+                                   NO_KW},
+   {NT_PROG_LOCAL_PARAM_NUMS2_TOKEN, {DOTDOT_TOKEN, NT_PROG_LOCAL_PARAM_NUM_TOKEN, NULL2}, NO_KW},
+   {NT_PROG_LOCAL_PARAM_NUMS2_TOKEN, {NULL4},                                              NO_KW},
+   {NT_PROG_LOCAL_PARAM_TOKEN, {ID_TOKEN, LBRACKET_TOKEN, NT_PROG_LOCAL_PARAM_NUM_TOKEN, RBRACKET_TOKEN},
+                                   {"local", "", "", ""}},
+
+   /* 265: */
+   {NT_PROG_ENV_PARAM_NUM_TOKEN, {INTEGER_TOKEN, NULL3},   {"-1", "", "", ""}},
+   {NT_PROG_LOCAL_PARAM_NUM_TOKEN, {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_PARAM_CONST_DECL_TOKEN, {NT_PARAM_CONST_SCALAR_DECL_TOKEN, NULL3}, NO_KW},
+   {NT_PARAM_CONST_DECL_TOKEN, {NT_PARAM_CONST_VECTOR_TOKEN, NULL3},      NO_KW},
+   {NT_PARAM_CONST_USE_TOKEN, {NT_PARAM_CONST_SCALAR_USE_TOKEN, NULL3},   NO_KW},
+    
+   /* 270: */
+   {NT_PARAM_CONST_USE_TOKEN,         {NT_PARAM_CONST_VECTOR_TOKEN, NULL3},    NO_KW},
+   {NT_PARAM_CONST_SCALAR_DECL_TOKEN, {NT_SIGNED_FLOAT_CONSTANT_TOKEN, NULL3}, NO_KW},
+   {NT_PARAM_CONST_SCALAR_USE_TOKEN,  {FLOAT_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_PARAM_CONST_VECTOR_TOKEN, {LBRACE_TOKEN, NT_SIGNED_FLOAT_CONSTANT_TOKEN,
+                                    NT_PARAM_CONST_VECTOR2_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_PARAM_CONST_VECTOR2_TOKEN,{RBRACE_TOKEN, NULL3},                        NO_KW},
+
+   /* 275: */
+   {NT_PARAM_CONST_VECTOR2_TOKEN, {COMMA_TOKEN, NT_SIGNED_FLOAT_CONSTANT_TOKEN,
+                                    NT_PARAM_CONST_VECTOR3_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_PARAM_CONST_VECTOR3_TOKEN, {RBRACE_TOKEN, NULL3},                       NO_KW},
+   {NT_PARAM_CONST_VECTOR3_TOKEN, {COMMA_TOKEN, NT_SIGNED_FLOAT_CONSTANT_TOKEN,
+                                    NT_PARAM_CONST_VECTOR4_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_PARAM_CONST_VECTOR4_TOKEN, {RBRACE_TOKEN, NULL3},                       NO_KW},
+   {NT_PARAM_CONST_VECTOR4_TOKEN, {COMMA_TOKEN, NT_SIGNED_FLOAT_CONSTANT_TOKEN, 
+														RBRACE_TOKEN, NULL_TOKEN},           NO_KW},
+
+   /* 280: */
+   {NT_SIGNED_FLOAT_CONSTANT_TOKEN, {NT_OPTIONAL_SIGN_TOKEN, FLOAT_TOKEN, NULL2}, 
+                                                  {"", "-1", "", ""}},
+   {NT_OPTIONAL_SIGN_TOKEN, {NULL4},              NO_KW},
+   {NT_OPTIONAL_SIGN_TOKEN, {MINUS_TOKEN, NULL3}, NO_KW},
+   {NT_OPTIONAL_SIGN_TOKEN, {PLUS_TOKEN, NULL3},  NO_KW},
+   {NT_TEMP_STATEMENT_TOKEN, {TEMP_TOKEN, NT_VAR_NAME_LIST_TOKEN, NULL2},
+                                                  NO_KW},
+
+   /* 285: */
+   {NT_ADDRESS_STATEMENT_TOKEN, {ADDRESS_TOKEN, NT_VAR_NAME_LIST_TOKEN, NULL2}, NO_KW},
+   {NT_VAR_NAME_LIST_TOKEN,     {NT_ESTABLISH_NAME_TOKEN, NULL3},               NO_KW},
+   {NT_VAR_NAME_LIST_TOKEN,     {NT_ESTABLISH_NAME_TOKEN, COMMA_TOKEN, NT_VAR_NAME_LIST_TOKEN,
+                                  NULL_TOKEN},                                  NO_KW},
+   {NT_OUTPUT_STATEMENT_TOKEN,  {OUTPUT_TOKEN, NT_ESTABLISH_NAME_TOKEN, EQUAL_TOKEN,
+                                  NT_RESULT_BINDING_TOKEN},                     NO_KW},
+   {NT_RESULT_BINDING_TOKEN,    {RESULT_TOKEN, PERIOD_TOKEN, NT_RESULT_BINDING2_TOKEN, NULL_TOKEN},
+                                                                                NO_KW},
+
+   /* 290: */
+   {NT_RESULT_BINDING2_TOKEN, {ID_TOKEN, NULL3},                    {"position", "", "", ""}},
+   {NT_RESULT_BINDING2_TOKEN, {ID_TOKEN, NULL3},                    {"fogcoord", "", "", ""}},
+   {NT_RESULT_BINDING2_TOKEN, {ID_TOKEN, NULL3},                    {"pointsize", "", "", ""}},
+   {NT_RESULT_BINDING2_TOKEN, {NT_RESULT_COL_BINDING_TOKEN, NULL3}, NO_KW},
+   {NT_RESULT_BINDING2_TOKEN, {ID_TOKEN, NT_OPT_TEX_COORD_NUM_TOKEN, NULL2},
+                                                                    {"texcoord", "", "", ""}},
+
+   /* 295: */
+   {NT_RESULT_COL_BINDING_TOKEN, {ID_TOKEN, NT_RESULT_COL_BINDING2_TOKEN, NULL2}, {"color", "", "", ""}},
+   {NT_RESULT_COL_BINDING2_TOKEN, {NULL4},                                        NO_KW},
+   {NT_RESULT_COL_BINDING2_TOKEN, {PERIOD_TOKEN, NT_RESULT_COL_BINDING3_TOKEN, NULL2}, NO_KW},
+   {NT_RESULT_COL_BINDING3_TOKEN, {ID_TOKEN, NT_RESULT_COL_BINDING4_TOKEN, NULL2}, {"front", "", "", ""}},
+   {NT_RESULT_COL_BINDING3_TOKEN, {ID_TOKEN, NT_RESULT_COL_BINDING4_TOKEN, NULL2}, {"back", "", "", ""}},
+    
+   /* 300: */
+   {NT_RESULT_COL_BINDING4_TOKEN, {NULL4},           NO_KW},
+   {NT_RESULT_COL_BINDING4_TOKEN, {PERIOD_TOKEN, NT_RESULT_COL_BINDING5_TOKEN, NULL2}, NO_KW},
+   {NT_RESULT_COL_BINDING5_TOKEN, {ID_TOKEN, NULL3}, {"primary", "", "", ""}},
+   {NT_RESULT_COL_BINDING5_TOKEN, {ID_TOKEN, NULL3}, {"secondary", "", "", ""}},
+   {NT_OPT_FACE_TYPE2_TOKEN,      {ID_TOKEN, NULL3}, {"front", "", "", ""}},
+
+   /* 305: */
+   {NT_OPT_FACE_TYPE2_TOKEN, {ID_TOKEN, NULL3},  {"back", "", "", ""}},
+   {NT_OPT_COLOR_TYPE_TOKEN, {PERIOD_TOKEN, NT_OPT_COLOR_TYPE2_TOKEN, NULL2}, NO_KW},
+   {NT_OPT_COLOR_TYPE_TOKEN, {NULL4},            NO_KW},
+   {NT_OPT_COLOR_TYPE2_TOKEN, {ID_TOKEN, NULL3}, {"primary", "", "", ""}},
+   {NT_OPT_COLOR_TYPE2_TOKEN, {ID_TOKEN, NULL3}, {"secondary", "", "", ""}},
+
+   /* 310: */
+   {NT_OPT_TEX_COORD_NUM_TOKEN, {NULL4},                                  NO_KW},
+   {NT_OPT_TEX_COORD_NUM_TOKEN,
+    {LBRACKET_TOKEN, NT_TEX_COORD_NUM_TOKEN, RBRACKET_TOKEN, NULL_TOKEN}, NO_KW},
+   {NT_TEX_COORD_NUM_TOKEN,     {INTEGER_TOKEN, NULL3}, {"-1", "", "", ""}},
+   {NT_ALIAS_STATEMENT_TOKEN,   {ALIAS_TOKEN, NT_ESTABLISH_NAME_TOKEN, EQUAL_TOKEN,
+                             NT_ESTABLISHED_NAME_TOKEN}, NO_KW},
+   {NT_ESTABLISH_NAME_TOKEN, {ID_TOKEN, NULL3},          {"-1", "", "", ""}},
+
+   /* 315: */
+   {NT_ESTABLISHED_NAME_TOKEN, {ID_TOKEN, NULL3},           {"-1", "", "", ""}},
+   {NT_FOO_TOKEN,              {NULL4},                     NO_KW},
+   {NT_SWIZZLE_SUFFIX_TOKEN, {PERIOD_TOKEN, NT_SWIZZLE_SUFFIX2_TOKEN, NULL2},
+                                                            NO_KW},
+   {NT_SWIZZLE_SUFFIX2_TOKEN, {NT_COMPONENT_TOKEN, NULL3},  NO_KW},
+   {NT_SWIZZLE_SUFFIX2_TOKEN, {NT_COMPONENT4_TOKEN, NULL3}, NO_KW},
+};
+
+/* This is the look ahead table. See the look_ahead_table struct def for a description */
+look_ahead_table latab[] = {
+   {NT_PROGRAM_TOKEN, ABS_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, ADD_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, ADDRESS_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, ALIAS_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, ARL_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, ATTRIB_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, DP3_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, DP4_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, DPH_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, DST_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, END_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, EOF_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, EX2_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, EXP_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, FLR_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, FRC_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, LIT_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, LG2_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, LOG_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, MAD_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, MAX_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, MIN_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, MOV_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, MUL_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, OPTION_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, OUTPUT_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, PARAM_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, POW_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, RCP_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, RSQ_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, SGE_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, SLT_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, SUB_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, SWZ_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, XPD_TOKEN, "", 0},
+   {NT_PROGRAM_TOKEN, TEMP_TOKEN, "", 0},
+
+   {NT_OPTION_SEQUENCE_TOKEN, ABS_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, ADD_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, ADDRESS_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, ALIAS_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, ARL_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, ATTRIB_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, DP3_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, DP4_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, DPH_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, DST_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, END_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, EX2_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, EXP_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, FLR_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, FRC_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, LIT_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, LG2_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, LOG_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, MAD_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, MAX_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, MIN_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, MOV_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, MUL_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, OPTION_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, OUTPUT_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, PARAM_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, POW_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, RCP_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, RSQ_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, SGE_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, SLT_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, SUB_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, SWZ_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, XPD_TOKEN, "", 1},
+   {NT_OPTION_SEQUENCE_TOKEN, TEMP_TOKEN, "", 1},
+
+   {NT_OPTION_SEQUENCE2_TOKEN, OPTION_TOKEN, "", 2},
+
+   {NT_OPTION_SEQUENCE2_TOKEN, ABS_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, ADD_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, ADDRESS_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, ALIAS_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, ARL_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, ATTRIB_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, DP3_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, DP4_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, DPH_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, DST_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, END_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, EX2_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, EXP_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, FLR_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, FRC_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, LIT_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, LG2_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, LOG_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, MAD_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, MAX_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, MIN_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, MOV_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, MUL_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, OUTPUT_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, PARAM_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, POW_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, RCP_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, RSQ_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, SGE_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, SLT_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, SUB_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, SWZ_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, XPD_TOKEN, "", 3},
+   {NT_OPTION_SEQUENCE2_TOKEN, TEMP_TOKEN, "", 3},
+
+   {NT_OPTION_TOKEN, OPTION_TOKEN, "", 4},
+
+   {NT_STATEMENT_SEQUENCE_TOKEN, ABS_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, ADD_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, ADDRESS_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, ALIAS_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, ARL_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, ATTRIB_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, DP3_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, DP4_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, DPH_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, DST_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, END_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, EX2_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, EXP_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, FLR_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, FRC_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, LIT_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, LG2_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, LOG_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, MAD_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, MAX_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, MIN_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, MOV_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, MUL_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, OUTPUT_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, PARAM_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, POW_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, RCP_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, RSQ_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, SGE_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, SLT_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, SUB_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, SWZ_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, XPD_TOKEN, "", 5},
+   {NT_STATEMENT_SEQUENCE_TOKEN, TEMP_TOKEN, "", 5},
+
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ABS_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ADD_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ADDRESS_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ALIAS_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ARL_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, ATTRIB_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, DP3_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, DP4_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, DPH_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, DST_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, EX2_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, EXP_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, FLR_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, FRC_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, LIT_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, LG2_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, LOG_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, MAD_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, MAX_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, MIN_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, MOV_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, MUL_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, OUTPUT_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, PARAM_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, POW_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, RCP_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, RSQ_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, SGE_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, SLT_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, SUB_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, SWZ_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, XPD_TOKEN, "", 6},
+   {NT_STATEMENT_SEQUENCE2_TOKEN, TEMP_TOKEN, "", 6},
+
+   {NT_STATEMENT_SEQUENCE2_TOKEN, END_TOKEN, "", 7},
+
+
+   {NT_STATEMENT_TOKEN, ABS_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, ADD_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, ARL_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, DP3_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, DP4_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, DPH_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, DST_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, EX2_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, EXP_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, FLR_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, FRC_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, LIT_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, LG2_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, LOG_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, MAD_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, MAX_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, MIN_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, MOV_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, MUL_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, POW_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, RCP_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, RSQ_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, SGE_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, SLT_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, SUB_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, SWZ_TOKEN, "", 8},
+   {NT_STATEMENT_TOKEN, XPD_TOKEN, "", 8},
+
+   {NT_STATEMENT_TOKEN, ADDRESS_TOKEN, "", 9},
+   {NT_STATEMENT_TOKEN, ALIAS_TOKEN, "", 9},
+   {NT_STATEMENT_TOKEN, ATTRIB_TOKEN, "", 9},
+   {NT_STATEMENT_TOKEN, OUTPUT_TOKEN, "", 9},
+   {NT_STATEMENT_TOKEN, PARAM_TOKEN, "", 9},
+   {NT_STATEMENT_TOKEN, TEMP_TOKEN, "", 9},
+
+   {NT_INSTRUCTION_TOKEN, ARL_TOKEN, "", 10},
+
+   {NT_INSTRUCTION_TOKEN, ABS_TOKEN, "", 11},
+   {NT_INSTRUCTION_TOKEN, FLR_TOKEN, "", 11},
+   {NT_INSTRUCTION_TOKEN, FRC_TOKEN, "", 11},
+   {NT_INSTRUCTION_TOKEN, LIT_TOKEN, "", 11},
+   {NT_INSTRUCTION_TOKEN, MOV_TOKEN, "", 11},
+
+   {NT_INSTRUCTION_TOKEN, EX2_TOKEN, "", 12},
+   {NT_INSTRUCTION_TOKEN, EXP_TOKEN, "", 12},
+   {NT_INSTRUCTION_TOKEN, LG2_TOKEN, "", 12},
+   {NT_INSTRUCTION_TOKEN, LOG_TOKEN, "", 12},
+   {NT_INSTRUCTION_TOKEN, RCP_TOKEN, "", 12},
+   {NT_INSTRUCTION_TOKEN, RSQ_TOKEN, "", 12},
+
+   {NT_INSTRUCTION_TOKEN, POW_TOKEN, "", 13},
+
+   {NT_INSTRUCTION_TOKEN, ADD_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, DP3_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, DP4_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, DPH_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, DST_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, MAX_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, MIN_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, MUL_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, SGE_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, SLT_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, SUB_TOKEN, "", 14},
+   {NT_INSTRUCTION_TOKEN, XPD_TOKEN, "", 14},
+
+   {NT_INSTRUCTION_TOKEN, MAD_TOKEN, "", 15},
+
+   {NT_INSTRUCTION_TOKEN, SWZ_TOKEN, "", 16},
+
+   {NT_ARL_INSTRUCTION_TOKEN, ARL_TOKEN, "", 17},
+
+   {NT_VECTOROP_INSTRUCTION_TOKEN, ABS_TOKEN, "", 18},
+   {NT_VECTOROP_INSTRUCTION_TOKEN, FLR_TOKEN, "", 18},
+   {NT_VECTOROP_INSTRUCTION_TOKEN, FRC_TOKEN, "", 18},
+   {NT_VECTOROP_INSTRUCTION_TOKEN, LIT_TOKEN, "", 18},
+   {NT_VECTOROP_INSTRUCTION_TOKEN, MOV_TOKEN, "", 18},
+
+   {NT_VECTOROP_TOKEN, ABS_TOKEN, "", 19},
+
+   {NT_VECTOROP_TOKEN, FLR_TOKEN, "", 20},
+
+   {NT_VECTOROP_TOKEN, FRC_TOKEN, "", 21},
+
+   {NT_VECTOROP_TOKEN, LIT_TOKEN, "", 22},
+
+   {NT_VECTOROP_TOKEN, MOV_TOKEN, "", 23},
+
+   {NT_SCALAROP_INSTRUCTION_TOKEN, EX2_TOKEN, "", 24},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, EXP_TOKEN, "", 24},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, LG2_TOKEN, "", 24},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, LOG_TOKEN, "", 24},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, RCP_TOKEN, "", 24},
+   {NT_SCALAROP_INSTRUCTION_TOKEN, RSQ_TOKEN, "", 24},
+
+   {NT_SCALAROP_TOKEN, EX2_TOKEN, "", 25},
+
+   {NT_SCALAROP_TOKEN, EXP_TOKEN, "", 26},
+
+   {NT_SCALAROP_TOKEN, LG2_TOKEN, "", 27},
+
+   {NT_SCALAROP_TOKEN, LOG_TOKEN, "", 28},
+
+   {NT_SCALAROP_TOKEN, RCP_TOKEN, "", 29},
+
+   {NT_SCALAROP_TOKEN, RSQ_TOKEN, "", 30},
+
+   {NT_BINSCOP_INSTRUCTION_TOKEN, POW_TOKEN, "", 31},
+
+   {NT_BINSCOP_INSTRUCTION2_TOKEN, COMMA_TOKEN, "", 32},
+
+   {NT_BINSCOP_TOKEN, POW_TOKEN, "", 33},
+
+   {NT_BINOP_INSTRUCTION_TOKEN, ADD_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, DP3_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, DP4_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, DPH_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, DST_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, MAX_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, MIN_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, MUL_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, SGE_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, SLT_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, SUB_TOKEN, "", 34},
+   {NT_BINOP_INSTRUCTION_TOKEN, XPD_TOKEN, "", 34},
+
+   {NT_BINOP_INSTRUCTION2_TOKEN, COMMA_TOKEN, "", 35},
+
+   {NT_BINOP_TOKEN, ADD_TOKEN, "", 36},
+   {NT_BINOP_TOKEN, DP3_TOKEN, "", 37},
+   {NT_BINOP_TOKEN, DP4_TOKEN, "", 38},
+   {NT_BINOP_TOKEN, DPH_TOKEN, "", 39},
+   {NT_BINOP_TOKEN, DST_TOKEN, "", 40},
+   {NT_BINOP_TOKEN, MAX_TOKEN, "", 41},
+   {NT_BINOP_TOKEN, MIN_TOKEN, "", 42},
+   {NT_BINOP_TOKEN, MUL_TOKEN, "", 43},
+   {NT_BINOP_TOKEN, SGE_TOKEN, "", 44},
+   {NT_BINOP_TOKEN, SLT_TOKEN, "", 45},
+   {NT_BINOP_TOKEN, SUB_TOKEN, "", 46},
+   {NT_BINOP_TOKEN, XPD_TOKEN, "", 47},
+
+   {NT_TRIOP_INSTRUCTION_TOKEN, MAD_TOKEN, "", 48},
+   {NT_TRIOP_INSTRUCTION2_TOKEN, COMMA_TOKEN, "", 49},
+   {NT_TRIOP_INSTRUCTION3_TOKEN, COMMA_TOKEN, "", 50},
+
+   {NT_TRIOP_TOKEN, MAD_TOKEN, "", 51},
+   {NT_SWZ_INSTRUCTION_TOKEN, SWZ_TOKEN, "", 52},
+   {NT_SWZ_INSTRUCTION2_TOKEN, COMMA_TOKEN, "", 53},
+
+   {NT_SCALAR_SRC_REG_TOKEN, PLUS_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, MINUS_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, VERTEX_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, STATE_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, PROGRAM_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, LBRACE_TOKEN, "", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, FLOAT_TOKEN, "-1", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, INTEGER_TOKEN, "-1", 54},
+   {NT_SCALAR_SRC_REG_TOKEN, ID_TOKEN, "-1", 54},
+
+   {NT_SWIZZLE_SRC_REG_TOKEN, PLUS_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, MINUS_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, VERTEX_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, STATE_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, PROGRAM_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, LBRACE_TOKEN, "", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, FLOAT_TOKEN, "-1", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, INTEGER_TOKEN, "-1", 55},
+   {NT_SWIZZLE_SRC_REG_TOKEN, ID_TOKEN, "-1", 55},
+
+   {NT_MASKED_DST_REG_TOKEN, ID_TOKEN, "-1", 56},
+   {NT_MASKED_DST_REG_TOKEN, RESULT_TOKEN, "", 56},
+   {NT_MASKED_ADDR_REG_TOKEN, ID_TOKEN, "-1", 57},
+
+   {NT_EXTENDED_SWIZZLE_TOKEN, PLUS_TOKEN, "", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, MINUS_TOKEN, "", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, INTEGER_TOKEN, "0", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, INTEGER_TOKEN, "1", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, ID_TOKEN, "x", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, ID_TOKEN, "y", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, ID_TOKEN, "z", 58},
+   {NT_EXTENDED_SWIZZLE_TOKEN, ID_TOKEN, "w", 58},
+
+   {NT_EXTENDED_SWIZZLE2_TOKEN, COMMA_TOKEN, "", 59},
+
+   {NT_EXT_SWIZ_COMP_TOKEN, PLUS_TOKEN, "", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, MINUS_TOKEN, "", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, INTEGER_TOKEN, "0", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, INTEGER_TOKEN, "1", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, ID_TOKEN, "x", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, ID_TOKEN, "y", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, ID_TOKEN, "z", 60},
+   {NT_EXT_SWIZ_COMP_TOKEN, ID_TOKEN, "w", 60},
+
+   {NT_EXT_SWIZ_SEL_TOKEN, INTEGER_TOKEN, "0", 61},
+   {NT_EXT_SWIZ_SEL_TOKEN, INTEGER_TOKEN, "1", 62},
+   {NT_EXT_SWIZ_SEL_TOKEN, ID_TOKEN, "x", 63},
+   {NT_EXT_SWIZ_SEL_TOKEN, ID_TOKEN, "y", 63},
+   {NT_EXT_SWIZ_SEL_TOKEN, ID_TOKEN, "z", 63},
+   {NT_EXT_SWIZ_SEL_TOKEN, ID_TOKEN, "w", 63},
+
+   /* Special case for 64 - 68 */
+
+   {NT_DST_REG_TOKEN, RESULT_TOKEN, "", 68},
+   {NT_VERTEX_ATTRIB_REG_TOKEN, ID_TOKEN, "-1", 69},
+   {NT_VERTEX_ATTRIB_REG_TOKEN, VERTEX_TOKEN, "", 70},
+   {NT_TEMPORARY_REG_TOKEN, ID_TOKEN, "-1", 71},
+
+   /* Special case for 72 - 73 */
+
+   {NT_PROG_PARAM_REG_TOKEN, STATE_TOKEN, "", 74},
+   {NT_PROG_PARAM_REG_TOKEN, PROGRAM_TOKEN, "", 74},
+   {NT_PROG_PARAM_REG_TOKEN, LBRACE_TOKEN, "", 74},
+   {NT_PROG_PARAM_REG_TOKEN, FLOAT_TOKEN, "-1", 74},
+
+   {NT_PROG_PARAM_SINGLE_TOKEN, ID_TOKEN, "-1", 75},
+   {NT_PROG_PARAM_ARRAY_TOKEN, ID_TOKEN, "-1", 76},
+   {NT_PROG_PARAM_ARRAY_MEM_TOKEN, INTEGER_TOKEN, "-1", 77},
+   {NT_PROG_PARAM_ARRAY_MEM_TOKEN, ID_TOKEN, "-1", 78},
+   {NT_PROG_PARAM_ARRAY_ABS_TOKEN, INTEGER_TOKEN, "-1", 79},
+   {NT_PROG_PARAM_ARRAY_REL_TOKEN, ID_TOKEN, "-1", 80},
+
+   {NT_ADDR_REG_REL_OFFSET_TOKEN, RBRACKET_TOKEN, "", 81},
+   {NT_ADDR_REG_REL_OFFSET_TOKEN, PLUS_TOKEN, "", 82},
+   {NT_ADDR_REG_REL_OFFSET_TOKEN, MINUS_TOKEN, "", 83},
+   {NT_ADDR_REG_POS_OFFSET_TOKEN, INTEGER_TOKEN, "-1", 84},
+   {NT_ADDR_REG_NEG_OFFSET_TOKEN, INTEGER_TOKEN, "-1", 85},
+
+
+   {NT_VERTEX_RESULT_REG_TOKEN, ID_TOKEN, "-1", 86},
+   {NT_VERTEX_RESULT_REG_TOKEN, RESULT_TOKEN, "", 87},
+   {NT_ADDR_REG_TOKEN, ID_TOKEN, "-1", 88},
+   {NT_ADDR_COMPONENT_TOKEN, PERIOD_TOKEN, "", 89},
+   {NT_ADDR_WRITE_MASK_TOKEN, PERIOD_TOKEN, "", 90},
+
+   {NT_SCALAR_SUFFIX_TOKEN, PERIOD_TOKEN, "", 91},
+
+   {NT_SWIZZLE_SUFFIX_TOKEN, COMMA_TOKEN, "", 92},
+   {NT_SWIZZLE_SUFFIX_TOKEN, SEMICOLON_TOKEN, "", 92},
+   {NT_SWIZZLE_SUFFIX_TOKEN, PERIOD_TOKEN, "", 317},
+
+   {NT_COMPONENT_TOKEN, ID_TOKEN, "x", 93},
+   {NT_COMPONENT_TOKEN, ID_TOKEN, "y", 94},
+   {NT_COMPONENT_TOKEN, ID_TOKEN, "z", 95},
+   {NT_COMPONENT_TOKEN, ID_TOKEN, "w", 96},
+
+   {NT_OPTIONAL_MASK_TOKEN, PERIOD_TOKEN, "", 97},
+   {NT_OPTIONAL_MASK_TOKEN, COMMA_TOKEN, "", 98},
+
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "x", 99},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "y", 100},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xy", 101},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "z", 102},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xz", 103},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "yz", 104},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xyz", 105},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "w", 106},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xw", 107},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "yw", 108},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xyw", 109},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "zw", 110},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xzw", 111},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "yzw", 112},
+   {NT_OPTIONAL_MASK2_TOKEN, ID_TOKEN, "xyzw", 113},
+
+
+   {NT_NAMING_STATEMENT_TOKEN, ATTRIB_TOKEN, "", 114},
+   {NT_NAMING_STATEMENT_TOKEN, PARAM_TOKEN, "", 115},
+   {NT_NAMING_STATEMENT_TOKEN, TEMP_TOKEN, "", 116},
+   {NT_NAMING_STATEMENT_TOKEN, ADDRESS_TOKEN, "", 117},
+   {NT_NAMING_STATEMENT_TOKEN, OUTPUT_TOKEN, "", 118},
+   {NT_NAMING_STATEMENT_TOKEN, ALIAS_TOKEN, "", 119},
+
+   {NT_ATTRIB_STATEMENT_TOKEN, ATTRIB_TOKEN, "", 120},
+   {NT_VTX_ATTRIB_BINDING_TOKEN, VERTEX_TOKEN, "", 121},
+
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "position", 122},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "weight", 123},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "normal", 124},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "color", 125},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "fogcoord", 126},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "texcoord", 127},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "matrixindex", 128},
+   {NT_VTX_ATTRIB_ITEM_TOKEN, ID_TOKEN, "attrib", 129},
+
+   {NT_VTX_ATTRIB_NUM_TOKEN, INTEGER_TOKEN, "-1", 130},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, SEMICOLON_TOKEN, "", 131},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, COMMA_TOKEN, "", 131},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, PERIOD_TOKEN, "", 131},
+   {NT_VTX_OPT_WEIGHT_NUM_TOKEN, LBRACKET_TOKEN, "", 132},
+
+   {NT_VTX_WEIGHT_NUM_TOKEN, INTEGER_TOKEN, "-1", 133},
+   {NT_PARAM_STATEMENT_TOKEN, PARAM_TOKEN, "", 134},
+   {NT_PARAM_STATEMENT2_TOKEN, EQUAL_TOKEN, "", 135},
+   {NT_PARAM_STATEMENT2_TOKEN, LBRACKET_TOKEN, "", 136},
+
+   {NT_OPT_ARRAY_SIZE_TOKEN, RBRACKET_TOKEN, "", 137},
+   {NT_OPT_ARRAY_SIZE_TOKEN, INTEGER_TOKEN, "-1", 138},
+
+   {NT_PARAM_SINGLE_INIT_TOKEN, EQUAL_TOKEN, "", 139},
+   {NT_PARAM_MULTIPLE_INIT_TOKEN, EQUAL_TOKEN, "", 140},
+
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, STATE_TOKEN, "", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, PROGRAM_TOKEN, "", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, PLUS_TOKEN, "", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, MINUS_TOKEN, "", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, FLOAT_TOKEN, "-1", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, INTEGER_TOKEN, "-1", 141},
+   {NT_PARAM_MULT_INIT_LIST_TOKEN, LBRACE_TOKEN, "", 141},
+
+
+   {NT_PARAM_MULT_INIT_LIST2_TOKEN, COMMA_TOKEN, "", 142},
+   {NT_PARAM_MULT_INIT_LIST2_TOKEN, RBRACE_TOKEN, "", 143},
+
+
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, STATE_TOKEN, "", 144},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, PROGRAM_TOKEN, "", 145},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, PLUS_TOKEN, "", 146},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, MINUS_TOKEN, "", 146},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, FLOAT_TOKEN, "-1", 146},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, INTEGER_TOKEN, "-1", 146},
+   {NT_PARAM_SINGLE_ITEM_DECL_TOKEN, LBRACE_TOKEN, "", 146},
+
+
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, STATE_TOKEN, "", 147},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, PROGRAM_TOKEN, "", 148},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, LBRACE_TOKEN, "", 149},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, FLOAT_TOKEN, "-1", 149},
+   {NT_PARAM_SINGLE_ITEM_USE_TOKEN, INTEGER_TOKEN, "-1", 149},
+
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, STATE_TOKEN, "", 150},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, PROGRAM_TOKEN, "", 151},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, PLUS_TOKEN, "", 152},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, MINUS_TOKEN, "", 152},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, FLOAT_TOKEN, "-1", 152},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, INTEGER_TOKEN, "-1", 152},
+   {NT_PARAM_MULTIPLE_ITEM_TOKEN, LBRACE_TOKEN, "", 152},
+
+   {NT_STATE_MULTIPLE_ITEM_TOKEN, STATE_TOKEN, "", 153},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "material", 154},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "light", 155},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "lightmodel", 156},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "lightprod", 157},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "texgen", 158},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "fog", 159},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "clip", 160},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "point", 161},
+   {NT_STATE_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "matrix", 162},
+
+   {NT_FOO_TOKEN, PERIOD_TOKEN, "", 163},
+   {NT_FOO_TOKEN, COMMA_TOKEN, "", 316},
+   {NT_FOO_TOKEN, RBRACE_TOKEN, "", 316},
+   {NT_FOO2_TOKEN, ID_TOKEN, "inverse", 164},
+   {NT_FOO2_TOKEN, ID_TOKEN, "transpose", 164},
+   {NT_FOO2_TOKEN, ID_TOKEN, "invtrans", 164},
+   {NT_FOO2_TOKEN, ID_TOKEN, "row", 165},
+   {NT_FOO3_TOKEN, COMMA_TOKEN, "", 166},
+   {NT_FOO3_TOKEN, RBRACE_TOKEN, "", 166},
+   {NT_FOO3_TOKEN, PERIOD_TOKEN, "", 167},
+
+   {NT_FOO35_TOKEN, INTEGER_TOKEN, "-1", 168},
+   {NT_FOO4_TOKEN, RBRACKET_TOKEN, "", 169},
+   {NT_FOO4_TOKEN, DOTDOT_TOKEN, "", 170},
+
+   {NT_STATE_SINGLE_ITEM_TOKEN, STATE_TOKEN, "", 171},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "material", 172},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "light", 173},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "lightmodel", 174},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "lightprod", 175},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "texgen", 176},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "fog", 177},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "clip", 178},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "point", 179},
+   {NT_STATE_SINGLE_ITEM2_TOKEN, ID_TOKEN, "matrix", 180},
+
+
+   {NT_STATE_MATERIAL_ITEM_TOKEN, ID_TOKEN, "material", 181},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, ID_TOKEN, "ambient", 182},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, ID_TOKEN, "diffuse", 182},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, ID_TOKEN, "specular", 182},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, ID_TOKEN, "emission", 182},
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, ID_TOKEN, "shininess", 182},
+
+   {NT_STATE_MATERIAL_ITEM2_TOKEN, PERIOD_TOKEN, "", 183},
+   {NT_STATE_MAT_PROPERTY_TOKEN, ID_TOKEN, "ambient", 184},
+   {NT_STATE_MAT_PROPERTY_TOKEN, ID_TOKEN, "diffuse", 185},
+   {NT_STATE_MAT_PROPERTY_TOKEN, ID_TOKEN, "specular", 186},
+   {NT_STATE_MAT_PROPERTY_TOKEN, ID_TOKEN, "emission", 187},
+   {NT_STATE_MAT_PROPERTY_TOKEN, ID_TOKEN, "shininess", 188},
+
+
+   {NT_STATE_LIGHT_ITEM_TOKEN, ID_TOKEN, "light", 189},
+   {NT_STATE_LIGHT_ITEM2_TOKEN, RBRACKET_TOKEN, "", 190},
+
+
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "ambient", 191},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "diffuse", 192},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "specular", 193},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "position", 194},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "attenuation", 195},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "spot", 196},
+   {NT_STATE_LIGHT_PROPERTY_TOKEN, ID_TOKEN, "half", 197},
+
+   {NT_STATE_SPOT_PROPERTY_TOKEN, ID_TOKEN, "direction", 198},
+   {NT_STATE_LIGHT_MODEL_ITEM_TOKEN, ID_TOKEN, "lightmodel", 199},
+
+
+   {NT_STATE_LMOD_PROPERTY_TOKEN, PERIOD_TOKEN, "", 200},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, ID_TOKEN, "ambient", 201},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, ID_TOKEN, "scenecolor", 202},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, ID_TOKEN, "front", 203},
+   {NT_STATE_LMOD_PROPERTY2_TOKEN, ID_TOKEN, "back", 203},
+
+
+   {NT_STATE_LIGHT_PROD_ITEM_TOKEN, ID_TOKEN, "lightprod", 204},
+   {NT_STATE_LIGHT_PROD_ITEM15_TOKEN, RBRACKET_TOKEN, "", 205},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, ID_TOKEN, "ambient", 206},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, ID_TOKEN, "diffuse", 206},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, ID_TOKEN, "specular", 206},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, ID_TOKEN, "front", 207},
+   {NT_STATE_LIGHT_PROD_ITEM2_TOKEN, ID_TOKEN, "back", 207},
+
+   {NT_STATE_LPROD_PROPERTY_TOKEN, ID_TOKEN, "ambient", 208},
+   {NT_STATE_LPROD_PROPERTY_TOKEN, ID_TOKEN, "diffuse", 209},
+   {NT_STATE_LPROD_PROPERTY_TOKEN, ID_TOKEN, "specular", 210},
+
+   {NT_STATE_LIGHT_NUMBER_TOKEN, INTEGER_TOKEN, "-1", 211},
+   {NT_STATE_TEX_GEN_ITEM_TOKEN, ID_TOKEN, "texgen", 212},
+   {NT_STATE_TEX_GEN_ITEM2_TOKEN, PERIOD_TOKEN, "", 213},
+   {NT_STATE_TEX_GEN_TYPE_TOKEN, ID_TOKEN, "eye", 214},
+   {NT_STATE_TEX_GEN_TYPE_TOKEN, ID_TOKEN, "object", 215},
+
+
+   {NT_STATE_TEX_GEN_COORD_TOKEN, ID_TOKEN, "s", 216},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, ID_TOKEN, "t", 217},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, ID_TOKEN, "r", 218},
+   {NT_STATE_TEX_GEN_COORD_TOKEN, ID_TOKEN, "q", 219},
+
+   {NT_STATE_FOG_ITEM_TOKEN, ID_TOKEN, "fog", 220},
+
+   {NT_STATE_FOG_PROPERTY_TOKEN, ID_TOKEN, "color", 221},
+   {NT_STATE_FOG_PROPERTY_TOKEN, ID_TOKEN, "params", 222},
+
+   {NT_STATE_CLIP_PLANE_ITEM_TOKEN, ID_TOKEN, "clip", 223},
+   {NT_STATE_CLIP_PLANE_ITEM2_TOKEN, RBRACKET_TOKEN, "", 224},
+   {NT_STATE_CLIP_PLANE_NUM_TOKEN, INTEGER_TOKEN, "-1", 225},
+   {NT_STATE_POINT_ITEM_TOKEN, ID_TOKEN, "point", 226},
+   {NT_STATE_POINT_PROPERTY_TOKEN, ID_TOKEN, "size", 227},
+   {NT_STATE_POINT_PROPERTY_TOKEN, ID_TOKEN, "attenuation", 228},
+
+
+   {NT_STATE_MATRIX_ROW_TOKEN, ID_TOKEN, "matrix", 229},
+   {NT_STATE_MATRIX_ROW15_TOKEN, PERIOD_TOKEN, "", 230},
+   {NT_STATE_MATRIX_ROW2_TOKEN, ID_TOKEN, "row", 231},
+   {NT_STATE_MATRIX_ROW2_TOKEN, ID_TOKEN, "inverse", 232},
+   {NT_STATE_MATRIX_ROW2_TOKEN, ID_TOKEN, "transpose", 232},
+   {NT_STATE_MATRIX_ROW2_TOKEN, ID_TOKEN, "invtrans", 232},
+   {NT_STATE_MATRIX_ROW3_TOKEN, LBRACKET_TOKEN, "", 233},
+
+   {NT_STATE_MAT_MODIFIER_TOKEN, ID_TOKEN, "inverse", 234},
+   {NT_STATE_MAT_MODIFIER_TOKEN, ID_TOKEN, "transpose", 235},
+   {NT_STATE_MAT_MODIFIER_TOKEN, ID_TOKEN, "invtrans", 236},
+   {NT_STATE_MATRIX_ROW_NUM_TOKEN, INTEGER_TOKEN, "-1", 237},
+
+
+   {NT_STATE_MATRIX_NAME_TOKEN, ID_TOKEN, "modelview", 238},
+   {NT_STATE_MATRIX_NAME_TOKEN, ID_TOKEN, "projection", 239},
+   {NT_STATE_MATRIX_NAME_TOKEN, ID_TOKEN, "mvp", 240},
+   {NT_STATE_MATRIX_NAME_TOKEN, ID_TOKEN, "texture", 241},
+   {NT_STATE_MATRIX_NAME_TOKEN, ID_TOKEN, "palette", 242},
+   {NT_STATE_MATRIX_NAME_TOKEN, PROGRAM_TOKEN, "", 243},
+
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN, PERIOD_TOKEN, "", 244},
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN, COMMA_TOKEN, "", 244},
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN, RBRACE_TOKEN, "", 244},
+   {NT_STATE_OPT_MOD_MAT_NUM_TOKEN, LBRACKET_TOKEN, "", 245},
+
+   {NT_STATE_MOD_MAT_NUM_TOKEN, INTEGER_TOKEN, "-1", 246},
+   {NT_STATE_PALETTE_MAT_NUM_TOKEN, INTEGER_TOKEN, "-1", 247},
+   {NT_STATE_PROGRAM_MAT_NUM_TOKEN, INTEGER_TOKEN, "-1", 248},
+
+   {NT_PROGRAM_SINGLE_ITEM_TOKEN, PROGRAM_TOKEN, "", 249},
+   {NT_PROGRAM_SINGLE_ITEM2_TOKEN, ID_TOKEN, "env", 250},
+   {NT_PROGRAM_SINGLE_ITEM2_TOKEN, ID_TOKEN, "local", 251},
+
+
+   {NT_PROGRAM_MULTIPLE_ITEM_TOKEN, PROGRAM_TOKEN, "", 252},
+   {NT_PROGRAM_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "env", 253},
+   {NT_PROGRAM_MULTIPLE_ITEM2_TOKEN, ID_TOKEN, "local", 254},
+   {NT_PROG_ENV_PARAMS_TOKEN, ID_TOKEN, "env", 255},
+   {NT_PROG_ENV_PARAM_NUMS_TOKEN, INTEGER_TOKEN, "-1", 256},
+   {NT_PROG_ENV_PARAM_NUMS2_TOKEN, DOTDOT_TOKEN, "", 257},
+   {NT_PROG_ENV_PARAM_NUMS2_TOKEN, RBRACKET_TOKEN, "", 258},
+   {NT_PROG_ENV_PARAM_TOKEN, ID_TOKEN, "env", 259},
+
+   {NT_PROG_LOCAL_PARAMS_TOKEN, ID_TOKEN, "local", 260},
+   {NT_PROG_LOCAL_PARAM_NUMS_TOKEN, INTEGER_TOKEN, "-1", 261},
+   {NT_PROG_LOCAL_PARAM_NUMS2_TOKEN, DOTDOT_TOKEN, "", 262},
+   {NT_PROG_LOCAL_PARAM_NUMS2_TOKEN, RBRACKET_TOKEN, "", 263},
+   {NT_PROG_LOCAL_PARAM_TOKEN, ID_TOKEN, "local", 264},
+   {NT_PROG_ENV_PARAM_NUM_TOKEN, INTEGER_TOKEN, "-1", 265},
+   {NT_PROG_LOCAL_PARAM_NUM_TOKEN, INTEGER_TOKEN, "-1", 266},
+   {NT_PARAM_CONST_DECL_TOKEN, PLUS_TOKEN, "", 267},
+   {NT_PARAM_CONST_DECL_TOKEN, MINUS_TOKEN, "", 267},
+   {NT_PARAM_CONST_DECL_TOKEN, FLOAT_TOKEN, "-1", 267},
+   {NT_PARAM_CONST_DECL_TOKEN, INTEGER_TOKEN, "-1", 267},
+   {NT_PARAM_CONST_DECL_TOKEN, LBRACE_TOKEN, "", 268},
+
+   {NT_PARAM_CONST_USE_TOKEN, FLOAT_TOKEN, "-1", 269},
+   {NT_PARAM_CONST_USE_TOKEN, INTEGER_TOKEN, "-1", 269},
+   {NT_PARAM_CONST_USE_TOKEN, LBRACE_TOKEN, "", 270},
+
+
+   {NT_PARAM_CONST_SCALAR_DECL_TOKEN, PLUS_TOKEN, "", 271},
+   {NT_PARAM_CONST_SCALAR_DECL_TOKEN, MINUS_TOKEN, "", 271},
+   {NT_PARAM_CONST_SCALAR_DECL_TOKEN, FLOAT_TOKEN, "-1", 271},
+   {NT_PARAM_CONST_SCALAR_DECL_TOKEN, INTEGER_TOKEN, "-1", 271},
+
+   {NT_PARAM_CONST_SCALAR_USE_TOKEN, FLOAT_TOKEN, "-1", 272},
+   {NT_PARAM_CONST_SCALAR_USE_TOKEN, INTEGER_TOKEN, "-1", 272},
+   {NT_PARAM_CONST_VECTOR_TOKEN, LBRACE_TOKEN, "", 273},
+   {NT_PARAM_CONST_VECTOR2_TOKEN, RBRACE_TOKEN, "", 274},
+   {NT_PARAM_CONST_VECTOR2_TOKEN, COMMA_TOKEN, "", 275},
+   {NT_PARAM_CONST_VECTOR3_TOKEN, RBRACE_TOKEN, "", 276},
+   {NT_PARAM_CONST_VECTOR3_TOKEN, COMMA_TOKEN, "", 277},
+   {NT_PARAM_CONST_VECTOR4_TOKEN, RBRACE_TOKEN, "", 278},
+   {NT_PARAM_CONST_VECTOR4_TOKEN, COMMA_TOKEN, "", 279},
+
+   {NT_SIGNED_FLOAT_CONSTANT_TOKEN, PLUS_TOKEN, "", 280},
+   {NT_SIGNED_FLOAT_CONSTANT_TOKEN, MINUS_TOKEN, "", 280},
+   {NT_SIGNED_FLOAT_CONSTANT_TOKEN, FLOAT_TOKEN, "-1", 280},
+   {NT_SIGNED_FLOAT_CONSTANT_TOKEN, INTEGER_TOKEN, "-1", 280},
+
+   {NT_OPTIONAL_SIGN_TOKEN, FLOAT_TOKEN, "-1", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, INTEGER_TOKEN, "0", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, INTEGER_TOKEN, "1", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, INTEGER_TOKEN, "-1", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, ID_TOKEN, "-1", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, STATE_TOKEN, "", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, PROGRAM_TOKEN, "", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, VERTEX_TOKEN, "", 281},
+   {NT_OPTIONAL_SIGN_TOKEN, LBRACE_TOKEN, "", 281},
+
+
+   {NT_OPTIONAL_SIGN_TOKEN, MINUS_TOKEN, "", 282},
+   {NT_OPTIONAL_SIGN_TOKEN, PLUS_TOKEN, "", 283},
+
+   {NT_TEMP_STATEMENT_TOKEN, TEMP_TOKEN, "", 284},
+   {NT_ADDRESS_STATEMENT_TOKEN, ADDRESS_TOKEN, "", 285},
+
+   /* Special case 286-7 */
+
+   {NT_OUTPUT_STATEMENT_TOKEN, OUTPUT_TOKEN, "", 288},
+   {NT_RESULT_BINDING_TOKEN, RESULT_TOKEN, "", 289},
+   {NT_RESULT_BINDING2_TOKEN, ID_TOKEN, "position", 290},
+   {NT_RESULT_BINDING2_TOKEN, ID_TOKEN, "fogcoord", 291},
+   {NT_RESULT_BINDING2_TOKEN, ID_TOKEN, "pointsize", 292},
+   {NT_RESULT_BINDING2_TOKEN, ID_TOKEN, "color", 293},
+   {NT_RESULT_BINDING2_TOKEN, ID_TOKEN, "texcoord", 294},
+
+   {NT_RESULT_COL_BINDING_TOKEN, ID_TOKEN, "color", 295},
+
+   /* Special case 296-7 */
+
+   {NT_RESULT_COL_BINDING3_TOKEN, ID_TOKEN, "front", 298},
+   {NT_RESULT_COL_BINDING3_TOKEN, ID_TOKEN, "back", 299},
+
+   /* Special case 300-301 */
+
+   {NT_RESULT_COL_BINDING5_TOKEN, ID_TOKEN, "primary", 302},
+   {NT_RESULT_COL_BINDING5_TOKEN, ID_TOKEN, "secondary", 303},
+   {NT_OPT_FACE_TYPE2_TOKEN, ID_TOKEN, "front", 304},
+   {NT_OPT_FACE_TYPE2_TOKEN, ID_TOKEN, "back", 305},
+
+   /* Special case 306-7 */
+
+   {NT_OPT_COLOR_TYPE2_TOKEN, ID_TOKEN, "primary", 308},
+   {NT_OPT_COLOR_TYPE2_TOKEN, ID_TOKEN, "secondary", 309},
+
+   {NT_OPT_TEX_COORD_NUM_TOKEN, PERIOD_TOKEN, "", 310},
+   {NT_OPT_TEX_COORD_NUM_TOKEN, SEMICOLON_TOKEN, "", 310},
+   {NT_OPT_TEX_COORD_NUM_TOKEN, COMMA_TOKEN, "", 310},
+   {NT_OPT_TEX_COORD_NUM_TOKEN, RBRACE_TOKEN, "", 310},
+   {NT_OPT_TEX_COORD_NUM_TOKEN, LBRACKET_TOKEN, "", 311},
+
+   {NT_TEX_COORD_NUM_TOKEN, INTEGER_TOKEN, "-1", 312},
+
+   /* Special case for 313 to get aliasing correct */
+
+   {NT_ESTABLISH_NAME_TOKEN, ID_TOKEN, "-1", 314},
+   {NT_ESTABLISHED_NAME_TOKEN, ID_TOKEN, "-1", 315},
+
+   /* Special case for 318-9 */
+};
+
+static GLint nprods = sizeof(ptab) / sizeof(prod_table);
+static GLint nlas = sizeof(latab) / sizeof(look_ahead_table);
+
+/** 
+ * This is a gigantic FSA to recognize the keywords put forth in the
+ * GL_ARB_vertex_program spec. 
+ *
+ * All other tokens are deemed 'identifiers', and shoved into the 
+ * identifier symbol table (as opposed to the GLint and GLfloat symbol tables)
+ *
+ * \param s				The parse state
+ * \param token		The next token seen is returned in this value
+ * \param token_attr	The token attribute for the next token is returned here. This
+ *                    is the index into the approprate symbol table if token is INTEGER_TOKEN,
+ *                    FLOAT_TOKEN, or ID_TOKEN
+ *                   
+ * \return ARB_VP_ERROR on lex error, ARB_VP_SUCESS on sucess
+ */
+static GLint
+get_next_token(parse_state * s, GLint * token, GLint * token_attr)
+{
+   GLubyte curr;
+
+   while (s->start_pos < s->len) {
+      curr = s->str[s->curr_pos];
+
+      switch (s->curr_state) {
+	 /* Default state */
+      case STATE_BASE:
+	 if (IS_WHITESPACE(curr)) {
+	    s->start_pos++;
+	    s->curr_pos++;
+	 }
+	 else {
+	    if (IS_IDCHAR(curr)) {
+	       switch (curr) {
+	       case 'A':
+		  ADV_TO_STATE(STATE_A);
+		  break;
+
+	       case 'D':
+		  ADV_TO_STATE(STATE_D);
+		  break;
+
+	       case 'E':
+		  ADV_TO_STATE(STATE_E);
+		  break;
+
+	       case 'F':
+		  ADV_TO_STATE(STATE_F);
+		  break;
+
+	       case 'L':
+		  ADV_TO_STATE(STATE_L);
+		  break;
+
+	       case 'M':
+		  ADV_TO_STATE(STATE_M);
+		  break;
+
+	       case 'O':
+		  ADV_TO_STATE(STATE_O);
+		  break;
+
+	       case 'P':
+		  ADV_TO_STATE(STATE_P);
+		  break;
+
+	       case 'R':
+		  ADV_TO_STATE(STATE_R);
+		  break;
+
+	       case 'S':
+		  ADV_TO_STATE(STATE_S);
+		  break;
+
+	       case 'T':
+		  ADV_TO_STATE(STATE_T);
+		  break;
+
+	       case 'X':
+		  ADV_TO_STATE(STATE_X);
+		  break;
+
+	       case 'p':
+		  ADV_TO_STATE(STATE_LC_P);
+		  break;
+
+	       case 'r':
+		  ADV_TO_STATE(STATE_LC_R);
+		  break;
+
+	       case 's':
+		  ADV_TO_STATE(STATE_LC_S);
+		  break;
+
+	       case 'v':
+		  ADV_TO_STATE(STATE_LC_V);
+		  break;
+
+	       default:
+		  s->curr_state = 1;
+		  s->start_pos = s->curr_pos;
+		  s->curr_pos++;
+	       }
+	    }
+	    else if (IS_DIGIT(curr)) {
+	       ADV_TO_STATE(STATE_N4);
+	    }
+	    else {
+	       switch (curr) {
+	       case '#':
+		  ADV_TO_STATE(STATE_COMMENT);
+		  break;
+	       case ';':
+		  ADV_AND_FINISH(SEMICOLON_TOKEN);
+		  break;
+	       case ',':
+		  ADV_AND_FINISH(COMMA_TOKEN);
+		  break;
+	       case '+':
+		  ADV_AND_FINISH(PLUS_TOKEN);
+		  break;
+	       case '-':
+		  ADV_AND_FINISH(MINUS_TOKEN);
+		  break;
+	       case '[':
+		  ADV_AND_FINISH(LBRACKET_TOKEN);
+		  break;
+	       case ']':
+		  ADV_AND_FINISH(RBRACKET_TOKEN);
+		  break;
+	       case '{':
+		  ADV_AND_FINISH(LBRACE_TOKEN);
+		  break;
+	       case '}':
+		  ADV_AND_FINISH(RBRACE_TOKEN);
+		  break;
+	       case '=':
+		  ADV_AND_FINISH(EQUAL_TOKEN);
+		  break;
+
+	       case '.':
+		  ADV_TO_STATE(STATE_N1);
+		  break;
+
+	       default:
+		  return ARB_VP_ERROR;
+		  break;
+	       }
+	    }
+	 }
+	 break;
+
+
+	 /* Main identifier state */
+      case STATE_IDENT:
+	 if (IS_CD(curr)) {
+	    s->curr_pos++;
+	 }
+	 else {
+	    *token = ID_TOKEN;
+	    *token_attr =
+	       id_table_add(&s->idents, s->str, s->start_pos, s->curr_pos);
+
+	    s->curr_state = 0;
+	    s->start_pos = s->curr_pos;
+	    return ARB_VP_SUCESS;
+	 }
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the A* keywords
+	  */
+      case STATE_A:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'B':
+	       ADV_TO_STATE(STATE_AB);
+	       break;
+	    case 'D':
+	       ADV_TO_STATE(STATE_AD);
+	       break;
+	    case 'L':
+	       ADV_TO_STATE(STATE_AL);
+	       break;
+	    case 'R':
+	       ADV_TO_STATE(STATE_AR);
+	       break;
+	    case 'T':
+	       ADV_TO_STATE(STATE_AT);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_AB:
+	 ADV_OR_FALLBACK('S', STATE_ABS);
+	 break;
+
+      case STATE_ABS:
+	 FINISH_OR_FALLBACK(ABS_TOKEN);
+	 break;
+
+      case STATE_AD:
+	 ADV_OR_FALLBACK('D', STATE_ADD);
+	 break;
+
+      case STATE_ADD:
+	 if (curr == 'R') {
+	    ADV_TO_STATE(STATE_ADDR);
+	 }
+	 else if (IS_CD(curr)) {
+	    ADV_TO_STATE(STATE_IDENT);
+	 }
+	 else {
+	    FINISH(ADD_TOKEN);
+	 }
+	 break;
+
+      case STATE_ADDR:
+	 ADV_OR_FALLBACK('E', STATE_ADDRE);
+	 break;
+
+      case STATE_ADDRE:
+	 ADV_OR_FALLBACK('S', STATE_ADDRES);
+	 break;
+
+      case STATE_ADDRES:
+	 ADV_OR_FALLBACK('S', STATE_ADDRESS);
+	 break;
+
+      case STATE_ADDRESS:
+	 FINISH_OR_FALLBACK(ADDRESS_TOKEN);
+	 break;
+
+      case STATE_AL:
+	 ADV_OR_FALLBACK('I', STATE_ALI);
+	 break;
+
+      case STATE_ALI:
+	 ADV_OR_FALLBACK('A', STATE_ALIA);
+	 break;
+
+      case STATE_ALIA:
+	 ADV_OR_FALLBACK('S', STATE_ALIAS);
+	 break;
+
+      case STATE_ALIAS:
+	 FINISH_OR_FALLBACK(ALIAS_TOKEN);
+	 break;
+
+      case STATE_AR:
+	 ADV_OR_FALLBACK('L', STATE_ARL);
+	 break;
+
+      case STATE_ARL:
+	 FINISH_OR_FALLBACK(ARL_TOKEN);
+	 break;
+
+      case STATE_AT:
+	 ADV_OR_FALLBACK('T', STATE_ATT);
+	 break;
+
+      case STATE_ATT:
+	 ADV_OR_FALLBACK('R', STATE_ATTR);
+	 break;
+
+      case STATE_ATTR:
+	 ADV_OR_FALLBACK('I', STATE_ATTRI);
+	 break;
+
+      case STATE_ATTRI:
+	 ADV_OR_FALLBACK('B', STATE_ATTRIB);
+	 break;
+
+      case STATE_ATTRIB:
+	 FINISH_OR_FALLBACK(ATTRIB_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the D* keywords
+	  */
+      case STATE_D:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'P':
+	       ADV_TO_STATE(STATE_DP);
+	       break;
+	    case 'S':
+	       ADV_TO_STATE(STATE_DS);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_DP:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case '3':
+	       ADV_TO_STATE(STATE_DP3);
+	       break;
+	    case '4':
+	       ADV_TO_STATE(STATE_DP4);
+	       break;
+	    case 'H':
+	       ADV_TO_STATE(STATE_DPH);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_DP3:
+	 FINISH_OR_FALLBACK(DP3_TOKEN);
+	 break;
+
+      case STATE_DP4:
+	 FINISH_OR_FALLBACK(DP4_TOKEN);
+	 break;
+
+      case STATE_DPH:
+	 FINISH_OR_FALLBACK(DPH_TOKEN);
+	 break;
+
+      case STATE_DS:
+	 ADV_OR_FALLBACK('T', STATE_DST);
+	 break;
+
+      case STATE_DST:
+	 FINISH_OR_FALLBACK(DST_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the E* keywords
+	  */
+      case STATE_E:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'N':
+	       ADV_TO_STATE(STATE_EN);
+	       break;
+	    case 'X':
+	       ADV_TO_STATE(STATE_EX);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_EN:
+	 ADV_OR_FALLBACK('D', STATE_END);
+	 break;
+
+      case STATE_END:
+	 FINISH_OR_FALLBACK(END_TOKEN);
+	 break;
+
+      case STATE_EX:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case '2':
+	       ADV_TO_STATE(STATE_EX2);
+	       break;
+	    case 'P':
+	       ADV_TO_STATE(STATE_EXP);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_EX2:
+	 FINISH_OR_FALLBACK(EX2_TOKEN);
+	 break;
+
+      case STATE_EXP:
+	 FINISH_OR_FALLBACK(EXP_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the F* keywords
+	  */
+      case STATE_F:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'L':
+	       ADV_TO_STATE(STATE_FL);
+	       break;
+	    case 'R':
+	       ADV_TO_STATE(STATE_FR);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_FL:
+	 ADV_OR_FALLBACK('R', STATE_FLR);
+	 break;
+
+      case STATE_FLR:
+	 FINISH_OR_FALLBACK(FLR_TOKEN);
+	 break;
+
+      case STATE_FR:
+	 ADV_OR_FALLBACK('C', STATE_FRC);
+	 break;
+
+      case STATE_FRC:
+	 FINISH_OR_FALLBACK(FRC_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the L* keywords
+	  */
+      case STATE_L:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'G':
+	       ADV_TO_STATE(STATE_LG);
+	       break;
+	    case 'I':
+	       ADV_TO_STATE(STATE_LI);
+	       break;
+	    case 'O':
+	       ADV_TO_STATE(STATE_LO);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_LG:
+	 ADV_OR_FALLBACK('2', STATE_LG2);
+	 break;
+
+      case STATE_LG2:
+	 FINISH_OR_FALLBACK(LG2_TOKEN);
+	 break;
+
+      case STATE_LI:
+	 ADV_OR_FALLBACK('T', STATE_LIT);
+	 break;
+
+      case STATE_LIT:
+	 FINISH_OR_FALLBACK(LIT_TOKEN);
+	 break;
+
+      case STATE_LO:
+	 ADV_OR_FALLBACK('G', STATE_LOG);
+	 break;
+
+      case STATE_LOG:
+	 FINISH_OR_FALLBACK(LOG_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the M* keywords
+	  */
+      case STATE_M:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'A':
+	       ADV_TO_STATE(STATE_MA);
+	       break;
+	    case 'I':
+	       ADV_TO_STATE(STATE_MI);
+	       break;
+	    case 'O':
+	       ADV_TO_STATE(STATE_MO);
+	       break;
+	    case 'U':
+	       ADV_TO_STATE(STATE_MU);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_MA:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'D':
+	       ADV_TO_STATE(STATE_MAD);
+	       break;
+	    case 'X':
+	       ADV_TO_STATE(STATE_MAX);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_MAD:
+	 FINISH_OR_FALLBACK(MAD_TOKEN);
+	 break;
+
+      case STATE_MAX:
+	 FINISH_OR_FALLBACK(MAX_TOKEN);
+	 break;
+
+      case STATE_MI:
+	 ADV_OR_FALLBACK('N', STATE_MIN);
+	 break;
+
+      case STATE_MIN:
+	 FINISH_OR_FALLBACK(MIN_TOKEN);
+	 break;
+
+      case STATE_MO:
+	 ADV_OR_FALLBACK('V', STATE_MOV);
+	 break;
+
+      case STATE_MOV:
+	 FINISH_OR_FALLBACK(MOV_TOKEN);
+	 break;
+
+      case STATE_MU:
+	 ADV_OR_FALLBACK('L', STATE_MUL);
+	 break;
+
+      case STATE_MUL:
+	 FINISH_OR_FALLBACK(MUL_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the O* keywords
+	  */
+      case STATE_O:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'P':
+	       ADV_TO_STATE(STATE_OP);
+	       break;
+	    case 'U':
+	       ADV_TO_STATE(STATE_OU);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_OP:
+	 ADV_OR_FALLBACK('T', STATE_OPT);
+	 break;
+
+      case STATE_OPT:
+	 ADV_OR_FALLBACK('I', STATE_OPTI);
+	 break;
+
+      case STATE_OPTI:
+	 ADV_OR_FALLBACK('O', STATE_OPTIO);
+	 break;
+
+      case STATE_OPTIO:
+	 ADV_OR_FALLBACK('N', STATE_OPTION);
+	 break;
+
+      case STATE_OPTION:
+	 FINISH_OR_FALLBACK(OPTION_TOKEN);
+	 break;
+
+      case STATE_OU:
+	 ADV_OR_FALLBACK('T', STATE_OUT);
+	 break;
+
+      case STATE_OUT:
+	 ADV_OR_FALLBACK('P', STATE_OUTP);
+	 break;
+
+      case STATE_OUTP:
+	 ADV_OR_FALLBACK('U', STATE_OUTPU);
+	 break;
+
+      case STATE_OUTPU:
+	 ADV_OR_FALLBACK('T', STATE_OUTPUT);
+	 break;
+
+      case STATE_OUTPUT:
+	 FINISH_OR_FALLBACK(OUTPUT_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the P* keywords
+	  */
+      case STATE_P:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'A':
+	       ADV_TO_STATE(STATE_PA);
+	       break;
+	    case 'O':
+	       ADV_TO_STATE(STATE_PO);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_PA:
+	 ADV_OR_FALLBACK('R', STATE_PAR);
+	 break;
+
+      case STATE_PAR:
+	 ADV_OR_FALLBACK('A', STATE_PARA);
+	 break;
+
+      case STATE_PARA:
+	 ADV_OR_FALLBACK('M', STATE_PARAM);
+	 break;
+
+      case STATE_PARAM:
+	 FINISH_OR_FALLBACK(PARAM_TOKEN);
+	 break;
+
+      case STATE_PO:
+	 ADV_OR_FALLBACK('W', STATE_POW);
+	 break;
+
+      case STATE_POW:
+	 FINISH_OR_FALLBACK(POW_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the R* keywords
+	  */
+      case STATE_R:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'C':
+	       ADV_TO_STATE(STATE_RC);
+	       break;
+	    case 'S':
+	       ADV_TO_STATE(STATE_RS);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_RC:
+	 ADV_OR_FALLBACK('P', STATE_RCP);
+	 break;
+
+      case STATE_RCP:
+	 FINISH_OR_FALLBACK(RCP_TOKEN);
+	 break;
+
+      case STATE_RS:
+	 ADV_OR_FALLBACK('Q', STATE_RSQ);
+	 break;
+
+      case STATE_RSQ:
+	 FINISH_OR_FALLBACK(RSQ_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the S* keywords
+	  */
+      case STATE_S:
+	 if (IS_CD(curr)) {
+	    switch (curr) {
+	    case 'G':
+	       ADV_TO_STATE(STATE_SG);
+	       break;
+	    case 'L':
+	       ADV_TO_STATE(STATE_SL);
+	       break;
+	    case 'U':
+	       ADV_TO_STATE(STATE_SU);
+	       break;
+	    case 'W':
+	       ADV_TO_STATE(STATE_SW);
+	       break;
+	    default:
+	       ADV_TO_STATE(STATE_IDENT);
+	       break;
+	    }
+	 }
+	 else {
+	    s->curr_state = 1;
+	 }
+	 break;
+
+      case STATE_SG:
+	 ADV_OR_FALLBACK('E', STATE_SGE);
+	 break;
+
+      case STATE_SGE:
+	 FINISH_OR_FALLBACK(SGE_TOKEN);
+	 break;
+
+      case STATE_SL:
+	 ADV_OR_FALLBACK('T', STATE_SLT);
+	 break;
+
+      case STATE_SLT:
+	 FINISH_OR_FALLBACK(SLT_TOKEN);
+	 break;
+
+      case STATE_SU:
+	 ADV_OR_FALLBACK('B', STATE_SUB);
+	 break;
+
+      case STATE_SUB:
+	 FINISH_OR_FALLBACK(SUB_TOKEN);
+	 break;
+
+      case STATE_SW:
+	 ADV_OR_FALLBACK('Z', STATE_SWZ);
+	 break;
+
+      case STATE_SWZ:
+	 FINISH_OR_FALLBACK(SWZ_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the T* keywords
+	  */
+      case STATE_T:
+	 ADV_OR_FALLBACK('E', STATE_TE);
+	 break;
+
+      case STATE_TE:
+	 ADV_OR_FALLBACK('M', STATE_TEM);
+	 break;
+
+      case STATE_TEM:
+	 ADV_OR_FALLBACK('P', STATE_TEMP);
+	 break;
+
+      case STATE_TEMP:
+	 FINISH_OR_FALLBACK(TEMP_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the X* keywords
+	  */
+      case STATE_X:
+	 ADV_OR_FALLBACK('P', STATE_XP);
+	 break;
+
+      case STATE_XP:
+	 ADV_OR_FALLBACK('D', STATE_XPD);
+	 break;
+
+      case STATE_XPD:
+	 FINISH_OR_FALLBACK(XPD_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the p* keywords
+	  */
+      case STATE_LC_P:
+	 ADV_OR_FALLBACK('r', STATE_LC_PR);
+	 break;
+
+      case STATE_LC_PR:
+	 ADV_OR_FALLBACK('o', STATE_LC_PRO);
+	 break;
+
+      case STATE_LC_PRO:
+	 ADV_OR_FALLBACK('g', STATE_LC_PROG);
+	 break;
+
+      case STATE_LC_PROG:
+	 ADV_OR_FALLBACK('r', STATE_LC_PROGR);
+	 break;
+
+      case STATE_LC_PROGR:
+	 ADV_OR_FALLBACK('a', STATE_LC_PROGRA);
+	 break;
+
+      case STATE_LC_PROGRA:
+	 ADV_OR_FALLBACK('m', STATE_LC_PROGRAM);
+	 break;
+
+      case STATE_LC_PROGRAM:
+	 FINISH_OR_FALLBACK(PROGRAM_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the r* keywords
+	  */
+      case STATE_LC_R:
+	 ADV_OR_FALLBACK('e', STATE_LC_RE);
+	 break;
+
+      case STATE_LC_RE:
+	 ADV_OR_FALLBACK('s', STATE_LC_RES);
+	 break;
+
+      case STATE_LC_RES:
+	 ADV_OR_FALLBACK('u', STATE_LC_RESU);
+	 break;
+
+      case STATE_LC_RESU:
+	 ADV_OR_FALLBACK('l', STATE_LC_RESUL);
+	 break;
+
+      case STATE_LC_RESUL:
+	 ADV_OR_FALLBACK('t', STATE_LC_RESULT);
+	 break;
+
+      case STATE_LC_RESULT:
+	 FINISH_OR_FALLBACK(RESULT_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the s* keywords
+	  */
+      case STATE_LC_S:
+	 ADV_OR_FALLBACK('t', STATE_LC_ST);
+	 break;
+
+      case STATE_LC_ST:
+	 ADV_OR_FALLBACK('a', STATE_LC_STA);
+	 break;
+
+      case STATE_LC_STA:
+	 ADV_OR_FALLBACK('t', STATE_LC_STAT);
+	 break;
+
+      case STATE_LC_STAT:
+	 ADV_OR_FALLBACK('e', STATE_LC_STATE);
+	 break;
+
+      case STATE_LC_STATE:
+	 FINISH_OR_FALLBACK(STATE_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the v* keywords
+	  */
+      case STATE_LC_V:
+	 ADV_OR_FALLBACK('e', STATE_LC_VE);
+	 break;
+
+      case STATE_LC_VE:
+	 ADV_OR_FALLBACK('r', STATE_LC_VER);
+	 break;
+
+      case STATE_LC_VER:
+	 ADV_OR_FALLBACK('t', STATE_LC_VERT);
+	 break;
+
+      case STATE_LC_VERT:
+	 ADV_OR_FALLBACK('e', STATE_LC_VERTE);
+	 break;
+
+      case STATE_LC_VERTE:
+	 ADV_OR_FALLBACK('x', STATE_LC_VERTEX);
+	 break;
+
+      case STATE_LC_VERTEX:
+	 FINISH_OR_FALLBACK(VERTEX_TOKEN);
+	 break;
+
+	 /* -----------------------------------------------------
+	  *  Beginning of the number & comment FSAs
+	  */
+      case STATE_N1:
+	 if (curr == '.') {
+	    ADV_TO_STATE(STATE_N2);
+	 }
+	 else if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N3);
+	 }
+	 else {
+	    //ADV_AND_FINISH(PERIOD_TOKEN);                                 
+	    FINISH(PERIOD_TOKEN);
+	 }
+	 break;
+
+      case STATE_N2:
+#if 1
+	 //ADV_AND_FINISH(DOTDOT_TOKEN);
+	 FINISH(DOTDOT_TOKEN);
+#else
+	 FINISH(PERIOD_TOKEN);
+#endif
+	 break;
+
+      case STATE_N3:
+	 if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N3);
+	 }
+	 else if ((curr == 'E') || (curr == 'e')) {
+	    ADV_TO_STATE(STATE_N5);
+	 }
+	 else if (curr == '.') {
+	    /* Blech! we have something like 1.. -> have to backup */
+	    s->curr_pos -= 1;
+	    *token_attr =
+	       int_table_add(&s->ints, s->str, s->start_pos, s->curr_pos);
+	    FINISH(INTEGER_TOKEN);
+	 }
+	 else {
+	    *token_attr =
+	       float_table_add(&s->floats, s->str, s->start_pos, s->curr_pos);
+	    //ADV_AND_FINISH(FLOAT_TOKEN);
+	    FINISH(FLOAT_TOKEN);
+	 }
+	 break;
+
+      case STATE_N4:
+	 if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N4);
+	 }
+	 else if ((curr == 'E') || (curr == 'e')) {
+	    ADV_TO_STATE(STATE_N5);
+	 }
+	 else if (curr == '.') {
+	    ADV_TO_STATE(STATE_N3);
+	 }
+	 else {
+	    *token_attr =
+	       int_table_add(&s->ints, s->str, s->start_pos, s->curr_pos);
+	    //ADV_AND_FINISH(INTEGER_TOKEN);
+	    FINISH(INTEGER_TOKEN);
+	 }
+	 break;
+
+      case STATE_N5:
+	 if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N6);
+	 }
+	 else if ((curr == '+') || (curr == '-')) {
+	    ADV_TO_STATE(STATE_N7)
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+      case STATE_N6:
+	 if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N6);
+	 }
+	 else {
+	    *token_attr =
+	       float_table_add(&s->floats, s->str, s->start_pos, s->curr_pos);
+	    //ADV_AND_FINISH(FLOAT_TOKEN);
+	    FINISH(FLOAT_TOKEN);
+	 }
+	 break;
+
+      case STATE_N7:
+	 if (IS_DIGIT(curr)) {
+	    ADV_TO_STATE(STATE_N6);
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+
+	 break;
+
+      case STATE_COMMENT:
+	 if ((curr == '\n') || (curr == '\r')) {
+	    s->start_pos = s->curr_pos + 1;
+	    s->curr_pos++;
+	    s->curr_state = 0;
+	 }
+	 else {
+	    ADV_TO_STATE(STATE_COMMENT);
+	 }
+      }
+   }
+
+   *token = EOF_TOKEN;
+   return ARB_VP_SUCESS;
+}
+
+/**
+ * This does the same as get_next_token(), but it does not advance the 
+ * position pointers (Err, rather it does, but then it resets them)
+ *
+ * \param s          The parse state
+ * \param token      The next token seen is returned in this value
+ * \param token_attr	The token attribute for the next token is returned here. This
+ *                    is the index into the approprate symbol table if token is INTEGER_TOKEN,
+ *                    FLOAT_TOKEN, or ID_TOKEN
+ * \param how_many   How many tokens to peek ahead
+ *                   
+ * \return ARB_VP_ERROR on lex error, ARB_VP_SUCESS on sucess
+ */
+static GLint
+peek_next_token(parse_state * s, GLint * token, GLint * token_attr,
+		GLint how_many)
+{
+   GLint tmp_state = s->curr_state;
+   GLint tmp_sp = s->start_pos;
+   GLint tmp_cp = s->curr_pos;
+   GLint a, retval;
+
+   for (a = 0; a < how_many; a++) {
+      retval = get_next_token(s, token, token_attr);
+
+      if (retval == ARB_VP_ERROR)
+	 return retval;
+   }
+
+   s->curr_state = tmp_state;
+   s->start_pos = tmp_sp;
+   s->curr_pos = tmp_cp;
+
+   return retval;
+}
+
+/**
+ * Print out the value of a token
+ */
+static void
+debug_token(parse_state * state, GLint t, GLint ta)
+{
+   switch (t) {
+   case EOF_TOKEN:
+      printf("EOF\n");
+      break;
+   case ID_TOKEN:
+      printf("|%s|  ", state->idents.data[ta]);
+      break;
+   case INTEGER_TOKEN:
+      printf("|%d|  ", state->ints.data[ta]);
+      break;
+   case FLOAT_TOKEN:
+      printf("|%f|  ", state->floats.data[ta]);
+      break;
+
+   case ABS_TOKEN:
+      printf("ABS  ");
+      break;
+   case ADD_TOKEN:
+      printf("ADD  ");
+      break;
+   case ADDRESS_TOKEN:
+      printf("ADDRESS  ");
+      break;
+   case ALIAS_TOKEN:
+      printf("ALIAS  ");
+      break;
+   case ARL_TOKEN:
+      printf("ARL  ");
+      break;
+   case ATTRIB_TOKEN:
+      printf("ATTRIB  ");
+      break;
+
+   case DP3_TOKEN:
+      printf("DP3  ");
+      break;
+   case DP4_TOKEN:
+      printf("DP4  ");
+      break;
+   case DPH_TOKEN:
+      printf("DPH  ");
+      break;
+   case DST_TOKEN:
+      printf("DST  ");
+      break;
+
+   case END_TOKEN:
+      printf("END  ");
+      break;
+   case EX2_TOKEN:
+      printf("EX2  ");
+      break;
+   case EXP_TOKEN:
+      printf("EXP  ");
+      break;
+
+   case FLR_TOKEN:
+      printf("FLR  ");
+      break;
+   case FRC_TOKEN:
+      printf("FRC  ");
+      break;
+
+   case LG2_TOKEN:
+      printf("LG2  ");
+      break;
+   case LIT_TOKEN:
+      printf("LIT  ");
+      break;
+   case LOG_TOKEN:
+      printf("LOG  ");
+      break;
+
+   case MAD_TOKEN:
+      printf("MAD  ");
+      break;
+   case MAX_TOKEN:
+      printf("MAX  ");
+      break;
+   case MIN_TOKEN:
+      printf("MIN  ");
+      break;
+   case MOV_TOKEN:
+      printf("MOV  ");
+      break;
+   case MUL_TOKEN:
+      printf("MUL  ");
+      break;
+
+   case OPTION_TOKEN:
+      printf("OPTION  ");
+      break;
+   case OUTPUT_TOKEN:
+      printf("OUTPUT  ");
+      break;
+
+   case PARAM_TOKEN:
+      printf("PARAM  ");
+      break;
+   case POW_TOKEN:
+      printf("POW  ");
+      break;
+
+   case RCP_TOKEN:
+      printf("RCP  ");
+      break;
+   case RSQ_TOKEN:
+      printf("RSQ  ");
+      break;
+
+   case SGE_TOKEN:
+      printf("SGE  ");
+      break;
+   case SLT_TOKEN:
+      printf("SLT  ");
+      break;
+   case SUB_TOKEN:
+      printf("SUB  ");
+      break;
+   case SWZ_TOKEN:
+      printf("SWZ  ");
+      break;
+
+   case TEMP_TOKEN:
+      printf("TEMP  ");
+      break;
+
+   case XPD_TOKEN:
+      printf("XPD  ");
+      break;
+
+   case SEMICOLON_TOKEN:
+      printf(";  ");
+      break;
+   case COMMA_TOKEN:
+      printf(",  ");
+      break;
+   case PLUS_TOKEN:
+      printf("+  ");
+      break;
+   case MINUS_TOKEN:
+      printf("-  ");
+      break;
+   case PERIOD_TOKEN:
+      printf(".  ");
+      break;
+   case DOTDOT_TOKEN:
+      printf("..  ");
+      break;
+   case LBRACKET_TOKEN:
+      printf("[  ");
+      break;
+   case RBRACKET_TOKEN:
+      printf("]  ");
+      break;
+   case LBRACE_TOKEN:
+      printf("{  ");
+      break;
+   case RBRACE_TOKEN:
+      printf("}  ");
+      break;
+   case EQUAL_TOKEN:
+      printf("=  ");
+      break;
+
+   case PROGRAM_TOKEN:
+      printf("program ");
+      break;
+   case RESULT_TOKEN:
+      printf("result ");
+      break;
+   case STATE_TOKEN:
+      printf("state ");
+      break;
+   case VERTEX_TOKEN:
+      printf("vertex ");
+      break;
+   default:
+      printf("Unknown token type %d\n", t);
+   }
+}
+
+/**
+ * Setup the state used by the parser / lex 
+ *
+ * \param str	The program string, with the !!ARBvp1.0 token stripped off
+ * \param len	The lenght of the given string
+ *
+ * \return 		A parse_state struct to keep track of all the things we need while parsing
+ */
+static parse_state *
+parse_state_init(GLubyte * str, GLint len)
+{
+   parse_state *s = (parse_state *) _mesa_malloc(sizeof(parse_state));
+
+   s->str = _mesa_strdup(str);
+   s->len = len;
+   s->curr_pos = 0;
+   s->start_pos = 0;
+
+   s->curr_state = 0;
+
+   s->idents.len = 0;
+   s->idents.data = NULL;
+
+   s->ints.len = 0;
+   s->ints.data = NULL;
+
+   s->floats.len = 0;
+   s->floats.data = NULL;
+   printf("%s\n", s->str);
+
+   s->binds.len = 0;
+   s->binds.type = NULL;
+   s->binds.offset = NULL;
+   s->binds.row = NULL;
+   s->binds.consts = NULL;
+
+   s->arrays.len = 0;
+   s->arrays.num_elements = NULL;
+   s->arrays.data = NULL;
+
+   s->stack_head = NULL;
+   s->stack_free_list = NULL;
+
+   s->pt_head = NULL;
+
+   return s;
+}
+
+/**
+ * This frees all the things we hold while parsing.
+ *
+ * \param s		The struct created by parse_state_init()
+ */
+static void
+parse_state_cleanup(parse_state * s)
+{
+   GLint a;
+   token_list *tl, *next;
+
+   /* Free our copy of the string [Mesa has its own] */
+   _mesa_free(s->str);
+
+   /* Free all the tables ident, int, float, bind, mat */
+   _mesa_free(s->idents.type);
+   _mesa_free(s->idents.attr);
+   for (a = 0; a < s->idents.len; a++)
+      _mesa_free(s->idents.data[a]);
+
+   _mesa_free(s->ints.data);
+   _mesa_free(s->floats.data);
+
+   _mesa_free(s->arrays.num_elements);
+   for (a = 0; a < s->arrays.len; a++)
+      _mesa_free(s->arrays.data[a]);
+
+   _mesa_free(s->binds.type);
+   _mesa_free(s->binds.offset);
+   _mesa_free(s->binds.row);
+   _mesa_free(s->binds.num_rows);
+   _mesa_free(s->binds.reg_num);
+#if 0
+   for (a = 0; a < s->binds.len; a++) {
+      printf("6: %d/%d\n", a, s->binds.len - 1);
+      _mesa_free(s->binds.consts[a]);
+   }
+#endif
+
+   /* Free the stack */
+   tl = s->stack_head;
+   while (tl) {
+      next = tl->next;
+      free(tl);
+      tl = next;
+   }
+   tl = s->stack_free_list;
+   while (tl) {
+      next = tl->next;
+      free(tl);
+      tl = next;
+   }
+   printf("freed stack free list\n");
+
+#if 0
+   /* Free the parse tree */
+   parse_tree_free_children(s->pt_head);
+   printf("freed parse_tree\n");
+#endif
+   free(s);
+   printf("freed state\n");
+}
+
+/**
+ *	Alloc a new node for a parse tree.
+ *
+ *	\return	An empty node to fill and stick into the parse tree
+ */
+static parse_tree_node *
+parse_tree_node_init(void)
+{
+   GLint a;
+   parse_tree_node *pt;
+
+   pt = (parse_tree_node *) _mesa_malloc(sizeof(parse_tree_node));
+   pt->tok = -1;
+   pt->tok_attr = -1;
+   pt->is_terminal = 0;
+   pt->prod_applied = -1;
+
+   for (a = 0; a < 4; a++)
+      pt->children[a] = NULL;
+
+   return pt;
+}
+
+/**
+ * We maintain a stack of nonterminals used for predictive parsing. To keep
+ * from thrashing malloc/free, we keep a free list of token_list structs
+ * to be used for this stack. This function is called to refill the free
+ * list, when we try to grab a new token_list struct, and find that there are none
+ * available
+ *
+ * \param s	The parse state
+ */
+static void
+_fill_free_list(parse_state * s)
+{
+   GLint a;
+   token_list *tl;
+
+   if (s->stack_free_list)
+      return;
+
+   for (a = 0; a < 20; a++) {
+      tl = (token_list *) _mesa_malloc(sizeof(token_list));
+
+      tl->next = s->stack_free_list;
+      s->stack_free_list = tl;
+   }
+}
+
+/**
+ * Peek at the head of the nonterminal stack,
+ *
+ * \param s          The parse state
+ * \param token      Return for the nonterminal token on the top of the stack
+ * \param token_attr Return for the the token attribute on the top of the stack
+ *
+ * \return ARB_VP_ERROR on an empty stack [not necessarily a bad thing], else ARB_VP_SUCESS
+ */
+static GLint
+_stack_peek(parse_state * s, GLint * token, GLint * token_attr)
+{
+   if (!s->stack_head) {
+      fprintf(stderr, "ACK! Empty stack on peek!\n");
+      return ARB_VP_ERROR;
+   }
+
+   *token = s->stack_head->tok;
+   *token_attr = s->stack_head->tok_attr;
+
+   return ARB_VP_SUCESS;
+}
+
+/**
+ * Remove the token at the head of the nonterminal stack
+ * \param s          The parse state
+ * \param token      Return for the nonterminal token on the top of the stack
+ * \param token_attr Return for the the token attribute on the top of the stack
+ * \param ptn        Return for a pointer to the place in the parse tree where 
+ *                    the token lives
+ *
+ * \return           ARB_VP_ERROR on an empty stack [not necessarily a bad thing], else ARB_VP_SUCESS
+ */
+static GLint
+_stack_pop(parse_state * s, GLint * token, GLint * token_attr,
+	   parse_tree_node ** ptn)
+{
+   token_list *tl;
+
+   if (!s->stack_head) {
+      fprintf(stderr, "ACK! Empty stack!\n");
+      return ARB_VP_ERROR;
+   }
+
+   *token = s->stack_head->tok;
+   *token_attr = s->stack_head->tok_attr;
+   if (ptn)
+      *ptn = s->stack_head->pt;
+   tl = s->stack_head;
+
+   s->stack_head = tl->next;
+   tl->next = s->stack_free_list;
+   s->stack_free_list = tl;
+
+   return ARB_VP_SUCESS;
+}
+
+/**
+ * Put a token, its attribute, and the the parse tree node where the token is stored, onto
+ * the parse stack.
+ * 
+ * \param s          The parse state
+ * \param token      Return for the nonterminal token on the top of the stack
+ * \param token_attr Return for the the token attribute on the top of the stack
+ * \param ptn        Return for a pointer to the place in the parse tree where 
+ *                    the token lives
+ *
+ * \return           ARB_VP_ERROR on out of memory while allocing more storage for the stack,
+ *                    else ARB_VP_SUCESS
+ */
+static GLint
+_stack_push(parse_state * s, GLint token, GLint token_attr,
+	    parse_tree_node * ptn)
+{
+   token_list *tl;
+
+   if (!s->stack_free_list) {
+      _fill_free_list(s);
+      if (!s->stack_free_list) {
+	 fprintf(stderr, "ACK! Error filling stack free list\n");
+	 return ARB_VP_ERROR;
+      }
+   }
+
+   tl = s->stack_free_list;
+
+   s->stack_free_list = tl->next;
+
+   tl->tok = token;
+   tl->tok_attr = token_attr;
+   tl->pt = ptn;
+   tl->next = s->stack_head;
+
+   s->stack_head = tl;
+
+   return ARB_VP_SUCESS;
+}
+
+/**
+ * Allocate a new entry in the array table
+ *
+ * \param tab   The array table to add a new element too
+ *
+ * \return      The index into the array table where the new element is.
+ */
+static GLint
+array_table_new(array_table * tab)
+{
+   GLint idx;
+   if (tab->len == 0) {
+      tab->num_elements = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->data = (GLint **) _mesa_malloc(sizeof(GLint *));
+      idx = 0;
+   }
+   else {
+      tab->num_elements =
+	 (GLint *) _mesa_realloc(tab->num_elements, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->data =
+	 (GLint **) _mesa_realloc(tab->data, tab->len * sizeof(GLint *),
+				  (tab->len + 1) * sizeof(GLint *));
+      idx = tab->len;
+   }
+
+   tab->len++;
+   tab->num_elements[idx] = 0;
+   tab->data[idx] = NULL;
+
+   return idx;
+}
+
+/**
+ * Add a new element to a array in a array table
+ *
+ * \param tab   The array table
+ * \param idx   The index into the array table of the array we want to append an item onto
+ * \param data  The program parameter that goes into the idx-th array 
+ */
+static void
+array_table_add_data(array_table * tab, GLint idx, GLint data)
+{
+   if ((idx < 0) || (idx >= tab->len)) {
+      printf("Bad matrix index %d!\n", idx);
+      return;
+   }
+
+   if (tab->data[idx] == NULL) {
+      tab->data[idx] = (GLint *) _mesa_malloc(sizeof(GLint));
+   }
+   else {
+      tab->data[idx] =
+	 (GLint *) _mesa_realloc(tab->data[idx],
+				 tab->num_elements[idx] * sizeof(GLint),
+				 (tab->num_elements[idx] +
+				  1) * sizeof(GLint));
+   }
+
+   tab->data[idx][tab->num_elements[idx]] = data;
+   tab->num_elements[idx]++;
+}
+
+
+/**
+ * This adds a new entry into the binding table. 
+ *
+ * \param tab    The binding table
+ * \param type   The type of the state
+ * \param offset For matrix bindings, e.g. MATRIXROWS_MODELVIEW, this gives the matrix number. 
+ *               For PROGRAM_ENV_* and PROGRAM_LOCAL_* bindings, this gives the number of the first parameter
+ *               
+ * \param row    For MATRIXROWS bindings, this is the first row in the matrix we're bound to
+ * \param nrows  For MATRIXROWS bindings, this is the number of rows of the matrix we have. 
+ *               For PROGRAM_ENV/LOCAL bindings, this is the number of parameters in the array we're bound to
+ * \param values For CONSTANT bindings, these are the constant values we're bound to
+ * \return       The index into the binding table where this state is bound
+ */
+static GLint
+binding_table_add(binding_table * tab, GLint type, GLint offset, GLint row,
+		  GLint nrows, GLfloat * values)
+{
+   GLint key, a;
+
+   key = tab->len;
+
+   /* test for existance */
+   for (a = 0; a < tab->len; a++) {
+      if ((tab->type[a] == type) && (tab->offset[a] == offset)
+	  && (tab->row[a] == row) && (tab->num_rows[a] == nrows) &&
+	  (fabs(tab->consts[a][0] - values[0]) < .0001) &&
+	  (fabs(tab->consts[a][1] - values[1]) < .0001) &&
+	  (fabs(tab->consts[a][2] - values[2]) < .0001) &&
+	  (fabs(tab->consts[a][3] - values[3]) < .0001))
+	 return a;
+   }
+
+   if (tab->len == 0) {
+      tab->type = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->offset = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->row = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->num_rows = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->consts = (GLfloat **) _mesa_malloc(sizeof(GLfloat *));
+      tab->consts[0] = (GLfloat *) _mesa_malloc(4 * sizeof(GLfloat));
+      tab->reg_num = (GLint *) _mesa_malloc(sizeof(GLint));
+   }
+   else {
+      tab->type =
+	 (GLint *) _mesa_realloc(tab->type, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->offset =
+	 (GLint *) _mesa_realloc(tab->offset, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->row =
+	 (GLint *) _mesa_realloc(tab->row, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->num_rows =
+	 (GLint *) _mesa_realloc(tab->num_rows, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->consts =
+	 (GLfloat **) _mesa_realloc(tab->consts, tab->len * sizeof(GLfloat),
+				    (tab->len + 1) * sizeof(GLfloat *));
+      tab->consts[tab->len] = (GLfloat *) _mesa_malloc(4 * sizeof(GLfloat));
+      tab->reg_num =
+	 (GLint *) _mesa_realloc(tab->reg_num, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+   }
+
+   tab->type[key] = type;
+   tab->offset[key] = offset;
+   tab->row[key] = row;		//key;
+   tab->num_rows[key] = nrows;
+   tab->reg_num[key] = 0;
+   _mesa_memcpy(tab->consts[key], values, 4 * sizeof(GLfloat));
+   tab->len++;
+
+   return key;
+}
+
+/** 
+ * Given a string and a start/end point, add a string into the float
+ * symbol table (and convert it into a float)
+ *
+ * If we already have this GLfloat in the table, don't bother
+ * adding another, just return the key to the existing one
+ *
+ * \param tab     The float table
+ * \param str     The string containing the float
+ * \param start   The starting position of the float in str
+ * \param end     The ending position of the float in str
+ *
+ * \return        The index of the float, after we insert it, in the float table
+ */
+static GLint
+float_table_add(float_table * tab, GLubyte * str, GLint start, GLint end)
+{
+   GLint key, a;
+   GLubyte *newstr;
+
+   key = tab->len;
+
+   newstr = (GLubyte *) _mesa_malloc(end - start + 2);
+   _mesa_memset(newstr, 0, end - start + 2);
+   _mesa_memcpy(newstr, str + start, end - start);
+
+   /* test for existance */
+   for (a = 0; a < tab->len; a++) {
+      if (tab->data[a] == atof(newstr)) {
+	 _mesa_free(newstr);
+	 return a;
+      }
+   }
+
+   if (tab->len == 0) {
+      tab->data = (GLdouble *) _mesa_malloc(sizeof(GLdouble));
+   }
+   else {
+      tab->data =
+	 (GLdouble *) _mesa_realloc(tab->data, tab->len * sizeof(GLdouble),
+				    (tab->len + 1) * sizeof(GLdouble));
+   }
+
+   tab->data[key] = atof(newstr);
+   tab->len++;
+
+   _mesa_free(newstr);
+   return key;
+}
+
+/** 
+ * Given a string and a start/end point, add a string into the int
+ * symbol table (and convert it into a int)
+ *
+ * If we already have this int in the table, don't bother
+ * adding another, just return the key to the existing one
+ *
+ * \param tab     The int table
+ * \param str     The string containing the int
+ * \param start   The starting position of the int in str
+ * \param end     The ending position of the int in str
+ *
+ * \return        The index of the int, after we insert it, in the int table
+ */
+static GLint
+int_table_add(int_table * tab, GLubyte * str, GLint start, GLint end)
+{
+   GLint key, a;
+   GLubyte *newstr;
+
+   key = tab->len;
+
+   newstr = (GLubyte *) _mesa_malloc(end - start + 2);
+   _mesa_memset(newstr, 0, end - start + 2);
+   _mesa_memcpy(newstr, str + start, end - start);
+
+   for (a = 0; a < tab->len; a++) {
+      if (tab->data[a] == _mesa_atoi(newstr)) {
+	 _mesa_free(newstr);
+	 return a;
+      }
+   }
+
+   if (tab->len == 0) {
+      tab->data = (GLint *) _mesa_malloc(sizeof(GLint));
+   }
+   else {
+      tab->data =
+	 (GLint *) _mesa_realloc(tab->data, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+   }
+
+   tab->data[key] = _mesa_atoi(newstr);
+   tab->len++;
+
+   _mesa_free(newstr);
+   return key;
+}
+
+/**
+ * Insert an identifier into the identifier symbol table
+ * 
+ * If we already have this id in the table, don't bother
+ * adding another, just return the key to the existing one
+ *
+ * If we already have this id in the table, and it has been
+ * initialized to an ALIAS, return what the alias points
+ * to, not the alias var
+ *
+ * \param tab    The ID table
+ * \param str    The string containing the id
+ * \param start  The position in str where the id begins
+ * \param end    The position in str where the id ends
+ *
+ * \return       either:
+ *                1) The index into the id table where the id is
+ *                2) The index into the id table where the alias of id, if we already have id
+ *                     in the table, and it has been initialized to type ALIAS
+ */
+static GLint
+id_table_add(id_table * tab, GLubyte * str, GLint start, GLint end)
+{
+   GLint key, a;
+   GLubyte *newstr;
+
+   key = tab->len;
+
+   if (tab->len == 0) {
+      tab->data = (GLubyte **) _mesa_malloc(sizeof(GLubyte *));
+      tab->type = (GLint *) _mesa_malloc(sizeof(GLint));
+      tab->attr = (GLint *) _mesa_malloc(sizeof(GLint));
+   }
+   else {
+      tab->data =
+	 (GLubyte **) _mesa_realloc(tab->data, tab->len * sizeof(GLubyte *),
+				    (tab->len + 1) * sizeof(GLubyte *));
+      tab->type =
+	 (GLint *) _mesa_realloc(tab->type, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+      tab->attr =
+	 (GLint *) _mesa_realloc(tab->attr, tab->len * sizeof(GLint),
+				 (tab->len + 1) * sizeof(GLint));
+   }
+
+   //tab->type[key] = TYPE_NONE;
+
+   newstr = (GLubyte *) _mesa_malloc((end - start + 2) * sizeof(GLubyte));
+   _mesa_memset(newstr, 0, end - start + 2);
+   _mesa_memcpy(newstr, str + start, end - start);
+
+   for (a = 0; a < tab->len; a++) {
+      /* aha! we found it in the table */
+      if (!_mesa_strcmp(tab->data[a], newstr)) {
+	 _mesa_free(newstr);
+
+	 key = a;
+	 while ((tab->type[key] == TYPE_ALIAS) && (tab->attr[key] != -1)) {
+	    printf("----------- %s is an alias, renaming to %s\n",
+		   tab->data[key], tab->data[tab->attr[key]]);
+	    key = tab->attr[key];
+	 }
+
+	 return key;
+      }
+   }
+
+   /* oh, we really have a new id */
+   tab->data[key] = newstr;
+   tab->type[key] = TYPE_NONE;
+   tab->attr[key] = -1;
+   tab->len++;
+
+   return key;
+}
+
+//#define SHOW_STEPS 1
+
+
+/**
+ * Apply the specified production number to the parse state. This handles
+ * looking at the production table and sticking new tokens onto the 
+ * parse stack. 
+ *
+ * It also handles the construction of the parse tree
+ *
+ * \param s   The parse state
+ * \param num The production number to apply [the idx in the production table]
+ *
+ */
+static void
+apply_production(parse_state * s, int num)
+{
+   GLint a, str_key, stack_tok, stack_tok_attr;
+   GLint tok, nnptr = 0;
+   parse_tree_node *ptn;
+   parse_tree_node *pt_ptr_new[4];
+
+   _stack_pop(s, &stack_tok, &stack_tok_attr, &ptn);
+   /*printf("apply prod %d\n", num); */
+
+   ptn->prod_applied = num;
+   for (a = 3; a >= 0; a--) {
+      str_key = 0;
+      tok = ptab[num].rhs[a];
+
+      if (tok == NULL_TOKEN)
+	 continue;
+
+      /* If we are pushing an identifier or a number, we need to translate the string literal
+       * in the production table into an entry in the approprate symbol table
+       */
+      if (tok == ID_TOKEN) {
+	 str_key =
+	    id_table_add(&s->idents, ptab[num].key[a], 0,
+			 strlen(ptab[num].key[a]));
+      }
+      else if (tok == INTEGER_TOKEN) {
+	 str_key =
+	    int_table_add(&s->ints, ptab[num].key[a], 0,
+			  strlen(ptab[num].key[a]));
+      }
+      else if (tok == FLOAT_TOKEN) {
+	 str_key =
+	    float_table_add(&s->floats, ptab[num].key[a], 0,
+			    strlen(ptab[num].key[a]));
+      }
+
+      /* "-1" is a wildcard flag, accept any id/float/int */
+      if ((!_mesa_strcmp(ptab[num].key[a], "-1")) &&
+	  ((tok == FLOAT_TOKEN) || (tok == INTEGER_TOKEN)
+	   || (tok == ID_TOKEN))) {
+	 pt_ptr_new[nnptr] = parse_tree_node_init();
+	 pt_ptr_new[nnptr]->is_terminal = 0;
+	 pt_ptr_new[nnptr]->tok = tok;
+	 pt_ptr_new[nnptr]->tok_attr = str_key;
+	 nnptr++;
+	 _stack_push(s, ptab[num].rhs[a], str_key, pt_ptr_new[nnptr - 1]);
+      }
+      else if (tok >= NT_PROGRAM_TOKEN) {
+	 pt_ptr_new[nnptr] = parse_tree_node_init();
+	 pt_ptr_new[nnptr]->is_terminal = 0;
+	 pt_ptr_new[nnptr]->tok = tok;
+	 nnptr++;
+	 _stack_push(s, ptab[num].rhs[a], str_key, pt_ptr_new[nnptr - 1]);
+      }
+      else
+	 _stack_push(s, ptab[num].rhs[a], str_key, NULL);
+   }
+
+   tok = 0;
+   if (ptn) {
+      /*printf("%x %d:[%x %x %x %x]\n", ptn, nnptr, pt_ptr_new[0], pt_ptr_new[1], pt_ptr_new[2], pt_ptr_new[3]); */
+
+      for (a = nnptr - 1; a >= 0; a--) {
+	 ptn->children[tok] = pt_ptr_new[a];
+	 /*printf("%x->children[%d] = %x\n", ptn, tok, pt_ptr_new[a]); */
+	 tok++;
+      }
+   }
+}
+
+/**
+ * Here we initialize a bunch of variables to a given type (e.g. TEMP). 
+ *
+ * We stick the variable type into the 0-th element in the var_queue array, followed by var_queue_size
+ * indicies into the identifier table which designate the variables we are to init.
+ * 
+ * \param s              The parse state
+ * \param var_queue      The queue of variables to initialize. The first element in the array is variable
+ *                        type. It is followed by var_queue_size indicies into the identifier table 
+ *                        who we are supposed to init to type var_queue[0].
+ * \param var_queue_size The number of variables listed in var_queue[].
+ *
+ * \return               ARB_VP_ERROR if we have already initilized a variable in var_queue, otherwise
+ *                        ARB_VP_SUCESS
+ */
+static GLint
+init_vars(parse_state * s, GLint * var_queue, GLint var_queue_size)
+{
+   GLint a;
+
+   a = 1;
+   while (a < var_queue_size) {
+      /* Make sure we haven't already init'd this var. This will
+       * catch multiple definations of the same symbol
+       */
+      if (s->idents.type[var_queue[a]] != TYPE_NONE) {
+	 printf("%s already init'd! (%d)\n", s->idents.data[var_queue[a]],
+		s->idents.type[var_queue[a]]);
+	 return ARB_VP_ERROR;
+      }
+
+      s->idents.type[var_queue[a]] = var_queue[0];
+      s->idents.attr[var_queue[a]] = -1;
+      a++;
+   }
+
+   return ARB_VP_SUCESS;
+}
+
+/**
+ * The main parsing loop. This applies productions and builds the parse tree.
+ *
+ * \param s    The parse state
+ *
+ * \return ARB_VP_ERROR on a parse error, else ARB_VP_SUCESS
+ */
+static GLint
+parse(parse_state * s)
+{
+   GLint input_tok, input_tok_attr;
+   GLint stack_tok, stack_tok_attr;
+   GLint peek_tok, peek_tok_attr, ret;
+   GLint idx, str_key;
+   GLint var_queue_size = 0;
+   GLint *var_queue;
+   parse_tree_node *ptn, *ptn2;
+
+   /* This should be MAX_VAR + 1 */
+   var_queue = (GLint *) _mesa_malloc(1000 * sizeof(int));
+
+   s->stack_head = NULL;
+
+   /* init the system by pushing the start symbol onto the stack */
+   ptn = parse_tree_node_init();
+   ptn->is_terminal = 0;
+   ptn->tok = NT_PROGRAM_TOKEN;
+   s->pt_head = ptn;
+   _stack_push(s, NT_PROGRAM_TOKEN, 0, ptn);
+
+   /* and get the first token */
+   if (get_next_token(s, &input_tok, &input_tok_attr) == ARB_VP_ERROR) {
+      fprintf(stderr, "LEX ERROR!!\n");
+      return ARB_VP_ERROR;
+   }
+
+   while (1) {
+      GLint la, is_nonterm;
+
+      /* If the stack is empty, and we've eaten all the input, we're done */
+      if ((_stack_peek(s, &stack_tok, &stack_tok_attr) == ARB_VP_ERROR) &&
+	  (input_tok == EOF_TOKEN))
+	 break;
+
+#ifdef SHOW_STEPS
+      printf("stack: %d input: ", stack_tok);
+      debug_token(s, input_tok, input_tok_attr);
+      printf("\n");
+#endif
+
+      /* We [may] have a non-terminal on top of the stack, apply
+       * productions!
+       */
+      switch (stack_tok) {
+	 /* Special case non-terminals */
+
+	 /* productions 64-66 */
+      case NT_SRC_REG_TOKEN:
+	 if ((input_tok == VERTEX_TOKEN) ||
+	     ((input_tok == ID_TOKEN)
+	      && (s->idents.type[input_tok_attr] == TYPE_ATTRIB))) {
+	    apply_production(s, 64);
+	 }
+	 else
+	    if ((input_tok == ID_TOKEN)
+		&& (s->idents.type[input_tok_attr] == TYPE_TEMP)) {
+	    apply_production(s, 65);
+	 }
+	 else
+	    if ((input_tok == STATE_TOKEN) ||
+		(input_tok == PROGRAM_TOKEN) ||
+		(input_tok == LBRACE_TOKEN) ||
+		(input_tok == FLOAT_TOKEN) ||
+		(input_tok == INTEGER_TOKEN) ||
+		((input_tok == ID_TOKEN)
+		 && (s->idents.type[input_tok_attr] == TYPE_PARAM_SINGLE))
+		|| ((input_tok == ID_TOKEN)
+		    && (s->idents.type[input_tok_attr] ==
+			TYPE_PARAM_ARRAY))) {
+	    apply_production(s, 66);
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 67-68 */
+      case NT_DST_REG_TOKEN:
+	 /* We can only write to result.*, TEMP vars, or OUTPUT vars */
+	 if (input_tok == RESULT_TOKEN) {
+	    apply_production(s, 68);
+	 }
+	 else if (input_tok == ID_TOKEN) {
+	    if (s->idents.type[input_tok_attr] == TYPE_TEMP) {
+	       apply_production(s, 67);
+	    }
+	    else if (s->idents.type[input_tok_attr] == TYPE_OUTPUT) {
+	       apply_production(s, 68);
+	    }
+	    else {
+	       return ARB_VP_ERROR;
+	    }
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 72-4 */
+      case NT_PROG_PARAM_REG_TOKEN:
+	 if ((input_tok == ID_TOKEN)
+	     && (s->idents.type[input_tok_attr] == TYPE_PARAM_SINGLE)) {
+	    apply_production(s, 72);
+	 }
+	 else
+	    if ((input_tok == ID_TOKEN)
+		&& (s->idents.type[input_tok_attr] == TYPE_PARAM_ARRAY)) {
+	    apply_production(s, 73);
+	 }
+	 else
+	    if ((input_tok == STATE_TOKEN) ||
+		(input_tok == PROGRAM_TOKEN) ||
+		(input_tok == FLOAT_TOKEN) ||
+		(input_tok == INTEGER_TOKEN) || (input_tok == LBRACE_TOKEN)) {
+	    apply_production(s, 74);
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 286-7 */
+      case NT_VAR_NAME_LIST_TOKEN:
+	 ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+
+	 var_queue[var_queue_size] = input_tok_attr;
+	 var_queue_size++;
+
+	 if ((ret == ARB_VP_ERROR) || (peek_tok != COMMA_TOKEN)) {
+	    apply_production(s, 286);
+
+	    /* Dump the var_queue & assign types */
+	    if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+	       return ARB_VP_ERROR;
+	 }
+	 else {
+	    apply_production(s, 287);
+	 }
+	 break;
+
+	 /* productions 296-7 */
+      case NT_RESULT_COL_BINDING2_TOKEN:
+	 if ((input_tok == SEMICOLON_TOKEN) || (input_tok == COMMA_TOKEN)) {
+	    apply_production(s, 296);
+	 }
+	 else if (input_tok == PERIOD_TOKEN) {
+	    ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	    if ((peek_tok == ID_TOKEN) &&
+		((!_mesa_strcmp(s->idents.data[peek_tok_attr], "back")) ||
+		 (!_mesa_strcmp(s->idents.data[peek_tok_attr], "front")))) {
+	       apply_production(s, 297);
+	    }
+	    else {
+	       apply_production(s, 296);
+	    }
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 300-1 */
+      case NT_RESULT_COL_BINDING4_TOKEN:
+	 if ((input_tok == SEMICOLON_TOKEN) || (input_tok == COMMA_TOKEN)) {
+	    apply_production(s, 300);
+	 }
+	 else if (input_tok == PERIOD_TOKEN) {
+	    ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	    if ((ret == ARB_VP_SUCESS) && (peek_tok == ID_TOKEN) &&
+		((!_mesa_strcmp(s->idents.data[peek_tok_attr], "primary")) ||
+		 (!_mesa_strcmp(s->idents.data[peek_tok_attr], "secondary"))))
+	    {
+	       apply_production(s, 301);
+	    }
+	    else {
+	       apply_production(s, 300);
+	    }
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 306-7 */
+      case NT_OPT_COLOR_TYPE_TOKEN:
+	 if ((input_tok == SEMICOLON_TOKEN) || (input_tok == COMMA_TOKEN)) {
+	    apply_production(s, 307);
+	 }
+	 else if (input_tok == PERIOD_TOKEN) {
+	    ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	    if ((ret == ARB_VP_SUCESS) && (peek_tok == ID_TOKEN) &&
+		((!_mesa_strcmp(s->idents.data[peek_tok_attr], "primary")) ||
+		 (!_mesa_strcmp(s->idents.data[peek_tok_attr], "secondary"))))
+	    {
+	       apply_production(s, 306);
+	    }
+	    else {
+	       apply_production(s, 307);
+	    }
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* production 313 -- Do this so we can mangle IDs as they are 
+	  *                                              added into the ID table for the lex
+	  */
+      case NT_ALIAS_STATEMENT_TOKEN:
+	 if (input_tok == ALIAS_TOKEN) {
+	    GLint alias_to;
+
+	    apply_production(s, 313);
+
+	    /* stack ALIAS */
+	    var_queue_size = 1;
+	    var_queue[0] = TYPE_ALIAS;
+	    ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	    var_queue[var_queue_size] = peek_tok_attr;
+	    var_queue_size++;
+
+	    if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+	       return ARB_VP_ERROR;
+
+	    /* Now, peek ahead and see what we are aliasing _to_ */
+	    alias_to = peek_tok_attr;
+	    ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 3);
+	    if (ret == ARB_VP_SUCESS) {
+	       s->idents.attr[alias_to] = peek_tok_attr;
+	    }
+	    else
+	       return ARB_VP_ERROR;
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* productions 314 (ESTABLISH_NAME) duplicates are caught by the ID symbol table */
+
+	 /* productions 315 */
+      case NT_ESTABLISHED_NAME_TOKEN:
+	 if (input_tok == ID_TOKEN) {
+	    if (s->idents.type[input_tok_attr] == TYPE_NONE) {
+	       printf("Trying to use variable %s before initializing!\n",
+		      s->idents.data[input_tok_attr]);
+	       return ARB_VP_ERROR;
+	    }
+	    else {
+	       apply_production(s, 315);
+	    }
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+
+	 /* productions 318-9 */
+      case NT_SWIZZLE_SUFFIX2_TOKEN:
+	 if (strlen(s->idents.data[input_tok_attr]) == 1) {
+	    apply_production(s, 318);
+	 }
+	 else if (strlen(s->idents.data[input_tok_attr]) == 4) {
+	    apply_production(s, 319);
+	 }
+	 else {
+	    return ARB_VP_ERROR;
+	 }
+	 break;
+
+	 /* 4-component swizzle mask -- this is a total hack */
+#define IS_SWZ_CMP(foo) ((foo == 'x') || (foo == 'y') || (foo == 'z') || (foo == 'w'))
+      case NT_COMPONENT4_TOKEN:
+	 {
+	    GLubyte *str = s->idents.data[input_tok_attr];
+
+	    if (IS_SWZ_CMP(str[0]) && IS_SWZ_CMP(str[1]) && IS_SWZ_CMP(str[2])
+		&& IS_SWZ_CMP(str[3])) {
+	       _stack_pop(s, &stack_tok, &stack_tok_attr, &ptn);
+//                                              _stack_push(s, input_tok, input_tok_attr, NULL);
+
+	       ptn2 = parse_tree_node_init();
+	       ptn2->tok = input_tok;
+	       ptn2->tok_attr = input_tok_attr;
+	       ptn2->is_terminal = 1;
+	       ptn->children[0] = ptn2;
+	       _stack_push(s, input_tok, input_tok_attr, ptn2);
+	    }
+	    else {
+	       return ARB_VP_ERROR;
+	    }
+	 }
+	 break;
+
+	 /* Handle general non-terminals using tables, and terminals */
+      default:
+	 is_nonterm = 0;
+	 for (la = 0; la < nlas; la++) {
+	    if (latab[la].lhs != stack_tok)
+	       continue;
+
+	    if (latab[la].la != input_tok)
+	       continue;
+
+	    if (input_tok == ID_TOKEN) {
+	       str_key =
+		  id_table_add(&s->idents, latab[la].la_kw, 0,
+			       strlen(latab[la].la_kw));
+	       if ((str_key != input_tok_attr)
+		   && (_mesa_strcmp(latab[la].la_kw, "-1")))
+		  continue;
+	    }
+	    else if (input_tok == INTEGER_TOKEN) {
+	       if ((s->ints.data[input_tok_attr] !=
+		    _mesa_atoi(latab[la].la_kw))
+		   && (_mesa_atoi(latab[la].la_kw) != -1)) {
+		  continue;
+	       }
+	    }
+	    else if (input_tok == FLOAT_TOKEN) {
+	       if ((s->floats.data[input_tok_attr] != atof(latab[la].la_kw))
+		   && (atof(latab[la].la_kw) != -1))
+		  continue;
+	    }
+	    idx = latab[la].prod_idx;
+
+	    /* Here we stack identifiers onto the var_queue */
+	    switch (idx) {
+	       /* setup ATTRIB */
+	    case 120:
+	       var_queue_size = 1;
+	       var_queue[0] = TYPE_ATTRIB;
+	       ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	       var_queue[var_queue_size] = peek_tok_attr;
+	       var_queue_size++;
+
+	       if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+		  return ARB_VP_ERROR;
+	       break;
+
+	       /* stack PARAM */
+	    case 134:
+	       var_queue_size = 1;
+	       var_queue[0] = TYPE_PARAM;
+
+	       ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	       var_queue[var_queue_size] = peek_tok_attr;
+	       var_queue_size++;
+
+	       break;
+
+	    case 135:
+	       var_queue[0] = TYPE_PARAM_SINGLE;
+
+	       if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+		  return ARB_VP_ERROR;
+	       break;
+
+	    case 136:
+	       var_queue[0] = TYPE_PARAM_ARRAY;
+
+	       if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+		  return ARB_VP_ERROR;
+	       break;
+
+	       /* stack TEMP */
+	    case 284:
+	       var_queue_size = 1;
+	       var_queue[0] = TYPE_TEMP;
+	       break;
+
+	       /* stack ADDRESS */
+	    case 285:
+	       var_queue_size = 1;
+	       var_queue[0] = TYPE_ADDRESS;
+	       break;
+
+	       /* stack OUTPUT */
+	    case 288:
+	       var_queue_size = 1;
+	       var_queue[0] = TYPE_OUTPUT;
+	       ret = peek_next_token(s, &peek_tok, &peek_tok_attr, 1);
+	       var_queue[var_queue_size] = peek_tok_attr;
+	       var_queue_size++;
+
+	       if (init_vars(s, var_queue, var_queue_size) == ARB_VP_ERROR)
+		  return ARB_VP_ERROR;
+	       break;
+
+
+	       /* stack opts for varNameList  -- see above */
+
+	    }
+
+	    /* finally.. we match! apply the production */
+	    if ((idx < 0) || (idx >= nprods)) {
+	       fprintf(stderr,
+		       "Prod IDX of %d in look ahead table [%d] is horked!\n",
+		       idx, la);
+	       exit(1);
+	    }
+
+	    apply_production(s, idx);
+	    is_nonterm = 1;
+	    break;
+	 }
+
+	 if (!is_nonterm) {
+	    if ((stack_tok == EOF_TOKEN) && (s->stack_head == NULL))
+	       return ARB_VP_SUCESS;
+
+	    if ((input_tok == stack_tok) ||
+		((stack_tok == FLOAT_TOKEN)
+		 && (input_tok == INTEGER_TOKEN))) {
+	       /* XXX: Need to check values for int/id/GLfloat tokens here -- yes! */
+
+	       _stack_pop(s, &stack_tok, &stack_tok_attr, &ptn);
+	       if ((ptn)
+		   && ((stack_tok == FLOAT_TOKEN)
+		       || (stack_tok == INTEGER_TOKEN)
+		       || (stack_tok == ID_TOKEN))) {
+		  ptn->is_terminal = 1;
+		  ptn->tok = input_tok;
+		  ptn->tok_attr = input_tok_attr;
+	       }
+
+	       if (get_next_token(s, &input_tok, &input_tok_attr) ==
+		   ARB_VP_ERROR) {
+		  fprintf(stderr, "PARSE ERROR!!\n");
+		  return ARB_VP_ERROR;
+	       }
+	    }
+	    else {
+	       fprintf(stderr, "PARSE ERROR!\n");
+	       return ARB_VP_ERROR;
+	    }
+	 }
+	 break;
+      }
+   }
+
+   return ARB_VP_SUCESS;
+
+
+}
+
+/**
+ * Print out the parse tree from a given point. Just for debugging.
+ *
+ * \param s    The parse state
+ * \param ptn  The root to start printing from
+ */
+static void
+print_parse_tree(parse_state * s, parse_tree_node * ptn)
+{
+   GLint a;
+
+   /* If we're terminal, prGLint and exit */
+   if (ptn->is_terminal) {
+      debug_token(s, ptn->tok, ptn->tok_attr);
+      printf("\n");
+      return;
+   }
+
+   /* Else, recurse on all our children */
+   for (a = 0; a < 4; a++) {
+      if (!ptn->children[a])
+	 return;
+
+      print_parse_tree(s, ptn->children[a]);
+   }
+}
+
+/**
+ * Free all of the children of a given parse tree node. 
+ *
+ * \param ptn    The root node whose children we recursively free
+ */
+static void
+parse_tree_free_children(parse_tree_node * ptn)
+{
+   GLint a;
+
+   if (!ptn)
+      return;
+   if (!ptn->children[0])
+      return;
+
+   for (a = 0; a < 4; a++) {
+      if (ptn->children[a]) {
+	 parse_tree_free_children(ptn->children[a]);
+	 _mesa_free(ptn->children[a]);
+	 ptn->children[a] = NULL;
+      }
+   }
+}
+
+/**
+ * Given the name of a matrix, and a modifier, expand into a binding type.
+ *
+ * names:  0 -- modelview
+ *         1 -- projection
+ *         2 -- mvp
+ *         3 -- texture
+ *         4 -- palette
+ *         5 -- program
+ *
+ * mods:   0 -- normal
+ *         1 -- inverse
+ *         2 -- invtrans
+ *         3 -- transpose
+ *
+ * \param name  The number of the matrix type
+ * \param mod   The number of the matrix modifier
+ *
+ * \return The binding state corresponding to name & mod
+ */
+static GLint
+name_and_mod_to_matrixrows(GLint name, GLint mod)
+{
+   switch (name) {
+   case 0:			/* modelview */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_MODELVIEW;
+      case 1:
+	 return MATRIXROWS_MODELVIEW_INVERSE;
+      case 2:
+	 return MATRIXROWS_MODELVIEW_INVTRANS;
+      case 3:
+	 return MATRIXROWS_MODELVIEW_TRANSPOSE;
+      }
+      break;
+   case 1:			/* projection */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_PROJECTION;
+      case 1:
+	 return MATRIXROWS_PROJECTION_INVERSE;
+      case 2:
+	 return MATRIXROWS_PROJECTION_INVTRANS;
+      case 3:
+	 return MATRIXROWS_PROJECTION_TRANSPOSE;
+      }
+
+      break;
+   case 2:			/* mvp */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_MVP;
+      case 1:
+	 return MATRIXROWS_MVP_INVERSE;
+      case 2:
+	 return MATRIXROWS_MVP_INVTRANS;
+      case 3:
+	 return MATRIXROWS_MVP_TRANSPOSE;
+      }
+
+      break;
+   case 3:			/* texture */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_TEXTURE;
+      case 1:
+	 return MATRIXROWS_TEXTURE_INVERSE;
+      case 2:
+	 return MATRIXROWS_TEXTURE_INVTRANS;
+      case 3:
+	 return MATRIXROWS_TEXTURE_TRANSPOSE;
+      }
+      break;
+   case 4:			/* palette */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_PALETTE;
+      case 1:
+	 return MATRIXROWS_PALETTE_INVERSE;
+      case 2:
+	 return MATRIXROWS_PALETTE_INVTRANS;
+      case 3:
+	 return MATRIXROWS_PALETTE_TRANSPOSE;
+      }
+      break;
+   case 5:			/* program */
+      switch (mod) {
+      case 0:
+	 return MATRIXROWS_PROGRAM;
+      case 1:
+	 return MATRIXROWS_PROGRAM_INVERSE;
+      case 2:
+	 return MATRIXROWS_PROGRAM_INVTRANS;
+      case 3:
+	 return MATRIXROWS_PROGRAM_TRANSPOSE;
+      }
+      break;
+   }
+
+   return 0;
+}
+
+/**
+ * This takes a node in the parse tree for an OPTIONAL_MASK token
+ * being derived into a write mask for a register. 
+ *
+ * This will expand the production number into a 4-component
+ * write mask.
+ *
+ * \param mask_node  The parse tree node for the optional_mask non-termina
+ * \param mask       4-component write mask
+ */
+static void
+get_optional_mask(parse_tree_node * mask_node, GLint * mask)
+{
+   if (mask_node->prod_applied == 97) {
+      switch (mask_node->children[0]->prod_applied) {
+      case 99:			/* x  */
+	 mask[0] = 1;
+	 mask[1] = 0;
+	 mask[2] = 0;
+	 mask[3] = 0;
+	 break;
+
+      case 100:		/* y */
+	 mask[0] = 0;
+	 mask[1] = 1;
+	 mask[2] = 0;
+	 mask[3] = 0;
+	 break;
+
+      case 101:		/* xy */
+	 mask[0] = 1;
+	 mask[1] = 1;
+	 mask[2] = 0;
+	 mask[3] = 0;
+	 break;
+
+      case 102:		/* z */
+	 mask[0] = 0;
+	 mask[1] = 0;
+	 mask[2] = 1;
+	 mask[3] = 0;
+	 break;
+
+      case 103:		/* xz */
+	 mask[0] = 1;
+	 mask[1] = 0;
+	 mask[2] = 1;
+	 mask[3] = 0;
+	 break;
+
+      case 104:		/* yz */
+	 mask[0] = 0;
+	 mask[1] = 1;
+	 mask[2] = 1;
+	 mask[3] = 0;
+	 break;
+
+      case 105:		/* xyz */
+	 mask[0] = 1;
+	 mask[1] = 1;
+	 mask[2] = 1;
+	 mask[3] = 0;
+	 break;
+
+      case 106:		/* w */
+	 mask[0] = 0;
+	 mask[1] = 0;
+	 mask[2] = 0;
+	 mask[3] = 1;
+	 break;
+
+      case 107:		/* xw */
+	 mask[0] = 1;
+	 mask[1] = 0;
+	 mask[2] = 0;
+	 mask[3] = 1;
+	 break;
+
+      case 108:		/* yw */
+	 mask[0] = 0;
+	 mask[1] = 1;
+	 mask[2] = 0;
+	 mask[3] = 1;
+	 break;
+
+      case 109:		/* xyw */
+	 mask[0] = 1;
+	 mask[1] = 1;
+	 mask[2] = 0;
+	 mask[3] = 1;
+	 break;
+
+      case 110:		/* zw */
+	 mask[0] = 0;
+	 mask[1] = 0;
+	 mask[2] = 1;
+	 mask[3] = 1;
+	 break;
+
+      case 111:		/* xzw */
+	 mask[0] = 1;
+	 mask[1] = 0;
+	 mask[2] = 1;
+	 mask[3] = 1;
+	 break;
+
+      case 112:		/* yzw */
+	 mask[0] = 0;
+	 mask[1] = 1;
+	 mask[2] = 1;
+	 mask[3] = 1;
+	 break;
+
+      case 113:		/* xyzw */
+	 mask[0] = 1;
+	 mask[1] = 1;
+	 mask[2] = 1;
+	 mask[3] = 1;
+	 break;
+      }
+   }
+}
+
+/**
+ * Given a MASKED_DST_REG token in a parse tree node, figure out what 
+ * register number and write mask the production results in.
+ *
+ * \param  s         The parse state
+ * \param  mdr       The parse tree node
+ * \param  dest      The destination register number
+ * \param  dest_mask The 4-component write mask
+ */
+static void
+get_masked_dst_reg(parse_state * s, parse_tree_node * mdr, GLint * dest,
+		   GLint * dest_mask)
+{
+   GLint a;
+
+   /* dest is a TEMP variable */
+   if (mdr->children[0]->prod_applied == 67) {
+      a = mdr->children[0]->children[0]->children[0]->children[0]->tok_attr;
+      *dest = s->binds.reg_num[s->idents.attr[a]];
+      printf("dst reg: %d (%s)\n", *dest, s->idents.data[a]);
+   }
+   else {
+      /* dest is a result variable */
+      if (mdr->children[0]->children[0]->prod_applied == 86) {
+	 a = mdr->children[0]->children[0]->children[0]->children[0]->
+	    tok_attr;
+	 *dest = s->binds.reg_num[s->idents.attr[a]];
+	 printf("dest reg: %d (%s)\n", *dest, s->idents.data[a]);
+      }
+      /* dest is an implicit binding to result/output state */
+      else {
+	 a = mdr->children[0]->children[0]->children[0]->tok_attr;
+	 *dest = s->binds.reg_num[a];
+	 printf("dst: %d\n", *dest);
+      }
+   }
+
+   /* mdr->children[1] is the write mask */
+   get_optional_mask(mdr->children[1], dest_mask);
+}
+
+
+/**
+ * Given a parse tree node with a swizzled src token, figure out the swizzle
+ * mask.
+ *
+ * \param s       The parse state
+ * \param ssr     The parse tree node
+ * \param swz     The 4-component swizzle, 0 - x, 1 - y, 2 - z, 3 - w
+ */
+static void
+get_src_swizzle(parse_state * s, parse_tree_node * ssr, GLint * swz)
+{
+   GLint a;
+   GLubyte *c;
+
+   if (ssr->prod_applied == 317) {
+      if (ssr->children[0]->prod_applied == 318) {	/* single component */
+	 switch (ssr->children[0]->children[0]->prod_applied) {
+	 case 93:		/* x */
+	    for (a = 0; a < 4; a++)
+	       swz[a] = 0;
+	    break;
+
+	 case 94:		/* y */
+	    for (a = 0; a < 4; a++)
+	       swz[a] = 1;
+	    break;
+
+	 case 95:		/* z */
+	    for (a = 0; a < 4; a++)
+	       swz[a] = 2;
+	    break;
+
+	 case 96:		/* w */
+	    for (a = 0; a < 4; a++)
+	       swz[a] = 3;
+	    break;
+	 }
+      }
+      else {			/* 4-component */
+
+	 c = s->idents.data[ssr->children[0]->children[0]->children[0]->
+			    tok_attr];
+	 for (a = 0; a < 4; a++) {
+	    switch (c[a]) {
+	    case 'x':
+	       swz[a] = 0;
+	       break;
+	    case 'y':
+	       swz[a] = 1;
+	       break;
+	    case 'z':
+	       swz[a] = 2;
+	       break;
+	    case 'w':
+	       swz[a] = 3;
+	       break;
+	    }
+	 }
+      }
+   }
+}
+
+
+/**
+ * Given a parse tree node for a src register with an optional sign, figure out
+ * what register the src maps to, and what the sign is
+ *
+ * \param s     The parse state
+ * \param ssr   The parse tree node to work from
+ * \param sign  The sign (1 or -1)
+ * \param ssrc  The src register number
+ */
+static void
+get_optional_sign_and_src_reg(parse_state * s, parse_tree_node * ssr,
+			      int *sign, int *ssrc)
+{
+   GLint a;
+
+   /* ssr->children[0] is the optionalSign  */
+   if (ssr->children[0]->prod_applied == 282) {	/* - */
+      *sign = -1;
+   }
+
+   /* ssr->children[1] is the srcReg        */
+
+   /* The src is a vertex attrib */
+   if (ssr->children[1]->prod_applied == 64) {
+      if (ssr->children[1]->children[0]->prod_applied == 69) {	/* variable */
+	 a = ssr->children[1]->children[0]->children[0]->children[0]->
+	    tok_attr;
+	 *ssrc = s->binds.reg_num[s->idents.attr[a]];
+	 printf("src reg: %d (%s)\n", *ssrc, s->idents.data[a]);
+      }
+      else {			/* implicit binding */
+
+	 a = ssr->children[1]->children[0]->children[0]->tok_attr;
+	 *ssrc = s->binds.reg_num[a];
+	 printf("src reg: %d %d (implicit binding)\n",
+		*ssrc, s->binds.type[a]);
+      }
+   }
+   else
+      /* The src is a temp variable */
+   if (ssr->children[1]->prod_applied == 65) {
+      a = ssr->children[1]->children[0]->children[0]->children[0]->tok_attr;
+      *ssrc = s->binds.reg_num[s->idents.attr[a]];
+      printf("src reg: %d (%s)\n", *ssrc, s->idents.data[a]);
+   }
+   /* The src is a param */
+   else {
+      /* We have a single item */
+      if (ssr->children[1]->children[0]->prod_applied == 72) {
+	 a = ssr->children[1]->children[0]->children[0]->children[0]->
+	    children[0]->tok_attr;
+	 *ssrc = s->binds.reg_num[s->idents.attr[a]];
+	 printf("src reg: %d (%s)\n", *ssrc, s->idents.data[a]);
+      }
+      else
+	 /* We have an array of items */
+      if (ssr->children[1]->children[0]->prod_applied == 73) {
+	 a = ssr->children[1]->children[0]->children[0]->children[0]->
+	    children[0]->tok_attr;
+	 *ssrc = s->binds.reg_num[s->idents.attr[a]];
+
+	 /* We have an absolute offset into the array */
+	 if (ssr->children[1]->children[0]->children[1]->prod_applied == 77) {
+	    /* Ok, are array will be layed out fully in registers, so we can compute the reg */
+	    printf("array base: %s\n", s->idents.data[a]);
+	    a = ssr->children[1]->children[0]->children[1]->children[0]->
+	       children[0]->tok_attr;
+	    printf("array absolute offset: %d\n", s->ints.data[a]);
+	    *ssrc += s->ints.data[a];
+	 }
+	 /* Otherwise, we have to grab the offset register */
+	 else {			/* progParamArrayRel */
+
+	    /* XXX: We don't know the offset, so we have to grab the offset register # */
+	 }
+      }
+      /* Otherwise, we have an implicit binding */
+      else {			/* paramSingleItemUse */
+
+	 if (ssr->children[1]->children[0]->children[0]->prod_applied == 148) {	/* programSingleItem */
+	    a = ssr->children[1]->children[0]->children[0]->children[0]->
+	       tok_attr;
+	 }
+	 else {
+	    a = ssr->children[1]->children[0]->children[0]->children[0]->
+	       children[0]->tok_attr;
+	 }
+	 *ssrc = s->binds.reg_num[a];
+	 printf("src reg: %d %d (implicit binding)\n", *ssrc,
+		s->binds.type[a]);
+      }
+   }
+}
+
+
+/**
+ * Figure out what register a src reg is in, as well as the swizzle mask and the 
+ * sign
+ *
+ * \param s    The parse state
+ * \param ssr  The swizzeled src reg parse tree node
+ * \param sign The return value for the sign {1, -1}
+ * \param ssrc The return value for the register number
+ * \param swz  The 4-component swizzle mask
+ */
+static void
+get_swizzle_src_reg(parse_state * s, parse_tree_node * ssr, GLint * sign,
+		    GLint * ssrc, GLint * swz)
+{
+   get_optional_sign_and_src_reg(s, ssr, sign, ssrc);
+
+   /* ssr->children[2] is the swizzleSuffix */
+   get_src_swizzle(s, ssr->children[2], swz);
+}
+
+/**
+ *	Just like get_swizzle_src_reg, but find the scalar value to use from the register instead
+ *	of the swizzle mask
+ *
+ * \param s       The parse state
+ * \param ssr     The swizzeled src reg parse tree node
+ * \param sign    The return value for the sign {1, -1}
+ * \param ssrc    The return value for the register number
+ * \param scalar  The 1-component scalar number
+ */
+static void
+get_scalar_src_reg(parse_state * s, parse_tree_node * ssr, GLint * sign,
+		   GLint * ssrc, GLint * scalar)
+{
+   get_optional_sign_and_src_reg(s, ssr, sign, ssrc);
+
+   /* sn->children[2] is a scalarSuffix  */
+   switch (ssr->children[2]->children[0]->prod_applied) {
+   case 93:
+      *scalar = 0;
+      break;
+   case 94:
+      *scalar = 1;
+      break;
+   case 95:
+      *scalar = 2;
+      break;
+   case 96:
+      *scalar = 3;
+      break;
+   }
+}
+
+/**
+ * Recursivly traverse the parse tree and generate Mesa opcodes 
+ *
+ * \param s    The parse state
+ * \param ptn  The parse tree node to process
+ */
+static void
+parse_tree_generate_opcodes(parse_state * s, parse_tree_node * ptn)
+{
+   GLint a;
+   GLint opcode, dst, src[3];
+   GLint dst_mask[4], src_swz[3][4], src_scalar[2], src_sign[3];
+   parse_tree_node *dn, *sn[3];
+
+   src_sign[0] = src_sign[1] = src_sign[2] = 1;
+   for (a = 0; a < 4; a++) {
+      src_swz[0][a] = a;
+      src_swz[1][a] = a;
+      src_swz[2][a] = a;
+   }
+   src_scalar[0] = src_scalar[1] = src_scalar[2] = 0;
+   dst_mask[0] = dst_mask[1] = dst_mask[2] = dst_mask[3] = 1;
+
+   switch (ptn->prod_applied) {
+   case 17:			/* ARL */
+      opcode = VP_OPCODE_ARL;
+
+      dn = ptn->children[0];
+      sn[0] = ptn->children[1];
+
+      /* dn is a maskedAddrReg */
+      /* dn->children[0] is an addrReg */
+      /* dn->children[1] is an addrWriteMask */
+      /* XXX: do this.. */
+      break;
+
+   case 18:			/* VECTORop */
+      switch (ptn->children[0]->prod_applied) {
+      case 19:			/* ABS */
+	 opcode = VP_OPCODE_ABS;
+	 break;
+      case 20:			/* FLR */
+	 opcode = VP_OPCODE_FLR;
+	 break;
+      case 21:			/* FRC */
+	 opcode = VP_OPCODE_FRC;
+	 break;
+      case 22:			/* LIT */
+	 opcode = VP_OPCODE_LIT;
+	 break;
+      case 23:			/* MOV */
+	 opcode = VP_OPCODE_MOV;
+	 break;
+      }
+      printf("opcode: %d\n", opcode);
+
+      /* dn is a maskedDstReg */
+      dn = ptn->children[1];
+
+      /* sn is a swizzleSrcReg */
+      sn[0] = ptn->children[2];
+
+      get_masked_dst_reg(s, dn, &dst, dst_mask);
+      printf("dst: %d mask: %d %d %d %d\n", dst, dst_mask[0], dst_mask[1],
+	     dst_mask[2], dst_mask[3]);
+
+      get_swizzle_src_reg(s, sn[0], &src_sign[0], &src[0], src_swz[0]);
+
+      printf("src sign: %d reg: %d swz: %d %d %d %d\n",
+	     src_sign[0], src[0], src_swz[0][0], src_swz[0][1], src_swz[0][2],
+	     src_swz[0][3]);
+      break;
+
+   case 24:			/* SCALARop */
+      switch (ptn->children[0]->prod_applied) {
+      case 25:			/* EX2 */
+	 opcode = VP_OPCODE_EX2;
+	 break;
+      case 26:			/* EXP */
+	 opcode = VP_OPCODE_EXP;
+	 break;
+      case 27:			/* LG2 */
+	 opcode = VP_OPCODE_LG2;
+	 break;
+      case 28:			/* LOG */
+	 opcode = VP_OPCODE_LOG;
+	 break;
+      case 29:			/* RCP */
+	 opcode = VP_OPCODE_RCP;
+	 break;
+      case 30:			/* RSQ */
+	 opcode = VP_OPCODE_RSQ;
+	 break;
+      }
+
+      printf("opcode: %d\n", opcode);
+      /* dn is a maskedDstReg */
+      dn = ptn->children[1];
+
+      get_masked_dst_reg(s, dn, &dst, dst_mask);
+      printf("dst: %d mask: %d %d %d %d\n", dst, dst_mask[0], dst_mask[1],
+	     dst_mask[2], dst_mask[3]);
+
+      /* sn is a scalarSrcReg */
+      sn[0] = ptn->children[2];
+
+      get_scalar_src_reg(s, sn[0], &src_sign[0], &src[0], &src_scalar[0]);
+      printf("src sign: %d reg: %d scalar: %d\n", src_sign[0], src[0],
+	     src_scalar[0]);
+      break;
+
+   case 31:			/* BINSC */
+      opcode = VP_OPCODE_POW;
+
+      printf("opcode: %d\n", opcode);
+      /* maskedDstReg */
+      dn = ptn->children[1];
+      get_masked_dst_reg(s, dn, &dst, dst_mask);
+      printf("dst: %d mask: %d %d %d %d\n", dst, dst_mask[0], dst_mask[1],
+	     dst_mask[2], dst_mask[3]);
+
+      /* sn are scalarSrcReg's */
+      sn[0] = ptn->children[2]->children[0];
+      sn[1] = ptn->children[2]->children[1];
+
+      get_scalar_src_reg(s, sn[0], &src_sign[0], &src[0], &src_scalar[0]);
+      get_scalar_src_reg(s, sn[1], &src_sign[1], &src[1], &src_scalar[1]);
+
+      printf("src0 sign: %d reg: %d scalar: %d\n", src_sign[0], src[0],
+	     src_scalar[0]);
+      printf("src1 sign: %d reg: %d scalar: %d\n", src_sign[1], src[1],
+	     src_scalar[1]);
+      break;
+
+
+   case 34:			/* BIN */
+      switch (ptn->children[0]->prod_applied) {
+      case 36:			/* ADD */
+	 opcode = VP_OPCODE_ADD;
+	 break;
+      case 37:			/* DP3 */
+	 opcode = VP_OPCODE_DP3;
+	 break;
+      case 38:			/* DP4 */
+	 opcode = VP_OPCODE_DP4;
+	 break;
+      case 39:			/* DPH */
+	 opcode = VP_OPCODE_DPH;
+	 break;
+      case 40:			/* DST */
+	 opcode = VP_OPCODE_DST;
+	 break;
+      case 41:			/* MAX */
+	 opcode = VP_OPCODE_MAX;
+	 break;
+      case 42:			/* MIN */
+	 opcode = VP_OPCODE_MIN;
+	 break;
+      case 43:			/* MUL */
+	 opcode = VP_OPCODE_MUL;
+	 break;
+      case 44:			/* SGE */
+	 opcode = VP_OPCODE_SGE;
+	 break;
+      case 45:			/* SLT */
+	 opcode = VP_OPCODE_SLT;
+	 break;
+      case 46:			/* SUB */
+	 opcode = VP_OPCODE_SUB;
+	 break;
+      case 47:			/* XPD */
+	 opcode = VP_OPCODE_XPD;
+	 break;
+      }
+
+      printf("opcode: %d\n", opcode);
+
+      /* maskedDstReg */
+      dn = ptn->children[1];
+      get_masked_dst_reg(s, dn, &dst, dst_mask);
+      printf("dst: %d mask: %d %d %d %d\n", dst, dst_mask[0], dst_mask[1],
+	     dst_mask[2], dst_mask[3]);
+
+      /* sn are scalarSrcReg's */
+      sn[0] = ptn->children[2]->children[0];
+      sn[1] = ptn->children[2]->children[1];
+
+      get_swizzle_src_reg(s, sn[0], &src_sign[0], &src[0], src_swz[0]);
+      get_swizzle_src_reg(s, sn[1], &src_sign[1], &src[1], src_swz[1]);
+
+      printf("src0 sign: %d reg: %d swz: %d %d %d %d\n",
+	     src_sign[0], src[0], src_swz[0][0], src_swz[0][1], src_swz[0][2],
+	     src_swz[0][3]);
+      printf("src1 sign: %d reg: %d swz: %d %d %d %d\n", src_sign[1], src[1],
+	     src_swz[1][0], src_swz[1][1], src_swz[1][2], src_swz[1][3]);
+      break;
+
+   case 48:			/* TRI */
+      opcode = VP_OPCODE_MAD;
+
+      printf("opcode: %d\n", opcode);
+
+      /* maskedDstReg */
+      dn = ptn->children[1];
+      get_masked_dst_reg(s, dn, &dst, dst_mask);
+      printf("dst: %d mask: %d %d %d %d\n", dst, dst_mask[0], dst_mask[1],
+	     dst_mask[2], dst_mask[3]);
+
+      /* sn are scalarSrcReg's */
+      sn[0] = ptn->children[2]->children[0];
+      sn[1] = ptn->children[2]->children[1]->children[0];
+      sn[2] = ptn->children[2]->children[1]->children[1];
+
+      get_swizzle_src_reg(s, sn[0], &src_sign[0], &src[0], src_swz[0]);
+      get_swizzle_src_reg(s, sn[1], &src_sign[1], &src[1], src_swz[1]);
+      get_swizzle_src_reg(s, sn[2], &src_sign[2], &src[2], src_swz[2]);
+
+      printf("src0 sign: %d reg: %d swz: %d %d %d %d\n",
+	     src_sign[0], src[0], src_swz[0][0], src_swz[0][1], src_swz[0][2],
+	     src_swz[0][3]);
+      printf("src1 sign: %d reg: %d swz: %d %d %d %d\n", src_sign[1], src[1],
+	     src_swz[1][0], src_swz[1][1], src_swz[1][2], src_swz[1][3]);
+      printf("src2 sign: %d reg: %d swz: %d %d %d %d\n", src_sign[2], src[2],
+	     src_swz[2][0], src_swz[2][1], src_swz[2][2], src_swz[2][3]);
+
+   }
+
+   for (a = 0; a < 4; a++) {
+      if (!ptn->children[a])
+	 return;
+      parse_tree_generate_opcodes(s, ptn->children[a]);
+   }
+}
+
+/**
+ * When we go to examine the parse tree to generate opcodes, things are not exactly pretty to deal with.
+ * Parameters, constants, matricies, attribute bindings, and the like are represented by large numbers
+ * of nodes.
+ *
+ * In order to keep the code generation code cleaner, we make a recursive pass over the parse tree and 'roll up' these deep
+ * derivations of the attribs, and replace them with a single token, BINDING_TOKEN. The token attribute for 
+ * BINDING_TOKEN is a index in the 'binding table' where all the relavant info on the chunk of state is stored, 
+ * e.g its type.
+ *
+ * For example, the string 'vertex.color.secondary' is represented by 4 productions, and 4 nodes in the parse
+ * tree. The token at the root of this derivation is NT_VTX_ATTRIB_BINDING_TOKEN. After this folding, 
+ * the token at the root is BINDING_TOKEN, and s->binds[token_attr_at_the_root].type = ATTRIB_COLOR_SECONDARY.
+ *
+ * \param s    The parse state
+ * \param ptn  The root parse tree node to start folding bindings 
+ */
+static void
+parse_tree_fold_bindings(parse_state * s, parse_tree_node * ptn)
+{
+   GLint a, b;
+   GLint eat_children, bind_type, bind_idx, bind_row, bind_nrows;
+   GLfloat bind_vals[4];
+   parse_tree_node *ptmp;
+
+   eat_children = 0;
+   bind_row = 0;
+   bind_nrows = 1;
+   bind_vals[0] = bind_vals[1] = bind_vals[2] = bind_vals[3];
+   switch (ptn->prod_applied) {
+      /* vertex */
+   case 121:
+      eat_children = 1;
+      bind_idx = 0;
+      switch (ptn->children[0]->prod_applied) {
+      case 122:		/* position */
+	 bind_type = ATTRIB_POSITION;
+	 break;
+      case 123:		/* weight */
+	 bind_type = ATTRIB_WEIGHT;
+	 if (ptn->children[0]->children[0]->prod_applied == 132) {
+	    bind_idx =
+	       s->ints.data[ptn->children[0]->children[0]->children[0]->
+			    children[0]->tok_attr];
+	 }
+	 break;
+      case 124:		/* normal */
+	 bind_type = ATTRIB_NORMAL;
+	 break;
+      case 125:		/* color */
+	 bind_type = ATTRIB_COLOR_PRIMARY;
+	 if (ptn->children[0]->children[0]->prod_applied == 306) {
+	    if (ptn->children[0]->children[0]->children[0]->prod_applied ==
+		309)
+	       bind_type = ATTRIB_COLOR_SECONDARY;
+	 }
+	 break;
+      case 126:		/* fogcoord */
+	 bind_type = ATTRIB_FOGCOORD;
+	 break;
+      case 127:		/* texcoord */
+	 bind_type = ATTRIB_TEXCOORD;
+	 if (ptn->children[0]->children[0]->prod_applied == 311) {
+	    bind_idx =
+	       s->ints.data[ptn->children[0]->children[0]->children[0]->
+			    children[0]->tok_attr];
+	 }
+	 break;
+      case 128:		/* matrixindex */
+	 bind_type = ATTRIB_MATRIXINDEX;
+	 bind_idx =
+	    s->ints.data[ptn->children[0]->children[0]->children[0]->
+			 tok_attr];
+	 break;
+      case 129:		/* attrib */
+	 bind_type = ATTRIB_ATTRIB;
+	 bind_idx =
+	    s->ints.data[ptn->children[0]->children[0]->children[0]->
+			 tok_attr];
+	 break;
+      }
+      break;
+
+      /* state */
+   case 154:
+   case 172:			/* material */
+      eat_children = 2;
+      bind_idx = 0;
+      ptmp = ptn->children[0]->children[0];
+
+      a = 0;
+      if (ptmp->prod_applied == 182) {
+	 a = 1;
+	 b = 0;
+      }
+      else
+	 if ((ptmp->prod_applied == 183)
+	     && (ptmp->children[0]->prod_applied == 305)) {
+	 a = 1;
+	 b = 1;
+      }
+
+      /* no explicit face, or explicit front */
+      if (a) {
+	 switch (ptmp->children[b]->prod_applied) {
+	 case 184:		/* ambient */
+	    bind_type = MATERIAL_FRONT_AMBIENT;
+	    break;
+	 case 185:		/* diffuse */
+	    bind_type = MATERIAL_FRONT_DIFFUSE;
+	    break;
+	 case 186:		/* specular */
+	    bind_type = MATERIAL_FRONT_SPECULAR;
+	    break;
+	 case 187:		/* emission */
+	    bind_type = MATERIAL_FRONT_EMISSION;
+	    break;
+	 case 188:		/* shininess */
+	    bind_type = MATERIAL_FRONT_SHININESS;
+	    break;
+	 }
+      }
+      /* has explicit back face */
+      else {
+	 switch (ptmp->children[1]->prod_applied) {
+	 case 184:		/* ambient */
+	    bind_type = MATERIAL_BACK_AMBIENT;
+	    break;
+	 case 185:		/* diffuse */
+	    bind_type = MATERIAL_BACK_DIFFUSE;
+	    break;
+	 case 186:		/* specular */
+	    bind_type = MATERIAL_BACK_SPECULAR;
+	    break;
+	 case 187:		/* emission */
+	    bind_type = MATERIAL_BACK_EMISSION;
+	    break;
+	 case 188:		/* shininess */
+	    bind_type = MATERIAL_BACK_SHININESS;
+	    break;
+	 }
+      }
+      break;
+   case 155:
+   case 173:			/* light */
+      eat_children = 2;
+      bind_idx = 0;
+      printf("FOLDING LIGHT!\n");
+      ptmp = ptn->children[0];
+      bind_idx = s->ints.data[ptmp->children[0]->children[0]->tok_attr];
+      switch (ptmp->children[1]->children[0]->prod_applied) {
+      case 191:		/* ambient */
+	 bind_type = LIGHT_AMBIENT;
+	 break;
+      case 192:		/* diffuse */
+	 bind_type = LIGHT_DIFFUSE;
+	 break;
+      case 193:		/* specular */
+	 bind_type = LIGHT_SPECULAR;
+	 break;
+      case 194:		/* position */
+	 bind_type = LIGHT_POSITION;
+	 break;
+      case 195:		/* attenuation */
+	 bind_type = LIGHT_ATTENUATION;
+	 break;
+      case 196:		/* spot */
+	 bind_type = LIGHT_SPOT_DIRECTION;
+	 break;
+      case 197:		/* half */
+	 bind_type = LIGHT_HALF;
+	 break;
+      }
+      break;
+
+   case 156:
+   case 174:			/* lightmodel */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      switch (ptmp->prod_applied) {
+      case 201:		/* ambient */
+	 bind_type = LIGHTMODEL_AMBIENT;
+	 break;
+      case 202:		/* scenecolor */
+	 bind_type = LIGHTMODEL_FRONT_SCENECOLOR;
+	 break;
+      case 203:		/* foo.scenecolor */
+	 if (ptmp->children[0]->prod_applied == 304)
+	    bind_type = LIGHTMODEL_FRONT_SCENECOLOR;
+	 else
+	    bind_type = LIGHTMODEL_BACK_SCENECOLOR;
+      }
+      break;
+   case 157:
+   case 175:			/* lightprod */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      bind_idx = s->ints.data[ptmp->children[0]->children[0]->tok_attr];
+      /* No explicit face */
+      if (ptmp->children[1]->children[0]->prod_applied == 206) {
+	 a = 1;			/* front */
+	 b = 0;			/* 0-th child */
+      }
+      else
+	 if ((ptmp->children[1]->children[0]->prod_applied == 207) &&
+	     (ptmp->children[1]->children[0]->children[0]->prod_applied ==
+	      304)) {
+	 a = 1;			/* front */
+	 b = 1;			/* 1-th child */
+      }
+      else {
+	 a = 0;
+	 b = 1;
+      }
+      if (a) {
+	 switch (ptmp->children[1]->children[0]->children[b]->prod_applied) {
+	 case 208:		/* ambient */
+	    bind_type = LIGHTPROD_FRONT_AMBIENT;
+	    break;
+	 case 209:		/* diffuse */
+	    bind_type = LIGHTPROD_FRONT_DIFFUSE;
+	    break;
+	 case 210:		/* specular */
+	    bind_type = LIGHTPROD_FRONT_SPECULAR;
+	    break;
+	 }
+      }
+      else {
+	 switch (ptmp->children[1]->children[0]->children[b]->prod_applied) {
+	 case 208:		/* ambient */
+	    bind_type = LIGHTPROD_BACK_AMBIENT;
+	    break;
+	 case 209:		/* diffuse */
+	    bind_type = LIGHTPROD_BACK_DIFFUSE;
+	    break;
+	 case 210:		/* specular */
+	    bind_type = LIGHTPROD_BACK_SPECULAR;
+	    break;
+	 }
+      }
+      break;
+   case 158:
+   case 176:			/* texgen */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      if (ptmp->children[0]->prod_applied == 311)
+	 bind_idx =
+	    s->ints.data[ptmp->children[0]->children[0]->children[0]->
+			 tok_attr];
+      ptmp = ptn->children[0]->children[1];
+      if (ptmp->children[0]->prod_applied == 214)
+	 a = 1;			/* eye */
+      else
+	 a = 0;			/* object */
+      b = ptmp->children[1]->prod_applied - 216;
+      if (a == 1) {
+	 switch (b) {
+	 case 0:
+	    bind_type = TEXGEN_EYE_S;
+	    break;
+	 case 1:
+	    bind_type = TEXGEN_EYE_T;
+	    break;
+	 case 2:
+	    bind_type = TEXGEN_EYE_R;
+	    break;
+	 case 3:
+	    bind_type = TEXGEN_EYE_Q;
+	    break;
+	 }
+      }
+      else {
+	 switch (b) {
+	 case 0:
+	    bind_type = TEXGEN_OBJECT_S;
+	    break;
+	 case 1:
+	    bind_type = TEXGEN_OBJECT_T;
+	    break;
+	 case 2:
+	    bind_type = TEXGEN_OBJECT_R;
+	    break;
+	 case 3:
+	    bind_type = TEXGEN_OBJECT_Q;
+	    break;
+	 }
+      }
+      break;
+   case 159:
+   case 177:			/* fog */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      if (ptmp->children[0]->prod_applied == 221)
+	 bind_type = FOG_COLOR;
+      else
+	 bind_type = FOG_PARAMS;
+      break;
+   case 160:
+   case 178:			/* clip */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      bind_idx = s->ints.data[ptmp->children[0]->children[0]->tok_attr];
+      bind_type = CLIP_PLANE;
+      break;
+   case 161:
+   case 179:			/* point */
+      eat_children = 2;
+      bind_idx = 0;
+
+      ptmp = ptn->children[0];
+      if (ptmp->children[0]->prod_applied == 227)
+	 bind_type = POINT_SIZE;
+      else
+	 bind_type = POINT_ATTENUATION;
+      break;
+
+   case 162:			/* matrix rows/whole matrix */
+      eat_children = 2;
+      bind_idx = 0;
+      {
+	 parse_tree_node *mname;
+	 GLint mod = 0;
+	 GLint name = 0;
+
+	 mname = ptn->children[0];
+	 switch (mname->prod_applied) {
+	 case 238:		/* modelview */
+	    name = 0;
+	    if (mname->children[0]->prod_applied == 245)
+	       bind_idx =
+		  s->ints.data[mname->children[0]->children[0]->children[0]->
+			       tok_attr];
+	    break;
+	 case 239:		/* projection */
+	    name = 1;
+	    break;
+	 case 240:		/* mvp */
+	    name = 2;
+	    break;
+	 case 241:		/* texture */
+	    if (mname->children[0]->prod_applied == 311)
+	       bind_idx =
+		  s->ints.data[mname->children[0]->children[0]->children[0]->
+			       tok_attr];
+	    name = 3;
+	    break;
+	 case 242:		/* palette */
+	    bind_idx =
+	       s->ints.data[mname->children[0]->children[0]->tok_attr];
+	    name = 4;
+	    break;
+	 case 243:		/* program */
+	    bind_idx =
+	       s->ints.data[mname->children[0]->children[0]->tok_attr];
+	    name = 5;
+	    break;
+	 }
+
+	 ptmp = ptn->children[1];
+	 if (ptmp->prod_applied == 316) {
+	    bind_type = name_and_mod_to_matrixrows(name, mod);
+	    bind_row = 0;
+	    bind_nrows = 4;
+	 }
+	 else {
+	    if (ptmp->children[0]->prod_applied == 164) {
+	       switch (ptmp->children[0]->children[0]->prod_applied) {
+	       case 234:	/* inverse */
+		  mod = 1;
+		  break;
+	       case 235:	/* transpose */
+		  mod = 3;
+		  break;
+	       case 236:	/* invtrans */
+		  mod = 2;
+		  break;
+	       }
+	       if (ptmp->children[0]->children[1]->prod_applied == 166) {
+		  bind_type = name_and_mod_to_matrixrows(name, mod);
+		  bind_row = 0;
+		  bind_nrows = 4;
+	       }
+	       else {		/* prod 167 */
+
+		  bind_type = name_and_mod_to_matrixrows(name, mod);
+		  bind_row =
+		     s->ints.data[ptmp->children[0]->children[1]->
+				  children[0]->children[0]->children[0]->
+				  tok_attr];
+		  if (ptmp->children[0]->children[1]->children[0]->
+		      children[1]->prod_applied == 169)
+		     bind_nrows = 1;
+		  else {
+		     bind_nrows =
+			s->ints.data[ptmp->children[0]->children[1]->
+				     children[0]->children[1]->children[0]->
+				     children[0]->tok_attr] - bind_row + 1;
+		  }
+	       }
+	    }
+	    else {		/* prod 165 */
+
+	       bind_type = name_and_mod_to_matrixrows(name, mod);
+
+	       bind_row =
+		  s->ints.data[ptmp->children[0]->children[0]->children[0]->
+			       tok_attr];
+	       if (ptmp->children[0]->children[1]->prod_applied == 169)
+		  bind_nrows = 1;
+	       else
+		  bind_nrows =
+		     s->ints.data[ptmp->children[0]->children[1]->
+				  children[0]->children[0]->tok_attr] -
+		     bind_row + 1;
+	    }
+	 }
+      }
+
+      printf("folding matrixrows: %d %d %d %d\n", bind_type, bind_idx,
+	     bind_row, bind_nrows);
+      break;
+
+   case 180:			/* matrix row */
+      eat_children = 2;
+      bind_idx = 0;
+
+      {
+	 GLint mod;
+	 parse_tree_node *mname, *mrow;
+
+	 ptmp = ptn->children[0];
+	 mname = ptmp->children[0];
+	 mod = 0;
+	 if (ptmp->children[1]->children[0]->prod_applied == 232) {
+	    mrow =
+	       ptmp->children[1]->children[0]->children[1]->children[0]->
+	       children[0];
+	    switch (ptmp->children[1]->children[0]->children[0]->prod_applied) {
+	    case 234:
+	       mod = 1;		/* inverse */
+	       break;
+	    case 235:
+	       mod = 2;		/* transpose */
+	       break;
+	    case 236:
+	       mod = 3;		/* invtrans */
+	       break;
+	    }
+	 }
+	 else {
+	    mrow = ptmp->children[1]->children[0]->children[0]->children[0];
+	 }
+	 bind_row = s->ints.data[mrow->tok_attr];
+
+	 switch (mname->prod_applied) {
+	 case 238:		/* modelview */
+	    if (mname->children[0]->prod_applied == 245) {
+	       bind_idx =
+		  s->ints.data[mname->children[0]->children[0]->children[0]->
+			       tok_attr];
+	    }
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_MODELVIEW;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_MODELVIEW_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_MODELVIEW_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_MODELVIEW_INVTRANS;
+	    }
+	    break;
+
+	 case 239:		/* projection */
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_PROJECTION;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_PROJECTION_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_PROJECTION_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_PROJECTION_INVTRANS;
+	    }
+	    break;
+
+	 case 240:		/* mvp */
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_MVP;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_MVP_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_MVP_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_MVP_INVTRANS;
+	    }
+	    break;
+
+	 case 241:		/* texture */
+	    if (mname->children[0]->prod_applied == 311) {
+	       bind_idx =
+		  s->ints.data[mname->children[0]->children[0]->children[0]->
+			       tok_attr];
+	    }
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_TEXTURE;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_TEXTURE_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_TEXTURE_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_TEXTURE_INVTRANS;
+	    }
+	    break;
+
+	 case 242:		/* palette */
+	    bind_idx =
+	       s->ints.data[mname->children[0]->children[0]->tok_attr];
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_PALETTE;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_PALETTE_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_PALETTE_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_PALETTE_INVTRANS;
+	    }
+	    break;
+
+	 case 243:		/* program */
+	    bind_idx =
+	       s->ints.data[mname->children[0]->children[0]->tok_attr];
+	    switch (mod) {
+	    case 0:
+	       bind_type = MATRIXROW_PROGRAM;
+	       break;
+	    case 1:
+	       bind_type = MATRIXROW_PROGRAM_INVERSE;
+	       break;
+	    case 2:
+	       bind_type = MATRIXROW_PROGRAM_TRANSPOSE;
+	       break;
+	    case 3:
+	       bind_type = MATRIXROW_PROGRAM_INVTRANS;
+	    }
+	    break;
+	 }
+      }
+      break;
+
+      /* program (single) */
+   case 249:
+      eat_children = 1;
+      bind_idx = 0;
+      switch (ptn->children[0]->prod_applied) {
+      case 250:		/* env */
+	 bind_type = PROGRAM_ENV_SINGLE;
+	 break;
+      case 251:		/* local */
+	 bind_type = PROGRAM_LOCAL_SINGLE;
+	 break;
+      }
+      bind_idx =
+	 s->ints.data[ptn->children[0]->children[0]->children[0]->
+		      children[0]->tok_attr];
+      break;
+
+      /* program (multi) */
+   case 252:
+      eat_children = 1;
+      bind_idx = 0;
+      switch (ptn->children[0]->prod_applied) {
+      case 253:		/* env */
+      case 254:		/* local */
+	 if (ptn->children[0]->prod_applied == 253)
+	    bind_type = PROGRAM_ENV_MULTI;
+	 else
+	    bind_type = PROGRAM_LOCAL_MULTI;
+
+	 ptmp = ptn->children[0]->children[0]->children[0];
+	 bind_idx = bind_row =
+	    s->ints.data[ptmp->children[0]->children[0]->tok_attr];
+	 bind_nrows = 1;
+
+	 ptmp = ptn->children[0]->children[0]->children[0]->children[1];
+	 if ((ptmp->prod_applied == 257) || (ptmp->prod_applied == 262))
+	    bind_nrows =
+	       s->ints.data[ptmp->children[0]->children[0]->tok_attr] -
+	       bind_idx;
+	 break;
+      }
+      break;
+
+#define FOLD_FLOAT_CONSTANT(float_ptr, bind_vals_idx, sign) \
+		if (float_ptr->tok == 49) /* GLfloat */ {\
+			bind_vals[bind_vals_idx] = sign * s->floats.data[float_ptr->tok_attr];\
+		}\
+		else /* GLint */ {\
+			bind_vals[bind_vals_idx] = sign * s->ints.data[float_ptr->tok_attr];\
+		}
+
+#define FOLD_SIGNED_FLOAT_CONSTANT(sf_ptr, bind_vals_idx) \
+		{\
+			GLfloat __mul = 1.;\
+			if (sf_ptr->children[0]->prod_applied == 282) \
+				__mul = -1.;\
+			FOLD_FLOAT_CONSTANT(sf_ptr->children[1], bind_vals_idx, __mul);\
+		}
+
+      /* const scalar decl */
+   case 271:
+      eat_children = 1;
+      bind_idx = 0;
+      bind_type = CONSTANT;
+
+      FOLD_SIGNED_FLOAT_CONSTANT(ptn->children[0], 0);
+#if 0
+      {
+	 GLfloat mul = 1.;
+	 if (ptn->children[0]->children[0]->prod_applied == 282) {
+	    mul = -1;
+	 }
+
+	 FOLD_FLOAT_CONSTANT(ptn->children[0]->children[1], 0, mul);
+      }
+#endif
+      break;
+
+      /* const vector */
+   case 273:
+      eat_children = 1;
+      bind_idx = 0;
+      bind_type = CONSTANT;
+
+      FOLD_SIGNED_FLOAT_CONSTANT(ptn->children[0], 0);
+      if (ptn->children[1]->prod_applied == 275) {
+	 FOLD_SIGNED_FLOAT_CONSTANT(ptn->children[1]->children[0], 1);
+	 if (ptn->children[1]->children[1]->prod_applied == 277) {
+	    FOLD_SIGNED_FLOAT_CONSTANT(ptn->children[1]->children[1]->
+				       children[0], 2);
+	    if (ptn->children[1]->children[1]->children[1]->prod_applied ==
+		279) {
+	       FOLD_SIGNED_FLOAT_CONSTANT(ptn->children[1]->children[1]->
+					  children[1]->children[0], 3);
+	    }
+	 }
+      }
+      break;
+
+      /* result */
+   case 289:
+      eat_children = 1;
+      bind_idx = 0;
+      switch (ptn->children[0]->prod_applied) {
+      case 290:		/* position */
+	 bind_type = RESULT_POSITION;
+	 break;
+      case 291:		/* fogcoord */
+	 bind_type = RESULT_FOGCOORD;
+	 break;
+      case 292:		/* pointsize */
+	 bind_type = RESULT_POINTSIZE;
+	 break;
+      case 293:		/* color */
+	 bind_type = RESULT_COLOR_FRONT_PRIMARY;
+	 ptmp = ptn->children[0]->children[0]->children[0];
+	 if (ptmp->prod_applied == 297) {
+	    if (ptmp->children[0]->prod_applied == 298) {	/* front */
+	       if (ptmp->children[0]->children[0]->prod_applied == 301) {
+		  if (ptmp->children[0]->children[0]->children[0]->prod_applied == 303)	/* secondary */
+		     bind_type = RESULT_COLOR_FRONT_SECONDARY;
+	       }
+	    }
+	    else {		/* back */
+
+	       bind_type = RESULT_COLOR_BACK_PRIMARY;
+	       if (ptmp->children[0]->children[0]->prod_applied == 301) {
+		  if (ptmp->children[0]->children[0]->children[0]->prod_applied == 303)	/* secondary */
+		     bind_type = RESULT_COLOR_BACK_SECONDARY;
+	       }
+
+	    }
+	 }
+	 break;
+      case 294:		/* texcoord */
+	 bind_type = RESULT_TEXCOORD;
+	 if (ptn->children[0]->children[0]->prod_applied == 311) {
+	    bind_idx =
+	       s->ints.data[ptn->children[0]->children[0]->children[0]->
+			    children[0]->tok_attr];
+	 }
+	 break;
+      }
+      break;
+   }
+
+   /* Mmmmm... baaaaby */
+   if (eat_children) {
+      if (eat_children == 2)
+	 parse_tree_free_children(ptn->children[0]);
+      else
+	 parse_tree_free_children(ptn);
+
+      /* Insert the binding into the binding table */
+      ptn->tok = BINDING_TOKEN;
+      ptn->tok_attr =
+	 binding_table_add(&s->binds, bind_type, bind_idx, bind_row,
+			   bind_nrows, bind_vals);
+
+      printf("Got binding %d %d %d %d at pos %d in bind tab [%f %f %f %f]\n",
+	     bind_type, bind_idx, bind_row, bind_nrows, ptn->tok_attr,
+	     bind_vals[0], bind_vals[1], bind_vals[2], bind_vals[3]);
+   }
+
+
+   for (a = 0; a < 4; a++) {
+      if (!ptn->children[a])
+	 return;
+
+      parse_tree_fold_bindings(s, ptn->children[a]);
+   }
+}
+
+/**
+ * After we have figured out what mess of parse tree actually represents GL state (or constants, or 
+ * whatnot), we have to line up variables with the state.  For example, a line something like
+ *
+ *    OUTPUT foo = result.position;
+ *
+ * We would have 'foo' in the identifier table at some position foo_idx, and 'result.position' in the 
+ * binding table at some position res_pos_idx. To set things up such that 'foo' is associated with 
+ * the result position state, we need to set ident[foo_idx].attr = res_pos_idx so we can generate
+ * opcodes without going bonkers.
+ *
+ * This function works on OUTPUT, ATTRIB, and PARAM single bindings. PARAM array bindings are handled in  
+ * parse_tree_assign_param_arrays().
+ *
+ * \param  s   The parse state
+ * \param  ptn The root of the parse tree from which to start lining up state and variables
+ */
+static void
+parse_tree_assign_bindings(parse_state * s, parse_tree_node * ptn)
+{
+   GLint a;
+   parse_tree_node *var_name, *attr_item;
+
+   /* OUTPUT, ATTRIB */
+   if ((ptn->prod_applied == 288) || (ptn->prod_applied == 120)) {
+      var_name = ptn->children[0]->children[0];
+      attr_item = ptn->children[1];
+
+      if (attr_item->tok != BINDING_TOKEN) {
+	 fprintf(stderr,
+		 "sanity check: trying to bind an output variable to something funky!\n");
+	 return;
+      }
+
+      s->idents.attr[var_name->tok_attr] = attr_item->tok_attr;
+      printf("result: %s bound to %d\n", s->idents.data[var_name->tok_attr],
+	     s->binds.type[s->idents.attr[var_name->tok_attr]]);
+      return;
+   }
+
+   /* stateSingleItemDecl */
+   if (ptn->prod_applied == 134) {
+      var_name = ptn->children[0]->children[0];
+      if (ptn->children[1]->prod_applied == 135) {
+	 if (ptn->children[1]->children[0]->prod_applied == 139) {
+	    if (ptn->children[1]->children[0]->children[0]->prod_applied ==
+		144)
+	       attr_item =
+		  ptn->children[1]->children[0]->children[0]->children[0]->
+		  children[0];
+	    else if (ptn->children[1]->children[0]->children[0]->
+		     prod_applied == 145)
+	       attr_item =
+		  ptn->children[1]->children[0]->children[0]->children[0];
+	    else
+	       attr_item =
+		  ptn->children[1]->children[0]->children[0]->children[0]->
+		  children[0];
+
+	    if (attr_item->tok != BINDING_TOKEN) {
+	       fprintf(stderr,
+		       "sanity check: trying to bind an param variable (%s) to something funky! [%d]\n",
+		       s->idents.data[var_name->tok_attr], attr_item->tok);
+	       exit(1);
+	    }
+
+	    s->idents.attr[var_name->tok_attr] = attr_item->tok_attr;
+	    printf("result: %s bound to %d\n",
+		   s->idents.data[var_name->tok_attr],
+		   s->binds.type[s->idents.attr[var_name->tok_attr]]);
+	    return;
+	 }
+      }
+
+   }
+
+   /* else, recurse on all our children */
+   for (a = 0; a < 4; a++) {
+      if (!ptn->children[a])
+	 return;
+
+      parse_tree_assign_bindings(s, ptn->children[a]);
+   }
+
+}
+
+/**
+ * This handles lining up PARAM arrays with variables, much like parse_tree_assign_bindings().
+ *
+ * In parse_tree_assign_bindings, we set the identifier attr to the index into the binding table of 
+ * the bound state.
+ *
+ * Here, instead, we allocate a slot in the 'array table' to stick the bound state into. Instead
+ * of an index into the binding table, the identifier attr now holds the index into the array table.
+ *
+ * \param s   The parse state
+ * \param pnt The root parse tree node to handle arrays from
+ *
+ */
+static void
+parse_tree_assign_param_arrays(parse_state * s, parse_tree_node * ptn)
+{
+   GLint a, is_mult, array_len;
+   parse_tree_node *var_name, *binding, *arraysize, *ptmp;
+
+   /* If we're a param */
+   if (ptn->prod_applied == 134) {
+      /* establish name */
+      var_name = ptn->children[0];
+
+      /* param_statement2 */
+      binding = ptn->children[1];
+      if (binding->prod_applied == 136) {
+	 /* optarraysize */
+	 arraysize = binding->children[0];
+
+	 is_mult = 0;
+
+	 /* foo[3] */
+	 if (arraysize->prod_applied == 138) {
+	    debug_token(s, var_name->children[0]->tok,
+			var_name->children[0]->tok_attr);
+	    debug_token(s, arraysize->children[0]->tok,
+			arraysize->children[0]->tok_attr);
+	    printf("\n");
+	    is_mult = 1;
+	 }
+	 else
+	    /* foo[] */
+	 if (arraysize->prod_applied == 137) {
+	    arraysize = NULL;
+	    printf("How do I init a PARAM array like foo[]?? \n");
+	    is_mult = 1;
+	 }
+
+	 if (!is_mult)
+	    return;
+
+	 s->idents.attr[var_name->tok_attr] = array_table_new(&s->arrays);
+
+	 binding = binding->children[1]->children[0];
+	 ptmp = binding->children[0];
+	 array_len = 0;
+
+	 if (ptmp->prod_applied == 150) {	/* state */
+	    printf("matrix 0 [state]:\n");
+	    printf("%d %d\n", ptmp->children[0]->children[0]->tok,
+		   ptmp->children[0]->children[0]->tok_attr);
+	    array_table_add_data(&s->arrays,
+				 s->idents.attr[var_name->tok_attr],
+				 ptmp->children[0]->children[0]->tok_attr);
+	    array_len +=
+	       s->binds.num_rows[ptmp->children[0]->children[0]->tok_attr];
+	 }
+	 else if (ptmp->prod_applied == 151) {	/* program */
+	    printf("matrix 0 [program]:\n");
+	    printf("%d %d\n", ptmp->children[0]->tok,
+		   ptmp->children[0]->tok_attr);
+	    array_table_add_data(&s->arrays,
+				 s->idents.attr[var_name->tok_attr],
+				 ptmp->children[0]->tok_attr);
+	    array_len += s->binds.num_rows[ptmp->children[0]->tok_attr];
+	 }
+	 else {			/* constant */
+
+	    printf("matrix 0 [constant]:\n");
+	    printf("%d %d\n", ptmp->children[0]->children[0]->tok,
+		   ptmp->children[0]->children[0]->tok_attr);
+	    array_table_add_data(&s->arrays,
+				 s->idents.attr[var_name->tok_attr],
+				 ptmp->children[0]->children[0]->tok_attr);
+	    array_len +=
+	       s->binds.num_rows[ptmp->children[0]->children[0]->tok_attr];
+	 }
+	 binding = binding->children[1];
+
+	 while (binding->prod_applied != 143) {
+	    ptmp = binding->children[0]->children[0];
+	    printf("mat: %d\n", ptmp->prod_applied);
+	    if (ptmp->prod_applied == 150) {	/* state */
+	       printf("matrix %d:\n", array_len);
+	       printf("%d %d\n", ptmp->children[0]->children[0]->tok,
+		      ptmp->children[0]->children[0]->tok_attr);
+	       array_table_add_data(&s->arrays,
+				    s->idents.attr[var_name->tok_attr],
+				    ptmp->children[0]->children[0]->tok_attr);
+	       array_len +=
+		  s->binds.num_rows[ptmp->children[0]->children[0]->tok_attr];
+	    }
+	    else if (ptmp->prod_applied == 151) {	/* program */
+	       printf("matrix %d [program]:\n", array_len);
+	       printf("%d %d\n", ptmp->children[0]->tok,
+		      ptmp->children[0]->tok_attr);
+	       array_table_add_data(&s->arrays,
+				    s->idents.attr[var_name->tok_attr],
+				    ptmp->children[0]->tok_attr);
+	       array_len += s->binds.num_rows[ptmp->children[0]->tok_attr];
+	    }
+	    else {		/* constant */
+
+	       printf("matrix %d [constant]:\n", array_len);
+	       printf("%d %d\n", ptmp->children[0]->children[0]->tok,
+		      ptmp->children[0]->children[0]->tok_attr);
+	       array_table_add_data(&s->arrays,
+				    s->idents.attr[var_name->tok_attr],
+				    ptmp->children[0]->children[0]->tok_attr);
+	       array_len +=
+		  s->binds.num_rows[ptmp->children[0]->children[0]->tok_attr];
+	    }
+	    binding = binding->children[0]->children[1];
+	 }
+
+	 /* XXX: have to compare the requested size, and the actual 
+	  * size, and fix up any inconsistancies
+	  */
+	 if (arraysize) {
+	    printf("matrix wants to get %d rows\n",
+		   s->ints.data[arraysize->children[0]->tok_attr]);
+	 }
+	 printf("matrix num rows: %d\n", array_len);
+      }
+
+      return;
+   }
+
+   /* Else, recurse on all our children */
+   for (a = 0; a < 4; a++) {
+      if (!ptn->children[a])
+	 return;
+
+      parse_tree_assign_param_arrays(s, ptn->children[a]);
+   }
+
+}
+
+/* XXX: This needs to be written properly. */
+/**
+ * Here we allocate 'registers' for all of the various variables and bound state. 
+ *
+ * The 'register' number is given by the reg_num field in the binding table. Note that this field
+ * is not stored in the identifier table. If it were, we would need a different mechanism for handling 
+ * implicit bindings.
+ *
+ * However, after some discussion with Brian, implicit bindings may be handled by grabbing state
+ * directly from Mesa's state structs. This might be a little hairy here, maybe not.. Implicit 
+ * bindings are those in the binding table that are not pointed to by any ident.attr or array.data
+ *
+ * This should also do various error checking, like the multiple vertex attrib error, or 'too many bindings'
+ * error.
+ * 
+ * \param s The parse state
+ */
+static void
+assign_regs(parse_state * s)
+{
+   GLint a;
+   GLfloat foo[4];
+
+   for (a = 0; a < s->idents.len; a++) {
+      if (s->idents.type[a] == TYPE_TEMP) {
+	 s->idents.attr[a] =
+	    binding_table_add(&s->binds, TYPE_TEMP, 0, 0, 0, foo);
+      }
+   }
+}
+
+/**
+ * Parse/compile the 'str' returning the compiled 'program'.
+ * ctx->Program.ErrorPos will be -1 if successful.  Otherwise, ErrorPos
+ * indicates the position of the error in 'str'.
+ */
+void
+_mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
+			       const GLubyte * string, GLsizei len,
+			       struct vertex_program *program)
+{
+   GLubyte *our_string;
+   parse_state *state;
+
+   printf("len: %d\n", len);
+
+   /* XXX: How do I handle these errors? */
+   if (len < 10)
+      return;
+   if (_mesa_strncmp(string, "!!ARBvp1.0", 10))
+      return;
+
+   /* Make a null-terminated copy of the program string */
+   our_string = (GLubyte *) MALLOC(len + 1);
+   if (!our_string) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
+      return;
+   }
+   MEMCPY(our_string, string, len);
+   our_string[len] = 0;
+
+   state = parse_state_init(our_string + 10, strlen(our_string) - 10);
+
+   if (parse(state) == ARB_VP_SUCESS) {
+      printf("parse sucess!\n");
+   }
+   else {
+      printf("*** error\n");
+      parse_state_cleanup(state);
+      return;
+   }
+
+   /* First, we 'fold' bindings from a big mess of productions and 
+    * tokens into one BINDING_TOKEN, which points to an entry
+    * in the binding sym table that holds all of the relevant
+    * info for the binding destination.
+    */
+   parse_tree_fold_bindings(state, state->pt_head);
+
+   /* Now, for each type of binding, walk the parse tree and stick
+    * the index into the binding sym table 
+    */
+   parse_tree_assign_bindings(state, state->pt_head);
+
+   /* XXX: this still needs a' fixin to get folded bindings 
+    *                   -- it does? wtf do I mean? */
+   parse_tree_assign_param_arrays(state, state->pt_head);
+
+   /* XXX: Now, assign registers. For this, we'll need to create
+    * bindings for all temps (and what else?? )
+    */
+   assign_regs(state);
+
+   /* Ok, now generate code */
+   parse_tree_generate_opcodes(state, state->pt_head);
+
+   /* Just for testing.. */
+   program->Base.Target = target;
+   if (program->Base.String) {
+      FREE(program->Base.String);
+   }
+   program->Base.String = our_string;
+   program->Base.Format = GL_PROGRAM_FORMAT_ASCII_ARB;
+
+   if (program->Instructions) {
+      FREE(program->Instructions);
+   }
+
+   program->Instructions =
+      (struct vp_instruction *) _mesa_malloc(sizeof(struct vp_instruction));
+   program->Instructions[0].Opcode = VP_OPCODE_END;
+   program->InputsRead = 0;
+   program->OutputsWritten = 0;
+   program->IsPositionInvariant = 0;
+
+   parse_state_cleanup(state);
+
+   /* TODO:
+    *    - handle implicit state grabbing & register allocation like discussed
+    *      - implicit param declarations -- see above
+    *
+    *      - variable bindings -- ADDRESS
+    *      - deal with explicit array sizes & size mismatches
+    *      - shuddup all my debugging crap
+    *      - grep for XXX
+    *      - multiple vtx attrib binding error
+    *      - What do I do on look ahead for prod 54 & 55? (see arbvp_grammar.txt)
+    *      - misc errors
+    *         - check integer ranges
+    *         - check array index ranges
+    *         - check variable counts
+    *      - param register allocation
+    *      - exercise swizzles and masks
+    *      - error handling
+    *      - generate opcodes
+    *          + Get addres registers for relative offsets in PARAM arrays 
+    *          + Properly encode implicit PARAMs and ATTRIBs.
+    *          + ARL
+    *          + SWZ
+    *          + actually emit Mesa opcodes
+    *      - segfaults while freeing stuff
+    *      - OPTION
+    */
+}
diff --git a/src/mesa/main/arbvertparse.h b/src/mesa/main/arbvertparse.h
new file mode 100644
index 0000000..4b4c3fe
--- /dev/null
+++ b/src/mesa/main/arbvertparse.h
@@ -0,0 +1,36 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  5.1
+ *
+ * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Brian Paul
+ */
+
+#ifndef ARBVERTPARSE_H
+#define ARBVERTPARSE_H
+
+extern void
+_mesa_parse_arb_vertex_program(GLcontext * ctx, GLenum target,
+			       const GLubyte * str, GLsizei len,
+			       struct vertex_program *program);
+
+#endif