Checkpoint work for new GLSL compiler back-end.

Among changes:
Remove ctx->FragmentProgram._Active
Remove _UseTexEnvProgram
Move _MaintainTnlProgram, _MaintainTexEnvProgram, _TexEnvProgram and
_TnlProgram fields.
Remove/disable old GLSL interpreter code.

16 files changed, 346 insertions, 316 deletions

diff --git a/src/mesa/tnl/t_context.c b/src/mesa/tnl/t_context.c
index 154780cc975..b07f90af02f 100644
--- a/src/mesa/tnl/t_context.c
+++ b/src/mesa/tnl/t_context.c
@@ -86,7 +86,7 @@ _tnl_CreateContext( GLcontext *ctx )
    _tnl_array_init( ctx );
    _tnl_vtx_init( ctx );
 
-   if (ctx->_MaintainTnlProgram) {
+   if (ctx->VertexProgram._MaintainTnlProgram) {
       _tnl_ProgramCacheInit( ctx );
       _tnl_install_pipeline( ctx, _tnl_vp_pipeline );
    } else {
@@ -136,7 +136,7 @@ _tnl_DestroyContext( GLcontext *ctx )
    _tnl_destroy_pipeline( ctx );
    _ae_destroy_context( ctx );
 
-   if (ctx->_MaintainTnlProgram)
+   if (ctx->VertexProgram._MaintainTnlProgram)
       _tnl_ProgramCacheDestroy( ctx );
 
    FREE(tnl);
@@ -183,7 +183,7 @@ _tnl_InvalidateState( GLcontext *ctx, GLuint new_state )
    }
 
    if (ctx->Fog.Enabled ||
-       (ctx->FragmentProgram._Active &&
+       (ctx->FragmentProgram._Current &&
         (ctx->FragmentProgram._Current->FogOption != GL_NONE ||
          ctx->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_FOGC)))
       RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_FOG );
@@ -199,8 +199,13 @@ _tnl_InvalidateState( GLcontext *ctx, GLuint new_state )
        (ctx->VertexProgram._Enabled && ctx->VertexProgram.PointSizeEnabled))
       RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_POINTSIZE );
 
+#if NEW_SLANG
+   RENDERINPUTS_SET_RANGE( tnl->render_inputs_bitset,
+                           _TNL_FIRST_GENERIC, _TNL_LAST_GENERIC );
+#else
    if (ctx->ShaderObjects._VertexShaderPresent || ctx->ShaderObjects._FragmentShaderPresent)
       RENDERINPUTS_SET_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_GENERIC, _TNL_LAST_GENERIC );
+#endif
 }
 
 
