Moved GL_PROGRAM_ERROR_POSITION_NV state (it's not per-program).

[mesa.git] / src / mesa / main / get.c

diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index 58e1605fb2f70eca0f5f6cdd63494dae5f60c869..73e924e6b395c5a245f742cca0e6f9175bc6a084 100644 (file)
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -1,10 +1,10 @@
-/* $Id: get.c,v 1.64 2001/06/20 18:54:43 brianp Exp $ */
+/* $Id: get.c,v 1.83 2002/06/18 16:53:46 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  4.1
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -59,6 +59,42 @@
 #endif
 
 
+/* Check if named extension is enabled, if not generate error and return */
+
+#define CHECK_EXTENSION_B(EXTNAME, PNAME)                      \
+   if (!ctx->Extensions.EXTNAME) {                             \
+      char s[100];                                             \
+      sprintf(s, "glGetBooleanv(0x%x)", (int) PNAME);          \
+      _mesa_error(ctx, GL_INVALID_VALUE, s);                   \
+      return;                                                  \
+   }   
+
+#define CHECK_EXTENSION_I(EXTNAME, PNAME)                      \
+   if (!ctx->Extensions.EXTNAME) {                             \
+      char s[100];                                             \
+      sprintf(s, "glGetIntegerv(0x%x)", (int) PNAME);          \
+      _mesa_error(ctx, GL_INVALID_VALUE, s);                   \
+      return;                                                  \
+   }   
+
+#define CHECK_EXTENSION_F(EXTNAME, PNAME)                      \
+   if (!ctx->Extensions.EXTNAME) {                             \
+      char s[100];                                             \
+      sprintf(s, "glGetFloatv(0x%x)", (int) PNAME);            \
+      _mesa_error(ctx, GL_INVALID_VALUE, s);                   \
+      return;                                                  \
+   }   
+
+#define CHECK_EXTENSION_D(EXTNAME, PNAME)                      \
+   if (!ctx->Extensions.EXTNAME) {                             \
+      char s[100];                                             \
+      sprintf(s, "glGetDoublev(0x%x)", (int) PNAME);           \
+      _mesa_error(ctx, GL_INVALID_VALUE, s);                   \
+      return;                                                  \
+   }   
+
+
+
 
 static GLenum
 pixel_texgen_mode(const GLcontext *ctx)
@@ -100,7 +136,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
    FLUSH_VERTICES(ctx, 0);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetBooleanv %s\n", _mesa_lookup_enum_by_nr(pname));
+      _mesa_debug(ctx, "glGetBooleanv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetBooleanv
        && (*ctx->Driver.GetBooleanv)(ctx, pname, params))
@@ -200,7 +236,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_CLIP_PLANE3:
       case GL_CLIP_PLANE4:
       case GL_CLIP_PLANE5:
-         *params = ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
+         if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
+            *params = GL_TRUE;
+         else
+            *params = GL_FALSE;
          break;
       case GL_COLOR_CLEAR_VALUE:
          params[0] = ctx->Color.ClearColor[0] ? GL_TRUE : GL_FALSE;
@@ -231,10 +270,10 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_CURRENT_COLOR:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Color[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Color[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Color[2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.Color[3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
          break;
       case GL_CURRENT_INDEX:
         FLUSH_CURRENT(ctx, 0);
@@ -242,9 +281,9 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_CURRENT_NORMAL:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Normal[0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Normal[1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Normal[2]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
          break;
       case GL_CURRENT_RASTER_COLOR:
         params[0] = FLOAT_TO_BOOL(ctx->Current.RasterColor[0]);
@@ -265,20 +304,20 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
         params[3] = FLOAT_TO_BOOL(ctx->Current.RasterPos[3]);
         break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-         params[0] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.RasterMultiTexCoord[texUnit][3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.RasterTexCoords[texUnit][3]);
         break;
       case GL_CURRENT_RASTER_POSITION_VALID:
          *params = ctx->Current.RasterPosValid;
         break;
       case GL_CURRENT_TEXTURE_COORDS:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][0]);
-         params[1] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][1]);
-         params[2] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][2]);
-         params[3] = FLOAT_TO_BOOL(ctx->Current.Texcoord[texUnit][3]);
+         params[0] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
+         params[1] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
+         params[2] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
+         params[3] = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
         break;
       case GL_DEPTH_BIAS:
          *params = FLOAT_TO_BOOL(ctx->Pixel.DepthBias);
@@ -363,15 +402,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_GREEN_SCALE:
          *params = FLOAT_TO_BOOL(ctx->Pixel.GreenScale);
         break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram) {
-            *params = ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
-        break;
       case GL_INDEX_BITS:
          *params = INT_TO_BOOL( ctx->Visual.indexBits );
         break;
@@ -595,16 +625,13 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
         params[0] = INT_TO_BOOL(MAX_WIDTH);
         params[1] = INT_TO_BOOL(MAX_HEIGHT);
         break;
-      case GL_MINMAX:
-         *params = ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = FLOAT_TO_BOOL(ctx->ModelView.m[i]);
+           params[i] = FLOAT_TO_BOOL(ctx->ModelviewMatrixStack.Top->m[i]);
         }
         break;
       case GL_MODELVIEW_STACK_DEPTH:
-        *params = INT_TO_BOOL(ctx->ModelViewStackDepth + 1);
+         *params = INT_TO_BOOL(ctx->ModelviewMatrixStack.Depth + 1);
         break;
       case GL_NAME_STACK_DEPTH:
         *params = INT_TO_BOOL(ctx->Select.NameStackDepth);
@@ -727,11 +754,11 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
         break;
       case GL_PROJECTION_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrix.m[i]);
+           params[i] = FLOAT_TO_BOOL(ctx->ProjectionMatrixStack.Top->m[i]);
         }
         break;
       case GL_PROJECTION_STACK_DEPTH:
-        *params = INT_TO_BOOL(ctx->ProjectionStackDepth + 1);
+        *params = INT_TO_BOOL(ctx->ProjectionMatrixStack.Depth + 1);
         break;
       case GL_READ_BUFFER:
         *params = ENUM_TO_BOOL(ctx->Pixel.ReadBuffer);
@@ -852,11 +879,11 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_TEXTURE_MATRIX:
         for (i=0;i<16;i++) {
            params[i] =
-              FLOAT_TO_BOOL(ctx->TextureMatrix[texUnit].m[i]);
+              FLOAT_TO_BOOL(ctx->TextureMatrixStack[texUnit].Top->m[i]);
         }
         break;
       case GL_TEXTURE_STACK_DEPTH:
-        *params = INT_TO_BOOL(ctx->TextureStackDepth[texUnit] + 1);
+        *params = INT_TO_BOOL(ctx->TextureMatrixStack[texUnit].Depth + 1);
         break;
       case GL_UNPACK_ALIGNMENT:
         *params = INT_TO_BOOL(ctx->Unpack.Alignment);
@@ -969,61 +996,54 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_EDGE_FLAG_ARRAY_STRIDE:
          *params = INT_TO_BOOL(ctx->Array.EdgeFlag.Stride);
          break;
+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
+         *params = INT_TO_BOOL(0);
+         break;
 
       /* GL_ARB_multitexture */
       case GL_MAX_TEXTURE_UNITS_ARB:
