vertex program check-in

1 files changed, 852 insertions, 754 deletions

diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index a1adf1de821..758426d0e4b 100644
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -1,4 +1,4 @@
-/* $Id: enable.c,v 1.50 2001/06/26 01:32:48 brianp Exp $ */
+/* $Id: enable.c,v 1.51 2001/12/14 02:50:01 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -37,13 +37,20 @@
 #include "simple_list.h"
 #include "mtypes.h"
 #include "enums.h"
-
 #include "math/m_matrix.h"
 #include "math/m_xform.h"
-
 #endif
 
 
+#define CHECK_EXTENSION(EXTNAME)					\
+   if (!ctx->Extensions.EXTNAME) {					\
+      _mesa_error(ctx, GL_INVALID_ENUM,					\
+         state ? "glEnableClientState": "glDisableClientState");	\
+      return;								\
+   }
+
+
+
 static void
 client_state( GLcontext *ctx, GLenum cap, GLboolean state )
 {
@@ -51,41 +58,66 @@ client_state( GLcontext *ctx, GLenum cap, GLboolean state )
    GLboolean *var;
 
    switch (cap) {
-   case GL_VERTEX_ARRAY:
-      var = &ctx->Array.Vertex.Enabled;
-      flag = _NEW_ARRAY_VERTEX;
-      break;
-   case GL_NORMAL_ARRAY:
-      var = &ctx->Array.Normal.Enabled;
-      flag = _NEW_ARRAY_NORMAL;
-      break;
-   case GL_COLOR_ARRAY:
-      var = &ctx->Array.Color.Enabled;
-      flag = _NEW_ARRAY_COLOR;
-      break;
-   case GL_INDEX_ARRAY:
-      var = &ctx->Array.Index.Enabled;
-      flag = _NEW_ARRAY_INDEX;
-      break;
-   case GL_TEXTURE_COORD_ARRAY:
-      var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
-      flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
-      break;
-   case GL_EDGE_FLAG_ARRAY:
-      var = &ctx->Array.EdgeFlag.Enabled;
-      flag = _NEW_ARRAY_EDGEFLAG;
-      break;
-   case GL_FOG_COORDINATE_ARRAY_EXT:
-      var = &ctx->Array.FogCoord.Enabled;
-      flag = _NEW_ARRAY_FOGCOORD;
-      break;
-   case GL_SECONDARY_COLOR_ARRAY_EXT:
-      var = &ctx->Array.SecondaryColor.Enabled;
-      flag = _NEW_ARRAY_SECONDARYCOLOR;
-      break;
-   default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
-      return;
+      case GL_VERTEX_ARRAY:
+         var = &ctx->Array.Vertex.Enabled;
+         flag = _NEW_ARRAY_VERTEX;
+         break;
+      case GL_NORMAL_ARRAY:
+         var = &ctx->Array.Normal.Enabled;
+         flag = _NEW_ARRAY_NORMAL;
+         break;
+      case GL_COLOR_ARRAY:
+         var = &ctx->Array.Color.Enabled;
+         flag = _NEW_ARRAY_COLOR0;
+         break;
+      case GL_INDEX_ARRAY:
+         var = &ctx->Array.Index.Enabled;
+         flag = _NEW_ARRAY_INDEX;
+         break;
+      case GL_TEXTURE_COORD_ARRAY:
+         var = &ctx->Array.TexCoord[ctx->Array.ActiveTexture].Enabled;
+         flag = _NEW_ARRAY_TEXCOORD(ctx->Array.ActiveTexture);
+         break;
+      case GL_EDGE_FLAG_ARRAY:
+         var = &ctx->Array.EdgeFlag.Enabled;
+         flag = _NEW_ARRAY_EDGEFLAG;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         var = &ctx->Array.FogCoord.Enabled;
+         flag = _NEW_ARRAY_FOGCOORD;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         var = &ctx->Array.SecondaryColor.Enabled;
+         flag = _NEW_ARRAY_COLOR1;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         {
+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            var = &ctx->Array.VertexAttrib[n].Enabled;
+            flag = _NEW_ARRAY_VERT_ATTRIB0;  /* XXX flag OK? */
+         }
+         break;
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
+         return;
    }
 
    if (*var == flag)
@@ -126,6 +158,15 @@ _mesa_DisableClientState( GLenum cap )
 }
 
 
+#undef CHECK_EXTENSION
+#define CHECK_EXTENSION(EXTNAME)			\
+   if (!ctx->Extensions.EXTNAME) {			\
+      _mesa_error(ctx, GL_INVALID_ENUM,			\
+                  state ? "glEnable": "glDisable");	\
+      return;						\
+   }
+
+
 /*
  * Perform glEnable and glDisable calls.
  */