diff --git a/src/mesa/tnl/t_pipeline.c b/src/mesa/tnl/t_pipeline.c
index 2efe701a802..a50a3f0f2f2 100644
--- a/src/mesa/tnl/t_pipeline.c
+++ b/src/mesa/tnl/t_pipeline.c
@@ -132,7 +132,7 @@ void _tnl_run_pipeline( GLcontext *ctx )
     * (ie const or non-const).
     */
    if (check_input_changes( ctx ) || tnl->pipeline.new_state) {
-      if (ctx->_MaintainTnlProgram)
+      if (ctx->VertexProgram._MaintainTnlProgram)
 	 _tnl_UpdateFixedFunctionProgram( ctx );
 
       for (i = 0; i < tnl->pipeline.nr_stages ; i++) {
@@ -208,9 +208,6 @@ const struct tnl_pipeline_stage *_tnl_default_pipeline[] = {
    &_tnl_arb_vertex_program_stage,
    &_tnl_vertex_program_stage, 
 #endif
-#if FEATURE_ARB_vertex_shader
-   &_tnl_arb_vertex_shader_stage,
-#endif
    &_tnl_render_stage,
    NULL 
 };
diff --git a/src/mesa/tnl/t_vb_arbprogram.c b/src/mesa/tnl/t_vb_arbprogram.c
index bf4c1d52237..b7975f3a4eb 100644
--- a/src/mesa/tnl/t_vb_arbprogram.c
+++ b/src/mesa/tnl/t_vb_arbprogram.c
@@ -37,6 +37,7 @@
 #include "arbprogparse.h"
 #include "light.h"
 #include "program.h"
+#include "programopt.h"
 #include "math/m_matrix.h"
 #include "t_context.h"
 #include "t_pipeline.h"
@@ -292,7 +293,7 @@ static void do_EX2( struct arb_vp_machine *m, union instruction op )
    GLfloat *result = m->File[0][op.alu.dst];
    const GLfloat *arg0 = m->File[op.alu.file0][op.alu.idx0];
 
-   result[0] = (GLfloat)ApproxExp2(arg0[0]);
+   result[0] = ApproxExp2(arg0[0]);
    PUFF(result);
 }
 
@@ -566,7 +567,7 @@ static void print_reg( GLuint file, GLuint reg )
 	 _mesa_printf("TMP%d", reg - REG_TMP0);
       else if (reg >= REG_IN0 && reg <= REG_IN31)
 	 _mesa_printf("IN%d", reg - REG_IN0);
-      else if (reg >= REG_OUT0 && reg <= REG_OUT14)
+      else if (reg >= REG_OUT0 && reg <= REG_OUT23)
 	 _mesa_printf("OUT%d", reg - REG_OUT0);
       else if (reg == REG_ADDR)
 	 _mesa_printf("ADDR");
@@ -714,6 +715,7 @@ _tnl_disassem_vba_insn( union instruction op )
 
 static void (* const opcode_func[MAX_OPCODE+3])(struct arb_vp_machine *, union instruction) = 
 {
+   do_NOP,
    do_ABS,
    do_ADD,
    do_NOP,/*ARA*/
@@ -853,6 +855,7 @@ static struct reg cvp_load_reg( struct compilation *cp,
 	 return reg;
 
    case PROGRAM_STATE_VAR:
+   case PROGRAM_CONSTANT:
       reg = cvp_make_reg(FILE_STATE_PARAM, index);
       if (rel) 
 	 return cvp_emit_rel(cp, reg, tmpreg);
@@ -1058,6 +1061,16 @@ static void compile_vertex_program( struct gl_vertex_program *program,
    struct tnl_compiled_program *p = CALLOC_STRUCT(tnl_compiled_program);
    GLuint i;
 
+#if 1
+   if (!program->IsNVProgram && program->IsPositionInvariant) {
+      printf("Adding MVP code\n");
+      if (!program->Base.Parameters)
+         program->Base.Parameters = _mesa_new_parameter_list();
+      _mesa_insert_mvp_code(NULL, program);
+      program->IsPositionInvariant = 0;
+   }
+#endif
+
    if (program->TnlData) 
       free_tnl_data( program );
    
@@ -1182,6 +1195,7 @@ do_ndc_cliptest(GLcontext *ctx, struct arb_vp_machine *m)
 
    /* Test userclip planes.  This contributes to VB->ClipMask.
     */
+   /** XXX NEW_SLANG _Enabled ??? */
    if (ctx->Transform.ClipPlanesEnabled && (!ctx->VertexProgram._Enabled ||
       ctx->VertexProgram.Current->IsPositionInvariant)) {
       userclip( ctx,
@@ -1221,21 +1235,14 @@ static INLINE void call_func( struct tnl_compiled_program *p,
 static GLboolean
 run_arb_vertex_program(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 {
-   const struct gl_vertex_program *program;
+   const struct gl_vertex_program *program = ctx->VertexProgram._Current;
    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
    struct arb_vp_machine *m = ARB_VP_MACHINE(stage);
    struct tnl_compiled_program *p;
    GLuint i, j;
    GLbitfield outputs;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   program = ctx->VertexProgram._Enabled ? ctx->VertexProgram.Current : NULL;
-   if (!program && ctx->_MaintainTnlProgram) {
-      program = ctx->_TnlProgram;
-   }
-   if (!program || program->IsNVProgram)
+   if (!program)
       return GL_TRUE;   
 
    if (program->Base.Parameters) {
@@ -1299,12 +1306,13 @@ run_arb_vertex_program(GLcontext *ctx, struct tnl_pipeline_stage *stage)
       /* If the program is position invariant, multiply the input position
        * by the MVP matrix and store in the vertex position result register.
        */
+#if 0
       if (program->IsPositionInvariant) {
 	 TRANSFORM_POINT( m->File[0][REG_OUT0+0], 
 			  ctx->_ModelProjectMatrix.m, 
 			  m->File[0][REG_IN0+0]);
       }
-
+#endif
       for (j = 0; j < m->nr_outputs; j++) {
 	 GLuint idx = REG_OUT0 + m->output[j].idx;
 	 m->output[j].data[0] = m->File[0][idx][0];
@@ -1370,6 +1378,14 @@ run_arb_vertex_program(GLcontext *ctx, struct tnl_pipeline_stage *stage)
       }
    }
 
+   for (i = 0; i < ctx->Const.MaxVarying; i++) {
+      if (outputs & (1 << (VERT_RESULT_VAR0 + i))) {
+         /* Note: varying results get put into the generic attributes */
+	 VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
+            = &m->attribs[VERT_RESULT_VAR0 + i];
+      }
+   }
+
 #if 0
    for (i = 0; i < VB->Count; i++) {
       printf("Out %d: %f %f %f %f %f %f %f %f\n", i,
@@ -1394,15 +1410,7 @@ static void
 validate_vertex_program( GLcontext *ctx, struct tnl_pipeline_stage *stage )
 {
    struct arb_vp_machine *m = ARB_VP_MACHINE(stage);
-   struct gl_vertex_program *program;
-
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return;
-
-   program = (ctx->VertexProgram._Enabled ? ctx->VertexProgram.Current : 0);
-   if (!program && ctx->_MaintainTnlProgram) {
-      program = ctx->_TnlProgram;
-   }
+   struct gl_vertex_program *program = ctx->VertexProgram._Current;
 
    if (program) {
       if (!program->TnlData)
@@ -1472,7 +1480,7 @@ static GLboolean init_vertex_program( GLcontext *ctx,
    _mesa_vector4f_alloc( &m->ndcCoords, 0, size, 32 );
    m->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
 
-   if (ctx->_MaintainTnlProgram)
+   if (ctx->VertexProgram._MaintainTnlProgram)
       _mesa_allow_light_in_model( ctx, GL_FALSE );
 
    m->fpucntl_rnd_neg = RND_NEG_FPU; /* const value */
@@ -1529,7 +1537,7 @@ const struct tnl_pipeline_stage _tnl_arb_vertex_program_stage =
 void
 _tnl_program_string(GLcontext *ctx, GLenum target, struct gl_program *program)
 {
-   if (target == GL_VERTEX_PROGRAM_ARB) {
+   if (program->Target == GL_VERTEX_PROGRAM_ARB) {
       /* free any existing tnl data hanging off the program */
       struct gl_vertex_program *vprog = (struct gl_vertex_program *) program;
       if (vprog->TnlData) {
diff --git a/src/mesa/tnl/t_vb_arbprogram.h b/src/mesa/tnl/t_vb_arbprogram.h
index 6de8dca328c..1bec2a411e8 100644
--- a/src/mesa/tnl/t_vb_arbprogram.h
+++ b/src/mesa/tnl/t_vb_arbprogram.h
@@ -56,6 +56,22 @@
 #define REG_TMP0   5
 #define REG_TMP11  16
 #define REG_OUT0   17
+#define REG_OUT23  40
+#define REG_IN0    41
+#define REG_IN31   72
+#define REG_ID     73		/* 0,0,0,1 */
+#define REG_ONES   74		/* 1,1,1,1 */
+#define REG_SWZ    75		/* 1,-1,0,0 */
+#define REG_NEG    76		/* -1,-1,-1,-1 */
+#define REG_LIT    77           /* 1,0,0,1 */
+#define REG_LIT2    78           /* 1,0,0,1 */
+#define REG_SCRATCH 79		/* internal temporary. XXX we can't actually use this because 70 doesn't fit in the 5-bit 'dst' instruction field! */
+#define REG_UNDEF  127		/* special case - never used */
+#define REG_MAX    128
+#define REG_INVALID ~0
+
+
+#if 0
 #define REG_OUT14  31
 #define REG_IN0    32
 #define REG_IN31   63
@@ -69,6 +85,7 @@
 #define REG_UNDEF  127		/* special case - never used */
 #define REG_MAX    128
 #define REG_INVALID ~0
+#endif
 
 /* ARB_vp instructions are broken down into one or more of the
  * following micro-instructions, each representable in a 64 bit packed
@@ -76,16 +93,16 @@
  */
 struct reg {
    GLuint file:2;
-   GLuint idx:7;
+   GLuint idx:8;
 };
 
 
 union instruction {
    struct {
       GLuint opcode:7;
-      GLuint dst:5;
+      GLuint dst:6;
       GLuint file0:2;
-      GLuint idx0:7;
+      GLuint idx0:8;
       GLuint file1:2;
       GLuint idx1:7;
       GLuint pad:2;
@@ -94,18 +111,18 @@ union instruction {
 
    struct {
       GLuint opcode:7;
-      GLuint dst:5;
+      GLuint dst:6;
       GLuint file0:2;
-      GLuint idx0:7;
+      GLuint idx0:8;
       GLuint neg:4;
       GLuint swz:12;		/* xyzw01 */
    } rsw;
 
    struct {
       GLuint opcode:7;
-      GLuint dst:5;
+      GLuint dst:6;
       GLuint file:2;
-      GLuint idx:7;
+      GLuint idx:8;
       GLuint mask:4;
       GLuint pad:7;
       GLuint pad2;
diff --git a/src/mesa/tnl/t_vb_arbshader.c b/src/mesa/tnl/t_vb_arbshader.c
index 13aa3ea9105..6d591146576 100644
--- a/src/mesa/tnl/t_vb_arbshader.c
+++ b/src/mesa/tnl/t_vb_arbshader.c
@@ -38,264 +38,295 @@
 
 typedef struct
 {
-	GLvector4f outputs[VERT_RESULT_MAX];
-	GLvector4f varyings[MAX_VARYING_VECTORS];
-	GLvector4f ndc_coords;
-	GLubyte *clipmask;
-	GLubyte ormask;
-	GLubyte andmask;
+   GLvector4f outputs[VERT_RESULT_MAX];
+   GLvector4f varyings[MAX_VARYING_VECTORS];
+   GLvector4f ndc_coords;
+   GLubyte *clipmask;
+   GLubyte ormask;
+   GLubyte andmask;
 } arbvs_stage_data;
 
 #define ARBVS_STAGE_DATA(stage) ((arbvs_stage_data *) stage->privatePtr)
 
-static GLboolean construct_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
+static GLboolean
+construct_arb_vertex_shader(GLcontext * ctx, struct tnl_pipeline_stage *stage)
 {
-	TNLcontext *tnl = TNL_CONTEXT(ctx);
-	struct vertex_buffer *vb = &tnl->vb;
-	arbvs_stage_data *store;
-	GLuint size = vb->Size;
-	GLuint i;
-
-	stage->privatePtr = _mesa_malloc (sizeof (arbvs_stage_data));
-	store = ARBVS_STAGE_DATA(stage);
-	if (store == NULL)
-		return GL_FALSE;
-
-	for (i = 0; i < VERT_RESULT_MAX; i++)
-	{
-		_mesa_vector4f_alloc (&store->outputs[i], 0, size, 32);
-		store->outputs[i].size = 4;
-	}
-	for (i = 0; i < MAX_VARYING_VECTORS; i++)
-	{
-		_mesa_vector4f_alloc (&store->varyings[i], 0, size, 32);
-		store->varyings[i].size = 4;
-	}
-	_mesa_vector4f_alloc (&store->ndc_coords, 0, size, 32);
-	store->clipmask = (GLubyte *) ALIGN_MALLOC (size, 32);
-
-	return GL_TRUE;
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *vb = &tnl->vb;
+   arbvs_stage_data *store;
+   GLuint size = vb->Size;
+   GLuint i;
+
+   stage->privatePtr = _mesa_malloc(sizeof(arbvs_stage_data));
+   store = ARBVS_STAGE_DATA(stage);
+   if (store == NULL)
+      return GL_FALSE;
+
+   for (i = 0; i < VERT_RESULT_MAX; i++) {
+      _mesa_vector4f_alloc(&store->outputs[i], 0, size, 32);
+      store->outputs[i].size = 4;
+   }
+   for (i = 0; i < MAX_VARYING_VECTORS; i++) {
+      _mesa_vector4f_alloc(&store->varyings[i], 0, size, 32);
+      store->varyings[i].size = 4;
+   }
+   _mesa_vector4f_alloc(&store->ndc_coords, 0, size, 32);
+   store->clipmask = (GLubyte *) ALIGN_MALLOC(size, 32);
+
+   return GL_TRUE;
 }
 
-static void destruct_arb_vertex_shader (struct tnl_pipeline_stage *stage)
+static void
+destruct_arb_vertex_shader(struct tnl_pipeline_stage *stage)
 {
-	arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
-
-	if (store != NULL)
-	{
-		GLuint i;
-
-		for (i = 0; i < VERT_RESULT_MAX; i++)
-			_mesa_vector4f_free (&store->outputs[i]);
-		for (i = 0; i < MAX_VARYING_VECTORS; i++)
-			_mesa_vector4f_free (&store->varyings[i]);
-		_mesa_vector4f_free (&store->ndc_coords);
-		ALIGN_FREE (store->clipmask);
-
-		_mesa_free (store);
-		stage->privatePtr = NULL;
-	}
+   arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
+
+   if (store != NULL) {
+      GLuint i;
+
+      for (i = 0; i < VERT_RESULT_MAX; i++)
+         _mesa_vector4f_free(&store->outputs[i]);
+      for (i = 0; i < MAX_VARYING_VECTORS; i++)
+         _mesa_vector4f_free(&store->varyings[i]);
+      _mesa_vector4f_free(&store->ndc_coords);
+      ALIGN_FREE(store->clipmask);
+
+      _mesa_free(store);
+      stage->privatePtr = NULL;
+   }
 }
 
-static void validate_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
+static void
+validate_arb_vertex_shader(GLcontext * ctx, struct tnl_pipeline_stage *stage)
 {
 }
 
-static GLvoid fetch_input_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
-	struct vertex_buffer *vb)
+static GLvoid
+fetch_input_float(struct gl2_program_intf **pro, GLuint index, GLuint attr,
+                  GLuint i, struct vertex_buffer *vb)
 {
-	const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
-	const GLuint stride = vb->AttribPtr[attr]->stride;
+   const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
+   const GLuint stride = vb->AttribPtr[attr]->stride;
    GLfloat *data = (GLfloat *) (ptr + stride * i);
 
-   (**pro).UpdateFixedAttrib (pro, index, data, 0, sizeof (GLfloat), GL_TRUE);
+   (**pro).UpdateFixedAttrib(pro, index, data, 0, sizeof(GLfloat), GL_TRUE);
 }
 
-static GLvoid fetch_input_vec3 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
-	struct vertex_buffer *vb)
+static GLvoid
+fetch_input_vec3(struct gl2_program_intf **pro, GLuint index, GLuint attr,
+                 GLuint i, struct vertex_buffer *vb)
 {
-	const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
-	const GLuint stride = vb->AttribPtr[attr]->stride;
+   const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
+   const GLuint stride = vb->AttribPtr[attr]->stride;
    GLfloat *data = (GLfloat *) (ptr + stride * i);
 
-   (**pro).UpdateFixedAttrib (pro, index, data, 0, 3 * sizeof (GLfloat), GL_TRUE);
+   (**pro).UpdateFixedAttrib(pro, index, data, 0, 3 * sizeof(GLfloat),
+                             GL_TRUE);
 }
 
-static void fetch_input_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
-	struct vertex_buffer *vb)
+static void
+fetch_input_vec4(struct gl2_program_intf **pro, GLuint index, GLuint attr,
+                 GLuint i, struct vertex_buffer *vb)
 {
-	const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
-	const GLuint size = vb->AttribPtr[attr]->size;
-	const GLuint stride = vb->AttribPtr[attr]->stride;
-	const GLfloat *data = (const GLfloat *) (ptr + stride * i);
-	GLfloat vec[4];
-
-	switch (size)
-	{
-	case 2:
-		vec[0] = data[0];
-		vec[1] = data[1];
-		vec[2] = 0.0f;
-		vec[3] = 1.0f;
-		break;
-	case 3:
-		vec[0] = data[0];
-		vec[1] = data[1];
-		vec[2] = data[2];
-		vec[3] = 1.0f;
-		break;
-	case 4:
-		vec[0] = data[0];
-		vec[1] = data[1];
-		vec[2] = data[2];
-		vec[3] = data[3];
-		break;
-	}
-   (**pro).UpdateFixedAttrib (pro, index, vec, 0, 4 * sizeof (GLfloat), GL_TRUE);
+   const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
+   const GLuint size = vb->AttribPtr[attr]->size;
+   const GLuint stride = vb->AttribPtr[attr]->stride;
+   const GLfloat *data = (const GLfloat *) (ptr + stride * i);
+   GLfloat vec[4];
+
+   switch (size) {
+   case 2:
+      vec[0] = data[0];
+      vec[1] = data[1];
+      vec[2] = 0.0f;
+      vec[3] = 1.0f;
+      break;
+   case 3:
+      vec[0] = data[0];
+      vec[1] = data[1];
+      vec[2] = data[2];
+      vec[3] = 1.0f;
+      break;
+   case 4:
+      vec[0] = data[0];
+      vec[1] = data[1];
+      vec[2] = data[2];
+      vec[3] = data[3];
+      break;
+   }
+   (**pro).UpdateFixedAttrib(pro, index, vec, 0, 4 * sizeof(GLfloat),
+                             GL_TRUE);
 }
 
 static GLvoid
-fetch_gen_attrib (struct gl2_program_intf **pro, GLuint index, GLuint i, struct vertex_buffer *vb)
+fetch_gen_attrib(struct gl2_program_intf **pro, GLuint index, GLuint i,
+                 struct vertex_buffer *vb)
 {
    const GLuint attr = _TNL_ATTRIB_GENERIC0 + index;
    const GLubyte *ptr = (const GLubyte *) (vb->AttribPtr[attr]->data);
    const GLuint stride = vb->AttribPtr[attr]->stride;
    const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 
-   (**pro).WriteAttrib (pro, index, data);
+   (**pro).WriteAttrib(pro, index, data);
 }
 
-static GLvoid fetch_output_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
-	arbvs_stage_data *store)
+static GLvoid
+fetch_output_float(struct gl2_program_intf **pro, GLuint index, GLuint attr,
+                   GLuint i, arbvs_stage_data * store)
 {
-   (**pro).UpdateFixedAttrib (pro, index, &store->outputs[attr].data[i], 0, sizeof (GLfloat),
-                              GL_FALSE);
+   (**pro).UpdateFixedAttrib(pro, index, &store->outputs[attr].data[i], 0,
+                             sizeof(GLfloat), GL_FALSE);
 }
 
-static void fetch_output_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
-	GLuint offset, arbvs_stage_data *store)
+static void
+fetch_output_vec4(struct gl2_program_intf **pro, GLuint index, GLuint attr,
+                  GLuint i, GLuint offset, arbvs_stage_data * store)
 {
-   (**pro).UpdateFixedAttrib (pro, index, &store->outputs[attr].data[i], offset,
-                              4 * sizeof (GLfloat), GL_FALSE);
+   (**pro).UpdateFixedAttrib(pro, index, &store->outputs[attr].data[i],
+                             offset, 4 * sizeof(GLfloat), GL_FALSE);
 }
 
-static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
+static GLboolean
+run_arb_vertex_shader(GLcontext * ctx, struct tnl_pipeline_stage *stage)
 {
-	TNLcontext *tnl = TNL_CONTEXT(ctx);
-	struct vertex_buffer *vb = &tnl->vb;
-	arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
-	struct gl2_program_intf **pro;
-	GLsizei i, j;
-
-	if (!ctx->ShaderObjects._VertexShaderPresent)
-		return GL_TRUE;
-
-	pro = ctx->ShaderObjects.CurrentProgram;
-	(**pro).UpdateFixedUniforms (pro);
-
-	for (i = 0; i < vb->Count; i++)
-	{
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_VERTEX, _TNL_ATTRIB_POS, i, vb);
-		fetch_input_vec3 (pro, SLANG_VERTEX_FIXED_NORMAL, _TNL_ATTRIB_NORMAL, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_COLOR, _TNL_ATTRIB_COLOR0, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_SECONDARYCOLOR, _TNL_ATTRIB_COLOR1, i, vb);
-		fetch_input_float (pro, SLANG_VERTEX_FIXED_FOGCOORD, _TNL_ATTRIB_FOG, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD0, _TNL_ATTRIB_TEX0, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD1, _TNL_ATTRIB_TEX1, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD2, _TNL_ATTRIB_TEX2, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD3, _TNL_ATTRIB_TEX3, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD4, _TNL_ATTRIB_TEX4, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD5, _TNL_ATTRIB_TEX5, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD6, _TNL_ATTRIB_TEX6, i, vb);
-		fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD7, _TNL_ATTRIB_TEX7, i, vb);
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *vb = &tnl->vb;
+   arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
+   struct gl2_program_intf **pro;
+   GLsizei i, j;
+
+#if 00
+   if (!ctx->ShaderObjects._VertexShaderPresent)
+      return GL_TRUE;
+#else
+   return GL_TRUE;
+#endif
+
+   pro = ctx->ShaderObjects.CurrentProgram;
+   (**pro).UpdateFixedUniforms(pro);
+
+   for (i = 0; i < vb->Count; i++) {
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_VERTEX, _TNL_ATTRIB_POS, i,
+                       vb);
+      fetch_input_vec3(pro, SLANG_VERTEX_FIXED_NORMAL, _TNL_ATTRIB_NORMAL, i,
+                       vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_COLOR, _TNL_ATTRIB_COLOR0, i,
+                       vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_SECONDARYCOLOR,
+                       _TNL_ATTRIB_COLOR1, i, vb);
+      fetch_input_float(pro, SLANG_VERTEX_FIXED_FOGCOORD, _TNL_ATTRIB_FOG, i,
+                        vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD0,
+                       _TNL_ATTRIB_TEX0, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD1,
+                       _TNL_ATTRIB_TEX1, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD2,
+                       _TNL_ATTRIB_TEX2, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD3,
+                       _TNL_ATTRIB_TEX3, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD4,
+                       _TNL_ATTRIB_TEX4, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD5,
+                       _TNL_ATTRIB_TEX5, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD6,
+                       _TNL_ATTRIB_TEX6, i, vb);
+      fetch_input_vec4(pro, SLANG_VERTEX_FIXED_MULTITEXCOORD7,
+                       _TNL_ATTRIB_TEX7, i, vb);
       for (j = 0; j < MAX_VERTEX_ATTRIBS; j++)
-         fetch_gen_attrib (pro, j, i, vb);
-
-		_slang_exec_vertex_shader (pro);
-
-		fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_POSITION, VERT_RESULT_HPOS, i, 0, store);
-		fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTCOLOR, VERT_RESULT_COL0, i, 0, store);
-		fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR, VERT_RESULT_COL1, i, 0, store);
-		fetch_output_float (pro, SLANG_VERTEX_FIXED_FOGFRAGCOORD, VERT_RESULT_FOGC, i, store);
-		for (j = 0; j < 8; j++)
-			fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_TEXCOORD, VERT_RESULT_TEX0 + j, i, j, store);
-		fetch_output_float (pro, SLANG_VERTEX_FIXED_POINTSIZE, VERT_RESULT_PSIZ, i, store);
-		fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store);
-		fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store);
-		/* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
-
-		for (j = 0; j < MAX_VARYING_VECTORS; j++)
-		{
-			GLuint k;
-
-			for (k = 0; k < VARYINGS_PER_VECTOR; k++)
-			{
-				(**pro).UpdateVarying (pro, j * VARYINGS_PER_VECTOR + k,
-					&store->varyings[j].data[i][k], GL_TRUE);
-			}
-		}
-	}
-
-	vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
-	vb->ClipPtr->count = vb->Count;
-
-	vb->ColorPtr[0] = &store->outputs[VERT_RESULT_COL0];
-	vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0];
-	vb->ColorPtr[1] = &store->outputs[VERT_RESULT_BFC0];
-
-	vb->SecondaryColorPtr[0] =
-	vb->AttribPtr[VERT_ATTRIB_COLOR1] = &store->outputs[VERT_RESULT_COL1];
-
-	vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1];
-
-	for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
-		vb->TexCoordPtr[i] =
-		vb->AttribPtr[VERT_ATTRIB_TEX0 + i] = &store->outputs[VERT_RESULT_TEX0 + i];
-        }
-
-	vb->FogCoordPtr =
-	vb->AttribPtr[VERT_ATTRIB_FOG] = &store->outputs[VERT_RESULT_FOGC];
-
-	vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ];
-
-	for (i = 0; i < MAX_VARYING_VECTORS; i++) {
-		vb->VaryingPtr[i] = &store->varyings[i];
-		vb->AttribPtr[_TNL_ATTRIB_GENERIC0 + i] = vb->VaryingPtr[i];
-        }
-
-	store->ormask = 0;
-	store->andmask = CLIP_FRUSTUM_BITS;
-
-	if (tnl->NeedNdcCoords)
-	{
-		vb->NdcPtr = _mesa_clip_tab[vb->ClipPtr->size] (vb->ClipPtr, &store->ndc_coords,
-			store->clipmask, &store->ormask, &store->andmask);
-	}
-	else
-	{
-		vb->NdcPtr = NULL;
-		_mesa_clip_np_tab[vb->ClipPtr->size] (vb->ClipPtr, NULL, store->clipmask, &store->ormask,
-			&store->andmask);
-	}
-
-	if (store->andmask)
-		return GL_FALSE;
-
-	vb->ClipAndMask = store->andmask;
-	vb->ClipOrMask = store->ormask;
-	vb->ClipMask = store->clipmask;
-
-	return GL_TRUE;
+         fetch_gen_attrib(pro, j, i, vb);
+
+      _slang_exec_vertex_shader(pro);
+
+      fetch_output_vec4(pro, SLANG_VERTEX_FIXED_POSITION, VERT_RESULT_HPOS, i,
+                        0, store);
+      fetch_output_vec4(pro, SLANG_VERTEX_FIXED_FRONTCOLOR, VERT_RESULT_COL0,
+                        i, 0, store);
+      fetch_output_vec4(pro, SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR,
+                        VERT_RESULT_COL1, i, 0, store);
+      fetch_output_float(pro, SLANG_VERTEX_FIXED_FOGFRAGCOORD,
+                         VERT_RESULT_FOGC, i, store);
+      for (j = 0; j < 8; j++)
+         fetch_output_vec4(pro, SLANG_VERTEX_FIXED_TEXCOORD,
+                           VERT_RESULT_TEX0 + j, i, j, store);
+      fetch_output_float(pro, SLANG_VERTEX_FIXED_POINTSIZE, VERT_RESULT_PSIZ,
+                         i, store);
+      fetch_output_vec4(pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0,
+                        i, 0, store);
+      fetch_output_vec4(pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR,
+                        VERT_RESULT_BFC1, i, 0, store);
+      /* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
+
+      for (j = 0; j < MAX_VARYING_VECTORS; j++) {
+         GLuint k;
+
+         for (k = 0; k < VARYINGS_PER_VECTOR; k++) {
+            (**pro).UpdateVarying(pro, j * VARYINGS_PER_VECTOR + k,
+                                  &store->varyings[j].data[i][k], GL_TRUE);
+         }
+      }
+   }
+
+   vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
+   vb->ClipPtr->count = vb->Count;
+
+   vb->ColorPtr[0] = &store->outputs[VERT_RESULT_COL0];
+   vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0];
+   vb->ColorPtr[1] = &store->outputs[VERT_RESULT_BFC0];
+
+   vb->SecondaryColorPtr[0] =
+      vb->AttribPtr[VERT_ATTRIB_COLOR1] = &store->outputs[VERT_RESULT_COL1];
+
+   vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1];
+
+   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
+      vb->TexCoordPtr[i] =
+         vb->AttribPtr[VERT_ATTRIB_TEX0 + i] =
+         &store->outputs[VERT_RESULT_TEX0 + i];
+   }
+
+   vb->FogCoordPtr =
+      vb->AttribPtr[VERT_ATTRIB_FOG] = &store->outputs[VERT_RESULT_FOGC];
+
+   vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ];
+
+   for (i = 0; i < MAX_VARYING_VECTORS; i++) {
+      vb->VaryingPtr[i] = &store->varyings[i];
+      vb->AttribPtr[_TNL_ATTRIB_GENERIC0 + i] = vb->VaryingPtr[i];
+   }
+
+   store->ormask = 0;
+   store->andmask = CLIP_FRUSTUM_BITS;
+
+   if (tnl->NeedNdcCoords) {
+      vb->NdcPtr =
+         _mesa_clip_tab[vb->ClipPtr->size] (vb->ClipPtr, &store->ndc_coords,
+                                            store->clipmask, &store->ormask,
+                                            &store->andmask);
+   }
+   else {
+      vb->NdcPtr = NULL;
+      _mesa_clip_np_tab[vb->ClipPtr->size] (vb->ClipPtr, NULL,
+                                            store->clipmask, &store->ormask,
+                                            &store->andmask);
+   }
+
+   if (store->andmask)
+      return GL_FALSE;
+
+   vb->ClipAndMask = store->andmask;
+   vb->ClipOrMask = store->ormask;
+   vb->ClipMask = store->clipmask;
+
+   return GL_TRUE;
 }
 
 const struct tnl_pipeline_stage _tnl_arb_vertex_shader_stage = {
-	"ARB_vertex_shader",
-	NULL,
-	construct_arb_vertex_shader,
-	destruct_arb_vertex_shader,
-	validate_arb_vertex_shader,
-	run_arb_vertex_shader
+   "ARB_vertex_shader",
+   NULL,
+   construct_arb_vertex_shader,
+   destruct_arb_vertex_shader,
+   validate_arb_vertex_shader,
+   run_arb_vertex_shader
 };
 
 #endif /* FEATURE_ARB_vertex_shader */
-
diff --git a/src/mesa/tnl/t_vb_cull.c b/src/mesa/tnl/t_vb_cull.c
index 8848dac10c1..21a32e5b1d8 100644
--- a/src/mesa/tnl/t_vb_cull.c
+++ b/src/mesa/tnl/t_vb_cull.c
@@ -57,10 +57,7 @@ static GLboolean run_cull_stage( GLcontext *ctx,
    GLuint count = VB->Count;
    GLuint i;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (ctx->VertexProgram._Enabled ||
+   if (ctx->VertexProgram._Current ||
        !ctx->Transform.CullVertexFlag) 
       return GL_TRUE;
 
diff --git a/src/mesa/tnl/t_vb_fog.c b/src/mesa/tnl/t_vb_fog.c
index 51f28c4059f..5440ff7894d 100644
--- a/src/mesa/tnl/t_vb_fog.c
+++ b/src/mesa/tnl/t_vb_fog.c
@@ -148,10 +148,7 @@ run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
    struct fog_stage_data *store = FOG_STAGE_DATA(stage);
    GLvector4f *input;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (!ctx->Fog.Enabled || ctx->VertexProgram._Enabled)
+   if (!ctx->Fog.Enabled || ctx->VertexProgram._Current)
       return GL_TRUE;
 
 
diff --git a/src/mesa/tnl/t_vb_light.c b/src/mesa/tnl/t_vb_light.c
index 47c5b400aae..12f2cc7735e 100644
--- a/src/mesa/tnl/t_vb_light.c
+++ b/src/mesa/tnl/t_vb_light.c
@@ -203,10 +203,7 @@ static GLboolean run_lighting( GLcontext *ctx,
    GLvector4f *input = ctx->_NeedEyeCoords ? VB->EyePtr : VB->ObjPtr;
    GLuint idx;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (!ctx->Light.Enabled || ctx->VertexProgram._Enabled)
+   if (!ctx->Light.Enabled || ctx->VertexProgram._Current)
       return GL_TRUE;
 
    /* Make sure we can talk about position x,y and z:
@@ -264,10 +261,7 @@ static void validate_lighting( GLcontext *ctx,
 {
    light_func *tab;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return;
-
-   if (!ctx->Light.Enabled || ctx->VertexProgram._Enabled)
+   if (!ctx->Light.Enabled || ctx->VertexProgram._Current)
       return;
 
    if (ctx->Visual.rgbMode) {
diff --git a/src/mesa/tnl/t_vb_normals.c b/src/mesa/tnl/t_vb_normals.c
index 0f91784e809..01fad0cee21 100644
--- a/src/mesa/tnl/t_vb_normals.c
+++ b/src/mesa/tnl/t_vb_normals.c
@@ -95,12 +95,7 @@ validate_normal_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 {
    struct normal_stage_data *store = NORMAL_STAGE_DATA(stage);
 
-   if (ctx->ShaderObjects._VertexShaderPresent) {
-      store->NormalTransform = NULL;
-      return;
-   }
-
-   if (ctx->VertexProgram._Enabled ||
+   if (ctx->VertexProgram._Current ||
        (!ctx->Light.Enabled &&
 	!(ctx->Texture._GenFlags & TEXGEN_NEED_NORMALS))) {
       store->NormalTransform = NULL;
diff --git a/src/mesa/tnl/t_vb_points.c b/src/mesa/tnl/t_vb_points.c
index 2f502d61d1d..9327f8c273c 100644
--- a/src/mesa/tnl/t_vb_points.c
+++ b/src/mesa/tnl/t_vb_points.c
@@ -47,10 +47,7 @@ struct point_stage_data {
 static GLboolean
 run_point_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
 {
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (ctx->Point._Attenuated && !ctx->VertexProgram._Enabled) {
+   if (ctx->Point._Attenuated && !ctx->VertexProgram._Current) {
       struct point_stage_data *store = POINT_STAGE_DATA(stage);
       struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
       const GLfloat (*eye)[4] = (const GLfloat (*)[4]) VB->EyePtr->data;
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index f11ac616f16..c901de05889 100644
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -39,6 +39,7 @@
 #include "light.h"
 #include "macros.h"
 #include "imports.h"
+#include "program.h"
 #include "simple_list.h"
 #include "mtypes.h"
 #include "program_instruction.h"
@@ -55,7 +56,7 @@
  */
 struct vp_stage_data {
    /** The results of running the vertex program go into these arrays. */
-   GLvector4f attribs[15];
+   GLvector4f attribs[VERT_RESULT_MAX];
 
    GLvector4f ndcCoords;              /**< normalized device coords */
    GLubyte *clipmask;                 /**< clip flags */
@@ -75,16 +76,14 @@ run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    struct vp_stage_data *store = VP_STAGE_DATA(stage);
    struct vertex_buffer *VB = &tnl->vb;
-   struct gl_vertex_program *program = ctx->VertexProgram.Current;
+   struct gl_vertex_program *program = ctx->VertexProgram._Current;
    struct vp_machine machine;
    GLuint i;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
+   if (!program || !program->IsNVProgram)
       return GL_TRUE;
 
-   if (!ctx->VertexProgram._Enabled ||
-       !program->IsNVProgram)
-      return GL_TRUE;
+   _mesa_load_state_parameters(ctx, program->Base.Parameters);
 
    /* load program parameter registers (they're read-only) */
    _mesa_init_vp_per_primitive_registers(ctx);
@@ -140,9 +139,16 @@ run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
 
       /* copy the output registers into the VB->attribs arrays */
       /* XXX (optimize) could use a conditional and smaller loop limit here */
-      for (attr = 0; attr < 15; attr++) {
+      for (attr = 0; attr < VERT_RESULT_MAX; attr++) {
          COPY_4V(store->attribs[attr].data[i], machine.Outputs[attr]);
       }
+#if 0
+      printf("HPOS: %f %f %f %f\n",
+             machine.Outputs[0][0], 
+             machine.Outputs[0][1], 
+             machine.Outputs[0][2], 
+             machine.Outputs[0][3]);
+#endif
    }
 
    /* Setup the VB pointers so that the next pipeline stages get
@@ -227,8 +233,7 @@ static GLboolean init_vp( GLcontext *ctx,
       return GL_FALSE;
 
    /* Allocate arrays of vertex output values */
-   /* XXX change '15' to a named constant */
-   for (i = 0; i < 15; i++) {
+   for (i = 0; i < VERT_RESULT_MAX; i++) {
       _mesa_vector4f_alloc( &store->attribs[i], 0, size, 32 );
       store->attribs[i].size = 4;
    }
diff --git a/src/mesa/tnl/t_vb_texgen.c b/src/mesa/tnl/t_vb_texgen.c
index 5f7b2dccd8f..e98ab743c5e 100644
--- a/src/mesa/tnl/t_vb_texgen.c
+++ b/src/mesa/tnl/t_vb_texgen.c
@@ -488,10 +488,7 @@ static GLboolean run_texgen_stage( GLcontext *ctx,
    struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
    GLuint i;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Enabled) 
+   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
       return GL_TRUE;
 
    for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
@@ -516,10 +513,7 @@ static void validate_texgen_stage( GLcontext *ctx,
    struct texgen_stage_data *store = TEXGEN_STAGE_DATA(stage);
    GLuint i;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return;
-
-   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Enabled) 
+   if (!ctx->Texture._TexGenEnabled || ctx->VertexProgram._Current) 
       return;
 
    for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++) {
diff --git a/src/mesa/tnl/t_vb_texmat.c b/src/mesa/tnl/t_vb_texmat.c
index fa9222c0f14..674d36f8cbe 100644
--- a/src/mesa/tnl/t_vb_texmat.c
+++ b/src/mesa/tnl/t_vb_texmat.c
@@ -61,10 +61,7 @@ static GLboolean run_texmat_stage( GLcontext *ctx,
    struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
    GLuint i;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (!ctx->Texture._TexMatEnabled || ctx->VertexProgram._Enabled) 
+   if (!ctx->Texture._TexMatEnabled || ctx->VertexProgram._Current) 
       return GL_TRUE;
 
    /* ENABLE_TEXMAT implies that the texture matrix is not the
diff --git a/src/mesa/tnl/t_vb_vertex.c b/src/mesa/tnl/t_vb_vertex.c
index 100fca2a226..276305b5e67 100644
--- a/src/mesa/tnl/t_vb_vertex.c
+++ b/src/mesa/tnl/t_vb_vertex.c
@@ -126,10 +126,7 @@ static GLboolean run_vertex_stage( GLcontext *ctx,
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    struct vertex_buffer *VB = &tnl->vb;
 
-   if (ctx->ShaderObjects._VertexShaderPresent)
-      return GL_TRUE;
-
-   if (ctx->VertexProgram._Enabled) 
+   if (ctx->VertexProgram._Current) 
       return GL_TRUE;
 
    if (ctx->_NeedEyeCoords) {
diff --git a/src/mesa/tnl/t_vp_build.c b/src/mesa/tnl/t_vp_build.c
index 805d05ae728..a68127e653a 100644
--- a/src/mesa/tnl/t_vp_build.c
+++ b/src/mesa/tnl/t_vp_build.c
@@ -382,11 +382,14 @@ static struct ureg register_const4f( struct tnl_program *p,
 {
    GLfloat values[4];
    GLint idx;
+   GLuint swizzle;
    values[0] = s0;
    values[1] = s1;
    values[2] = s2;
    values[3] = s3;
-   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4 );
+   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
+                                     &swizzle );
+   ASSERT(swizzle == SWIZZLE_NOOP);
    return make_ureg(PROGRAM_STATE_VAR, idx);
 }
 
@@ -1495,7 +1498,7 @@ void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
    GLuint hash;
    const struct gl_vertex_program *prev = ctx->VertexProgram._Current;
 
-   if (ctx->VertexProgram._Enabled == GL_FALSE) { 
+   if (!ctx->VertexProgram._Current) {
       /* Grab all the relevent state and put it in a single structure:
        */
       key = make_state_key(ctx);
@@ -1503,45 +1506,42 @@ void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
 
       /* Look for an already-prepared program for this state:
        */
-      ctx->_TnlProgram = (struct gl_vertex_program *)
+      ctx->VertexProgram._TnlProgram = (struct gl_vertex_program *)
 	 search_cache( tnl->vp_cache, hash, key, sizeof(*key) );
    
       /* OK, we'll have to build a new one:
        */
-      if (!ctx->_TnlProgram) {
+      if (!ctx->VertexProgram._TnlProgram) {
 	 if (0)
 	    _mesa_printf("Build new TNL program\n");
 	 
-	 ctx->_TnlProgram = (struct gl_vertex_program *)
+	 ctx->VertexProgram._TnlProgram = (struct gl_vertex_program *)
 	    ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); 
 
-	 create_new_program( key, ctx->_TnlProgram, 
+	 create_new_program( key, ctx->VertexProgram._TnlProgram, 
 			     ctx->Const.VertexProgram.MaxTemps );
 
 	 if (ctx->Driver.ProgramStringNotify)
 	    ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB, 
-					     &ctx->_TnlProgram->Base );
+                                       &ctx->VertexProgram._TnlProgram->Base );
 
-	 cache_item(tnl->vp_cache, hash, key, ctx->_TnlProgram );
+	 cache_item(tnl->vp_cache, hash, key, ctx->VertexProgram._TnlProgram );
       }
       else {
 	 FREE(key);
 	 if (0) 
 	    _mesa_printf("Found existing TNL program for key %x\n", hash);
       }
-      ctx->VertexProgram._Current = ctx->_TnlProgram;
-   }
-   else {
-      ctx->VertexProgram._Current = ctx->VertexProgram.Current;
+      ctx->VertexProgram._Current = ctx->VertexProgram._TnlProgram;
    }
 
    /* Tell the driver about the change.  Could define a new target for
     * this?
     */
-   if (ctx->VertexProgram._Current != prev &&
-       ctx->Driver.BindProgram) 
+   if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) {
       ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
                             (struct gl_program *) ctx->VertexProgram._Current);
+   }
 }
 
 void _tnl_ProgramCacheInit( GLcontext *ctx )
diff --git a/src/mesa/tnl/t_vtx_eval.c b/src/mesa/tnl/t_vtx_eval.c
index 71564076e37..bb621ecbe39 100644
--- a/src/mesa/tnl/t_vtx_eval.c
+++ b/src/mesa/tnl/t_vtx_eval.c
@@ -123,8 +123,7 @@ void _tnl_update_eval( GLcontext *ctx )
     * We do this after the conventional attributes since the spec says that
     * these generic maps have higher priority.
     */
-   if (ctx->VertexProgram._Enabled &&
-       ctx->VertexProgram._Current &&
+   if (ctx->VertexProgram._Current &&
        ctx->VertexProgram._Current->IsNVProgram) {
       for (attr = 0; attr < 16; attr++) {
 	 if (ctx->Eval.Map1Attrib[attr])