-         *params = ctx->Const.MaxTextureUnits;
+         CHECK_EXTENSION_B(ARB_multitexture, pname);
+         *params = INT_TO_BOOL(ctx->Const.MaxTextureUnits);
          break;
       case GL_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_B(ARB_multitexture, pname);
          *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
          break;
       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_B(ARB_multitexture, pname);
          *params = INT_TO_BOOL(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
          break;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-         return;
+         CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
+         *params = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-         return;
+         CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
+         *params = INT_TO_BOOL(textureUnit->CurrentCubeMap->Name);
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_cube_map, pname);
+         *params = INT_TO_BOOL(1 << (ctx->Const.MaxCubeTextureLevels - 1));
          break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = INT_TO_BOOL(ctx->Hint.TextureCompression);
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_compression, pname);
+         *params = INT_TO_BOOL(ctx->Hint.TextureCompression);
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = INT_TO_BOOL(ctx->Const.NumCompressedTextureFormats);
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
+         CHECK_EXTENSION_B(ARB_texture_compression, pname);
+         *params = INT_TO_BOOL(ctx->Const.NumCompressedTextureFormats);
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_B(ARB_texture_compression, pname);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = INT_TO_BOOL(ctx->Const.CompressedTextureFormats[i]);
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
          break;
 
       /* GL_EXT_compiled_vertex_array */
@@ -1039,7 +1059,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1049,7 +1069,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1059,7 +1079,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1069,7 +1089,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
+            _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m);
             for (i=0;i<16;i++) {
                params[i] = FLOAT_TO_BOOL(tm[i]);
             }
@@ -1078,26 +1098,18 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-         }
+         CHECK_EXTENSION_B(HP_occlusion_test, pname);
+         *params = ctx->Depth.OcclusionTest;
          return;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = ctx->OcclusionResult;
-            else
-               *params = ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-         }
+         CHECK_EXTENSION_B(HP_occlusion_test, pname);
+         if (ctx->Depth.OcclusionTest)
+            *params = ctx->OcclusionResult;
+         else
+            *params = ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
          return;
 
       /* GL_SGIS_pixel_texture */
@@ -1116,11 +1128,11 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       /* GL_SGI_color_matrix (also in 1.2 imaging) */
       case GL_COLOR_MATRIX_SGI:
          for (i=0;i<16;i++) {
-           params[i] = FLOAT_TO_BOOL(ctx->ColorMatrix.m[i]);
+           params[i] = FLOAT_TO_BOOL(ctx->ColorMatrixStack.Top->m[i]);
         }
         break;
       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-         *params = INT_TO_BOOL(ctx->ColorStackDepth + 1);
+         *params = INT_TO_BOOL(ctx->ColorMatrixStack.Depth + 1);
          break;
       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
          *params = FLOAT_TO_BOOL(MAX_COLOR_STACK_DEPTH);
@@ -1152,63 +1164,68 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution, pname);
+         *params = ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution, pname);
+         *params = ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_convolution, pname);
+         *params = ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = INT_TO_BOOL(ctx->Const.MaxConvolutionWidth);
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = INT_TO_BOOL(ctx->Const.MaxConvolutionHeight);
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[0]);
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[1]);
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[2]);
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionScale[3]);
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[0]);
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[1]);
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_B(EXT_convolution, pname);
          *params = FLOAT_TO_BOOL(ctx->Pixel.PostConvolutionBias[2]);
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_B(EXT_histogram, pname);
+         *params = ctx->Pixel.HistogramEnabled;
+        break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_B(EXT_histogram, pname);
+         *params = ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = ctx->Pixel.ColorTableEnabled;
@@ -1222,143 +1239,243 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
         *params = ctx->Fog.ColorSumEnabled;
         break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
         FLUSH_CURRENT(ctx, 0);
-         params[0] = INT_TO_BOOL(ctx->Current.SecondaryColor[0]);
-         params[1] = INT_TO_BOOL(ctx->Current.SecondaryColor[1]);
-         params[2] = INT_TO_BOOL(ctx->Current.SecondaryColor[2]);
+         params[0] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
+         params[1] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
+         params[2] = INT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
         break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
          *params = ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
         *params = ENUM_TO_BOOL(ctx->Array.SecondaryColor.Type);
         break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
         *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
         break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_B(EXT_secondary_color, pname);
         *params = INT_TO_BOOL(ctx->Array.SecondaryColor.Stride);
         break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord, pname);
         FLUSH_CURRENT(ctx, 0);
-        *params = FLOAT_TO_BOOL(ctx->Current.FogCoord);
+        *params = FLOAT_TO_BOOL(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
         break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord, pname);
          *params = ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord, pname);
         *params = ENUM_TO_BOOL(ctx->Array.FogCoord.Type);
         break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_B(EXT_fog_coord, pname);
         *params = INT_TO_BOOL(ctx->Array.FogCoord.Stride);
         break;
 
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureLodBias);
+         break;
+
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-           *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy);
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-            return;
-         }
+         CHECK_EXTENSION_B(EXT_texture_filter_anisotropic, pname);
+         *params = FLOAT_TO_BOOL(ctx->Const.MaxTextureMaxAnisotropy);
         break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = ctx->Multisample.Enabled;
+         break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleAlphaToCoverage;
+         break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleAlphaToOne;
+         break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleCoverage;
+         break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = FLOAT_TO_BOOL(ctx->Multisample.SampleCoverageValue);
+         break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleCoverageInvert;
+         break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = 0; /* XXX fix someday */
+         break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-            return;
-         }
+         CHECK_EXTENSION_B(ARB_multisample, pname);
+         *params = 0; /* XXX fix someday */
+         break;
 
-      /* GL_MESA_sprite_point */
-      case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
-            return;
-         }
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION_B(IBM_rasterpos_clip, pname);
+         *params = ctx->Transform.RasterPositionUnclipped;
+         break;
+
+      /* GL_NV_point_sprite */
+      case GL_POINT_SPRITE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = ctx->Point.PointSprite;
+         break;
+      case GL_POINT_SPRITE_R_MODE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = ENUM_TO_BOOL(ctx->Point.SpriteRMode);
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv");
-           return;
+         CHECK_EXTENSION_B(SGIS_generate_mipmap, pname);
+         *params = ENUM_TO_BOOL(ctx->Hint.GenerateMipmap);
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = ctx->VertexProgram.Enabled;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = ctx->VertexProgram.PointSizeEnabled;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = ctx->VertexProgram.TwoSideEnabled;
+         break;
+      case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (MAX_PROGRAM_STACK_DEPTH > 0) ? GL_TRUE : GL_FALSE;
+         break;
+      case GL_MAX_TRACK_MATRICES_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (MAX_PROGRAM_MATRICES > 0) ? GL_TRUE : GL_FALSE;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (ctx->CurrentStack->Depth > 0) ? GL_TRUE : GL_FALSE;
+         break;
+      case GL_CURRENT_MATRIX_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (ctx->Transform.MatrixMode != 0) ? GL_TRUE : GL_FALSE;
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (ctx->VertexProgram.CurrentID != 0) ? GL_TRUE : GL_FALSE;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_NV:
+         CHECK_EXTENSION_B(NV_vertex_program, pname);
+         *params = (ctx->VertexProgram.ErrorPos != 0) ? GL_TRUE : GL_FALSE;
+         break;
+      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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            *params = ctx->Array.VertexAttrib[n].Enabled;
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV;
+            *params = ctx->Eval.Map1Attrib[n];
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV;
+            *params = ctx->Eval.Map2Attrib[n];
          }
          break;
 
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = INT_TO_BOOL(textureUnit->CurrentRect->Name);
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_B(NV_texture_rectangle, pname);
+         *params = INT_TO_BOOL(ctx->Const.MaxTextureRectSize);
+         break;
+
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetBooleanv" );
+         {
+            char s[100];
+            sprintf(s, "glGetBooleanv(pname=0x%x)", pname);
+            _mesa_error( ctx, GL_INVALID_ENUM, s );
+         }
    }
 }
 
@@ -1381,7 +1498,7 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
    FLUSH_VERTICES(ctx, 0);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname));