@@ -138,680 +179,686 @@ void _mesa_set_enable( GLcontext *ctx, GLenum cap, GLboolean state )
 	      ctx->NewState);
 
    switch (cap) {
-   case GL_ALPHA_TEST:
-      if (ctx->Color.AlphaEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.AlphaEnabled = state;
-      break;
-   case GL_AUTO_NORMAL:
-      if (ctx->Eval.AutoNormal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.AutoNormal = state;
-      break;
-   case GL_BLEND:
-      if (ctx->Color.BlendEnabled == state)
-	 return;
-
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.BlendEnabled = state;
-      /* The following needed to accomodate 1.0 RGB logic op blending */
-      ctx->Color.ColorLogicOpEnabled =
-	 (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
-      break;
-   case GL_CLIP_PLANE0:
-   case GL_CLIP_PLANE1:
-   case GL_CLIP_PLANE2:
-   case GL_CLIP_PLANE3:
-   case GL_CLIP_PLANE4:
-   case GL_CLIP_PLANE5: {
-      GLuint p = cap-GL_CLIP_PLANE0;
-
-      if (ctx->Transform.ClipEnabled[p] == state)
-	 return;
-
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.ClipEnabled[p] = state;
-
-      if (state) {
-	 ctx->Transform._AnyClip++;
-
-	 if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
-	    _math_matrix_analyse( &ctx->ProjectionMatrix );
-	 }
-
-	 /* This derived state also calculated in clip.c and
-	  * from _mesa_update_state() on changes to EyeUserPlane
-	  * and ctx->ProjectionMatrix respectively.
-	  */
-	 _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
-			      ctx->Transform.EyeUserPlane[p],
-			      ctx->ProjectionMatrix.inv );
+      case GL_ALPHA_TEST:
+         if (ctx->Color.AlphaEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.AlphaEnabled = state;
+         break;
+      case GL_AUTO_NORMAL:
+         if (ctx->Eval.AutoNormal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.AutoNormal = state;
+         break;
+      case GL_BLEND:
+         if (ctx->Color.BlendEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.BlendEnabled = state;
+         /* The following needed to accomodate 1.0 RGB logic op blending */
+         ctx->Color.ColorLogicOpEnabled =
+            (ctx->Color.BlendEquation == GL_LOGIC_OP && state);
+         break;
+      case GL_CLIP_PLANE0:
+      case GL_CLIP_PLANE1:
+      case GL_CLIP_PLANE2:
+      case GL_CLIP_PLANE3:
+      case GL_CLIP_PLANE4:
+      case GL_CLIP_PLANE5:
+         {
+            GLuint p = cap-GL_CLIP_PLANE0;
+
+            if (ctx->Transform.ClipEnabled[p] == state)
+               return;
+
+            FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+            ctx->Transform.ClipEnabled[p] = state;
+
+            if (state) {
+               ctx->Transform._AnyClip++;
+
+               if (ctx->ProjectionMatrix.flags & MAT_DIRTY) {
+                  _math_matrix_analyse( &ctx->ProjectionMatrix );
+               }
+
+               /* This derived state also calculated in clip.c and
+                * from _mesa_update_state() on changes to EyeUserPlane
+                * and ctx->ProjectionMatrix respectively.
+                */
+               _mesa_transform_vector( ctx->Transform._ClipUserPlane[p],
+                                    ctx->Transform.EyeUserPlane[p],
+                                    ctx->ProjectionMatrix.inv );
+            }
+         }
+         break;
+      case GL_COLOR_MATERIAL:
+         if (ctx->Light.ColorMaterialEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.ColorMaterialEnabled = state;
+         if (state) {
+            FLUSH_CURRENT(ctx, 0);
+            _mesa_update_color_material( ctx,
+                                  ctx->Current.Attrib[VERT_ATTRIB_COLOR0] );
+         }
+         break;
+      case GL_CULL_FACE:
+         if (ctx->Polygon.CullFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.CullFlag = state;
+         break;
+      case GL_DEPTH_TEST:
+         if (state && ctx->Visual.depthBits==0) {
+            _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
+            return;
+         }
+         if (ctx->Depth.Test==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_DEPTH);
+         ctx->Depth.Test = state;
+         break;
+      case GL_DITHER:
+         if (ctx->NoDither) {
+            state = GL_FALSE; /* MESA_NO_DITHER env var */
+         }
+         if (ctx->Color.DitherFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.DitherFlag = state;
+         break;
+      case GL_FOG:
+         if (ctx->Fog.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.Enabled = state;
+         break;
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION(EXT_histogram);
+         if (ctx->Pixel.HistogramEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.HistogramEnabled = state;
+         break;
+      case GL_LIGHT0:
+      case GL_LIGHT1:
+      case GL_LIGHT2:
+      case GL_LIGHT3:
+      case GL_LIGHT4:
+      case GL_LIGHT5:
+      case GL_LIGHT6:
+      case GL_LIGHT7:
+         if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
+         if (state) {
+            insert_at_tail(&ctx->Light.EnabledList,
+                           &ctx->Light.Light[cap-GL_LIGHT0]);
+         }
+         else {
+            remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
+         }
+         break;
+      case GL_LIGHTING:
+         if (ctx->Light.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LIGHT);
+         ctx->Light.Enabled = state;
+
+         if ((ctx->Light.Enabled &&
+              ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+             || ctx->Fog.ColorSumEnabled)
+            ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+         else
+            ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+         break;
+      case GL_LINE_SMOOTH:
+         if (ctx->Line.SmoothFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LINE);
+         ctx->Line.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
+         break;
+      case GL_LINE_STIPPLE:
+         if (ctx->Line.StippleFlag == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_LINE);
+         ctx->Line.StippleFlag = state;
+         ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
+         break;
+      case GL_INDEX_LOGIC_OP:
+         if (ctx->Color.IndexLogicOpEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.IndexLogicOpEnabled = state;
+         break;
+      case GL_COLOR_LOGIC_OP:
+         if (ctx->Color.ColorLogicOpEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_COLOR);
+         ctx->Color.ColorLogicOpEnabled = state;
+         break;
+      case GL_MAP1_COLOR_4:
+         if (ctx->Eval.Map1Color4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Color4 = state;
+         break;
+      case GL_MAP1_INDEX:
+         if (ctx->Eval.Map1Index == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Index = state;
+         break;
+      case GL_MAP1_NORMAL:
+         if (ctx->Eval.Map1Normal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Normal = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_1:
+         if (ctx->Eval.Map1TextureCoord1 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord1 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_2:
+         if (ctx->Eval.Map1TextureCoord2 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord2 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_3:
+         if (ctx->Eval.Map1TextureCoord3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord3 = state;
+         break;
+      case GL_MAP1_TEXTURE_COORD_4:
+         if (ctx->Eval.Map1TextureCoord4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1TextureCoord4 = state;
+         break;
+      case GL_MAP1_VERTEX_3:
+         if (ctx->Eval.Map1Vertex3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Vertex3 = state;
+         break;
+      case GL_MAP1_VERTEX_4:
+         if (ctx->Eval.Map1Vertex4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map1Vertex4 = state;
+         break;
+      case GL_MAP2_COLOR_4:
+         if (ctx->Eval.Map2Color4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Color4 = state;
+         break;
+      case GL_MAP2_INDEX:
+         if (ctx->Eval.Map2Index == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Index = state;
+         break;
+      case GL_MAP2_NORMAL:
+         if (ctx->Eval.Map2Normal == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Normal = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_1:
+         if (ctx->Eval.Map2TextureCoord1 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord1 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_2:
+         if (ctx->Eval.Map2TextureCoord2 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord2 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_3:
+         if (ctx->Eval.Map2TextureCoord3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord3 = state;
+         break;
+      case GL_MAP2_TEXTURE_COORD_4:
+         if (ctx->Eval.Map2TextureCoord4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2TextureCoord4 = state;
+         break;
+      case GL_MAP2_VERTEX_3:
+         if (ctx->Eval.Map2Vertex3 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Vertex3 = state;
+         break;
+      case GL_MAP2_VERTEX_4:
+         if (ctx->Eval.Map2Vertex4 == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_EVAL);
+         ctx->Eval.Map2Vertex4 = state;
+         break;
+      case GL_MINMAX:
+         if (ctx->Pixel.MinMaxEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.MinMaxEnabled = state;
+         break;
+      case GL_NORMALIZE:
+         if (ctx->Transform.Normalize == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.Normalize = state;
+         break;
+      case GL_POINT_SMOOTH:
+         if (ctx->Point.SmoothFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POINT);
+         ctx->Point.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
+         break;
+      case GL_POLYGON_SMOOTH:
+         if (ctx->Polygon.SmoothFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.SmoothFlag = state;
+         ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
+         break;
+      case GL_POLYGON_STIPPLE:
+         if (ctx->Polygon.StippleFlag==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.StippleFlag = state;
+         ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
+         break;
+      case GL_POLYGON_OFFSET_POINT:
+         if (ctx->Polygon.OffsetPoint==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetPoint = state;
+         break;
+      case GL_POLYGON_OFFSET_LINE:
+         if (ctx->Polygon.OffsetLine==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetLine = state;
+         break;
+      case GL_POLYGON_OFFSET_FILL:
+         /*case GL_POLYGON_OFFSET_EXT:*/
+         if (ctx->Polygon.OffsetFill==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POLYGON);
+         ctx->Polygon.OffsetFill = state;
+         break;
+      case GL_RESCALE_NORMAL_EXT:
+         if (ctx->Transform.RescaleNormals == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.RescaleNormals = state;
+         break;
+      case GL_SCISSOR_TEST:
+         if (ctx->Scissor.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_SCISSOR);
+         ctx->Scissor.Enabled = state;
+         break;
+      case GL_SHARED_TEXTURE_PALETTE_EXT:
+         if (ctx->Texture.SharedPalette == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         ctx->Texture.SharedPalette = state;
+         break;
+      case GL_STENCIL_TEST:
+         if (state && ctx->Visual.stencilBits==0) {
+            _mesa_warning(ctx,
+                          "glEnable(GL_STENCIL_TEST) but no stencil buffer");
+            return;
+         }
+         if (ctx->Stencil.Enabled==state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_STENCIL);
+         ctx->Stencil.Enabled = state;
+         break;
+      case GL_TEXTURE_1D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
+         if (state)
+            newenabled |= TEXTURE0_1D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-   }
-   break;
-   case GL_COLOR_MATERIAL:
-      if (ctx->Light.ColorMaterialEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.ColorMaterialEnabled = state;
-      if (state) {
-	 FLUSH_CURRENT(ctx, 0);
-	 _mesa_update_color_material( ctx, ctx->Current.Color );
+      case GL_TEXTURE_2D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
+         if (state)
+            newenabled |= TEXTURE0_2D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-      break;
-   case GL_CULL_FACE:
-      if (ctx->Polygon.CullFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.CullFlag = state;
-      break;
-   case GL_DEPTH_TEST:
-      if (state && ctx->Visual.depthBits==0) {
-	 _mesa_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
-	 return;
+      case GL_TEXTURE_3D: {
+         const GLuint curr = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+         GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
+         if (state)
+            newenabled |= TEXTURE0_3D;
+         if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->Enabled = newenabled;
+         break;
       }
-      if (ctx->Depth.Test==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_DEPTH);
-      ctx->Depth.Test = state;
-      break;
-   case GL_DITHER:
-      if (ctx->NoDither) {
-	 state = GL_FALSE; /* MESA_NO_DITHER env var */
+      case GL_TEXTURE_GEN_Q: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
+         if (state)
+            newenabled |= Q_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Color.DitherFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.DitherFlag = state;
-      break;
-   case GL_FOG:
-      if (ctx->Fog.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_FOG);
-      ctx->Fog.Enabled = state;
-      break;
-   case GL_HISTOGRAM:
-      if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, "glEnable(GL_HISTOGRAM)");
-	 return;
+      case GL_TEXTURE_GEN_R: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
+         if (state)
+            newenabled |= R_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Pixel.HistogramEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.HistogramEnabled = state;
       break;
-   case GL_LIGHT0:
-   case GL_LIGHT1:
-   case GL_LIGHT2:
-   case GL_LIGHT3:
-   case GL_LIGHT4:
-   case GL_LIGHT5:
-   case GL_LIGHT6:
-   case GL_LIGHT7:
-      if (ctx->Light.Light[cap-GL_LIGHT0].Enabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
-      if (state) {
-	 insert_at_tail(&ctx->Light.EnabledList,
-			&ctx->Light.Light[cap-GL_LIGHT0]);
-      }
-      else {
-	 remove_from_list(&ctx->Light.Light[cap-GL_LIGHT0]);
+      case GL_TEXTURE_GEN_S: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
+         if (state)
+            newenabled |= S_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
       break;
-   case GL_LIGHTING:
-      if (ctx->Light.Enabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      ctx->Light.Enabled = state;
-
-      if ((ctx->Light.Enabled &&
-	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
-	  || ctx->Fog.ColorSumEnabled)
-	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-      else
-	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
-
-      break;
-   case GL_LINE_SMOOTH:
-      if (ctx->Line.SmoothFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LINE);
-      ctx->Line.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_LINE_SMOOTH;
-      break;
-   case GL_LINE_STIPPLE:
-      if (ctx->Line.StippleFlag == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_LINE);
-      ctx->Line.StippleFlag = state;
-      ctx->_TriangleCaps ^= DD_LINE_STIPPLE;
-      break;
-   case GL_INDEX_LOGIC_OP:
-      if (ctx->Color.IndexLogicOpEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.IndexLogicOpEnabled = state;
-      break;
-   case GL_COLOR_LOGIC_OP:
-      if (ctx->Color.ColorLogicOpEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_COLOR);
-      ctx->Color.ColorLogicOpEnabled = state;
-      break;
-   case GL_MAP1_COLOR_4:
-      if (ctx->Eval.Map1Color4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Color4 = state;
-      break;
-   case GL_MAP1_INDEX:
-      if (ctx->Eval.Map1Index == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Index = state;
-      break;
-   case GL_MAP1_NORMAL:
-      if (ctx->Eval.Map1Normal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Normal = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_1:
-      if (ctx->Eval.Map1TextureCoord1 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord1 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_2:
-      if (ctx->Eval.Map1TextureCoord2 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord2 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_3:
-      if (ctx->Eval.Map1TextureCoord3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord3 = state;
-      break;
-   case GL_MAP1_TEXTURE_COORD_4:
-      if (ctx->Eval.Map1TextureCoord4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1TextureCoord4 = state;
-      break;
-   case GL_MAP1_VERTEX_3:
-      if (ctx->Eval.Map1Vertex3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Vertex3 = state;
-      break;
-   case GL_MAP1_VERTEX_4:
-      if (ctx->Eval.Map1Vertex4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map1Vertex4 = state;
-      break;
-   case GL_MAP2_COLOR_4:
-      if (ctx->Eval.Map2Color4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Color4 = state;
-      break;
-   case GL_MAP2_INDEX:
-      if (ctx->Eval.Map2Index == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Index = state;
-      break;
-   case GL_MAP2_NORMAL:
-      if (ctx->Eval.Map2Normal == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Normal = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_1:
-      if (ctx->Eval.Map2TextureCoord1 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord1 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_2:
-      if (ctx->Eval.Map2TextureCoord2 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord2 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_3:
-      if (ctx->Eval.Map2TextureCoord3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord3 = state;
-      break;
-   case GL_MAP2_TEXTURE_COORD_4:
-      if (ctx->Eval.Map2TextureCoord4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2TextureCoord4 = state;
-      break;
-   case GL_MAP2_VERTEX_3:
-      if (ctx->Eval.Map2Vertex3 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Vertex3 = state;
-      break;
-   case GL_MAP2_VERTEX_4:
-      if (ctx->Eval.Map2Vertex4 == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_EVAL);
-      ctx->Eval.Map2Vertex4 = state;
-      break;
-   case GL_MINMAX:
-      if (ctx->Pixel.MinMaxEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.MinMaxEnabled = state;
-      break;
-   case GL_NORMALIZE:
-      if (ctx->Transform.Normalize == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.Normalize = state;
-      break;
-   case GL_POINT_SMOOTH:
-      if (ctx->Point.SmoothFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POINT);
-      ctx->Point.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_POINT_SMOOTH;
-      break;
-   case GL_POLYGON_SMOOTH:
-      if (ctx->Polygon.SmoothFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.SmoothFlag = state;
-      ctx->_TriangleCaps ^= DD_TRI_SMOOTH;
-      break;
-   case GL_POLYGON_STIPPLE:
-      if (ctx->Polygon.StippleFlag==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.StippleFlag = state;
-      ctx->_TriangleCaps ^= DD_TRI_STIPPLE;
-      break;
-   case GL_POLYGON_OFFSET_POINT:
-      if (ctx->Polygon.OffsetPoint==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetPoint = state;
-      break;
-   case GL_POLYGON_OFFSET_LINE:
-      if (ctx->Polygon.OffsetLine==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetLine = state;
-      break;
-   case GL_POLYGON_OFFSET_FILL:
-      /*case GL_POLYGON_OFFSET_EXT:*/
-      if (ctx->Polygon.OffsetFill==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POLYGON);
-      ctx->Polygon.OffsetFill = state;
-      break;
-   case GL_RESCALE_NORMAL_EXT:
-      if (ctx->Transform.RescaleNormals == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.RescaleNormals = state;
-      break;
-   case GL_SCISSOR_TEST:
-      if (ctx->Scissor.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_SCISSOR);
-      ctx->Scissor.Enabled = state;
-      break;
-   case GL_SHARED_TEXTURE_PALETTE_EXT:
-      if (ctx->Texture.SharedPalette == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      ctx->Texture.SharedPalette = state;
-      break;
-   case GL_STENCIL_TEST:
-      if (state && ctx->Visual.stencilBits==0) {
-	 _mesa_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
-	 return;
+      case GL_TEXTURE_GEN_T: {
+         GLuint unit = ctx->Texture.CurrentUnit;
+         struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+         GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
+         if (state)
+            newenabled |= T_BIT;
+         if (texUnit->TexGenEnabled == newenabled)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->TexGenEnabled = newenabled;
+         break;
       }
-      if (ctx->Stencil.Enabled==state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.Enabled = state;
       break;
-   case GL_TEXTURE_1D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_1D;
-      if (state)
-	 newenabled |= TEXTURE0_1D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_2D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_2D;
-      if (state)
-	 newenabled |= TEXTURE0_2D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_3D: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_3D;
-      if (state)
-	 newenabled |= TEXTURE0_3D;
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_GEN_Q: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~Q_BIT;
-      if (state)
-	 newenabled |= Q_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   case GL_TEXTURE_GEN_R: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~R_BIT;
-      if (state)
-	 newenabled |= R_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-   case GL_TEXTURE_GEN_S: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~S_BIT;
-      if (state)
-	 newenabled |= S_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-   case GL_TEXTURE_GEN_T: {
-      GLuint unit = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLuint newenabled = texUnit->TexGenEnabled & ~T_BIT;
-      if (state)
-	 newenabled |= T_BIT;
-      if (texUnit->TexGenEnabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->TexGenEnabled = newenabled;
-      break;
-   }
-   break;
-
-   /*
-    * CLIENT STATE!!!
-    */
-   case GL_VERTEX_ARRAY:
-   case GL_NORMAL_ARRAY:
-   case GL_COLOR_ARRAY:
-   case GL_INDEX_ARRAY:
-   case GL_TEXTURE_COORD_ARRAY:
-   case GL_EDGE_FLAG_ARRAY:
-   case GL_FOG_COORDINATE_ARRAY_EXT:
-   case GL_SECONDARY_COLOR_ARRAY_EXT:
-      client_state( ctx, cap, state );
-      return;
+
+      /*
+       * CLIENT STATE!!!
+       */
+      case GL_VERTEX_ARRAY:
+      case GL_NORMAL_ARRAY:
+      case GL_COLOR_ARRAY:
+      case GL_INDEX_ARRAY:
+      case GL_TEXTURE_COORD_ARRAY:
+      case GL_EDGE_FLAG_ARRAY:
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         client_state( ctx, cap, state );
+         return;
 
       /* GL_HP_occlusion_test */
-   case GL_OCCLUSION_TEST_HP:
-      if (!ctx->Extensions.HP_occlusion_test) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Depth.OcclusionTest == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_DEPTH);
-      ctx->Depth.OcclusionTest = state;
-      if (state)
-	 ctx->OcclusionResult = ctx->OcclusionResultSaved;
-      else
-	 ctx->OcclusionResultSaved = ctx->OcclusionResult;
-      break;
+      case GL_OCCLUSION_TEST_HP:
+         CHECK_EXTENSION(HP_occlusion_test);
+         if (ctx->Depth.OcclusionTest == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_DEPTH);
+         ctx->Depth.OcclusionTest = state;
+         if (state)
+            ctx->OcclusionResult = ctx->OcclusionResultSaved;
+         else
+            ctx->OcclusionResultSaved = ctx->OcclusionResult;
+         break;
 
       /* GL_SGIS_pixel_texture */
-   case GL_PIXEL_TEXTURE_SGIS:
-      if (!ctx->Extensions.SGIS_pixel_texture) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PixelTextureEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PixelTextureEnabled = state;
-      break;
+      case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION(SGIS_pixel_texture);
+         if (ctx->Pixel.PixelTextureEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PixelTextureEnabled = state;
+         break;
 
       /* GL_SGIX_pixel_texture */
-   case GL_PIXEL_TEX_GEN_SGIX:
-      if (!ctx->Extensions.SGIX_pixel_texture) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PixelTextureEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PixelTextureEnabled = state;
-      break;
+      case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION(SGIX_pixel_texture);
+         if (ctx->Pixel.PixelTextureEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PixelTextureEnabled = state;
+         break;
 
       /* GL_SGI_color_table */
-   case GL_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.ColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.ColorTableEnabled = state;
-      break;
-   case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PostConvolutionColorTableEnabled = state;
-      break;
-   case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-      if (!ctx->Extensions.SGI_color_table && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error( ctx, GL_INVALID_ENUM, state ? "glEnable": "glDisable" );
-	 return;
-      }
-      if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.PostColorMatrixColorTableEnabled = state;
-      break;
+      case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.ColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.ColorTableEnabled = state;
+         break;
+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.PostConvolutionColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PostConvolutionColorTableEnabled = state;
+         break;
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
+         if (ctx->Pixel.PostColorMatrixColorTableEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.PostColorMatrixColorTableEnabled = state;
+         break;
 
       /* GL_EXT_convolution */
-   case GL_CONVOLUTION_1D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Convolution1DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Convolution1DEnabled = state;
-      break;
-   case GL_CONVOLUTION_2D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Convolution2DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Convolution2DEnabled = state;
-      break;
-   case GL_SEPARABLE_2D:
-      if (!ctx->Extensions.EXT_convolution && !ctx->Extensions.ARB_imaging) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Pixel.Separable2DEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_PIXEL);
-      ctx->Pixel.Separable2DEnabled = state;
-      break;
+      case GL_CONVOLUTION_1D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Convolution1DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Convolution1DEnabled = state;
+         break;
+      case GL_CONVOLUTION_2D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Convolution2DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Convolution2DEnabled = state;
+         break;
+      case GL_SEPARABLE_2D:
+         CHECK_EXTENSION(EXT_convolution);
+         if (ctx->Pixel.Separable2DEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_PIXEL);
+         ctx->Pixel.Separable2DEnabled = state;
+         break;
 
       /* GL_ARB_texture_cube_map */
-   case GL_TEXTURE_CUBE_MAP_ARB: {
-      const GLuint curr = ctx->Texture.CurrentUnit;
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-      GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
-      if (state)
-	 newenabled |= TEXTURE0_CUBE;
-      if (!ctx->Extensions.ARB_texture_cube_map) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-      texUnit->Enabled = newenabled;
-      break;
-   }
-      /* GL_EXT_secondary_color */
-   case GL_COLOR_SUM_EXT:
-      if (!ctx->Extensions.EXT_secondary_color) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Fog.ColorSumEnabled == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_FOG);
-      ctx->Fog.ColorSumEnabled = state;
-
-      if ((ctx->Light.Enabled &&
-	   ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
-	  || ctx->Fog.ColorSumEnabled)
-	 ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-      else
-	 ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         {
+            const GLuint curr = ctx->Texture.CurrentUnit;
+            struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
+            GLuint newenabled = texUnit->Enabled & ~TEXTURE0_CUBE;
+            CHECK_EXTENSION(ARB_texture_cube_map);
+            if (state)
+               newenabled |= TEXTURE0_CUBE;
+            if (!ctx->Visual.rgbMode || texUnit->Enabled == newenabled)
+               return;
+            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+            texUnit->Enabled = newenabled;
+         }
+         break;
 
-      break;
+      /* GL_EXT_secondary_color */
+      case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION(EXT_secondary_color);
+         if (ctx->Fog.ColorSumEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.ColorSumEnabled = state;
+
+         if ((ctx->Light.Enabled &&
+              ctx->Light.Model.ColorControl==GL_SEPARATE_SPECULAR_COLOR)
+             || ctx->Fog.ColorSumEnabled)
+            ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
+         else
+            ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
+
+         break;
 
       /* GL_ARB_multisample */
-   case GL_MULTISAMPLE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.Enabled == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.Enabled = state;
-      break;
-   case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleAlphaToCoverage == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleAlphaToCoverage = state;
-      break;
-   case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleAlphaToOne == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleAlphaToOne = state;
-      break;
-   case GL_SAMPLE_COVERAGE_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleCoverage == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleCoverage = state;
-      break;
-   case GL_SAMPLE_COVERAGE_INVERT_ARB:
-      if (!ctx->Extensions.ARB_multisample) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Multisample.SampleCoverageInvert == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
-      ctx->Multisample.SampleCoverageInvert = state;
-      break;
+      case GL_MULTISAMPLE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.Enabled = state;
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleAlphaToCoverage == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleAlphaToCoverage = state;
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleAlphaToOne == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleAlphaToOne = state;
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleCoverage == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleCoverage = state;
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         CHECK_EXTENSION(ARB_multisample);
+         if (ctx->Multisample.SampleCoverageInvert == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
+         ctx->Multisample.SampleCoverageInvert = state;
+         break;
 
       /* GL_IBM_rasterpos_clip */
-   case GL_RASTER_POSITION_UNCLIPPED_IBM:
-      if (!ctx->Extensions.IBM_rasterpos_clip) {
-         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-         return;
-      }
-      if (ctx->Transform.RasterPositionUnclipped == state)
-         return;
-      FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
-      ctx->Transform.RasterPositionUnclipped = state;
-      break;
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION(IBM_rasterpos_clip);
+         if (ctx->Transform.RasterPositionUnclipped == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+         ctx->Transform.RasterPositionUnclipped = state;
+         break;
 
       /* GL_MESA_sprite_point */
-   case GL_SPRITE_POINT_MESA:
-      if (!ctx->Extensions.MESA_sprite_point) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-	 return;
-      }
-      if (ctx->Point.SpriteMode == state)
-	 return;
-      FLUSH_VERTICES(ctx, _NEW_POINT);
-      ctx->Point.SpriteMode = state;
-      break;
+      case GL_SPRITE_POINT_MESA:
+         CHECK_EXTENSION(MESA_sprite_point);
+         if (ctx->Point.SpriteMode == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_POINT);
+         ctx->Point.SpriteMode = state;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.Enabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.Enabled = state;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.PointSizeEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.PointSizeEnabled = state;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         if (ctx->VertexProgram.TwoSideEnabled == state)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);  /* XXX OK? */
+         ctx->VertexProgram.TwoSideEnabled = state;
+         break;
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         break;
+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         break;
 
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
-      return;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, state ? "glEnable" : "glDisable");
+         return;
    }
 
    if (ctx->Driver.Enable) {
@@ -843,6 +890,13 @@ _mesa_Disable( GLenum cap )
 }
 
 
+#undef CHECK_EXTENSION
+#define CHECK_EXTENSION(EXTNAME)			\
+   if (!ctx->Extensions.EXTNAME) {			\
+      _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");	\
+      return GL_FALSE;					\
+   }
+
 
 GLboolean
 _mesa_IsEnabled( GLenum cap )
@@ -872,14 +926,6 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Color.DitherFlag;
       case GL_FOG:
 	 return ctx->Fog.Enabled;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            return ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
       case GL_LIGHTING:
          return ctx->Light.Enabled;
       case GL_LIGHT0:
@@ -935,8 +981,6 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Eval.Map2Vertex3;
       case GL_MAP2_VERTEX_4:
 	 return ctx->Eval.Map2Vertex4;
-      case GL_MINMAX:
-         return ctx->Pixel.MinMaxEnabled;
       case GL_NORMALIZE:
 	 return ctx->Transform.Normalize;
       case GL_POINT_SMOOTH:
@@ -962,37 +1006,44 @@ _mesa_IsEnabled( GLenum cap )
 	 return ctx->Stencil.Enabled;
       case GL_TEXTURE_1D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_1D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_2D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_2D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_3D:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_3D) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_Q:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_R:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_S:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
          }
       case GL_TEXTURE_GEN_T:
          {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
          }
 
@@ -1012,107 +1063,154 @@ _mesa_IsEnabled( GLenum cap )
       case GL_EDGE_FLAG_ARRAY:
          return ctx->Array.EdgeFlag.Enabled;
 
+      /* GL_EXT_histogram */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION(EXT_histogram);
+         return ctx->Pixel.HistogramEnabled;
+      case GL_MINMAX:
+         CHECK_EXTENSION(EXT_histogram);
+         return ctx->Pixel.MinMaxEnabled;
+
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            return ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(HP_occlusion_test);
+         return ctx->Depth.OcclusionTest;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION(SGIS_pixel_texture);
          return ctx->Pixel.PixelTextureEnabled;
 
       /* GL_SGIX_pixel_texture */
       case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION(SGIX_pixel_texture);
          return ctx->Pixel.PixelTextureEnabled;
 
       /* GL_SGI_color_table */
       case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.ColorTableEnabled;
       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.PostConvolutionColorTableEnabled;
       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION(SGI_color_table);
          return ctx->Pixel.PostColorMatrixColorTableEnabled;
 
       /* GL_EXT_convolution */
       case GL_CONVOLUTION_1D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Convolution1DEnabled;
       case GL_CONVOLUTION_2D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Convolution2DEnabled;
       case GL_SEPARABLE_2D:
+         CHECK_EXTENSION(EXT_convolution);
          return ctx->Pixel.Separable2DEnabled;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map) {
-            const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         CHECK_EXTENSION(ARB_texture_cube_map);
+         {
+            const struct gl_texture_unit *texUnit;
+            texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
             return (texUnit->Enabled & TEXTURE0_CUBE) ? GL_TRUE : GL_FALSE;
          }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.Enabled;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleAlphaToCoverage;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleAlphaToOne;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleCoverage;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            return ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(ARB_multisample);
+         return ctx->Multisample.SampleCoverageInvert;
 
       /* GL_IBM_rasterpos_clip */
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
-         if (ctx->Extensions.IBM_rasterpos_clip) {
-            return ctx->Transform.RasterPositionUnclipped;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled");
-            return GL_FALSE;
-         }
+         CHECK_EXTENSION(IBM_rasterpos_clip);
+         return ctx->Transform.RasterPositionUnclipped;
 
       /* GL_MESA_sprite_point */
       case GL_SPRITE_POINT_MESA:
          return ctx->Point.SpriteMode;
 
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.Enabled;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.PointSizeEnabled;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return ctx->VertexProgram.TwoSideEnabled;
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         {
+            GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            return ctx->Array.VertexAttrib[n].Enabled;
+         }
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return GL_FALSE;
+      case GL_MAP2_VERTEX_ATTRIB0_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB1_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB2_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB3_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB4_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB5_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB6_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB7_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB8_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB9_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB10_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB11_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB12_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB13_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB14_4_NV:
+      case GL_MAP2_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXTENSION(NV_vertex_program);
+         return GL_FALSE;
+
       default:
 	 _mesa_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
 	 return GL_FALSE;