+      _mesa_debug(ctx, "glGetDoublev %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetDoublev && (*ctx->Driver.GetDoublev)(ctx, pname, params))
       return;
@@ -1480,7 +1597,10 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
       case GL_CLIP_PLANE3:
       case GL_CLIP_PLANE4:
       case GL_CLIP_PLANE5:
-         *params = (GLdouble) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
+         if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
+            *params = 1.0;
+         else
+            *params = 0.0;
          break;
       case GL_COLOR_CLEAR_VALUE:
          params[0] = (GLdouble) CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
@@ -1511,10 +1631,10 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          break;
       case GL_CURRENT_COLOR:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.Color[0]);
-         params[1] = (ctx->Current.Color[1]);
-         params[2] = (ctx->Current.Color[2]);
-         params[3] = (ctx->Current.Color[3]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
          break;
       case GL_CURRENT_INDEX:
         FLUSH_CURRENT(ctx, 0);
@@ -1522,9 +1642,9 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          break;
       case GL_CURRENT_NORMAL:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (GLdouble) ctx->Current.Normal[0];
-         params[1] = (GLdouble) ctx->Current.Normal[1];
-         params[2] = (GLdouble) ctx->Current.Normal[2];
+         params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
+         params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
+         params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
          break;
       case GL_CURRENT_RASTER_COLOR:
         params[0] = (GLdouble) ctx->Current.RasterColor[0];
@@ -1545,20 +1665,20 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
         params[3] = (GLdouble) ctx->Current.RasterPos[3];
         break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-        params[0] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][0];
-        params[1] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][1];
-        params[2] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][2];
-        params[3] = (GLdouble) ctx->Current.RasterMultiTexCoord[texUnit][3];
+        params[0] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][0];
+        params[1] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][1];
+        params[2] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][2];
+        params[3] = (GLdouble) ctx->Current.RasterTexCoords[texUnit][3];
         break;
       case GL_CURRENT_RASTER_POSITION_VALID:
         *params = (GLdouble) ctx->Current.RasterPosValid;
         break;
       case GL_CURRENT_TEXTURE_COORDS:
         FLUSH_CURRENT(ctx, 0);
-        params[0] = (GLdouble) ctx->Current.Texcoord[texUnit][0];
-        params[1] = (GLdouble) ctx->Current.Texcoord[texUnit][1];
-        params[2] = (GLdouble) ctx->Current.Texcoord[texUnit][2];
-        params[3] = (GLdouble) ctx->Current.Texcoord[texUnit][3];
+        params[0] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+        params[1] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+        params[2] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+        params[3] = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
         break;
       case GL_DEPTH_BIAS:
         *params = (GLdouble) ctx->Pixel.DepthBias;
@@ -1643,15 +1763,6 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
       case GL_GREEN_SCALE:
          *params = (GLdouble) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
-        break;
       case GL_INDEX_BITS:
          *params = (GLdouble) ctx->Visual.indexBits;
         break;
@@ -1875,16 +1986,13 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          params[0] = (GLdouble) MAX_WIDTH;
          params[1] = (GLdouble) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = (GLdouble) ctx->ModelView.m[i];
+           params[i] = (GLdouble) ctx->ModelviewMatrixStack.Top->m[i];
         }
         break;
       case GL_MODELVIEW_STACK_DEPTH:
-        *params = (GLdouble) (ctx->ModelViewStackDepth + 1);
+        *params = (GLdouble) (ctx->ModelviewMatrixStack.Depth + 1);
         break;
       case GL_NAME_STACK_DEPTH:
         *params = (GLdouble) ctx->Select.NameStackDepth;
@@ -2007,11 +2115,11 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
         break;
       case GL_PROJECTION_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = (GLdouble) ctx->ProjectionMatrix.m[i];
+           params[i] = (GLdouble) ctx->ProjectionMatrixStack.Top->m[i];
         }
         break;
       case GL_PROJECTION_STACK_DEPTH:
-        *params = (GLdouble) (ctx->ProjectionStackDepth + 1);
+        *params = (GLdouble) (ctx->ProjectionMatrixStack.Depth + 1);
         break;
       case GL_READ_BUFFER:
         *params = ENUM_TO_DOUBLE(ctx->Pixel.ReadBuffer);
@@ -2129,11 +2237,11 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
         break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-           params[i] = (GLdouble) ctx->TextureMatrix[texUnit].m[i];
+           params[i] = (GLdouble) ctx->TextureMatrixStack[texUnit].Top->m[i];
         }
         break;
       case GL_TEXTURE_STACK_DEPTH:
-        *params = (GLdouble) (ctx->TextureStackDepth[texUnit] + 1);
+        *params = (GLdouble) (ctx->TextureMatrixStack[texUnit].Depth + 1);
         break;
       case GL_UNPACK_ALIGNMENT:
         *params = (GLdouble) ctx->Unpack.Alignment;
@@ -2252,58 +2360,48 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_ARB_multitexture */
       case GL_MAX_TEXTURE_UNITS_ARB:
+         CHECK_EXTENSION_D(ARB_multitexture, pname);
          *params = (GLdouble) ctx->Const.MaxTextureUnits;
          break;
       case GL_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_D(ARB_multitexture, pname);
          *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
          break;
       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_D(ARB_multitexture, pname);
          *params = (GLdouble) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
          break;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map, pname);
+         *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map, pname);
+         *params = (GLdouble) textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-         return;
+         CHECK_EXTENSION_D(ARB_texture_cube_map, pname);
+         *params = (GLdouble) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLdouble) ctx->Hint.TextureCompression;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+         CHECK_EXTENSION_D(ARB_texture_compression, pname);
+         *params = (GLdouble) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
+         CHECK_EXTENSION_D(ARB_texture_compression, pname);
+         *params = (GLdouble) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_D(ARB_texture_compression, pname);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLdouble) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
          break;
 
       /* GL_EXT_compiled_vertex_array */
@@ -2319,7 +2417,7 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2329,7 +2427,7 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2339,7 +2437,7 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2349,7 +2447,7 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
+            _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLdouble) tm[i];
             }
@@ -2358,27 +2456,19 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLdouble) ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-         }
-         return;
+         CHECK_EXTENSION_D(HP_occlusion_test, pname);
+         *params = (GLdouble) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLdouble) ctx->OcclusionResult;
-            else
-               *params = (GLdouble) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-         }
-         return;
+         CHECK_EXTENSION_D(HP_occlusion_test, pname);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLdouble) ctx->OcclusionResult;
+         else
+            *params = (GLdouble) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
@@ -2396,11 +2486,11 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
       /* GL_SGI_color_matrix (also in 1.2 imaging) */
       case GL_COLOR_MATRIX_SGI:
          for (i=0;i<16;i++) {
-           params[i] = (GLdouble) ctx->ColorMatrix.m[i];
+           params[i] = (GLdouble) ctx->ColorMatrixStack.Top->m[i];
         }
         break;
       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-         *params = (GLdouble) (ctx->ColorStackDepth + 1);
+         *params = (GLdouble) (ctx->ColorMatrixStack.Depth + 1);
          break;
       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
          *params = (GLdouble) MAX_COLOR_STACK_DEPTH;
@@ -2432,63 +2522,68 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution, pname);
+         *params = (GLdouble) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution, pname);
+         *params = (GLdouble) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_convolution, pname);
+         *params = (GLdouble) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_D(EXT_convolution, pname);
          *params = (GLdouble) ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_D(EXT_histogram, pname);
+         *params = (GLdouble) ctx->Pixel.HistogramEnabled;
+        break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_D(EXT_histogram, pname);
+         *params = (GLdouble) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = (GLdouble) ctx->Pixel.ColorTableEnabled;
@@ -2502,143 +2597,243 @@ _mesa_GetDoublev( GLenum pname, GLdouble *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
         *params = (GLdouble) ctx->Fog.ColorSumEnabled;
         break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.SecondaryColor[0]);
-         params[1] = (ctx->Current.SecondaryColor[1]);
-         params[2] = (ctx->Current.SecondaryColor[2]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
         break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
          *params = (GLdouble) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
         *params = (GLdouble) ctx->Array.SecondaryColor.Type;
         break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
         *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
         break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_D(EXT_secondary_color, pname);
         *params = (GLdouble) ctx->Array.SecondaryColor.Stride;
         break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord, pname);
         FLUSH_CURRENT(ctx, 0);
-        *params = (GLdouble) ctx->Current.FogCoord;
+        *params = (GLdouble) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
         break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord, pname);
          *params = (GLdouble) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord, pname);
         *params = (GLdouble) ctx->Array.FogCoord.Type;
         break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_D(EXT_fog_coord, pname);
         *params = (GLdouble) ctx->Array.FogCoord.Stride;
         break;
 
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = (GLdouble) ctx->Const.MaxTextureLodBias;
+         break;
+
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-           *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-            return;
-         }
+         CHECK_EXTENSION_D(EXT_texture_filter_anisotropic, pname);
+         *params = (GLdouble) ctx->Const.MaxTextureMaxAnisotropy;
         break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = (GLdouble) ctx->Multisample.Enabled;
+         break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = (GLdouble) ctx->Multisample.SampleAlphaToCoverage;
+         break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = (GLdouble) ctx->Multisample.SampleAlphaToOne;
+         break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = (GLdouble) ctx->Multisample.SampleCoverage;
+         break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleCoverageValue;
+         break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = (GLdouble) ctx->Multisample.SampleCoverageInvert;
+         break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = 0.0; /* XXX fix someday */
+         break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-            return;
-         }
+         CHECK_EXTENSION_D(ARB_multisample, pname);
+         *params = 0.0; /* XXX fix someday */
+         break;
 
-      /* GL_MESA_sprite_point */
-      case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLdouble) ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
-            return;
-         }
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION_D(IBM_rasterpos_clip, pname);
+         *params = (GLdouble) ctx->Transform.RasterPositionUnclipped;
+         break;
+
+      /* GL_NV_point_sprite */
+      case GL_POINT_SPRITE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLdouble) ctx->Point.PointSprite;
+         break;
+      case GL_POINT_SPRITE_R_MODE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLdouble) ctx->Point.SpriteRMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLdouble) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetDoublev");
-           return;
+         CHECK_EXTENSION_D(SGIS_generate_mipmap, pname);
+         *params = (GLdouble) ctx->Hint.GenerateMipmap;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->VertexProgram.Enabled;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->VertexProgram.PointSizeEnabled;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->VertexProgram.TwoSideEnabled;
+         break;
+      case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) MAX_PROGRAM_STACK_DEPTH;
+         break;
+      case GL_MAX_TRACK_MATRICES_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) MAX_PROGRAM_MATRICES;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->CurrentStack->Depth;
+         break;
+      case GL_CURRENT_MATRIX_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->Transform.MatrixMode;
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->VertexProgram.CurrentID;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_NV:
+         CHECK_EXTENSION_D(NV_vertex_program, pname);
+         *params = (GLdouble) ctx->VertexProgram.ErrorPos;
+         break;
+      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_D(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            *params = (GLdouble) ctx->Array.VertexAttrib[n].Enabled;
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV;
+            *params = (GLdouble) ctx->Eval.Map1Attrib[n];
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV;
+            *params = (GLdouble) ctx->Eval.Map2Attrib[n];
          }
          break;
 
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_D(NV_texture_rectangle, pname);
+         *params = (GLdouble) ctx->Const.MaxTextureRectSize;
+         break;
+
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetDoublev" );
+         {
+            char s[100];
+            sprintf(s, "glGetDoublev(pname=0x%x)", pname);
+            _mesa_error( ctx, GL_INVALID_ENUM, s );
+         }
    }
 }
 
@@ -2661,7 +2856,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
    FLUSH_VERTICES(ctx, 0);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname));
+      _mesa_debug(ctx, "glGetFloatv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetFloatv && (*ctx->Driver.GetFloatv)(ctx, pname, params))
       return;
@@ -2760,7 +2955,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
       case GL_CLIP_PLANE3:
       case GL_CLIP_PLANE4:
       case GL_CLIP_PLANE5:
-         *params = (GLfloat) ctx->Transform.ClipEnabled[pname-GL_CLIP_PLANE0];
+         if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
+            *params = 1.0;
+         else
+            *params = 0.0;
          break;
       case GL_COLOR_CLEAR_VALUE:
          params[0] = CHAN_TO_FLOAT(ctx->Color.ClearColor[0]);
@@ -2791,10 +2989,10 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_CURRENT_COLOR:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.Color[0]);
-         params[1] = (ctx->Current.Color[1]);
-         params[2] = (ctx->Current.Color[2]);
-         params[3] = (ctx->Current.Color[3]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
          break;
       case GL_CURRENT_INDEX:
         FLUSH_CURRENT(ctx, 0);
@@ -2802,9 +3000,9 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_CURRENT_NORMAL:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = ctx->Current.Normal[0];
-         params[1] = ctx->Current.Normal[1];
-         params[2] = ctx->Current.Normal[2];
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
          break;
       case GL_CURRENT_RASTER_COLOR:
         params[0] = ctx->Current.RasterColor[0];
@@ -2825,20 +3023,20 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
         params[3] = ctx->Current.RasterPos[3];
         break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-        params[0] = ctx->Current.RasterMultiTexCoord[texUnit][0];
-        params[1] = ctx->Current.RasterMultiTexCoord[texUnit][1];
-        params[2] = ctx->Current.RasterMultiTexCoord[texUnit][2];
-        params[3] = ctx->Current.RasterMultiTexCoord[texUnit][3];
+        params[0] = ctx->Current.RasterTexCoords[texUnit][0];
+        params[1] = ctx->Current.RasterTexCoords[texUnit][1];
+        params[2] = ctx->Current.RasterTexCoords[texUnit][2];
+        params[3] = ctx->Current.RasterTexCoords[texUnit][3];
         break;
       case GL_CURRENT_RASTER_POSITION_VALID:
         *params = (GLfloat) ctx->Current.RasterPosValid;
         break;
       case GL_CURRENT_TEXTURE_COORDS:
         FLUSH_CURRENT(ctx, 0);
-        params[0] = (GLfloat) ctx->Current.Texcoord[texUnit][0];
-        params[1] = (GLfloat) ctx->Current.Texcoord[texUnit][1];
-        params[2] = (GLfloat) ctx->Current.Texcoord[texUnit][2];
-        params[3] = (GLfloat) ctx->Current.Texcoord[texUnit][3];
+        params[0] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+        params[1] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+        params[2] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+        params[3] = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
         break;
       case GL_DEPTH_BIAS:
         *params = (GLfloat) ctx->Pixel.DepthBias;
@@ -2923,15 +3121,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
       case GL_GREEN_SCALE:
          *params = (GLfloat) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
-        break;
       case GL_INDEX_BITS:
          *params = (GLfloat) ctx->Visual.indexBits;
         break;
@@ -3155,16 +3344,13 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = (GLfloat) MAX_WIDTH;
          params[1] = (GLfloat) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = ctx->ModelView.m[i];
+           params[i] = ctx->ModelviewMatrixStack.Top->m[i];
         }
         break;
       case GL_MODELVIEW_STACK_DEPTH:
-        *params = (GLfloat) (ctx->ModelViewStackDepth + 1);
+        *params = (GLfloat) (ctx->ModelviewMatrixStack.Depth + 1);
         break;
       case GL_NAME_STACK_DEPTH:
         *params = (GLfloat) ctx->Select.NameStackDepth;
@@ -3289,11 +3475,11 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
         break;
       case GL_PROJECTION_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = ctx->ProjectionMatrix.m[i];
+           params[i] = ctx->ProjectionMatrixStack.Top->m[i];
         }
         break;
       case GL_PROJECTION_STACK_DEPTH:
-        *params = (GLfloat) (ctx->ProjectionStackDepth + 1);
+        *params = (GLfloat) (ctx->ProjectionMatrixStack.Depth + 1);
         break;
       case GL_READ_BUFFER:
         *params = ENUM_TO_FLOAT(ctx->Pixel.ReadBuffer);
@@ -3371,13 +3557,13 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
         *params = (GLfloat) ctx->Const.SubPixelBits;
         break;
       case GL_TEXTURE_1D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_1D) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_2D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_2D) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_3D:
-         *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0 : 0.0;
+         *params = _mesa_IsEnabled(GL_TEXTURE_3D) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_BINDING_1D:
          *params = (GLfloat) textureUnit->Current1D->Name;
@@ -3398,24 +3584,24 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
         *params = ENUM_TO_FLOAT(textureUnit->EnvMode);
         break;
       case GL_TEXTURE_GEN_S:
-        *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0 : 0.0;
+        *params = (textureUnit->TexGenEnabled & S_BIT) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_GEN_T:
-        *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0 : 0.0;
+        *params = (textureUnit->TexGenEnabled & T_BIT) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_GEN_R:
-        *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0 : 0.0;
+        *params = (textureUnit->TexGenEnabled & R_BIT) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_GEN_Q:
-        *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0 : 0.0;
+        *params = (textureUnit->TexGenEnabled & Q_BIT) ? 1.0F : 0.0F;
         break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-           params[i] = ctx->TextureMatrix[texUnit].m[i];
+           params[i] = ctx->TextureMatrixStack[texUnit].Top->m[i];
         }
         break;
       case GL_TEXTURE_STACK_DEPTH:
-        *params = (GLfloat) (ctx->TextureStackDepth[texUnit] + 1);
+        *params = (GLfloat) (ctx->TextureMatrixStack[texUnit].Depth + 1);
         break;
       case GL_UNPACK_ALIGNMENT:
         *params = (GLfloat) ctx->Unpack.Alignment;
@@ -3534,105 +3720,89 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_ARB_multitexture */
       case GL_MAX_TEXTURE_UNITS_ARB:
+         CHECK_EXTENSION_F(ARB_multitexture, pname);
          *params = (GLfloat) ctx->Const.MaxTextureUnits;
          break;
       case GL_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_F(ARB_multitexture, pname);
          *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
          break;
       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_F(ARB_multitexture, pname);
          *params = (GLfloat) (GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
          break;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
+         *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
+         *params = (GLfloat) textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-         return;
+         CHECK_EXTENSION_F(ARB_texture_cube_map, pname);
+         *params = (GLfloat) (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLfloat) ctx->Hint.TextureCompression;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+         CHECK_EXTENSION_F(ARB_texture_compression, pname);
+         *params = (GLfloat) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
+         CHECK_EXTENSION_F(ARB_texture_compression, pname);
+         *params = (GLfloat) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_F(ARB_texture_compression, pname);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLfloat) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
          break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
+         CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname);
         *params = (GLfloat) ctx->Array.LockFirst;
         break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
+         CHECK_EXTENSION_F(EXT_compiled_vertex_array, pname);
         *params = (GLfloat) ctx->Array.LockCount;
         break;
 
       /* GL_ARB_transpose_matrix */
       case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-         _math_transposef(params, ctx->ColorMatrix.m);
+         _math_transposef(params, ctx->ColorMatrixStack.Top->m);
          break;
       case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-         _math_transposef(params, ctx->ModelView.m);
+         _math_transposef(params, ctx->ModelviewMatrixStack.Top->m);
          break;
       case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-         _math_transposef(params, ctx->ProjectionMatrix.m);
+         _math_transposef(params, ctx->ProjectionMatrixStack.Top->m);
          break;
       case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-         _math_transposef(params, ctx->TextureMatrix[texUnit].m);
+         _math_transposef(params, ctx->TextureMatrixStack[texUnit].Top->m);
          break;
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLfloat) ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
-         }
-         return;
+         CHECK_EXTENSION_F(HP_occlusion_test, pname);
+         *params = (GLfloat) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLfloat) ctx->OcclusionResult;
-            else
-               *params = (GLfloat) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
-         }
-         return;
+         CHECK_EXTENSION_F(HP_occlusion_test, pname);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLfloat) ctx->OcclusionResult;
+         else
+            *params = (GLfloat) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
@@ -3650,11 +3820,11 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
       /* GL_SGI_color_matrix (also in 1.2 imaging) */
       case GL_COLOR_MATRIX_SGI:
          for (i=0;i<16;i++) {
-           params[i] = ctx->ColorMatrix.m[i];
+           params[i] = ctx->ColorMatrixStack.Top->m[i];
         }
         break;
       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-         *params = (GLfloat) (ctx->ColorStackDepth + 1);
+         *params = (GLfloat) (ctx->ColorMatrixStack.Depth + 1);
          break;
       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
          *params = (GLfloat) MAX_COLOR_STACK_DEPTH;
@@ -3686,63 +3856,68 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution, pname);
+         *params = (GLfloat) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution, pname);
+         *params = (GLfloat) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_convolution, pname);
+         *params = (GLfloat) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = (GLfloat) ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = (GLfloat) ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_F(EXT_convolution, pname);
          *params = ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_F(EXT_histogram, pname);
+         *params = (GLfloat) ctx->Pixel.HistogramEnabled;
+        break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_F(EXT_histogram, pname);
+         *params = (GLfloat) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
          *params = (GLfloat) ctx->Pixel.ColorTableEnabled;
@@ -3756,143 +3931,243 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
         *params = (GLfloat) ctx->Fog.ColorSumEnabled;
         break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (ctx->Current.SecondaryColor[0]);
-         params[1] = (ctx->Current.SecondaryColor[1]);
-         params[2] = (ctx->Current.SecondaryColor[2]);
+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
         break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
          *params = (GLfloat) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
         *params = (GLfloat) ctx->Array.SecondaryColor.Type;
         break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
         *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
         break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_F(EXT_secondary_color, pname);
         *params = (GLfloat) ctx->Array.SecondaryColor.Stride;
         break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord, pname);
         FLUSH_CURRENT(ctx, 0);
-        *params = (GLfloat) ctx->Current.FogCoord;
+        *params = (GLfloat) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
         break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord, pname);
          *params = (GLfloat) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord, pname);
         *params = (GLfloat) ctx->Array.FogCoord.Type;
         break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_F(EXT_fog_coord, pname);
         *params = (GLfloat) ctx->Array.FogCoord.Stride;
         break;
 
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = ctx->Const.MaxTextureLodBias;
+         break;
+
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-           *params = ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
-            return;
-         }
+         CHECK_EXTENSION_F(EXT_texture_filter_anisotropic, pname);
+         *params = ctx->Const.MaxTextureMaxAnisotropy;
         break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = (GLfloat) ctx->Multisample.Enabled;
+         break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = (GLfloat) ctx->Multisample.SampleAlphaToCoverage;
+         break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = (GLfloat) ctx->Multisample.SampleAlphaToOne;
+         break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = (GLfloat) ctx->Multisample.SampleCoverage;
+         break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = ctx->Multisample.SampleCoverageValue;
+         break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = (GLfloat) ctx->Multisample.SampleCoverageInvert;
+         break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = 0.0; /* XXX fix someday */
+         break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0.0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
+         CHECK_EXTENSION_F(ARB_multisample, pname);
+         *params = 0.0; /* XXX fix someday */
+         break;
 
-      /* GL_MESA_sprite_point */
-      case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLfloat) ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
-            return;
-         }
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION_F(IBM_rasterpos_clip, pname);
+         *params = (GLfloat) ctx->Transform.RasterPositionUnclipped;
+         break;
+
+      /* GL_NV_point_sprite */
+      case GL_POINT_SPRITE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLfloat) ctx->Point.PointSprite;
+         break;
+      case GL_POINT_SPRITE_R_MODE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLfloat) ctx->Point.SpriteRMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLfloat) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-           return;
+         CHECK_EXTENSION_F(SGIS_generate_mipmap, pname);
+         *params = (GLfloat) ctx->Hint.GenerateMipmap;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->VertexProgram.Enabled;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->VertexProgram.PointSizeEnabled;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->VertexProgram.TwoSideEnabled;
+         break;
+      case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) MAX_PROGRAM_STACK_DEPTH;
+         break;
+      case GL_MAX_TRACK_MATRICES_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) MAX_PROGRAM_MATRICES;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->CurrentStack->Depth;
+         break;
+      case GL_CURRENT_MATRIX_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->Transform.MatrixMode;
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->VertexProgram.CurrentID;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_NV:
+         CHECK_EXTENSION_F(NV_vertex_program, pname);
+         *params = (GLfloat) ctx->VertexProgram.ErrorPos;
+         break;
+      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_F(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            *params = (GLfloat) ctx->Array.VertexAttrib[n].Enabled;
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV;
+            *params = (GLfloat) ctx->Eval.Map1Attrib[n];
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV;
+            *params = (GLfloat) ctx->Eval.Map2Attrib[n];
          }
          break;
 
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_F(NV_texture_rectangle, pname);
+         *params = (GLfloat) ctx->Const.MaxTextureRectSize;
+         break;
+
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetFloatv" );
+         {
+            char s[100];
+            sprintf(s, "glGetFloatv(0x%x)", pname);
+            _mesa_error(ctx, GL_INVALID_ENUM, s);
+         }
    }
 }
 
@@ -3915,7 +4190,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
    FLUSH_VERTICES(ctx, 0);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname));
+      _mesa_debug(ctx, "glGetIntegerv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetIntegerv
        && (*ctx->Driver.GetIntegerv)(ctx, pname, params))
@@ -4015,8 +4290,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
       case GL_CLIP_PLANE3:
       case GL_CLIP_PLANE4:
       case GL_CLIP_PLANE5:
-         i = (GLint) (pname - GL_CLIP_PLANE0);
-         *params = (GLint) ctx->Transform.ClipEnabled[i];
+         if (ctx->Transform.ClipPlanesEnabled & (1 << (pname - GL_CLIP_PLANE0)))
+            *params = 1;
+         else
+            *params = 0;
          break;
       case GL_COLOR_CLEAR_VALUE:
          params[0] = FLOAT_TO_INT( (ctx->Color.ClearColor[0]) );
@@ -4047,10 +4324,10 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_CURRENT_COLOR:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( ( ctx->Current.Color[0] ) );
-         params[1] = FLOAT_TO_INT( ( ctx->Current.Color[1] ) );
-         params[2] = FLOAT_TO_INT( ( ctx->Current.Color[2] ) );
-         params[3] = FLOAT_TO_INT( ( ctx->Current.Color[3] ) );
+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+         params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
          break;
       case GL_CURRENT_INDEX:
         FLUSH_CURRENT(ctx, 0);
@@ -4058,9 +4335,9 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_CURRENT_NORMAL:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( ctx->Current.Normal[0] );
-         params[1] = FLOAT_TO_INT( ctx->Current.Normal[1] );
-         params[2] = FLOAT_TO_INT( ctx->Current.Normal[2] );
+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
          break;
       case GL_CURRENT_RASTER_COLOR:
         params[0] = FLOAT_TO_INT( ctx->Current.RasterColor[0] );
@@ -4081,20 +4358,20 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
         params[3] = (GLint) ctx->Current.RasterPos[3];
         break;
       case GL_CURRENT_RASTER_TEXTURE_COORDS:
-        params[0] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][0];
-        params[1] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][1];
-        params[2] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][2];
-        params[3] = (GLint) ctx->Current.RasterMultiTexCoord[texUnit][3];
+        params[0] = (GLint) ctx->Current.RasterTexCoords[texUnit][0];
+        params[1] = (GLint) ctx->Current.RasterTexCoords[texUnit][1];
+        params[2] = (GLint) ctx->Current.RasterTexCoords[texUnit][2];
+        params[3] = (GLint) ctx->Current.RasterTexCoords[texUnit][3];
         break;
       case GL_CURRENT_RASTER_POSITION_VALID:
         *params = (GLint) ctx->Current.RasterPosValid;
         break;
       case GL_CURRENT_TEXTURE_COORDS:
         FLUSH_CURRENT(ctx, 0);
-         params[0] = (GLint) ctx->Current.Texcoord[texUnit][0];
-         params[1] = (GLint) ctx->Current.Texcoord[texUnit][1];
-         params[2] = (GLint) ctx->Current.Texcoord[texUnit][2];
-         params[3] = (GLint) ctx->Current.Texcoord[texUnit][3];
+         params[0] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
+         params[1] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
+         params[2] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
+         params[3] = (GLint) ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
         break;
       case GL_DEPTH_BIAS:
          *params = (GLint) ctx->Pixel.DepthBias;
@@ -4179,15 +4456,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
       case GL_GREEN_SCALE:
          *params = (GLint) ctx->Pixel.GreenScale;
          break;
-      case GL_HISTOGRAM:
-         if (ctx->Extensions.EXT_histogram || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.HistogramEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv");
-            return;
-         }
-        break;
       case GL_INDEX_BITS:
          *params = (GLint) ctx->Visual.indexBits;
          break;
@@ -4411,16 +4679,13 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = (GLint) MAX_WIDTH;
          params[1] = (GLint) MAX_HEIGHT;
          break;
-      case GL_MINMAX:
-         *params = (GLint) ctx->Pixel.MinMaxEnabled;
-         break;
       case GL_MODELVIEW_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = (GLint) ctx->ModelView.m[i];
+           params[i] = (GLint) ctx->ModelviewMatrixStack.Top->m[i];
         }
         break;
       case GL_MODELVIEW_STACK_DEPTH:
-        *params = (GLint) (ctx->ModelViewStackDepth + 1);
+        *params = (GLint) (ctx->ModelviewMatrixStack.Depth + 1);
         break;
       case GL_NAME_STACK_DEPTH:
         *params = (GLint) ctx->Select.NameStackDepth;
@@ -4543,11 +4808,11 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
         break;
       case GL_PROJECTION_MATRIX:
         for (i=0;i<16;i++) {
-           params[i] = (GLint) ctx->ProjectionMatrix.m[i];
+           params[i] = (GLint) ctx->ProjectionMatrixStack.Top->m[i];
         }
         break;
       case GL_PROJECTION_STACK_DEPTH:
-        *params = (GLint) (ctx->ProjectionStackDepth + 1);
+        *params = (GLint) (ctx->ProjectionMatrixStack.Depth + 1);
         break;
       case GL_READ_BUFFER:
         *params = (GLint) ctx->Pixel.ReadBuffer;
@@ -4665,11 +4930,11 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
         break;
       case GL_TEXTURE_MATRIX:
          for (i=0;i<16;i++) {
-           params[i] = (GLint) ctx->TextureMatrix[texUnit].m[i];
+           params[i] = (GLint) ctx->TextureMatrixStack[texUnit].Top->m[i];
         }
         break;
       case GL_TEXTURE_STACK_DEPTH:
-        *params = (GLint) (ctx->TextureStackDepth[texUnit] + 1);
+        *params = (GLint) (ctx->TextureMatrixStack[texUnit].Depth + 1);
         break;
       case GL_UNPACK_ALIGNMENT:
         *params = ctx->Unpack.Alignment;
@@ -4788,65 +5053,57 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 
       /* GL_ARB_multitexture */
       case GL_MAX_TEXTURE_UNITS_ARB:
+         CHECK_EXTENSION_I(ARB_multitexture, pname);
          *params = ctx->Const.MaxTextureUnits;
          break;
       case GL_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_I(ARB_multitexture, pname);
          *params = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
          break;
       case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+         CHECK_EXTENSION_I(ARB_multitexture, pname);
          *params = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
          break;
 
       /* GL_ARB_texture_cube_map */
       case GL_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
+         *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
+         break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = textureUnit->CurrentCubeMap->Name;
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
+         *params = textureUnit->CurrentCubeMap->Name;
+         break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-         return;
+         CHECK_EXTENSION_I(ARB_texture_cube_map, pname);
+         *params = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLint) ctx->Hint.TextureCompression;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+         CHECK_EXTENSION_I(ARB_texture_compression, pname);
+         *params = (GLint) ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLint) ctx->Const.NumCompressedTextureFormats;
-         }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
+         CHECK_EXTENSION_I(ARB_texture_compression, pname);
+         *params = (GLint) ctx->Const.NumCompressedTextureFormats;
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         if (ctx->Extensions.ARB_texture_compression) {
+         CHECK_EXTENSION_I(ARB_texture_compression, pname);
+         {
             GLuint i;
             for (i = 0; i < ctx->Const.NumCompressedTextureFormats; i++)
                params[i] = (GLint) ctx->Const.CompressedTextureFormats[i];
          }
-         else
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
          break;
 
       /* GL_EXT_compiled_vertex_array */
       case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
+         CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname);
         *params = ctx->Array.LockFirst;
         break;
       case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
+         CHECK_EXTENSION_I(EXT_compiled_vertex_array, pname);
         *params = ctx->Array.LockCount;
         break;
 
@@ -4855,7 +5112,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ColorMatrix.m);
+            _math_transposef(tm, ctx->ColorMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4865,7 +5122,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ModelView.m);
+            _math_transposef(tm, ctx->ModelviewMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4875,7 +5132,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->ProjectionMatrix.m);
+            _math_transposef(tm, ctx->ProjectionMatrixStack.Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4885,7 +5142,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          {
             GLfloat tm[16];
             GLuint i;
-            _math_transposef(tm, ctx->TextureMatrix[texUnit].m);
+            _math_transposef(tm, ctx->TextureMatrixStack[texUnit].Top->m);
             for (i=0;i<16;i++) {
                params[i] = (GLint) tm[i];
             }
@@ -4894,308 +5151,402 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
 
       /* GL_HP_occlusion_test */
       case GL_OCCLUSION_TEST_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            *params = (GLint) ctx->Depth.OcclusionTest;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
-         return;
+         CHECK_EXTENSION_I(HP_occlusion_test, pname);
+         *params = (GLint) ctx->Depth.OcclusionTest;
+         break;
       case GL_OCCLUSION_TEST_RESULT_HP:
-         if (ctx->Extensions.HP_occlusion_test) {
-            if (ctx->Depth.OcclusionTest)
-               *params = (GLint) ctx->OcclusionResult;
-            else
-               *params = (GLint) ctx->OcclusionResultSaved;
-            /* reset flag now */
-            ctx->OcclusionResult = GL_FALSE;
-            ctx->OcclusionResultSaved = GL_FALSE;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
-         return;
+         CHECK_EXTENSION_I(HP_occlusion_test, pname);
+         if (ctx->Depth.OcclusionTest)
+            *params = (GLint) ctx->OcclusionResult;
+         else
+            *params = (GLint) ctx->OcclusionResultSaved;
+         /* reset flag now */
+         ctx->OcclusionResult = GL_FALSE;
+         ctx->OcclusionResultSaved = GL_FALSE;
+         break;
 
       /* GL_SGIS_pixel_texture */
       case GL_PIXEL_TEXTURE_SGIS:
+         CHECK_EXTENSION_I(SGIS_pixel_texture, pname);
          *params = (GLint) ctx->Pixel.PixelTextureEnabled;
          break;
 
       /* GL_SGIX_pixel_texture */
       case GL_PIXEL_TEX_GEN_SGIX:
+         CHECK_EXTENSION_I(SGIX_pixel_texture, pname);
          *params = (GLint) ctx->Pixel.PixelTextureEnabled;
          break;
       case GL_PIXEL_TEX_GEN_MODE_SGIX:
+         CHECK_EXTENSION_I(SGIX_pixel_texture, pname);
          *params = (GLint) pixel_texgen_mode(ctx);
          break;
 
       /* GL_SGI_color_matrix (also in 1.2 imaging) */
       case GL_COLOR_MATRIX_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          for (i=0;i<16;i++) {
-           params[i] = (GLint) ctx->ColorMatrix.m[i];
+           params[i] = (GLint) ctx->ColorMatrixStack.Top->m[i];
         }
         break;
       case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-         *params = ctx->ColorStackDepth + 1;
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
+         *params = ctx->ColorMatrixStack.Depth + 1;
          break;
       case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = MAX_COLOR_STACK_DEPTH;
          break;
       case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[0];
          break;
       case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[1];
          break;
       case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[2];
          break;
       case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixScale[3];
          break;
       case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[0];
          break;
       case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[1];
          break;
       case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[2];
          break;
       case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
+         CHECK_EXTENSION_I(SGI_color_matrix, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixBias[3];
          break;
 
       /* GL_EXT_convolution (also in 1.2 imaging) */
       case GL_CONVOLUTION_1D_EXT:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Convolution1DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution, pname);
+         *params = (GLint) ctx->Pixel.Convolution1DEnabled;
          break;
       case GL_CONVOLUTION_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Convolution2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution, pname);
+         *params = (GLint) ctx->Pixel.Convolution2DEnabled;
          break;
       case GL_SEPARABLE_2D:
-         if (ctx->Extensions.EXT_convolution || ctx->Extensions.ARB_imaging) {
-            *params = (GLint) ctx->Pixel.Separable2DEnabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_convolution, pname);
+         *params = (GLint) ctx->Pixel.Separable2DEnabled;
          break;
       case GL_MAX_CONVOLUTION_WIDTH:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = ctx->Const.MaxConvolutionWidth;
          break;
       case GL_MAX_CONVOLUTION_HEIGHT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = ctx->Const.MaxConvolutionHeight;
          break;
       case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionScale[3];
          break;
       case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[0];
          break;
       case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[1];
          break;
       case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
          break;
       case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXTENSION_I(EXT_convolution, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionBias[2];
          break;
 
+      /* GL_EXT_histogram (also in 1.2 imaging) */
+      case GL_HISTOGRAM:
+         CHECK_EXTENSION_I(EXT_histogram, pname);
+         *params = (GLint) ctx->Pixel.HistogramEnabled;
+        break;
+      case GL_MINMAX:
+         CHECK_EXTENSION_I(EXT_histogram, pname);
+         *params = (GLint) ctx->Pixel.MinMaxEnabled;
+         break;
+
       /* GL_SGI_color_table (also in 1.2 imaging */
       case GL_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table, pname);
          *params = (GLint) ctx->Pixel.ColorTableEnabled;
          break;
       case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table, pname);
          *params = (GLint) ctx->Pixel.PostConvolutionColorTableEnabled;
          break;
       case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXTENSION_I(SGI_color_table, pname);
          *params = (GLint) ctx->Pixel.PostColorMatrixColorTableEnabled;
          break;
 
 
       /* GL_EXT_secondary_color */
       case GL_COLOR_SUM_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
         *params = (GLint) ctx->Fog.ColorSumEnabled;
         break;
       case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
         FLUSH_CURRENT(ctx, 0);
-         params[0] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[0]) );
-         params[1] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[1]) );
-         params[2] = FLOAT_TO_INT( (ctx->Current.SecondaryColor[2]) );
+         params[0] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]) );
+         params[1] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]) );
+         params[2] = FLOAT_TO_INT( (ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]) );
         break;
       case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
          *params = (GLint) ctx->Array.SecondaryColor.Enabled;
          break;
       case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
         *params = (GLint) ctx->Array.SecondaryColor.Type;
         break;
       case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
         *params = (GLint) ctx->Array.SecondaryColor.Stride;
         break;
       case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXTENSION_I(EXT_secondary_color, pname);
         *params = (GLint) ctx->Array.SecondaryColor.Stride;
         break;
 
       /* GL_EXT_fog_coord */
       case GL_CURRENT_FOG_COORDINATE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            FLUSH_CURRENT(ctx, 0);
-            *params = (GLint) ctx->Current.FogCoord;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord, pname);
+         FLUSH_CURRENT(ctx, 0);
+         *params = (GLint) ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
         break;
       case GL_FOG_COORDINATE_ARRAY_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Enabled;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord, pname);
+         *params = (GLint) ctx->Array.FogCoord.Enabled;
          break;
       case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Type;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord, pname);
+         *params = (GLint) ctx->Array.FogCoord.Type;
         break;
       case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-         if (ctx->Extensions.EXT_fog_coord) {
-            *params = (GLint) ctx->Array.FogCoord.Stride;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-         }
+         CHECK_EXTENSION_I(EXT_fog_coord, pname);
+         *params = (GLint) ctx->Array.FogCoord.Stride;
         break;
 
+      /* GL_EXT_texture_lod_bias */
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         *params = (GLint) ctx->Const.MaxTextureLodBias;
+         break;
+
       /* GL_EXT_texture_filter_anisotropic */
       case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-           *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-            return;
-         }
+         CHECK_EXTENSION_I(EXT_texture_filter_anisotropic, pname);
+         *params = (GLint) ctx->Const.MaxTextureMaxAnisotropy;
         break;
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.Enabled;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.Enabled;
+         break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.SampleAlphaToCoverage;
+         break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleAlphaToOne;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.SampleAlphaToOne;
+         break;
       case GL_SAMPLE_COVERAGE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverage;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.SampleCoverage;
+         break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverageValue;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.SampleCoverageValue;
+         break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = (GLint) ctx->Multisample.SampleCoverageInvert;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = (GLint) ctx->Multisample.SampleCoverageInvert;
+         break;
       case GL_SAMPLE_BUFFERS_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = 0; /* XXX fix someday */
+         break;
       case GL_SAMPLES_ARB:
-         if (ctx->Extensions.ARB_multisample) {
-            *params = 0; /* XXX fix someday */
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-            return;
-         }
+         CHECK_EXTENSION_I(ARB_multisample, pname);
+         *params = 0; /* XXX fix someday */
+         break;
 
-      /* GL_MESA_sprite_point */
-      case GL_SPRITE_POINT_MESA:
-         if (ctx->Extensions.MESA_sprite_point) {
-            *params = (GLint) ctx->Point.SpriteMode;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
-            return;
-         }
+      /* GL_IBM_rasterpos_clip */
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXTENSION_I(IBM_rasterpos_clip, pname);
+         *params = (GLint) ctx->Transform.RasterPositionUnclipped;
+         break;
+
+      /* GL_NV_point_sprite */
+      case GL_POINT_SPRITE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLint) ctx->Point.PointSprite;
+         break;
+      case GL_POINT_SPRITE_R_MODE_NV:
+         CHECK_EXTENSION_B(NV_point_sprite, pname);
+         *params = (GLint) ctx->Point.SpriteRMode;
          break;
 
       /* GL_SGIS_generate_mipmap */
       case GL_GENERATE_MIPMAP_HINT_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            *params = (GLint) ctx->Hint.GenerateMipmap;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv");
-           return;
+         CHECK_EXTENSION_I(SGIS_generate_mipmap, pname);
+         *params = (GLint) ctx->Hint.GenerateMipmap;
+         break;
+
+      /* GL_NV_vertex_program */
+      case GL_VERTEX_PROGRAM_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->VertexProgram.Enabled;
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->VertexProgram.PointSizeEnabled;
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->VertexProgram.TwoSideEnabled;
+         break;
+      case GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = MAX_PROGRAM_STACK_DEPTH;
+         break;
+      case GL_MAX_TRACK_MATRICES_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = MAX_PROGRAM_MATRICES;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = ctx->CurrentStack->Depth;
+         break;
+      case GL_CURRENT_MATRIX_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->Transform.MatrixMode;
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->VertexProgram.CurrentID;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_NV:
+         CHECK_EXTENSION_I(NV_vertex_program, pname);
+         *params = (GLint) ctx->VertexProgram.ErrorPos;
+         break;
+      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_I(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            *params = (GLint) ctx->Array.VertexAttrib[n].Enabled;
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP1_VERTEX_ATTRIB0_4_NV;
+            *params = (GLint) ctx->Eval.Map1Attrib[n];
+         }
+         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_B(NV_vertex_program, pname);
+         {
+            GLuint n = (GLuint) pname - GL_MAP2_VERTEX_ATTRIB0_4_NV;
+            *params = (GLint) ctx->Eval.Map2Attrib[n];
          }
          break;
 
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) textureUnit->CurrentRect->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXTENSION_I(NV_texture_rectangle, pname);
+         *params = (GLint) ctx->Const.MaxTextureRectSize;
+         break;
+
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetIntegerv" );
+         {
+            char s[100];
+            sprintf(s, "glGetIntegerv(pname=0x%x)", pname);
+            _mesa_error( ctx, GL_INVALID_ENUM, s );
+         }
    }
 }
 
@@ -5212,7 +5563,7 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params )
       return;
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname));
+      _mesa_debug(ctx, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname));
 
    if (ctx->Driver.GetPointerv
        && (*ctx->Driver.GetPointerv)(ctx, pname, params))
@@ -5263,7 +5614,9 @@ _mesa_GetString( GLenum name )
    GET_CURRENT_CONTEXT(ctx);
    static const char *vendor = "Brian Paul";
    static const char *renderer = "Mesa";
-   static const char *version = "1.2 Mesa 3.5";
+   static const char *version_1_2 = "1.2 Mesa 4.1 beta";
+   static const char *version_1_3 = "1.3 Mesa 4.1 beta";
+
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
    /* this is a required driver function */
@@ -5279,7 +5632,16 @@ _mesa_GetString( GLenum name )
           case GL_RENDERER:
              return (const GLubyte *) renderer;
           case GL_VERSION:
-             return (const GLubyte *) version;
+             if (ctx->Extensions.ARB_multitexture &&
+                 ctx->Extensions.ARB_multisample &&
+                 ctx->Extensions.ARB_texture_border_clamp &&
+                 ctx->Extensions.ARB_texture_compression &&
+                 ctx->Extensions.EXT_texture_env_add &&
+                 ctx->Extensions.ARB_texture_env_combine &&
+                 ctx->Extensions.ARB_texture_env_dot3)
+                return (const GLubyte *) version_1_3;
+             else
+                return (const GLubyte *) version_1_2;
           case GL_EXTENSIONS:
              return (const GLubyte *) _mesa_extensions_get_string(ctx);
           default:
@@ -5301,7 +5663,7 @@ _mesa_GetError( void )
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      fprintf(stderr, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
+      _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
 
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
    return e;