Merge commit 'eee/mesa-es' into android

author: Chia-I Wu <olvaffe@gmail.com> 2009-09-15 14:16:22 +0800
committer: Chia-I Wu <olvaffe@gmail.com> 2009-09-15 14:16:22 +0800
commit: e2ba90a9cc762cf00a168f0a59d31e7dc52fc42e (patch)
tree: fe3206d7602ad935296884742980f3c4d30bd867 /src/mesa/main
parent: 11a4292d4eb515813b82b8d688a318adef66b3e6 (diff)
parent: b4b8800315637d9218a81c76f09df7d601710d29 (diff)
129 files changed, 19764 insertions, 11625 deletions
diff --git a/src/mesa/main/accum.c b/src/mesa/main/accum.c
index 2345695f3c..30e2f9664a 100644
--- a/src/mesa/main/accum.c
+++ b/src/mesa/main/accum.c
@@ -29,6 +29,10 @@
 #include "macros.h"
 #include "state.h"
 #include "mtypes.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_accum
 
 
 void GLAPIENTRY
@@ -99,6 +103,16 @@ _mesa_Accum( GLenum op, GLfloat value )
 }
 
 
+void
+_mesa_init_accum_dispatch(struct _glapi_table *disp)
+{
+   SET_Accum(disp, _mesa_Accum);
+   SET_ClearAccum(disp, _mesa_ClearAccum);
+}
+
+
+#endif /* FEATURE_accum */
+
 
 void 
 _mesa_init_accum( GLcontext *ctx )
diff --git a/src/mesa/main/accum.h b/src/mesa/main/accum.h
index ce92688a5b..ef5e44ea9e 100644
--- a/src/mesa/main/accum.h
+++ b/src/mesa/main/accum.h
@@ -38,25 +38,41 @@
 #define ACCUM_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
-#if _HAVE_FULL_GL
+#if FEATURE_accum
+
+#define _MESA_INIT_ACCUM_FUNCTIONS(driver, impl) \
+   do {                                          \
+      (driver)->Accum = impl ## Accum;           \
+   } while (0)
 
 extern void GLAPIENTRY
 _mesa_Accum( GLenum op, GLfloat value );
 
-
 extern void GLAPIENTRY
 _mesa_ClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
 
-extern void 
-_mesa_init_accum( GLcontext *ctx );
+extern void
+_mesa_init_accum_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_accum */
 
-#else
+#define _MESA_INIT_ACCUM_FUNCTIONS(driver, impl) do { } while (0)
 
-/** No-op */
-#define _mesa_init_accum( c ) ((void)0)
+static INLINE void
+_mesa_ClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+}
 
-#endif
+static INLINE void
+_mesa_init_accum_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_accum */
+
+extern void 
+_mesa_init_accum( GLcontext *ctx );
 
-#endif
+#endif /* ACCUM_H */
diff --git a/src/mesa/main/api_arrayelt.c b/src/mesa/main/api_arrayelt.c
index d124c724c9..a058227110 100644
--- a/src/mesa/main/api_arrayelt.c
+++ b/src/mesa/main/api_arrayelt.c
@@ -28,6 +28,7 @@
 
 #include "glheader.h"
 #include "api_arrayelt.h"
+#include "bufferobj.h"
 #include "context.h"
 #include "imports.h"
 #include "macros.h"
@@ -70,6 +71,10 @@ typedef struct {
  */
 #define TYPE_IDX(t) ( (t) == GL_DOUBLE ? 7 : (t) & 7 )
 
+
+#if FEATURE_arrayelt
+
+
 static const int ColorFuncs[2][8] = {
    {
       _gloffset_Color3bv,
@@ -1071,7 +1076,7 @@ void _ae_destroy_context( GLcontext *ctx )
 static void check_vbo( AEcontext *actx,
 		       struct gl_buffer_object *vbo )
 {
-   if (vbo->Name && !vbo->Pointer) {
+   if (_mesa_is_bufferobj(vbo) && !_mesa_bufferobj_mapped(vbo)) {
       GLuint i;
       for (i = 0; i < actx->nr_vbos; i++)
 	 if (actx->vbo[i] == vbo)
@@ -1094,48 +1099,49 @@ static void _ae_update_state( GLcontext *ctx )
    AEarray *aa = actx->arrays;
    AEattrib *at = actx->attribs;
    GLuint i;
+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
 
    actx->nr_vbos = 0;
 
    /* conventional vertex arrays */
-  if (ctx->Array.ArrayObj->Index.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->Index;
+   if (arrayObj->Index.Enabled) {
+      aa->array = &arrayObj->Index;
       aa->offset = IndexFuncs[TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   if (ctx->Array.ArrayObj->EdgeFlag.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->EdgeFlag;
+   if (arrayObj->EdgeFlag.Enabled) {
+      aa->array = &arrayObj->EdgeFlag;
       aa->offset = _gloffset_EdgeFlagv;
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   if (ctx->Array.ArrayObj->Normal.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->Normal;
+   if (arrayObj->Normal.Enabled) {
+      aa->array = &arrayObj->Normal;
       aa->offset = NormalFuncs[TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   if (ctx->Array.ArrayObj->Color.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->Color;
+   if (arrayObj->Color.Enabled) {
+      aa->array = &arrayObj->Color;
       aa->offset = ColorFuncs[aa->array->Size-3][TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   if (ctx->Array.ArrayObj->SecondaryColor.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->SecondaryColor;
+   if (arrayObj->SecondaryColor.Enabled) {
+      aa->array = &arrayObj->SecondaryColor;
       aa->offset = SecondaryColorFuncs[TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   if (ctx->Array.ArrayObj->FogCoord.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->FogCoord;
+   if (arrayObj->FogCoord.Enabled) {
+      aa->array = &arrayObj->FogCoord;
       aa->offset = FogCoordFuncs[TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
    for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
-      struct gl_client_array *attribArray = &ctx->Array.ArrayObj->TexCoord[i];
+      struct gl_client_array *attribArray = &arrayObj->TexCoord[i];
       if (attribArray->Enabled) {
          /* NOTE: we use generic glVertexAttribNV functions here.
           * If we ever remove GL_NV_vertex_program this will have to change.
@@ -1152,13 +1158,13 @@ static void _ae_update_state( GLcontext *ctx )
    }
 
    /* generic vertex attribute arrays */   
-   for (i = 1; i < VERT_ATTRIB_MAX; i++) {  /* skip zero! */
-      struct gl_client_array *attribArray = &ctx->Array.ArrayObj->VertexAttrib[i];
+   for (i = 1; i < Elements(arrayObj->VertexAttrib); i++) {  /* skip zero! */
+      struct gl_client_array *attribArray = &arrayObj->VertexAttrib[i];
       if (attribArray->Enabled) {
          at->array = attribArray;
          /* Note: we can't grab the _glapi_Dispatch->VertexAttrib1fvNV
           * function pointer here (for float arrays) since the pointer may
-          * change from one execution of _ae_loopback_array_elt() to
+          * change from one execution of _ae_ArrayElement() to
           * the next.  Doing so caused UT to break.
           */
          if (ctx->VertexProgram._Enabled
@@ -1179,18 +1185,18 @@ static void _ae_update_state( GLcontext *ctx )
    }
 
    /* finally, vertex position */
-   if (ctx->Array.ArrayObj->VertexAttrib[0].Enabled) {
+   if (arrayObj->VertexAttrib[0].Enabled) {
       /* Use glVertex(v) instead of glVertexAttrib(0, v) to be sure it's
        * issued as the last (provoking) attribute).
        */
-      aa->array = &ctx->Array.ArrayObj->VertexAttrib[0];
+      aa->array = &arrayObj->VertexAttrib[0];
       assert(aa->array->Size >= 2); /* XXX fix someday? */
       aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
    }
-   else if (ctx->Array.ArrayObj->Vertex.Enabled) {
-      aa->array = &ctx->Array.ArrayObj->Vertex;
+   else if (arrayObj->Vertex.Enabled) {
+      aa->array = &arrayObj->Vertex;
       aa->offset = VertexFuncs[aa->array->Size-2][TYPE_IDX(aa->array->Type)];
       check_vbo(actx, aa->array->BufferObj);
       aa++;
@@ -1252,7 +1258,7 @@ void _ae_unmap_vbos( GLcontext *ctx )
  * for all enabled vertex arrays (for elt-th element).
  * Note: this may be called during display list construction.
  */
-void GLAPIENTRY _ae_loopback_array_elt( GLint elt )
+void GLAPIENTRY _ae_ArrayElement( GLint elt )
 {
    GET_CURRENT_CONTEXT(ctx);
    const AEcontext *actx = AE_CONTEXT(ctx);
@@ -1315,3 +1321,13 @@ void _ae_invalidate_state( GLcontext *ctx, GLuint new_state )
       actx->NewState |= new_state;
    }
 }
+
+
+void _mesa_install_arrayelt_vtxfmt(struct _glapi_table *disp,
+                                   const GLvertexformat *vfmt)
+{
+   SET_ArrayElement(disp, vfmt->ArrayElement);
+}
+
+
+#endif /* FEATURE_arrayelt */
diff --git a/src/mesa/main/api_arrayelt.h b/src/mesa/main/api_arrayelt.h
index e621724fb2..d18c0792c3 100644
--- a/src/mesa/main/api_arrayelt.h
+++ b/src/mesa/main/api_arrayelt.h
@@ -27,16 +27,57 @@
 #ifndef API_ARRAYELT_H
 #define API_ARRAYELT_H
 
-#include "mtypes.h"
+
+#include "main/mtypes.h"
+
+#if FEATURE_arrayelt
+
+#define _MESA_INIT_ARRAYELT_VTXFMT(vfmt, impl)     \
+   do {                                            \
+      (vfmt)->ArrayElement = impl ## ArrayElement; \
+   } while (0)
 
 extern GLboolean _ae_create_context( GLcontext *ctx );
 extern void _ae_destroy_context( GLcontext *ctx );
 extern void _ae_invalidate_state( GLcontext *ctx, GLuint new_state );
-extern void GLAPIENTRY _ae_loopback_array_elt( GLint elt );
+extern void GLAPIENTRY _ae_ArrayElement( GLint elt );
 
 /* May optionally be called before a batch of element calls:
  */
 extern void _ae_map_vbos( GLcontext *ctx );
 extern void _ae_unmap_vbos( GLcontext *ctx );
 
-#endif
+extern void
+_mesa_install_arrayelt_vtxfmt(struct _glapi_table *disp,
+                              const GLvertexformat *vfmt);
+
+#else /* FEATURE_arrayelt */
+
+#define _MESA_INIT_ARRAYELT_VTXFMT(vfmt, impl) do { } while (0)
+
+static INLINE GLboolean
+_ae_create_context( GLcontext *ctx )
+{
+   return GL_TRUE;
+}
+
+static INLINE void
+_ae_destroy_context( GLcontext *ctx )
+{
+}
+
+static INLINE void
+_ae_invalidate_state( GLcontext *ctx, GLuint new_state )
+{
+}
+
+static INLINE void
+_mesa_install_arrayelt_vtxfmt(struct _glapi_table *disp,
+                              const GLvertexformat *vfmt)
+{
+}
+
+#endif /* FEATURE_arrayelt */
+
+
+#endif /* API_ARRAYELT_H */
diff --git a/src/mesa/main/api_exec.c b/src/mesa/main/api_exec.c
index bae3bf11cb..1559984f43 100644
--- a/src/mesa/main/api_exec.c
+++ b/src/mesa/main/api_exec.c
@@ -29,10 +29,8 @@
  */
 
 
-#include "glheader.h"
-#if FEATURE_accum
+#include "mfeatures.h"
 #include "accum.h"
-#endif
 #include "api_loopback.h"
 #include "api_exec.h"
 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
@@ -41,9 +39,7 @@
 #if FEATURE_ATI_fragment_shader
 #include "shader/atifragshader.h"
 #endif
-#if FEATURE_attrib_stack
 #include "attrib.h"
-#endif
 #include "blend.h"
 #if FEATURE_ARB_vertex_buffer_object
 #include "bufferobj.h"
@@ -54,29 +50,17 @@
 #endif
 #include "clear.h"
 #include "clip.h"
-#if FEATURE_colortable
 #include "colortab.h"
-#endif
 #include "context.h"
-#if FEATURE_convolve
 #include "convolve.h"
-#endif
 #include "depth.h"
-#if FEATURE_dlist
 #include "dlist.h"
-#endif
-#if FEATURE_drawpix
 #include "drawpix.h"
 #include "rastpos.h"
-#endif
 #include "enable.h"
-#if FEATURE_evaluators
 #include "eval.h"
-#endif
 #include "get.h"
-#if FEATURE_feedback
 #include "feedback.h"
-#endif
 #include "fog.h"
 #if FEATURE_EXT_framebuffer_object
 #include "fbobject.h"
@@ -84,38 +68,32 @@
 #include "ffvertex_prog.h"
 #include "framebuffer.h"
 #include "hint.h"
-#if FEATURE_histogram
 #include "histogram.h"
-#endif
 #include "imports.h"
 #include "light.h"
 #include "lines.h"
 #include "macros.h"
 #include "matrix.h"
 #include "multisample.h"
-#if FEATURE_pixel_transfer
 #include "pixel.h"
-#endif
 #include "pixelstore.h"
 #include "points.h"
 #include "polygon.h"
-#if FEATURE_ARB_occlusion_query || FEATURE_EXT_timer_query
 #include "queryobj.h"
-#endif
 #include "readpix.h"
 #include "scissor.h"
 #include "state.h"
 #include "stencil.h"
 #include "texenv.h"
+#include "texgetimage.h"
 #include "teximage.h"
-#if FEATURE_texgen
 #include "texgen.h"
-#endif
 #include "texobj.h"
 #include "texparam.h"
 #include "texstate.h"
 #include "mtypes.h"
 #include "varray.h"
+#include "viewport.h"
 #if FEATURE_NV_vertex_program
 #include "shader/nvprogram.h"
 #endif
@@ -127,6 +105,9 @@
 #if FEATURE_ARB_shader_objects
 #include "shaders.h"
 #endif
+#if FEATURE_ARB_sync
+#include "syncobj.h"
+#endif
 #include "debug.h"
 #include "glapi/dispatch.h"
 
@@ -194,20 +175,10 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_TexParameteri(exec, _mesa_TexParameteri);
    SET_Translatef(exec, _mesa_Translatef);
    SET_Viewport(exec, _mesa_Viewport);
-#if FEATURE_accum
-   SET_Accum(exec, _mesa_Accum);
-   SET_ClearAccum(exec, _mesa_ClearAccum);
-#endif
-#if FEATURE_dlist
-   SET_CallList(exec, _mesa_CallList);
-   SET_CallLists(exec, _mesa_CallLists);
-   SET_DeleteLists(exec, _mesa_DeleteLists);
-   SET_EndList(exec, _mesa_EndList);
-   SET_GenLists(exec, _mesa_GenLists);
-   SET_IsList(exec, _mesa_IsList);
-   SET_ListBase(exec, _mesa_ListBase);
-   SET_NewList(exec, _mesa_NewList);
-#endif
+
+   _mesa_init_accum_dispatch(exec);
+   _mesa_init_dlist_dispatch(exec);
+
    SET_ClearDepth(exec, _mesa_ClearDepth);
    SET_ClearIndex(exec, _mesa_ClearIndex);
    SET_ClipPlane(exec, _mesa_ClipPlane);
@@ -217,21 +188,10 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_DepthFunc(exec, _mesa_DepthFunc);
    SET_DepthMask(exec, _mesa_DepthMask);
    SET_DepthRange(exec, _mesa_DepthRange);
-#if FEATURE_drawpix
-   SET_Bitmap(exec, _mesa_Bitmap);
-   SET_CopyPixels(exec, _mesa_CopyPixels);
-   SET_DrawPixels(exec, _mesa_DrawPixels);
-#endif
-#if FEATURE_feedback
-   SET_InitNames(exec, _mesa_InitNames);
-   SET_FeedbackBuffer(exec, _mesa_FeedbackBuffer);
-   SET_LoadName(exec, _mesa_LoadName);
-   SET_PassThrough(exec, _mesa_PassThrough);
-   SET_PopName(exec, _mesa_PopName);
-   SET_PushName(exec, _mesa_PushName);
-   SET_SelectBuffer(exec, _mesa_SelectBuffer);
-   SET_RenderMode(exec, _mesa_RenderMode);
-#endif
+
+   _mesa_init_drawpix_dispatch(exec);
+   _mesa_init_feedback_dispatch(exec);
+
    SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT);
    SET_Fogf(exec, _mesa_Fogf);
    SET_Fogfv(exec, _mesa_Fogfv);
@@ -265,68 +225,22 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_Lighti(exec, _mesa_Lighti);
    SET_Lightiv(exec, _mesa_Lightiv);
    SET_LoadMatrixd(exec, _mesa_LoadMatrixd);
-#if FEATURE_evaluators
-   SET_GetMapdv(exec, _mesa_GetMapdv);
-   SET_GetMapfv(exec, _mesa_GetMapfv);
-   SET_GetMapiv(exec, _mesa_GetMapiv);
-   SET_Map1d(exec, _mesa_Map1d);
-   SET_Map1f(exec, _mesa_Map1f);
-   SET_Map2d(exec, _mesa_Map2d);
-   SET_Map2f(exec, _mesa_Map2f);
-   SET_MapGrid1d(exec, _mesa_MapGrid1d);
-   SET_MapGrid1f(exec, _mesa_MapGrid1f);
-   SET_MapGrid2d(exec, _mesa_MapGrid2d);
-   SET_MapGrid2f(exec, _mesa_MapGrid2f);
-#endif
+
+   _mesa_init_eval_dispatch(exec);
+
    SET_MultMatrixd(exec, _mesa_MultMatrixd);
-#if FEATURE_pixel_transfer
-   SET_GetPixelMapfv(exec, _mesa_GetPixelMapfv);
-   SET_GetPixelMapuiv(exec, _mesa_GetPixelMapuiv);
-   SET_GetPixelMapusv(exec, _mesa_GetPixelMapusv);
-   SET_PixelMapfv(exec, _mesa_PixelMapfv);
-   SET_PixelMapuiv(exec, _mesa_PixelMapuiv);
-   SET_PixelMapusv(exec, _mesa_PixelMapusv);
-   SET_PixelTransferf(exec, _mesa_PixelTransferf);
-   SET_PixelTransferi(exec, _mesa_PixelTransferi);
-   SET_PixelZoom(exec, _mesa_PixelZoom);
-#endif
+
+   _mesa_init_pixel_dispatch(exec);
+
    SET_PixelStoref(exec, _mesa_PixelStoref);
    SET_PointSize(exec, _mesa_PointSize);
    SET_PolygonMode(exec, _mesa_PolygonMode);
    SET_PolygonOffset(exec, _mesa_PolygonOffset);
    SET_PolygonStipple(exec, _mesa_PolygonStipple);
-#if FEATURE_attrib_stack
-   SET_PopAttrib(exec, _mesa_PopAttrib);
-   SET_PushAttrib(exec, _mesa_PushAttrib);
-   SET_PopClientAttrib(exec, _mesa_PopClientAttrib);
-   SET_PushClientAttrib(exec, _mesa_PushClientAttrib);
-#endif
-#if FEATURE_drawpix
-   SET_RasterPos2f(exec, _mesa_RasterPos2f);
-   SET_RasterPos2fv(exec, _mesa_RasterPos2fv);
-   SET_RasterPos2i(exec, _mesa_RasterPos2i);
-   SET_RasterPos2iv(exec, _mesa_RasterPos2iv);
-   SET_RasterPos2d(exec, _mesa_RasterPos2d);
-   SET_RasterPos2dv(exec, _mesa_RasterPos2dv);
-   SET_RasterPos2s(exec, _mesa_RasterPos2s);
-   SET_RasterPos2sv(exec, _mesa_RasterPos2sv);
-   SET_RasterPos3d(exec, _mesa_RasterPos3d);
-   SET_RasterPos3dv(exec, _mesa_RasterPos3dv);
-   SET_RasterPos3f(exec, _mesa_RasterPos3f);
-   SET_RasterPos3fv(exec, _mesa_RasterPos3fv);
-   SET_RasterPos3i(exec, _mesa_RasterPos3i);
-   SET_RasterPos3iv(exec, _mesa_RasterPos3iv);
-   SET_RasterPos3s(exec, _mesa_RasterPos3s);
-   SET_RasterPos3sv(exec, _mesa_RasterPos3sv);
-   SET_RasterPos4d(exec, _mesa_RasterPos4d);
-   SET_RasterPos4dv(exec, _mesa_RasterPos4dv);
-   SET_RasterPos4f(exec, _mesa_RasterPos4f);
-   SET_RasterPos4fv(exec, _mesa_RasterPos4fv);
-   SET_RasterPos4i(exec, _mesa_RasterPos4i);
-   SET_RasterPos4iv(exec, _mesa_RasterPos4iv);
-   SET_RasterPos4s(exec, _mesa_RasterPos4s);
-   SET_RasterPos4sv(exec, _mesa_RasterPos4sv);
-#endif
+
+   _mesa_init_attrib_dispatch(exec);
+   _mesa_init_rastpos_dispatch(exec);
+
    SET_ReadPixels(exec, _mesa_ReadPixels);
    SET_Rotated(exec, _mesa_Rotated);
    SET_Scaled(exec, _mesa_Scaled);
@@ -334,17 +248,7 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_TexEnvf(exec, _mesa_TexEnvf);
    SET_TexEnviv(exec, _mesa_TexEnviv);
 
-#if FEATURE_texgen
-   SET_GetTexGendv(exec, _mesa_GetTexGendv);
-   SET_GetTexGenfv(exec, _mesa_GetTexGenfv);
-   SET_GetTexGeniv(exec, _mesa_GetTexGeniv);
-   SET_TexGend(exec, _mesa_TexGend);
-   SET_TexGendv(exec, _mesa_TexGendv);
-   SET_TexGenf(exec, _mesa_TexGenf);
-   SET_TexGenfv(exec, _mesa_TexGenfv);
-   SET_TexGeni(exec, _mesa_TexGeni);
-   SET_TexGeniv(exec, _mesa_TexGeniv);
-#endif
+   _mesa_init_texgen_dispatch(exec);
 
    SET_TexImage1D(exec, _mesa_TexImage1D);
    SET_TexParameterf(exec, _mesa_TexParameterf);
@@ -390,45 +294,9 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_BlendEquation(exec, _mesa_BlendEquation);
    SET_BlendEquationSeparateEXT(exec, _mesa_BlendEquationSeparateEXT);
 
-#if FEATURE_colortable
-   SET_ColorSubTable(exec, _mesa_ColorSubTable);
-   SET_ColorTable(exec, _mesa_ColorTable);
-   SET_ColorTableParameterfv(exec, _mesa_ColorTableParameterfv);
-   SET_ColorTableParameteriv(exec, _mesa_ColorTableParameteriv);
-   SET_CopyColorSubTable(exec, _mesa_CopyColorSubTable);
-   SET_CopyColorTable(exec, _mesa_CopyColorTable);
-   SET_GetColorTable(exec, _mesa_GetColorTable);
-   SET_GetColorTableParameterfv(exec, _mesa_GetColorTableParameterfv);
-   SET_GetColorTableParameteriv(exec, _mesa_GetColorTableParameteriv);
-#endif
-
-#if FEATURE_convolve
-   SET_ConvolutionFilter1D(exec, _mesa_ConvolutionFilter1D);
-   SET_ConvolutionFilter2D(exec, _mesa_ConvolutionFilter2D);
-   SET_ConvolutionParameterf(exec, _mesa_ConvolutionParameterf);
-   SET_ConvolutionParameterfv(exec, _mesa_ConvolutionParameterfv);
-   SET_ConvolutionParameteri(exec, _mesa_ConvolutionParameteri);
-   SET_ConvolutionParameteriv(exec, _mesa_ConvolutionParameteriv);
-   SET_CopyConvolutionFilter1D(exec, _mesa_CopyConvolutionFilter1D);
-   SET_CopyConvolutionFilter2D(exec, _mesa_CopyConvolutionFilter2D);
-   SET_GetConvolutionFilter(exec, _mesa_GetConvolutionFilter);
-   SET_GetConvolutionParameterfv(exec, _mesa_GetConvolutionParameterfv);
-   SET_GetConvolutionParameteriv(exec, _mesa_GetConvolutionParameteriv);
-   SET_SeparableFilter2D(exec, _mesa_SeparableFilter2D);
-#endif
-#if FEATURE_histogram
-   SET_GetHistogram(exec, _mesa_GetHistogram);
-   SET_GetHistogramParameterfv(exec, _mesa_GetHistogramParameterfv);
-   SET_GetHistogramParameteriv(exec, _mesa_GetHistogramParameteriv);
-   SET_GetMinmax(exec, _mesa_GetMinmax);
-   SET_GetMinmaxParameterfv(exec, _mesa_GetMinmaxParameterfv);
-   SET_GetMinmaxParameteriv(exec, _mesa_GetMinmaxParameteriv);
-   SET_GetSeparableFilter(exec, _mesa_GetSeparableFilter);
-   SET_Histogram(exec, _mesa_Histogram);
-   SET_Minmax(exec, _mesa_Minmax);
-   SET_ResetHistogram(exec, _mesa_ResetHistogram);
-   SET_ResetMinmax(exec, _mesa_ResetMinmax);
-#endif
+   _mesa_init_colortable_dispatch(exec);
+   _mesa_init_convolve_dispatch(exec);
+   _mesa_init_histogram_dispatch(exec);
 
    /* OpenGL 2.0 */
    SET_StencilFuncSeparate(exec, _mesa_StencilFuncSeparate);
@@ -527,7 +395,6 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    /* 148. GL_EXT_multi_draw_arrays */
 #if _HAVE_FULL_GL
    SET_MultiDrawArraysEXT(exec, _mesa_MultiDrawArraysEXT);
-   SET_MultiDrawElementsEXT(exec, _mesa_MultiDrawElementsEXT);
 #endif
 
    /* 173. GL_INGR_blend_func_separate */
@@ -541,32 +408,7 @@ _mesa_init_exec_table(struct _glapi_table *exec)
 #endif
 
    /* 197. GL_MESA_window_pos */
-#if FEATURE_drawpix
-   SET_WindowPos2dMESA(exec, _mesa_WindowPos2dMESA);
-   SET_WindowPos2dvMESA(exec, _mesa_WindowPos2dvMESA);
-   SET_WindowPos2fMESA(exec, _mesa_WindowPos2fMESA);
-   SET_WindowPos2fvMESA(exec, _mesa_WindowPos2fvMESA);
-   SET_WindowPos2iMESA(exec, _mesa_WindowPos2iMESA);
-   SET_WindowPos2ivMESA(exec, _mesa_WindowPos2ivMESA);
-   SET_WindowPos2sMESA(exec, _mesa_WindowPos2sMESA);
-   SET_WindowPos2svMESA(exec, _mesa_WindowPos2svMESA);
-   SET_WindowPos3dMESA(exec, _mesa_WindowPos3dMESA);
-   SET_WindowPos3dvMESA(exec, _mesa_WindowPos3dvMESA);
-   SET_WindowPos3fMESA(exec, _mesa_WindowPos3fMESA);
-   SET_WindowPos3fvMESA(exec, _mesa_WindowPos3fvMESA);
-   SET_WindowPos3iMESA(exec, _mesa_WindowPos3iMESA);
-   SET_WindowPos3ivMESA(exec, _mesa_WindowPos3ivMESA);
-   SET_WindowPos3sMESA(exec, _mesa_WindowPos3sMESA);
-   SET_WindowPos3svMESA(exec, _mesa_WindowPos3svMESA);
-   SET_WindowPos4dMESA(exec, _mesa_WindowPos4dMESA);
-   SET_WindowPos4dvMESA(exec, _mesa_WindowPos4dvMESA);
-   SET_WindowPos4fMESA(exec, _mesa_WindowPos4fMESA);
-   SET_WindowPos4fvMESA(exec, _mesa_WindowPos4fvMESA);
-   SET_WindowPos4iMESA(exec, _mesa_WindowPos4iMESA);
-   SET_WindowPos4ivMESA(exec, _mesa_WindowPos4ivMESA);
-   SET_WindowPos4sMESA(exec, _mesa_WindowPos4sMESA);
-   SET_WindowPos4svMESA(exec, _mesa_WindowPos4svMESA);
-#endif
+   /* part of _mesa_init_rastpos_dispatch(exec); */
 
    /* 200. GL_IBM_multimode_draw_arrays */
 #if _HAVE_FULL_GL
@@ -640,6 +482,8 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    /* ???. GL_EXT_depth_bounds_test */
    SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT);
 
+   SET_ProvokingVertexEXT(exec, _mesa_ProvokingVertexEXT);
+
    /* ARB 1. GL_ARB_multitexture */
 #if _HAVE_FULL_GL
    SET_ActiveTextureARB(exec, _mesa_ActiveTextureARB);
@@ -756,16 +600,7 @@ _mesa_init_exec_table(struct _glapi_table *exec)
 #endif
 
    /* ARB 29. GL_ARB_occlusion_query */
-#if FEATURE_ARB_occlusion_query
-   SET_GenQueriesARB(exec, _mesa_GenQueriesARB);
-   SET_DeleteQueriesARB(exec, _mesa_DeleteQueriesARB);
-   SET_IsQueryARB(exec, _mesa_IsQueryARB);
-   SET_BeginQueryARB(exec, _mesa_BeginQueryARB);
-   SET_EndQueryARB(exec, _mesa_EndQueryARB);
-   SET_GetQueryivARB(exec, _mesa_GetQueryivARB);
-   SET_GetQueryObjectivARB(exec, _mesa_GetQueryObjectivARB);
-   SET_GetQueryObjectuivARB(exec, _mesa_GetQueryObjectuivARB);
-#endif
+   _mesa_init_queryobj_dispatch(exec);
 
    /* ARB 37. GL_ARB_draw_buffers */
 #if FEATURE_draw_read_buffer
@@ -820,6 +655,17 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
 #endif    /* FEATURE_ARB_vertex_shader */
 
+   /* GL_ARB_sync */
+#if FEATURE_ARB_sync
+   SET_IsSync(exec, _mesa_IsSync);
+   SET_DeleteSync(exec, _mesa_DeleteSync);
+   SET_FenceSync(exec, _mesa_FenceSync);
+   SET_ClientWaitSync(exec, _mesa_ClientWaitSync);
+   SET_WaitSync(exec, _mesa_WaitSync);
+   SET_GetInteger64v(exec, _mesa_GetInteger64v);
+   SET_GetSynciv(exec, _mesa_GetSynciv);
+#endif
+
   /* GL_ATI_fragment_shader */
 #if FEATURE_ATI_fragment_shader
    SET_GenFragmentShadersATI(exec, _mesa_GenFragmentShadersATI);
@@ -838,6 +684,12 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_SetFragmentShaderConstantATI(exec, _mesa_SetFragmentShaderConstantATI);
 #endif
 
+  /* GL_ATI_envmap_bumpmap */
+   SET_GetTexBumpParameterivATI(exec, _mesa_GetTexBumpParameterivATI);
+   SET_GetTexBumpParameterfvATI(exec, _mesa_GetTexBumpParameterfvATI);
+   SET_TexBumpParameterivATI(exec, _mesa_TexBumpParameterivATI);
+   SET_TexBumpParameterfvATI(exec, _mesa_TexBumpParameterfvATI);
+
 #if FEATURE_EXT_framebuffer_object
    SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT);
    SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT);
@@ -858,11 +710,6 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    SET_GenerateMipmapEXT(exec, _mesa_GenerateMipmapEXT);
 #endif
 
-#if FEATURE_EXT_timer_query
-   SET_GetQueryObjecti64vEXT(exec, _mesa_GetQueryObjecti64vEXT);
-   SET_GetQueryObjectui64vEXT(exec, _mesa_GetQueryObjectui64vEXT);
-#endif
-
 #if FEATURE_EXT_framebuffer_blit
    SET_BlitFramebufferEXT(exec, _mesa_BlitFramebufferEXT);
 #endif
@@ -880,5 +727,23 @@ _mesa_init_exec_table(struct _glapi_table *exec)
 
    /* GL_ATI_separate_stencil */
    SET_StencilFuncSeparateATI(exec, _mesa_StencilFuncSeparateATI);
-}
 
+#if FEATURE_ARB_framebuffer_object
+   /* The ARB_fbo functions are the union of
+    * GL_EXT_fbo, GL_EXT_framebuffer_blit, GL_EXT_texture_array
+    */
+   SET_RenderbufferStorageMultisample(exec, _mesa_RenderbufferStorageMultisample);
+#endif
+
+#if FEATURE_ARB_map_buffer_range
+   SET_MapBufferRange(exec, _mesa_MapBufferRange);
+   SET_FlushMappedBufferRange(exec, _mesa_FlushMappedBufferRange);
+#endif
+
+   /* GL_ARB_copy_buffer */
+   SET_CopyBufferSubData(exec, _mesa_CopyBufferSubData);
+
+   /* GL_ARB_vertex_array_object */
+   SET_BindVertexArray(exec, _mesa_BindVertexArray);
+   SET_GenVertexArrays(exec, _mesa_GenVertexArrays);
+}
diff --git a/src/mesa/main/api_loopback.c b/src/mesa/main/api_loopback.c
index 0e3f5ff957..3d466ac44a 100644
--- a/src/mesa/main/api_loopback.c
+++ b/src/mesa/main/api_loopback.c
@@ -77,6 +77,10 @@
 #define FOGCOORDF(x)                CALL_FogCoordfEXT(GET_DISPATCH(), (x))
 #define SECONDARYCOLORF(a,b,c)      CALL_SecondaryColor3fEXT(GET_DISPATCH(), (a,b,c))
 
+
+#if FEATURE_beginend
+
+
 static void GLAPIENTRY
 loopback_Color3b_f( GLbyte red, GLbyte green, GLbyte blue )
 {
@@ -1655,3 +1659,6 @@ _mesa_loopback_init_api_table( struct _glapi_table *dest )
    SET_VertexAttrib4NusvARB(dest, loopback_VertexAttrib4NusvARB);
    SET_VertexAttrib4NuivARB(dest, loopback_VertexAttrib4NuivARB);
 }
+
+
+#endif /* FEATURE_beginend */
diff --git a/src/mesa/main/api_loopback.h b/src/mesa/main/api_loopback.h
index 6f85bbc1d9..751cba2931 100644
--- a/src/mesa/main/api_loopback.h
+++ b/src/mesa/main/api_loopback.h
@@ -27,11 +27,21 @@
 #ifndef API_LOOPBACK_H
 #define API_LOOPBACK_H
 
-#include "glheader.h"
+#include "main/mtypes.h"
 
+#if FEATURE_beginend
 
 struct _glapi_table;
 
 extern void _mesa_loopback_init_api_table( struct _glapi_table *dest );
 
-#endif
+#else /* FEATURE_beginend */
+
+static INLINE void
+_mesa_loopback_init_api_table( struct _glapi_table *dest )
+{
+}
+
+#endif /* FEATURE_beginend */
+
+#endif /* API_LOOPBACK_H */
diff --git a/src/mesa/main/api_noop.c b/src/mesa/main/api_noop.c
index a1cc3a2a4b..cd67661382 100644
--- a/src/mesa/main/api_noop.c
+++ b/src/mesa/main/api_noop.c
@@ -30,9 +30,8 @@
 #include "context.h"
 #include "light.h"
 #include "macros.h"
-#if FEATURE_dlist
 #include "dlist.h"
-#endif
+#include "eval.h"
 #include "glapi/dispatch.h"
 
 
@@ -44,6 +43,9 @@
  */
 
 
+#if FEATURE_beginend
+
+
 static void GLAPIENTRY _mesa_noop_EdgeFlag( GLboolean b )
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -477,7 +479,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat
 static void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, 0, 0, 1);
    }
    else
@@ -487,7 +489,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
 static void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], 0, 0, 1);
    }
    else
@@ -497,7 +499,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloa
 static void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, 0, 1);
    }
    else
@@ -507,7 +509,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GL
 static void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], 0, 1);
    }
    else
@@ -518,7 +520,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
                                   GLfloat y, GLfloat z )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, 1);
    }
    else
@@ -528,7 +530,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
 static void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], 1);
    }
    else
@@ -539,7 +541,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
                                   GLfloat y, GLfloat z, GLfloat w )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, w);
    }
    else
@@ -549,7 +551,7 @@ static void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
 static void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (index < MAX_VERTEX_ATTRIBS) {
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
       ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], v[3]);
    }
    else
@@ -624,7 +626,7 @@ static void GLAPIENTRY _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLf
 }
 
 
-#if FEATURE_evaluators
+#if FEATURE_eval
 /* Similarly, these have no effect outside begin/end:
  */
 static void GLAPIENTRY _mesa_noop_EvalCoord1f( GLfloat a )
@@ -656,7 +658,7 @@ static void GLAPIENTRY _mesa_noop_EvalPoint2( GLint a, GLint b )
 {
    (void) a; (void) b;
 }
-#endif /* FEATURE_evaluators */
+#endif /* FEATURE_eval */
 
 
 /* Begin -- call into driver, should result in the vtxfmt being
@@ -731,7 +733,7 @@ _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
 
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
       return;
 
    CALL_Begin(GET_DISPATCH(), (mode));
@@ -757,6 +759,43 @@ _mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
    CALL_End(GET_DISPATCH(), ());
 }
 
+static void GLAPIENTRY
+_mesa_noop_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+				  const GLvoid *indices, GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint i;
+
+   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
+				     basevertex ))
+      return;
+
+   CALL_Begin(GET_DISPATCH(), (mode));
+
+   switch (type) {
+   case GL_UNSIGNED_BYTE:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] +
+					      basevertex));
+      break;
+   case GL_UNSIGNED_SHORT:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] +
+					      basevertex ));
+      break;
+   case GL_UNSIGNED_INT:
+      for (i = 0 ; i < count ; i++)
+	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] +
+					      basevertex ));
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElementsBaseVertex(type)" );
+      break;
+   }
+
+   CALL_End(GET_DISPATCH(), ());
+}
+
 
 static void GLAPIENTRY
 _mesa_noop_DrawRangeElements(GLenum mode,
@@ -768,10 +807,58 @@ _mesa_noop_DrawRangeElements(GLenum mode,
 
    if (_mesa_validate_DrawRangeElements( ctx, mode,
 					 start, end,
-					 count, type, indices ))
+					 count, type, indices, 0 ))
        CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
 }
 
+/* GL_EXT_multi_draw_arrays */
+void GLAPIENTRY
+_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
+			     const GLvoid **indices, GLsizei primcount)
+{
+   GLsizei i;
+
+   for (i = 0; i < primcount; i++) {
+      if (count[i] > 0) {
+	 CALL_DrawElements(GET_DISPATCH(), (mode, count[i], type, indices[i]));
+      }
+   }
+}
+
+static void GLAPIENTRY
+_mesa_noop_DrawRangeElementsBaseVertex(GLenum mode,
+				       GLuint start, GLuint end,
+				       GLsizei count, GLenum type,
+				       const GLvoid *indices, GLint basevertex)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (_mesa_validate_DrawRangeElements( ctx, mode,
+					 start, end,
+					 count, type, indices, basevertex ))
+      CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count, type, indices,
+						   basevertex));
+}
+
+/* GL_EXT_multi_draw_arrays */
+void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+				       GLenum type,
+				       const GLvoid **indices,
+				       GLsizei primcount,
+				       const GLint *basevertex)
+{
+   GLsizei i;
+
+   for (i = 0; i < primcount; i++) {
+      if (count[i] > 0) {
+	 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
+						      indices[i],
+						      basevertex[i]));
+      }
+   }
+}
+
 /*
  * Eval Mesh
  */
@@ -907,26 +994,21 @@ _mesa_noop_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
 void
 _mesa_noop_vtxfmt_init( GLvertexformat *vfmt )
 {
-   vfmt->ArrayElement = _ae_loopback_array_elt;	        /* generic helper */
+   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
+
    vfmt->Begin = _mesa_noop_Begin;
-#if FEATURE_dlist
-   vfmt->CallList = _mesa_CallList;
-   vfmt->CallLists = _mesa_CallLists;
-#endif
+
+   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);
+
    vfmt->Color3f = _mesa_noop_Color3f;
    vfmt->Color3fv = _mesa_noop_Color3fv;
    vfmt->Color4f = _mesa_noop_Color4f;
    vfmt->Color4fv = _mesa_noop_Color4fv;
    vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
    vfmt->End = _mesa_noop_End;
-#if FEATURE_evaluators
-   vfmt->EvalCoord1f = _mesa_noop_EvalCoord1f;
-   vfmt->EvalCoord1fv = _mesa_noop_EvalCoord1fv;
-   vfmt->EvalCoord2f = _mesa_noop_EvalCoord2f;
-   vfmt->EvalCoord2fv = _mesa_noop_EvalCoord2fv;
-   vfmt->EvalPoint1 = _mesa_noop_EvalPoint1;
-   vfmt->EvalPoint2 = _mesa_noop_EvalPoint2;
-#endif
+
+   _MESA_INIT_EVAL_VTXFMT(vfmt, _mesa_noop_);
+
    vfmt->FogCoordfEXT = _mesa_noop_FogCoordfEXT;
    vfmt->FogCoordfvEXT = _mesa_noop_FogCoordfvEXT;
    vfmt->Indexf = _mesa_noop_Indexf;
@@ -980,6 +1062,11 @@ _mesa_noop_vtxfmt_init( GLvertexformat *vfmt )
    vfmt->DrawArrays = _mesa_noop_DrawArrays;
    vfmt->DrawElements = _mesa_noop_DrawElements;
    vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements;
-   vfmt->EvalMesh1 = _mesa_noop_EvalMesh1;
-   vfmt->EvalMesh2 = _mesa_noop_EvalMesh2;
+   vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
+   vfmt->DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
+   vfmt->DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
+   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
 }
+
+
+#endif /* FEATURE_beginend */
diff --git a/src/mesa/main/api_noop.h b/src/mesa/main/api_noop.h
index 8bf4660800..e7fd49bafb 100644
--- a/src/mesa/main/api_noop.h
+++ b/src/mesa/main/api_noop.h
@@ -25,8 +25,9 @@
 #ifndef _API_NOOP_H
 #define _API_NOOP_H
 
-#include "mtypes.h"
-#include "context.h"
+#include "main/mtypes.h"
+
+#if FEATURE_beginend
 
 extern void GLAPIENTRY
 _mesa_noop_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
@@ -40,7 +41,20 @@ _mesa_noop_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
 extern void GLAPIENTRY
 _mesa_noop_Materialfv(GLenum face, GLenum pname, const GLfloat *param);
 
+extern void GLAPIENTRY
+_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
+			     const GLvoid **indices, GLsizei primcount);
+
+extern void GLAPIENTRY
+_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
+				       GLenum type,
+				       const GLvoid **indices,
+				       GLsizei primcount,
+				       const GLint *basevertex);
+
 extern void
 _mesa_noop_vtxfmt_init(GLvertexformat *vfmt);
 
-#endif
+#endif /* FEATURE_beginend */
+
+#endif /* _API_NOOP_H */
diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c
index 59c2debb22..4a1448deee 100644
--- a/src/mesa/main/api_validate.c
+++ b/src/mesa/main/api_validate.c
@@ -24,82 +24,105 @@
 
 #include "glheader.h"
 #include "api_validate.h"
+#include "bufferobj.h"
 #include "context.h"
 #include "imports.h"
 #include "mtypes.h"
 #include "state.h"
+#include "vbo/vbo.h"
 
 
 /**
- * Find the max index in the given element/index buffer
+ * \return  number of bytes in array [count] of type.
  */
-static GLuint
-max_buffer_index(GLcontext *ctx, GLuint count, GLenum type,
-                 const void *indices,
-                 struct gl_buffer_object *elementBuf)
+static GLsizei
+index_bytes(GLenum type, GLsizei count)
 {
-   const GLubyte *map = NULL;
-   GLuint max = 0;
-   GLint i;
-
-   if (elementBuf->Name) {
-      /* elements are in a user-defined buffer object.  need to map it */
-      map = ctx->Driver.MapBuffer(ctx,
-                                  GL_ELEMENT_ARRAY_BUFFER_ARB,
-                                  GL_READ_ONLY,
-                                  elementBuf);
-      /* Actual address is the sum of pointers */
-      indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
-   }
-
    if (type == GL_UNSIGNED_INT) {
-      for (i = 0; i < count; i++)
-         if (((GLuint *) indices)[i] > max)
-            max = ((GLuint *) indices)[i];
+      return count * sizeof(GLuint);
    }
-   else if (type == GL_UNSIGNED_SHORT) {
-      for (i = 0; i < count; i++)
-         if (((GLushort *) indices)[i] > max)
-            max = ((GLushort *) indices)[i];
+   else if (type == GL_UNSIGNED_BYTE) {
+      return count * sizeof(GLubyte);
    }
    else {
-      ASSERT(type == GL_UNSIGNED_BYTE);
-      for (i = 0; i < count; i++)
-         if (((GLubyte *) indices)[i] > max)
-            max = ((GLubyte *) indices)[i];
-   }
-
-   if (map) {
-      ctx->Driver.UnmapBuffer(ctx,
-                              GL_ELEMENT_ARRAY_BUFFER_ARB,
-                              ctx->Array.ElementArrayBufferObj);
+      ASSERT(type == GL_UNSIGNED_SHORT);
+      return count * sizeof(GLushort);
    }
-
-   return max;
 }
 
+
+/**
+ * Check if OK to draw arrays/elements.
+ */
 static GLboolean
-check_valid_to_render(GLcontext *ctx, char *function)
+check_valid_to_render(GLcontext *ctx, const char *function)
 {
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "glDraw%s(incomplete framebuffer)", function);
+   if (!_mesa_valid_to_render(ctx, function)) {
       return GL_FALSE;
    }
 
-   /* Always need vertex positions, unless a vertex program is in use */
-   if (!ctx->VertexProgram._Current &&
-       !ctx->Array.ArrayObj->Vertex.Enabled &&
+#if FEATURE_es2_glsl
+   /* For ES2, we can draw if any vertex array is enabled (and we should
+    * always have a vertex program/shader).
+    */
+   if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
+      return GL_FALSE;
+#else
+   /* For regular OpenGL, only draw if we have vertex positions (regardless
+    * of whether or not we have a vertex program/shader).
+    */
+   if (!ctx->Array.ArrayObj->Vertex.Enabled &&
        !ctx->Array.ArrayObj->VertexAttrib[0].Enabled)
       return GL_FALSE;
+#endif
 
    return GL_TRUE;
 }
 
+static GLboolean
+check_index_bounds(GLcontext *ctx, GLsizei count, GLenum type,
+		   const GLvoid *indices, GLint basevertex)
+{
+   struct _mesa_prim prim;
+   struct _mesa_index_buffer ib;
+   GLuint min, max;
+
+   /* Only the X Server needs to do this -- otherwise, accessing outside
+    * array/BO bounds allows application termination.
+    */
+   if (!ctx->Const.CheckArrayBounds)
+      return GL_TRUE;
+
+   memset(&prim, 0, sizeof(prim));
+   prim.count = count;
+
+   memset(&ib, 0, sizeof(ib));
+   ib.type = type;
+   ib.ptr = indices;
+   ib.obj = ctx->Array.ElementArrayBufferObj;
+
+   vbo_get_minmax_index(ctx, &prim, &ib, &min, &max);
+
+   if (min + basevertex < 0 ||
+       max + basevertex > ctx->Array.ArrayObj->_MaxElement) {
+      /* the max element is out of bounds of one or more enabled arrays */
+      _mesa_warning(ctx, "glDrawElements() index=%u is "
+		    "out of bounds (max=%u)", max, ctx->Array.ArrayObj->_MaxElement);
+      return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+
+/**
+ * Error checking for glDrawElements().  Includes parameter checking
+ * and VBO bounds checking.
+ * \return GL_TRUE if OK to render, GL_FALSE if error found
+ */
 GLboolean
 _mesa_validate_DrawElements(GLcontext *ctx,
 			    GLenum mode, GLsizei count, GLenum type,
-			    const GLvoid *indices)
+			    const GLvoid *indices, GLint basevertex)
 {
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx,  GL_FALSE);
 
@@ -125,27 +148,14 @@ _mesa_validate_DrawElements(GLcontext *ctx,
    if (ctx->NewState)
       _mesa_update_state(ctx);
 
-   if (!check_valid_to_render(ctx, "Elements"))
+   if (!check_valid_to_render(ctx, "glDrawElements"))
       return GL_FALSE;
 
    /* Vertex buffer object tests */
-   if (ctx->Array.ElementArrayBufferObj->Name) {
+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
       /* use indices in the buffer object */
-      GLuint indexBytes;
-
-      if (type == GL_UNSIGNED_INT) {
-         indexBytes = count * sizeof(GLuint);
-      }
-      else if (type == GL_UNSIGNED_BYTE) {
-         indexBytes = count * sizeof(GLubyte);
-      }
-      else {
-         ASSERT(type == GL_UNSIGNED_SHORT);
-         indexBytes = count * sizeof(GLushort);
-      }
-
       /* make sure count doesn't go outside buffer bounds */
-      if (indexBytes > (GLuint) ctx->Array.ElementArrayBufferObj->Size) {
+      if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
          _mesa_warning(ctx, "glDrawElements index out of buffer bounds");
          return GL_FALSE;
       }
@@ -156,24 +166,23 @@ _mesa_validate_DrawElements(GLcontext *ctx,
          return GL_FALSE;
    }
 
-   if (ctx->Const.CheckArrayBounds) {
-      /* find max array index */
-      GLuint max = max_buffer_index(ctx, count, type, indices,
-                                    ctx->Array.ElementArrayBufferObj);
-      if (max >= ctx->Array._MaxElement) {
-         /* the max element is out of bounds of one or more enabled arrays */
-         return GL_FALSE;
-      }
-   }
+   if (!check_index_bounds(ctx, count, type, indices, basevertex))
+      return GL_FALSE;
 
    return GL_TRUE;
 }
 
+
+/**
+ * Error checking for glDrawRangeElements().  Includes parameter checking
+ * and VBO bounds checking.
+ * \return GL_TRUE if OK to render, GL_FALSE if error found
+ */
 GLboolean
 _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 				 GLuint start, GLuint end,
 				 GLsizei count, GLenum type,
-				 const GLvoid *indices)
+				 const GLvoid *indices, GLint basevertex)
 {
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
@@ -203,27 +212,14 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
    if (ctx->NewState)
       _mesa_update_state(ctx);
 
-   if (!check_valid_to_render(ctx, "RangeElements"))
+   if (!check_valid_to_render(ctx, "glDrawRangeElements"))
       return GL_FALSE;
 
    /* Vertex buffer object tests */
-   if (ctx->Array.ElementArrayBufferObj->Name) {
+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
       /* use indices in the buffer object */
-      GLuint indexBytes;
-
-      if (type == GL_UNSIGNED_INT) {
-         indexBytes = count * sizeof(GLuint);
-      }
-      else if (type == GL_UNSIGNED_BYTE) {
-         indexBytes = count * sizeof(GLubyte);
-      }
-      else {
-         ASSERT(type == GL_UNSIGNED_SHORT);
-         indexBytes = count * sizeof(GLushort);
-      }
-
       /* make sure count doesn't go outside buffer bounds */
-      if (indexBytes > ctx->Array.ElementArrayBufferObj->Size) {
+      if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
          _mesa_warning(ctx, "glDrawRangeElements index out of buffer bounds");
          return GL_FALSE;
       }
@@ -234,14 +230,8 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
          return GL_FALSE;
    }
 
-   if (ctx->Const.CheckArrayBounds) {
-      GLuint max = max_buffer_index(ctx, count, type, indices,
-                                    ctx->Array.ElementArrayBufferObj);
-      if (max >= ctx->Array._MaxElement) {
-         /* the max element is out of bounds of one or more enabled arrays */
-         return GL_FALSE;
-      }
-   }
+   if (!check_index_bounds(ctx, count, type, indices, basevertex))
+      return GL_FALSE;
 
    return GL_TRUE;
 }
@@ -250,6 +240,7 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 /**
  * Called from the tnl module to error check the function parameters and
  * verify that we really can draw something.
+ * \return GL_TRUE if OK to render, GL_FALSE if error found
  */
 GLboolean
 _mesa_validate_DrawArrays(GLcontext *ctx,
@@ -271,11 +262,11 @@ _mesa_validate_DrawArrays(GLcontext *ctx,
    if (ctx->NewState)
       _mesa_update_state(ctx);
 
-   if (!check_valid_to_render(ctx, "Arrays"))
+   if (!check_valid_to_render(ctx, "glDrawArrays"))
       return GL_FALSE;
 
    if (ctx->Const.CheckArrayBounds) {
-      if (start + count > (GLint) ctx->Array._MaxElement)
+      if (start + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
          return GL_FALSE;
    }
 
diff --git a/src/mesa/main/api_validate.h b/src/mesa/main/api_validate.h
index 10f0c34e66..1d3ae157d7 100644
--- a/src/mesa/main/api_validate.h
+++ b/src/mesa/main/api_validate.h
@@ -37,13 +37,13 @@ _mesa_validate_DrawArrays(GLcontext *ctx,
 extern GLboolean
 _mesa_validate_DrawElements(GLcontext *ctx,
 			    GLenum mode, GLsizei count, GLenum type,
-			    const GLvoid *indices);
+			    const GLvoid *indices, GLint basevertex);
 
 extern GLboolean
 _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 				 GLuint start, GLuint end,
 				 GLsizei count, GLenum type,
-				 const GLvoid *indices);
+				 const GLvoid *indices, GLint basevertex);
 
 
 #endif
diff --git a/src/mesa/main/arrayobj.c b/src/mesa/main/arrayobj.c
index f3f482f8c8..fd35d4e38c 100644
--- a/src/mesa/main/arrayobj.c
+++ b/src/mesa/main/arrayobj.c
@@ -1,9 +1,10 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.2
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  * (C) Copyright IBM Corporation 2006
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -46,6 +47,7 @@
 #include "bufferobj.h"
 #endif
 #include "arrayobj.h"
+#include "macros.h"
 #include "glapi/dispatch.h"
 
 
@@ -61,10 +63,38 @@
 static INLINE struct gl_array_object *
 lookup_arrayobj(GLcontext *ctx, GLuint id)
 {
-   return (id == 0) 
-     ? NULL 
-     : (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects,
-						   id);
+   if (id == 0)
+      return NULL;
+   else
+      return (struct gl_array_object *)
+         _mesa_HashLookup(ctx->Array.Objects, id);
+}
+
+
+/**
+ * For all the vertex arrays in the array object, unbind any pointers
+ * to any buffer objects (VBOs).
+ * This is done just prior to array object destruction.
+ */
+static void
+unbind_array_object_vbos(GLcontext *ctx, struct gl_array_object *obj)
+{
+   GLuint i;
+
+   _mesa_reference_buffer_object(ctx, &obj->Vertex.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->Weight.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->Normal.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->Color.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->SecondaryColor.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->FogCoord.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->Index.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &obj->EdgeFlag.BufferObj, NULL);
+
+   for (i = 0; i < Elements(obj->TexCoord); i++)
+      _mesa_reference_buffer_object(ctx, &obj->TexCoord[i].BufferObj, NULL);
+
+   for (i = 0; i < Elements(obj->VertexAttrib); i++)
+      _mesa_reference_buffer_object(ctx, &obj->VertexAttrib[i].BufferObj,NULL);
 }
 
 
@@ -94,10 +124,93 @@ void
 _mesa_delete_array_object( GLcontext *ctx, struct gl_array_object *obj )
 {
    (void) ctx;
+   unbind_array_object_vbos(ctx, obj);
+   _glthread_DESTROY_MUTEX(obj->Mutex);
    _mesa_free(obj);
 }
 
 
+/**
+ * Set ptr to arrayObj w/ reference counting.
+ */
+void
+_mesa_reference_array_object(GLcontext *ctx,
+                             struct gl_array_object **ptr,
+                             struct gl_array_object *arrayObj)
+{
+   if (*ptr == arrayObj)
+      return;
+
+   if (*ptr) {
+      /* Unreference the old array object */
+      GLboolean deleteFlag = GL_FALSE;
+      struct gl_array_object *oldObj = *ptr;
+
+      _glthread_LOCK_MUTEX(oldObj->Mutex);
+      ASSERT(oldObj->RefCount > 0);
+      oldObj->RefCount--;
+#if 0
+      printf("ArrayObj %p %d DECR to %d\n",
+             (void *) oldObj, oldObj->Name, oldObj->RefCount);
+#endif
+      deleteFlag = (oldObj->RefCount == 0);
+      _glthread_UNLOCK_MUTEX(oldObj->Mutex);
+
+      if (deleteFlag) {
+	 ASSERT(ctx->Driver.DeleteArrayObject);
+         ctx->Driver.DeleteArrayObject(ctx, oldObj);
+      }
+
+      *ptr = NULL;
+   }
+   ASSERT(!*ptr);
+
+   if (arrayObj) {
+      /* reference new array object */
+      _glthread_LOCK_MUTEX(arrayObj->Mutex);
+      if (arrayObj->RefCount == 0) {
+         /* this array's being deleted (look just above) */
+         /* Not sure this can every really happen.  Warn if it does. */
+         _mesa_problem(NULL, "referencing deleted array object");
+         *ptr = NULL;
+      }
+      else {
+         arrayObj->RefCount++;
+#if 0
+         printf("ArrayObj %p %d INCR to %d\n",
+                (void *) arrayObj, arrayObj->Name, arrayObj->RefCount);
+#endif
+         *ptr = arrayObj;
+      }
+      _glthread_UNLOCK_MUTEX(arrayObj->Mutex);
+   }
+}
+
+
+
+static void
+init_array(GLcontext *ctx,
+           struct gl_client_array *array, GLint size, GLint type)
+{
+   array->Size = size;
+   array->Type = type;
+   array->Format = GL_RGBA; /* only significant for GL_EXT_vertex_array_bgra */
+   array->Stride = 0;
+   array->StrideB = 0;
+   array->Ptr = NULL;
+   array->Enabled = GL_FALSE;
+   array->Normalized = GL_FALSE;
+#if FEATURE_ARB_vertex_buffer_object
+   /* Vertex array buffers */
+   _mesa_reference_buffer_object(ctx, &array->BufferObj,
+                                 ctx->Shared->NullBufferObj);
+#endif
+}
+
+
+/**
+ * Initialize a gl_array_object's arrays.
+ */
 void
 _mesa_initialize_array_object( GLcontext *ctx,
 			       struct gl_array_object *obj,
@@ -107,87 +220,27 @@ _mesa_initialize_array_object( GLcontext *ctx,
 
    obj->Name = name;
 
-   /* Vertex arrays */
-   obj->Vertex.Size = 4;
-   obj->Vertex.Type = GL_FLOAT;
-   obj->Vertex.Stride = 0;
-   obj->Vertex.StrideB = 0;
-   obj->Vertex.Ptr = NULL;
-   obj->Vertex.Enabled = GL_FALSE;
-   obj->Normal.Type = GL_FLOAT;
-   obj->Normal.Stride = 0;
-   obj->Normal.StrideB = 0;
-   obj->Normal.Ptr = NULL;
-   obj->Normal.Enabled = GL_FALSE;
-   obj->Color.Size = 4;
-   obj->Color.Type = GL_FLOAT;
-   obj->Color.Stride = 0;
-   obj->Color.StrideB = 0;
-   obj->Color.Ptr = NULL;
-   obj->Color.Enabled = GL_FALSE;
-   obj->SecondaryColor.Size = 4;
-   obj->SecondaryColor.Type = GL_FLOAT;
-   obj->SecondaryColor.Stride = 0;
-   obj->SecondaryColor.StrideB = 0;
-   obj->SecondaryColor.Ptr = NULL;
-   obj->SecondaryColor.Enabled = GL_FALSE;
-   obj->FogCoord.Size = 1;
-   obj->FogCoord.Type = GL_FLOAT;
-   obj->FogCoord.Stride = 0;
-   obj->FogCoord.StrideB = 0;
-   obj->FogCoord.Ptr = NULL;
-   obj->FogCoord.Enabled = GL_FALSE;
-   obj->Index.Type = GL_FLOAT;
-   obj->Index.Stride = 0;
-   obj->Index.StrideB = 0;
-   obj->Index.Ptr = NULL;
-   obj->Index.Enabled = GL_FALSE;
-   for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
-      obj->TexCoord[i].Size = 4;
-      obj->TexCoord[i].Type = GL_FLOAT;
-      obj->TexCoord[i].Stride = 0;
-      obj->TexCoord[i].StrideB = 0;
-      obj->TexCoord[i].Ptr = NULL;
-      obj->TexCoord[i].Enabled = GL_FALSE;
+   _glthread_INIT_MUTEX(obj->Mutex);
+   obj->RefCount = 1;
+
+   /* Init the individual arrays */
+   init_array(ctx, &obj->Vertex, 4, GL_FLOAT);
+   init_array(ctx, &obj->Weight, 1, GL_FLOAT);
+   init_array(ctx, &obj->Normal, 3, GL_FLOAT);
+   init_array(ctx, &obj->Color, 4, GL_FLOAT);
+   init_array(ctx, &obj->SecondaryColor, 4, GL_FLOAT);
+   init_array(ctx, &obj->FogCoord, 1, GL_FLOAT);
+   init_array(ctx, &obj->Index, 1, GL_FLOAT);
+   for (i = 0; i < Elements(obj->TexCoord); i++) {
+      init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT);
    }
-   obj->EdgeFlag.Stride = 0;
-   obj->EdgeFlag.StrideB = 0;
-   obj->EdgeFlag.Ptr = NULL;
-   obj->EdgeFlag.Enabled = GL_FALSE;
-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
-      obj->VertexAttrib[i].Size = 4;
-      obj->VertexAttrib[i].Type = GL_FLOAT;
-      obj->VertexAttrib[i].Stride = 0;
-      obj->VertexAttrib[i].StrideB = 0;
-      obj->VertexAttrib[i].Ptr = NULL;
-      obj->VertexAttrib[i].Enabled = GL_FALSE;
-      obj->VertexAttrib[i].Normalized = GL_FALSE;
+   init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL);
+   for (i = 0; i < Elements(obj->VertexAttrib); i++) {
+      init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT);
    }
 
 #if FEATURE_point_size_array
-   obj->PointSize.Type = GL_FLOAT;
-   obj->PointSize.Stride = 0;
-   obj->PointSize.StrideB = 0;
-   obj->PointSize.Ptr = NULL;
-   obj->PointSize.Enabled = GL_FALSE;
-   obj->PointSize.BufferObj = ctx->Array.NullBufferObj;
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object
-   /* Vertex array buffers */
-   obj->Vertex.BufferObj = ctx->Array.NullBufferObj;
-   obj->Normal.BufferObj = ctx->Array.NullBufferObj;
-   obj->Color.BufferObj = ctx->Array.NullBufferObj;
-   obj->SecondaryColor.BufferObj = ctx->Array.NullBufferObj;
-   obj->FogCoord.BufferObj = ctx->Array.NullBufferObj;
-   obj->Index.BufferObj = ctx->Array.NullBufferObj;
-   for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
-      obj->TexCoord[i].BufferObj = ctx->Array.NullBufferObj;
-   }
-   obj->EdgeFlag.BufferObj = ctx->Array.NullBufferObj;
-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
-      obj->VertexAttrib[i].BufferObj = ctx->Array.NullBufferObj;
-   }
+   init_array(ctx, &obj->PointSize, 1, GL_FLOAT);
 #endif
 }
 
@@ -195,12 +248,12 @@ _mesa_initialize_array_object( GLcontext *ctx,
 /**
  * Add the given array object to the array object pool.
  */
-void
-_mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj )
+static void
+save_array_object( GLcontext *ctx, struct gl_array_object *obj )
 {
    if (obj->Name > 0) {
       /* insert into hash table */
-      _mesa_HashInsert(ctx->Shared->ArrayObjects, obj->Name, obj);
+      _mesa_HashInsert(ctx->Array.Objects, obj->Name, obj);
    }
 }
 
@@ -209,22 +262,90 @@ _mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj )
  * Remove the given array object from the array object pool.
  * Do not deallocate the array object though.
  */
-void
-_mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj )
+static void
+remove_array_object( GLcontext *ctx, struct gl_array_object *obj )
 {
    if (obj->Name > 0) {
       /* remove from hash table */
-      _mesa_HashRemove(ctx->Shared->ArrayObjects, obj->Name);
+      _mesa_HashRemove(ctx->Array.Objects, obj->Name);
    }
 }
 
 
+
+/**
+ * Compute the index of the last array element that can be safely accessed
+ * in a vertex array.  We can really only do this when the array lives in
+ * a VBO.
+ * The array->_MaxElement field will be updated.
+ * Later in glDrawArrays/Elements/etc we can do some bounds checking.
+ */
 static void
-unbind_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
+compute_max_element(struct gl_client_array *array)
 {
-   if (bufObj != ctx->Array.NullBufferObj) {
-      _mesa_reference_buffer_object(ctx, &bufObj, NULL);
+   if (array->BufferObj->Name) {
+      /* Compute the max element we can access in the VBO without going
+       * out of bounds.
+       */
+      array->_MaxElement = ((GLsizeiptrARB) array->BufferObj->Size
+                            - (GLsizeiptrARB) array->Ptr + array->StrideB
+                            - array->_ElementSize) / array->StrideB;
+      if (0)
+         _mesa_printf("%s Object %u  Size %u  MaxElement %u\n",
+                      __FUNCTION__,
+                      array->BufferObj->Name,
+                      (GLuint) array->BufferObj->Size,
+                      array->_MaxElement);
    }
+   else {
+      /* user-space array, no idea how big it is */
+      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
+   }
+}
+
+
+/**
+ * Helper for update_arrays().
+ * \return  min(current min, array->_MaxElement).
+ */
+static GLuint
+update_min(GLuint min, struct gl_client_array *array)
+{
+   compute_max_element(array);
+   if (array->Enabled)
+      return MIN2(min, array->_MaxElement);
+   else
+      return min;
+}
+
+
+/**
+ * Examine vertex arrays to update the gl_array_object::_MaxElement field.
+ */
+void
+_mesa_update_array_object_max_element(GLcontext *ctx,
+                                      struct gl_array_object *arrayObj)
+{
+   GLuint i, min = ~0;
+
+   min = update_min(min, &arrayObj->Vertex);
+   min = update_min(min, &arrayObj->Weight);
+   min = update_min(min, &arrayObj->Normal);
+   min = update_min(min, &arrayObj->Color);
+   min = update_min(min, &arrayObj->SecondaryColor);
+   min = update_min(min, &arrayObj->FogCoord);
+   min = update_min(min, &arrayObj->Index);
+   min = update_min(min, &arrayObj->EdgeFlag);
+#if FEATURE_point_size_array
+   min = update_min(min, &arrayObj->PointSize);
+#endif
+   for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
+      min = update_min(min, &arrayObj->TexCoord[i]);
+   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
+      min = update_min(min, &arrayObj->VertexAttrib[i]);
+
+   /* _MaxElement is one past the last legal array element */
+   arrayObj->_MaxElement = min;
 }
 
 
@@ -232,18 +353,15 @@ unbind_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
 /* API Functions                                                      */
 /**********************************************************************/
 
+
 /**
- * Bind a new array.
- *
- * \todo
- * The binding could be done more efficiently by comparing the non-NULL
- * pointers in the old and new objects.  The only arrays that are "dirty" are
- * the ones that are non-NULL in either object.
+ * Helper for _mesa_BindVertexArray() and _mesa_BindVertexArrayAPPLE().
+ * \param genRequired  specifies behavour when id was not generated with
+ *                     glGenVertexArrays().
  */
-void GLAPIENTRY
-_mesa_BindVertexArrayAPPLE( GLuint id )
+static void
+bind_vertex_array(GLcontext *ctx, GLuint id, GLboolean genRequired)
 {
-   GET_CURRENT_CONTEXT(ctx);
    struct gl_array_object * const oldObj = ctx->Array.ArrayObj;
    struct gl_array_object *newObj = NULL;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
@@ -254,7 +372,7 @@ _mesa_BindVertexArrayAPPLE( GLuint id )
       return;   /* rebinding the same array object- no change */
 
    /*
-    * Get pointer to new array object (newBufObj)
+    * Get pointer to new array object (newObj)
     */
    if (id == 0) {
       /* The spec says there is no array object named 0, but we use
@@ -266,27 +384,58 @@ _mesa_BindVertexArrayAPPLE( GLuint id )
       /* non-default array object */
       newObj = lookup_arrayobj(ctx, id);
       if (!newObj) {
-         /* If this is a new array object id, allocate an array object now.
-	  */
+         if (genRequired) {
+            _mesa_error(ctx, GL_INVALID_OPERATION, "glBindVertexArray(id)");
+            return;
+         }
 
+         /* For APPLE version, generate a new array object now */
 	 newObj = (*ctx->Driver.NewArrayObject)(ctx, id);
          if (!newObj) {
             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindVertexArrayAPPLE");
             return;
          }
-         _mesa_save_array_object(ctx, newObj);
+         save_array_object(ctx, newObj);
       }
    }
 
-
    ctx->NewState |= _NEW_ARRAY;
    ctx->Array.NewState |= _NEW_ARRAY_ALL;
-   ctx->Array.ArrayObj = newObj;
-
+   _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, newObj);
 
    /* Pass BindVertexArray call to device driver */
    if (ctx->Driver.BindArrayObject && newObj)
-      (*ctx->Driver.BindArrayObject)( ctx, newObj );
+      ctx->Driver.BindArrayObject(ctx, newObj);
+}
+
+
+/**
+ * ARB version of glBindVertexArray()
+ * This function behaves differently from glBindVertexArrayAPPLE() in
+ * that this function requires all ids to have been previously generated
+ * by glGenVertexArrays[APPLE]().
+ */
+void GLAPIENTRY
+_mesa_BindVertexArray( GLuint id )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   bind_vertex_array(ctx, id, GL_TRUE);
+}
+
+
+/**
+ * Bind a new array.
+ *
+ * \todo
+ * The binding could be done more efficiently by comparing the non-NULL
+ * pointers in the old and new objects.  The only arrays that are "dirty" are
+ * the ones that are non-NULL in either object.
+ */
+void GLAPIENTRY
+_mesa_BindVertexArrayAPPLE( GLuint id )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   bind_vertex_array(ctx, id, GL_FALSE);
 }
 
 
@@ -308,15 +457,12 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids)
       return;
    }
 
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
    for (i = 0; i < n; i++) {
       struct gl_array_object *obj = lookup_arrayobj(ctx, ids[i]);
 
       if ( obj != NULL ) {
 	 ASSERT( obj->Name == ids[i] );
 
-
 	 /* If the array object is currently bound, the spec says "the binding
 	  * for that object reverts to zero and the default vertex array
 	  * becomes current."
@@ -325,45 +471,28 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids)
 	    CALL_BindVertexArrayAPPLE( ctx->Exec, (0) );
 	 }
 
-#if FEATURE_ARB_vertex_buffer_object
-	 /* Unbind any buffer objects that might be bound to arrays in
-	  * this array object.
-	  */
-	 unbind_buffer_object( ctx, obj->Vertex.BufferObj );
-	 unbind_buffer_object( ctx, obj->Normal.BufferObj );
-	 unbind_buffer_object( ctx, obj->Color.BufferObj );
-	 unbind_buffer_object( ctx, obj->SecondaryColor.BufferObj );
-	 unbind_buffer_object( ctx, obj->FogCoord.BufferObj );
-	 unbind_buffer_object( ctx, obj->Index.BufferObj );
-	 for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
-	    unbind_buffer_object( ctx, obj->TexCoord[i].BufferObj );
-	 }
-	 unbind_buffer_object( ctx, obj->EdgeFlag.BufferObj );
-	 for (i = 0; i < VERT_ATTRIB_MAX; i++) {
-	    unbind_buffer_object( ctx, obj->VertexAttrib[i].BufferObj );
-	 }
-#endif
-
 	 /* The ID is immediately freed for re-use */
-	 _mesa_remove_array_object(ctx, obj);
-	 ctx->Driver.DeleteArrayObject(ctx, obj);
+	 remove_array_object(ctx, obj);
+
+         /* Unreference the array object. 
+          * If refcount hits zero, the object will be deleted.
+          */
+         _mesa_reference_array_object(ctx, &obj, NULL);
       }
    }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 }
 
 
 /**
  * Generate a set of unique array object IDs and store them in \c arrays.
- * 
+ * Helper for _mesa_GenVertexArrays[APPLE]() functions below.
  * \param n       Number of IDs to generate.
  * \param arrays  Array of \c n locations to store the IDs.
+ * \param vboOnly Will arrays have to reside in VBOs?
  */
-void GLAPIENTRY
-_mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
+static void 
+gen_vertex_arrays(GLcontext *ctx, GLsizei n, GLuint *arrays, GLboolean vboOnly)
 {
-   GET_CURRENT_CONTEXT(ctx);
    GLuint first;
    GLint i;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
@@ -377,12 +506,7 @@ _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
       return;
    }
 
-   /*
-    * This must be atomic (generation and allocation of array object IDs)
-    */
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->ArrayObjects, n);
+   first = _mesa_HashFindFreeKeyBlock(ctx->Array.Objects, n);
 
    /* Allocate new, empty array objects and return identifiers */
    for (i = 0; i < n; i++) {
@@ -391,15 +515,37 @@ _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
 
       obj = (*ctx->Driver.NewArrayObject)( ctx, name );
       if (!obj) {
-         _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenVertexArraysAPPLE");
          return;
       }
-      _mesa_save_array_object(ctx, obj);
+      obj->VBOonly = vboOnly;
+      save_array_object(ctx, obj);
       arrays[i] = first + i;
    }
+}
+
+
+/**
+ * ARB version of glGenVertexArrays()
+ * All arrays will be required to live in VBOs.
+ */
+void GLAPIENTRY
+_mesa_GenVertexArrays(GLsizei n, GLuint *arrays)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   gen_vertex_arrays(ctx, n, arrays, GL_TRUE);
+}
+
 
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+/**
+ * APPLE version of glGenVertexArraysAPPLE()
+ * Arrays may live in VBOs or ordinary memory.
+ */
+void GLAPIENTRY
+_mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   gen_vertex_arrays(ctx, n, arrays, GL_FALSE);
 }
 
 
@@ -420,9 +566,7 @@ _mesa_IsVertexArrayAPPLE( GLuint id )
    if (id == 0)
       return GL_FALSE;
 
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
    obj = lookup_arrayobj(ctx, id);
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 
    return (obj != NULL) ? GL_TRUE : GL_FALSE;
 }
diff --git a/src/mesa/main/arrayobj.h b/src/mesa/main/arrayobj.h
index c7d66ec166..8999edc724 100644
--- a/src/mesa/main/arrayobj.h
+++ b/src/mesa/main/arrayobj.h
@@ -1,9 +1,10 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5
+ * Version:  7.6
  *
  * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
  * (C) Copyright IBM Corporation 2006
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -41,28 +42,40 @@
  * Internal functions
  */
 
-struct gl_array_object * _mesa_new_array_object( GLcontext *ctx,
-    GLuint name );
+extern struct gl_array_object *
+_mesa_new_array_object( GLcontext *ctx, GLuint name );
 
-void _mesa_delete_array_object( GLcontext *ctx, struct gl_array_object *obj );
+extern void
+_mesa_delete_array_object( GLcontext *ctx, struct gl_array_object *obj );
 
-void _mesa_initialize_array_object( GLcontext *ctx,
-    struct gl_array_object *obj, GLuint name );
+extern void
+_mesa_reference_array_object(GLcontext *ctx,
+                             struct gl_array_object **ptr,
+                             struct gl_array_object *arrayObj);
 
-void _mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj );
+extern void
+_mesa_initialize_array_object( GLcontext *ctx,
+                               struct gl_array_object *obj, GLuint name );
 
-void _mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj );
 
+extern void
+_mesa_update_array_object_max_element(GLcontext *ctx,
+                                      struct gl_array_object *arrayObj);
 
 
 /*
  * API functions
  */
 
+
+void GLAPIENTRY _mesa_BindVertexArray( GLuint id );
+
 void GLAPIENTRY _mesa_BindVertexArrayAPPLE( GLuint id );
 
 void GLAPIENTRY _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids);
 
+void GLAPIENTRY _mesa_GenVertexArrays(GLsizei n, GLuint *arrays);
+
 void GLAPIENTRY _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *buffer);
 
 GLboolean GLAPIENTRY _mesa_IsVertexArrayAPPLE( GLuint id );
diff --git a/src/mesa/main/attrib.c b/src/mesa/main/attrib.c
index 825c841ee2..246c5521b7 100644
--- a/src/mesa/main/attrib.c
+++ b/src/mesa/main/attrib.c
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  * Copyright (C) 2009  VMware, Inc.   All Rights Reserved.
@@ -55,8 +55,107 @@
 #include "texparam.h"
 #include "texstate.h"
 #include "varray.h"
+#include "viewport.h"
 #include "mtypes.h"
-#include "math/m_xform.h"
+#include "glapi/dispatch.h"
+
+
+/**
+ * glEnable()/glDisable() attribute group (GL_ENABLE_BIT).
+ */
+struct gl_enable_attrib
+{
+   GLboolean AlphaTest;
+   GLboolean AutoNormal;
+   GLboolean Blend;
+   GLbitfield ClipPlanes;
+   GLboolean ColorMaterial;
+   GLboolean ColorTable[COLORTABLE_MAX];
+   GLboolean Convolution1D;
+   GLboolean Convolution2D;
+   GLboolean Separable2D;
+   GLboolean CullFace;
+   GLboolean DepthClamp;
+   GLboolean DepthTest;
+   GLboolean Dither;
+   GLboolean Fog;
+   GLboolean Histogram;
+   GLboolean Light[MAX_LIGHTS];
+   GLboolean Lighting;
+   GLboolean LineSmooth;
+   GLboolean LineStipple;
+   GLboolean IndexLogicOp;
+   GLboolean ColorLogicOp;
+
+   GLboolean Map1Color4;
+   GLboolean Map1Index;
+   GLboolean Map1Normal;
+   GLboolean Map1TextureCoord1;
+   GLboolean Map1TextureCoord2;
+   GLboolean Map1TextureCoord3;
+   GLboolean Map1TextureCoord4;
+   GLboolean Map1Vertex3;
+   GLboolean Map1Vertex4;
+   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
+   GLboolean Map2Color4;
+   GLboolean Map2Index;
+   GLboolean Map2Normal;
+   GLboolean Map2TextureCoord1;
+   GLboolean Map2TextureCoord2;
+   GLboolean Map2TextureCoord3;
+   GLboolean Map2TextureCoord4;
+   GLboolean Map2Vertex3;
+   GLboolean Map2Vertex4;
+   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
+
+   GLboolean MinMax;
+   GLboolean Normalize;
+   GLboolean PixelTexture;
+   GLboolean PointSmooth;
+   GLboolean PolygonOffsetPoint;
+   GLboolean PolygonOffsetLine;
+   GLboolean PolygonOffsetFill;
+   GLboolean PolygonSmooth;
+   GLboolean PolygonStipple;
+   GLboolean RescaleNormals;
+   GLboolean Scissor;
+   GLboolean Stencil;
+   GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */
+   GLboolean MultisampleEnabled;      /* GL_ARB_multisample */
+   GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */
+   GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */
+   GLboolean SampleCoverage;          /* GL_ARB_multisample */
+   GLboolean SampleCoverageInvert;    /* GL_ARB_multisample */
+   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
+
+   GLbitfield Texture[MAX_TEXTURE_UNITS];
+   GLbitfield TexGen[MAX_TEXTURE_UNITS];
+
+   /* SGI_texture_color_table */
+   GLboolean TextureColorTable[MAX_TEXTURE_UNITS];
+
+   /* GL_ARB_vertex_program / GL_NV_vertex_program */
+   GLboolean VertexProgram;
+   GLboolean VertexProgramPointSize;
+   GLboolean VertexProgramTwoSide;
+
+   /* GL_ARB_point_sprite / GL_NV_point_sprite */
+   GLboolean PointSprite;
+   GLboolean FragmentShaderATI;
+};
+
+
+/**
+ * Node for the attribute stack.
+ */
+struct gl_attrib_node
+{
+   GLbitfield kind;
+   void *data;
+   struct gl_attrib_node *next;
+};
+
+
 
 /**
  * Special struct for saving/restoring texture state (GL_TEXTURE_BIT)
@@ -76,25 +175,34 @@ struct texture_state
 };
 
 
+#if FEATURE_attrib_stack
+
+
 /**
- * Allocate a new attribute state node.  These nodes have a
- * "kind" value and a pointer to a struct of state data.
+ * Allocate new attribute node of given type/kind.  Attach payload data.
+ * Insert it into the linked list named by 'head'.
  */
-static struct gl_attrib_node *
-new_attrib_node( GLbitfield kind )
+static void
+save_attrib_data(struct gl_attrib_node **head,
+                 GLbitfield kind, void *payload)
 {
-   struct gl_attrib_node *an = MALLOC_STRUCT(gl_attrib_node);
-   if (an) {
-      an->kind = kind;
+   struct gl_attrib_node *n = MALLOC_STRUCT(gl_attrib_node);
+   if (n) {
+      n->kind = kind;
+      n->data = payload;
+      /* insert at head */
+      n->next = *head;
+      *head = n;
+   }
+   else {
+      /* out of memory! */
    }
-   return an;
 }
 
 
 void GLAPIENTRY
 _mesa_PushAttrib(GLbitfield mask)
 {
-   struct gl_attrib_node *newnode;
    struct gl_attrib_node *head;
 
    GET_CURRENT_CONTEXT(ctx);
@@ -116,10 +224,7 @@ _mesa_PushAttrib(GLbitfield mask)
       struct gl_accum_attrib *attr;
       attr = MALLOC_STRUCT( gl_accum_attrib );
       MEMCPY( attr, &ctx->Accum, sizeof(struct gl_accum_attrib) );
-      newnode = new_attrib_node( GL_ACCUM_BUFFER_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_ACCUM_BUFFER_BIT, attr);
    }
 
    if (mask & GL_COLOR_BUFFER_BIT) {
@@ -130,10 +235,7 @@ _mesa_PushAttrib(GLbitfield mask)
       /* push the Draw FBO's DrawBuffer[] state, not ctx->Color.DrawBuffer[] */
       for (i = 0; i < ctx->Const.MaxDrawBuffers; i ++)
          attr->DrawBuffer[i] = ctx->DrawBuffer->ColorDrawBuffer[i];
-      newnode = new_attrib_node( GL_COLOR_BUFFER_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_COLOR_BUFFER_BIT, attr);
    }
 
    if (mask & GL_CURRENT_BIT) {
@@ -141,20 +243,14 @@ _mesa_PushAttrib(GLbitfield mask)
       FLUSH_CURRENT( ctx, 0 );
       attr = MALLOC_STRUCT( gl_current_attrib );
       MEMCPY( attr, &ctx->Current, sizeof(struct gl_current_attrib) );
-      newnode = new_attrib_node( GL_CURRENT_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_CURRENT_BIT, attr);
    }
 
    if (mask & GL_DEPTH_BUFFER_BIT) {
       struct gl_depthbuffer_attrib *attr;
       attr = MALLOC_STRUCT( gl_depthbuffer_attrib );
       MEMCPY( attr, &ctx->Depth, sizeof(struct gl_depthbuffer_attrib) );
-      newnode = new_attrib_node( GL_DEPTH_BUFFER_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_DEPTH_BUFFER_BIT, attr);
    }
 
    if (mask & GL_ENABLE_BIT) {
@@ -174,6 +270,7 @@ _mesa_PushAttrib(GLbitfield mask)
       attr->Convolution2D = ctx->Pixel.Convolution2DEnabled;
       attr->Separable2D = ctx->Pixel.Separable2DEnabled;
       attr->CullFace = ctx->Polygon.CullFlag;
+      attr->DepthClamp = ctx->Transform.DepthClamp;
       attr->DepthTest = ctx->Depth.Test;
       attr->Dither = ctx->Color.DitherFlag;
       attr->Fog = ctx->Fog.Enabled;
@@ -234,40 +331,28 @@ _mesa_PushAttrib(GLbitfield mask)
       attr->VertexProgram = ctx->VertexProgram.Enabled;
       attr->VertexProgramPointSize = ctx->VertexProgram.PointSizeEnabled;
       attr->VertexProgramTwoSide = ctx->VertexProgram.TwoSideEnabled;
-      newnode = new_attrib_node( GL_ENABLE_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_ENABLE_BIT, attr);
    }
 
    if (mask & GL_EVAL_BIT) {
       struct gl_eval_attrib *attr;
       attr = MALLOC_STRUCT( gl_eval_attrib );
       MEMCPY( attr, &ctx->Eval, sizeof(struct gl_eval_attrib) );
-      newnode = new_attrib_node( GL_EVAL_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_EVAL_BIT, attr);
    }
 
    if (mask & GL_FOG_BIT) {
       struct gl_fog_attrib *attr;
       attr = MALLOC_STRUCT( gl_fog_attrib );
       MEMCPY( attr, &ctx->Fog, sizeof(struct gl_fog_attrib) );
-      newnode = new_attrib_node( GL_FOG_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_FOG_BIT, attr);
    }
 
    if (mask & GL_HINT_BIT) {
       struct gl_hint_attrib *attr;
       attr = MALLOC_STRUCT( gl_hint_attrib );
       MEMCPY( attr, &ctx->Hint, sizeof(struct gl_hint_attrib) );
-      newnode = new_attrib_node( GL_HINT_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_HINT_BIT, attr);
    }
 
    if (mask & GL_LIGHTING_BIT) {
@@ -275,30 +360,21 @@ _mesa_PushAttrib(GLbitfield mask)
       FLUSH_CURRENT(ctx, 0);	/* flush material changes */
       attr = MALLOC_STRUCT( gl_light_attrib );
       MEMCPY( attr, &ctx->Light, sizeof(struct gl_light_attrib) );
-      newnode = new_attrib_node( GL_LIGHTING_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_LIGHTING_BIT, attr);
    }
 
    if (mask & GL_LINE_BIT) {
       struct gl_line_attrib *attr;
       attr = MALLOC_STRUCT( gl_line_attrib );
       MEMCPY( attr, &ctx->Line, sizeof(struct gl_line_attrib) );
-      newnode = new_attrib_node( GL_LINE_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_LINE_BIT, attr);
    }
 
    if (mask & GL_LIST_BIT) {
       struct gl_list_attrib *attr;
       attr = MALLOC_STRUCT( gl_list_attrib );
       MEMCPY( attr, &ctx->List, sizeof(struct gl_list_attrib) );
-      newnode = new_attrib_node( GL_LIST_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_LIST_BIT, attr);
    }
 
    if (mask & GL_PIXEL_MODE_BIT) {
@@ -307,65 +383,47 @@ _mesa_PushAttrib(GLbitfield mask)
       MEMCPY( attr, &ctx->Pixel, sizeof(struct gl_pixel_attrib) );
       /* push the Read FBO's ReadBuffer state, not ctx->Pixel.ReadBuffer */
       attr->ReadBuffer = ctx->ReadBuffer->ColorReadBuffer;
-      newnode = new_attrib_node( GL_PIXEL_MODE_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_PIXEL_MODE_BIT, attr);
    }
 
    if (mask & GL_POINT_BIT) {
       struct gl_point_attrib *attr;
       attr = MALLOC_STRUCT( gl_point_attrib );
       MEMCPY( attr, &ctx->Point, sizeof(struct gl_point_attrib) );
-      newnode = new_attrib_node( GL_POINT_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_POINT_BIT, attr);
    }
 
    if (mask & GL_POLYGON_BIT) {
       struct gl_polygon_attrib *attr;
       attr = MALLOC_STRUCT( gl_polygon_attrib );
       MEMCPY( attr, &ctx->Polygon, sizeof(struct gl_polygon_attrib) );
-      newnode = new_attrib_node( GL_POLYGON_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_POLYGON_BIT, attr);
    }
 
    if (mask & GL_POLYGON_STIPPLE_BIT) {
       GLuint *stipple;
       stipple = (GLuint *) MALLOC( 32*sizeof(GLuint) );
       MEMCPY( stipple, ctx->PolygonStipple, 32*sizeof(GLuint) );
-      newnode = new_attrib_node( GL_POLYGON_STIPPLE_BIT );
-      newnode->data = stipple;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_POLYGON_STIPPLE_BIT, stipple);
    }
 
    if (mask & GL_SCISSOR_BIT) {
       struct gl_scissor_attrib *attr;
       attr = MALLOC_STRUCT( gl_scissor_attrib );
       MEMCPY( attr, &ctx->Scissor, sizeof(struct gl_scissor_attrib) );
-      newnode = new_attrib_node( GL_SCISSOR_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_SCISSOR_BIT, attr);
    }
 
    if (mask & GL_STENCIL_BUFFER_BIT) {
       struct gl_stencil_attrib *attr;
       attr = MALLOC_STRUCT( gl_stencil_attrib );
       MEMCPY( attr, &ctx->Stencil, sizeof(struct gl_stencil_attrib) );
-      newnode = new_attrib_node( GL_STENCIL_BUFFER_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_STENCIL_BUFFER_BIT, attr);
    }
 
    if (mask & GL_TEXTURE_BIT) {
       struct texture_state *texstate = CALLOC_STRUCT(texture_state);
-      GLuint u;
+      GLuint u, tex;
 
       if (!texstate) {
          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glPushAttrib(GL_TEXTURE_BIT)");
@@ -381,66 +439,37 @@ _mesa_PushAttrib(GLbitfield mask)
        * accidentally get deleted while referenced in the attribute stack.
        */
       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_1D_INDEX],
-                                ctx->Texture.Unit[u].Current1D);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_2D_INDEX],
-                                ctx->Texture.Unit[u].Current2D);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_3D_INDEX],
-                                ctx->Texture.Unit[u].Current3D);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_CUBE_INDEX],
-                                ctx->Texture.Unit[u].CurrentCubeMap);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_RECT_INDEX],
-                                ctx->Texture.Unit[u].CurrentRect);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_1D_ARRAY_INDEX],
-                                ctx->Texture.Unit[u].Current1DArray);
-         _mesa_reference_texobj(&texstate->SavedTexRef[u][TEXTURE_2D_ARRAY_INDEX],
-                                ctx->Texture.Unit[u].Current2DArray);
+         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+            _mesa_reference_texobj(&texstate->SavedTexRef[u][tex],
+                                   ctx->Texture.Unit[u].CurrentTex[tex]);
+         }
       }
 
       /* copy state/contents of the currently bound texture objects */
       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_1D_INDEX],
-                                   ctx->Texture.Unit[u].Current1D);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_2D_INDEX],
-                                   ctx->Texture.Unit[u].Current2D);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_3D_INDEX],
-                                   ctx->Texture.Unit[u].Current3D);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_CUBE_INDEX],
-                                   ctx->Texture.Unit[u].CurrentCubeMap);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_RECT_INDEX],
-                                   ctx->Texture.Unit[u].CurrentRect);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_1D_ARRAY_INDEX],
-                                   ctx->Texture.Unit[u].Current1DArray);
-         _mesa_copy_texture_object(&texstate->SavedObj[u][TEXTURE_2D_ARRAY_INDEX],
-                                   ctx->Texture.Unit[u].Current2DArray);
+         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+            _mesa_copy_texture_object(&texstate->SavedObj[u][tex],
+                                      ctx->Texture.Unit[u].CurrentTex[tex]);
+         }
       }
 
       _mesa_unlock_context_textures(ctx);
 
-      newnode = new_attrib_node( GL_TEXTURE_BIT );
-      newnode->data = texstate;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_TEXTURE_BIT, texstate);
    }
 
    if (mask & GL_TRANSFORM_BIT) {
       struct gl_transform_attrib *attr;
       attr = MALLOC_STRUCT( gl_transform_attrib );
       MEMCPY( attr, &ctx->Transform, sizeof(struct gl_transform_attrib) );
-      newnode = new_attrib_node( GL_TRANSFORM_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_TRANSFORM_BIT, attr);
    }
 
    if (mask & GL_VIEWPORT_BIT) {
       struct gl_viewport_attrib *attr;
       attr = MALLOC_STRUCT( gl_viewport_attrib );
       MEMCPY( attr, &ctx->Viewport, sizeof(struct gl_viewport_attrib) );
-      newnode = new_attrib_node( GL_VIEWPORT_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_VIEWPORT_BIT, attr);
    }
 
    /* GL_ARB_multisample */
@@ -448,10 +477,7 @@ _mesa_PushAttrib(GLbitfield mask)
       struct gl_multisample_attrib *attr;
       attr = MALLOC_STRUCT( gl_multisample_attrib );
       MEMCPY( attr, &ctx->Multisample, sizeof(struct gl_multisample_attrib) );
-      newnode = new_attrib_node( GL_MULTISAMPLE_BIT_ARB );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_MULTISAMPLE_BIT_ARB, attr);
    }
 
 end:
@@ -464,6 +490,7 @@ end:
 static void
 pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable)
 {
+   const GLuint curTexUnitSave = ctx->Texture.CurrentUnit;
    GLuint i;
 
 #define TEST_AND_UPDATE(VALUE, NEWVALUE, ENUM)		\
@@ -493,6 +520,8 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable)
                    enable->ColorTable[COLORTABLE_POSTCOLORMATRIX],
                    GL_POST_COLOR_MATRIX_COLOR_TABLE);
    TEST_AND_UPDATE(ctx->Polygon.CullFlag, enable->CullFace, GL_CULL_FACE);
+   TEST_AND_UPDATE(ctx->Transform.DepthClamp, enable->DepthClamp,
+		   GL_DEPTH_CLAMP);
    TEST_AND_UPDATE(ctx->Depth.Test, enable->DepthTest, GL_DEPTH_TEST);
    TEST_AND_UPDATE(ctx->Color.DitherFlag, enable->Dither, GL_DITHER);
    TEST_AND_UPDATE(ctx->Pixel.Convolution1DEnabled, enable->Convolution1D,
@@ -608,59 +637,51 @@ pop_enable_group(GLcontext *ctx, const struct gl_enable_attrib *enable)
 
    /* texture unit enables */
    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
-      if (ctx->Texture.Unit[i].Enabled != enable->Texture[i]) {
-         ctx->Texture.Unit[i].Enabled = enable->Texture[i];
-         if (ctx->Driver.Enable) {
-            if (ctx->Driver.ActiveTexture) {
-               (*ctx->Driver.ActiveTexture)(ctx, i);
-            }
-            (*ctx->Driver.Enable)( ctx, GL_TEXTURE_1D,
-                             (GLboolean) (enable->Texture[i] & TEXTURE_1D_BIT) );
-            (*ctx->Driver.Enable)( ctx, GL_TEXTURE_2D,
-                             (GLboolean) (enable->Texture[i] & TEXTURE_2D_BIT) );
-            (*ctx->Driver.Enable)( ctx, GL_TEXTURE_3D,
-                             (GLboolean) (enable->Texture[i] & TEXTURE_3D_BIT) );
-            if (ctx->Extensions.ARB_texture_cube_map)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_CUBE_MAP_ARB,
-                          (GLboolean) (enable->Texture[i] & TEXTURE_CUBE_BIT) );
-            if (ctx->Extensions.NV_texture_rectangle)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_RECTANGLE_NV,
-                          (GLboolean) (enable->Texture[i] & TEXTURE_RECT_BIT) );
+      const GLbitfield enabled = enable->Texture[i];
+      const GLbitfield genEnabled = enable->TexGen[i];
+
+      if (ctx->Texture.Unit[i].Enabled != enabled) {
+         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);
+
+         _mesa_set_enable(ctx, GL_TEXTURE_1D,
+                          (enabled & TEXTURE_1D_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_2D,
+                          (enabled & TEXTURE_2D_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_3D,
+                          (enabled & TEXTURE_3D_BIT) ? GL_TRUE : GL_FALSE);
+         if (ctx->Extensions.NV_texture_rectangle) {
+            _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_ARB,
+                             (enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);
+         }
+         if (ctx->Extensions.ARB_texture_cube_map) {
+            _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP,
+                             (enabled & TEXTURE_CUBE_BIT) ? GL_TRUE : GL_FALSE);
+         }
+         if (ctx->Extensions.MESA_texture_array) {
+            _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,
+                           (enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
+            _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,
+                           (enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
          }
       }
 
-      if (ctx->Texture.Unit[i].TexGenEnabled != enable->TexGen[i]) {
-         ctx->Texture.Unit[i].TexGenEnabled = enable->TexGen[i];
-         if (ctx->Driver.Enable) {
-            if (ctx->Driver.ActiveTexture) {
-               (*ctx->Driver.ActiveTexture)(ctx, i);
-            }
-            if (enable->TexGen[i] & S_BIT)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_S, GL_TRUE);
-            else
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_S, GL_FALSE);
-            if (enable->TexGen[i] & T_BIT)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_T, GL_TRUE);
-            else
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_T, GL_FALSE);
-            if (enable->TexGen[i] & R_BIT)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_R, GL_TRUE);
-            else
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_R, GL_FALSE);
-            if (enable->TexGen[i] & Q_BIT)
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_Q, GL_TRUE);
-            else
-               (*ctx->Driver.Enable)( ctx, GL_TEXTURE_GEN_Q, GL_FALSE);
-         }
+      if (ctx->Texture.Unit[i].TexGenEnabled != genEnabled) {
+         _mesa_ActiveTextureARB(GL_TEXTURE0 + i);
+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,
+                          (genEnabled & S_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_T,
+                          (genEnabled & T_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_R,
+                          (genEnabled & R_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q,
+                          (genEnabled & Q_BIT) ? GL_TRUE : GL_FALSE);
       }
 
       /* GL_SGI_texture_color_table */
       ctx->Texture.Unit[i].ColorTableEnabled = enable->TextureColorTable[i];
    }
 
-   if (ctx->Driver.ActiveTexture) {
-      (*ctx->Driver.ActiveTexture)(ctx, ctx->Texture.CurrentUnit);
-   }
+   _mesa_ActiveTextureARB(GL_TEXTURE0 + curTexUnitSave);
 }
 
 
@@ -693,32 +714,39 @@ pop_texture_group(GLcontext *ctx, struct texture_state *texstate)
          _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE_NV,
                      (unit->Enabled & TEXTURE_RECT_BIT) ? GL_TRUE : GL_FALSE);
       }
+      if (ctx->Extensions.MESA_texture_array) {
+         _mesa_set_enable(ctx, GL_TEXTURE_1D_ARRAY_EXT,
+                 (unit->Enabled & TEXTURE_1D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
+         _mesa_set_enable(ctx, GL_TEXTURE_2D_ARRAY_EXT,
+                 (unit->Enabled & TEXTURE_2D_ARRAY_BIT) ? GL_TRUE : GL_FALSE);
+      }
+
       if (ctx->Extensions.SGI_texture_color_table) {
          _mesa_set_enable(ctx, GL_TEXTURE_COLOR_TABLE_SGI,
                           unit->ColorTableEnabled);
       }
       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, unit->EnvMode);
       _mesa_TexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, unit->EnvColor);
-      _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenModeS);
-      _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenModeT);
-      _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenModeR);
-      _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenModeQ);
-      _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->ObjectPlaneS);
-      _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->ObjectPlaneT);
-      _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->ObjectPlaneR);
-      _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->ObjectPlaneQ);
+      _mesa_TexGeni(GL_S, GL_TEXTURE_GEN_MODE, unit->GenS.Mode);
+      _mesa_TexGeni(GL_T, GL_TEXTURE_GEN_MODE, unit->GenT.Mode);
+      _mesa_TexGeni(GL_R, GL_TEXTURE_GEN_MODE, unit->GenR.Mode);
+      _mesa_TexGeni(GL_Q, GL_TEXTURE_GEN_MODE, unit->GenQ.Mode);
+      _mesa_TexGenfv(GL_S, GL_OBJECT_PLANE, unit->GenS.ObjectPlane);
+      _mesa_TexGenfv(GL_T, GL_OBJECT_PLANE, unit->GenT.ObjectPlane);
+      _mesa_TexGenfv(GL_R, GL_OBJECT_PLANE, unit->GenR.ObjectPlane);
+      _mesa_TexGenfv(GL_Q, GL_OBJECT_PLANE, unit->GenQ.ObjectPlane);
       /* Eye plane done differently to avoid re-transformation */
       {
          struct gl_texture_unit *destUnit = &ctx->Texture.Unit[u];
-         COPY_4FV(destUnit->EyePlaneS, unit->EyePlaneS);
-         COPY_4FV(destUnit->EyePlaneT, unit->EyePlaneT);
-         COPY_4FV(destUnit->EyePlaneR, unit->EyePlaneR);
-         COPY_4FV(destUnit->EyePlaneQ, unit->EyePlaneQ);
+         COPY_4FV(destUnit->GenS.EyePlane, unit->GenS.EyePlane);
+         COPY_4FV(destUnit->GenT.EyePlane, unit->GenT.EyePlane);
+         COPY_4FV(destUnit->GenR.EyePlane, unit->GenR.EyePlane);
+         COPY_4FV(destUnit->GenQ.EyePlane, unit->GenQ.EyePlane);
          if (ctx->Driver.TexGen) {
-            ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->EyePlaneS);
-            ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->EyePlaneT);
-            ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->EyePlaneR);
-            ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->EyePlaneQ);
+            ctx->Driver.TexGen(ctx, GL_S, GL_EYE_PLANE, unit->GenS.EyePlane);
+            ctx->Driver.TexGen(ctx, GL_T, GL_EYE_PLANE, unit->GenT.EyePlane);
+            ctx->Driver.TexGen(ctx, GL_R, GL_EYE_PLANE, unit->GenR.EyePlane);
+            ctx->Driver.TexGen(ctx, GL_Q, GL_EYE_PLANE, unit->GenQ.EyePlane);
          }
       }
       _mesa_set_enable(ctx, GL_TEXTURE_GEN_S,
@@ -772,7 +800,6 @@ pop_texture_group(GLcontext *ctx, struct texture_state *texstate)
       /* Restore texture object state for each target */
       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
          const struct gl_texture_object *obj = NULL;
-         GLfloat bordColor[4];
          GLenum target;
 
          obj = &texstate->SavedObj[u][tgt];
@@ -798,12 +825,7 @@ pop_texture_group(GLcontext *ctx, struct texture_state *texstate)
 
          _mesa_BindTexture(target, obj->Name);
 
-         bordColor[0] = CHAN_TO_FLOAT(obj->BorderColor[0]);
-         bordColor[1] = CHAN_TO_FLOAT(obj->BorderColor[1]);
-         bordColor[2] = CHAN_TO_FLOAT(obj->BorderColor[2]);
-         bordColor[3] = CHAN_TO_FLOAT(obj->BorderColor[3]);
-
-         _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, bordColor);
+         _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, obj->BorderColor);
          _mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);
          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS);
          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT);
@@ -820,15 +842,9 @@ pop_texture_group(GLcontext *ctx, struct texture_state *texstate)
             _mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                                 obj->MaxAnisotropy);
          }
-         if (ctx->Extensions.SGIX_shadow) {
-            _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_SGIX,
-                                obj->CompareFlag);
-            _mesa_TexParameteri(target, GL_TEXTURE_COMPARE_OPERATOR_SGIX,
-                                obj->CompareOperator);
-         }
-         if (ctx->Extensions.SGIX_shadow_ambient) {
-            _mesa_TexParameterf(target, GL_SHADOW_AMBIENT_SGIX,
-                                obj->ShadowAmbient);
+         if (ctx->Extensions.ARB_shadow_ambient) {
+            _mesa_TexParameterf(target, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB,
+                                obj->CompareFailValue);
          }
       }
 
@@ -909,14 +925,13 @@ _mesa_PopAttrib(void)
                    * function, but legal for the later.
                    */
                   GLboolean multipleBuffers = GL_FALSE;
-                  if (ctx->Extensions.ARB_draw_buffers) {
-                     GLuint i;
-                     for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
-                        if (color->DrawBuffer[i] != GL_NONE) {
-                           multipleBuffers = GL_TRUE;
-                           break;
-                        }
-                     }
+		  GLuint i;
+
+		  for (i = 1; i < ctx->Const.MaxDrawBuffers; i++) {
+		     if (color->DrawBuffer[i] != GL_NONE) {
+			multipleBuffers = GL_TRUE;
+			break;
+		     }
                   }
                   /* Call the API_level functions, not _mesa_drawbuffers()
                    * since we need to do error checking on the pop'd
@@ -1012,9 +1027,8 @@ _mesa_PopAttrib(void)
                _mesa_Hint(GL_FOG_HINT, hint->Fog);
                _mesa_Hint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT,
                           hint->ClipVolumeClipping);
-               if (ctx->Extensions.ARB_texture_compression)
-                  _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
-                             hint->TextureCompression);
+	       _mesa_Hint(GL_TEXTURE_COMPRESSION_HINT_ARB,
+			  hint->TextureCompression);
             }
             break;
          case GL_LIGHTING_BIT:
@@ -1035,7 +1049,7 @@ _mesa_PopAttrib(void)
 		  _mesa_light(ctx, i, GL_DIFFUSE, l->Diffuse);
 		  _mesa_light(ctx, i, GL_SPECULAR, l->Specular );
 		  _mesa_light(ctx, i, GL_POSITION, l->EyePosition);
-		  _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->EyeDirection);
+		  _mesa_light(ctx, i, GL_SPOT_DIRECTION, l->SpotDirection);
 		  _mesa_light(ctx, i, GL_SPOT_EXPONENT, &l->SpotExponent);
 		  _mesa_light(ctx, i, GL_SPOT_CUTOFF, &l->SpotCutoff);
 		  _mesa_light(ctx, i, GL_CONSTANT_ATTENUATION,
@@ -1196,7 +1210,7 @@ _mesa_PopAttrib(void)
 
                /* restore clip planes */
                for (i = 0; i < MAX_CLIP_PLANES; i++) {
-                  const GLuint mask = 1 << 1;
+                  const GLuint mask = 1 << i;
                   const GLfloat *eyePlane = xform->EyeUserPlane[i];
                   COPY_4V(ctx->Transform.EyeUserPlane[i], eyePlane);
                   if (xform->ClipPlanesEnabled & mask) {
@@ -1215,6 +1229,9 @@ _mesa_PopAttrib(void)
                if (xform->RescaleNormals != ctx->Transform.RescaleNormals)
                   _mesa_set_enable(ctx, GL_RESCALE_NORMAL_EXT,
                                    ctx->Transform.RescaleNormals);
+               if (xform->DepthClamp != ctx->Transform.DepthClamp)
+                  _mesa_set_enable(ctx, GL_DEPTH_CLAMP,
+                                   ctx->Transform.DepthClamp);
             }
             break;
          case GL_TEXTURE_BIT:
@@ -1261,23 +1278,22 @@ _mesa_PopAttrib(void)
  * counts when pushing/popping the GL_CLIENT_VERTEX_ARRAY_BIT attribute group.
  */
 static void
-adjust_buffer_object_ref_counts(struct gl_array_attrib *array, GLint step)
+adjust_buffer_object_ref_counts(struct gl_array_object *arrayObj, GLint step)
 {
    GLuint i;
-   array->ArrayObj->Vertex.BufferObj->RefCount += step;
-   array->ArrayObj->Normal.BufferObj->RefCount += step;
-   array->ArrayObj->Color.BufferObj->RefCount += step;
-   array->ArrayObj->SecondaryColor.BufferObj->RefCount += step;
-   array->ArrayObj->FogCoord.BufferObj->RefCount += step;
-   array->ArrayObj->Index.BufferObj->RefCount += step;
-   array->ArrayObj->EdgeFlag.BufferObj->RefCount += step;
-   for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++)
-      array->ArrayObj->TexCoord[i].BufferObj->RefCount += step;
-   for (i = 0; i < VERT_ATTRIB_MAX; i++)
-      array->ArrayObj->VertexAttrib[i].BufferObj->RefCount += step;
-
-   array->ArrayBufferObj->RefCount += step;
-   array->ElementArrayBufferObj->RefCount += step;
+
+   arrayObj->Vertex.BufferObj->RefCount += step;
+   arrayObj->Weight.BufferObj->RefCount += step;
+   arrayObj->Normal.BufferObj->RefCount += step;
+   arrayObj->Color.BufferObj->RefCount += step;
+   arrayObj->SecondaryColor.BufferObj->RefCount += step;
+   arrayObj->FogCoord.BufferObj->RefCount += step;
+   arrayObj->Index.BufferObj->RefCount += step;
+   arrayObj->EdgeFlag.BufferObj->RefCount += step;
+   for (i = 0; i < Elements(arrayObj->TexCoord); i++)
+      arrayObj->TexCoord[i].BufferObj->RefCount += step;
+   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
+      arrayObj->VertexAttrib[i].BufferObj->RefCount += step;
 }
 
 
@@ -1311,7 +1327,6 @@ copy_pixelstore(GLcontext *ctx,
 void GLAPIENTRY
 _mesa_PushClientAttrib(GLbitfield mask)
 {
-   struct gl_attrib_node *newnode;
    struct gl_attrib_node *head;
 
    GET_CURRENT_CONTEXT(ctx);
@@ -1332,17 +1347,11 @@ _mesa_PushClientAttrib(GLbitfield mask)
       /* packing attribs */
       attr = CALLOC_STRUCT( gl_pixelstore_attrib );
       copy_pixelstore(ctx, attr, &ctx->Pack);
-      newnode = new_attrib_node( GL_CLIENT_PACK_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_CLIENT_PACK_BIT, attr);
       /* unpacking attribs */
       attr = CALLOC_STRUCT( gl_pixelstore_attrib );
       copy_pixelstore(ctx, attr, &ctx->Unpack);
-      newnode = new_attrib_node( GL_CLIENT_UNPACK_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_CLIENT_UNPACK_BIT, attr);
    }
 
    if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
@@ -1363,12 +1372,10 @@ _mesa_PushClientAttrib(GLbitfield mask)
 
       attr->ArrayObj = obj;
 
-      newnode = new_attrib_node( GL_CLIENT_VERTEX_ARRAY_BIT );
-      newnode->data = attr;
-      newnode->next = head;
-      head = newnode;
+      save_attrib_data(&head, GL_CLIENT_VERTEX_ARRAY_BIT, attr);
+
       /* bump reference counts on buffer objects */
-      adjust_buffer_object_ref_counts(&ctx->Array, 1);
+      adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, 1);
    }
 
    ctx->ClientAttribStack[ctx->ClientAttribStackDepth] = head;
@@ -1418,7 +1425,7 @@ _mesa_PopClientAttrib(void)
 	    struct gl_array_attrib * data =
 	      (struct gl_array_attrib *) node->data;
 
-            adjust_buffer_object_ref_counts(&ctx->Array, -1);
+            adjust_buffer_object_ref_counts(ctx->Array.ArrayObj, -1);
 	 
             ctx->Array.ActiveTexture = data->ActiveTexture;
 	    if (data->LockCount != 0)
@@ -1461,6 +1468,19 @@ _mesa_PopClientAttrib(void)
 }
 
 
+void
+_mesa_init_attrib_dispatch(struct _glapi_table *disp)
+{
+   SET_PopAttrib(disp, _mesa_PopAttrib);
+   SET_PushAttrib(disp, _mesa_PushAttrib);
+   SET_PopClientAttrib(disp, _mesa_PopClientAttrib);
+   SET_PushClientAttrib(disp, _mesa_PushClientAttrib);
+}
+
+
+#endif /* FEATURE_attrib_stack */
+
+
 /**
  * Free any attribute state data that might be attached to the context.
  */
diff --git a/src/mesa/main/attrib.h b/src/mesa/main/attrib.h
index 2cf8fe6934..aa9d42e408 100644
--- a/src/mesa/main/attrib.h
+++ b/src/mesa/main/attrib.h
@@ -26,10 +26,10 @@
 #define ATTRIB_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
 
-#if _HAVE_FULL_GL
+#if FEATURE_attrib_stack
 
 extern void GLAPIENTRY
 _mesa_PushAttrib( GLbitfield mask );
@@ -43,18 +43,32 @@ _mesa_PushClientAttrib( GLbitfield mask );
 extern void GLAPIENTRY
 _mesa_PopClientAttrib( void );
 
+extern void
+_mesa_init_attrib_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_attrib_stack */
+
+static INLINE void
+_mesa_PushClientAttrib( GLbitfield mask )
+{
+}
+
+static INLINE void
+_mesa_PopClientAttrib( void )
+{
+}
+
+static INLINE void
+_mesa_init_attrib_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_attrib_stack */
+
 extern void 
 _mesa_init_attrib( GLcontext *ctx );
 
 extern void 
 _mesa_free_attrib_data( GLcontext *ctx );
 
-#else
-
-/** No-op */
-#define _mesa_init_attrib( c ) ((void)0)
-#define _mesa_free_attrib_data( c ) ((void)0)
-
-#endif
-
-#endif
+#endif /* ATTRIB_H */
diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c
index 59fe8e25de..b95e00af5b 100644
--- a/src/mesa/main/bufferobj.c
+++ b/src/mesa/main/bufferobj.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.2
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -25,7 +26,7 @@
 
 /**
  * \file bufferobj.c
- * \brief Functions for the GL_ARB_vertex_buffer_object extension.
+ * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.
  * \author Brian Paul, Ian Romanick
  */
 
@@ -38,6 +39,18 @@
 #include "bufferobj.h"
 
 
+/* Debug flags */
+/*#define VBO_DEBUG*/
+/*#define BOUNDS_CHECK*/
+
+
+#ifdef FEATURE_OES_mapbuffer
+#define DEFAULT_ACCESS GL_MAP_WRITE_BIT
+#else
+#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)
+#endif
+
+
 /**
  * Get the buffer object bound to the specified target in a GL context.
  *
@@ -65,6 +78,16 @@ get_buffer(GLcontext *ctx, GLenum target)
       case GL_PIXEL_UNPACK_BUFFER_EXT:
          bufObj = ctx->Unpack.BufferObj;
          break;
+      case GL_COPY_READ_BUFFER:
+         if (ctx->Extensions.ARB_copy_buffer) {
+            bufObj = ctx->CopyReadBuffer;
+         }
+         break;
+      case GL_COPY_WRITE_BUFFER:
+         if (ctx->Extensions.ARB_copy_buffer) {
+            bufObj = ctx->CopyWriteBuffer;
+         }
+         break;
       default:
          /* error must be recorded by caller */
          return NULL;
@@ -78,6 +101,24 @@ get_buffer(GLcontext *ctx, GLenum target)
 
 
 /**
+ * Convert a GLbitfield describing the mapped buffer access flags
+ * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.
+ */
+static GLenum
+simplified_access_mode(GLbitfield access)
+{
+   const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
+   if ((access & rwFlags) == rwFlags)
+      return GL_READ_WRITE;
+   if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)
+      return GL_READ_ONLY;
+   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)
+      return GL_WRITE_ONLY;
+   return GL_READ_WRITE; /* this should never happen, but no big deal */
+}
+
+
+/**
  * Tests the subdata range parameters and sets the GL error code for
  * \c glBufferSubDataARB and \c glGetBufferSubDataARB.
  *
@@ -115,7 +156,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target,
       _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);
       return NULL;
    }
-   if (bufObj->Name == 0) {
+   if (!_mesa_is_bufferobj(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
       return NULL;
    }
@@ -124,7 +165,7 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target,
 		  "%s(size + offset > buffer size)", caller);
       return NULL;
    }
-   if (bufObj->Pointer) {
+   if (_mesa_bufferobj_mapped(bufObj)) {
       /* Buffer is currently mapped */
       _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
       return NULL;
@@ -137,10 +178,9 @@ buffer_object_subdata_range_good( GLcontext * ctx, GLenum target,
 /**
  * Allocate and initialize a new buffer object.
  * 
- * This function is intended to be called via
- * \c dd_function_table::NewBufferObject.
+ * Default callback for the \c dd_function_table::NewBufferObject() hook.
  */
-struct gl_buffer_object *
+static struct gl_buffer_object *
 _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target )
 {
    struct gl_buffer_object *obj;
@@ -156,10 +196,9 @@ _mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target )
 /**
  * Delete a buffer object.
  * 
- * This function is intended to be called via
- * \c dd_function_table::DeleteBuffer.
+ * Default callback for the \c dd_function_table::DeleteBuffer() hook.
  */
-void
+static void
 _mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
 {
    (void) ctx;
@@ -188,7 +227,7 @@ _mesa_reference_buffer_object(GLcontext *ctx,
       return;
 
    if (*ptr) {
-      /* Unreference the old texture */
+      /* Unreference the old buffer */
       GLboolean deleteFlag = GL_FALSE;
       struct gl_buffer_object *oldObj = *ptr;
 
@@ -221,7 +260,7 @@ _mesa_reference_buffer_object(GLcontext *ctx,
    ASSERT(!*ptr);
 
    if (bufObj) {
-      /* reference new texture */
+      /* reference new buffer */
       /*_glthread_LOCK_MUTEX(tex->Mutex);*/
       if (bufObj->RefCount == 0) {
          /* this buffer's being deleted (look just above) */
@@ -255,7 +294,7 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj,
    obj->RefCount = 1;
    obj->Name = name;
    obj->Usage = GL_STATIC_DRAW_ARB;
-   obj->Access = GL_READ_WRITE_ARB;
+   obj->AccessFlags = DEFAULT_ACCESS;
 }
 
 
@@ -264,9 +303,8 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj,
  * previously stored in the buffer object is lost.  If \c data is \c NULL,
  * memory will be allocated, but no copy will occur.
  *
- * This function is intended to be called via
- * \c dd_function_table::BufferData.  This function need not set GL error
- * codes.  The input parameters will have been tested before calling.
+ * This is the default callback for \c dd_function_table::BufferData()
+ * Note that all GL error checking will have been done already.
  *
  * \param ctx     GL context.
  * \param target  Buffer object target on which to operate.
@@ -276,9 +314,10 @@ _mesa_initialize_buffer_object( struct gl_buffer_object *obj,
  * \param usage   Hints about how the data will be used.
  * \param bufObj  Object to be used.
  *
+ * \return GL_TRUE for success, GL_FALSE for failure
  * \sa glBufferDataARB, dd_function_table::BufferData.
  */
-void
+static GLboolean
 _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
 		   const GLvoid * data, GLenum usage,
 		   struct gl_buffer_object * bufObj )
@@ -296,6 +335,11 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
       if (data) {
 	 _mesa_memcpy( bufObj->Data, data, size );
       }
+
+      return GL_TRUE;
+   }
+   else {
+      return GL_FALSE;
    }
 }
 
@@ -305,9 +349,8 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
  * specified by \c size + \c offset extends beyond the end of the buffer or
  * if \c data is \c NULL, no copy is performed.
  *
- * This function is intended to be called by
- * \c dd_function_table::BufferSubData.  This function need not set GL error
- * codes.  The input parameters will have been tested before calling.
+ * This is the default callback for \c dd_function_table::BufferSubData()
+ * Note that all GL error checking will have been done already.
  *
  * \param ctx     GL context.
  * \param target  Buffer object target on which to operate.
@@ -318,7 +361,7 @@ _mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
  *
  * \sa glBufferSubDataARB, dd_function_table::BufferSubData.
  */
-void
+static void
 _mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
 		      GLsizeiptrARB size, const GLvoid * data,
 		      struct gl_buffer_object * bufObj )
@@ -339,20 +382,19 @@ _mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
  * specified by \c size + \c offset extends beyond the end of the buffer or
  * if \c data is \c NULL, no copy is performed.
  *
- * This function is intended to be called by
- * \c dd_function_table::BufferGetSubData.  This function need not set GL error
- * codes.  The input parameters will have been tested before calling.
+ * This is the default callback for \c dd_function_table::GetBufferSubData()
+ * Note that all GL error checking will have been done already.
  *
  * \param ctx     GL context.
  * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte to be modified.
+ * \param offset  Offset of the first byte to be fetched.
  * \param size    Size, in bytes, of the data range.
- * \param data    Pointer to the data to store in the buffer object.
+ * \param data    Destination for data
  * \param bufObj  Object to be used.
  *
  * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
  */
-void
+static void
 _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
 			  GLsizeiptrARB size, GLvoid * data,
 			  struct gl_buffer_object * bufObj )
@@ -366,9 +408,7 @@ _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
 
 
 /**
- * Fallback function called via ctx->Driver.MapBuffer().
- * Hardware drivers that really implement buffer objects should never use
- * this function.
+ * Default callback for \c dd_function_tabel::MapBuffer().
  *
  * The function parameters will have been already tested for errors.
  *
@@ -381,64 +421,135 @@ _mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
  *
  * \sa glMapBufferARB, dd_function_table::MapBuffer
  */
-void *
+static void *
 _mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access,
 		  struct gl_buffer_object *bufObj )
 {
    (void) ctx;
    (void) target;
    (void) access;
-   ASSERT(!bufObj->OnCard);
    /* Just return a direct pointer to the data */
-   if (bufObj->Pointer) {
+   if (_mesa_bufferobj_mapped(bufObj)) {
       /* already mapped! */
       return NULL;
    }
    bufObj->Pointer = bufObj->Data;
+   bufObj->Length = bufObj->Size;
+   bufObj->Offset = 0;
    return bufObj->Pointer;
 }
 
 
 /**
- * Fallback function called via ctx->Driver.MapBuffer().
- * Hardware drivers that really implement buffer objects should never use
- * function.
+ * Default fallback for \c dd_function_table::MapBufferRange().
+ * Called via glMapBufferRange().
+ */
+static void *
+_mesa_buffer_map_range( GLcontext *ctx, GLenum target, GLintptr offset,
+                        GLsizeiptr length, GLbitfield access,
+                        struct gl_buffer_object *bufObj )
+{
+   (void) ctx;
+   (void) target;
+   assert(!_mesa_bufferobj_mapped(bufObj));
+   /* Just return a direct pointer to the data */
+   bufObj->Pointer = bufObj->Data + offset;
+   bufObj->Length = length;
+   bufObj->Offset = offset;
+   bufObj->AccessFlags = access;
+   return bufObj->Pointer;
+}
+
+
+/**
+ * Default fallback for \c dd_function_table::FlushMappedBufferRange().
+ * Called via glFlushMappedBufferRange().
+ */
+static void
+_mesa_buffer_flush_mapped_range( GLcontext *ctx, GLenum target, 
+                                 GLintptr offset, GLsizeiptr length,
+                                 struct gl_buffer_object *obj )
+{
+   (void) ctx;
+   (void) target;
+   (void) offset;
+   (void) length;
+   (void) obj;
+   /* no-op */
+}
+
+
+/**
+ * Default callback for \c dd_function_table::MapBuffer().
  *
  * The input parameters will have been already tested for errors.
  *
  * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer
  */
-GLboolean
+static GLboolean
 _mesa_buffer_unmap( GLcontext *ctx, GLenum target,
                     struct gl_buffer_object *bufObj )
 {
    (void) ctx;
    (void) target;
-   ASSERT(!bufObj->OnCard);
    /* XXX we might assert here that bufObj->Pointer is non-null */
    bufObj->Pointer = NULL;
+   bufObj->Length = 0;
+   bufObj->Offset = 0;
+   bufObj->AccessFlags = 0x0;
    return GL_TRUE;
 }
 
 
 /**
+ * Default fallback for \c dd_function_table::CopyBufferSubData().
+ * Called via glCopyBuffserSubData().
+ */
+static void
+_mesa_copy_buffer_subdata(GLcontext *ctx,
+                          struct gl_buffer_object *src,
+                          struct gl_buffer_object *dst,
+                          GLintptr readOffset, GLintptr writeOffset,
+                          GLsizeiptr size)
+{
+   GLubyte *srcPtr, *dstPtr;
+
+   /* buffer should not already be mapped */
+   assert(!_mesa_bufferobj_mapped(src));
+   assert(!_mesa_bufferobj_mapped(dst));
+
+   srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER,
+                                              GL_READ_ONLY, src);
+   dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER,
+                                              GL_WRITE_ONLY, dst);
+
+   if (srcPtr && dstPtr)
+      _mesa_memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
+
+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src);
+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst);
+}
+
+
+
+/**
  * Initialize the state associated with buffer objects
  */
 void
 _mesa_init_buffer_objects( GLcontext *ctx )
 {
-   /* Allocate the default buffer object and set refcount so high that
-    * it never gets deleted.
-    * XXX with recent/improved refcounting this may not longer be needed.
-    */
-   ctx->Array.NullBufferObj = _mesa_new_buffer_object(ctx, 0, 0);
-   if (ctx->Array.NullBufferObj)
-      ctx->Array.NullBufferObj->RefCount = 1000;
-
-   ctx->Array.ArrayBufferObj = ctx->Array.NullBufferObj;
-   ctx->Array.ElementArrayBufferObj = ctx->Array.NullBufferObj;
+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,
+                                 ctx->Shared->NullBufferObj);
+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj,
+                                 ctx->Shared->NullBufferObj);
+
+   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,
+                                 ctx->Shared->NullBufferObj);
+   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
+                                 ctx->Shared->NullBufferObj);
 }
 
+
 /**
  * Bind the specified target to buffer for the specified context.
  */
@@ -462,8 +573,22 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer)
    case GL_PIXEL_UNPACK_BUFFER_EXT:
       bindTarget = &ctx->Unpack.BufferObj;
       break;
+   case GL_COPY_READ_BUFFER:
+      if (ctx->Extensions.ARB_copy_buffer) {
+         bindTarget = &ctx->CopyReadBuffer;
+      }
+      break;
+   case GL_COPY_WRITE_BUFFER:
+      if (ctx->Extensions.ARB_copy_buffer) {
+         bindTarget = &ctx->CopyWriteBuffer;
+      }
+      break;
    default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target)");
+      ; /* no-op / we'll hit the follow error test next */
+   }
+
+   if (!bindTarget) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)");
       return;
    }
 
@@ -479,7 +604,7 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer)
       /* The spec says there's not a buffer object named 0, but we use
        * one internally because it simplifies things.
        */
-      newBufObj = ctx->Array.NullBufferObj;
+      newBufObj = ctx->Shared->NullBufferObj;
    }
    else {
       /* non-default buffer object */
@@ -500,7 +625,7 @@ bind_buffer_object(GLcontext *ctx, GLenum target, GLuint buffer)
    _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);
 
    /* Pass BindBuffer call to device driver */
-   if (ctx->Driver.BindBuffer && newBufObj)
+   if (ctx->Driver.BindBuffer)
       ctx->Driver.BindBuffer( ctx, target, newBufObj );
 }
 
@@ -533,6 +658,8 @@ _mesa_update_default_objects_buffer_objects(GLcontext *ctx)
  * currently mapped.  Whoever calls this function should check for that.
  * Remember, we can't use a PBO when it's mapped!
  *
+ * If we're not using a PBO, this is a no-op.
+ *
  * \param width  width of image to read/write
  * \param height  height of image to read/write
  * \param depth  depth of image to read/write
@@ -551,7 +678,8 @@ _mesa_validate_pbo_access(GLuint dimensions,
    GLvoid *start, *end;
    const GLubyte *sizeAddr; /* buffer size, cast to a pointer */
 
-   ASSERT(pack->BufferObj->Name != 0);
+   if (!_mesa_is_bufferobj(pack->BufferObj))
+      return GL_TRUE;  /* no PBO, OK */
 
    if (pack->BufferObj->Size == 0)
       /* no buffer! */
@@ -583,21 +711,22 @@ _mesa_validate_pbo_access(GLuint dimensions,
 
 
 /**
- * If the source of glBitmap data is a PBO, check that we won't read out
- * of buffer bounds, then map the buffer.
- * If not sourcing from a PBO, just return the bitmap pointer.
- * This is a helper function for (some) drivers.
- * Return NULL if error.
- * If non-null return, must call _mesa_unmap_bitmap_pbo() when done.
+ * For commands that read from a PBO (glDrawPixels, glTexImage,
+ * glPolygonStipple, etc), if we're reading from a PBO, map it read-only
+ * and return the pointer into the PBO.  If we're not reading from a
+ * PBO, return \p src as-is.
+ * If non-null return, must call _mesa_unmap_pbo_source() when done.
+ *
+ * \return NULL if error, else pointer to start of data
  */
-const GLubyte *
-_mesa_map_bitmap_pbo(GLcontext *ctx,
+const GLvoid *
+_mesa_map_pbo_source(GLcontext *ctx,
                      const struct gl_pixelstore_attrib *unpack,
-                     const GLubyte *bitmap)
+                     const GLvoid *src)
 {
    const GLubyte *buf;
 
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       /* unpack from PBO */
       buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                                               GL_READ_ONLY_ARB,
@@ -605,11 +734,11 @@ _mesa_map_bitmap_pbo(GLcontext *ctx,
       if (!buf)
          return NULL;
 
-      buf = ADD_POINTERS(buf, bitmap);
+      buf = ADD_POINTERS(buf, src);
    }
    else {
       /* unpack from normal memory */
-      buf = bitmap;
+      buf = src;
    }
 
    return buf;
@@ -617,57 +746,55 @@ _mesa_map_bitmap_pbo(GLcontext *ctx,
 
 
 /**
- * Counterpart to _mesa_map_bitmap_pbo()
- * This is a helper function for (some) drivers.
- */
-void
-_mesa_unmap_bitmap_pbo(GLcontext *ctx,
-                       const struct gl_pixelstore_attrib *unpack)
-{
-   if (unpack->BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              unpack->BufferObj);
-   }
-}
-
-
-/**
- * \sa _mesa_map_bitmap_pbo
+ * Combine PBO-read validation and mapping.
+ * If any GL errors are detected, they'll be recorded and NULL returned.
+ * \sa _mesa_validate_pbo_access
+ * \sa _mesa_map_pbo_source
+ * A call to this function should have a matching call to
+ * _mesa_unmap_pbo_source().
  */
 const GLvoid *
-_mesa_map_drawpix_pbo(GLcontext *ctx,
-                      const struct gl_pixelstore_attrib *unpack,
-                      const GLvoid *pixels)
+_mesa_map_validate_pbo_source(GLcontext *ctx,
+                              GLuint dimensions,
+                              const struct gl_pixelstore_attrib *unpack,
+                              GLsizei width, GLsizei height, GLsizei depth,
+                              GLenum format, GLenum type, const GLvoid *ptr,
+                              const char *where)
 {
-   const GLvoid *buf;
+   ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3);
 
-   if (unpack->BufferObj->Name) {
-      /* unpack from PBO */
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              unpack->BufferObj);
-      if (!buf)
-         return NULL;
+   if (!_mesa_is_bufferobj(unpack->BufferObj)) {
+      /* non-PBO access: no validation to be done */
+      return ptr;
+   }
 
-      buf = ADD_POINTERS(buf, pixels);
+   if (!_mesa_validate_pbo_access(dimensions, unpack,
+                                  width, height, depth, format, type, ptr)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "%s(out of bounds PBO access)", where);
+      return NULL;
    }
-   else {
-      /* unpack from normal memory */
-      buf = pixels;
+
+   if (_mesa_bufferobj_mapped(unpack->BufferObj)) {
+      /* buffer is already mapped - that's an error */
+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(PBO is mapped)", where);
+      return NULL;
    }
 
-   return buf;
+   ptr = _mesa_map_pbo_source(ctx, unpack, ptr);
+   return ptr;
 }
 
 
 /**
- * \sa _mesa_unmap_bitmap_pbo
+ * Counterpart to _mesa_map_pbo_source()
  */
 void
-_mesa_unmap_drapix_pbo(GLcontext *ctx,
+_mesa_unmap_pbo_source(GLcontext *ctx,
                        const struct gl_pixelstore_attrib *unpack)
 {
-   if (unpack->BufferObj->Name) {
+   ASSERT(unpack != &ctx->Pack); /* catch pack/unpack mismatch */
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                               unpack->BufferObj);
    }
@@ -675,18 +802,21 @@ _mesa_unmap_drapix_pbo(GLcontext *ctx,
 
 
 /**
- * If PBO is bound, map the buffer, return dest pointer in mapped buffer.
- * Call _mesa_unmap_readpix_pbo() when finished
- * \return NULL if error
+ * For commands that write to a PBO (glReadPixels, glGetColorTable, etc),
+ * if we're writing to a PBO, map it write-only and return the pointer
+ * into the PBO.  If we're not writing to a PBO, return \p dst as-is.
+ * If non-null return, must call _mesa_unmap_pbo_dest() when done.
+ *
+ * \return NULL if error, else pointer to start of data
  */
 void *
-_mesa_map_readpix_pbo(GLcontext *ctx,
-                      const struct gl_pixelstore_attrib *pack,
-                      GLvoid *dest)
+_mesa_map_pbo_dest(GLcontext *ctx,
+                   const struct gl_pixelstore_attrib *pack,
+                   GLvoid *dest)
 {
    void *buf;
 
-   if (pack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(pack->BufferObj)) {
       /* pack into PBO */
       buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
                                               GL_WRITE_ONLY_ARB,
@@ -706,13 +836,55 @@ _mesa_map_readpix_pbo(GLcontext *ctx,
 
 
 /**
- * Counterpart to _mesa_map_readpix_pbo()
+ * Combine PBO-write validation and mapping.
+ * If any GL errors are detected, they'll be recorded and NULL returned.
+ * \sa _mesa_validate_pbo_access
+ * \sa _mesa_map_pbo_dest
+ * A call to this function should have a matching call to
+ * _mesa_unmap_pbo_dest().
+ */
+GLvoid *
+_mesa_map_validate_pbo_dest(GLcontext *ctx,
+                            GLuint dimensions,
+                            const struct gl_pixelstore_attrib *unpack,
+                            GLsizei width, GLsizei height, GLsizei depth,
+                            GLenum format, GLenum type, GLvoid *ptr,
+                            const char *where)
+{
+   ASSERT(dimensions == 1 || dimensions == 2 || dimensions == 3);
+
+   if (!_mesa_is_bufferobj(unpack->BufferObj)) {
+      /* non-PBO access: no validation to be done */
+      return ptr;
+   }
+
+   if (!_mesa_validate_pbo_access(dimensions, unpack,
+                                  width, height, depth, format, type, ptr)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "%s(out of bounds PBO access)", where);
+      return NULL;
+   }
+
+   if (_mesa_bufferobj_mapped(unpack->BufferObj)) {
+      /* buffer is already mapped - that's an error */
+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(PBO is mapped)", where);
+      return NULL;
+   }
+
+   ptr = _mesa_map_pbo_dest(ctx, unpack, ptr);
+   return ptr;
+}
+
+
+/**
+ * Counterpart to _mesa_map_pbo_dest()
  */
 void
-_mesa_unmap_readpix_pbo(GLcontext *ctx,
-                        const struct gl_pixelstore_attrib *pack)
+_mesa_unmap_pbo_dest(GLcontext *ctx,
+                     const struct gl_pixelstore_attrib *pack)
 {
-   if (pack->BufferObj->Name) {
+   ASSERT(pack != &ctx->Unpack); /* catch pack/unpack mismatch */
+   if (_mesa_is_bufferobj(pack->BufferObj)) {
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, pack->BufferObj);
    }
 }
@@ -746,11 +918,37 @@ unbind(GLcontext *ctx,
        struct gl_buffer_object *obj)
 {
    if (*ptr == obj) {
-      _mesa_reference_buffer_object(ctx, ptr, ctx->Array.NullBufferObj);
+      _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);
    }
 }
 
 
+/**
+ * Plug default/fallback buffer object functions into the device
+ * driver hooks.
+ */
+void
+_mesa_init_buffer_object_functions(struct dd_function_table *driver)
+{
+   /* GL_ARB_vertex/pixel_buffer_object */
+   driver->NewBufferObject = _mesa_new_buffer_object;
+   driver->DeleteBuffer = _mesa_delete_buffer_object;
+   driver->BindBuffer = NULL;
+   driver->BufferData = _mesa_buffer_data;
+   driver->BufferSubData = _mesa_buffer_subdata;
+   driver->GetBufferSubData = _mesa_buffer_get_subdata;
+   driver->MapBuffer = _mesa_buffer_map;
+   driver->UnmapBuffer = _mesa_buffer_unmap;
+
+   /* GL_ARB_map_buffer_range */
+   driver->MapBufferRange = _mesa_buffer_map_range;
+   driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;
+
+   /* GL_ARB_copy_buffer */
+   driver->CopyBufferSubData = _mesa_copy_buffer_subdata;
+}
+
+
 
 /**********************************************************************/
 /* API Functions                                                      */
@@ -789,23 +987,32 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
    for (i = 0; i < n; i++) {
       struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);
       if (bufObj) {
-         /* unbind any vertex pointers bound to this buffer */
+         struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
          GLuint j;
 
          ASSERT(bufObj->Name == ids[i]);
 
-         unbind(ctx, &ctx->Array.ArrayObj->Vertex.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->Normal.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->Color.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->SecondaryColor.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->FogCoord.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->Index.BufferObj, bufObj);
-         unbind(ctx, &ctx->Array.ArrayObj->EdgeFlag.BufferObj, bufObj);
-         for (j = 0; j < MAX_TEXTURE_COORD_UNITS; j++) {
-            unbind(ctx, &ctx->Array.ArrayObj->TexCoord[j].BufferObj, bufObj);
+         if (_mesa_bufferobj_mapped(bufObj)) {
+            /* if mapped, unmap it now */
+            ctx->Driver.UnmapBuffer(ctx, 0, bufObj);
+            bufObj->AccessFlags = DEFAULT_ACCESS;
+            bufObj->Pointer = NULL;
          }
-         for (j = 0; j < VERT_ATTRIB_MAX; j++) {
-            unbind(ctx, &ctx->Array.ArrayObj->VertexAttrib[j].BufferObj, bufObj);
+
+         /* unbind any vertex pointers bound to this buffer */
+         unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->Color.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->Index.BufferObj, bufObj);
+         unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);
+         for (j = 0; j < Elements(arrayObj->TexCoord); j++) {
+            unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);
+         }
+         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {
+            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);
          }
 
          if (ctx->Array.ArrayBufferObj == bufObj) {
@@ -815,6 +1022,7 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
             _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
          }
 
+         /* unbind any pixel pack/unpack pointers bound to this buffer */
          if (ctx->Pack.BufferObj == bufObj) {
             _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );
          }
@@ -938,20 +1146,35 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
       _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );
       return;
    }
-   if (bufObj->Name == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB" );
+   if (!_mesa_is_bufferobj(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" );
       return;
    }
    
-   if (bufObj->Pointer) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer is mapped)" );
-      return;
+   if (_mesa_bufferobj_mapped(bufObj)) {
+      /* Unmap the existing buffer.  We'll replace it now.  Not an error. */
+      ctx->Driver.UnmapBuffer(ctx, target, bufObj);
+      bufObj->AccessFlags = DEFAULT_ACCESS;
+      ASSERT(bufObj->Pointer == NULL);
    }  
 
-   ASSERT(ctx->Driver.BufferData);
+   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
+
+   bufObj->Written = GL_TRUE;
+
+#ifdef VBO_DEBUG
+   _mesa_printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
+                bufObj->Name, size, data, usage);
+#endif
 
-   /* Give the buffer object to the driver!  <data> may be null! */
-   ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj );
+#ifdef BOUNDS_CHECK
+   size += 100;
+#endif
+
+   ASSERT(ctx->Driver.BufferData);
+   if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB(access)");
+   }
 }
 
 
@@ -970,6 +1193,8 @@ _mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,
       return;
    }
 
+   bufObj->Written = GL_TRUE;
+
    ASSERT(ctx->Driver.BufferSubData);
    ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );
 }
@@ -1000,13 +1225,20 @@ _mesa_MapBufferARB(GLenum target, GLenum access)
 {
    GET_CURRENT_CONTEXT(ctx);
    struct gl_buffer_object * bufObj;
+   GLbitfield accessFlags;
+   void *map;
+
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
 
    switch (access) {
       case GL_READ_ONLY_ARB:
+         accessFlags = GL_MAP_READ_BIT;
+         break;
       case GL_WRITE_ONLY_ARB:
+         accessFlags = GL_MAP_WRITE_BIT;
+         break;
       case GL_READ_WRITE_ARB:
-         /* OK */
+         accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
          break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");
@@ -1018,22 +1250,56 @@ _mesa_MapBufferARB(GLenum target, GLenum access)
       _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );
       return NULL;
    }
-   if (bufObj->Name == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB" );
+   if (!_mesa_is_bufferobj(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" );
       return NULL;
    }
-   if (bufObj->Pointer) {
+   if (_mesa_bufferobj_mapped(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");
       return NULL;
    }
 
    ASSERT(ctx->Driver.MapBuffer);
-   bufObj->Pointer = ctx->Driver.MapBuffer( ctx, target, access, bufObj );
-   if (!bufObj->Pointer) {
+   map = ctx->Driver.MapBuffer( ctx, target, access, bufObj );
+   if (!map) {
       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)");
+      return NULL;
+   }
+   else {
+      /* The driver callback should have set these fields.
+       * This is important because other modules (like VBO) might call
+       * the driver function directly.
+       */
+      ASSERT(bufObj->Pointer == map);
+      ASSERT(bufObj->Length == bufObj->Size);
+      ASSERT(bufObj->Offset == 0);
+      bufObj->AccessFlags = accessFlags;
    }
 
-   bufObj->Access = access;
+   if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB)
+      bufObj->Written = GL_TRUE;
+
+#ifdef VBO_DEBUG
+   _mesa_printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",
+                bufObj->Name, bufObj->Size, access);
+   if (access == GL_WRITE_ONLY_ARB) {
+      GLuint i;
+      GLubyte *b = (GLubyte *) bufObj->Pointer;
+      for (i = 0; i < bufObj->Size; i++)
+         b[i] = i & 0xff;
+   }
+#endif
+
+#ifdef BOUNDS_CHECK
+   {
+      GLubyte *buf = (GLubyte *) bufObj->Pointer;
+      GLuint i;
+      /* buffer is 100 bytes larger than requested, fill with magic value */
+      for (i = 0; i < 100; i++) {
+         buf[bufObj->Size - i - 1] = 123;
+      }
+   }
+#endif
 
    return bufObj->Pointer;
 }
@@ -1052,21 +1318,56 @@ _mesa_UnmapBufferARB(GLenum target)
       _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );
       return GL_FALSE;
    }
-   if (bufObj->Name == 0) {
+   if (!_mesa_is_bufferobj(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );
       return GL_FALSE;
    }
-   if (!bufObj->Pointer) {
+   if (!_mesa_bufferobj_mapped(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
       return GL_FALSE;
    }
 
-   if (ctx->Driver.UnmapBuffer) {
-      status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );
+#ifdef BOUNDS_CHECK
+   if (bufObj->Access != GL_READ_ONLY_ARB) {
+      GLubyte *buf = (GLubyte *) bufObj->Pointer;
+      GLuint i;
+      /* check that last 100 bytes are still = magic value */
+      for (i = 0; i < 100; i++) {
+         GLuint pos = bufObj->Size - i - 1;
+         if (buf[pos] != 123) {
+            _mesa_warning(ctx, "Out of bounds buffer object write detected"
+                          " at position %d (value = %u)\n",
+                          pos, buf[pos]);
+         }
+      }
    }
+#endif
 
-   bufObj->Access = GL_READ_WRITE_ARB; /* initial value, OK? */
-   bufObj->Pointer = NULL;
+#ifdef VBO_DEBUG
+   if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {
+      GLuint i, unchanged = 0;
+      GLubyte *b = (GLubyte *) bufObj->Pointer;
+      GLint pos = -1;
+      /* check which bytes changed */
+      for (i = 0; i < bufObj->Size - 1; i++) {
+         if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {
+            unchanged++;
+            if (pos == -1)
+               pos = i;
+         }
+      }
+      if (unchanged) {
+         _mesa_printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
+                      bufObj->Name, unchanged, bufObj->Size, pos);
+      }
+   }
+#endif
+
+   status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );
+   bufObj->AccessFlags = DEFAULT_ACCESS;
+   ASSERT(bufObj->Pointer == NULL);
+   ASSERT(bufObj->Offset == 0);
+   ASSERT(bufObj->Length == 0);
 
    return status;
 }
@@ -1084,7 +1385,7 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
       _mesa_error(ctx, GL_INVALID_ENUM, "GetBufferParameterivARB(target)" );
       return;
    }
-   if (bufObj->Name == 0) {
+   if (!_mesa_is_bufferobj(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameterivARB" );
       return;
    }
@@ -1097,10 +1398,10 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
          *params = bufObj->Usage;
          break;
       case GL_BUFFER_ACCESS_ARB:
-         *params = bufObj->Access;
+         *params = simplified_access_mode(bufObj->AccessFlags);
          break;
       case GL_BUFFER_MAPPED_ARB:
-         *params = (bufObj->Pointer != NULL);
+         *params = _mesa_bufferobj_mapped(bufObj);
          break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname)");
@@ -1126,10 +1427,252 @@ _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
       _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );
       return;
    }
-   if (bufObj->Name == 0) {
+   if (!_mesa_is_bufferobj(bufObj)) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );
       return;
    }
 
    *params = bufObj->Pointer;
 }
+
+
+void GLAPIENTRY
+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+                        GLintptr readOffset, GLintptr writeOffset,
+                        GLsizeiptr size)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *src, *dst;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   src = get_buffer(ctx, readTarget);
+   if (!src || !_mesa_is_bufferobj(src)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glCopyBuffserSubData(readTarget = 0x%x)", readTarget);
+      return;
+   }
+
+   dst = get_buffer(ctx, writeTarget);
+   if (!dst || !_mesa_is_bufferobj(dst)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget);
+      return;
+   }
+
+   if (_mesa_bufferobj_mapped(src)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glCopyBuffserSubData(readBuffer is mapped)");
+      return;
+   }
+
+   if (_mesa_bufferobj_mapped(dst)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glCopyBuffserSubData(writeBuffer is mapped)");
+      return;
+   }
+
+   if (readOffset < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glCopyBuffserSubData(readOffset = %d)", readOffset);
+      return;
+   }
+
+   if (writeOffset < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glCopyBuffserSubData(writeOffset = %d)", writeOffset);
+      return;
+   }
+
+   if (readOffset + size > src->Size) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glCopyBuffserSubData(readOffset + size = %d)",
+                  readOffset, size);
+      return;
+   }
+
+   if (writeOffset + size > dst->Size) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glCopyBuffserSubData(writeOffset + size = %d)",
+                  writeOffset, size);
+      return;
+   }
+
+   if (src == dst) {
+      if (readOffset + size <= writeOffset) {
+         /* OK */
+      }
+      else if (writeOffset + size <= readOffset) {
+         /* OK */
+      }
+      else {
+         /* overlapping src/dst is illegal */
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glCopyBuffserSubData(overlapping src/dst)");
+         return;
+      }
+   }
+
+   ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);
+}
+
+
+/**
+ * See GL_ARB_map_buffer_range spec
+ */
+void * GLAPIENTRY
+_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
+                     GLbitfield access)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
+   void *map;
+
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
+
+   if (!ctx->Extensions.ARB_map_buffer_range) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(extension not supported)");
+      return NULL;
+   }
+
+   if (offset < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glMapBufferRange(offset = %ld)", offset);
+      return NULL;
+   }
+
+   if (length < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glMapBufferRange(length = %ld)", length);
+      return NULL;
+   }
+
+   if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(access indicates neither read or write)");
+      return NULL;
+   }
+
+   if (access & GL_MAP_READ_BIT) {
+      if ((access & GL_MAP_INVALIDATE_RANGE_BIT) ||
+          (access & GL_MAP_INVALIDATE_BUFFER_BIT) ||
+          (access & GL_MAP_UNSYNCHRONIZED_BIT)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glMapBufferRange(invalid access flags)");
+         return NULL;
+      }
+   }
+
+   if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&
+       ((access & GL_MAP_WRITE_BIT) == 0)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(invalid access flags)");
+      return NULL;
+   }
+
+   bufObj = get_buffer(ctx, target);
+   if (!bufObj || !_mesa_is_bufferobj(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glMapBufferRange(target = 0x%x)", target);
+      return NULL;
+   }
+
+   if (offset + length > bufObj->Size) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glMapBufferRange(offset + length > size)");
+      return NULL;
+   }
+
+   if (_mesa_bufferobj_mapped(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(buffer already mapped)");
+      return NULL;
+   }
+      
+   ASSERT(ctx->Driver.MapBufferRange);
+   map = ctx->Driver.MapBufferRange(ctx, target, offset, length,
+                                    access, bufObj);
+   if (!map) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)");
+   }
+   else {
+      /* The driver callback should have set all these fields.
+       * This is important because other modules (like VBO) might call
+       * the driver function directly.
+       */
+      ASSERT(bufObj->Pointer == map);
+      ASSERT(bufObj->Length == length);
+      ASSERT(bufObj->Offset == offset);
+      ASSERT(bufObj->AccessFlags == access);
+   }
+
+   return map;
+}
+
+
+/**
+ * See GL_ARB_map_buffer_range spec
+ */
+void GLAPIENTRY
+_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ARB_map_buffer_range) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(extension not supported)");
+      return;
+   }
+
+   if (offset < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glMapBufferRange(offset = %ld)", offset);
+      return;
+   }
+
+   if (length < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+                  "glMapBufferRange(length = %ld)", length);
+      return;
+   }
+
+   bufObj = get_buffer(ctx, target);
+   if (!bufObj) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glMapBufferRange(target = 0x%x)", target);
+      return;
+   }
+
+   if (!_mesa_is_bufferobj(bufObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(current buffer is 0)");
+      return;
+   }
+
+   if (!_mesa_bufferobj_mapped(bufObj)) {
+      /* buffer is not mapped */
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(buffer is not mapped)");
+      return;
+   }
+
+   if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)");
+      return;
+   }
+
+   if (offset + length > bufObj->Length) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+             "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",
+             offset, length, bufObj->Length);
+      return;
+   }
+
+   ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT);
+
+   if (ctx->Driver.FlushMappedBufferRange)
+      ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj);
+}
diff --git a/src/mesa/main/bufferobj.h b/src/mesa/main/bufferobj.h
index 163fe241aa..9f732ec0c0 100644
--- a/src/mesa/main/bufferobj.h
+++ b/src/mesa/main/bufferobj.h
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.2
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -35,17 +36,32 @@
  * Internal functions
  */
 
+
+/** Is the given buffer object currently mapped? */
+static INLINE GLboolean
+_mesa_bufferobj_mapped(const struct gl_buffer_object *obj)
+{
+   return obj->Pointer != NULL;
+}
+
+/**
+ * Is the given buffer object a user-created buffer object?
+ * Mesa uses default buffer objects in several places.  Default buffers
+ * always have Name==0.  User created buffers have Name!=0.
+ */
+static INLINE GLboolean
+_mesa_is_bufferobj(const struct gl_buffer_object *obj)
+{
+   return obj->Name != 0;
+}
+
+
 extern void
 _mesa_init_buffer_objects( GLcontext *ctx );
 
 extern void
 _mesa_update_default_objects_buffer_objects(GLcontext *ctx);
 
-extern struct gl_buffer_object *
-_mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target );
-
-extern void
-_mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj );
 
 extern struct gl_buffer_object *
 _mesa_lookup_bufferobj(GLcontext *ctx, GLuint buffer);
@@ -59,64 +75,50 @@ _mesa_reference_buffer_object(GLcontext *ctx,
                               struct gl_buffer_object **ptr,
                               struct gl_buffer_object *bufObj);
 
-extern void
-_mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
-		   const GLvoid * data, GLenum usage,
-		   struct gl_buffer_object * bufObj );
-
-extern void
-_mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
-		      GLsizeiptrARB size, const GLvoid * data,
-		      struct gl_buffer_object * bufObj );
-
-extern void
-_mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
-			  GLsizeiptrARB size, GLvoid * data,
-			  struct gl_buffer_object * bufObj );
-
-extern void *
-_mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access,
-		  struct gl_buffer_object * bufObj );
-
-extern GLboolean
-_mesa_buffer_unmap( GLcontext *ctx, GLenum target,
-                    struct gl_buffer_object * bufObj );
-
 extern GLboolean
 _mesa_validate_pbo_access(GLuint dimensions,
                           const struct gl_pixelstore_attrib *pack,
                           GLsizei width, GLsizei height, GLsizei depth,
                           GLenum format, GLenum type, const GLvoid *ptr);
 
-extern const GLubyte *
-_mesa_map_bitmap_pbo(GLcontext *ctx,
+extern const GLvoid *
+_mesa_map_pbo_source(GLcontext *ctx,
                      const struct gl_pixelstore_attrib *unpack,
-                     const GLubyte *bitmap);
-
-extern void
-_mesa_unmap_bitmap_pbo(GLcontext *ctx,
-                       const struct gl_pixelstore_attrib *unpack);
+                     const GLvoid *src);
 
 extern const GLvoid *
-_mesa_map_drawpix_pbo(GLcontext *ctx,
-                      const struct gl_pixelstore_attrib *unpack,
-                      const GLvoid *pixels);
+_mesa_map_validate_pbo_source(GLcontext *ctx,
+                              GLuint dimensions,
+                              const struct gl_pixelstore_attrib *unpack,
+                              GLsizei width, GLsizei height, GLsizei depth,
+                              GLenum format, GLenum type, const GLvoid *ptr,
+                              const char *where);
 
 extern void
-_mesa_unmap_drapix_pbo(GLcontext *ctx,
+_mesa_unmap_pbo_source(GLcontext *ctx,
                        const struct gl_pixelstore_attrib *unpack);
 
-
 extern void *
-_mesa_map_readpix_pbo(GLcontext *ctx,
-                      const struct gl_pixelstore_attrib *pack,
-                      GLvoid *dest);
+_mesa_map_pbo_dest(GLcontext *ctx,
+                   const struct gl_pixelstore_attrib *pack,
+                   GLvoid *dest);
+
+extern GLvoid *
+_mesa_map_validate_pbo_dest(GLcontext *ctx,
+                            GLuint dimensions,
+                            const struct gl_pixelstore_attrib *unpack,
+                            GLsizei width, GLsizei height, GLsizei depth,
+                            GLenum format, GLenum type, GLvoid *ptr,
+                            const char *where);
 
 extern void
-_mesa_unmap_readpix_pbo(GLcontext *ctx,
-                        const struct gl_pixelstore_attrib *pack);
+_mesa_unmap_pbo_dest(GLcontext *ctx,
+                     const struct gl_pixelstore_attrib *pack);
 
 
+extern void
+_mesa_init_buffer_object_functions(struct dd_function_table *driver);
+
 
 /*
  * API functions
@@ -155,4 +157,16 @@ _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params);
 extern void GLAPIENTRY
 _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params);
 
+extern void GLAPIENTRY
+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+                        GLintptr readOffset, GLintptr writeOffset,
+                        GLsizeiptr size);
+
+extern void * GLAPIENTRY
+_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
+                     GLbitfield access);
+
+extern void GLAPIENTRY
+_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+
 #endif
diff --git a/src/mesa/main/buffers.c b/src/mesa/main/buffers.c
index b23d2f612b..d8b5f3b1f4 100644
--- a/src/mesa/main/buffers.c
+++ b/src/mesa/main/buffers.c
@@ -120,11 +120,9 @@ draw_buffer_enum_to_bitmask(GLenum buffer)
       case GL_AUX0:
          return BUFFER_BIT_AUX0;
       case GL_AUX1:
-         return BUFFER_BIT_AUX1;
       case GL_AUX2:
-         return BUFFER_BIT_AUX2;
       case GL_AUX3:
-         return BUFFER_BIT_AUX3;
+         return 1 << BUFFER_COUNT; /* invalid, but not BAD_MASK */
       case GL_COLOR_ATTACHMENT0_EXT:
          return BUFFER_BIT_COLOR0;
       case GL_COLOR_ATTACHMENT1_EXT:
@@ -177,11 +175,9 @@ read_buffer_enum_to_index(GLenum buffer)
       case GL_AUX0:
          return BUFFER_AUX0;
       case GL_AUX1:
-         return BUFFER_AUX1;
       case GL_AUX2:
-         return BUFFER_AUX2;
       case GL_AUX3:
-         return BUFFER_AUX3;
+         return BUFFER_COUNT; /* invalid, but not -1 */
       case GL_COLOR_ATTACHMENT0_EXT:
          return BUFFER_COLOR0;
       case GL_COLOR_ATTACHMENT1_EXT:
@@ -247,13 +243,14 @@ _mesa_DrawBuffer(GLenum buffer)
       destMask = draw_buffer_enum_to_bitmask(buffer);
       if (destMask == BAD_MASK) {
          /* totally bogus buffer */
-         _mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffer(buffer)");
+         _mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffer(buffer=0x%x)", buffer);
          return;
       }
       destMask &= supportedMask;
       if (destMask == 0x0) {
          /* none of the named color buffers exist! */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawBuffer(buffer)");
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glDrawBuffer(buffer=0x%x)", buffer);
          return;
       }
    }
@@ -289,11 +286,10 @@ _mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers)
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (!ctx->Extensions.ARB_draw_buffers) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawBuffersARB");
-      return;
-   }
-   if (n < 1 || n > (GLsizei) ctx->Const.MaxDrawBuffers) {
+   /* Turns out n==0 is a valid input that should not produce an error.
+    * The remaining code below correctly handles the n==0 case.
+    */
+   if (n < 0 || n > (GLsizei) ctx->Const.MaxDrawBuffers) {
       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawBuffersARB(n)");
       return;
    }
@@ -335,12 +331,14 @@ _mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers)
    _mesa_drawbuffers(ctx, n, buffers, destMask);
 
    /*
-    * Call device driver function.
+    * Call device driver function.  Note that n can be equal to 0,
+    * in which case we don't want to reference buffers[0], which
+    * may not be valid.
     */
    if (ctx->Driver.DrawBuffers)
       ctx->Driver.DrawBuffers(ctx, n, buffers);
    else if (ctx->Driver.DrawBuffer)
-      ctx->Driver.DrawBuffer(ctx, buffers[0]);
+      ctx->Driver.DrawBuffer(ctx, n>0? buffers[0]:GL_NONE);
 }
 
 
@@ -419,7 +417,7 @@ _mesa_drawbuffers(GLcontext *ctx, GLuint n, const GLenum *buffers,
       }
    }
 
-   ctx->NewState |= _NEW_COLOR;
+   ctx->NewState |= _NEW_BUFFERS;
 }
 
 
@@ -445,7 +443,7 @@ _mesa_readbuffer(GLcontext *ctx, GLenum buffer, GLint bufferIndex)
    fb->ColorReadBuffer = buffer;
    fb->_ColorReadBufferIndex = bufferIndex;
 
-   ctx->NewState |= _NEW_PIXEL;
+   ctx->NewState |= _NEW_BUFFERS;
 }
 
 
@@ -494,6 +492,7 @@ _mesa_ReadBuffer(GLenum buffer)
    /* OK, all error checking has been completed now */
 
    _mesa_readbuffer(ctx, buffer, srcBuffer);
+   ctx->NewState |= _NEW_BUFFERS;
 
    /*
     * Call device driver function.
diff --git a/src/mesa/main/clip.c b/src/mesa/main/clip.c
index 43ef55ee3b..96c80e6ef8 100644
--- a/src/mesa/main/clip.c
+++ b/src/mesa/main/clip.c
@@ -29,7 +29,6 @@
 #include "macros.h"
 #include "mtypes.h"
 
-#include "math/m_xform.h"
 #include "math/m_matrix.h"
 
 
diff --git a/src/mesa/main/colormac.h b/src/mesa/main/colormac.h
index 74692e9a98..815624ee50 100644
--- a/src/mesa/main/colormac.h
+++ b/src/mesa/main/colormac.h
@@ -71,9 +71,6 @@
 /** \def COPY_CHAN4
  * Copy a GLchan[4] array */
 
-/** \def CHAN_PRODUCT
- * Scaled product (usually approximated) between two GLchan arguments */
-
 #if CHAN_BITS == 8
 
 #define BYTE_TO_CHAN(b)   ((b) < 0 ? 0 : (GLchan) (b))
@@ -91,8 +88,6 @@
 
 #define COPY_CHAN4(DST, SRC)  COPY_4UBV(DST, SRC)
 
-#define CHAN_PRODUCT(a, b)  ((GLubyte) (((GLint)(a) * ((GLint)(b) + 1)) >> 8))
-
 #elif CHAN_BITS == 16
 
 #define BYTE_TO_CHAN(b)   ((b) < 0 ? 0 : (((GLchan) (b)) * 516))
@@ -110,8 +105,6 @@
 
 #define COPY_CHAN4(DST, SRC)  COPY_4V(DST, SRC)
 
-#define CHAN_PRODUCT(a, b) ((GLchan) ((((GLuint) (a)) * ((GLuint) (b))) / 65535))
-
 #elif CHAN_BITS == 32
 
 /* XXX floating-point color channels not fully thought-out */
@@ -130,8 +123,6 @@
 
 #define COPY_CHAN4(DST, SRC)  COPY_4V(DST, SRC)
 
-#define CHAN_PRODUCT(a, b)    ((a) * (b))
-
 #else
 
 #error unexpected CHAN_BITS size
diff --git a/src/mesa/main/colortab.c b/src/mesa/main/colortab.c
index bd9cf438b4..d6f3121cb4 100644
--- a/src/mesa/main/colortab.c
+++ b/src/mesa/main/colortab.c
@@ -31,6 +31,10 @@
 #include "macros.h"
 #include "state.h"
 #include "teximage.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_colortable
 
 
 /**
@@ -179,26 +183,12 @@ store_colortable_entries(GLcontext *ctx, struct gl_color_table *table,
 			 GLfloat bScale, GLfloat bBias,
 			 GLfloat aScale, GLfloat aBias)
 {
-   if (ctx->Unpack.BufferObj->Name) {
-      /* Get/unpack the color table data from a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Unpack, count, 1, 1,
-                                     format, type, data)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glColor[Sub]Table(bad PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glColor[Sub]Table(PBO mapped)");
-         return;
-      }
-      data = ADD_POINTERS(buf, data);
-   }
-
+   data = _mesa_map_validate_pbo_source(ctx, 
+                                        1, &ctx->Unpack, count, 1, 1,
+                                        format, type, data,
+                                        "glColor[Sub]Table");
+   if (!data)
+      return;
 
    {
       /* convert user-provided data to GLfloat values */
@@ -279,10 +269,7 @@ store_colortable_entries(GLcontext *ctx, struct gl_color_table *table,
       }
    }
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 }
 
 
@@ -696,34 +683,17 @@ _mesa_GetColorTable( GLenum target, GLenum format,
       return;
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack color table into PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Pack, table->Size, 1, 1,
-                                     format, type, data)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetColorTable(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetColorTable(PBO is mapped)");
-         return;
-      }
-      data = ADD_POINTERS(buf, data);
-   }
+   data = _mesa_map_validate_pbo_dest(ctx, 
+                                      1, &ctx->Pack, table->Size, 1, 1,
+                                      format, type, data,
+                                      "glGetColorTable");
+   if (!data)
+      return;
 
    _mesa_pack_rgba_span_float(ctx, table->Size, rgba,
                               format, type, data, &ctx->Pack, 0x0);
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
@@ -1078,6 +1048,25 @@ _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
    }
 }
 
+
+void 
+_mesa_init_colortable_dispatch(struct _glapi_table *disp)
+{
+   SET_ColorSubTable(disp, _mesa_ColorSubTable);
+   SET_ColorTable(disp, _mesa_ColorTable);
+   SET_ColorTableParameterfv(disp, _mesa_ColorTableParameterfv);
+   SET_ColorTableParameteriv(disp, _mesa_ColorTableParameteriv);
+   SET_CopyColorSubTable(disp, _mesa_CopyColorSubTable);
+   SET_CopyColorTable(disp, _mesa_CopyColorTable);
+   SET_GetColorTable(disp, _mesa_GetColorTable);
+   SET_GetColorTableParameterfv(disp, _mesa_GetColorTableParameterfv);
+   SET_GetColorTableParameteriv(disp, _mesa_GetColorTableParameteriv);
+}
+
+
+#endif /* FEATURE_colortable */
+
+
 /**********************************************************************/
 /*****                      Initialization                        *****/
 /**********************************************************************/
diff --git a/src/mesa/main/colortab.h b/src/mesa/main/colortab.h
index b6ff737a65..ec28ceca9d 100644
--- a/src/mesa/main/colortab.h
+++ b/src/mesa/main/colortab.h
@@ -27,9 +27,16 @@
 #define COLORTAB_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
-#if _HAVE_FULL_GL
+#if FEATURE_colortable
+
+#define _MESA_INIT_COLORTABLE_FUNCTIONS(driver, impl)                \
+   do {                                                              \
+      (driver)->CopyColorTable       = impl ## CopyColorTable;       \
+      (driver)->CopyColorSubTable    = impl ## CopyColorSubTable;    \
+      (driver)->UpdateTexturePalette = impl ## UpdateTexturePalette; \
+   } while (0)
 
 extern void GLAPIENTRY
 _mesa_ColorTable( GLenum target, GLenum internalformat,
@@ -67,6 +74,19 @@ _mesa_GetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params );
 extern void GLAPIENTRY
 _mesa_GetColorTableParameteriv( GLenum target, GLenum pname, GLint *params );
 
+extern void 
+_mesa_init_colortable_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_colortable */
+
+#define _MESA_INIT_COLORTABLE_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void
+_mesa_init_colortable_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_colortable */
 
 
 extern void
@@ -81,20 +101,5 @@ _mesa_init_colortables( GLcontext *ctx );
 extern void 
 _mesa_free_colortables_data( GLcontext *ctx );
 
-#else
-
-/** No-op */
-#define _mesa_init_colortable( p ) ((void) 0)
-
-/** No-op */
-#define _mesa_free_colortable_data( p ) ((void) 0)
-
-/** No-op */
-#define _mesa_init_colortables( p ) ((void)0)
-
-/** No-op */
-#define _mesa_free_colortables_data( p ) ((void)0)
-
-#endif
 
-#endif
+#endif /* COLORTAB_H */
diff --git a/src/mesa/main/compiler.h b/src/mesa/main/compiler.h
new file mode 100644
index 0000000000..9319505a75
--- /dev/null
+++ b/src/mesa/main/compiler.h
@@ -0,0 +1,484 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/**
+ * \file compiler.h
+ * Compiler-related stuff.
+ */
+
+
+#ifndef COMPILER_H
+#define COMPILER_H
+
+
+#include <assert.h>
+#include <ctype.h>
+#if defined(__alpha__) && defined(CCPML)
+#include <cpml.h> /* use Compaq's Fast Math Library on Alpha */
+#else
+#include <math.h>
+#endif
+#include <limits.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#if defined(__linux__) && defined(__i386__)
+#include <fpu_control.h>
+#endif
+#include <float.h>
+#include <stdarg.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Get standard integer types
+ */
+#if defined(_MSC_VER)
+   typedef __int8             int8_t;
+   typedef unsigned __int8    uint8_t;
+   typedef __int16            int16_t;
+   typedef unsigned __int16   uint16_t;
+#  ifndef __eglplatform_h_
+     typedef __int32            int32_t;
+#  endif
+   typedef unsigned __int32   uint32_t;
+   typedef __int64            int64_t;
+   typedef unsigned __int64   uint64_t;
+
+#  if defined(_WIN64)
+     typedef __int64            intptr_t;
+     typedef unsigned __int64   uintptr_t;
+#  else
+     typedef __int32            intptr_t;
+     typedef unsigned __int32   uintptr_t;
+#  endif
+
+#  define INT64_C(__val) __val##i64
+#  define UINT64_C(__val) __val##ui64
+#else
+#  include <stdint.h>
+#endif
+
+
+/**
+  * Sun compilers define __i386 instead of the gcc-style __i386__
+ */
+#ifdef __SUNPRO_C
+# if !defined(__i386__) && defined(__i386)
+#  define __i386__
+# elif !defined(__amd64__) && defined(__amd64)
+#  define __amd64__
+# elif !defined(__sparc__) && defined(__sparc)
+#  define __sparc__
+# endif
+# if !defined(__volatile)
+#  define __volatile volatile
+# endif
+#endif
+
+
+/**
+ * finite macro.
+ */
+#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__) && !defined(BUILD_FOR_SNAP)
+#  define __WIN32__
+#  define finite _finite
+#elif defined(__WATCOMC__)
+#  define finite _finite
+#endif
+
+
+/**
+ * Disable assorted warnings
+ */
+#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP)
+#  if !defined(__GNUC__) /* mingw environment */
+#    pragma warning( disable : 4068 ) /* unknown pragma */
+#    pragma warning( disable : 4710 ) /* function 'foo' not inlined */
+#    pragma warning( disable : 4711 ) /* function 'foo' selected for automatic inline expansion */
+#    pragma warning( disable : 4127 ) /* conditional expression is constant */
+#    if defined(MESA_MINWARN)
+#      pragma warning( disable : 4244 ) /* '=' : conversion from 'const double ' to 'float ', possible loss of data */
+#      pragma warning( disable : 4018 ) /* '<' : signed/unsigned mismatch */
+#      pragma warning( disable : 4305 ) /* '=' : truncation from 'const double ' to 'float ' */
+#      pragma warning( disable : 4550 ) /* 'function' undefined; assuming extern returning int */
+#      pragma warning( disable : 4761 ) /* integral size mismatch in argument; conversion supplied */
+#    endif
+#  endif
+#endif
+#if defined(__WATCOMC__)
+#  pragma disable_message(201) /* Disable unreachable code warnings */
+#endif
+
+
+
+/**
+ * Function inlining
+ */
+#if defined(__GNUC__)
+#  define INLINE __inline__
+#elif defined(__MSC__)
+#  define INLINE __inline
+#elif defined(_MSC_VER)
+#  define INLINE __inline
+#elif defined(__ICL)
+#  define INLINE __inline
+#elif defined(__INTEL_COMPILER)
+#  define INLINE inline
+#elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100)
+#  define INLINE __inline
+#elif defined(__SUNPRO_C) && defined(__C99FEATURES__)
+#  define INLINE inline
+#  define __inline inline
+#  define __inline__ inline
+#elif (__STDC_VERSION__ >= 199901L) /* C99 */
+#  define INLINE inline
+#else
+#  define INLINE
+#endif
+
+
+/**
+ * PUBLIC/USED macros
+ *
+ * If we build the library with gcc's -fvisibility=hidden flag, we'll
+ * use the PUBLIC macro to mark functions that are to be exported.
+ *
+ * We also need to define a USED attribute, so the optimizer doesn't 
+ * inline a static function that we later use in an alias. - ajax
+ */
+#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
+#  define PUBLIC __attribute__((visibility("default")))
+#  define USED __attribute__((used))
+#else
+#  define PUBLIC
+#  define USED
+#endif
+
+
+/**
+ * Some compilers don't like some of Mesa's const usage.  In those places use
+ * CONST instead of const.  Pass -DNO_CONST to compilers where this matters.
+ */
+#ifdef NO_CONST
+#  define CONST
+#else
+#  define CONST const
+#endif
+
+
+/**
+ * __builtin_expect macros
+ */
+#if (!defined(__GNUC__) || __GNUC__ < 3) && (!defined(__IBMC__) || __IBMC__ < 900)
+#  define __builtin_expect(x, y) x
+#endif
+
+
+/**
+ * The __FUNCTION__ gcc variable is generally only used for debugging.
+ * If we're not using gcc, define __FUNCTION__ as a cpp symbol here.
+ * Don't define it if using a newer Windows compiler.
+ */
+#ifndef __FUNCTION__
+# if defined(__VMS)
+#  define __FUNCTION__ "VMS$NL:"
+# elif ((!defined __GNUC__) || (__GNUC__ < 2)) && (!defined __xlC__) && \
+      (!defined(_MSC_VER) || _MSC_VER < 1300)
+#  if (__STDC_VERSION__ >= 199901L) /* C99 */ || \
+    (defined(__SUNPRO_C) && defined(__C99FEATURES__))
+#   define __FUNCTION__ __func__
+#  else
+#   define __FUNCTION__ "<unknown>"
+#  endif
+# endif
+#endif
+
+
+/**
+ * Either define MESA_BIG_ENDIAN or MESA_LITTLE_ENDIAN.
+ * Do not use them unless absolutely necessary!
+ * Try to use a runtime test instead.
+ * For now, only used by some DRI hardware drivers for color/texel packing.
+ */
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+#if defined(__linux__)
+#include <byteswap.h>
+#define CPU_TO_LE32( x )	bswap_32( x )
+#elif defined(__APPLE__)
+#include <CoreFoundation/CFByteOrder.h>
+#define CPU_TO_LE32( x )	CFSwapInt32HostToLittle( x )
+#else /*__linux__ __APPLE__*/
+#include <sys/endian.h>
+#define CPU_TO_LE32( x )	bswap32( x )
+#endif /*__linux__*/
+#define MESA_BIG_ENDIAN 1
+#else
+#define CPU_TO_LE32( x )	( x )
+#define MESA_LITTLE_ENDIAN 1
+#endif
+#define LE32_TO_CPU( x )	CPU_TO_LE32( x )
+
+
+
+#if !defined(CAPI) && defined(WIN32) && !defined(BUILD_FOR_SNAP)
+#define CAPI _cdecl
+#endif
+
+
+/**
+ * Create a macro so that asm functions can be linked into compilers other
+ * than GNU C
+ */
+#ifndef _ASMAPI
+#if defined(WIN32) && !defined(BUILD_FOR_SNAP)/* was: !defined( __GNUC__ ) && !defined( VMS ) && !defined( __INTEL_COMPILER )*/
+#define _ASMAPI __cdecl
+#else
+#define _ASMAPI
+#endif
+#ifdef	PTR_DECL_IN_FRONT
+#define	_ASMAPIP * _ASMAPI
+#else
+#define	_ASMAPIP _ASMAPI *
+#endif
+#endif
+
+#ifdef USE_X86_ASM
+#define _NORMAPI _ASMAPI
+#define _NORMAPIP _ASMAPIP
+#else
+#define _NORMAPI
+#define _NORMAPIP *
+#endif
+
+
+/* This is a macro on IRIX */
+#ifdef _P
+#undef _P
+#endif
+
+
+/* Turn off macro checking systems used by other libraries */
+#ifdef CHECK
+#undef CHECK
+#endif
+
+
+/**
+ * ASSERT macro
+ */
+#if !defined(_WIN32_WCE)
+#if defined(BUILD_FOR_SNAP) && defined(CHECKED)
+#  define ASSERT(X)   _CHECK(X) 
+#elif defined(DEBUG)
+#  define ASSERT(X)   assert(X)
+#else
+#  define ASSERT(X)
+#endif
+#endif
+
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+/**
+ * LONGSTRING macro
+ * gcc -pedantic warns about long string literals, LONGSTRING silences that.
+ */
+#if !defined(__GNUC__) || (__GNUC__ < 2) || \
+    ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7))
+# define LONGSTRING
+#else
+# define LONGSTRING __extension__
+#endif
+
+
+#ifndef M_PI
+#define M_PI (3.1415926536)
+#endif
+
+#ifndef M_E
+#define M_E (2.7182818284590452354)
+#endif
+
+#ifndef ONE_DIV_LN2
+#define ONE_DIV_LN2 (1.442695040888963456)
+#endif
+
+#ifndef ONE_DIV_SQRT_LN2
+#define ONE_DIV_SQRT_LN2 (1.201122408786449815)
+#endif
+
+#ifndef FLT_MAX_EXP
+#define FLT_MAX_EXP 128
+#endif
+
+
+/**
+ * USE_IEEE: Determine if we're using IEEE floating point
+ */
+#if defined(__i386__) || defined(__386__) || defined(__sparc__) || \
+    defined(__s390x__) || defined(__powerpc__) || \
+    defined(__x86_64__) || \
+    defined(ia64) || defined(__ia64__) || \
+    defined(__hppa__) || defined(hpux) || \
+    defined(__mips) || defined(_MIPS_ARCH) || \
+    defined(__arm__) || \
+    defined(__sh__) || defined(__m32r__) || \
+    (defined(__sun) && defined(_IEEE_754)) || \
+    (defined(__alpha__) && (defined(__IEEE_FLOAT) || !defined(VMS)))
+#define USE_IEEE
+#define IEEE_ONE 0x3f800000
+#endif
+
+
+/**
+ * START/END_FAST_MATH macros:
+ *
+ * START_FAST_MATH: Set x86 FPU to faster, 32-bit precision mode (and save
+ *                  original mode to a temporary).
+ * END_FAST_MATH: Restore x86 FPU to original mode.
+ */
+#if defined(__GNUC__) && defined(__i386__)
+/*
+ * Set the x86 FPU control word to guarentee only 32 bits of precision
+ * are stored in registers.  Allowing the FPU to store more introduces
+ * differences between situations where numbers are pulled out of memory
+ * vs. situations where the compiler is able to optimize register usage.
+ *
+ * In the worst case, we force the compiler to use a memory access to
+ * truncate the float, by specifying the 'volatile' keyword.
+ */
+/* Hardware default: All exceptions masked, extended double precision,
+ * round to nearest (IEEE compliant):
+ */
+#define DEFAULT_X86_FPU		0x037f
+/* All exceptions masked, single precision, round to nearest:
+ */
+#define FAST_X86_FPU		0x003f
+/* The fldcw instruction will cause any pending FP exceptions to be
+ * raised prior to entering the block, and we clear any pending
+ * exceptions before exiting the block.  Hence, asm code has free
+ * reign over the FPU while in the fast math block.
+ */
+#if defined(NO_FAST_MATH)
+#define START_FAST_MATH(x)						\
+do {									\
+   static GLuint mask = DEFAULT_X86_FPU;				\
+   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
+   __asm__ ( "fldcw %0" : : "m" (mask) );				\
+} while (0)
+#else
+#define START_FAST_MATH(x)						\
+do {									\
+   static GLuint mask = FAST_X86_FPU;					\
+   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
+   __asm__ ( "fldcw %0" : : "m" (mask) );				\
+} while (0)
+#endif
+/* Restore original FPU mode, and clear any exceptions that may have
+ * occurred in the FAST_MATH block.
+ */
+#define END_FAST_MATH(x)						\
+do {									\
+   __asm__ ( "fnclex ; fldcw %0" : : "m" (*&(x)) );			\
+} while (0)
+
+#elif defined(__WATCOMC__) && defined(__386__)
+#define DEFAULT_X86_FPU		0x037f /* See GCC comments above */
+#define FAST_X86_FPU		0x003f /* See GCC comments above */
+void _watcom_start_fast_math(unsigned short *x,unsigned short *mask);
+#pragma aux _watcom_start_fast_math =                                   \
+   "fnstcw  word ptr [eax]"                                             \
+   "fldcw   word ptr [ecx]"                                             \
+   parm [eax] [ecx]                                                     \
+   modify exact [];
+void _watcom_end_fast_math(unsigned short *x);
+#pragma aux _watcom_end_fast_math =                                     \
+   "fnclex"                                                             \
+   "fldcw   word ptr [eax]"                                             \
+   parm [eax]                                                           \
+   modify exact [];
+#if defined(NO_FAST_MATH)
+#define START_FAST_MATH(x)                                              \
+do {                                                                    \
+   static GLushort mask = DEFAULT_X86_FPU;	                        \
+   _watcom_start_fast_math(&x,&mask);                                   \
+} while (0)
+#else
+#define START_FAST_MATH(x)                                              \
+do {                                                                    \
+   static GLushort mask = FAST_X86_FPU;                                 \
+   _watcom_start_fast_math(&x,&mask);                                   \
+} while (0)
+#endif
+#define END_FAST_MATH(x)  _watcom_end_fast_math(&x)
+
+#elif defined(_MSC_VER) && defined(_M_IX86)
+#define DEFAULT_X86_FPU		0x037f /* See GCC comments above */
+#define FAST_X86_FPU		0x003f /* See GCC comments above */
+#if defined(NO_FAST_MATH)
+#define START_FAST_MATH(x) do {\
+	static GLuint mask = DEFAULT_X86_FPU;\
+	__asm fnstcw word ptr [x]\
+	__asm fldcw word ptr [mask]\
+} while(0)
+#else
+#define START_FAST_MATH(x) do {\
+	static GLuint mask = FAST_X86_FPU;\
+	__asm fnstcw word ptr [x]\
+	__asm fldcw word ptr [mask]\
+} while(0)
+#endif
+#define END_FAST_MATH(x) do {\
+	__asm fnclex\
+	__asm fldcw word ptr [x]\
+} while(0)
+
+#else
+#define START_FAST_MATH(x)  x = 0
+#define END_FAST_MATH(x)  (void)(x)
+#endif
+
+
+#ifndef Elements
+#define Elements(x) (sizeof(x)/sizeof(*(x)))
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* COMPILER_H */
diff --git a/src/mesa/main/config.h b/src/mesa/main/config.h
index cf1198cd0d..8a09efdb53 100644
--- a/src/mesa/main/config.h
+++ b/src/mesa/main/config.h
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.5
  *
  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
@@ -32,9 +32,6 @@
 #define MESA_CONFIG_H_INCLUDED
 
 
-#include "main/mfeatures.h"
-
-
 /**
  * \name OpenGL implementation limits
  */
@@ -71,7 +68,7 @@
 #define MAX_PIXEL_MAP_TABLE 256
 
 /** Maximum number of auxillary color buffers */
-#define MAX_AUX_BUFFERS 4
+#define MAX_AUX_BUFFERS 1
 
 /** Maximum order (degree) of curves */
 #ifdef AMIGA
@@ -101,16 +98,16 @@
 #define MAX_COLOR_TABLE_SIZE 256
 
 /** Number of 1D/2D texture mipmap levels */
-#define MAX_TEXTURE_LEVELS 12
+#define MAX_TEXTURE_LEVELS 13
 
 /** Number of 3D texture mipmap levels */
 #define MAX_3D_TEXTURE_LEVELS 9
 
 /** Number of cube texture mipmap levels - GL_ARB_texture_cube_map */
-#define MAX_CUBE_TEXTURE_LEVELS 12
+#define MAX_CUBE_TEXTURE_LEVELS 13
 
 /** Maximum rectangular texture size - GL_NV_texture_rectangle */
-#define MAX_TEXTURE_RECT_SIZE 2048
+#define MAX_TEXTURE_RECT_SIZE 4096
 
 /** Maximum number of layers in a 1D or 2D array texture - GL_MESA_texture_array */
 #define MAX_ARRAY_TEXTURE_LAYERS 64
@@ -141,9 +138,14 @@
 /** 
  * Maximum viewport/image width. Must accomodate all texture sizes too. 
  */
-#define MAX_WIDTH 4096
+
+#ifndef MAX_WIDTH
+#   define MAX_WIDTH 4096
+#endif
 /** Maximum viewport/image height */
-#define MAX_HEIGHT 4096
+#ifndef MAX_HEIGHT
+#   define MAX_HEIGHT 4096
+#endif
 
 /** Maxmimum size for CVA.  May be overridden by the drivers.  */
 #define MAX_ARRAY_LOCK_SIZE 3000
@@ -166,43 +168,62 @@
 #define MAX_TEXTURE_MAX_ANISOTROPY 16.0
 
 /** For GL_EXT_texture_lod_bias (typically MAX_TEXTURE_LEVELS - 1) */
-#define MAX_TEXTURE_LOD_BIAS 11.0
+#define MAX_TEXTURE_LOD_BIAS 12.0
+
+/** For any program target/extension */
+/*@{*/
+#define MAX_PROGRAM_INSTRUCTIONS       (16 * 1024)
+
+/**
+ * Per-program constants (power of two)
+ *
+ * \c MAX_PROGRAM_LOCAL_PARAMS and \c MAX_UNIFORMS are just the assmebly shader
+ * and GLSL shader names for the same thing.  They should \b always have the
+ * same value.  Each refers to the number of vec4 values supplied as
+ * per-program parameters.
+ */
+/*@{*/
+#define MAX_PROGRAM_LOCAL_PARAMS       1024
+#define MAX_UNIFORMS                   1024
+/*@}*/
+
+/**
+ * Per-context constants (power of two)
+ *
+ * \note
+ * This value should always be less than or equal to \c MAX_PROGRAM_LOCAL_PARAMS
+ * and \c MAX_VERTEX_PROGRAM_PARAMS.  Otherwise some applications will make
+ * incorrect assumptions.
+ */
+#define MAX_PROGRAM_ENV_PARAMS         256
+
+#define MAX_PROGRAM_MATRICES           8
+#define MAX_PROGRAM_MATRIX_STACK_DEPTH 4
+#define MAX_PROGRAM_CALL_DEPTH         8
+#define MAX_PROGRAM_TEMPS              256
+#define MAX_PROGRAM_ADDRESS_REGS       2
+#define MAX_VARYING                    16    /**< number of float[4] vectors */
+#define MAX_SAMPLERS                   MAX_TEXTURE_IMAGE_UNITS
+#define MAX_PROGRAM_INPUTS             32
+#define MAX_PROGRAM_OUTPUTS            32
+/*@}*/
 
 /** For GL_ARB_vertex_program */
 /*@{*/
 #define MAX_VERTEX_PROGRAM_ADDRESS_REGS 1
-#define MAX_VERTEX_PROGRAM_ATTRIBS     16
+#define MAX_VERTEX_PROGRAM_PARAMS       MAX_UNIFORMS
 /*@}*/
 
 /** For GL_ARB_fragment_program */
 /*@{*/
 #define MAX_FRAGMENT_PROGRAM_ADDRESS_REGS 0
-#define MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS 48
-#define MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS 24
-#define MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS  4
-/*@}*/
-
-/** For any program target/extension */
-/*@{*/
-#define MAX_PROGRAM_LOCAL_PARAMS 256 /**< per-program constants (power of two) */
-#define MAX_PROGRAM_ENV_PARAMS 128
-#define MAX_PROGRAM_MATRICES 8
-#define MAX_PROGRAM_MATRIX_STACK_DEPTH 4
-#define MAX_PROGRAM_CALL_DEPTH 8
-#define MAX_PROGRAM_TEMPS 128
-#define MAX_PROGRAM_ADDRESS_REGS 2
-#define MAX_UNIFORMS 256   /**< number of vec4 uniforms */
-#define MAX_VARYING 8      /**< number of float[4] vectors */
-#define MAX_SAMPLERS MAX_TEXTURE_IMAGE_UNITS
-#define MAX_PROGRAM_INPUTS 32
-#define MAX_PROGRAM_OUTPUTS 32
 /*@}*/
 
 /** For GL_NV_vertex_program */
 /*@{*/
 #define MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS 128
 #define MAX_NV_VERTEX_PROGRAM_TEMPS         12
-#define MAX_NV_VERTEX_PROGRAM_PARAMS        MAX_PROGRAM_ENV_PARAMS
+#define MAX_NV_VERTEX_PROGRAM_PARAMS        96
 #define MAX_NV_VERTEX_PROGRAM_INPUTS        16
 #define MAX_NV_VERTEX_PROGRAM_OUTPUTS       15
 /*@}*/
@@ -220,7 +241,7 @@
 
 /** For GL_ARB_vertex_shader */
 /*@{*/
-#define MAX_VERTEX_ATTRIBS 16
+#define MAX_VERTEX_GENERIC_ATTRIBS 16
 #define MAX_VERTEX_TEXTURE_IMAGE_UNITS MAX_TEXTURE_IMAGE_UNITS
 #define MAX_COMBINED_TEXTURE_IMAGE_UNITS MAX_TEXTURE_IMAGE_UNITS
 /*@}*/
@@ -237,7 +258,8 @@
 #define MAX_COLOR_ATTACHMENTS 8
 /*@}*/
 
-
+/** For GL_ATI_envmap_bump - support bump mapping on first 8 units */
+#define SUPPORTED_ATI_BUMP_UNITS 0xff
 
 /**
  * \name Mesa-specific parameters
diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 98c23bbd3a..4e637ff44b 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -77,42 +77,30 @@
 
 
 #include "glheader.h"
+#include "mfeatures.h"
 #include "imports.h"
-#if FEATURE_accum
 #include "accum.h"
-#endif
 #include "api_exec.h"
 #include "arrayobj.h"
-#if FEATURE_attrib_stack
 #include "attrib.h"
-#endif
 #include "blend.h"
 #include "buffers.h"
 #include "bufferobj.h"
-#if FEATURE_colortable
 #include "colortab.h"
-#endif
 #include "context.h"
+#include "cpuinfo.h"
 #include "debug.h"
 #include "depth.h"
-#if FEATURE_dlist
 #include "dlist.h"
-#endif
-#if FEATURE_evaluators
 #include "eval.h"
-#endif
 #include "enums.h"
 #include "extensions.h"
 #include "fbobject.h"
-#if FEATURE_feedback
 #include "feedback.h"
-#endif
 #include "fog.h"
 #include "framebuffer.h"
 #include "get.h"
-#if FEATURE_histogram
 #include "histogram.h"
-#endif
 #include "hint.h"
 #include "hash.h"
 #include "light.h"
@@ -124,13 +112,13 @@
 #include "pixelstore.h"
 #include "points.h"
 #include "polygon.h"
-#if FEATURE_ARB_occlusion_query
 #include "queryobj.h"
+#if FEATURE_ARB_sync
+#include "syncobj.h"
 #endif
-#if FEATURE_drawpix
 #include "rastpos.h"
-#endif
 #include "scissor.h"
+#include "shared.h"
 #include "simple_list.h"
 #include "state.h"
 #include "stencil.h"
@@ -141,22 +129,19 @@
 #include "mtypes.h"
 #include "varray.h"
 #include "version.h"
+#include "viewport.h"
 #include "vtxfmt.h"
 #include "glapi/glthread.h"
 #include "glapi/glapioffsets.h"
 #include "glapi/glapitable.h"
-#if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 #include "shader/program.h"
-#endif
+#include "shader/prog_print.h"
 #include "shader/shader_api.h"
 #if FEATURE_ATI_fragment_shader
 #include "shader/atifragshader.h"
 #endif
 #if _HAVE_FULL_GL
-#include "math/m_translate.h"
 #include "math/m_matrix.h"
-#include "math/m_xform.h"
-#include "math/mathmod.h"
 #endif
 
 #ifdef USE_SPARC_ASM
@@ -180,15 +165,18 @@ GLfloat _mesa_ubyte_to_float_color_tab[256];
 /**
  * Swap buffers notification callback.
  * 
- * \param gc GL context.
+ * \param ctx GL context.
  *
  * Called by window system just before swapping buffers.
  * We have to finish any pending rendering.
  */
 void
-_mesa_notifySwapBuffers(__GLcontext *gc)
+_mesa_notifySwapBuffers(__GLcontext *ctx)
 {
-   FLUSH_VERTICES( gc, 0 );
+   FLUSH_CURRENT( ctx, 0 );
+   if (ctx->Driver.Flush) {
+      ctx->Driver.Flush(ctx);
+   }
 }
 
 
@@ -352,6 +340,36 @@ _mesa_destroy_visual( GLvisual *vis )
 /**********************************************************************/
 /*@{*/
 
+
+/**
+ * This is lame.  gdb only seems to recognize enum types that are
+ * actually used somewhere.  We want to be able to print/use enum
+ * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
+ * the gl_texture_index type anywhere.  Thus, this lame function.
+ */
+static void
+dummy_enum_func(void)
+{
+   gl_buffer_index bi;
+   gl_colortable_index ci;
+   gl_face_index fi;
+   gl_frag_attrib fa;
+   gl_frag_result fr;
+   gl_texture_index ti;
+   gl_vert_attrib va;
+   gl_vert_result vr;
+
+   (void) bi;
+   (void) ci;
+   (void) fi;
+   (void) fa;
+   (void) fr;
+   (void) ti;
+   (void) va;
+   (void) vr;
+}
+
+
 /**
  * One-time initialization mutex lock.
  *
@@ -385,19 +403,14 @@ one_time_init( GLcontext *ctx )
       assert( sizeof(GLint) == 4 );
       assert( sizeof(GLuint) == 4 );
 
-      _mesa_init_sqrt_table();
+      _mesa_get_cpu_features();
 
-#if _HAVE_FULL_GL
-      _math_init();
+      _mesa_init_sqrt_table();
 
       for (i = 0; i < 256; i++) {
          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
       }
-#endif
 
-#ifdef USE_SPARC_ASM
-      _mesa_init_sparc_glapi_relocs();
-#endif
       if (_mesa_getenv("MESA_DEBUG")) {
          _glapi_noop_enable_warnings(GL_TRUE);
          _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
@@ -414,383 +427,8 @@ one_time_init( GLcontext *ctx )
       alreadyCalled = GL_TRUE;
    }
    _glthread_UNLOCK_MUTEX(OneTimeLock);
-}
-
-
-/**
- * Allocate and initialize a shared context state structure.
- * Initializes the display list, texture objects and vertex programs hash
- * tables, allocates the texture objects. If it runs out of memory, frees
- * everything already allocated before returning NULL.
- *
- * \return pointer to a gl_shared_state structure on success, or NULL on
- * failure.
- */
-static GLboolean
-alloc_shared_state( GLcontext *ctx )
-{
-   struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
-   if (!ss)
-      return GL_FALSE;
-
-   ctx->Shared = ss;
-
-   _glthread_INIT_MUTEX(ss->Mutex);
-
-   ss->DisplayList = _mesa_NewHashTable();
-   ss->TexObjects = _mesa_NewHashTable();
-   ss->Programs = _mesa_NewHashTable();
-
-#if FEATURE_ARB_vertex_program
-   ss->DefaultVertexProgram = (struct gl_vertex_program *)
-      ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
-   if (!ss->DefaultVertexProgram)
-      goto cleanup;
-#endif
-#if FEATURE_ARB_fragment_program
-   ss->DefaultFragmentProgram = (struct gl_fragment_program *)
-      ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!ss->DefaultFragmentProgram)
-      goto cleanup;
-#endif
-#if FEATURE_ATI_fragment_shader
-   ss->ATIShaders = _mesa_NewHashTable();
-   ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
-   if (!ss->DefaultFragmentShader)
-      goto cleanup;
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
-   ss->BufferObjects = _mesa_NewHashTable();
-#endif
-
-   ss->ArrayObjects = _mesa_NewHashTable();
-
-#if FEATURE_ARB_shader_objects
-   ss->ShaderObjects = _mesa_NewHashTable();
-#endif
-
-   ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
-   if (!ss->Default1D)
-      goto cleanup;
-
-   ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
-   if (!ss->Default2D)
-      goto cleanup;
-
-   ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
-   if (!ss->Default3D)
-      goto cleanup;
-
-   ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
-   if (!ss->DefaultCubeMap)
-      goto cleanup;
-
-   ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
-   if (!ss->DefaultRect)
-      goto cleanup;
-
-   ss->Default1DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D_ARRAY_EXT);
-   if (!ss->Default1DArray)
-      goto cleanup;
-
-   ss->Default2DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D_ARRAY_EXT);
-   if (!ss->Default2DArray)
-      goto cleanup;
-
-   /* sanity check */
-   assert(ss->Default1D->RefCount == 1);
-
-   _glthread_INIT_MUTEX(ss->TexMutex);
-   ss->TextureStateStamp = 0;
-
-#if FEATURE_EXT_framebuffer_object
-   ss->FrameBuffers = _mesa_NewHashTable();
-   if (!ss->FrameBuffers)
-      goto cleanup;
-   ss->RenderBuffers = _mesa_NewHashTable();
-   if (!ss->RenderBuffers)
-      goto cleanup;
-#endif
-
-   return GL_TRUE;
-
-cleanup:
-   /* Ran out of memory at some point.  Free everything and return NULL */
-   if (ss->DisplayList)
-      _mesa_DeleteHashTable(ss->DisplayList);
-   if (ss->TexObjects)
-      _mesa_DeleteHashTable(ss->TexObjects);
-   if (ss->Programs)
-      _mesa_DeleteHashTable(ss->Programs);
-#if FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL);
-#endif
-#if FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL);
-#endif
-#if FEATURE_ATI_fragment_shader
-   if (ss->DefaultFragmentShader)
-      _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
-#endif
-#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
-   if (ss->BufferObjects)
-      _mesa_DeleteHashTable(ss->BufferObjects);
-#endif
-
-   if (ss->ArrayObjects)
-      _mesa_DeleteHashTable (ss->ArrayObjects);
-
-#if FEATURE_ARB_shader_objects
-   if (ss->ShaderObjects)
-      _mesa_DeleteHashTable (ss->ShaderObjects);
-#endif
-
-#if FEATURE_EXT_framebuffer_object
-   if (ss->FrameBuffers)
-      _mesa_DeleteHashTable(ss->FrameBuffers);
-   if (ss->RenderBuffers)
-      _mesa_DeleteHashTable(ss->RenderBuffers);
-#endif
-
-   if (ss->Default1D)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
-   if (ss->Default2D)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
-   if (ss->Default3D)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
-   if (ss->DefaultCubeMap)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
-   if (ss->DefaultRect)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
-   if (ss->Default1DArray)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->Default1DArray);
-   if (ss->Default2DArray)
-      (*ctx->Driver.DeleteTexture)(ctx, ss->Default2DArray);
-
-   _mesa_free(ss);
-
-   return GL_FALSE;
-}
-
-
-/**
- * Callback for deleting a display list.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_displaylist_cb(GLuint id, void *data, void *userData)
-{
-#if FEATURE_dlist
-   struct mesa_display_list *list = (struct mesa_display_list *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   _mesa_delete_list(ctx, list);
-#endif
-}
-
-/**
- * Callback for deleting a texture object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_texture_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_texture_object *texObj = (struct gl_texture_object *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   ctx->Driver.DeleteTexture(ctx, texObj);
-}
-
-/**
- * Callback for deleting a program object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_program_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_program *prog = (struct gl_program *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */
-   prog->RefCount = 0;  /* now going away */
-   ctx->Driver.DeleteProgram(ctx, prog);
-}
-
-/**
- * Callback for deleting an ATI fragment shader object.
- * Called by _mesa_HashDeleteAll().
- */
-static void
-delete_fragshader_cb(GLuint id, void *data, void *userData)
-{
-   struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   _mesa_delete_ati_fragment_shader(ctx, shader);
-}
-
-/**
- * Callback for deleting a buffer object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_bufferobj_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   ctx->Driver.DeleteBuffer(ctx, bufObj);
-}
-
-/**
- * Callback for deleting an array object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_arrayobj_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_array_object *arrayObj = (struct gl_array_object *) data;
-   GLcontext *ctx = (GLcontext *) userData;
-   _mesa_delete_array_object(ctx, arrayObj);
-}
-
-/**
- * Callback for freeing shader program data. Call it before delete_shader_cb
- * to avoid memory access error.
- */
-static void
-free_shader_program_data_cb(GLuint id, void *data, void *userData)
-{
-   GLcontext *ctx = (GLcontext *) userData;
-   struct gl_shader_program *shProg = (struct gl_shader_program *) data;
-
-   if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
-       _mesa_free_shader_program_data(ctx, shProg);
-   }
-}
-
-/**
- * Callback for deleting shader and shader programs objects.
- * Called by _mesa_HashDeleteAll().
- */
-static void
-delete_shader_cb(GLuint id, void *data, void *userData)
-{
-   GLcontext *ctx = (GLcontext *) userData;
-   struct gl_shader *sh = (struct gl_shader *) data;
-   if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
-      _mesa_free_shader(ctx, sh);
-   }
-   else {
-      struct gl_shader_program *shProg = (struct gl_shader_program *) data;
-      ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
-      _mesa_free_shader_program(ctx, shProg);
-   }
-}
-
-/**
- * Callback for deleting a framebuffer object.  Called by _mesa_HashDeleteAll()
- */
-static void
-delete_framebuffer_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
-   /* The fact that the framebuffer is in the hashtable means its refcount
-    * is one, but we're removing from the hashtable now.  So clear refcount.
-    */
-   /*assert(fb->RefCount == 1);*/
-   fb->RefCount = 0;
 
-   /* NOTE: Delete should always be defined but there are two reports
-    * of it being NULL (bugs 13507, 14293).  Work-around for now.
-    */
-   if (fb->Delete)
-      fb->Delete(fb);
-}
-
-/**
- * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll()
- */
-static void
-delete_renderbuffer_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
-   rb->RefCount = 0;  /* see comment for FBOs above */
-   if (rb->Delete)
-      rb->Delete(rb);
-}
-
-
-
-/**
- * Deallocate a shared state object and all children structures.
- *
- * \param ctx GL context.
- * \param ss shared state pointer.
- * 
- * Frees the display lists, the texture objects (calling the driver texture
- * deletion callback to free its private data) and the vertex programs, as well
- * as their hash tables.
- *
- * \sa alloc_shared_state().
- */
-static void
-free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
-{
-   /*
-    * Free display lists
-    */
-   _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx);
-   _mesa_DeleteHashTable(ss->DisplayList);
-
-#if FEATURE_ARB_shader_objects
-   _mesa_HashWalk(ss->ShaderObjects, free_shader_program_data_cb, ctx);
-   _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx);
-   _mesa_DeleteHashTable(ss->ShaderObjects);
-#endif
-
-   _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx);
-   _mesa_DeleteHashTable(ss->Programs);
-
-#if FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ss->DefaultVertexProgram, NULL);
-#endif
-#if FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ss->DefaultFragmentProgram, NULL);
-#endif
-
-#if FEATURE_ATI_fragment_shader
-   _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx);
-   _mesa_DeleteHashTable(ss->ATIShaders);
-   _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
-   _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx);
-   _mesa_DeleteHashTable(ss->BufferObjects);
-#endif
-
-   _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx);
-   _mesa_DeleteHashTable(ss->ArrayObjects);
-
-#if FEATURE_EXT_framebuffer_object
-   _mesa_HashDeleteAll(ss->FrameBuffers, delete_framebuffer_cb, ctx);
-   _mesa_DeleteHashTable(ss->FrameBuffers);
-   _mesa_HashDeleteAll(ss->RenderBuffers, delete_renderbuffer_cb, ctx);
-   _mesa_DeleteHashTable(ss->RenderBuffers);
-#endif
-
-   /*
-    * Free texture objects (after FBOs since some textures might have
-    * been bound to FBOs).
-    */
-   ASSERT(ctx->Driver.DeleteTexture);
-   /* the default textures */
-   ctx->Driver.DeleteTexture(ctx, ss->Default1D);
-   ctx->Driver.DeleteTexture(ctx, ss->Default2D);
-   ctx->Driver.DeleteTexture(ctx, ss->Default3D);
-   ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap);
-   ctx->Driver.DeleteTexture(ctx, ss->DefaultRect);
-   ctx->Driver.DeleteTexture(ctx, ss->Default1DArray);
-   ctx->Driver.DeleteTexture(ctx, ss->Default2DArray);
-   /* all other textures */
-   _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx);
-   _mesa_DeleteHashTable(ss->TexObjects);
-
-   _glthread_DESTROY_MUTEX(ss->Mutex);
-
-   _mesa_free(ss);
+   dummy_enum_func();
 }
 
 
@@ -803,7 +441,7 @@ _mesa_init_current(GLcontext *ctx)
    GLuint i;
 
    /* Init all to (0,0,0,1) */
-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
+   for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
    }
 
@@ -818,19 +456,43 @@ _mesa_init_current(GLcontext *ctx)
 
 
 /**
- * Init vertex/fragment program native limits from logical limits.
+ * Init vertex/fragment program limits.
+ * Important: drivers should override these with actual limits.
  */
 static void
-init_natives(struct gl_program_constants *prog)
+init_program_limits(GLenum type, struct gl_program_constants *prog)
 {
-   prog->MaxNativeInstructions = prog->MaxInstructions;
-   prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
-   prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
-   prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
-   prog->MaxNativeAttribs = prog->MaxAttribs;
-   prog->MaxNativeTemps = prog->MaxTemps;
-   prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
-   prog->MaxNativeParameters = prog->MaxParameters;
+   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
+   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
+   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
+   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
+   prog->MaxTemps = MAX_PROGRAM_TEMPS;
+   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
+   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
+   prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
+
+   if (type == GL_VERTEX_PROGRAM_ARB) {
+      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
+      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
+      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
+   }
+   else {
+      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
+      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
+      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
+   }
+
+   /* Set the native limits to zero.  This implies that there is no native
+    * support for shaders.  Let the drivers fill in the actual values.
+    */
+   prog->MaxNativeInstructions = 0;
+   prog->MaxNativeAluInstructions = 0;
+   prog->MaxNativeTexInstructions = 0;
+   prog->MaxNativeTexIndirections = 0;
+   prog->MaxNativeAttribs = 0;
+   prog->MaxNativeTemps = 0;
+   prog->MaxNativeAddressRegs = 0;
+   prog->MaxNativeParameters = 0;
 }
 
 
@@ -847,6 +509,9 @@ _mesa_init_constants(GLcontext *ctx)
    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 
+   /* Max texture size should be <= max viewport size (render to texture) */
+   assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
+
    /* Constants, may be overriden (usually only reduced) by device drivers */
    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
@@ -881,33 +546,10 @@ _mesa_init_constants(GLcontext *ctx)
    ctx->Const.MaxViewportWidth = MAX_WIDTH;
    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 #if FEATURE_ARB_vertex_program
-   ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
-   ctx->Const.VertexProgram.MaxAluInstructions = 0;
-   ctx->Const.VertexProgram.MaxTexInstructions = 0;
-   ctx->Const.VertexProgram.MaxTexIndirections = 0;
-   ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
-   ctx->Const.VertexProgram.MaxTemps = MAX_PROGRAM_TEMPS;
-   ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
-   ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
-   ctx->Const.VertexProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
-   ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
-   ctx->Const.VertexProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
-   init_natives(&ctx->Const.VertexProgram);
+   init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
 #endif
-
 #if FEATURE_ARB_fragment_program
-   ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
-   ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
-   ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
-   ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
-   ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
-   ctx->Const.FragmentProgram.MaxTemps = MAX_PROGRAM_TEMPS;
-   ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
-   ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
-   ctx->Const.FragmentProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
-   ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
-   ctx->Const.FragmentProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
-   init_natives(&ctx->Const.FragmentProgram);
+   init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
 #endif
    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
@@ -932,6 +574,18 @@ _mesa_init_constants(GLcontext *ctx)
    ctx->Const.MaxVarying = MAX_VARYING;
 #endif
 
+   /* GL_ARB_framebuffer_object */
+   ctx->Const.MaxSamples = 0;
+
+   /* GL_ARB_sync */
+   ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
+
+   /* GL_ATI_envmap_bumpmap */
+   ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
+
+   /* GL_EXT_provoking_vertex */
+   ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
+
    /* sanity checks */
    ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
                                              ctx->Const.MaxTextureCoordUnits));
@@ -942,6 +596,10 @@ _mesa_init_constants(GLcontext *ctx)
    ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
    ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
    ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
+
+   /* check that we don't exceed various 32-bit bitfields */
+   ASSERT(VERT_RESULT_MAX <= 32);
+   ASSERT(FRAG_ATTRIB_MAX <= 32);
 }
 
 
@@ -963,13 +621,18 @@ check_context_limits(GLcontext *ctx)
    /* number of coord units cannot be greater than number of image units */
    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
 
-   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
-   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
+   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
+   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
+   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
+   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
 
    /* make sure largest texture image is <= MAX_WIDTH in size */
-   assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH);
+   assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
+   assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
+   assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
+
+   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
+   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
 
    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 
@@ -997,36 +660,20 @@ init_attrib_groups(GLcontext *ctx)
    _mesa_init_extensions( ctx );
 
    /* Attribute Groups */
-#if FEATURE_accum
    _mesa_init_accum( ctx );
-#endif
-#if FEATURE_attrib_stack
    _mesa_init_attrib( ctx );
-#endif
    _mesa_init_buffer_objects( ctx );
    _mesa_init_color( ctx );
-#if FEATURE_colortable
    _mesa_init_colortables( ctx );
-#endif
    _mesa_init_current( ctx );
    _mesa_init_depth( ctx );
    _mesa_init_debug( ctx );
-#if FEATURE_dlist
    _mesa_init_display_list( ctx );
-#endif
-#if FEATURE_evaluators
    _mesa_init_eval( ctx );
-#endif
    _mesa_init_fbobjects( ctx );
-#if FEATURE_feedback
    _mesa_init_feedback( ctx );
-#else
-   ctx->RenderMode = GL_RENDER;
-#endif
    _mesa_init_fog( ctx );
-#if FEATURE_histogram
    _mesa_init_histogram( ctx );
-#endif
    _mesa_init_hint( ctx );
    _mesa_init_line( ctx );
    _mesa_init_lighting( ctx );
@@ -1037,12 +684,11 @@ init_attrib_groups(GLcontext *ctx)
    _mesa_init_point( ctx );
    _mesa_init_polygon( ctx );
    _mesa_init_program( ctx );
-#if FEATURE_ARB_occlusion_query
-   _mesa_init_query( ctx );
+   _mesa_init_queryobj( ctx );
+#if FEATURE_ARB_sync
+   _mesa_init_sync( ctx );
 #endif
-#if FEATURE_drawpix
    _mesa_init_rastpos( ctx );
-#endif
    _mesa_init_scissor( ctx );
    _mesa_init_shader_state( ctx );
    _mesa_init_stencil( ctx );
@@ -1053,16 +699,13 @@ init_attrib_groups(GLcontext *ctx)
    if (!_mesa_init_texture( ctx ))
       return GL_FALSE;
 
-#if FEATURE_texture_s3tc
    _mesa_init_texture_s3tc( ctx );
-#endif
-#if FEATURE_texture_fxt1
    _mesa_init_texture_fxt1( ctx );
-#endif
 
    /* Miscellaneous */
    ctx->NewState = _NEW_ALL;
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
+   ctx->varying_vp_inputs = ~0;
 
    return GL_TRUE;
 }
@@ -1162,7 +805,9 @@ _mesa_initialize_context(GLcontext *ctx,
                          const struct dd_function_table *driverFunctions,
                          void *driverContext)
 {
-   ASSERT(driverContext);
+   struct gl_shared_state *shared;
+
+   /*ASSERT(driverContext);*/
    assert(driverFunctions->NewTextureObject);
    assert(driverFunctions->FreeTexImageData);
 
@@ -1185,20 +830,22 @@ _mesa_initialize_context(GLcontext *ctx,
 
    if (share_list) {
       /* share state with another context */
-      ctx->Shared = share_list->Shared;
+      shared = share_list->Shared;
    }
    else {
       /* allocate new, unshared state */
-      if (!alloc_shared_state( ctx )) {
+      shared = _mesa_alloc_shared_state(ctx);
+      if (!shared)
          return GL_FALSE;
-      }
    }
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-   ctx->Shared->RefCount++;
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+   _glthread_LOCK_MUTEX(shared->Mutex);
+   ctx->Shared = shared;
+   shared->RefCount++;
+   _glthread_UNLOCK_MUTEX(shared->Mutex);
 
    if (!init_attrib_groups( ctx )) {
-      free_shared_state(ctx, ctx->Shared);
+      _mesa_free_shared_state(ctx, ctx->Shared);
       return GL_FALSE;
    }
 
@@ -1206,7 +853,7 @@ _mesa_initialize_context(GLcontext *ctx,
    ctx->Exec = alloc_dispatch_table();
    ctx->Save = alloc_dispatch_table();
    if (!ctx->Exec || !ctx->Save) {
-      free_shared_state(ctx, ctx->Shared);
+      _mesa_free_shared_state(ctx, ctx->Shared);
       if (ctx->Exec)
          _mesa_free(ctx->Exec);
    }
@@ -1214,10 +861,10 @@ _mesa_initialize_context(GLcontext *ctx,
    _mesa_init_exec_table(ctx->Exec);
 #endif
    ctx->CurrentDispatch = ctx->Exec;
-#if FEATURE_dlist
-   _mesa_init_dlist_table(ctx->Save);
+
+   _mesa_init_save_table(ctx->Save);
    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-#endif
+
    /* Neutral tnl module stuff */
    _mesa_init_exec_vtxfmt( ctx ); 
    ctx->TnlModule.Current = NULL;
@@ -1253,7 +900,7 @@ _mesa_initialize_context(GLcontext *ctx,
  * \param share_list another context to share display lists with or NULL
  * \param driverFunctions points to the dd_function_table into which the
  *        driver has plugged in all its special functions.
- * \param driverCtx points to the device driver's private context state
+ * \param driverContext points to the device driver's private context state
  * 
  * \return pointer to a new __GLcontextRec or NULL if error.
  */
@@ -1266,7 +913,7 @@ _mesa_create_context(const GLvisual *visual,
    GLcontext *ctx;
 
    ASSERT(visual);
-   ASSERT(driverContext);
+   /*ASSERT(driverContext);*/
 
    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
    if (!ctx)
@@ -1293,6 +940,8 @@ _mesa_create_context(const GLvisual *visual,
 void
 _mesa_free_context_data( GLcontext *ctx )
 {
+   GLint RefCount;
+
    if (!_mesa_get_current_context()){
       /* No current context, but we may need one in order to delete
        * texture objs, etc.  So temporarily bind the context now.
@@ -1301,10 +950,10 @@ _mesa_free_context_data( GLcontext *ctx )
    }
 
    /* unreference WinSysDraw/Read buffers */
-   _mesa_unreference_framebuffer(&ctx->WinSysDrawBuffer);
-   _mesa_unreference_framebuffer(&ctx->WinSysReadBuffer);
-   _mesa_unreference_framebuffer(&ctx->DrawBuffer);
-   _mesa_unreference_framebuffer(&ctx->ReadBuffer);
+   _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
+   _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
+   _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
+   _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
 
    _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
@@ -1316,25 +965,30 @@ _mesa_free_context_data( GLcontext *ctx )
 
    _mesa_free_attrib_data(ctx);
    _mesa_free_lighting_data( ctx );
-#if FEATURE_evaluators
    _mesa_free_eval_data( ctx );
-#endif
    _mesa_free_texture_data( ctx );
    _mesa_free_matrix_data( ctx );
    _mesa_free_viewport_data( ctx );
-#if FEATURE_colortable
    _mesa_free_colortables_data( ctx );
-#endif
    _mesa_free_program_data(ctx);
    _mesa_free_shader_state(ctx);
-#if FEATURE_ARB_occlusion_query
-   _mesa_free_query_data(ctx);
+   _mesa_free_queryobj_data(ctx);
+#if FEATURE_ARB_sync
+   _mesa_free_sync_data(ctx);
+#endif
+   _mesa_free_varray_data(ctx);
+
+   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
+
+#if FEATURE_ARB_pixel_buffer_object
+   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
 #endif
 
 #if FEATURE_ARB_vertex_buffer_object
-   _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
 #endif
-   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
 
    /* free dispatch tables */
    _mesa_free(ctx->Exec);
@@ -1342,12 +996,12 @@ _mesa_free_context_data( GLcontext *ctx )
 
    /* Shared context state (display lists, textures, etc) */
    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-   ctx->Shared->RefCount--;
-   assert(ctx->Shared->RefCount >= 0);
+   RefCount = --ctx->Shared->RefCount;
    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-   if (ctx->Shared->RefCount == 0) {
+   assert(RefCount >= 0);
+   if (RefCount == 0) {
       /* free shared state */
-      free_shared_state( ctx, ctx->Shared );
+      _mesa_free_shared_state( ctx, ctx->Shared );
    }
 
    if (ctx->Extensions.String)
@@ -1571,6 +1225,24 @@ initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
 
 
 /**
+ * Check if the viewport/scissor size has not yet been initialized.
+ * Initialize the size if the given width and height are non-zero.
+ */
+void
+_mesa_check_init_viewport(GLcontext *ctx, GLuint width, GLuint height)
+{
+   if (!ctx->ViewportInitialized && width > 0 && height > 0) {
+      /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
+       * potential infinite recursion.
+       */
+      ctx->ViewportInitialized = GL_TRUE;
+      _mesa_set_viewport(ctx, 0, 0, width, height);
+      _mesa_set_scissor(ctx, 0, 0, width, height);
+   }
+}
+
+
+/**
  * Bind the given context to the given drawBuffer and readBuffer and
  * make it the current context for the calling thread.
  * We'll render into the drawBuffer and read pixels from the
@@ -1584,7 +1256,7 @@ initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
  * \param drawBuffer  the drawing framebuffer
  * \param readBuffer  the reading framebuffer
  */
-void
+GLboolean
 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
                     GLframebuffer *readBuffer )
 {
@@ -1597,14 +1269,14 @@ _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
       if (!check_compatible(newCtx, drawBuffer)) {
          _mesa_warning(newCtx,
               "MakeCurrent: incompatible visuals for context and drawbuffer");
-         return;
+         return GL_FALSE;
       }
    }
    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
       if (!check_compatible(newCtx, readBuffer)) {
          _mesa_warning(newCtx,
               "MakeCurrent: incompatible visuals for context and readbuffer");
-         return;
+         return GL_FALSE;
       }
    }
 
@@ -1631,7 +1303,22 @@ _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
           * or not bound to a user-created FBO.
           */
          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
+            /* KW: merge conflict here, revisit. 
+             */
+            /* fix up the fb fields - these will end up wrong otherwise
+             * if the DRIdrawable changes, and everything relies on them.
+             * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
+             */
+            unsigned int i;
+            GLenum buffers[MAX_DRAW_BUFFERS];
+
             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
+
+            for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
+               buffers[i] = newCtx->Color.DrawBuffer[i];
+            }
+
+            _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
          }
          if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
@@ -1672,28 +1359,29 @@ _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
          ASSERT(drawBuffer->Height > 0);
 #endif
 
-         if (newCtx->FirstTimeCurrent) {
-            /* set initial viewport and scissor size now */
-            _mesa_set_viewport(newCtx, 0, 0,
-                               drawBuffer->Width, drawBuffer->Height);
-	    _mesa_set_scissor(newCtx, 0, 0,
-			      drawBuffer->Width, drawBuffer->Height );
-            check_context_limits(newCtx);
+         if (drawBuffer) {
+            _mesa_check_init_viewport(newCtx,
+                                      drawBuffer->Width, drawBuffer->Height);
          }
       }
 
-      /* We can use this to help debug user's problems.  Tell them to set
-       * the MESA_INFO env variable before running their app.  Then the
-       * first time each context is made current we'll print some useful
-       * information.
-       */
       if (newCtx->FirstTimeCurrent) {
+         check_context_limits(newCtx);
+
+         /* We can use this to help debug user's problems.  Tell them to set
+          * the MESA_INFO env variable before running their app.  Then the
+          * first time each context is made current we'll print some useful
+          * information.
+          */
 	 if (_mesa_getenv("MESA_INFO")) {
 	    _mesa_print_info();
 	 }
+
 	 newCtx->FirstTimeCurrent = GL_FALSE;
       }
    }
+   
+   return GL_TRUE;
 }
 
 
@@ -1708,15 +1396,22 @@ _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
 {
    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
       struct gl_shared_state *oldSharedState = ctx->Shared;
+      GLint RefCount;
 
       ctx->Shared = ctxToShare->Shared;
+      
+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
       ctx->Shared->RefCount++;
+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 
       update_default_objects(ctx);
 
-      oldSharedState->RefCount--;
-      if (oldSharedState->RefCount == 0) {
-         free_shared_state(ctx, oldSharedState);
+      _glthread_LOCK_MUTEX(oldSharedState->Mutex);
+      RefCount = --oldSharedState->RefCount;
+      _glthread_UNLOCK_MUTEX(oldSharedState->Mutex);
+
+      if (RefCount == 0) {
+         _mesa_free_shared_state(ctx, oldSharedState);
       }
 
       return GL_TRUE;
@@ -1808,6 +1503,7 @@ _mesa_Finish(void)
 {
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT( ctx, 0 );
    if (ctx->Driver.Finish) {
       ctx->Driver.Finish(ctx);
    }
@@ -1825,10 +1521,102 @@ _mesa_Flush(void)
 {
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   FLUSH_CURRENT( ctx, 0 );
    if (ctx->Driver.Flush) {
       ctx->Driver.Flush(ctx);
    }
 }
 
 
+/**
+ * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
+ * MUL/MAD, or vice versa, call this function to register that.
+ * Otherwise we default to MUL/MAD.
+ */
+void
+_mesa_set_mvp_with_dp4( GLcontext *ctx,
+                        GLboolean flag )
+{
+   ctx->mvp_with_dp4 = flag;
+}
+
+
+
+/**
+ * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
+ * is called to see if it's valid to render.  This involves checking that
+ * the current shader is valid and the framebuffer is complete.
+ * If an error is detected it'll be recorded here.
+ * \return GL_TRUE if OK to render, GL_FALSE if not
+ */
+GLboolean
+_mesa_valid_to_render(GLcontext *ctx, const char *where)
+{
+   if (ctx->Shader.CurrentProgram) {
+      /* using shaders */
+      if (!ctx->Shader.CurrentProgram->LinkStatus) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "%s(shader not linked), where");
+         return GL_FALSE;
+      }
+#if 0 /* not normally enabled */
+      {
+         char errMsg[100];
+         if (!_mesa_validate_shader_program(ctx, ctx->Shader.CurrentProgram,
+                                            errMsg)) {
+            _mesa_warning(ctx, "Shader program %u is invalid: %s",
+                          ctx->Shader.CurrentProgram->Name, errMsg);
+         }
+      }
+#endif
+   }
+   else {
+      if (ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "%s(vertex program not valid)", where);
+         return GL_FALSE;
+      }
+      if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "%s(fragment program not valid)", where);
+         return GL_FALSE;
+      }
+   }
+
+   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
+                  "%s(incomplete framebuffer)", where);
+      return GL_FALSE;
+   }
+
+#ifdef DEBUG
+   if (ctx->Shader.Flags & GLSL_LOG) {
+      struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
+      if (shProg) {
+         if (!shProg->_Used) {
+            /* This is the first time this shader is being used.
+             * Append shader's constants/uniforms to log file.
+             */
+            GLuint i;
+            for (i = 0; i < shProg->NumShaders; i++) {
+               struct gl_shader *sh = shProg->Shaders[i];
+               if (sh->Type == GL_VERTEX_SHADER) {
+                  _mesa_append_uniforms_to_file(sh,
+                                                &shProg->VertexProgram->Base);
+               }
+               else if (sh->Type == GL_FRAGMENT_SHADER) {
+                  _mesa_append_uniforms_to_file(sh,
+                                                &shProg->FragmentProgram->Base);
+               }
+            }
+            shProg->_Used = GL_TRUE;
+         }
+      }
+   }
+#endif
+
+   return GL_TRUE;
+}
+
+
 /*@}*/
diff --git a/src/mesa/main/context.h b/src/mesa/main/context.h
index 54f1af911d..5587695fa0 100644
--- a/src/mesa/main/context.h
+++ b/src/mesa/main/context.h
@@ -49,11 +49,13 @@
 #define CONTEXT_H
 
 
-#include "glapi/glapi.h"
 #include "imports.h"
 #include "mtypes.h"
 
 
+struct _glapi_table;
+
+
 /** \name Visual-related functions */
 /*@{*/
  
@@ -129,6 +131,9 @@ _mesa_copy_context(const GLcontext *src, GLcontext *dst, GLuint mask);
 
 
 extern void
+_mesa_check_init_viewport(GLcontext *ctx, GLuint width, GLuint height);
+
+extern GLboolean
 _mesa_make_current( GLcontext *ctx, GLframebuffer *drawBuffer,
                     GLframebuffer *readBuffer );
 
@@ -149,6 +154,15 @@ extern struct _glapi_table *
 _mesa_get_dispatch(GLcontext *ctx);
 
 
+void
+_mesa_set_mvp_with_dp4( GLcontext *ctx,
+                        GLboolean flag );
+
+
+extern GLboolean
+_mesa_valid_to_render(GLcontext *ctx, const char *where);
+
+
 
 /** \name Miscellaneous */
 /*@{*/
@@ -165,7 +179,6 @@ _mesa_Flush( void );
 /*@}*/
 
 
-
 /**
  * \name Macros for flushing buffered rendering commands before state changes,
  * checking if inside glBegin/glEnd, etc.
diff --git a/src/mesa/main/convolve.c b/src/mesa/main/convolve.c
index 814c6a0a5a..4bca436095 100644
--- a/src/mesa/main/convolve.c
+++ b/src/mesa/main/convolve.c
@@ -40,6 +40,10 @@
 #include "mtypes.h"
 #include "pixel.h"
 #include "state.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_convolve
 
 
 /*
@@ -144,39 +148,19 @@ _mesa_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width, G
    ctx->Convolution1D.Width = width;
    ctx->Convolution1D.Height = 1;
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack filter from PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Unpack, width, 1, 1,
-                                     format, type, image)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glConvolutionFilter1D(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glConvolutionFilter1D(PBO is mapped)");
-         return;
-      }
-      image = ADD_POINTERS(buf, image);
-   }
-   else if (!image) {
+   image = _mesa_map_validate_pbo_source(ctx, 
+                                        1, &ctx->Unpack, width, 1, 1,
+                                        format, type, image,
+                                        "glConvolutionFilter1D");
+   if (!image)
       return;
-   }
 
    _mesa_unpack_color_span_float(ctx, width, GL_RGBA,
                                  ctx->Convolution1D.Filter,
                                  format, type, image, &ctx->Unpack,
                                  0); /* transferOps */
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 
    _mesa_scale_and_bias_rgba(width,
                              (GLfloat (*)[4]) ctx->Convolution1D.Filter,
@@ -242,29 +226,12 @@ _mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, G
    ctx->Convolution2D.Width = width;
    ctx->Convolution2D.Height = height;
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack filter from PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
-                                     format, type, image)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glConvolutionFilter2D(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glConvolutionFilter2D(PBO is mapped)");
-         return;
-      }
-      image = ADD_POINTERS(buf, image);
-   }
-   else if (!image) {
+   image = _mesa_map_validate_pbo_source(ctx, 
+                                         2, &ctx->Unpack, width, height, 1,
+                                         format, type, image,
+                                         "glConvolutionFilter2D");
+   if (!image)
       return;
-   }
 
    /* Unpack filter image.  We always store filters in RGBA format. */
    for (i = 0; i < height; i++) {
@@ -276,10 +243,7 @@ _mesa_ConvolutionFilter2D(GLenum target, GLenum internalFormat, GLsizei width, G
                                     0); /* transferOps */
    }
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 
    _mesa_scale_and_bias_rgba(width * height,
                              (GLfloat (*)[4]) ctx->Convolution2D.Filter,
@@ -598,27 +562,12 @@ _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
          return;
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* Pack the filter into a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(2, &ctx->Pack,
-                                     filter->Width, filter->Height,
-                                     1, format, type, image)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetConvolutionFilter(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetConvolutionFilter(PBO is mapped)");
-         return;
-      }
-      image = ADD_POINTERS(image, buf);
-   }
+   image = _mesa_map_validate_pbo_dest(ctx, 2, &ctx->Pack,
+                                       filter->Width, filter->Height, 1,
+                                       format, type, image,
+                                       "glGetConvolutionFilter");
+   if (!image)
+      return;
 
    for (row = 0; row < filter->Height; row++) {
       GLvoid *dst = _mesa_image_address2d(&ctx->Pack, image, filter->Width,
@@ -629,10 +578,7 @@ _mesa_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
                                  format, type, dst, &ctx->Pack, 0x0);
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
@@ -802,59 +748,35 @@ _mesa_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
 
    filter = &ctx->Separable2D;
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* Pack filter into PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Pack, filter->Width, 1, 1,
-                                     format, type, row)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetSeparableFilter(invalid PBO access, width)");
-         return;
-      }
-      if (!_mesa_validate_pbo_access(1, &ctx->Pack, filter->Height, 1, 1,
-                                     format, type, column)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetSeparableFilter(invalid PBO access, height)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetSeparableFilter(PBO is mapped)");
-         return;
-      }
-      row = ADD_POINTERS(buf, row);
-      column = ADD_POINTERS(buf, column);
-   }
-
-   /* Row filter */
+   /* Get row filter */
+   row = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack,
+                                     filter->Width, 1, 1,
+                                     format, type, row,
+                                     "glGetConvolutionFilter");
    if (row) {
       GLvoid *dst = _mesa_image_address1d(&ctx->Pack, row, filter->Width,
                                           format, type, 0);
       _mesa_pack_rgba_span_float(ctx, filter->Width,
                                  (GLfloat (*)[4]) filter->Filter,
                                  format, type, dst, &ctx->Pack, 0x0);
+      _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
    }
 
-   /* Column filter */
+   /* get column filter */
+   column = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack,
+                                        filter->Height, 1, 1,
+                                        format, type, column,
+                                        "glGetConvolutionFilter");
    if (column) {
       GLvoid *dst = _mesa_image_address1d(&ctx->Pack, column, filter->Height,
                                           format, type, 0);
       GLfloat (*src)[4] = (GLfloat (*)[4]) (filter->Filter + colStart);
       _mesa_pack_rgba_span_float(ctx, filter->Height, src,
                                  format, type, dst, &ctx->Pack, 0x0);
+      _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
    }
 
    (void) span;  /* unused at this time */
-
-   if (ctx->Pack.BufferObj->Name) {
-      /* Pack filter into PBO */
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
 }
 
 
@@ -905,41 +827,16 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs
    ctx->Separable2D.Width = width;
    ctx->Separable2D.Height = height;
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack filter from PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Unpack, width, 1, 1,
-                                     format, type, row)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glSeparableFilter2D(invalid PBO access, width)");
-         return;
-      }
-      if (!_mesa_validate_pbo_access(1, &ctx->Unpack, height, 1, 1,
-                                     format, type, column)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glSeparableFilter2D(invalid PBO access, height)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glSeparableFilter2D(PBO is mapped)");
-         return;
-      }
-      row = ADD_POINTERS(buf, row);
-      column = ADD_POINTERS(buf, column);
-   }
-
    /* unpack row filter */
+   row = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack,
+                                       width, 1, 1,
+                                       format, type, row,
+                                       "glSeparableFilter2D");
    if (row) {
       _mesa_unpack_color_span_float(ctx, width, GL_RGBA,
                                     ctx->Separable2D.Filter,
                                     format, type, row, &ctx->Unpack,
-                                    0);  /* transferOps */
-
+                                    0x0);  /* transferOps */
       _mesa_scale_and_bias_rgba(width,
                              (GLfloat (*)[4]) ctx->Separable2D.Filter,
                              ctx->Pixel.ConvolutionFilterScale[2][0],
@@ -950,9 +847,14 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs
                              ctx->Pixel.ConvolutionFilterBias[2][1],
                              ctx->Pixel.ConvolutionFilterBias[2][2],
                              ctx->Pixel.ConvolutionFilterBias[2][3]);
+      _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
    }
 
    /* unpack column filter */
+   column = _mesa_map_validate_pbo_source(ctx, 1, &ctx->Unpack,
+                                          height, 1, 1,
+                                          format, type, column,
+                                          "glSeparableFilter2D");
    if (column) {
       _mesa_unpack_color_span_float(ctx, height, GL_RGBA,
                                     &ctx->Separable2D.Filter[colStart],
@@ -969,9 +871,10 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalFormat, GLsizei width, GLs
                        ctx->Pixel.ConvolutionFilterBias[2][1],
                        ctx->Pixel.ConvolutionFilterBias[2][2],
                        ctx->Pixel.ConvolutionFilterBias[2][3]);
+      _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
    }
 
-   if (ctx->Unpack.BufferObj->Name) {
+   if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                               ctx->Unpack.BufferObj);
    }
@@ -1526,3 +1429,25 @@ _mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions,
       *height = *height - (MAX2(ctx->Separable2D.Height, 1) - 1);
    }
 }
+
+
+void 
+_mesa_init_convolve_dispatch(struct _glapi_table *disp)
+{
+   SET_ConvolutionFilter1D(disp, _mesa_ConvolutionFilter1D);
+   SET_ConvolutionFilter2D(disp, _mesa_ConvolutionFilter2D);
+   SET_ConvolutionParameterf(disp, _mesa_ConvolutionParameterf);
+   SET_ConvolutionParameterfv(disp, _mesa_ConvolutionParameterfv);
+   SET_ConvolutionParameteri(disp, _mesa_ConvolutionParameteri);
+   SET_ConvolutionParameteriv(disp, _mesa_ConvolutionParameteriv);
+   SET_CopyConvolutionFilter1D(disp, _mesa_CopyConvolutionFilter1D);
+   SET_CopyConvolutionFilter2D(disp, _mesa_CopyConvolutionFilter2D);
+   SET_GetConvolutionFilter(disp, _mesa_GetConvolutionFilter);
+   SET_GetConvolutionParameterfv(disp, _mesa_GetConvolutionParameterfv);
+   SET_GetConvolutionParameteriv(disp, _mesa_GetConvolutionParameteriv);
+   SET_SeparableFilter2D(disp, _mesa_SeparableFilter2D);
+   SET_GetSeparableFilter(disp, _mesa_GetSeparableFilter);
+}
+
+
+#endif /* FEATURE_convolve */
diff --git a/src/mesa/main/convolve.h b/src/mesa/main/convolve.h
index 4505cdae01..565a51ef8f 100644
--- a/src/mesa/main/convolve.h
+++ b/src/mesa/main/convolve.h
@@ -28,10 +28,17 @@
 #define CONVOLVE_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
 
-#if _HAVE_FULL_GL
+#if FEATURE_convolve
+
+#define _MESA_INIT_CONVOLVE_FUNCTIONS(driver, impl)                        \
+   do {                                                                    \
+      (driver)->CopyConvolutionFilter1D = impl ## CopyConvolutionFilter1D; \
+      (driver)->CopyConvolutionFilter2D = impl ## CopyConvolutionFilter2D; \
+   } while (0)
+
 extern void GLAPIENTRY
 _mesa_ConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width,
                           GLenum format, GLenum type, const GLvoid *image);
@@ -83,32 +90,66 @@ _mesa_SeparableFilter2D(GLenum target, GLenum internalformat,
                         const GLvoid *row, const GLvoid *column);
 
 
-
 extern void
 _mesa_convolve_1d_image(const GLcontext *ctx, GLsizei *width,
                         const GLfloat *srcImage, GLfloat *dstImage);
 
-
 extern void
 _mesa_convolve_2d_image(const GLcontext *ctx, GLsizei *width, GLsizei *height,
                         const GLfloat *srcImage, GLfloat *dstImage);
 
-
 extern void
 _mesa_convolve_sep_image(const GLcontext *ctx,
                          GLsizei *width, GLsizei *height,
                          const GLfloat *srcImage, GLfloat *dstImage);
 
-
 extern void
 _mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions,
                                    GLsizei *width, GLsizei *height);
 
-#else
-#define _mesa_adjust_image_for_convolution(c, d, w, h) ((void)0)
-#define _mesa_convolve_1d_image(c,w,s,d) ((void)0)
-#define _mesa_convolve_2d_image(c,w,h,s,d) ((void)0)
-#define _mesa_convolve_sep_image(c,w,h,s,d) ((void)0)
-#endif
+extern void
+_mesa_init_convolve_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_convolve */
+
+#define _MESA_INIT_CONVOLVE_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void
+_mesa_convolve_1d_image(const GLcontext *ctx, GLsizei *width,
+                        const GLfloat *srcImage, GLfloat *dstImage)
+{
+   *width = 0;
+}
+
+static INLINE void
+_mesa_convolve_2d_image(const GLcontext *ctx, GLsizei *width, GLsizei *height,
+                        const GLfloat *srcImage, GLfloat *dstImage)
+{
+   *width = 0;
+   *height = 0;
+}
+
+
+static INLINE void
+_mesa_convolve_sep_image(const GLcontext *ctx,
+                         GLsizei *width, GLsizei *height,
+                         const GLfloat *srcImage, GLfloat *dstImage)
+{
+   *width = 0;
+   *height = 0;
+}
+
+static INLINE void
+_mesa_adjust_image_for_convolution(const GLcontext *ctx, GLuint dimensions,
+                                   GLsizei *width, GLsizei *height)
+{
+}
+
+static INLINE void 
+_mesa_init_convolve_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_convolve */
 
-#endif
+#endif /* CONVOLVE_H */
diff --git a/src/mesa/main/cpuinfo.c b/src/mesa/main/cpuinfo.c
new file mode 100644
index 0000000000..b4bfb40eb1
--- /dev/null
+++ b/src/mesa/main/cpuinfo.c
@@ -0,0 +1,109 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include "main/imports.h"
+#include "main/cpuinfo.h"
+
+
+/**
+ * This function should be called before the various "cpu_has_foo" macros
+ * are used.
+ */
+void
+_mesa_get_cpu_features(void)
+{
+#ifdef USE_X86_ASM
+   _mesa_get_x86_features();
+#endif
+}
+
+
+/**
+ * Return a string describing the CPU architexture and extensions that
+ * Mesa is using (such as SSE or Altivec).
+ * \return information string, free it with _mesa_free()
+ */
+char *
+_mesa_get_cpu_string(void)
+{
+#define MAX_STRING 50
+   char *buffer;
+
+   buffer = (char *) _mesa_malloc(MAX_STRING);
+   if (!buffer)
+      return NULL;
+
+   buffer[0] = 0;
+
+#ifdef USE_X86_ASM
+
+   if (_mesa_x86_cpu_features) {
+      strcat(buffer, "x86");
+   }
+
+# ifdef USE_MMX_ASM
+   if (cpu_has_mmx) {
+      strcat(buffer, (cpu_has_mmxext) ? "/MMX+" : "/MMX");
+   }
+# endif
+# ifdef USE_3DNOW_ASM
+   if (cpu_has_3dnow) {
+      strcat(buffer, (cpu_has_3dnowext) ? "/3DNow!+" : "/3DNow!");
+   }
+# endif
+# ifdef USE_SSE_ASM
+   if (cpu_has_xmm) {
+      strcat(buffer, (cpu_has_xmm2) ? "/SSE2" : "/SSE");
+   }
+# endif
+
+#elif defined(USE_SPARC_ASM)
+
+   strcat(buffer, "SPARC");
+
+#elif defined(USE_PPC_ASM)
+
+   if (_mesa_ppc_cpu_features) {
+      strcat(buffer, (cpu_has_64) ? "PowerPC 64" : "PowerPC");
+   }
+
+# ifdef USE_VMX_ASM
+
+   if (cpu_has_vmx) {
+      strcat(buffer, "/Altivec");
+   }
+
+# endif
+
+   if (! cpu_has_fpu) {
+      strcat(buffer, "/No FPU");
+   }
+
+#endif
+
+   assert(_mesa_strlen(buffer) < MAX_STRING);
+
+   return buffer;
+}
diff --git a/src/mesa/main/cpuinfo.h b/src/mesa/main/cpuinfo.h
new file mode 100644
index 0000000000..c41a90b075
--- /dev/null
+++ b/src/mesa/main/cpuinfo.h
@@ -0,0 +1,47 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef CPUINFO_H
+#define CPUINFO_H
+
+
+#if defined(USE_X86_ASM)
+#include "x86/common_x86_asm.h"
+#endif
+
+#if defined(USE_PPC_ASM)
+#include "ppc/common_ppc_features.h"
+#endif
+
+
+extern void
+_mesa_get_cpu_features(void);
+
+
+extern char *
+_mesa_get_cpu_string(void);
+
+
+#endif /* CPUINFO_H */
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index ddb38030bf..307ecd3d8b 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -34,7 +34,23 @@
 /* THIS FILE ONLY INCLUDED BY mtypes.h !!!!! */
 
 struct gl_pixelstore_attrib;
-struct mesa_display_list;
+struct gl_display_list;
+
+#if FEATURE_ARB_vertex_buffer_object
+/* Modifies GL_MAP_UNSYNCHRONIZED_BIT to allow driver to fail (return
+ * NULL) if buffer is unavailable for immediate mapping.
+ *
+ * Does GL_MAP_INVALIDATE_RANGE_BIT do this?  It seems so, but it
+ * would require more book-keeping in the driver than seems necessary
+ * at this point.
+ *
+ * Does GL_MAP_INVALDIATE_BUFFER_BIT do this?  Not really -- we don't
+ * want to provoke the driver to throw away the old storage, we will
+ * respect the contents of already referenced data.
+ */
+#define MESA_MAP_NOWAIT_BIT       0x0040
+#endif
+
 
 /**
  * Device driver function table.
@@ -586,9 +602,6 @@ struct dd_function_table {
    /** Notify driver that a program string has been specified. */
    void (*ProgramStringNotify)(GLcontext *ctx, GLenum target, 
 			       struct gl_program *prog);
-   /** Get value of a program register during program execution. */
-   void (*GetProgramRegister)(GLcontext *ctx, enum register_file file,
-                              GLuint index, GLfloat val[4]);
 
    /** Query if program can be loaded onto hardware */
    GLboolean (*IsProgramNative)(GLcontext *ctx, GLenum target, 
@@ -753,6 +766,8 @@ struct dd_function_table {
    /** Return the value or values of a selected parameter */
    GLboolean (*GetIntegerv)(GLcontext *ctx, GLenum pname, GLint *result);
    /** Return the value or values of a selected parameter */
+   GLboolean (*GetInteger64v)(GLcontext *ctx, GLenum pname, GLint64 *result);
+   /** Return the value or values of a selected parameter */
    GLboolean (*GetPointerv)(GLcontext *ctx, GLenum pname, GLvoid **result);
    /*@}*/
    
@@ -770,9 +785,9 @@ struct dd_function_table {
    
    void (*DeleteBuffer)( GLcontext *ctx, struct gl_buffer_object *obj );
 
-   void (*BufferData)( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
-		       const GLvoid *data, GLenum usage,
-		       struct gl_buffer_object *obj );
+   GLboolean (*BufferData)( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
+                            const GLvoid *data, GLenum usage,
+                            struct gl_buffer_object *obj );
 
    void (*BufferSubData)( GLcontext *ctx, GLenum target, GLintptrARB offset,
 			  GLsizeiptrARB size, const GLvoid *data,
@@ -785,6 +800,22 @@ struct dd_function_table {
    void * (*MapBuffer)( GLcontext *ctx, GLenum target, GLenum access,
 			struct gl_buffer_object *obj );
 
+   void (*CopyBufferSubData)( GLcontext *ctx,
+                              struct gl_buffer_object *src,
+                              struct gl_buffer_object *dst,
+                              GLintptr readOffset, GLintptr writeOffset,
+                              GLsizeiptr size );
+
+   /* May return NULL if MESA_MAP_NOWAIT_BIT is set in access:
+    */
+   void * (*MapBufferRange)( GLcontext *ctx, GLenum target,
+                             GLintptr offset, GLsizeiptr length, GLbitfield access,
+                             struct gl_buffer_object *obj);
+
+   void (*FlushMappedBufferRange) (GLcontext *ctx, GLenum target, 
+                                   GLintptr offset, GLsizeiptr length,
+                                   struct gl_buffer_object *obj);
+
    GLboolean (*UnmapBuffer)( GLcontext *ctx, GLenum target,
 			     struct gl_buffer_object *obj );
    /*@}*/
@@ -808,6 +839,8 @@ struct dd_function_table {
                          struct gl_renderbuffer_attachment *att);
    void (*FinishRenderTexture)(GLcontext *ctx,
                                struct gl_renderbuffer_attachment *att);
+   void (*ValidateFramebuffer)(GLcontext *ctx,
+                               struct gl_framebuffer *fb);
    /*@}*/
 #endif
 #if FEATURE_EXT_framebuffer_blit
@@ -886,7 +919,7 @@ struct dd_function_table {
    void (*Uniform)(GLcontext *ctx, GLint location, GLsizei count,
                    const GLvoid *values, GLenum type);
    void (*UniformMatrix)(GLcontext *ctx, GLint cols, GLint rows,
-                         GLenum matrixType, GLint location, GLsizei count,
+                         GLint location, GLsizei count,
                          GLboolean transpose, const GLfloat *values);
    void (*UseProgram)(GLcontext *ctx, GLuint program);
    void (*ValidateProgram)(GLcontext *ctx, GLuint program);
@@ -952,6 +985,12 @@ struct dd_function_table {
    GLuint NeedFlush;
    GLuint SaveNeedFlush;
 
+
+   /* Called prior to any of the GLvertexformat functions being
+    * called.  Paired with Driver.FlushVertices().
+    */
+   void (*BeginVertices)( GLcontext *ctx );
+
    /**
     * If inside glBegin()/glEnd(), it should ASSERT(0).  Otherwise, if
     * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
@@ -997,7 +1036,7 @@ struct dd_function_table {
     * Notify the T&L component before and after calling a display list.
     */
    void (*BeginCallList)( GLcontext *ctx, 
-			  struct mesa_display_list *dlist );
+			  struct gl_display_list *dlist );
    /**
     * Called by glEndCallList().
     *
@@ -1005,6 +1044,45 @@ struct dd_function_table {
     */
    void (*EndCallList)( GLcontext *ctx );
 
+
+#if FEATURE_ARB_sync
+   /**
+    * \name GL_ARB_sync interfaces
+    */
+   /*@{*/
+   struct gl_sync_object * (*NewSyncObject)(GLcontext *, GLenum);
+   void (*FenceSync)(GLcontext *, struct gl_sync_object *, GLenum, GLbitfield);
+   void (*DeleteSyncObject)(GLcontext *, struct gl_sync_object *);
+   void (*CheckSync)(GLcontext *, struct gl_sync_object *);
+   void (*ClientWaitSync)(GLcontext *, struct gl_sync_object *,
+			  GLbitfield, GLuint64);
+   void (*ServerWaitSync)(GLcontext *, struct gl_sync_object *,
+			  GLbitfield, GLuint64);
+   /*@}*/
+#endif
+
+#if FEATURE_OES_draw_texture
+   /**
+    * \name GL_OES_draw_texture interface
+    */
+   /*@{*/
+   void (*DrawTex)(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
+                   GLfloat width, GLfloat height);
+   /*@}*/
+#endif
+#if FEATURE_OES_EGL_image
+   /**
+    * \name GL_OES_EGL_image interface
+    */
+   /*@{*/
+   void (*EGLImageTargetRenderbufferStorage)(GLcontext *ctx,
+                                             struct gl_renderbuffer *rb,
+                                             GLvoid *image);
+   void (*EGLImageTargetTexture2D)(GLcontext *ctx,
+                                   struct gl_texture_object *texObj,
+                                   GLvoid *image);
+   /*@}*/
+#endif
 };
 
 
@@ -1113,6 +1191,25 @@ typedef struct {
    void (GLAPIENTRYP DrawRangeElements)( GLenum mode, GLuint start,
 			      GLuint end, GLsizei count,
 			      GLenum type, const GLvoid *indices );
+   void (GLAPIENTRYP MultiDrawElementsEXT)( GLenum mode, const GLsizei *count,
+					    GLenum type,
+					    const GLvoid **indices,
+					    GLsizei primcount);
+   void (GLAPIENTRYP DrawElementsBaseVertex)( GLenum mode, GLsizei count,
+					      GLenum type,
+					      const GLvoid *indices,
+					      GLint basevertex );
+   void (GLAPIENTRYP DrawRangeElementsBaseVertex)( GLenum mode, GLuint start,
+						   GLuint end, GLsizei count,
+						   GLenum type,
+						   const GLvoid *indices,
+						   GLint basevertex);
+   void (GLAPIENTRYP MultiDrawElementsBaseVertex)( GLenum mode,
+						   const GLsizei *count,
+						   GLenum type,
+						   const GLvoid **indices,
+						   GLsizei primcount,
+						   const GLint *basevertex);
    /*@}*/
 
    /**
diff --git a/src/mesa/main/debug.c b/src/mesa/main/debug.c
index 77fef32558..8492c8561d 100644
--- a/src/mesa/main/debug.c
+++ b/src/mesa/main/debug.c
@@ -3,6 +3,7 @@
  * Version:  6.5
  *
  * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -23,10 +24,19 @@
  */
 
 #include "mtypes.h"
+#include "attrib.h"
+#include "colormac.h"
 #include "context.h"
+#include "hash.h"
 #include "imports.h"
 #include "debug.h"
 #include "get.h"
+#include "pixelstore.h"
+#include "readpix.h"
+#include "texgetimage.h"
+#include "texobj.h"
+#include "texformat.h"
+
 
 /**
  * Primitive names
@@ -164,9 +174,7 @@ static void add_debug_flags( const char *debug )
       { "api",       VERBOSE_API },
       { "list",      VERBOSE_DISPLAY_LIST },
       { "lighting",  VERBOSE_LIGHTING },
-      { "disassem",  VERBOSE_DISASSEM },
-      { "glsl",      VERBOSE_GLSL },     /* report GLSL compile/link errors */
-      { "glsl_dump", VERBOSE_GLSL_DUMP } /* print shader GPU instructions */
+      { "disassem",  VERBOSE_DISASSEM }
    };
    GLuint i;
 
@@ -221,3 +229,212 @@ _mesa_init_debug( GLcontext *ctx )
       add_debug_flags(c);
 }
 
+
+/*
+ * Write ppm file
+ */
+static void
+write_ppm(const char *filename, const GLubyte *buffer, int width, int height,
+          int comps, int rcomp, int gcomp, int bcomp, GLboolean invert)
+{
+   FILE *f = fopen( filename, "w" );
+   if (f) {
+      int x, y;
+      const GLubyte *ptr = buffer;
+      fprintf(f,"P6\n");
+      fprintf(f,"# ppm-file created by osdemo.c\n");
+      fprintf(f,"%i %i\n", width,height);
+      fprintf(f,"255\n");
+      fclose(f);
+      f = fopen( filename, "ab" );  /* reopen in binary append mode */
+      for (y=0; y < height; y++) {
+         for (x = 0; x < width; x++) {
+            int yy = invert ? (height - 1 - y) : y;
+            int i = (yy * width + x) * comps;
+            fputc(ptr[i+rcomp], f); /* write red */
+            fputc(ptr[i+gcomp], f); /* write green */
+            fputc(ptr[i+bcomp], f); /* write blue */
+         }
+      }
+      fclose(f);
+   }
+}
+
+
+/**
+ * Write level[0] image to a ppm file.
+ */
+static void
+write_texture_image(struct gl_texture_object *texObj, GLuint face, GLuint level)
+{
+   struct gl_texture_image *img = texObj->Image[face][level];
+   if (img) {
+      GET_CURRENT_CONTEXT(ctx);
+      struct gl_pixelstore_attrib store;
+      GLubyte *buffer;
+      char s[100];
+
+      buffer = (GLubyte *) _mesa_malloc(img->Width * img->Height
+                                        * img->Depth * 4);
+
+      store = ctx->Pack; /* save */
+      ctx->Pack = ctx->DefaultPacking;
+
+      ctx->Driver.GetTexImage(ctx, texObj->Target, level,
+                              GL_RGBA, GL_UNSIGNED_BYTE,
+                              buffer, texObj, img);
+
+      /* make filename */
+      _mesa_sprintf(s, "/tmp/teximage%u.ppm", texObj->Name);
+
+      _mesa_printf("  Writing image level %u to %s\n", level, s);
+      write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE);
+
+      ctx->Pack = store; /* restore */
+
+      _mesa_free(buffer);
+   }
+}
+
+
+static GLboolean DumpImages;
+
+
+static void
+dump_texture_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_texture_object *texObj = (struct gl_texture_object *) data;
+   int i;
+   GLboolean written = GL_FALSE;
+   (void) userData;
+
+   _mesa_printf("Texture %u\n", texObj->Name);
+   _mesa_printf("  Target 0x%x\n", texObj->Target);
+   for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
+      struct gl_texture_image *texImg = texObj->Image[0][i];
+      if (texImg) {
+         _mesa_printf("  Image %u: %d x %d x %d, format %u at %p\n", i,
+                      texImg->Width, texImg->Height, texImg->Depth,
+                      texImg->TexFormat->MesaFormat, texImg->Data);
+         if (DumpImages && !written) {
+            GLuint face = 0;
+            write_texture_image(texObj, face, i);
+            written = GL_TRUE;
+         }
+      }
+   }
+}
+
+
+/**
+ * Print basic info about all texture objext to stdout.
+ * If dumpImages is true, write PPM of level[0] image to a file.
+ */
+void
+_mesa_dump_textures(GLboolean dumpImages)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   DumpImages = dumpImages;
+   _mesa_HashWalk(ctx->Shared->TexObjects, dump_texture_cb, ctx);
+}
+
+
+void
+_mesa_dump_color_buffer(const char *filename)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const GLuint w = ctx->DrawBuffer->Width;
+   const GLuint h = ctx->DrawBuffer->Height;
+   GLubyte *buf;
+
+   buf = (GLubyte *) _mesa_malloc(w * h * 4);
+
+   _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+   _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
+   _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
+
+   _mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
+
+   _mesa_printf("ReadBuffer %p 0x%x  DrawBuffer %p 0x%x\n",
+                ctx->ReadBuffer->_ColorReadBuffer,
+                ctx->ReadBuffer->ColorReadBuffer,
+                ctx->DrawBuffer->_ColorDrawBuffers[0],
+                ctx->DrawBuffer->ColorDrawBuffer[0]);
+   _mesa_printf("Writing %d x %d color buffer to %s\n", w, h, filename);
+   write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE);
+
+   _mesa_PopClientAttrib();
+
+   _mesa_free(buf);
+}
+
+
+void
+_mesa_dump_depth_buffer(const char *filename)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const GLuint w = ctx->DrawBuffer->Width;
+   const GLuint h = ctx->DrawBuffer->Height;
+   GLuint *buf;
+   GLubyte *buf2;
+   GLuint i;
+
+   buf = (GLuint *) _mesa_malloc(w * h * 4);  /* 4 bpp */
+   buf2 = (GLubyte *) _mesa_malloc(w * h * 3); /* 3 bpp */
+
+   _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+   _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
+   _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
+
+   _mesa_ReadPixels(0, 0, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buf);
+
+   /* spread 24 bits of Z across R, G, B */
+   for (i = 0; i < w * h; i++) {
+      buf2[i*3+0] = (buf[i] >> 24) & 0xff;
+      buf2[i*3+1] = (buf[i] >> 16) & 0xff;
+      buf2[i*3+2] = (buf[i] >>  8) & 0xff;
+   }
+
+   _mesa_printf("Writing %d x %d depth buffer to %s\n", w, h, filename);
+   write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
+
+   _mesa_PopClientAttrib();
+
+   _mesa_free(buf);
+   _mesa_free(buf2);
+}
+
+
+void
+_mesa_dump_stencil_buffer(const char *filename)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   const GLuint w = ctx->DrawBuffer->Width;
+   const GLuint h = ctx->DrawBuffer->Height;
+   GLubyte *buf;
+   GLubyte *buf2;
+   GLuint i;
+
+   buf = (GLubyte *) _mesa_malloc(w * h);  /* 1 bpp */
+   buf2 = (GLubyte *) _mesa_malloc(w * h * 3); /* 3 bpp */
+
+   _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+   _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
+   _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
+
+   _mesa_ReadPixels(0, 0, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf);
+
+   for (i = 0; i < w * h; i++) {
+      buf2[i*3+0] = buf[i];
+      buf2[i*3+1] = (buf[i] & 127) * 2;
+      buf2[i*3+2] = (buf[i] - 128) * 2;
+   }
+
+   _mesa_printf("Writing %d x %d stencil buffer to %s\n", w, h, filename);
+   write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
+
+   _mesa_PopClientAttrib();
+
+   _mesa_free(buf);
+   _mesa_free(buf2);
+}
diff --git a/src/mesa/main/debug.h b/src/mesa/main/debug.h
index 94d99c384b..bb384c4324 100644
--- a/src/mesa/main/debug.h
+++ b/src/mesa/main/debug.h
@@ -57,4 +57,16 @@ extern void _mesa_init_debug( GLcontext *ctx );
 
 #endif
 
+extern void
+_mesa_dump_textures(GLboolean dumpImages);
+
+extern void
+_mesa_dump_color_buffer(const char *filename);
+
+extern void
+_mesa_dump_depth_buffer(const char *filename);
+
+extern void
+_mesa_dump_stencil_buffer(const char *filename);
+
 #endif
diff --git a/src/mesa/main/depthstencil.c b/src/mesa/main/depthstencil.c
index 9d208e2997..7be2aacaf2 100644
--- a/src/mesa/main/depthstencil.c
+++ b/src/mesa/main/depthstencil.c
@@ -62,15 +62,9 @@ nop_get_pointer(GLcontext *ctx, struct gl_renderbuffer *rb, GLint x, GLint y)
 static void
 delete_wrapper(struct gl_renderbuffer *rb)
 {
-   struct gl_renderbuffer *dsrb = rb->Wrapped;
-   ASSERT(dsrb);
    ASSERT(rb->_ActualFormat == GL_DEPTH_COMPONENT24 ||
           rb->_ActualFormat == GL_STENCIL_INDEX8_EXT);
-   /* decrement refcount on the wrapped buffer and delete it if necessary */
-   dsrb->RefCount--;
-   if (dsrb->RefCount <= 0) {
-      dsrb->Delete(dsrb);
-   }
+   _mesa_reference_renderbuffer(&rb->Wrapped, NULL);
    _mesa_free(rb);
 }
 
diff --git a/src/mesa/main/dispatch.c b/src/mesa/main/dispatch.c
index 34127cb248..bf1a013789 100644
--- a/src/mesa/main/dispatch.c
+++ b/src/mesa/main/dispatch.c
@@ -40,6 +40,7 @@
 #ifndef GLX_USE_APPLEGL
 
 #include "main/glheader.h"
+#include "main/compiler.h"
 #include "glapi/glapi.h"
 #include "glapi/glapitable.h"
 #include "glapi/glthread.h"
diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c
index d3aee196c7..f793b60284 100644
--- a/src/mesa/main/dlist.c
+++ b/src/mesa/main/dlist.c
@@ -33,6 +33,7 @@
 #include "api_arrayelt.h"
 #include "api_loopback.h"
 #include "config.h"
+#include "mfeatures.h"
 #include "attrib.h"
 #include "blend.h"
 #include "buffers.h"
@@ -72,6 +73,7 @@
 #include "texstate.h"
 #include "mtypes.h"
 #include "varray.h"
+#include "vtxfmt.h"
 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
 #include "shader/arbprogram.h"
 #include "shader/program.h"
@@ -85,7 +87,6 @@
 #endif
 
 #include "math/m_matrix.h"
-#include "math/m_xform.h"
 
 #include "glapi/dispatch.h"
 
@@ -320,6 +321,8 @@ typedef enum
    /* GL_ARB_draw_buffers */
    OPCODE_DRAW_BUFFERS_ARB,
    /* GL_ATI_fragment_shader */
+   OPCODE_TEX_BUMP_PARAMETER_ATI,
+   /* GL_ATI_fragment_shader */
    OPCODE_BIND_FRAGMENT_SHADER_ATI,
    OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,
    /* OpenGL 2.0 */
@@ -350,6 +353,9 @@ typedef enum
    OPCODE_EVAL_P1,
    OPCODE_EVAL_P2,
 
+   /* GL_EXT_provoking_vertex */
+   OPCODE_PROVOKING_VERTEX,
+
    /* The following three are meta instructions */
    OPCODE_ERROR,                /* raise compiled-in error */
    OPCODE_CONTINUE,
@@ -370,7 +376,7 @@ typedef enum
  * contiguous nodes in memory.
  * Each node is the union of a variety of data types.
  */
-union node
+union gl_dlist_node
 {
    OpCode opcode;
    GLboolean b;
@@ -387,6 +393,9 @@ union node
 };
 
 
+typedef union gl_dlist_node Node;
+
+
 /**
  * How many nodes to allocate at a time.
  *
@@ -402,6 +411,10 @@ union node
  */
 static GLuint InstSize[OPCODE_END_OF_LIST + 1];
 
+
+#if FEATURE_dlist
+
+
 void mesa_print_display_list(GLuint list);
 
 
@@ -414,13 +427,13 @@ void mesa_print_display_list(GLuint list);
  * Make an empty display list.  This is used by glGenLists() to
  * reserve display list IDs.
  */
-static struct mesa_display_list *
-make_list(GLuint list, GLuint count)
+static struct gl_display_list *
+make_list(GLuint name, GLuint count)
 {
-   struct mesa_display_list *dlist = CALLOC_STRUCT(mesa_display_list);
-   dlist->id = list;
-   dlist->node = (Node *) _mesa_malloc(sizeof(Node) * count);
-   dlist->node[0].opcode = OPCODE_END_OF_LIST;
+   struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);
+   dlist->Name = name;
+   dlist->Head = (Node *) _mesa_malloc(sizeof(Node) * count);
+   dlist->Head[0].opcode = OPCODE_END_OF_LIST;
    return dlist;
 }
 
@@ -428,10 +441,10 @@ make_list(GLuint list, GLuint count)
 /**
  * Lookup function to just encapsulate casting.
  */
-static INLINE struct mesa_display_list *
+static INLINE struct gl_display_list *
 lookup_list(GLcontext *ctx, GLuint list)
 {
-   return (struct mesa_display_list *)
+   return (struct gl_display_list *)
       _mesa_HashLookup(ctx->Shared->DisplayList, list);
 }
 
@@ -442,12 +455,12 @@ lookup_list(GLcontext *ctx, GLuint list)
  * \param dlist - display list pointer
  */
 void
-_mesa_delete_list(GLcontext *ctx, struct mesa_display_list *dlist)
+_mesa_delete_list(GLcontext *ctx, struct gl_display_list *dlist)
 {
    Node *n, *block;
    GLboolean done;
 
-   n = block = dlist->node;
+   n = block = dlist->Head;
 
    done = block ? GL_FALSE : GL_TRUE;
    while (!done) {
@@ -596,7 +609,7 @@ _mesa_delete_list(GLcontext *ctx, struct mesa_display_list *dlist)
 static void
 destroy_list(GLcontext *ctx, GLuint list)
 {
-   struct mesa_display_list *dlist;
+   struct gl_display_list *dlist;
 
    if (list == 0)
       return;
@@ -675,24 +688,48 @@ translate_id(GLsizei n, GLenum type, const GLvoid * list)
 
 /**
  * Wrapper for _mesa_unpack_image() that handles pixel buffer objects.
- * \todo This won't suffice when the PBO is really in VRAM/GPU memory.
+ * If we run out of memory, GL_OUT_OF_MEMORY will be recorded.
  */
 static GLvoid *
-unpack_image(GLuint dimensions, GLsizei width, GLsizei height, GLsizei depth,
+unpack_image(GLcontext *ctx, GLuint dimensions,
+             GLsizei width, GLsizei height, GLsizei depth,
              GLenum format, GLenum type, const GLvoid * pixels,
              const struct gl_pixelstore_attrib *unpack)
 {
-   if (unpack->BufferObj->Name == 0) {
+   if (!_mesa_is_bufferobj(unpack->BufferObj)) {
       /* no PBO */
-      return _mesa_unpack_image(dimensions, width, height, depth, format,
-                                type, pixels, unpack);
+      GLvoid *image = _mesa_unpack_image(dimensions, width, height, depth,
+                                         format, type, pixels, unpack);
+      if (pixels && !image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
+      }
+      return image;
    }
-   else
-      if (_mesa_validate_pbo_access
-          (dimensions, unpack, width, height, depth, format, type, pixels)) {
-      const GLubyte *src = ADD_POINTERS(unpack->BufferObj->Data, pixels);
-      return _mesa_unpack_image(dimensions, width, height, depth, format,
-                                type, src, unpack);
+   else if (_mesa_validate_pbo_access(dimensions, unpack, width, height, depth,
+                                      format, type, pixels)) {
+      const GLubyte *map, *src;
+      GLvoid *image;
+
+      map = (GLubyte *)
+         ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
+                               GL_READ_ONLY_ARB, unpack->BufferObj);
+      if (!map) {
+         /* unable to map src buffer! */
+         _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");
+         return NULL;
+      }
+
+      src = ADD_POINTERS(map, pixels);
+      image = _mesa_unpack_image(dimensions, width, height, depth,
+                                 format, type, src, unpack);
+
+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
+                              unpack->BufferObj);
+
+      if (!image) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
+      }
+      return image;
    }
    /* bad access! */
    return NULL;
@@ -702,7 +739,7 @@ unpack_image(GLuint dimensions, GLsizei width, GLsizei height, GLsizei depth,
 /**
  * Allocate space for a display list instruction.
  * \param opcode  the instruction opcode (OPCODE_* value)
- * \param size   instruction size in bytes, not counting opcode.
+ * \param bytes   instruction size in bytes, not counting opcode.
  * \return pointer to the usable data area (not including the internal
  *         opcode).
  */
@@ -850,7 +887,6 @@ save_Bitmap(GLsizei width, GLsizei height,
             GLfloat xmove, GLfloat ymove, const GLubyte * pixels)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);
    Node *n;
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
    n = ALLOC_INSTRUCTION(ctx, OPCODE_BITMAP, 7);
@@ -861,10 +897,7 @@ save_Bitmap(GLsizei width, GLsizei height,
       n[4].f = yorig;
       n[5].f = xmove;
       n[6].f = ymove;
-      n[7].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[7].data = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_Bitmap(ctx->Exec, (width, height,
@@ -952,6 +985,20 @@ save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
    }
 }
 
+static void invalidate_saved_current_state( GLcontext *ctx )
+{
+   GLint i;
+
+   for (i = 0; i < VERT_ATTRIB_MAX; i++)
+      ctx->ListState.ActiveAttribSize[i] = 0;
+
+   for (i = 0; i < MAT_ATTRIB_MAX; i++)
+      ctx->ListState.ActiveMaterialSize[i] = 0;
+
+   memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);
+
+   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
+}
 
 void GLAPIENTRY
 _mesa_save_CallList(GLuint list)
@@ -965,18 +1012,19 @@ _mesa_save_CallList(GLuint list)
       n[1].ui = list;
    }
 
-   /* After this, we don't know what begin/end state we're in:
+   /* After this, we don't know what state we're in.  Invalidate all
+    * cached information previously gathered:
     */
-   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
+   invalidate_saved_current_state( ctx );
 
    if (ctx->ExecuteFlag) {
-      CALL_CallList(ctx->Exec, (list));
+      _mesa_CallList(list);
    }
 }
 
 
 void GLAPIENTRY
-_mesa_save_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
+_mesa_save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
@@ -1001,7 +1049,7 @@ _mesa_save_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
       typeErrorFlag = GL_TRUE;
    }
 
-   for (i = 0; i < n; i++) {
+   for (i = 0; i < num; i++) {
       GLint list = translate_id(i, type, lists);
       Node *n = ALLOC_INSTRUCTION(ctx, OPCODE_CALL_LIST_OFFSET, 2);
       if (n) {
@@ -1010,12 +1058,13 @@ _mesa_save_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
       }
    }
 
-   /* After this, we don't know what begin/end state we're in:
+   /* After this, we don't know what state we're in.  Invalidate all
+    * cached information previously gathered:
     */
-   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
+   invalidate_saved_current_state( ctx );
 
    if (ctx->ExecuteFlag) {
-      CALL_CallLists(ctx->Exec, (n, type, lists));
+      CALL_CallLists(ctx->Exec, (num, type, lists));
    }
 }
 
@@ -1193,8 +1242,6 @@ save_ColorTable(GLenum target, GLenum internalFormat,
                                   format, type, table));
    }
    else {
-      GLvoid *image = unpack_image(1, width, 1, 1, format, type, table,
-                                   &ctx->Unpack);
       Node *n;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_TABLE, 6);
@@ -1204,10 +1251,8 @@ save_ColorTable(GLenum target, GLenum internalFormat,
          n[3].i = width;
          n[4].e = format;
          n[5].e = type;
-         n[6].data = image;
-      }
-      else if (image) {
-         _mesa_free(image);
+         n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, table,
+                                  &ctx->Unpack);
       }
       if (ctx->ExecuteFlag) {
          CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
@@ -1283,8 +1328,6 @@ save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,
                    GLenum format, GLenum type, const GLvoid * table)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = unpack_image(1, count, 1, 1, format, type, table,
-                                &ctx->Unpack);
    Node *n;
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
    n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_SUB_TABLE, 6);
@@ -1294,10 +1337,8 @@ save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,
       n[3].i = count;
       n[4].e = format;
       n[5].e = type;
-      n[6].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[6].data = unpack_image(ctx, 1, count, 1, 1, format, type, table,
+                               &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_ColorSubTable(ctx->Exec,
@@ -1355,10 +1396,10 @@ save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
                          GLenum format, GLenum type, const GLvoid * filter)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = unpack_image(1, width, 1, 1, format, type, filter,
-                                &ctx->Unpack);
    Node *n;
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_FILTER_1D, 6);
    if (n) {
       n[1].e = target;
@@ -1366,10 +1407,8 @@ save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
       n[3].i = width;
       n[4].e = format;
       n[5].e = type;
-      n[6].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[6].data = unpack_image(ctx, 1, width, 1, 1, format, type, filter,
+                               &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_ConvolutionFilter1D(ctx->Exec, (target, internalFormat, width,
@@ -1384,10 +1423,10 @@ save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
                          GLenum type, const GLvoid * filter)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = unpack_image(2, width, height, 1, format, type, filter,
-                                &ctx->Unpack);
    Node *n;
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_FILTER_2D, 7);
    if (n) {
       n[1].e = target;
@@ -1396,10 +1435,8 @@ save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
       n[4].i = height;
       n[5].e = format;
       n[6].e = type;
-      n[7].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[7].data = unpack_image(ctx, 2, width, height, 1, format, type, filter,
+                               &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_ConvolutionFilter2D(ctx->Exec,
@@ -1754,20 +1791,18 @@ save_DrawPixels(GLsizei width, GLsizei height,
                 GLenum format, GLenum type, const GLvoid * pixels)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = unpack_image(2, width, height, 1, format, type,
-                                pixels, &ctx->Unpack);
    Node *n;
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_DRAW_PIXELS, 5);
    if (n) {
       n[1].i = width;
       n[2].i = height;
       n[3].e = format;
       n[4].e = type;
-      n[5].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[5].data = unpack_image(ctx, 2, width, height, 1, format, type,
+                               pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
@@ -1794,7 +1829,7 @@ save_Enable(GLenum cap)
 
 
 static void GLAPIENTRY
-_mesa_save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
+save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
@@ -1812,7 +1847,7 @@ _mesa_save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
 
 
 static void GLAPIENTRY
-_mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
@@ -1856,7 +1891,10 @@ save_Fogfv(GLenum pname, const GLfloat *params)
 static void GLAPIENTRY
 save_Fogf(GLenum pname, GLfloat param)
 {
-   save_Fogfv(pname, &param);
+   GLfloat parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_Fogfv(pname, parray);
 }
 
 
@@ -1880,7 +1918,7 @@ save_Fogiv(GLenum pname, const GLint *params)
       break;
    default:
       /* Error will be caught later in gl_Fogfv */
-      ;
+      ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
    }
    save_Fogfv(pname, p);
 }
@@ -1889,7 +1927,10 @@ save_Fogiv(GLenum pname, const GLint *params)
 static void GLAPIENTRY
 save_Fogi(GLenum pname, GLint param)
 {
-   save_Fogiv(pname, &param);
+   GLint parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0;
+   save_Fogiv(pname, parray);
 }
 
 
@@ -2053,9 +2094,12 @@ save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
 
 
 static void GLAPIENTRY
-save_Lightf(GLenum light, GLenum pname, GLfloat params)
+save_Lightf(GLenum light, GLenum pname, GLfloat param)
 {
-   save_Lightfv(light, pname, &params);
+   GLfloat parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_Lightfv(light, pname, parray);
 }
 
 
@@ -2101,7 +2145,10 @@ save_Lightiv(GLenum light, GLenum pname, const GLint *params)
 static void GLAPIENTRY
 save_Lighti(GLenum light, GLenum pname, GLint param)
 {
-   save_Lightiv(light, pname, &param);
+   GLint parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0;
+   save_Lightiv(light, pname, parray);
 }
 
 
@@ -2128,7 +2175,10 @@ save_LightModelfv(GLenum pname, const GLfloat *params)
 static void GLAPIENTRY
 save_LightModelf(GLenum pname, GLfloat param)
 {
-   save_LightModelfv(pname, &param);
+   GLfloat parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_LightModelfv(pname, parray);
 }
 
 
@@ -2150,7 +2200,7 @@ save_LightModeliv(GLenum pname, const GLint *params)
       break;
    default:
       /* Error will be caught later in gl_LightModelfv */
-      ;
+      ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);
    }
    save_LightModelfv(pname, fparam);
 }
@@ -2159,7 +2209,10 @@ save_LightModeliv(GLenum pname, const GLint *params)
 static void GLAPIENTRY
 save_LightModeli(GLenum pname, GLint param)
 {
-   save_LightModeliv(pname, &param);
+   GLint parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0;
+   save_LightModeliv(pname, parray);
 }
 
 
@@ -2521,12 +2574,12 @@ save_MultMatrixd(const GLdouble * m)
 
 
 static void GLAPIENTRY
-save_NewList(GLuint list, GLenum mode)
+save_NewList(GLuint name, GLenum mode)
 {
    GET_CURRENT_CONTEXT(ctx);
    /* It's an error to call this function while building a display list */
    _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
-   (void) list;
+   (void) name;
    (void) mode;
 }
 
@@ -2674,21 +2727,28 @@ save_PointParameterfvEXT(GLenum pname, const GLfloat *params)
 static void GLAPIENTRY
 save_PointParameterfEXT(GLenum pname, GLfloat param)
 {
-   save_PointParameterfvEXT(pname, &param);
+   GLfloat parray[3];
+   parray[0] = param;
+   parray[1] = parray[2] = 0.0F;
+   save_PointParameterfvEXT(pname, parray);
 }
 
 static void GLAPIENTRY
 save_PointParameteriNV(GLenum pname, GLint param)
 {
-   GLfloat p = (GLfloat) param;
-   save_PointParameterfvEXT(pname, &p);
+   GLfloat parray[3];
+   parray[0] = (GLfloat) param;
+   parray[1] = parray[2] = 0.0F;
+   save_PointParameterfvEXT(pname, parray);
 }
 
 static void GLAPIENTRY
 save_PointParameterivNV(GLenum pname, const GLint * param)
 {
-   GLfloat p = (GLfloat) param[0];
-   save_PointParameterfvEXT(pname, &p);
+   GLfloat parray[3];
+   parray[0] = (GLfloat) param[0];
+   parray[1] = parray[2] = 0.0F;
+   save_PointParameterfvEXT(pname, parray);
 }
 
 
@@ -2729,16 +2789,14 @@ static void GLAPIENTRY
 save_PolygonStipple(const GLubyte * pattern)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLvoid *image = unpack_image(2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
-                                pattern, &ctx->Unpack);
    Node *n;
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_POLYGON_STIPPLE, 1);
    if (n) {
-      n[1].data = image; 
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[1].data = unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
+                               pattern, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
@@ -3172,14 +3230,26 @@ save_ShadeModel(GLenum mode)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);
+
+   if (ctx->ExecuteFlag) {
+      CALL_ShadeModel(ctx->Exec, (mode));
+   }
+
+   if (ctx->ListState.Current.ShadeModel == mode)
+      return;
+
+   SAVE_FLUSH_VERTICES(ctx);
+
+   /* Only save the value if we know the statechange will take effect:
+    */
+   if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)
+      ctx->ListState.Current.ShadeModel = mode;
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_SHADE_MODEL, 1);
    if (n) {
       n[1].e = mode;
    }
-   if (ctx->ExecuteFlag) {
-      CALL_ShadeModel(ctx->Exec, (mode));
-   }
 }
 
 
@@ -3350,7 +3420,10 @@ save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 static void GLAPIENTRY
 save_TexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-   save_TexEnvfv(target, pname, &param);
+   GLfloat parray[4];
+   parray[0] = (GLfloat) param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_TexEnvfv(target, pname, parray);
 }
 
 
@@ -3418,8 +3491,10 @@ save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
 static void GLAPIENTRY
 save_TexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-   GLfloat p = (GLfloat) param;
-   save_TexGenfv(coord, pname, &p);
+   GLfloat parray[4];
+   parray[0] = (GLfloat) param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_TexGenfv(coord, pname, parray);
 }
 
 
@@ -3438,14 +3513,20 @@ save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 static void GLAPIENTRY
 save_TexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-   save_TexGenfv(coord, pname, &param);
+   GLfloat parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_TexGenfv(coord, pname, parray);
 }
 
 
 static void GLAPIENTRY
 save_TexGeni(GLenum coord, GLenum pname, GLint param)
 {
-   save_TexGeniv(coord, pname, &param);
+   GLint parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0;
+   save_TexGeniv(coord, pname, parray);
 }
 
 
@@ -3473,7 +3554,10 @@ save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 static void GLAPIENTRY
 save_TexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-   save_TexParameterfv(target, pname, &param);
+   GLfloat parray[4];
+   parray[0] = param;
+   parray[1] = parray[2] = parray[3] = 0.0F;
+   save_TexParameterfv(target, pname, parray);
 }
 
 
@@ -3510,8 +3594,6 @@ save_TexImage1D(GLenum target,
                                   border, format, type, pixels));
    }
    else {
-      GLvoid *image = unpack_image(1, width, 1, 1, format, type,
-                                   pixels, &ctx->Unpack);
       Node *n;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE1D, 8);
@@ -3523,10 +3605,8 @@ save_TexImage1D(GLenum target,
          n[5].i = border;
          n[6].e = format;
          n[7].e = type;
-         n[8].data = image;
-      }
-      else if (image) {
-         _mesa_free(image);
+         n[8].data = unpack_image(ctx, 1, width, 1, 1, format, type,
+                                  pixels, &ctx->Unpack);
       }
       if (ctx->ExecuteFlag) {
          CALL_TexImage1D(ctx->Exec, (target, level, components, width,
@@ -3549,8 +3629,6 @@ save_TexImage2D(GLenum target,
                                   height, border, format, type, pixels));
    }
    else {
-      GLvoid *image = unpack_image(2, width, height, 1, format, type,
-                                   pixels, &ctx->Unpack);
       Node *n;
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE2D, 9);
@@ -3563,10 +3641,8 @@ save_TexImage2D(GLenum target,
          n[6].i = border;
          n[7].e = format;
          n[8].e = type;
-         n[9].data = image;
-      }
-      else if (image) {
-         _mesa_free(image);
+         n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
+                                  pixels, &ctx->Unpack);
       }
       if (ctx->ExecuteFlag) {
          CALL_TexImage2D(ctx->Exec, (target, level, components, width,
@@ -3592,8 +3668,6 @@ save_TexImage3D(GLenum target,
    }
    else {
       Node *n;
-      GLvoid *image = unpack_image(3, width, height, depth, format, type,
-                                   pixels, &ctx->Unpack);
       ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
       n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE3D, 10);
       if (n) {
@@ -3606,10 +3680,8 @@ save_TexImage3D(GLenum target,
          n[7].i = border;
          n[8].e = format;
          n[9].e = type;
-         n[10].data = image;
-      }
-      else if (image) {
-         _mesa_free(image);
+         n[10].data = unpack_image(ctx, 3, width, height, depth, format, type,
+                                   pixels, &ctx->Unpack);
       }
       if (ctx->ExecuteFlag) {
          CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
@@ -3627,9 +3699,9 @@ save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLvoid *image = unpack_image(1, width, 1, 1, format, type,
-                                pixels, &ctx->Unpack);
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE1D, 7);
    if (n) {
       n[1].e = target;
@@ -3638,10 +3710,8 @@ save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
       n[4].i = (GLint) width;
       n[5].e = format;
       n[6].e = type;
-      n[7].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[7].data = unpack_image(ctx, 1, width, 1, 1, format, type,
+                               pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
@@ -3658,9 +3728,9 @@ save_TexSubImage2D(GLenum target, GLint level,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLvoid *image = unpack_image(2, width, height, 1, format, type,
-                                pixels, &ctx->Unpack);
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE2D, 9);
    if (n) {
       n[1].e = target;
@@ -3671,10 +3741,8 @@ save_TexSubImage2D(GLenum target, GLint level,
       n[6].i = (GLint) height;
       n[7].e = format;
       n[8].e = type;
-      n[9].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[9].data = unpack_image(ctx, 2, width, height, 1, format, type,
+                               pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
@@ -3691,9 +3759,9 @@ save_TexSubImage3D(GLenum target, GLint level,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLvoid *image = unpack_image(3, width, height, depth, format, type,
-                                pixels, &ctx->Unpack);
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE3D, 11);
    if (n) {
       n[1].e = target;
@@ -3706,10 +3774,8 @@ save_TexSubImage3D(GLenum target, GLint level,
       n[8].i = (GLint) depth;
       n[9].e = format;
       n[10].e = type;
-      n[11].data = image;
-   }
-   else if (image) {
-      _mesa_free(image);
+      n[11].data = unpack_image(ctx, 3, width, height, depth, format, type,
+                                pixels, &ctx->Unpack);
    }
    if (ctx->ExecuteFlag) {
       CALL_TexSubImage3D(ctx->Exec, (target, level,
@@ -4422,18 +4488,17 @@ save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLubyte *programCopy;
-
-   programCopy = (GLubyte *) _mesa_malloc(len);
-   if (!programCopy) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
-      return;
-   }
-   _mesa_memcpy(programCopy, program, len);
 
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_LOAD_PROGRAM_NV, 4);
    if (n) {
+      GLubyte *programCopy = (GLubyte *) _mesa_malloc(len);
+      if (!programCopy) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
+         return;
+      }
+      _mesa_memcpy(programCopy, program, len);
       n[1].e = target;
       n[2].ui = id;
       n[3].i = len;
@@ -4450,15 +4515,17 @@ save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLuint *idCopy = (GLuint *) _mesa_malloc(num * sizeof(GLuint));
-   if (!idCopy) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
-      return;
-   }
-   _mesa_memcpy(idCopy, ids, num * sizeof(GLuint));
+
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_TRACK_MATRIX_NV, 2);
    if (n) {
+      GLuint *idCopy = (GLuint *) _mesa_malloc(num * sizeof(GLuint));
+      if (!idCopy) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
+         return;
+      }
+      _mesa_memcpy(idCopy, ids, num * sizeof(GLuint));
       n[1].i = num;
       n[2].data = idCopy;
    }
@@ -4619,16 +4686,17 @@ save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLubyte *nameCopy = (GLubyte *) _mesa_malloc(len);
-   if (!nameCopy) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
-      return;
-   }
-   _mesa_memcpy(nameCopy, name, len);
 
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);
    if (n) {
+      GLubyte *nameCopy = (GLubyte *) _mesa_malloc(len);
+      if (!nameCopy) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
+         return;
+      }
+      _mesa_memcpy(nameCopy, name, len);
       n[1].ui = id;
       n[2].i = len;
       n[3].data = nameCopy;
@@ -4717,18 +4785,17 @@ save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
-   GLubyte *programCopy;
-
-   programCopy = (GLubyte *) _mesa_malloc(len);
-   if (!programCopy) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
-      return;
-   }
-   _mesa_memcpy(programCopy, string, len);
 
    ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+
    n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_STRING_ARB, 4);
    if (n) {
+      GLubyte *programCopy = (GLubyte *) _mesa_malloc(len);
+      if (!programCopy) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
+         return;
+      }
+      _mesa_memcpy(programCopy, string, len);
       n[1].e = target;
       n[2].e = format;
       n[3].i = len;
@@ -4742,7 +4809,7 @@ save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
 #endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */
 
 
-#if FEATURE_ARB_occlusion_query
+#if FEATURE_queryobj
 
 static void GLAPIENTRY
 save_BeginQueryARB(GLenum target, GLuint id)
@@ -4776,7 +4843,7 @@ save_EndQueryARB(GLenum target)
    }
 }
 
-#endif /* FEATURE_ARB_occlusion_query */
+#endif /* FEATURE_queryobj */
 
 
 static void GLAPIENTRY
@@ -4800,6 +4867,36 @@ save_DrawBuffersARB(GLsizei count, const GLenum * buffers)
    }
 }
 
+static void GLAPIENTRY
+save_TexBumpParameterfvATI(GLenum pname, const GLfloat *param)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_BUMP_PARAMETER_ATI, 5);
+   if (n) {
+      n[1].ui = pname;
+      n[2].f = param[0];
+      n[3].f = param[1];
+      n[4].f = param[2];
+      n[5].f = param[3];
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_TexBumpParameterfvATI(ctx->Exec, (pname, param));
+   }
+}
+
+static void GLAPIENTRY
+save_TexBumpParameterivATI(GLenum pname, const GLint *param)
+{
+   GLfloat p[4];
+   p[0] = INT_TO_FLOAT(param[0]);
+   p[1] = INT_TO_FLOAT(param[1]);
+   p[2] = INT_TO_FLOAT(param[2]);
+   p[3] = INT_TO_FLOAT(param[3]);
+   save_TexBumpParameterfvATI(pname, p);
+}
+
 #if FEATURE_ATI_fragment_shader
 static void GLAPIENTRY
 save_BindFragmentShaderATI(GLuint id)
@@ -4848,7 +4945,7 @@ save_Attr1fNV(GLenum attr, GLfloat x)
       n[2].f = x;
    }
 
-   ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 1;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
 
@@ -4870,7 +4967,7 @@ save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
       n[3].f = y;
    }
 
-   ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 2;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
 
@@ -4893,7 +4990,7 @@ save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
       n[4].f = z;
    }
 
-   ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 3;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
 
@@ -4917,7 +5014,7 @@ save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
       n[5].f = w;
    }
 
-   ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 4;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
 
@@ -4939,7 +5036,7 @@ save_Attr1fARB(GLenum attr, GLfloat x)
       n[2].f = x;
    }
 
-   ASSERT(attr < MAX_VERTEX_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 1;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
 
@@ -4961,7 +5058,7 @@ save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
       n[3].f = y;
    }
 
-   ASSERT(attr < MAX_VERTEX_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 2;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
 
@@ -4984,7 +5081,7 @@ save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
       n[4].f = z;
    }
 
-   ASSERT(attr < MAX_VERTEX_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 3;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
 
@@ -5008,7 +5105,7 @@ save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
       n[5].f = w;
    }
 
-   ASSERT(attr < MAX_VERTEX_ATTRIBS);
+   ASSERT(attr < MAX_VERTEX_GENERIC_ATTRIBS);
    ctx->ListState.ActiveAttribSize[attr] = 4;
    ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
 
@@ -5111,14 +5208,21 @@ save_EdgeFlag(GLboolean x)
    save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? (GLfloat)1.0 : (GLfloat)0.0);
 }
 
+static INLINE GLboolean compare4fv( const GLfloat *a,
+                                    const GLfloat *b,
+                                    GLuint count )
+{
+   return memcmp( a, b, count * sizeof(GLfloat) ) == 0;
+}
+                              
+
 static void GLAPIENTRY
 save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
 {
    GET_CURRENT_CONTEXT(ctx);
    Node *n;
    int args, i;
-
-   SAVE_FLUSH_VERTICES(ctx);
+   GLuint bitmask;
 
    switch (face) {
    case GL_BACK:
@@ -5148,26 +5252,43 @@ save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
       _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(pname)");
       return;
    }
-
-   n = ALLOC_INSTRUCTION(ctx, OPCODE_MATERIAL, 6);
-   if (n) {
-      n[1].e = face;
-      n[2].e = pname;
-      for (i = 0; i < args; i++)
-         n[3 + i].f = param[i];
+   
+   if (ctx->ExecuteFlag) {
+      CALL_Materialfv(ctx->Exec, (face, pname, param));
    }
 
-   {
-      GLuint bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
-      for (i = 0; i < MAT_ATTRIB_MAX; i++)
-         if (bitmask & (1 << i)) {
+   bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
+
+   /* Try to eliminate redundant statechanges.  Because it is legal to
+    * call glMaterial even inside begin/end calls, don't need to worry
+    * about ctx->Driver.CurrentSavePrimitive here.
+    */
+   for (i = 0; i < MAT_ATTRIB_MAX; i++) {
+      if (bitmask & (1 << i)) {
+         if (ctx->ListState.ActiveMaterialSize[i] == args &&
+             compare4fv(ctx->ListState.CurrentMaterial[i], param, args)) {
+            bitmask &= ~(1 << i);
+         }
+         else {
             ctx->ListState.ActiveMaterialSize[i] = args;
             COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
          }
+      }
    }
 
-   if (ctx->ExecuteFlag) {
-      CALL_Materialfv(ctx->Exec, (face, pname, param));
+   /* If this call has effect, return early:
+    */
+   if (bitmask == 0)
+      return;
+
+   SAVE_FLUSH_VERTICES(ctx);
+
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_MATERIAL, 6);
+   if (n) {
+      n[1].e = face;
+      n[2].e = pname;
+      for (i = 0; i < args; i++)
+         n[3 + i].f = param[i];
    }
 }
 
@@ -5471,7 +5592,7 @@ index_error(void)
 static void GLAPIENTRY
 save_VertexAttrib1fNV(GLuint index, GLfloat x)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr1fNV(index, x);
    else
       index_error();
@@ -5480,7 +5601,7 @@ save_VertexAttrib1fNV(GLuint index, GLfloat x)
 static void GLAPIENTRY
 save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr1fNV(index, v[0]);
    else
       index_error();
@@ -5489,7 +5610,7 @@ save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
 static void GLAPIENTRY
 save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr2fNV(index, x, y);
    else
       index_error();
@@ -5498,7 +5619,7 @@ save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
 static void GLAPIENTRY
 save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr2fNV(index, v[0], v[1]);
    else
       index_error();
@@ -5507,7 +5628,7 @@ save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
 static void GLAPIENTRY
 save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr3fNV(index, x, y, z);
    else
       index_error();
@@ -5516,7 +5637,7 @@ save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 static void GLAPIENTRY
 save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr3fNV(index, v[0], v[1], v[2]);
    else
       index_error();
@@ -5526,7 +5647,7 @@ static void GLAPIENTRY
 save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
                       GLfloat z, GLfloat w)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr4fNV(index, x, y, z, w);
    else
       index_error();
@@ -5535,7 +5656,7 @@ save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
 static void GLAPIENTRY
 save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
+   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS)
       save_Attr4fNV(index, v[0], v[1], v[2], v[3]);
    else
       index_error();
@@ -5547,7 +5668,7 @@ save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
 static void GLAPIENTRY
 save_VertexAttrib1fARB(GLuint index, GLfloat x)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr1fARB(index, x);
    else
       index_error();
@@ -5556,7 +5677,7 @@ save_VertexAttrib1fARB(GLuint index, GLfloat x)
 static void GLAPIENTRY
 save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr1fARB(index, v[0]);
    else
       index_error();
@@ -5565,7 +5686,7 @@ save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
 static void GLAPIENTRY
 save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr2fARB(index, x, y);
    else
       index_error();
@@ -5574,7 +5695,7 @@ save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
 static void GLAPIENTRY
 save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr2fARB(index, v[0], v[1]);
    else
       index_error();
@@ -5583,7 +5704,7 @@ save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
 static void GLAPIENTRY
 save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr3fARB(index, x, y, z);
    else
       index_error();
@@ -5592,7 +5713,7 @@ save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 static void GLAPIENTRY
 save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr3fARB(index, v[0], v[1], v[2]);
    else
       index_error();
@@ -5602,7 +5723,7 @@ static void GLAPIENTRY
 save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
                        GLfloat w)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr4fARB(index, x, y, z, w);
    else
       index_error();
@@ -5611,7 +5732,7 @@ save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
 static void GLAPIENTRY
 save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
 {
-   if (index < MAX_VERTEX_ATTRIBS)
+   if (index < MAX_VERTEX_GENERIC_ATTRIBS)
       save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
    else
       index_error();
@@ -5670,6 +5791,25 @@ save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 #endif
 
 
+/** GL_EXT_provoking_vertex */
+static void GLAPIENTRY
+save_ProvokingVertexEXT(GLenum mode)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = ALLOC_INSTRUCTION(ctx, OPCODE_PROVOKING_VERTEX, 1);
+   if (n) {
+      n[1].e = mode;
+   }
+   if (ctx->ExecuteFlag) {
+      /*CALL_ProvokingVertexEXT(ctx->Exec, (mode));*/
+      _mesa_ProvokingVertexEXT(mode);
+   }
+}
+
+
+
 /**
  * Save an error-generating command into display list.
  *
@@ -5731,7 +5871,7 @@ islist(GLcontext *ctx, GLuint list)
 static void
 execute_list(GLcontext *ctx, GLuint list)
 {
-   struct mesa_display_list *dlist;
+   struct gl_display_list *dlist;
    Node *n;
    GLboolean done;
 
@@ -5752,7 +5892,7 @@ execute_list(GLcontext *ctx, GLuint list)
    if (ctx->Driver.BeginCallList)
       ctx->Driver.BeginCallList(ctx, dlist);
 
-   n = dlist->node;
+   n = dlist->Head;
 
    done = GL_FALSE;
    while (!done) {
@@ -6234,6 +6374,9 @@ execute_list(GLcontext *ctx, GLuint list)
          case OPCODE_SHADE_MODEL:
             CALL_ShadeModel(ctx->Exec, (n[1].e));
             break;
+         case OPCODE_PROVOKING_VERTEX:
+            CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e));
+            break;
          case OPCODE_STENCIL_FUNC:
             CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
             break;
@@ -6478,7 +6621,7 @@ execute_list(GLcontext *ctx, GLuint list)
                                                       n[6].f));
             break;
 #endif
-#if FEATURE_ARB_occlusion_query
+#if FEATURE_queryobj
          case OPCODE_BEGIN_QUERY_ARB:
             CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));
             break;
@@ -6502,6 +6645,16 @@ execute_list(GLcontext *ctx, GLuint list)
                                                 n[9].i, n[10].e));
 	    break;
 #endif
+         case OPCODE_TEX_BUMP_PARAMETER_ATI:
+            {
+               GLfloat values[4];
+               GLuint i, pname = n[1].ui;
+
+               for (i = 0; i < 4; i++)
+                  values[i] = n[1 + i].f;
+               CALL_TexBumpParameterfvATI(ctx->Exec, (pname, values));
+            }
+            break;
 #if FEATURE_ATI_fragment_shader
          case OPCODE_BIND_FRAGMENT_SHADER_ATI:
             CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
@@ -6723,19 +6876,18 @@ _mesa_GenLists(GLsizei range)
  * Begin a new display list.
  */
 void GLAPIENTRY
-_mesa_NewList(GLuint list, GLenum mode)
+_mesa_NewList(GLuint name, GLenum mode)
 {
    GET_CURRENT_CONTEXT(ctx);
-   GLint i;
 
    FLUSH_CURRENT(ctx, 0);       /* must be called before assert */
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glNewList %u %s\n", list,
+      _mesa_debug(ctx, "glNewList %u %s\n", name,
                   _mesa_lookup_enum_by_nr(mode));
 
-   if (list == 0) {
+   if (name == 0) {
       _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
       return;
    }
@@ -6745,7 +6897,7 @@ _mesa_NewList(GLuint list, GLenum mode)
       return;
    }
 
-   if (ctx->ListState.CurrentListPtr) {
+   if (ctx->ListState.CurrentList) {
       /* already compiling a display list */
       _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
       return;
@@ -6754,23 +6906,16 @@ _mesa_NewList(GLuint list, GLenum mode)
    ctx->CompileFlag = GL_TRUE;
    ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
 
-   /* Allocate new display list */
-   ctx->ListState.CurrentListNum = list;
-   ctx->ListState.CurrentList = make_list(list, BLOCK_SIZE);
-   ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->node;
-   ctx->ListState.CurrentListPtr = ctx->ListState.CurrentBlock;
-   ctx->ListState.CurrentPos = 0;
-
    /* Reset acumulated list state:
     */
-   for (i = 0; i < VERT_ATTRIB_MAX; i++)
-      ctx->ListState.ActiveAttribSize[i] = 0;
+   invalidate_saved_current_state( ctx );
 
-   for (i = 0; i < MAT_ATTRIB_MAX; i++)
-      ctx->ListState.ActiveMaterialSize[i] = 0;
+   /* Allocate new display list */
+   ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);
+   ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;
+   ctx->ListState.CurrentPos = 0;
 
-   ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
-   ctx->Driver.NewList(ctx, list, mode);
+   ctx->Driver.NewList(ctx, name, mode);
 
    ctx->CurrentDispatch = ctx->Save;
    _glapi_set_dispatch(ctx->CurrentDispatch);
@@ -6791,7 +6936,7 @@ _mesa_EndList(void)
       _mesa_debug(ctx, "glEndList\n");
 
    /* Check that a list is under construction */
-   if (!ctx->ListState.CurrentListPtr) {
+   if (!ctx->ListState.CurrentList) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
       return;
    }
@@ -6804,18 +6949,18 @@ _mesa_EndList(void)
    (void) ALLOC_INSTRUCTION(ctx, OPCODE_END_OF_LIST, 0);
 
    /* Destroy old list, if any */
-   destroy_list(ctx, ctx->ListState.CurrentListNum);
-   /* Install the list */
-   _mesa_HashInsert(ctx->Shared->DisplayList, ctx->ListState.CurrentListNum,
+   destroy_list(ctx, ctx->ListState.CurrentList->Name);
+
+   /* Install the new list */
+   _mesa_HashInsert(ctx->Shared->DisplayList,
+                    ctx->ListState.CurrentList->Name,
                     ctx->ListState.CurrentList);
 
 
    if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
-      mesa_print_display_list(ctx->ListState.CurrentListNum);
+      mesa_print_display_list(ctx->ListState.CurrentList->Name);
 
    ctx->ListState.CurrentList = NULL;
-   ctx->ListState.CurrentListNum = 0;
-   ctx->ListState.CurrentListPtr = NULL;
    ctx->ExecuteFlag = GL_TRUE;
    ctx->CompileFlag = GL_FALSE;
 
@@ -7611,18 +7756,6 @@ exec_MultiDrawArraysEXT(GLenum mode, GLint * first,
    CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount));
 }
 
-/* GL_EXT_multi_draw_arrays */
-static void GLAPIENTRY
-exec_MultiDrawElementsEXT(GLenum mode, const GLsizei * count,
-                          GLenum type, const GLvoid ** indices,
-                          GLsizei primcount)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   FLUSH_VERTICES(ctx, 0);
-   CALL_MultiDrawElementsEXT(ctx->Exec,
-                             (mode, count, type, indices, primcount));
-}
-
 /* GL_IBM_multimode_draw_arrays */
 static void GLAPIENTRY
 exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first,
@@ -7661,7 +7794,7 @@ exec_MultiModeDrawElementsIBM(const GLenum * mode,
  * struct.
  */
 void
-_mesa_init_dlist_table(struct _glapi_table *table)
+_mesa_init_save_table(struct _glapi_table *table)
 {
    _mesa_loopback_init_api_table(table);
 
@@ -7692,8 +7825,8 @@ _mesa_init_dlist_table(struct _glapi_table *table)
    SET_DrawPixels(table, save_DrawPixels);
    SET_Enable(table, save_Enable);
    SET_EndList(table, _mesa_EndList);
-   SET_EvalMesh1(table, _mesa_save_EvalMesh1);
-   SET_EvalMesh2(table, _mesa_save_EvalMesh2);
+   SET_EvalMesh1(table, save_EvalMesh1);
+   SET_EvalMesh2(table, save_EvalMesh2);
    SET_Finish(table, exec_Finish);
    SET_Flush(table, exec_Flush);
    SET_Fogf(table, save_Fogf);
@@ -7968,7 +8101,6 @@ _mesa_init_dlist_table(struct _glapi_table *table)
 
    /* 148. GL_EXT_multi_draw_arrays */
    SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);
-   SET_MultiDrawElementsEXT(table, exec_MultiDrawElementsEXT);
 
    /* 149. GL_EXT_fog_coord */
    SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);
@@ -8042,6 +8174,10 @@ _mesa_init_dlist_table(struct _glapi_table *table)
    SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);
 #endif
 
+   /* 244. GL_ATI_envmap_bumpmap */
+   SET_TexBumpParameterivATI(table, save_TexBumpParameterivATI);
+   SET_TexBumpParameterfvATI(table, save_TexBumpParameterfvATI);
+
    /* 245. GL_ATI_fragment_shader */
 #if FEATURE_ATI_fragment_shader
    SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
@@ -8162,7 +8298,7 @@ _mesa_init_dlist_table(struct _glapi_table *table)
    SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);
 #endif
 
-#if FEATURE_ARB_occlusion_query
+#if FEATURE_queryobj
    SET_BeginQueryARB(table, save_BeginQueryARB);
    SET_EndQueryARB(table, save_EndQueryARB);
    SET_GenQueriesARB(table, _mesa_GenQueriesARB);
@@ -8191,6 +8327,18 @@ _mesa_init_dlist_table(struct _glapi_table *table)
    SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
    SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
 #endif
+
+   /* ARB 50. GL_ARB_map_buffer_range */
+#if FEATURE_ARB_map_buffer_range
+   SET_MapBufferRange(table, _mesa_MapBufferRange); /* no dlist save */
+   SET_FlushMappedBufferRange(table, _mesa_FlushMappedBufferRange); /* no dl */
+#endif
+
+   /* ARB 59. GL_ARB_copy_buffer */
+   SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */
+
+   /* 364. GL_EXT_provoking_vertex */
+   SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT);
 }
 
 
@@ -8209,7 +8357,7 @@ enum_string(GLenum k)
 static void GLAPIENTRY
 print_list(GLcontext *ctx, GLuint list)
 {
-   struct mesa_display_list *dlist;
+   struct gl_display_list *dlist;
    Node *n;
    GLboolean done;
 
@@ -8222,7 +8370,7 @@ print_list(GLcontext *ctx, GLuint list)
    if (!dlist)
       return;
 
-   n = dlist->node;
+   n = dlist->Head;
 
    _mesa_printf("START-LIST %u, address %p\n", list, (void *) n);
 
@@ -8427,6 +8575,11 @@ print_list(GLcontext *ctx, GLuint list)
             _mesa_printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
             break;
 
+         case OPCODE_PROVOKING_VERTEX:
+            _mesa_printf("ProvokingVertex %s\n",
+                         _mesa_lookup_enum_by_nr(n[1].ui));
+            break;
+
             /*
              * meta opcodes/commands
              */
@@ -8484,22 +8637,21 @@ mesa_print_display_list(GLuint list)
 void
 _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
 {
-   vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */
+   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
+
    vfmt->Begin = save_Begin;
-   vfmt->CallList = _mesa_save_CallList;
-   vfmt->CallLists = _mesa_save_CallLists;
+
+   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_save_);
+
    vfmt->Color3f = save_Color3f;
    vfmt->Color3fv = save_Color3fv;
    vfmt->Color4f = save_Color4f;
    vfmt->Color4fv = save_Color4fv;
    vfmt->EdgeFlag = save_EdgeFlag;
    vfmt->End = save_End;
-   vfmt->EvalCoord1f = save_EvalCoord1f;
-   vfmt->EvalCoord1fv = save_EvalCoord1fv;
-   vfmt->EvalCoord2f = save_EvalCoord2f;
-   vfmt->EvalCoord2fv = save_EvalCoord2fv;
-   vfmt->EvalPoint1 = save_EvalPoint1;
-   vfmt->EvalPoint2 = save_EvalPoint2;
+
+   _MESA_INIT_EVAL_VTXFMT(vfmt, save_);
+
    vfmt->FogCoordfEXT = save_FogCoordfEXT;
    vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
    vfmt->Indexf = save_Indexf;
@@ -8548,8 +8700,6 @@ _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
    vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
    vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
 
-   vfmt->EvalMesh1 = _mesa_save_EvalMesh1;
-   vfmt->EvalMesh2 = _mesa_save_EvalMesh2;
    vfmt->Rectf = save_Rectf;
 
    /* The driver is required to implement these as
@@ -8562,10 +8712,40 @@ _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
    vfmt->DrawArrays = 0;
    vfmt->DrawElements = 0;
    vfmt->DrawRangeElements = 0;
+   vfmt->MultiDrawElemementsEXT = 0;
+   vfmt->DrawElementsBaseVertex = 0;
+   vfmt->DrawRangeElementsBaseVertex = 0;
+   vfmt->MultiDrawElemementsBaseVertex = 0;
 #endif
 }
 
 
+void
+_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
+                           const GLvertexformat *vfmt)
+{
+   SET_CallList(disp, vfmt->CallList);
+   SET_CallLists(disp, vfmt->CallLists);
+}
+
+
+void _mesa_init_dlist_dispatch(struct _glapi_table *disp)
+{
+   SET_CallList(disp, _mesa_CallList);
+   SET_CallLists(disp, _mesa_CallLists);
+
+   SET_DeleteLists(disp, _mesa_DeleteLists);
+   SET_EndList(disp, _mesa_EndList);
+   SET_GenLists(disp, _mesa_GenLists);
+   SET_IsList(disp, _mesa_IsList);
+   SET_ListBase(disp, _mesa_ListBase);
+   SET_NewList(disp, _mesa_NewList);
+}
+
+
+#endif /* FEATURE_dlist */
+
+
 /**
  * Initialize display list state for given context.
  */
@@ -8584,13 +8764,13 @@ _mesa_init_display_list(GLcontext *ctx)
    ctx->ListState.CallDepth = 0;
    ctx->ExecuteFlag = GL_TRUE;
    ctx->CompileFlag = GL_FALSE;
-   ctx->ListState.CurrentListPtr = NULL;
    ctx->ListState.CurrentBlock = NULL;
-   ctx->ListState.CurrentListNum = 0;
    ctx->ListState.CurrentPos = 0;
 
    /* Display List group */
    ctx->List.ListBase = 0;
 
+#if FEATURE_dlist
    _mesa_save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
+#endif
 }
diff --git a/src/mesa/main/dlist.h b/src/mesa/main/dlist.h
index ef6a10af83..6e1059eac2 100644
--- a/src/mesa/main/dlist.h
+++ b/src/mesa/main/dlist.h
@@ -33,13 +33,26 @@
 #define DLIST_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
 
-#if _HAVE_FULL_GL
+#if FEATURE_dlist
 
-extern void
-_mesa_delete_list(GLcontext *ctx, struct mesa_display_list *dlist);
+#define _MESA_INIT_DLIST_FUNCTIONS(driver, impl)               \
+   do {                                                        \
+      (driver)->NewList           = impl ## NewList;           \
+      (driver)->EndList           = impl ## EndList;           \
+      (driver)->BeginCallList     = impl ## BeginCallList;     \
+      (driver)->EndCallList       = impl ## EndCallList;       \
+      (driver)->SaveFlushVertices = impl ## SaveFlushVertices; \
+      (driver)->NotifySaveBegin   = impl ## NotifyBegin;       \
+   } while (0)
+
+#define _MESA_INIT_DLIST_VTXFMT(vfmt, impl)  \
+   do {                                      \
+      (vfmt)->CallList  = impl ## CallList;  \
+      (vfmt)->CallLists = impl ## CallLists; \
+   } while (0)
 
 extern void GLAPIENTRY _mesa_CallList( GLuint list );
 
@@ -62,12 +75,8 @@ extern void GLAPIENTRY _mesa_save_CallLists( GLsizei n, GLenum type, const GLvoi
 extern void GLAPIENTRY _mesa_save_CallList( GLuint list );
 
 
-
-extern void _mesa_init_dlist_table( struct _glapi_table *table );
-
 extern void _mesa_compile_error( GLcontext *ctx, GLenum error, const char *s );
 
-
 extern void *_mesa_alloc_instruction(GLcontext *ctx, GLuint opcode, GLuint sz);
 
 extern GLint _mesa_alloc_opcode( GLcontext *ctx, GLuint sz,
@@ -75,22 +84,48 @@ extern GLint _mesa_alloc_opcode( GLcontext *ctx, GLuint sz,
                                  void (*destroy)( GLcontext *, void * ),
                                  void (*print)( GLcontext *, void * ) );
 
-extern void _mesa_init_display_list( GLcontext * ctx );
+extern void _mesa_delete_list(GLcontext *ctx, struct gl_display_list *dlist);
 
 extern void _mesa_save_vtxfmt_init( GLvertexformat *vfmt );
 
+extern void _mesa_init_save_table( struct _glapi_table *table );
+
+extern void _mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
+                                       const GLvertexformat *vfmt);
 
-#else
+extern void _mesa_init_dlist_dispatch(struct _glapi_table *disp);
 
-/** No-op */
-#define _mesa_init_dlist_table(t,ts) ((void)0)
+#else /* FEATURE_dlist */
 
-/** No-op */
-#define _mesa_init_display_list(c) ((void)0)
+#define _MESA_INIT_DLIST_FUNCTIONS(driver, impl) do { } while (0)
+#define _MESA_INIT_DLIST_VTXFMT(vfmt, impl) do { } while (0)
 
-/** No-op */
-#define _mesa_save_vtxfmt_init(v) ((void)0)
+static INLINE void
+_mesa_delete_list(GLcontext *ctx, struct gl_display_list *dlist)
+{
+   /* there should be no list to delete */
+   ASSERT_NO_FEATURE();
+}
+
+static INLINE void
+_mesa_init_save_table(struct _glapi_table *disp)
+{
+}
+
+static INLINE void
+_mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
+                           const GLvertexformat *vfmt)
+{
+}
+
+static INLINE void 
+_mesa_init_dlist_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_dlist */
+
+extern void _mesa_init_display_list( GLcontext * ctx );
 
-#endif
 
-#endif
+#endif /* DLIST_H */
diff --git a/src/mesa/main/dlopen.c b/src/mesa/main/dlopen.c
index becef8173e..414cfad8e2 100644
--- a/src/mesa/main/dlopen.c
+++ b/src/mesa/main/dlopen.c
@@ -28,13 +28,15 @@
  */
 
 
-#include "glheader.h"
-#include "imports.h"
+#include "compiler.h"
 #include "dlopen.h"
 
 #if defined(_GNU_SOURCE) && !defined(__MINGW32__)
 #include <dlfcn.h>
 #endif
+#if defined(_WIN32)
+#include <windows.h>
+#endif
 
 
 /**
@@ -48,7 +50,7 @@ _mesa_dlopen(const char *libname, int flags)
    flags = RTLD_LAZY | RTLD_GLOBAL; /* Overriding flags at this time */
    return dlopen(libname, flags);
 #elif defined(__MINGW32__)
-   return LoadLibrary(libname);
+   return LoadLibraryA(libname);
 #else
    return NULL;
 #endif
diff --git a/src/mesa/main/drawpix.c b/src/mesa/main/drawpix.c
index ac97bc1ff9..f7ce64fd7c 100644
--- a/src/mesa/main/drawpix.c
+++ b/src/mesa/main/drawpix.c
@@ -27,14 +27,28 @@
 #include "bufferobj.h"
 #include "context.h"
 #include "drawpix.h"
+#include "enums.h"
 #include "feedback.h"
 #include "framebuffer.h"
 #include "image.h"
 #include "readpix.h"
 #include "state.h"
+#include "glapi/dispatch.h"
 
 
-#if _HAVE_FULL_GL
+#if FEATURE_drawpix
+
+
+/**
+ * If a fragment program is enabled, check that it's valid.
+ * \return GL_TRUE if valid, GL_FALSE otherwise
+ */
+static GLboolean
+valid_fragment_program(GLcontext *ctx)
+{
+   return !(ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled);
+}
+
 
 /*
  * Execute glDrawPixels
@@ -51,59 +65,66 @@ _mesa_DrawPixels( GLsizei width, GLsizei height,
       return;
    }
 
+   /* We're not using the current vertex program, and the driver may install
+    * it's own.
+    */
+   _mesa_set_vp_override(ctx, GL_TRUE);
+
    if (ctx->NewState) {
       _mesa_update_state(ctx);
    }
 
-   if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
+   if (!valid_fragment_program(ctx)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glDrawPixels (invalid fragment program)");
-      return;
+      goto end;
    }
 
    if (_mesa_error_check_format_type(ctx, format, type, GL_TRUE)) {
-      /* found an error */
-      return;
+      /* the error was already recorded */
+      goto end;
    }
 
    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
                   "glDrawPixels(incomplete framebuffer)" );
-      return;
+      goto end;
    }
 
    if (!ctx->Current.RasterPosValid) {
-      return;
+      goto end; /* no-op, not an error */
    }
 
    if (ctx->RenderMode == GL_RENDER) {
-      /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
-      GLint x = IROUND(ctx->Current.RasterPos[0]);
-      GLint y = IROUND(ctx->Current.RasterPos[1]);
-
-      if (ctx->Unpack.BufferObj->Name) {
-         /* unpack from PBO */
-         if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
-                                        format, type, pixels)) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glDrawPixels(invalid PBO access)");
-            return;
-         }
-         if (ctx->Unpack.BufferObj->Pointer) {
-            /* buffer is mapped - that's an error */
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glDrawPixels(PBO is mapped)");
-            return;
+      if (width > 0 && height > 0) {
+         /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
+         GLint x = IROUND(ctx->Current.RasterPos[0]);
+         GLint y = IROUND(ctx->Current.RasterPos[1]);
+
+         if (ctx->Unpack.BufferObj->Name) {
+            /* unpack from PBO */
+            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
+                                           format, type, pixels)) {
+               _mesa_error(ctx, GL_INVALID_OPERATION,
+                           "glDrawPixels(invalid PBO access)");
+               goto end;
+            }
+            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
+               /* buffer is mapped - that's an error */
+               _mesa_error(ctx, GL_INVALID_OPERATION,
+                           "glDrawPixels(PBO is mapped)");
+               goto end;
+            }
          }
-      }
 
-      ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
-			     &ctx->Unpack, pixels);
+         ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
+                                &ctx->Unpack, pixels);
+      }
    }
    else if (ctx->RenderMode == GL_FEEDBACK) {
       /* Feedback the current raster pos info */
       FLUSH_CURRENT( ctx, 0 );
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
       _mesa_feedback_vertex( ctx,
                              ctx->Current.RasterPos,
                              ctx->Current.RasterColor,
@@ -114,6 +135,9 @@ _mesa_DrawPixels( GLsizei width, GLsizei height,
       ASSERT(ctx->RenderMode == GL_SELECT);
       /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
    }
+
+end:
+   _mesa_set_vp_override(ctx, GL_FALSE);
 }
 
 
@@ -124,49 +148,69 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   if (width < 0 || height < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");
+      return;
+   }
+
+   /* Note: more detailed 'type' checking is done by the
+    * _mesa_source/dest_buffer_exists() calls below.  That's where we
+    * check if the stencil buffer exists, etc.
+    */
+   if (type != GL_COLOR &&
+       type != GL_DEPTH &&
+       type != GL_STENCIL &&
+       type != GL_DEPTH_STENCIL) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glCopyPixels(type=%s)",
+                  _mesa_lookup_enum_by_nr(type));
+      return;
+   }
+
+   /* We're not using the current vertex program, and the driver may install
+    * it's own.
+    */
+   _mesa_set_vp_override(ctx, GL_TRUE);
+
    if (ctx->NewState) {
       _mesa_update_state(ctx);
    }
 
-   if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
+   if (!valid_fragment_program(ctx)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glCopyPixels (invalid fragment program)");
-      return;
-   }
-
-   if (width < 0 || height < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");
-      return;
+      goto end;
    }
 
    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||
        ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
                   "glCopyPixels(incomplete framebuffer)" );
-      return;
+      goto end;
    }
 
    if (!_mesa_source_buffer_exists(ctx, type) ||
        !_mesa_dest_buffer_exists(ctx, type)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glCopyPixels(missing source or dest buffer)");
-      return;
+      goto end;
    }
 
-   if (!ctx->Current.RasterPosValid) {
-      return;
+   if (!ctx->Current.RasterPosValid || width ==0 || height == 0) {
+      goto end; /* no-op, not an error */
    }
 
    if (ctx->RenderMode == GL_RENDER) {
       /* Round to satisfy conformance tests (matches SGI's OpenGL) */
-      GLint destx = IROUND(ctx->Current.RasterPos[0]);
-      GLint desty = IROUND(ctx->Current.RasterPos[1]);
-      ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
-			      type );
+      if (width > 0 && height > 0) {
+         GLint destx = IROUND(ctx->Current.RasterPos[0]);
+         GLint desty = IROUND(ctx->Current.RasterPos[1]);
+         ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
+                                 type );
+      }
    }
    else if (ctx->RenderMode == GL_FEEDBACK) {
       FLUSH_CURRENT( ctx, 0 );
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
       _mesa_feedback_vertex( ctx, 
                              ctx->Current.RasterPos,
                              ctx->Current.RasterColor,
@@ -177,10 +221,10 @@ _mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
       ASSERT(ctx->RenderMode == GL_SELECT);
       /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
    }
-}
-
-#endif /* _HAVE_FULL_GL */
 
+end:
+   _mesa_set_vp_override(ctx, GL_FALSE);
+}
 
 
 void GLAPIENTRY
@@ -204,7 +248,7 @@ _mesa_Bitmap( GLsizei width, GLsizei height,
       _mesa_update_state(ctx);
    }
 
-   if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
+   if (!valid_fragment_program(ctx)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glBitmap (invalid fragment program)");
       return;
@@ -218,32 +262,35 @@ _mesa_Bitmap( GLsizei width, GLsizei height,
 
    if (ctx->RenderMode == GL_RENDER) {
       /* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
-      const GLfloat epsilon = (const GLfloat)0.0001;
-      GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig);
-      GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig);
-
-      if (ctx->Unpack.BufferObj->Name) {
-         /* unpack from PBO */
-         if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
-                                        GL_COLOR_INDEX, GL_BITMAP,
-                                        (GLvoid *) bitmap)) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glBitmap(invalid PBO access)");
-            return;
-         }
-         if (ctx->Unpack.BufferObj->Pointer) {
-            /* buffer is mapped - that's an error */
-            _mesa_error(ctx, GL_INVALID_OPERATION, "glBitmap(PBO is mapped)");
-            return;
+      if (width > 0 && height > 0) {
+         const GLfloat epsilon = 0.0001F;
+         GLint x = IFLOOR(ctx->Current.RasterPos[0] + epsilon - xorig);
+         GLint y = IFLOOR(ctx->Current.RasterPos[1] + epsilon - yorig);
+
+         if (ctx->Unpack.BufferObj->Name) {
+            /* unpack from PBO */
+            if (!_mesa_validate_pbo_access(2, &ctx->Unpack, width, height, 1,
+                                           GL_COLOR_INDEX, GL_BITMAP,
+                                           (GLvoid *) bitmap)) {
+               _mesa_error(ctx, GL_INVALID_OPERATION,
+                           "glBitmap(invalid PBO access)");
+               return;
+            }
+            if (_mesa_bufferobj_mapped(ctx->Unpack.BufferObj)) {
+               /* buffer is mapped - that's an error */
+               _mesa_error(ctx, GL_INVALID_OPERATION,
+                           "glBitmap(PBO is mapped)");
+               return;
+            }
          }
-      }
 
-      ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
+         ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
+      }
    }
 #if _HAVE_FULL_GL
    else if (ctx->RenderMode == GL_FEEDBACK) {
       FLUSH_CURRENT(ctx, 0);
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
       _mesa_feedback_vertex( ctx,
                              ctx->Current.RasterPos,
                              ctx->Current.RasterColor,
@@ -262,66 +309,13 @@ _mesa_Bitmap( GLsizei width, GLsizei height,
 }
 
 
-
-#if 0  /* experimental */
-/*
- * Execute glDrawDepthPixelsMESA().  This function accepts both a color
- * image and depth (Z) image.  Rasterization produces fragments with
- * color and Z taken from these images.  This function is intended for
- * Z-compositing.  Normally, this operation requires two glDrawPixels
- * calls with stencil testing.
- */
-void GLAPIENTRY
-_mesa_DrawDepthPixelsMESA( GLsizei width, GLsizei height,
-                           GLenum colorFormat, GLenum colorType,
-                           const GLvoid *colors,
-                           GLenum depthType, const GLvoid *depths )
+void 
+_mesa_init_drawpix_dispatch(struct _glapi_table *disp)
 {
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (width < 0 || height < 0) {
-      _mesa_error( ctx, GL_INVALID_VALUE,
-                   "glDrawDepthPixelsMESA(width or height < 0" );
-      return;
-   }
-
-   if (!ctx->Current.RasterPosValid) {
-      return;
-   }
-
-   if (ctx->NewState) {
-      _mesa_update_state(ctx);
-   }
-
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "glDrawDepthPixelsMESA(incomplete framebuffer)");
-      return;
-   }
-
-   if (ctx->RenderMode == GL_RENDER) {
-      /* Round, to satisfy conformance tests (matches SGI's OpenGL) */
-      GLint x = IROUND(ctx->Current.RasterPos[0]);
-      GLint y = IROUND(ctx->Current.RasterPos[1]);
-      ctx->Driver.DrawDepthPixelsMESA(ctx, x, y, width, height,
-                                      colorFormat, colorType, colors,
-                                      depthType, depths, &ctx->Unpack);
-   }
-   else if (ctx->RenderMode == GL_FEEDBACK) {
-      /* Feedback the current raster pos info */
-      FLUSH_CURRENT( ctx, 0 );
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
-      _mesa_feedback_vertex( ctx,
-                             ctx->Current.RasterPos,
-                             ctx->Current.RasterColor,
-                             ctx->Current.RasterIndex,
-                             ctx->Current.RasterTexCoords[0] );
-   }
-   else {
-      ASSERT(ctx->RenderMode == GL_SELECT);
-      /* Do nothing.  See OpenGL Spec, Appendix B, Corollary 6. */
-   }
+   SET_Bitmap(disp, _mesa_Bitmap);
+   SET_CopyPixels(disp, _mesa_CopyPixels);
+   SET_DrawPixels(disp, _mesa_DrawPixels);
 }
 
-#endif
+
+#endif /* FEATURE_drawpix */
diff --git a/src/mesa/main/drawpix.h b/src/mesa/main/drawpix.h
index 6177adad6d..01564b3ed7 100644
--- a/src/mesa/main/drawpix.h
+++ b/src/mesa/main/drawpix.h
@@ -22,13 +22,21 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#ifndef DRAWPIX_H
+#define DRAWPIX_H
 
-#ifndef DRAWPIXELS_H
-#define DRAWPIXELS_H
 
+#include "main/mtypes.h"
 
-#include "main/glheader.h"
 
+#if FEATURE_drawpix
+
+#define _MESA_INIT_DRAWPIX_FUNCTIONS(driver, impl) \
+   do {                                            \
+      (driver)->DrawPixels = impl ## DrawPixels;   \
+      (driver)->CopyPixels = impl ## CopyPixels;   \
+      (driver)->Bitmap     = impl ## Bitmap;       \
+   } while (0)
 
 extern void GLAPIENTRY
 _mesa_DrawPixels( GLsizei width, GLsizei height,
@@ -45,5 +53,19 @@ _mesa_Bitmap( GLsizei width, GLsizei height,
               GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
               const GLubyte *bitmap );
 
+extern void 
+_mesa_init_drawpix_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_drawpix */
+
+#define _MESA_INIT_DRAWPIX_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void 
+_mesa_init_drawpix_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_drawpix */
+
 
-#endif
+#endif /* DRAWPIX_H */
diff --git a/src/mesa/main/enable.c b/src/mesa/main/enable.c
index dae576ae5a..4c1f46102d 100644
--- a/src/mesa/main/enable.c
+++ b/src/mesa/main/enable.c
@@ -36,8 +36,6 @@
 #include "simple_list.h"
 #include "mtypes.h"
 #include "enums.h"
-#include "math/m_matrix.h"
-#include "math/m_xform.h"
 #include "api_arrayelt.h"
 
 
@@ -120,6 +118,7 @@ client_state(GLcontext *ctx, GLenum cap, GLboolean state)
          CHECK_EXTENSION(NV_vertex_program, cap);
          {
             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
             var = &ctx->Array.ArrayObj->VertexAttrib[n].Enabled;
             flag = _NEW_ARRAY_ATTRIB(n);
          }
@@ -223,14 +222,16 @@ get_texcoord_unit(GLcontext *ctx)
 
 /**
  * Helper function to enable or disable a texture target.
+ * \param bit  one of the TEXTURE_x_BIT values
+ * \return GL_TRUE if state is changing or GL_FALSE if no change
  */
 static GLboolean
-enable_texture(GLcontext *ctx, GLboolean state, GLbitfield bit)
+enable_texture(GLcontext *ctx, GLboolean state, GLbitfield texBit)
 {
    const GLuint curr = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[curr];
-   const GLuint newenabled = (!state)
-       ? (texUnit->Enabled & ~bit) :  (texUnit->Enabled | bit);
+   const GLbitfield newenabled = state
+      ? (texUnit->Enabled | texBit) : (texUnit->Enabled & ~texBit);
 
    if (!ctx->DrawBuffer->Visual.rgbMode || texUnit->Enabled == newenabled)
        return GL_FALSE;
@@ -603,11 +604,6 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
          ctx->Texture.SharedPalette = state;
          break;
       case GL_STENCIL_TEST:
-         if (state && ctx->DrawBuffer->Visual.stencilBits == 0) {
-            _mesa_warning(ctx,
-                          "glEnable(GL_STENCIL_TEST) but no stencil buffer");
-            return;
-         }
          if (ctx->Stencil.Enabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_STENCIL);
@@ -772,35 +768,30 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.Enabled == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.Enabled = state;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleAlphaToCoverage == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleAlphaToCoverage = state;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleAlphaToOne == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleAlphaToOne = state;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleCoverage == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
          ctx->Multisample.SampleCoverage = state;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXTENSION(ARB_multisample, cap);
          if (ctx->Multisample.SampleCoverageInvert == state)
             return;
          FLUSH_VERTICES(ctx, _NEW_MULTISAMPLE);
@@ -922,10 +913,13 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
             return;
          FLUSH_VERTICES(ctx, _NEW_STENCIL);
          ctx->Stencil.TestTwoSide = state;
-         if (state)
+         if (state) {
+            ctx->Stencil._BackFace = 2;
             ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
-         else
+         } else {
+            ctx->Stencil._BackFace = 1;
             ctx->_TriangleCaps &= ~DD_TRI_TWOSTENCIL;
+         }
          break;
 
 #if FEATURE_ARB_fragment_program
@@ -952,15 +946,13 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
          ctx->Depth.BoundsTest = state;
          break;
 
-      /* GL_MESA_program_debug */
-      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-         CHECK_EXTENSION(MESA_program_debug, cap);
-         ctx->FragmentProgram.CallbackEnabled = state;
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-         CHECK_EXTENSION(MESA_program_debug, cap);
-         ctx->VertexProgram.CallbackEnabled = state;
-         break;
+      case GL_DEPTH_CLAMP:
+         if (ctx->Transform.DepthClamp == state)
+            return;
+	 CHECK_EXTENSION(ARB_depth_clamp, cap);
+         FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
+	 ctx->Transform.DepthClamp = state;
+	 break;
 
 #if FEATURE_ATI_fragment_shader
       case GL_FRAGMENT_SHADER_ATI:
@@ -987,6 +979,11 @@ _mesa_set_enable(GLcontext *ctx, GLenum cap, GLboolean state)
          }
          break;
 
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+	 CHECK_EXTENSION(ARB_seamless_cube_map, cap);
+	 ctx->Texture.CubeMapSeamless = state;
+	 break;
+
       default:
          _mesa_error(ctx, GL_INVALID_ENUM,
                      "%s(0x%x)", state ? "glEnable" : "glDisable", cap);
@@ -1281,19 +1278,14 @@ _mesa_IsEnabled( GLenum cap )
 
       /* GL_ARB_multisample */
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
          return ctx->Multisample.Enabled;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
          return ctx->Multisample.SampleAlphaToCoverage;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
          return ctx->Multisample.SampleAlphaToOne;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXTENSION(ARB_multisample);
          return ctx->Multisample.SampleCoverage;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXTENSION(ARB_multisample);
          return ctx->Multisample.SampleCoverageInvert;
 
       /* GL_IBM_rasterpos_clip */
@@ -1337,6 +1329,7 @@ _mesa_IsEnabled( GLenum cap )
          CHECK_EXTENSION(NV_vertex_program);
          {
             GLint n = (GLint) cap - GL_VERTEX_ATTRIB_ARRAY0_NV;
+            ASSERT(n < Elements(ctx->Array.ArrayObj->VertexAttrib));
             return (ctx->Array.ArrayObj->VertexAttrib[n].Enabled != 0);
          }
       case GL_MAP1_VERTEX_ATTRIB0_4_NV:
@@ -1409,18 +1402,21 @@ _mesa_IsEnabled( GLenum cap )
          CHECK_EXTENSION(EXT_depth_bounds_test);
          return ctx->Depth.BoundsTest;
 
-      /* GL_MESA_program_debug */
-      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-         CHECK_EXTENSION(MESA_program_debug);
-         return ctx->FragmentProgram.CallbackEnabled;
-      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-         CHECK_EXTENSION(MESA_program_debug);
-         return ctx->VertexProgram.CallbackEnabled;
+      /* GL_ARB_depth_clamp */
+      case GL_DEPTH_CLAMP:
+         CHECK_EXTENSION(ARB_depth_clamp);
+         return ctx->Transform.DepthClamp;
+
 #if FEATURE_ATI_fragment_shader
       case GL_FRAGMENT_SHADER_ATI:
 	 CHECK_EXTENSION(ATI_fragment_shader);
 	 return ctx->ATIFragmentShader.Enabled;
 #endif /* FEATURE_ATI_fragment_shader */
+
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+	 CHECK_EXTENSION(ARB_seamless_cube_map);
+	 return ctx->Texture.CubeMapSeamless;
+
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glIsEnabled(0x%x)", (int) cap);
 	 return GL_FALSE;
diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c
index 4796f3027a..2d1594eb7a 100644
--- a/src/mesa/main/enums.c
+++ b/src/mesa/main/enums.c
@@ -26,6 +26,7 @@
  */
 
 #include "glheader.h"
+#include "mfeatures.h"
 #include "enums.h"
 #include "imports.h"
 
@@ -81,6 +82,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_ALPHA_TEST\0"
    "GL_ALPHA_TEST_FUNC\0"
    "GL_ALPHA_TEST_REF\0"
+   "GL_ALREADY_SIGNALED\0"
    "GL_ALWAYS\0"
    "GL_AMBIENT\0"
    "GL_AMBIENT_AND_DIFFUSE\0"
@@ -119,6 +121,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_BLEND_EQUATION_ALPHA\0"
    "GL_BLEND_EQUATION_ALPHA_EXT\0"
    "GL_BLEND_EQUATION_EXT\0"
+   "GL_BLEND_EQUATION_RGB\0"
    "GL_BLEND_EQUATION_RGB_EXT\0"
    "GL_BLEND_SRC\0"
    "GL_BLEND_SRC_ALPHA\0"
@@ -137,14 +140,22 @@ LONGSTRING static const char enum_string_table[] =
    "GL_BOOL_VEC4_ARB\0"
    "GL_BUFFER_ACCESS\0"
    "GL_BUFFER_ACCESS_ARB\0"
+   "GL_BUFFER_FLUSHING_UNMAP_APPLE\0"
    "GL_BUFFER_MAPPED\0"
    "GL_BUFFER_MAPPED_ARB\0"
    "GL_BUFFER_MAP_POINTER\0"
    "GL_BUFFER_MAP_POINTER_ARB\0"
+   "GL_BUFFER_SERIALIZED_MODIFY_APPLE\0"
    "GL_BUFFER_SIZE\0"
    "GL_BUFFER_SIZE_ARB\0"
    "GL_BUFFER_USAGE\0"
    "GL_BUFFER_USAGE_ARB\0"
+   "GL_BUMP_ENVMAP_ATI\0"
+   "GL_BUMP_NUM_TEX_UNITS_ATI\0"
+   "GL_BUMP_ROT_MATRIX_ATI\0"
+   "GL_BUMP_ROT_MATRIX_SIZE_ATI\0"
+   "GL_BUMP_TARGET_ATI\0"
+   "GL_BUMP_TEX_UNITS_ATI\0"
    "GL_BYTE\0"
    "GL_C3F_V3F\0"
    "GL_C4F_N3F_V3F\0"
@@ -180,21 +191,37 @@ LONGSTRING static const char enum_string_table[] =
    "GL_COLOR_ARRAY_SIZE\0"
    "GL_COLOR_ARRAY_STRIDE\0"
    "GL_COLOR_ARRAY_TYPE\0"
+   "GL_COLOR_ATTACHMENT0\0"
    "GL_COLOR_ATTACHMENT0_EXT\0"
+   "GL_COLOR_ATTACHMENT1\0"
+   "GL_COLOR_ATTACHMENT10\0"
    "GL_COLOR_ATTACHMENT10_EXT\0"
+   "GL_COLOR_ATTACHMENT11\0"
    "GL_COLOR_ATTACHMENT11_EXT\0"
+   "GL_COLOR_ATTACHMENT12\0"
    "GL_COLOR_ATTACHMENT12_EXT\0"
+   "GL_COLOR_ATTACHMENT13\0"
    "GL_COLOR_ATTACHMENT13_EXT\0"
+   "GL_COLOR_ATTACHMENT14\0"
    "GL_COLOR_ATTACHMENT14_EXT\0"
+   "GL_COLOR_ATTACHMENT15\0"
    "GL_COLOR_ATTACHMENT15_EXT\0"
    "GL_COLOR_ATTACHMENT1_EXT\0"
+   "GL_COLOR_ATTACHMENT2\0"
    "GL_COLOR_ATTACHMENT2_EXT\0"
+   "GL_COLOR_ATTACHMENT3\0"
    "GL_COLOR_ATTACHMENT3_EXT\0"
+   "GL_COLOR_ATTACHMENT4\0"
    "GL_COLOR_ATTACHMENT4_EXT\0"
+   "GL_COLOR_ATTACHMENT5\0"
    "GL_COLOR_ATTACHMENT5_EXT\0"
+   "GL_COLOR_ATTACHMENT6\0"
    "GL_COLOR_ATTACHMENT6_EXT\0"
+   "GL_COLOR_ATTACHMENT7\0"
    "GL_COLOR_ATTACHMENT7_EXT\0"
+   "GL_COLOR_ATTACHMENT8\0"
    "GL_COLOR_ATTACHMENT8_EXT\0"
+   "GL_COLOR_ATTACHMENT9\0"
    "GL_COLOR_ATTACHMENT9_EXT\0"
    "GL_COLOR_BUFFER_BIT\0"
    "GL_COLOR_CLEAR_VALUE\0"
@@ -274,7 +301,12 @@ LONGSTRING static const char enum_string_table[] =
    "GL_COMPRESSED_RGB_ARB\0"
    "GL_COMPRESSED_RGB_FXT1_3DFX\0"
    "GL_COMPRESSED_RGB_S3TC_DXT1_EXT\0"
+   "GL_COMPRESSED_SLUMINANCE\0"
+   "GL_COMPRESSED_SLUMINANCE_ALPHA\0"
+   "GL_COMPRESSED_SRGB\0"
+   "GL_COMPRESSED_SRGB_ALPHA\0"
    "GL_COMPRESSED_TEXTURE_FORMATS\0"
+   "GL_CONDITION_SATISFIED\0"
    "GL_CONSTANT\0"
    "GL_CONSTANT_ALPHA\0"
    "GL_CONSTANT_ALPHA_EXT\0"
@@ -306,6 +338,8 @@ LONGSTRING static const char enum_string_table[] =
    "GL_COPY\0"
    "GL_COPY_INVERTED\0"
    "GL_COPY_PIXEL_TOKEN\0"
+   "GL_COPY_READ_BUFFER\0"
+   "GL_COPY_WRITE_BUFFER\0"
    "GL_CULL_FACE\0"
    "GL_CULL_FACE_MODE\0"
    "GL_CULL_VERTEX_EXT\0"
@@ -332,6 +366,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_CURRENT_RASTER_INDEX\0"
    "GL_CURRENT_RASTER_POSITION\0"
    "GL_CURRENT_RASTER_POSITION_VALID\0"
+   "GL_CURRENT_RASTER_SECONDARY_COLOR\0"
    "GL_CURRENT_RASTER_TEXTURE_COORDS\0"
    "GL_CURRENT_SECONDARY_COLOR\0"
    "GL_CURRENT_TEXTURE_COORDS\0"
@@ -348,12 +383,15 @@ LONGSTRING static const char enum_string_table[] =
    "GL_DECR_WRAP_EXT\0"
    "GL_DELETE_STATUS\0"
    "GL_DEPTH\0"
+   "GL_DEPTH24_STENCIL8\0"
+   "GL_DEPTH_ATTACHMENT\0"
    "GL_DEPTH_ATTACHMENT_EXT\0"
    "GL_DEPTH_BIAS\0"
    "GL_DEPTH_BITS\0"
    "GL_DEPTH_BOUNDS_EXT\0"
    "GL_DEPTH_BOUNDS_TEST_EXT\0"
    "GL_DEPTH_BUFFER_BIT\0"
+   "GL_DEPTH_CLAMP\0"
    "GL_DEPTH_CLAMP_NV\0"
    "GL_DEPTH_CLEAR_VALUE\0"
    "GL_DEPTH_COMPONENT\0"
@@ -369,6 +407,8 @@ LONGSTRING static const char enum_string_table[] =
    "GL_DEPTH_FUNC\0"
    "GL_DEPTH_RANGE\0"
    "GL_DEPTH_SCALE\0"
+   "GL_DEPTH_STENCIL\0"
+   "GL_DEPTH_STENCIL_ATTACHMENT\0"
    "GL_DEPTH_STENCIL_NV\0"
    "GL_DEPTH_STENCIL_TO_BGRA_NV\0"
    "GL_DEPTH_STENCIL_TO_RGBA_NV\0"
@@ -437,11 +477,14 @@ LONGSTRING static const char enum_string_table[] =
    "GL_DRAW_BUFFER9\0"
    "GL_DRAW_BUFFER9_ARB\0"
    "GL_DRAW_BUFFER9_ATI\0"
+   "GL_DRAW_FRAMEBUFFER\0"
    "GL_DRAW_FRAMEBUFFER_BINDING_EXT\0"
    "GL_DRAW_FRAMEBUFFER_EXT\0"
    "GL_DRAW_PIXEL_TOKEN\0"
    "GL_DST_ALPHA\0"
    "GL_DST_COLOR\0"
+   "GL_DU8DV8_ATI\0"
+   "GL_DUDV_ATI\0"
    "GL_DYNAMIC_COPY\0"
    "GL_DYNAMIC_COPY_ARB\0"
    "GL_DYNAMIC_DRAW\0"
@@ -476,14 +519,21 @@ LONGSTRING static const char enum_string_table[] =
    "GL_FEEDBACK_BUFFER_SIZE\0"
    "GL_FEEDBACK_BUFFER_TYPE\0"
    "GL_FILL\0"
+   "GL_FIRST_VERTEX_CONVENTION_EXT\0"
    "GL_FLAT\0"
    "GL_FLOAT\0"
    "GL_FLOAT_MAT2\0"
    "GL_FLOAT_MAT2_ARB\0"
+   "GL_FLOAT_MAT2x3\0"
+   "GL_FLOAT_MAT2x4\0"
    "GL_FLOAT_MAT3\0"
    "GL_FLOAT_MAT3_ARB\0"
+   "GL_FLOAT_MAT3x2\0"
+   "GL_FLOAT_MAT3x4\0"
    "GL_FLOAT_MAT4\0"
    "GL_FLOAT_MAT4_ARB\0"
+   "GL_FLOAT_MAT4x2\0"
+   "GL_FLOAT_MAT4x3\0"
    "GL_FLOAT_VEC2\0"
    "GL_FLOAT_VEC2_ARB\0"
    "GL_FLOAT_VEC3\0"
@@ -522,23 +572,44 @@ LONGSTRING static const char enum_string_table[] =
    "GL_FRAGMENT_SHADER\0"
    "GL_FRAGMENT_SHADER_ARB\0"
    "GL_FRAGMENT_SHADER_DERIVATIVE_HINT\0"
+   "GL_FRAMEBUFFER\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME\0"
    "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE\0"
    "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE\0"
    "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE\0"
    "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER\0"
    "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL\0"
    "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT\0"
    "GL_FRAMEBUFFER_BINDING_EXT\0"
+   "GL_FRAMEBUFFER_COMPLETE\0"
    "GL_FRAMEBUFFER_COMPLETE_EXT\0"
+   "GL_FRAMEBUFFER_DEFAULT\0"
    "GL_FRAMEBUFFER_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\0"
    "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\0"
    "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\0"
    "GL_FRAMEBUFFER_STATUS_ERROR_EXT\0"
+   "GL_FRAMEBUFFER_UNDEFINED\0"
+   "GL_FRAMEBUFFER_UNSUPPORTED\0"
    "GL_FRAMEBUFFER_UNSUPPORTED_EXT\0"
    "GL_FRONT\0"
    "GL_FRONT_AND_BACK\0"
@@ -556,30 +627,6 @@ LONGSTRING static const char enum_string_table[] =
    "GL_GENERATE_MIPMAP_HINT_SGIS\0"
    "GL_GENERATE_MIPMAP_SGIS\0"
    "GL_GEQUAL\0"
-   "GL_GL_BLEND_EQUATION_RGB\0"
-   "GL_GL_COMPRESSED_SLUMINANCE\0"
-   "GL_GL_COMPRESSED_SLUMINANCE_ALPHA\0"
-   "GL_GL_COMPRESSED_SRGB\0"
-   "GL_GL_COMPRESSED_SRGB_ALPHA\0"
-   "GL_GL_CURRENT_RASTER_SECONDARY_COLOR\0"
-   "GL_GL_FLOAT_MAT2x3\0"
-   "GL_GL_FLOAT_MAT2x4\0"
-   "GL_GL_FLOAT_MAT3x2\0"
-   "GL_GL_FLOAT_MAT3x4\0"
-   "GL_GL_FLOAT_MAT4x2\0"
-   "GL_GL_FLOAT_MAT4x3\0"
-   "GL_GL_PIXEL_PACK_BUFFER\0"
-   "GL_GL_PIXEL_PACK_BUFFER_BINDING\0"
-   "GL_GL_PIXEL_UNPACK_BUFFER\0"
-   "GL_GL_PIXEL_UNPACK_BUFFER_BINDING\0"
-   "GL_GL_SLUMINANCE\0"
-   "GL_GL_SLUMINANCE8\0"
-   "GL_GL_SLUMINANCE8_ALPHA8\0"
-   "GL_GL_SLUMINANCE_ALPHA\0"
-   "GL_GL_SRGB\0"
-   "GL_GL_SRGB8\0"
-   "GL_GL_SRGB8_ALPHA8\0"
-   "GL_GL_SRGB_ALPHA\0"
    "GL_GREATER\0"
    "GL_GREEN\0"
    "GL_GREEN_BIAS\0"
@@ -611,6 +658,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_INCR\0"
    "GL_INCR_WRAP\0"
    "GL_INCR_WRAP_EXT\0"
+   "GL_INDEX\0"
    "GL_INDEX_ARRAY\0"
    "GL_INDEX_ARRAY_BUFFER_BINDING\0"
    "GL_INDEX_ARRAY_BUFFER_BINDING_ARB\0"
@@ -646,6 +694,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_INT_VEC4\0"
    "GL_INT_VEC4_ARB\0"
    "GL_INVALID_ENUM\0"
+   "GL_INVALID_FRAMEBUFFER_OPERATION\0"
    "GL_INVALID_FRAMEBUFFER_OPERATION_EXT\0"
    "GL_INVALID_OPERATION\0"
    "GL_INVALID_VALUE\0"
@@ -653,6 +702,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_INVERSE_TRANSPOSE_NV\0"
    "GL_INVERT\0"
    "GL_KEEP\0"
+   "GL_LAST_VERTEX_CONVENTION_EXT\0"
    "GL_LEFT\0"
    "GL_LEQUAL\0"
    "GL_LESS\0"
@@ -778,7 +828,13 @@ LONGSTRING static const char enum_string_table[] =
    "GL_MAP2_VERTEX_ATTRIB8_4_NV\0"
    "GL_MAP2_VERTEX_ATTRIB9_4_NV\0"
    "GL_MAP_COLOR\0"
+   "GL_MAP_FLUSH_EXPLICIT_BIT\0"
+   "GL_MAP_INVALIDATE_BUFFER_BIT\0"
+   "GL_MAP_INVALIDATE_RANGE_BIT\0"
+   "GL_MAP_READ_BIT\0"
    "GL_MAP_STENCIL\0"
+   "GL_MAP_UNSYNCHRONIZED_BIT\0"
+   "GL_MAP_WRITE_BIT\0"
    "GL_MATRIX0_ARB\0"
    "GL_MATRIX0_NV\0"
    "GL_MATRIX10_ARB\0"
@@ -890,6 +946,8 @@ LONGSTRING static const char enum_string_table[] =
    "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB\0"
    "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0"
    "GL_MAX_RENDERBUFFER_SIZE_EXT\0"
+   "GL_MAX_SAMPLES\0"
+   "GL_MAX_SERVER_WAIT_TIMEOUT\0"
    "GL_MAX_SHININESS_NV\0"
    "GL_MAX_SPOT_EXPONENT_NV\0"
    "GL_MAX_TEXTURE_COORDS\0"
@@ -1018,6 +1076,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_OBJECT_PLANE\0"
    "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB\0"
    "GL_OBJECT_SUBTYPE_ARB\0"
+   "GL_OBJECT_TYPE\0"
    "GL_OBJECT_TYPE_ARB\0"
    "GL_OBJECT_VALIDATE_STATUS_ARB\0"
    "GL_OCCLUSION_TEST_HP\0"
@@ -1098,8 +1157,12 @@ LONGSTRING static const char enum_string_table[] =
    "GL_PIXEL_MAP_S_TO_S\0"
    "GL_PIXEL_MAP_S_TO_S_SIZE\0"
    "GL_PIXEL_MODE_BIT\0"
+   "GL_PIXEL_PACK_BUFFER\0"
+   "GL_PIXEL_PACK_BUFFER_BINDING\0"
    "GL_PIXEL_PACK_BUFFER_BINDING_EXT\0"
    "GL_PIXEL_PACK_BUFFER_EXT\0"
+   "GL_PIXEL_UNPACK_BUFFER\0"
+   "GL_PIXEL_UNPACK_BUFFER_BINDING\0"
    "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT\0"
    "GL_PIXEL_UNPACK_BUFFER_EXT\0"
    "GL_POINT\0"
@@ -1225,6 +1288,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_PROJECTION\0"
    "GL_PROJECTION_MATRIX\0"
    "GL_PROJECTION_STACK_DEPTH\0"
+   "GL_PROVOKING_VERTEX_EXT\0"
    "GL_PROXY_COLOR_TABLE\0"
    "GL_PROXY_HISTOGRAM\0"
    "GL_PROXY_HISTOGRAM_EXT\0"
@@ -1245,6 +1309,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_Q\0"
    "GL_QUADRATIC_ATTENUATION\0"
    "GL_QUADS\0"
+   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT\0"
    "GL_QUAD_MESH_SUN\0"
    "GL_QUAD_STRIP\0"
    "GL_QUERY_COUNTER_BITS\0"
@@ -1257,6 +1322,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_R3_G3_B2\0"
    "GL_RASTER_POSITION_UNCLIPPED_IBM\0"
    "GL_READ_BUFFER\0"
+   "GL_READ_FRAMEBUFFER\0"
    "GL_READ_FRAMEBUFFER_BINDING_EXT\0"
    "GL_READ_FRAMEBUFFER_EXT\0"
    "GL_READ_ONLY\0"
@@ -1273,10 +1339,21 @@ LONGSTRING static const char enum_string_table[] =
    "GL_REFLECTION_MAP_ARB\0"
    "GL_REFLECTION_MAP_NV\0"
    "GL_RENDER\0"
+   "GL_RENDERBUFFER\0"
+   "GL_RENDERBUFFER_ALPHA_SIZE\0"
    "GL_RENDERBUFFER_BINDING_EXT\0"
+   "GL_RENDERBUFFER_BLUE_SIZE\0"
+   "GL_RENDERBUFFER_DEPTH_SIZE\0"
    "GL_RENDERBUFFER_EXT\0"
+   "GL_RENDERBUFFER_GREEN_SIZE\0"
+   "GL_RENDERBUFFER_HEIGHT\0"
    "GL_RENDERBUFFER_HEIGHT_EXT\0"
+   "GL_RENDERBUFFER_INTERNAL_FORMAT\0"
    "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT\0"
+   "GL_RENDERBUFFER_RED_SIZE\0"
+   "GL_RENDERBUFFER_SAMPLES\0"
+   "GL_RENDERBUFFER_STENCIL_SIZE\0"
+   "GL_RENDERBUFFER_WIDTH\0"
    "GL_RENDERBUFFER_WIDTH_EXT\0"
    "GL_RENDERER\0"
    "GL_RENDER_MODE\0"
@@ -1319,9 +1396,11 @@ LONGSTRING static const char enum_string_table[] =
    "GL_RGBA4_S3TC\0"
    "GL_RGBA8\0"
    "GL_RGBA8_EXT\0"
+   "GL_RGBA8_SNORM\0"
    "GL_RGBA_DXT5_S3TC\0"
    "GL_RGBA_MODE\0"
    "GL_RGBA_S3TC\0"
+   "GL_RGBA_SNORM\0"
    "GL_RGB_S3TC\0"
    "GL_RGB_SCALE\0"
    "GL_RGB_SCALE_ARB\0"
@@ -1378,9 +1457,15 @@ LONGSTRING static const char enum_string_table[] =
    "GL_SHARED_TEXTURE_PALETTE_EXT\0"
    "GL_SHININESS\0"
    "GL_SHORT\0"
+   "GL_SIGNALED\0"
+   "GL_SIGNED_NORMALIZED\0"
    "GL_SINGLE_COLOR\0"
    "GL_SINGLE_COLOR_EXT\0"
    "GL_SLICE_ACCUM_SUN\0"
+   "GL_SLUMINANCE\0"
+   "GL_SLUMINANCE8\0"
+   "GL_SLUMINANCE8_ALPHA8\0"
+   "GL_SLUMINANCE_ALPHA\0"
    "GL_SMOOTH\0"
    "GL_SMOOTH_LINE_WIDTH_GRANULARITY\0"
    "GL_SMOOTH_LINE_WIDTH_RANGE\0"
@@ -1420,6 +1505,10 @@ LONGSTRING static const char enum_string_table[] =
    "GL_SRC_ALPHA\0"
    "GL_SRC_ALPHA_SATURATE\0"
    "GL_SRC_COLOR\0"
+   "GL_SRGB\0"
+   "GL_SRGB8\0"
+   "GL_SRGB8_ALPHA8\0"
+   "GL_SRGB_ALPHA\0"
    "GL_STACK_OVERFLOW\0"
    "GL_STACK_UNDERFLOW\0"
    "GL_STATIC_COPY\0"
@@ -1429,6 +1518,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_STATIC_READ\0"
    "GL_STATIC_READ_ARB\0"
    "GL_STENCIL\0"
+   "GL_STENCIL_ATTACHMENT\0"
    "GL_STENCIL_ATTACHMENT_EXT\0"
    "GL_STENCIL_BACK_FAIL\0"
    "GL_STENCIL_BACK_FAIL_ATI\0"
@@ -1460,6 +1550,9 @@ LONGSTRING static const char enum_string_table[] =
    "GL_STENCIL_VALUE_MASK\0"
    "GL_STENCIL_WRITEMASK\0"
    "GL_STEREO\0"
+   "GL_STORAGE_CACHED_APPLE\0"
+   "GL_STORAGE_PRIVATE_APPLE\0"
+   "GL_STORAGE_SHARED_APPLE\0"
    "GL_STREAM_COPY\0"
    "GL_STREAM_COPY_ARB\0"
    "GL_STREAM_DRAW\0"
@@ -1469,6 +1562,12 @@ LONGSTRING static const char enum_string_table[] =
    "GL_SUBPIXEL_BITS\0"
    "GL_SUBTRACT\0"
    "GL_SUBTRACT_ARB\0"
+   "GL_SYNC_CONDITION\0"
+   "GL_SYNC_FENCE\0"
+   "GL_SYNC_FLAGS\0"
+   "GL_SYNC_FLUSH_COMMANDS_BIT\0"
+   "GL_SYNC_GPU_COMMANDS_COMPLETE\0"
+   "GL_SYNC_STATUS\0"
    "GL_T\0"
    "GL_T2F_C3F_V3F\0"
    "GL_T2F_C4F_N3F_V3F\0"
@@ -1609,6 +1708,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0"
    "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0"
    "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_SEAMLESS\0"
    "GL_TEXTURE_DEPTH\0"
    "GL_TEXTURE_DEPTH_SIZE\0"
    "GL_TEXTURE_DEPTH_SIZE_ARB\0"
@@ -1648,18 +1748,24 @@ LONGSTRING static const char enum_string_table[] =
    "GL_TEXTURE_MIN_FILTER\0"
    "GL_TEXTURE_MIN_LOD\0"
    "GL_TEXTURE_PRIORITY\0"
+   "GL_TEXTURE_RANGE_LENGTH_APPLE\0"
+   "GL_TEXTURE_RANGE_POINTER_APPLE\0"
    "GL_TEXTURE_RECTANGLE_ARB\0"
    "GL_TEXTURE_RECTANGLE_NV\0"
    "GL_TEXTURE_RED_SIZE\0"
    "GL_TEXTURE_RED_SIZE_EXT\0"
    "GL_TEXTURE_RESIDENT\0"
    "GL_TEXTURE_STACK_DEPTH\0"
+   "GL_TEXTURE_STENCIL_SIZE\0"
+   "GL_TEXTURE_STORAGE_HINT_APPLE\0"
    "GL_TEXTURE_TOO_LARGE_EXT\0"
    "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV\0"
    "GL_TEXTURE_WIDTH\0"
    "GL_TEXTURE_WRAP_R\0"
    "GL_TEXTURE_WRAP_S\0"
    "GL_TEXTURE_WRAP_T\0"
+   "GL_TIMEOUT_EXPIRED\0"
+   "GL_TIMEOUT_IGNORED\0"
    "GL_TIME_ELAPSED_EXT\0"
    "GL_TRACK_MATRIX_NV\0"
    "GL_TRACK_MATRIX_TRANSFORM_NV\0"
@@ -1687,15 +1793,18 @@ LONGSTRING static const char enum_string_table[] =
    "GL_UNPACK_SKIP_PIXELS\0"
    "GL_UNPACK_SKIP_ROWS\0"
    "GL_UNPACK_SWAP_BYTES\0"
+   "GL_UNSIGNALED\0"
    "GL_UNSIGNED_BYTE\0"
    "GL_UNSIGNED_BYTE_2_3_3_REV\0"
    "GL_UNSIGNED_BYTE_3_3_2\0"
    "GL_UNSIGNED_INT\0"
    "GL_UNSIGNED_INT_10_10_10_2\0"
+   "GL_UNSIGNED_INT_24_8\0"
    "GL_UNSIGNED_INT_24_8_NV\0"
    "GL_UNSIGNED_INT_2_10_10_10_REV\0"
    "GL_UNSIGNED_INT_8_8_8_8\0"
    "GL_UNSIGNED_INT_8_8_8_8_REV\0"
+   "GL_UNSIGNED_NORMALIZED\0"
    "GL_UNSIGNED_SHORT\0"
    "GL_UNSIGNED_SHORT_1_5_5_5_REV\0"
    "GL_UNSIGNED_SHORT_4_4_4_4\0"
@@ -1714,6 +1823,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_VENDOR\0"
    "GL_VERSION\0"
    "GL_VERTEX_ARRAY\0"
+   "GL_VERTEX_ARRAY_BINDING\0"
    "GL_VERTEX_ARRAY_BINDING_APPLE\0"
    "GL_VERTEX_ARRAY_BUFFER_BINDING\0"
    "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB\0"
@@ -1766,6 +1876,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_VERTEX_STATE_PROGRAM_NV\0"
    "GL_VIEWPORT\0"
    "GL_VIEWPORT_BIT\0"
+   "GL_WAIT_FAILED\0"
    "GL_WEIGHT_ARRAY_ARB\0"
    "GL_WEIGHT_ARRAY_BUFFER_BINDING\0"
    "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0"
@@ -1785,7 +1896,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_ZOOM_Y\0"
    ;
 
-static const enum_elt all_enums[1748] =
+static const enum_elt all_enums[1858] =
 {
    {     0, 0x00000600 }, /* GL_2D */
    {     6, 0x00001407 }, /* GL_2_BYTES */
@@ -1833,3000 +1944,3171 @@ static const enum_elt all_enums[1748] =
    {   728, 0x00000BC0 }, /* GL_ALPHA_TEST */
    {   742, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */
    {   761, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */
-   {   779, 0x00000207 }, /* GL_ALWAYS */
-   {   789, 0x00001200 }, /* GL_AMBIENT */
-   {   800, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */
-   {   823, 0x00001501 }, /* GL_AND */
-   {   830, 0x00001504 }, /* GL_AND_INVERTED */
-   {   846, 0x00001502 }, /* GL_AND_REVERSE */
-   {   861, 0x00008892 }, /* GL_ARRAY_BUFFER */
-   {   877, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */
-   {   901, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */
-   {   929, 0x00008B85 }, /* GL_ATTACHED_SHADERS */
-   {   949, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */
-   {   976, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */
-   {  1000, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */
-   {  1026, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */
-   {  1050, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */
-   {  1072, 0x00000D80 }, /* GL_AUTO_NORMAL */
-   {  1087, 0x00000409 }, /* GL_AUX0 */
-   {  1095, 0x0000040A }, /* GL_AUX1 */
-   {  1103, 0x0000040B }, /* GL_AUX2 */
-   {  1111, 0x0000040C }, /* GL_AUX3 */
-   {  1119, 0x00000C00 }, /* GL_AUX_BUFFERS */
-   {  1134, 0x00000405 }, /* GL_BACK */
-   {  1142, 0x00000402 }, /* GL_BACK_LEFT */
-   {  1155, 0x00000403 }, /* GL_BACK_RIGHT */
-   {  1169, 0x000080E0 }, /* GL_BGR */
-   {  1176, 0x000080E1 }, /* GL_BGRA */
-   {  1184, 0x00001A00 }, /* GL_BITMAP */
-   {  1194, 0x00000704 }, /* GL_BITMAP_TOKEN */
-   {  1210, 0x00000BE2 }, /* GL_BLEND */
-   {  1219, 0x00008005 }, /* GL_BLEND_COLOR */
-   {  1234, 0x00008005 }, /* GL_BLEND_COLOR_EXT */
-   {  1253, 0x00000BE0 }, /* GL_BLEND_DST */
-   {  1266, 0x000080CA }, /* GL_BLEND_DST_ALPHA */
-   {  1285, 0x000080C8 }, /* GL_BLEND_DST_RGB */
-   {  1302, 0x00008009 }, /* GL_BLEND_EQUATION */
-   {  1320, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */
-   {  1344, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */
-   {  1372, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */
-   {  1394, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */
-   {  1420, 0x00000BE1 }, /* GL_BLEND_SRC */
-   {  1433, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */
-   {  1452, 0x000080C9 }, /* GL_BLEND_SRC_RGB */
-   {  1469, 0x00001905 }, /* GL_BLUE */
-   {  1477, 0x00000D1B }, /* GL_BLUE_BIAS */
-   {  1490, 0x00000D54 }, /* GL_BLUE_BITS */
-   {  1503, 0x00000D1A }, /* GL_BLUE_SCALE */
-   {  1517, 0x00008B56 }, /* GL_BOOL */
-   {  1525, 0x00008B56 }, /* GL_BOOL_ARB */
-   {  1537, 0x00008B57 }, /* GL_BOOL_VEC2 */
-   {  1550, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */
-   {  1567, 0x00008B58 }, /* GL_BOOL_VEC3 */
-   {  1580, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */
-   {  1597, 0x00008B59 }, /* GL_BOOL_VEC4 */
-   {  1610, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */
-   {  1627, 0x000088BB }, /* GL_BUFFER_ACCESS */
-   {  1644, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */
-   {  1665, 0x000088BC }, /* GL_BUFFER_MAPPED */
-   {  1682, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */
-   {  1703, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */
-   {  1725, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */
-   {  1751, 0x00008764 }, /* GL_BUFFER_SIZE */
-   {  1766, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */
-   {  1785, 0x00008765 }, /* GL_BUFFER_USAGE */
-   {  1801, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */
-   {  1821, 0x00001400 }, /* GL_BYTE */
-   {  1829, 0x00002A24 }, /* GL_C3F_V3F */
-   {  1840, 0x00002A26 }, /* GL_C4F_N3F_V3F */
-   {  1855, 0x00002A22 }, /* GL_C4UB_V2F */
-   {  1867, 0x00002A23 }, /* GL_C4UB_V3F */
-   {  1879, 0x00000901 }, /* GL_CCW */
-   {  1886, 0x00002900 }, /* GL_CLAMP */
-   {  1895, 0x0000812D }, /* GL_CLAMP_TO_BORDER */
-   {  1914, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */
-   {  1937, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */
-   {  1961, 0x0000812F }, /* GL_CLAMP_TO_EDGE */
-   {  1978, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */
-   {  2000, 0x00001500 }, /* GL_CLEAR */
-   {  2009, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */
-   {  2034, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */
-   {  2063, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */
-   {  2089, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
-   {  2118, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */
-   {  2144, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */
-   {  2171, 0x00003000 }, /* GL_CLIP_PLANE0 */
-   {  2186, 0x00003001 }, /* GL_CLIP_PLANE1 */
-   {  2201, 0x00003002 }, /* GL_CLIP_PLANE2 */
-   {  2216, 0x00003003 }, /* GL_CLIP_PLANE3 */
-   {  2231, 0x00003004 }, /* GL_CLIP_PLANE4 */
-   {  2246, 0x00003005 }, /* GL_CLIP_PLANE5 */
-   {  2261, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-   {  2294, 0x00000A00 }, /* GL_COEFF */
-   {  2303, 0x00001800 }, /* GL_COLOR */
-   {  2312, 0x00008076 }, /* GL_COLOR_ARRAY */
-   {  2327, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-   {  2357, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */
-   {  2391, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */
-   {  2414, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */
-   {  2434, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */
-   {  2456, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */
-   {  2476, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */
-   {  2501, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */
-   {  2527, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */
-   {  2553, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */
-   {  2579, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */
-   {  2605, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */
-   {  2631, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */
-   {  2657, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */
-   {  2682, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */
-   {  2707, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */
-   {  2732, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */
-   {  2757, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */
-   {  2782, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */
-   {  2807, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */
-   {  2832, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */
-   {  2857, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */
-   {  2882, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */
-   {  2902, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */
-   {  2923, 0x00001900 }, /* GL_COLOR_INDEX */
-   {  2938, 0x00001603 }, /* GL_COLOR_INDEXES */
-   {  2955, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */
-   {  2973, 0x00000B57 }, /* GL_COLOR_MATERIAL */
-   {  2991, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */
-   {  3014, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */
-   {  3042, 0x000080B1 }, /* GL_COLOR_MATRIX */
-   {  3058, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */
-   {  3078, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */
-   {  3106, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */
-   {  3138, 0x00008458 }, /* GL_COLOR_SUM */
-   {  3151, 0x00008458 }, /* GL_COLOR_SUM_ARB */
-   {  3168, 0x000080D0 }, /* GL_COLOR_TABLE */
-   {  3183, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */
-   {  3209, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */
-   {  3239, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */
-   {  3269, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */
-   {  3289, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */
-   {  3313, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */
-   {  3338, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */
-   {  3367, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */
-   {  3396, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */
-   {  3418, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */
-   {  3444, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */
-   {  3470, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */
-   {  3496, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */
-   {  3526, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */
-   {  3556, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-   {  3586, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */
-   {  3620, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */
-   {  3654, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-   {  3684, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */
-   {  3718, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */
-   {  3752, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */
-   {  3776, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */
-   {  3804, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */
-   {  3832, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */
-   {  3853, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */
-   {  3878, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */
-   {  3899, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */
-   {  3924, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */
-   {  3949, 0x00000C23 }, /* GL_COLOR_WRITEMASK */
-   {  3968, 0x00008570 }, /* GL_COMBINE */
-   {  3979, 0x00008503 }, /* GL_COMBINE4 */
-   {  3991, 0x00008572 }, /* GL_COMBINE_ALPHA */
-   {  4008, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */
-   {  4029, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */
-   {  4050, 0x00008570 }, /* GL_COMBINE_ARB */
-   {  4065, 0x00008570 }, /* GL_COMBINE_EXT */
-   {  4080, 0x00008571 }, /* GL_COMBINE_RGB */
-   {  4095, 0x00008571 }, /* GL_COMBINE_RGB_ARB */
-   {  4114, 0x00008571 }, /* GL_COMBINE_RGB_EXT */
-   {  4133, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */
-   {  4169, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */
-   {  4193, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */
-   {  4221, 0x00001300 }, /* GL_COMPILE */
-   {  4232, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */
-   {  4255, 0x00008B81 }, /* GL_COMPILE_STATUS */
-   {  4273, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */
-   {  4293, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */
-   {  4317, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */
-   {  4341, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */
-   {  4369, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */
-   {  4393, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-   {  4423, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */
-   {  4457, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */
-   {  4485, 0x000084ED }, /* GL_COMPRESSED_RGB */
-   {  4503, 0x000084EE }, /* GL_COMPRESSED_RGBA */
-   {  4522, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */
-   {  4545, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-   {  4574, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-   {  4607, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-   {  4640, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-   {  4673, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */
-   {  4695, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-   {  4723, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-   {  4755, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */
-   {  4785, 0x00008576 }, /* GL_CONSTANT */
-   {  4797, 0x00008003 }, /* GL_CONSTANT_ALPHA */
-   {  4815, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */
-   {  4837, 0x00008576 }, /* GL_CONSTANT_ARB */
-   {  4853, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */
-   {  4877, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */
-   {  4899, 0x00008001 }, /* GL_CONSTANT_COLOR */
-   {  4917, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */
-   {  4939, 0x00008576 }, /* GL_CONSTANT_EXT */
-   {  4955, 0x00008010 }, /* GL_CONVOLUTION_1D */
-   {  4973, 0x00008011 }, /* GL_CONVOLUTION_2D */
-   {  4991, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */
-   {  5019, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */
-   {  5050, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */
-   {  5077, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */
-   {  5108, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */
-   {  5135, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */
-   {  5166, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */
-   {  5194, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */
-   {  5226, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */
-   {  5248, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */
-   {  5274, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */
-   {  5296, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */
-   {  5322, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */
-   {  5343, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */
-   {  5368, 0x00008862 }, /* GL_COORD_REPLACE */
-   {  5385, 0x00008862 }, /* GL_COORD_REPLACE_ARB */
-   {  5406, 0x00008862 }, /* GL_COORD_REPLACE_NV */
-   {  5426, 0x00001503 }, /* GL_COPY */
-   {  5434, 0x0000150C }, /* GL_COPY_INVERTED */
-   {  5451, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */
-   {  5471, 0x00000B44 }, /* GL_CULL_FACE */
-   {  5484, 0x00000B45 }, /* GL_CULL_FACE_MODE */
-   {  5502, 0x000081AA }, /* GL_CULL_VERTEX_EXT */
-   {  5521, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-   {  5553, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-   {  5588, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */
-   {  5609, 0x00000001 }, /* GL_CURRENT_BIT */
-   {  5624, 0x00000B00 }, /* GL_CURRENT_COLOR */
-   {  5641, 0x00008453 }, /* GL_CURRENT_FOG_COORD */
-   {  5662, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */
-   {  5688, 0x00000B01 }, /* GL_CURRENT_INDEX */
-   {  5705, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */
-   {  5727, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */
-   {  5755, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */
-   {  5776, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-   {  5810, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */
-   {  5843, 0x00000B02 }, /* GL_CURRENT_NORMAL */
-   {  5861, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-   {  5891, 0x00008B8D }, /* GL_CURRENT_PROGRAM */
-   {  5910, 0x00008865 }, /* GL_CURRENT_QUERY */
-   {  5927, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */
-   {  5948, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */
-   {  5972, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */
-   {  5999, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */
-   {  6023, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */
-   {  6050, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */
-   {  6083, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-   {  6116, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */
-   {  6143, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */
-   {  6169, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */
-   {  6194, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
-   {  6223, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */
-   {  6245, 0x00000900 }, /* GL_CW */
-   {  6251, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */
-   {  6272, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */
-   {  6293, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */
-   {  6313, 0x00002101 }, /* GL_DECAL */
-   {  6322, 0x00001E03 }, /* GL_DECR */
-   {  6330, 0x00008508 }, /* GL_DECR_WRAP */
-   {  6343, 0x00008508 }, /* GL_DECR_WRAP_EXT */
-   {  6360, 0x00008B80 }, /* GL_DELETE_STATUS */
-   {  6377, 0x00001801 }, /* GL_DEPTH */
-   {  6386, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */
-   {  6410, 0x00000D1F }, /* GL_DEPTH_BIAS */
-   {  6424, 0x00000D56 }, /* GL_DEPTH_BITS */
-   {  6438, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
-   {  6458, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
-   {  6483, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
-   {  6503, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
-   {  6521, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
-   {  6542, 0x00001902 }, /* GL_DEPTH_COMPONENT */
-   {  6561, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
-   {  6582, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
-   {  6607, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
-   {  6633, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
-   {  6654, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
-   {  6679, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
-   {  6705, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
-   {  6726, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
-   {  6751, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
-   {  6777, 0x00000B74 }, /* GL_DEPTH_FUNC */
-   {  6791, 0x00000B70 }, /* GL_DEPTH_RANGE */
-   {  6806, 0x00000D1E }, /* GL_DEPTH_SCALE */
-   {  6821, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
-   {  6841, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-   {  6869, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-   {  6897, 0x00000B71 }, /* GL_DEPTH_TEST */
-   {  6911, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
-   {  6933, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
-   {  6959, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
-   {  6978, 0x00001201 }, /* GL_DIFFUSE */
-   {  6989, 0x00000BD0 }, /* GL_DITHER */
-   {  6999, 0x00000A02 }, /* GL_DOMAIN */
-   {  7009, 0x00001100 }, /* GL_DONT_CARE */
-   {  7022, 0x000086AE }, /* GL_DOT3_RGB */
-   {  7034, 0x000086AF }, /* GL_DOT3_RGBA */
-   {  7047, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
-   {  7064, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
-   {  7081, 0x000086AE }, /* GL_DOT3_RGB_ARB */
-   {  7097, 0x00008740 }, /* GL_DOT3_RGB_EXT */
-   {  7113, 0x0000140A }, /* GL_DOUBLE */
-   {  7123, 0x00000C32 }, /* GL_DOUBLEBUFFER */
-   {  7139, 0x00000C01 }, /* GL_DRAW_BUFFER */
-   {  7154, 0x00008825 }, /* GL_DRAW_BUFFER0 */
-   {  7170, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
-   {  7190, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
-   {  7210, 0x00008826 }, /* GL_DRAW_BUFFER1 */
-   {  7226, 0x0000882F }, /* GL_DRAW_BUFFER10 */
-   {  7243, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
-   {  7264, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
-   {  7285, 0x00008830 }, /* GL_DRAW_BUFFER11 */
-   {  7302, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
-   {  7323, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
-   {  7344, 0x00008831 }, /* GL_DRAW_BUFFER12 */
-   {  7361, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
-   {  7382, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
-   {  7403, 0x00008832 }, /* GL_DRAW_BUFFER13 */
-   {  7420, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
-   {  7441, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
-   {  7462, 0x00008833 }, /* GL_DRAW_BUFFER14 */
-   {  7479, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
-   {  7500, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
-   {  7521, 0x00008834 }, /* GL_DRAW_BUFFER15 */
-   {  7538, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
-   {  7559, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
-   {  7580, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
-   {  7600, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
-   {  7620, 0x00008827 }, /* GL_DRAW_BUFFER2 */
-   {  7636, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
-   {  7656, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
-   {  7676, 0x00008828 }, /* GL_DRAW_BUFFER3 */
-   {  7692, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
-   {  7712, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
-   {  7732, 0x00008829 }, /* GL_DRAW_BUFFER4 */
-   {  7748, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
-   {  7768, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
-   {  7788, 0x0000882A }, /* GL_DRAW_BUFFER5 */
-   {  7804, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
-   {  7824, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
-   {  7844, 0x0000882B }, /* GL_DRAW_BUFFER6 */
-   {  7860, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
-   {  7880, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
-   {  7900, 0x0000882C }, /* GL_DRAW_BUFFER7 */
-   {  7916, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
-   {  7936, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
-   {  7956, 0x0000882D }, /* GL_DRAW_BUFFER8 */
-   {  7972, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
-   {  7992, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
-   {  8012, 0x0000882E }, /* GL_DRAW_BUFFER9 */
-   {  8028, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
-   {  8048, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
-   {  8068, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-   {  8100, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
-   {  8124, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
-   {  8144, 0x00000304 }, /* GL_DST_ALPHA */
-   {  8157, 0x00000306 }, /* GL_DST_COLOR */
-   {  8170, 0x000088EA }, /* GL_DYNAMIC_COPY */
-   {  8186, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
-   {  8206, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
-   {  8222, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
-   {  8242, 0x000088E9 }, /* GL_DYNAMIC_READ */
-   {  8258, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
-   {  8278, 0x00000B43 }, /* GL_EDGE_FLAG */
-   {  8291, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
-   {  8310, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-   {  8344, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
-   {  8382, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
-   {  8409, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-   {  8435, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
-   {  8459, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-   {  8491, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
-   {  8527, 0x00001600 }, /* GL_EMISSION */
-   {  8539, 0x00002000 }, /* GL_ENABLE_BIT */
-   {  8553, 0x00000202 }, /* GL_EQUAL */
-   {  8562, 0x00001509 }, /* GL_EQUIV */
-   {  8571, 0x00010000 }, /* GL_EVAL_BIT */
-   {  8583, 0x00000800 }, /* GL_EXP */
-   {  8590, 0x00000801 }, /* GL_EXP2 */
-   {  8598, 0x00001F03 }, /* GL_EXTENSIONS */
-   {  8612, 0x00002400 }, /* GL_EYE_LINEAR */
-   {  8626, 0x00002502 }, /* GL_EYE_PLANE */
-   {  8639, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
-   {  8664, 0x0000855B }, /* GL_EYE_RADIAL_NV */
-   {  8681, 0x00000000 }, /* GL_FALSE */
-   {  8690, 0x00001101 }, /* GL_FASTEST */
-   {  8701, 0x00001C01 }, /* GL_FEEDBACK */
-   {  8713, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
-   {  8740, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
-   {  8764, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
-   {  8788, 0x00001B02 }, /* GL_FILL */
-   {  8796, 0x00001D00 }, /* GL_FLAT */
-   {  8804, 0x00001406 }, /* GL_FLOAT */
-   {  8813, 0x00008B5A }, /* GL_FLOAT_MAT2 */
-   {  8827, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
-   {  8845, 0x00008B5B }, /* GL_FLOAT_MAT3 */
-   {  8859, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
-   {  8877, 0x00008B5C }, /* GL_FLOAT_MAT4 */
-   {  8891, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
-   {  8909, 0x00008B50 }, /* GL_FLOAT_VEC2 */
-   {  8923, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
-   {  8941, 0x00008B51 }, /* GL_FLOAT_VEC3 */
-   {  8955, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
-   {  8973, 0x00008B52 }, /* GL_FLOAT_VEC4 */
-   {  8987, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
-   {  9005, 0x00000B60 }, /* GL_FOG */
-   {  9012, 0x00000080 }, /* GL_FOG_BIT */
-   {  9023, 0x00000B66 }, /* GL_FOG_COLOR */
-   {  9036, 0x00008451 }, /* GL_FOG_COORD */
-   {  9049, 0x00008451 }, /* GL_FOG_COORDINATE */
-   {  9067, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
-   {  9091, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-   {  9130, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
-   {  9173, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-   {  9205, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-   {  9236, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-   {  9265, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
-   {  9290, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
-   {  9309, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
-   {  9343, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
-   {  9370, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
-   {  9396, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
-   {  9420, 0x00008450 }, /* GL_FOG_COORD_SRC */
-   {  9437, 0x00000B62 }, /* GL_FOG_DENSITY */
-   {  9452, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
-   {  9476, 0x00000B64 }, /* GL_FOG_END */
-   {  9487, 0x00000C54 }, /* GL_FOG_HINT */
-   {  9499, 0x00000B61 }, /* GL_FOG_INDEX */
-   {  9512, 0x00000B65 }, /* GL_FOG_MODE */
-   {  9524, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
-   {  9543, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
-   {  9568, 0x00000B63 }, /* GL_FOG_START */
-   {  9581, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
-   {  9599, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
-   {  9623, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
-   {  9642, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
-   {  9665, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-   {  9700, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-   {  9742, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-   {  9784, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-   {  9833, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-   {  9885, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
-   {  9929, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-   {  9973, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
-   { 10000, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-   { 10028, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
-   { 10047, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-   { 10088, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-   { 10129, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-   { 10171, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-   { 10222, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-   { 10260, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-   { 10309, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-   { 10351, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-   { 10383, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-   { 10414, 0x00000404 }, /* GL_FRONT */
-   { 10423, 0x00000408 }, /* GL_FRONT_AND_BACK */
-   { 10441, 0x00000B46 }, /* GL_FRONT_FACE */
-   { 10455, 0x00000400 }, /* GL_FRONT_LEFT */
-   { 10469, 0x00000401 }, /* GL_FRONT_RIGHT */
-   { 10484, 0x00008006 }, /* GL_FUNC_ADD */
-   { 10496, 0x00008006 }, /* GL_FUNC_ADD_EXT */
-   { 10512, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
-   { 10537, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
-   { 10566, 0x0000800A }, /* GL_FUNC_SUBTRACT */
-   { 10583, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
-   { 10604, 0x00008191 }, /* GL_GENERATE_MIPMAP */
-   { 10623, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
-   { 10647, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
-   { 10676, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
-   { 10700, 0x00000206 }, /* GL_GEQUAL */
-   { 10710, 0x00008009 }, /* GL_GL_BLEND_EQUATION_RGB */
-   { 10735, 0x00008C4A }, /* GL_GL_COMPRESSED_SLUMINANCE */
-   { 10763, 0x00008C4B }, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-   { 10797, 0x00008C48 }, /* GL_GL_COMPRESSED_SRGB */
-   { 10819, 0x00008C49 }, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-   { 10847, 0x0000845F }, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
-   { 10884, 0x00008B65 }, /* GL_GL_FLOAT_MAT2x3 */
-   { 10903, 0x00008B66 }, /* GL_GL_FLOAT_MAT2x4 */
-   { 10922, 0x00008B67 }, /* GL_GL_FLOAT_MAT3x2 */
-   { 10941, 0x00008B68 }, /* GL_GL_FLOAT_MAT3x4 */
-   { 10960, 0x00008B69 }, /* GL_GL_FLOAT_MAT4x2 */
-   { 10979, 0x00008B6A }, /* GL_GL_FLOAT_MAT4x3 */
-   { 10998, 0x000088EB }, /* GL_GL_PIXEL_PACK_BUFFER */
-   { 11022, 0x000088ED }, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-   { 11054, 0x000088EC }, /* GL_GL_PIXEL_UNPACK_BUFFER */
-   { 11080, 0x000088EF }, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-   { 11114, 0x00008C46 }, /* GL_GL_SLUMINANCE */
-   { 11131, 0x00008C47 }, /* GL_GL_SLUMINANCE8 */
-   { 11149, 0x00008C45 }, /* GL_GL_SLUMINANCE8_ALPHA8 */
-   { 11174, 0x00008C44 }, /* GL_GL_SLUMINANCE_ALPHA */
-   { 11197, 0x00008C40 }, /* GL_GL_SRGB */
-   { 11208, 0x00008C41 }, /* GL_GL_SRGB8 */
-   { 11220, 0x00008C43 }, /* GL_GL_SRGB8_ALPHA8 */
-   { 11239, 0x00008C42 }, /* GL_GL_SRGB_ALPHA */
-   { 11256, 0x00000204 }, /* GL_GREATER */
-   { 11267, 0x00001904 }, /* GL_GREEN */
-   { 11276, 0x00000D19 }, /* GL_GREEN_BIAS */
-   { 11290, 0x00000D53 }, /* GL_GREEN_BITS */
-   { 11304, 0x00000D18 }, /* GL_GREEN_SCALE */
-   { 11319, 0x00008000 }, /* GL_HINT_BIT */
-   { 11331, 0x00008024 }, /* GL_HISTOGRAM */
-   { 11344, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
-   { 11368, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
-   { 11396, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
-   { 11419, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
-   { 11446, 0x00008024 }, /* GL_HISTOGRAM_EXT */
-   { 11463, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
-   { 11483, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
-   { 11507, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
-   { 11531, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
-   { 11559, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-   { 11587, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
-   { 11619, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
-   { 11641, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
-   { 11667, 0x0000802D }, /* GL_HISTOGRAM_SINK */
-   { 11685, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
-   { 11707, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
-   { 11726, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
-   { 11749, 0x0000862A }, /* GL_IDENTITY_NV */
-   { 11764, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
-   { 11784, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-   { 11824, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-   { 11862, 0x00001E02 }, /* GL_INCR */
-   { 11870, 0x00008507 }, /* GL_INCR_WRAP */
-   { 11883, 0x00008507 }, /* GL_INCR_WRAP_EXT */
-   { 11900, 0x00008077 }, /* GL_INDEX_ARRAY */
-   { 11915, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-   { 11945, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
-   { 11979, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
-   { 12002, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
-   { 12024, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
-   { 12044, 0x00000D51 }, /* GL_INDEX_BITS */
-   { 12058, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
-   { 12079, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
-   { 12097, 0x00000C30 }, /* GL_INDEX_MODE */
-   { 12111, 0x00000D13 }, /* GL_INDEX_OFFSET */
-   { 12127, 0x00000D12 }, /* GL_INDEX_SHIFT */
-   { 12142, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
-   { 12161, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
-   { 12180, 0x00001404 }, /* GL_INT */
-   { 12187, 0x00008049 }, /* GL_INTENSITY */
-   { 12200, 0x0000804C }, /* GL_INTENSITY12 */
-   { 12215, 0x0000804C }, /* GL_INTENSITY12_EXT */
-   { 12234, 0x0000804D }, /* GL_INTENSITY16 */
-   { 12249, 0x0000804D }, /* GL_INTENSITY16_EXT */
-   { 12268, 0x0000804A }, /* GL_INTENSITY4 */
-   { 12282, 0x0000804A }, /* GL_INTENSITY4_EXT */
-   { 12300, 0x0000804B }, /* GL_INTENSITY8 */
-   { 12314, 0x0000804B }, /* GL_INTENSITY8_EXT */
-   { 12332, 0x00008049 }, /* GL_INTENSITY_EXT */
-   { 12349, 0x00008575 }, /* GL_INTERPOLATE */
-   { 12364, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-   { 12383, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-   { 12402, 0x00008B53 }, /* GL_INT_VEC2 */
-   { 12414, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-   { 12430, 0x00008B54 }, /* GL_INT_VEC3 */
-   { 12442, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-   { 12458, 0x00008B55 }, /* GL_INT_VEC4 */
-   { 12470, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-   { 12486, 0x00000500 }, /* GL_INVALID_ENUM */
-   { 12502, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-   { 12539, 0x00000502 }, /* GL_INVALID_OPERATION */
-   { 12560, 0x00000501 }, /* GL_INVALID_VALUE */
-   { 12577, 0x0000862B }, /* GL_INVERSE_NV */
-   { 12591, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-   { 12615, 0x0000150A }, /* GL_INVERT */
-   { 12625, 0x00001E00 }, /* GL_KEEP */
-   { 12633, 0x00000406 }, /* GL_LEFT */
-   { 12641, 0x00000203 }, /* GL_LEQUAL */
-   { 12651, 0x00000201 }, /* GL_LESS */
-   { 12659, 0x00004000 }, /* GL_LIGHT0 */
-   { 12669, 0x00004001 }, /* GL_LIGHT1 */
-   { 12679, 0x00004002 }, /* GL_LIGHT2 */
-   { 12689, 0x00004003 }, /* GL_LIGHT3 */
-   { 12699, 0x00004004 }, /* GL_LIGHT4 */
-   { 12709, 0x00004005 }, /* GL_LIGHT5 */
-   { 12719, 0x00004006 }, /* GL_LIGHT6 */
-   { 12729, 0x00004007 }, /* GL_LIGHT7 */
-   { 12739, 0x00000B50 }, /* GL_LIGHTING */
-   { 12751, 0x00000040 }, /* GL_LIGHTING_BIT */
-   { 12767, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-   { 12790, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-   { 12819, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-   { 12852, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-   { 12880, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-   { 12904, 0x00001B01 }, /* GL_LINE */
-   { 12912, 0x00002601 }, /* GL_LINEAR */
-   { 12922, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-   { 12944, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-   { 12974, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-   { 13005, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-   { 13029, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-   { 13054, 0x00000001 }, /* GL_LINES */
-   { 13063, 0x00000004 }, /* GL_LINE_BIT */
-   { 13075, 0x00000002 }, /* GL_LINE_LOOP */
-   { 13088, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-   { 13108, 0x00000B20 }, /* GL_LINE_SMOOTH */
-   { 13123, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-   { 13143, 0x00000B24 }, /* GL_LINE_STIPPLE */
-   { 13159, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-   { 13183, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-   { 13206, 0x00000003 }, /* GL_LINE_STRIP */
-   { 13220, 0x00000702 }, /* GL_LINE_TOKEN */
-   { 13234, 0x00000B21 }, /* GL_LINE_WIDTH */
-   { 13248, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-   { 13274, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-   { 13294, 0x00008B82 }, /* GL_LINK_STATUS */
-   { 13309, 0x00000B32 }, /* GL_LIST_BASE */
-   { 13322, 0x00020000 }, /* GL_LIST_BIT */
-   { 13334, 0x00000B33 }, /* GL_LIST_INDEX */
-   { 13348, 0x00000B30 }, /* GL_LIST_MODE */
-   { 13361, 0x00000101 }, /* GL_LOAD */
-   { 13369, 0x00000BF1 }, /* GL_LOGIC_OP */
-   { 13381, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-   { 13398, 0x00008CA1 }, /* GL_LOWER_LEFT */
-   { 13412, 0x00001909 }, /* GL_LUMINANCE */
-   { 13425, 0x00008041 }, /* GL_LUMINANCE12 */
-   { 13440, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-   { 13463, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-   { 13490, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-   { 13512, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-   { 13538, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-   { 13557, 0x00008042 }, /* GL_LUMINANCE16 */
-   { 13572, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-   { 13595, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-   { 13622, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-   { 13641, 0x0000803F }, /* GL_LUMINANCE4 */
-   { 13655, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-   { 13676, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-   { 13701, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-   { 13719, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-   { 13740, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-   { 13765, 0x00008040 }, /* GL_LUMINANCE8 */
-   { 13779, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-   { 13800, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-   { 13825, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-   { 13843, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-   { 13862, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-   { 13878, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-   { 13898, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-   { 13920, 0x00000D91 }, /* GL_MAP1_INDEX */
-   { 13934, 0x00000D92 }, /* GL_MAP1_NORMAL */
-   { 13949, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-   { 13973, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-   { 13997, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-   { 14021, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-   { 14045, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-   { 14062, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-   { 14079, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-   { 14107, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-   { 14136, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-   { 14165, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-   { 14194, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-   { 14223, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-   { 14252, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-   { 14281, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-   { 14309, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-   { 14337, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-   { 14365, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-   { 14393, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-   { 14421, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-   { 14449, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-   { 14477, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-   { 14505, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-   { 14533, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-   { 14549, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-   { 14569, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-   { 14591, 0x00000DB1 }, /* GL_MAP2_INDEX */
-   { 14605, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-   { 14620, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-   { 14644, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-   { 14668, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-   { 14692, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-   { 14716, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-   { 14733, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-   { 14750, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-   { 14778, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-   { 14807, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-   { 14836, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-   { 14865, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-   { 14894, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-   { 14923, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-   { 14952, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-   { 14980, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-   { 15008, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-   { 15036, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-   { 15064, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-   { 15092, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-   { 15120, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-   { 15148, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-   { 15176, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-   { 15204, 0x00000D10 }, /* GL_MAP_COLOR */
-   { 15217, 0x00000D11 }, /* GL_MAP_STENCIL */
-   { 15232, 0x000088C0 }, /* GL_MATRIX0_ARB */
-   { 15247, 0x00008630 }, /* GL_MATRIX0_NV */
-   { 15261, 0x000088CA }, /* GL_MATRIX10_ARB */
-   { 15277, 0x000088CB }, /* GL_MATRIX11_ARB */
-   { 15293, 0x000088CC }, /* GL_MATRIX12_ARB */
-   { 15309, 0x000088CD }, /* GL_MATRIX13_ARB */
-   { 15325, 0x000088CE }, /* GL_MATRIX14_ARB */
-   { 15341, 0x000088CF }, /* GL_MATRIX15_ARB */
-   { 15357, 0x000088D0 }, /* GL_MATRIX16_ARB */
-   { 15373, 0x000088D1 }, /* GL_MATRIX17_ARB */
-   { 15389, 0x000088D2 }, /* GL_MATRIX18_ARB */
-   { 15405, 0x000088D3 }, /* GL_MATRIX19_ARB */
-   { 15421, 0x000088C1 }, /* GL_MATRIX1_ARB */
-   { 15436, 0x00008631 }, /* GL_MATRIX1_NV */
-   { 15450, 0x000088D4 }, /* GL_MATRIX20_ARB */
-   { 15466, 0x000088D5 }, /* GL_MATRIX21_ARB */
-   { 15482, 0x000088D6 }, /* GL_MATRIX22_ARB */
-   { 15498, 0x000088D7 }, /* GL_MATRIX23_ARB */
-   { 15514, 0x000088D8 }, /* GL_MATRIX24_ARB */
-   { 15530, 0x000088D9 }, /* GL_MATRIX25_ARB */
-   { 15546, 0x000088DA }, /* GL_MATRIX26_ARB */
-   { 15562, 0x000088DB }, /* GL_MATRIX27_ARB */
-   { 15578, 0x000088DC }, /* GL_MATRIX28_ARB */
-   { 15594, 0x000088DD }, /* GL_MATRIX29_ARB */
-   { 15610, 0x000088C2 }, /* GL_MATRIX2_ARB */
-   { 15625, 0x00008632 }, /* GL_MATRIX2_NV */
-   { 15639, 0x000088DE }, /* GL_MATRIX30_ARB */
-   { 15655, 0x000088DF }, /* GL_MATRIX31_ARB */
-   { 15671, 0x000088C3 }, /* GL_MATRIX3_ARB */
-   { 15686, 0x00008633 }, /* GL_MATRIX3_NV */
-   { 15700, 0x000088C4 }, /* GL_MATRIX4_ARB */
-   { 15715, 0x00008634 }, /* GL_MATRIX4_NV */
-   { 15729, 0x000088C5 }, /* GL_MATRIX5_ARB */
-   { 15744, 0x00008635 }, /* GL_MATRIX5_NV */
-   { 15758, 0x000088C6 }, /* GL_MATRIX6_ARB */
-   { 15773, 0x00008636 }, /* GL_MATRIX6_NV */
-   { 15787, 0x000088C7 }, /* GL_MATRIX7_ARB */
-   { 15802, 0x00008637 }, /* GL_MATRIX7_NV */
-   { 15816, 0x000088C8 }, /* GL_MATRIX8_ARB */
-   { 15831, 0x000088C9 }, /* GL_MATRIX9_ARB */
-   { 15846, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-   { 15872, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-   { 15906, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-   { 15937, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-   { 15970, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-   { 16001, 0x00000BA0 }, /* GL_MATRIX_MODE */
-   { 16016, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-   { 16038, 0x00008008 }, /* GL_MAX */
-   { 16045, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-   { 16068, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-   { 16100, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-   { 16126, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-   { 16159, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-   { 16185, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 16219, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-   { 16238, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-   { 16267, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-   { 16299, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-   { 16335, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-   { 16371, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-   { 16411, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-   { 16437, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-   { 16467, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-   { 16492, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-   { 16521, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-   { 16550, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-   { 16583, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
-   { 16603, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-   { 16627, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-   { 16651, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-   { 16675, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-   { 16700, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-   { 16718, 0x00008008 }, /* GL_MAX_EXT */
-   { 16729, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-   { 16764, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-   { 16803, 0x00000D31 }, /* GL_MAX_LIGHTS */
-   { 16817, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-   { 16837, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-   { 16875, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-   { 16904, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-   { 16928, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-   { 16956, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-   { 16979, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 17016, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 17052, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-   { 17079, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-   { 17108, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-   { 17142, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-   { 17178, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-   { 17205, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-   { 17237, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-   { 17273, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-   { 17302, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-   { 17331, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-   { 17359, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-   { 17397, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 17441, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 17484, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 17518, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 17557, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 17594, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 17632, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 17675, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 17718, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-   { 17748, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-   { 17779, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 17815, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 17851, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-   { 17881, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-   { 17915, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-   { 17948, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-   { 17977, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-   { 17997, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-   { 18021, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
-   { 18043, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-   { 18069, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-   { 18096, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-   { 18127, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-   { 18151, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 18185, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-   { 18205, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-   { 18232, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-   { 18253, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-   { 18278, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-   { 18303, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-   { 18338, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
-   { 18360, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-   { 18386, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
-   { 18408, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-   { 18434, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-   { 18468, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-   { 18506, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-   { 18539, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-   { 18576, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-   { 18600, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-   { 18621, 0x00008007 }, /* GL_MIN */
-   { 18628, 0x0000802E }, /* GL_MINMAX */
-   { 18638, 0x0000802E }, /* GL_MINMAX_EXT */
-   { 18652, 0x0000802F }, /* GL_MINMAX_FORMAT */
-   { 18669, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-   { 18690, 0x00008030 }, /* GL_MINMAX_SINK */
-   { 18705, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-   { 18724, 0x00008007 }, /* GL_MIN_EXT */
-   { 18735, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-   { 18754, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-   { 18777, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-   { 18800, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-   { 18820, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-   { 18840, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-   { 18870, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-   { 18898, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-   { 18926, 0x00001700 }, /* GL_MODELVIEW */
-   { 18939, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-   { 18957, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-   { 18976, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-   { 18995, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-   { 19014, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-   { 19033, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-   { 19052, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-   { 19071, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-   { 19090, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-   { 19109, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-   { 19128, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-   { 19147, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-   { 19165, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-   { 19184, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-   { 19203, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-   { 19222, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-   { 19241, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-   { 19260, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-   { 19279, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-   { 19298, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-   { 19317, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-   { 19336, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-   { 19355, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-   { 19373, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-   { 19392, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-   { 19411, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-   { 19429, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-   { 19447, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-   { 19465, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-   { 19483, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-   { 19501, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-   { 19519, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-   { 19537, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-   { 19557, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-   { 19584, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-   { 19609, 0x00002100 }, /* GL_MODULATE */
-   { 19621, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-   { 19641, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-   { 19668, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-   { 19693, 0x00000103 }, /* GL_MULT */
-   { 19701, 0x0000809D }, /* GL_MULTISAMPLE */
-   { 19716, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-   { 19736, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-   { 19755, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-   { 19774, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-   { 19798, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-   { 19821, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-   { 19851, 0x00002A25 }, /* GL_N3F_V3F */
-   { 19862, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-   { 19882, 0x0000150E }, /* GL_NAND */
-   { 19890, 0x00002600 }, /* GL_NEAREST */
-   { 19901, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-   { 19932, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-   { 19964, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-   { 19989, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-   { 20015, 0x00000200 }, /* GL_NEVER */
-   { 20024, 0x00001102 }, /* GL_NICEST */
-   { 20034, 0x00000000 }, /* GL_NONE */
-   { 20042, 0x00001505 }, /* GL_NOOP */
-   { 20050, 0x00001508 }, /* GL_NOR */
-   { 20057, 0x00000BA1 }, /* GL_NORMALIZE */
-   { 20070, 0x00008075 }, /* GL_NORMAL_ARRAY */
-   { 20086, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-   { 20117, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-   { 20152, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-   { 20176, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-   { 20199, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-   { 20220, 0x00008511 }, /* GL_NORMAL_MAP */
-   { 20234, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-   { 20252, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-   { 20269, 0x00000205 }, /* GL_NOTEQUAL */
-   { 20281, 0x00000000 }, /* GL_NO_ERROR */
-   { 20293, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-   { 20327, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
-   { 20365, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-   { 20397, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-   { 20439, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-   { 20469, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-   { 20509, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-   { 20540, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-   { 20569, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-   { 20597, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-   { 20627, 0x00002401 }, /* GL_OBJECT_LINEAR */
-   { 20644, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-   { 20670, 0x00002501 }, /* GL_OBJECT_PLANE */
-   { 20686, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-   { 20721, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-   { 20743, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-   { 20762, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-   { 20792, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-   { 20813, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-   { 20841, 0x00000001 }, /* GL_ONE */
-   { 20848, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-   { 20876, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-   { 20908, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-   { 20936, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-   { 20968, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-   { 20991, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-   { 21014, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-   { 21037, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-   { 21060, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-   { 21078, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-   { 21100, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-   { 21122, 0x00008590 }, /* GL_OPERAND0_RGB */
-   { 21138, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-   { 21158, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-   { 21178, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-   { 21196, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-   { 21218, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-   { 21240, 0x00008591 }, /* GL_OPERAND1_RGB */
-   { 21256, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-   { 21276, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-   { 21296, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-   { 21314, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-   { 21336, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-   { 21358, 0x00008592 }, /* GL_OPERAND2_RGB */
-   { 21374, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-   { 21394, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-   { 21414, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-   { 21435, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-   { 21454, 0x00001507 }, /* GL_OR */
-   { 21460, 0x00000A01 }, /* GL_ORDER */
-   { 21469, 0x0000150D }, /* GL_OR_INVERTED */
-   { 21484, 0x0000150B }, /* GL_OR_REVERSE */
-   { 21498, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-   { 21515, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-   { 21533, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-   { 21554, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-   { 21574, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-   { 21592, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-   { 21611, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-   { 21631, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-   { 21651, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-   { 21669, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-   { 21688, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-   { 21713, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-   { 21737, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-   { 21758, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-   { 21780, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-   { 21802, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-   { 21827, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-   { 21851, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-   { 21872, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-   { 21894, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-   { 21916, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-   { 21938, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-   { 21969, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-   { 21989, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-   { 22014, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-   { 22034, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-   { 22059, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-   { 22079, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-   { 22104, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-   { 22124, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-   { 22149, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-   { 22169, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-   { 22194, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-   { 22214, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-   { 22239, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-   { 22259, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-   { 22284, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-   { 22304, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-   { 22329, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-   { 22349, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-   { 22374, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-   { 22394, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-   { 22419, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-   { 22437, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-   { 22470, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-   { 22495, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-   { 22530, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-   { 22557, 0x00001B00 }, /* GL_POINT */
-   { 22566, 0x00000000 }, /* GL_POINTS */
-   { 22576, 0x00000002 }, /* GL_POINT_BIT */
-   { 22589, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-   { 22619, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-   { 22653, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-   { 22687, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-   { 22722, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-   { 22751, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-   { 22784, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-   { 22817, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-   { 22851, 0x00000B11 }, /* GL_POINT_SIZE */
-   { 22865, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-   { 22891, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-   { 22909, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-   { 22931, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-   { 22953, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-   { 22976, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-   { 22994, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-   { 23016, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-   { 23038, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-   { 23061, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-   { 23081, 0x00000B10 }, /* GL_POINT_SMOOTH */
-   { 23097, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-   { 23118, 0x00008861 }, /* GL_POINT_SPRITE */
-   { 23134, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-   { 23154, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-   { 23183, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-   { 23202, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-   { 23228, 0x00000701 }, /* GL_POINT_TOKEN */
-   { 23243, 0x00000009 }, /* GL_POLYGON */
-   { 23254, 0x00000008 }, /* GL_POLYGON_BIT */
-   { 23269, 0x00000B40 }, /* GL_POLYGON_MODE */
-   { 23285, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-   { 23308, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-   { 23333, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-   { 23356, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-   { 23379, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-   { 23403, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-   { 23427, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-   { 23445, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-   { 23468, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-   { 23487, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-   { 23510, 0x00000703 }, /* GL_POLYGON_TOKEN */
-   { 23527, 0x00001203 }, /* GL_POSITION */
-   { 23539, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-   { 23571, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-   { 23607, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-   { 23640, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-   { 23677, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-   { 23708, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-   { 23743, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-   { 23775, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-   { 23811, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 23844, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-   { 23876, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-   { 23912, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-   { 23945, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-   { 23982, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-   { 24012, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-   { 24046, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-   { 24077, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-   { 24112, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-   { 24143, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-   { 24178, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-   { 24210, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-   { 24246, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-   { 24276, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-   { 24310, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-   { 24341, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-   { 24376, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-   { 24408, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-   { 24439, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-   { 24474, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-   { 24506, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-   { 24542, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-   { 24571, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-   { 24604, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-   { 24634, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-   { 24668, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-   { 24707, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-   { 24740, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-   { 24780, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-   { 24814, 0x00008578 }, /* GL_PREVIOUS */
-   { 24826, 0x00008578 }, /* GL_PREVIOUS_ARB */
-   { 24842, 0x00008578 }, /* GL_PREVIOUS_EXT */
-   { 24858, 0x00008577 }, /* GL_PRIMARY_COLOR */
-   { 24875, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-   { 24896, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-   { 24917, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 24950, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 24982, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-   { 25005, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-   { 25028, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-   { 25058, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-   { 25087, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-   { 25115, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-   { 25137, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-   { 25165, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-   { 25193, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-   { 25215, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-   { 25236, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 25276, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 25315, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 25345, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 25380, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 25413, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 25447, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 25486, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 25525, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-   { 25547, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-   { 25573, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-   { 25597, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-   { 25620, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-   { 25642, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-   { 25663, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-   { 25684, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-   { 25711, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 25743, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 25775, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-   { 25810, 0x00001701 }, /* GL_PROJECTION */
-   { 25824, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-   { 25845, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-   { 25871, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-   { 25892, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-   { 25911, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-   { 25934, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 25973, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-   { 26011, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-   { 26031, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-   { 26061, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-   { 26085, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-   { 26105, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-   { 26135, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-   { 26159, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-   { 26179, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-   { 26212, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-   { 26238, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-   { 26268, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-   { 26299, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-   { 26329, 0x00002003 }, /* GL_Q */
-   { 26334, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-   { 26359, 0x00000007 }, /* GL_QUADS */
-   { 26368, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-   { 26385, 0x00000008 }, /* GL_QUAD_STRIP */
-   { 26399, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-   { 26421, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-   { 26447, 0x00008866 }, /* GL_QUERY_RESULT */
-   { 26463, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-   { 26483, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-   { 26509, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-   { 26539, 0x00002002 }, /* GL_R */
-   { 26544, 0x00002A10 }, /* GL_R3_G3_B2 */
-   { 26556, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-   { 26589, 0x00000C02 }, /* GL_READ_BUFFER */
-   { 26604, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-   { 26636, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
-   { 26660, 0x000088B8 }, /* GL_READ_ONLY */
-   { 26673, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-   { 26690, 0x000088BA }, /* GL_READ_WRITE */
-   { 26704, 0x000088BA }, /* GL_READ_WRITE_ARB */
-   { 26722, 0x00001903 }, /* GL_RED */
-   { 26729, 0x00008016 }, /* GL_REDUCE */
-   { 26739, 0x00008016 }, /* GL_REDUCE_EXT */
-   { 26753, 0x00000D15 }, /* GL_RED_BIAS */
-   { 26765, 0x00000D52 }, /* GL_RED_BITS */
-   { 26777, 0x00000D14 }, /* GL_RED_SCALE */
-   { 26790, 0x00008512 }, /* GL_REFLECTION_MAP */
-   { 26808, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-   { 26830, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-   { 26851, 0x00001C00 }, /* GL_RENDER */
-   { 26861, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-   { 26889, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-   { 26909, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-   { 26936, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-   { 26972, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-   { 26998, 0x00001F01 }, /* GL_RENDERER */
-   { 27010, 0x00000C40 }, /* GL_RENDER_MODE */
-   { 27025, 0x00002901 }, /* GL_REPEAT */
-   { 27035, 0x00001E01 }, /* GL_REPLACE */
-   { 27046, 0x00008062 }, /* GL_REPLACE_EXT */
-   { 27061, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-   { 27084, 0x0000803A }, /* GL_RESCALE_NORMAL */
-   { 27102, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-   { 27124, 0x00000102 }, /* GL_RETURN */
-   { 27134, 0x00001907 }, /* GL_RGB */
-   { 27141, 0x00008052 }, /* GL_RGB10 */
-   { 27150, 0x00008059 }, /* GL_RGB10_A2 */
-   { 27162, 0x00008059 }, /* GL_RGB10_A2_EXT */
-   { 27178, 0x00008052 }, /* GL_RGB10_EXT */
-   { 27191, 0x00008053 }, /* GL_RGB12 */
-   { 27200, 0x00008053 }, /* GL_RGB12_EXT */
-   { 27213, 0x00008054 }, /* GL_RGB16 */
-   { 27222, 0x00008054 }, /* GL_RGB16_EXT */
-   { 27235, 0x0000804E }, /* GL_RGB2_EXT */
-   { 27247, 0x0000804F }, /* GL_RGB4 */
-   { 27255, 0x0000804F }, /* GL_RGB4_EXT */
-   { 27267, 0x000083A1 }, /* GL_RGB4_S3TC */
-   { 27280, 0x00008050 }, /* GL_RGB5 */
-   { 27288, 0x00008057 }, /* GL_RGB5_A1 */
-   { 27299, 0x00008057 }, /* GL_RGB5_A1_EXT */
-   { 27314, 0x00008050 }, /* GL_RGB5_EXT */
-   { 27326, 0x00008051 }, /* GL_RGB8 */
-   { 27334, 0x00008051 }, /* GL_RGB8_EXT */
-   { 27346, 0x00001908 }, /* GL_RGBA */
-   { 27354, 0x0000805A }, /* GL_RGBA12 */
-   { 27364, 0x0000805A }, /* GL_RGBA12_EXT */
-   { 27378, 0x0000805B }, /* GL_RGBA16 */
-   { 27388, 0x0000805B }, /* GL_RGBA16_EXT */
-   { 27402, 0x00008055 }, /* GL_RGBA2 */
-   { 27411, 0x00008055 }, /* GL_RGBA2_EXT */
-   { 27424, 0x00008056 }, /* GL_RGBA4 */
-   { 27433, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-   { 27452, 0x00008056 }, /* GL_RGBA4_EXT */
-   { 27465, 0x000083A3 }, /* GL_RGBA4_S3TC */
-   { 27479, 0x00008058 }, /* GL_RGBA8 */
-   { 27488, 0x00008058 }, /* GL_RGBA8_EXT */
-   { 27501, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-   { 27519, 0x00000C31 }, /* GL_RGBA_MODE */
-   { 27532, 0x000083A2 }, /* GL_RGBA_S3TC */
-   { 27545, 0x000083A0 }, /* GL_RGB_S3TC */
-   { 27557, 0x00008573 }, /* GL_RGB_SCALE */
-   { 27570, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-   { 27587, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-   { 27604, 0x00000407 }, /* GL_RIGHT */
-   { 27613, 0x00002000 }, /* GL_S */
-   { 27618, 0x00008B5D }, /* GL_SAMPLER_1D */
-   { 27632, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
-   { 27653, 0x00008B5E }, /* GL_SAMPLER_2D */
-   { 27667, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
-   { 27688, 0x00008B5F }, /* GL_SAMPLER_3D */
-   { 27702, 0x00008B60 }, /* GL_SAMPLER_CUBE */
-   { 27718, 0x000080A9 }, /* GL_SAMPLES */
-   { 27729, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-   { 27745, 0x000080A9 }, /* GL_SAMPLES_ARB */
-   { 27760, 0x00008914 }, /* GL_SAMPLES_PASSED */
-   { 27778, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-   { 27800, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-   { 27828, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-   { 27860, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-   { 27883, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-   { 27910, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-   { 27928, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-   { 27951, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-   { 27973, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-   { 27992, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-   { 28015, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-   { 28041, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-   { 28071, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-   { 28096, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-   { 28125, 0x00080000 }, /* GL_SCISSOR_BIT */
-   { 28140, 0x00000C10 }, /* GL_SCISSOR_BOX */
-   { 28155, 0x00000C11 }, /* GL_SCISSOR_TEST */
-   { 28171, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-   { 28196, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-   { 28236, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-   { 28280, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-   { 28313, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-   { 28343, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-   { 28375, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-   { 28405, 0x00001C02 }, /* GL_SELECT */
-   { 28415, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-   { 28443, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-   { 28468, 0x00008012 }, /* GL_SEPARABLE_2D */
-   { 28484, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-   { 28511, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-   { 28542, 0x0000150F }, /* GL_SET */
-   { 28549, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-   { 28570, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
-   { 28594, 0x00008B4F }, /* GL_SHADER_TYPE */
-   { 28609, 0x00000B54 }, /* GL_SHADE_MODEL */
-   { 28624, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
-   { 28652, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-   { 28675, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-   { 28705, 0x00001601 }, /* GL_SHININESS */
-   { 28718, 0x00001402 }, /* GL_SHORT */
-   { 28727, 0x000081F9 }, /* GL_SINGLE_COLOR */
-   { 28743, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-   { 28763, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-   { 28782, 0x00001D01 }, /* GL_SMOOTH */
-   { 28792, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-   { 28825, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-   { 28852, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-   { 28885, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-   { 28912, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-   { 28929, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-   { 28950, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-   { 28971, 0x00008580 }, /* GL_SOURCE0_RGB */
-   { 28986, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-   { 29005, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-   { 29024, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-   { 29041, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-   { 29062, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-   { 29083, 0x00008581 }, /* GL_SOURCE1_RGB */
-   { 29098, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-   { 29117, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-   { 29136, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-   { 29153, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-   { 29174, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-   { 29195, 0x00008582 }, /* GL_SOURCE2_RGB */
-   { 29210, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-   { 29229, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-   { 29248, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-   { 29268, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-   { 29286, 0x00001202 }, /* GL_SPECULAR */
-   { 29298, 0x00002402 }, /* GL_SPHERE_MAP */
-   { 29312, 0x00001206 }, /* GL_SPOT_CUTOFF */
-   { 29327, 0x00001204 }, /* GL_SPOT_DIRECTION */
-   { 29345, 0x00001205 }, /* GL_SPOT_EXPONENT */
-   { 29362, 0x00008588 }, /* GL_SRC0_ALPHA */
-   { 29376, 0x00008580 }, /* GL_SRC0_RGB */
-   { 29388, 0x00008589 }, /* GL_SRC1_ALPHA */
-   { 29402, 0x00008581 }, /* GL_SRC1_RGB */
-   { 29414, 0x0000858A }, /* GL_SRC2_ALPHA */
-   { 29428, 0x00008582 }, /* GL_SRC2_RGB */
-   { 29440, 0x00000302 }, /* GL_SRC_ALPHA */
-   { 29453, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-   { 29475, 0x00000300 }, /* GL_SRC_COLOR */
-   { 29488, 0x00000503 }, /* GL_STACK_OVERFLOW */
-   { 29506, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-   { 29525, 0x000088E6 }, /* GL_STATIC_COPY */
-   { 29540, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-   { 29559, 0x000088E4 }, /* GL_STATIC_DRAW */
-   { 29574, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-   { 29593, 0x000088E5 }, /* GL_STATIC_READ */
-   { 29608, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-   { 29627, 0x00001802 }, /* GL_STENCIL */
-   { 29638, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-   { 29664, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
-   { 29685, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
-   { 29710, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
-   { 29731, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
-   { 29756, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-   { 29788, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
-   { 29824, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-   { 29856, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
-   { 29892, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
-   { 29912, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
-   { 29939, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
-   { 29965, 0x00000D57 }, /* GL_STENCIL_BITS */
-   { 29981, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-   { 30003, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-   { 30026, 0x00000B94 }, /* GL_STENCIL_FAIL */
-   { 30042, 0x00000B92 }, /* GL_STENCIL_FUNC */
-   { 30058, 0x00001901 }, /* GL_STENCIL_INDEX */
-   { 30075, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-   { 30098, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-   { 30120, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-   { 30142, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-   { 30164, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-   { 30185, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-   { 30212, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-   { 30239, 0x00000B97 }, /* GL_STENCIL_REF */
-   { 30254, 0x00000B90 }, /* GL_STENCIL_TEST */
-   { 30270, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-   { 30299, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-   { 30321, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-   { 30342, 0x00000C33 }, /* GL_STEREO */
-   { 30352, 0x000088E2 }, /* GL_STREAM_COPY */
-   { 30367, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-   { 30386, 0x000088E0 }, /* GL_STREAM_DRAW */
-   { 30401, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-   { 30420, 0x000088E1 }, /* GL_STREAM_READ */
-   { 30435, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-   { 30454, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-   { 30471, 0x000084E7 }, /* GL_SUBTRACT */
-   { 30483, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-   { 30499, 0x00002001 }, /* GL_T */
-   { 30504, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-   { 30519, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-   { 30538, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-   { 30554, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-   { 30569, 0x00002A27 }, /* GL_T2F_V3F */
-   { 30580, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-   { 30599, 0x00002A28 }, /* GL_T4F_V4F */
-   { 30610, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-   { 30633, 0x00001702 }, /* GL_TEXTURE */
-   { 30644, 0x000084C0 }, /* GL_TEXTURE0 */
-   { 30656, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-   { 30672, 0x000084C1 }, /* GL_TEXTURE1 */
-   { 30684, 0x000084CA }, /* GL_TEXTURE10 */
-   { 30697, 0x000084CA }, /* GL_TEXTURE10_ARB */
-   { 30714, 0x000084CB }, /* GL_TEXTURE11 */
-   { 30727, 0x000084CB }, /* GL_TEXTURE11_ARB */
-   { 30744, 0x000084CC }, /* GL_TEXTURE12 */
-   { 30757, 0x000084CC }, /* GL_TEXTURE12_ARB */
-   { 30774, 0x000084CD }, /* GL_TEXTURE13 */
-   { 30787, 0x000084CD }, /* GL_TEXTURE13_ARB */
-   { 30804, 0x000084CE }, /* GL_TEXTURE14 */
-   { 30817, 0x000084CE }, /* GL_TEXTURE14_ARB */
-   { 30834, 0x000084CF }, /* GL_TEXTURE15 */
-   { 30847, 0x000084CF }, /* GL_TEXTURE15_ARB */
-   { 30864, 0x000084D0 }, /* GL_TEXTURE16 */
-   { 30877, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-   { 30894, 0x000084D1 }, /* GL_TEXTURE17 */
-   { 30907, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-   { 30924, 0x000084D2 }, /* GL_TEXTURE18 */
-   { 30937, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-   { 30954, 0x000084D3 }, /* GL_TEXTURE19 */
-   { 30967, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-   { 30984, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-   { 31000, 0x000084C2 }, /* GL_TEXTURE2 */
-   { 31012, 0x000084D4 }, /* GL_TEXTURE20 */
-   { 31025, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-   { 31042, 0x000084D5 }, /* GL_TEXTURE21 */
-   { 31055, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-   { 31072, 0x000084D6 }, /* GL_TEXTURE22 */
-   { 31085, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-   { 31102, 0x000084D7 }, /* GL_TEXTURE23 */
-   { 31115, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-   { 31132, 0x000084D8 }, /* GL_TEXTURE24 */
-   { 31145, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-   { 31162, 0x000084D9 }, /* GL_TEXTURE25 */
-   { 31175, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-   { 31192, 0x000084DA }, /* GL_TEXTURE26 */
-   { 31205, 0x000084DA }, /* GL_TEXTURE26_ARB */
-   { 31222, 0x000084DB }, /* GL_TEXTURE27 */
-   { 31235, 0x000084DB }, /* GL_TEXTURE27_ARB */
-   { 31252, 0x000084DC }, /* GL_TEXTURE28 */
-   { 31265, 0x000084DC }, /* GL_TEXTURE28_ARB */
-   { 31282, 0x000084DD }, /* GL_TEXTURE29 */
-   { 31295, 0x000084DD }, /* GL_TEXTURE29_ARB */
-   { 31312, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-   { 31328, 0x000084C3 }, /* GL_TEXTURE3 */
-   { 31340, 0x000084DE }, /* GL_TEXTURE30 */
-   { 31353, 0x000084DE }, /* GL_TEXTURE30_ARB */
-   { 31370, 0x000084DF }, /* GL_TEXTURE31 */
-   { 31383, 0x000084DF }, /* GL_TEXTURE31_ARB */
-   { 31400, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-   { 31416, 0x000084C4 }, /* GL_TEXTURE4 */
-   { 31428, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-   { 31444, 0x000084C5 }, /* GL_TEXTURE5 */
-   { 31456, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-   { 31472, 0x000084C6 }, /* GL_TEXTURE6 */
-   { 31484, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-   { 31500, 0x000084C7 }, /* GL_TEXTURE7 */
-   { 31512, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-   { 31528, 0x000084C8 }, /* GL_TEXTURE8 */
-   { 31540, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-   { 31556, 0x000084C9 }, /* GL_TEXTURE9 */
-   { 31568, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-   { 31584, 0x00000DE0 }, /* GL_TEXTURE_1D */
-   { 31598, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
-   { 31622, 0x00000DE1 }, /* GL_TEXTURE_2D */
-   { 31636, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
-   { 31660, 0x0000806F }, /* GL_TEXTURE_3D */
-   { 31674, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-   { 31696, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-   { 31722, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-   { 31744, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-   { 31766, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-   { 31798, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-   { 31820, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-   { 31852, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-   { 31874, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-   { 31902, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-   { 31934, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-   { 31967, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-   { 31999, 0x00040000 }, /* GL_TEXTURE_BIT */
-   { 32014, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-   { 32035, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-   { 32060, 0x00001005 }, /* GL_TEXTURE_BORDER */
-   { 32078, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-   { 32102, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-   { 32133, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-   { 32163, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-   { 32193, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-   { 32228, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-   { 32259, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 32297, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-   { 32324, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-   { 32356, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-   { 32390, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-   { 32414, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-   { 32442, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-   { 32466, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-   { 32494, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-   { 32527, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-   { 32551, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-   { 32573, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-   { 32595, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-   { 32621, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-   { 32655, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-   { 32688, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-   { 32725, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-   { 32753, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-   { 32785, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-   { 32808, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-   { 32846, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-   { 32888, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-   { 32919, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-   { 32947, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-   { 32977, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-   { 33005, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-   { 33025, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-   { 33049, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-   { 33080, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-   { 33115, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-   { 33146, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-   { 33181, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-   { 33212, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-   { 33247, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-   { 33278, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-   { 33313, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-   { 33344, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-   { 33379, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-   { 33410, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-   { 33445, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-   { 33462, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-   { 33484, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-   { 33510, 0x00002300 }, /* GL_TEXTURE_ENV */
-   { 33525, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-   { 33546, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-   { 33566, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-   { 33592, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-   { 33612, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-   { 33629, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-   { 33646, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-   { 33663, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-   { 33680, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-   { 33705, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-   { 33727, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-   { 33753, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-   { 33771, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-   { 33797, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-   { 33823, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-   { 33853, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-   { 33880, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-   { 33905, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-   { 33925, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-   { 33949, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-   { 33976, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-   { 34003, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-   { 34030, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-   { 34056, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-   { 34086, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-   { 34108, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-   { 34126, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 34156, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-   { 34184, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-   { 34212, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-   { 34240, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-   { 34261, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-   { 34280, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-   { 34302, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-   { 34321, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-   { 34341, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-   { 34366, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-   { 34390, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-   { 34410, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-   { 34434, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-   { 34454, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-   { 34477, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-   { 34502, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-   { 34536, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-   { 34553, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-   { 34571, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-   { 34589, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-   { 34607, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
-   { 34627, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-   { 34646, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-   { 34675, 0x00001000 }, /* GL_TRANSFORM_BIT */
-   { 34692, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-   { 34718, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-   { 34748, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-   { 34780, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-   { 34810, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-   { 34844, 0x0000862C }, /* GL_TRANSPOSE_NV */
-   { 34860, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-   { 34891, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-   { 34926, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-   { 34954, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-   { 34986, 0x00000004 }, /* GL_TRIANGLES */
-   { 34999, 0x00000006 }, /* GL_TRIANGLE_FAN */
-   { 35015, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-   { 35036, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-   { 35054, 0x00000001 }, /* GL_TRUE */
-   { 35062, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-   { 35082, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-   { 35105, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-   { 35125, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-   { 35146, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-   { 35168, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-   { 35190, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-   { 35210, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-   { 35231, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-   { 35248, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-   { 35275, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-   { 35298, 0x00001405 }, /* GL_UNSIGNED_INT */
-   { 35314, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-   { 35341, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-   { 35365, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-   { 35396, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-   { 35420, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-   { 35448, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-   { 35466, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-   { 35496, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-   { 35522, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-   { 35552, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-   { 35578, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-   { 35602, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-   { 35630, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-   { 35658, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-   { 35685, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-   { 35717, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-   { 35748, 0x00008CA2 }, /* GL_UPPER_LEFT */
-   { 35762, 0x00002A20 }, /* GL_V2F */
-   { 35769, 0x00002A21 }, /* GL_V3F */
-   { 35776, 0x00008B83 }, /* GL_VALIDATE_STATUS */
-   { 35795, 0x00001F00 }, /* GL_VENDOR */
-   { 35805, 0x00001F02 }, /* GL_VERSION */
-   { 35816, 0x00008074 }, /* GL_VERTEX_ARRAY */
-   { 35832, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-   { 35862, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-   { 35893, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-   { 35928, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-   { 35952, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-   { 35973, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-   { 35996, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-   { 36017, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-   { 36044, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-   { 36072, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-   { 36100, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-   { 36128, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-   { 36156, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-   { 36184, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-   { 36212, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-   { 36239, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-   { 36266, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-   { 36293, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-   { 36320, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-   { 36347, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-   { 36374, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-   { 36401, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-   { 36428, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-   { 36455, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-   { 36493, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-   { 36535, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-   { 36566, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-   { 36601, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-   { 36635, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-   { 36673, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-   { 36704, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-   { 36739, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-   { 36767, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-   { 36799, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-   { 36829, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-   { 36863, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-   { 36891, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-   { 36923, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-   { 36943, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-   { 36965, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-   { 36994, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-   { 37015, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-   { 37044, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-   { 37077, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-   { 37109, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-   { 37136, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-   { 37167, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-   { 37197, 0x00008B31 }, /* GL_VERTEX_SHADER */
-   { 37214, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-   { 37235, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-   { 37262, 0x00000BA2 }, /* GL_VIEWPORT */
-   { 37274, 0x00000800 }, /* GL_VIEWPORT_BIT */
-   { 37290, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-   { 37310, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-   { 37341, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-   { 37376, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-   { 37404, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-   { 37429, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-   { 37456, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-   { 37481, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-   { 37505, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-   { 37524, 0x000088B9 }, /* GL_WRITE_ONLY */
-   { 37538, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-   { 37556, 0x00001506 }, /* GL_XOR */
-   { 37563, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-   { 37582, 0x00008757 }, /* GL_YCBCR_MESA */
-   { 37596, 0x00000000 }, /* GL_ZERO */
-   { 37604, 0x00000D16 }, /* GL_ZOOM_X */
-   { 37614, 0x00000D17 }, /* GL_ZOOM_Y */
+   {   779, 0x0000911A }, /* GL_ALREADY_SIGNALED */
+   {   799, 0x00000207 }, /* GL_ALWAYS */
+   {   809, 0x00001200 }, /* GL_AMBIENT */
+   {   820, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */
+   {   843, 0x00001501 }, /* GL_AND */
+   {   850, 0x00001504 }, /* GL_AND_INVERTED */
+   {   866, 0x00001502 }, /* GL_AND_REVERSE */
+   {   881, 0x00008892 }, /* GL_ARRAY_BUFFER */
+   {   897, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */
+   {   921, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */
+   {   949, 0x00008B85 }, /* GL_ATTACHED_SHADERS */
+   {   969, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */
+   {   996, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */
+   {  1020, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */
+   {  1046, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */
+   {  1070, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */
+   {  1092, 0x00000D80 }, /* GL_AUTO_NORMAL */
+   {  1107, 0x00000409 }, /* GL_AUX0 */
+   {  1115, 0x0000040A }, /* GL_AUX1 */
+   {  1123, 0x0000040B }, /* GL_AUX2 */
+   {  1131, 0x0000040C }, /* GL_AUX3 */
+   {  1139, 0x00000C00 }, /* GL_AUX_BUFFERS */
+   {  1154, 0x00000405 }, /* GL_BACK */
+   {  1162, 0x00000402 }, /* GL_BACK_LEFT */
+   {  1175, 0x00000403 }, /* GL_BACK_RIGHT */
+   {  1189, 0x000080E0 }, /* GL_BGR */
+   {  1196, 0x000080E1 }, /* GL_BGRA */
+   {  1204, 0x00001A00 }, /* GL_BITMAP */
+   {  1214, 0x00000704 }, /* GL_BITMAP_TOKEN */
+   {  1230, 0x00000BE2 }, /* GL_BLEND */
+   {  1239, 0x00008005 }, /* GL_BLEND_COLOR */
+   {  1254, 0x00008005 }, /* GL_BLEND_COLOR_EXT */
+   {  1273, 0x00000BE0 }, /* GL_BLEND_DST */
+   {  1286, 0x000080CA }, /* GL_BLEND_DST_ALPHA */
+   {  1305, 0x000080C8 }, /* GL_BLEND_DST_RGB */
+   {  1322, 0x00008009 }, /* GL_BLEND_EQUATION */
+   {  1340, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */
+   {  1364, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */
+   {  1392, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */
+   {  1414, 0x00008009 }, /* GL_BLEND_EQUATION_RGB */
+   {  1436, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */
+   {  1462, 0x00000BE1 }, /* GL_BLEND_SRC */
+   {  1475, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */
+   {  1494, 0x000080C9 }, /* GL_BLEND_SRC_RGB */
+   {  1511, 0x00001905 }, /* GL_BLUE */
+   {  1519, 0x00000D1B }, /* GL_BLUE_BIAS */
+   {  1532, 0x00000D54 }, /* GL_BLUE_BITS */
+   {  1545, 0x00000D1A }, /* GL_BLUE_SCALE */
+   {  1559, 0x00008B56 }, /* GL_BOOL */
+   {  1567, 0x00008B56 }, /* GL_BOOL_ARB */
+   {  1579, 0x00008B57 }, /* GL_BOOL_VEC2 */
+   {  1592, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */
+   {  1609, 0x00008B58 }, /* GL_BOOL_VEC3 */
+   {  1622, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */
+   {  1639, 0x00008B59 }, /* GL_BOOL_VEC4 */
+   {  1652, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */
+   {  1669, 0x000088BB }, /* GL_BUFFER_ACCESS */
+   {  1686, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */
+   {  1707, 0x00008A13 }, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
+   {  1738, 0x000088BC }, /* GL_BUFFER_MAPPED */
+   {  1755, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */
+   {  1776, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */
+   {  1798, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */
+   {  1824, 0x00008A12 }, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
+   {  1858, 0x00008764 }, /* GL_BUFFER_SIZE */
+   {  1873, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */
+   {  1892, 0x00008765 }, /* GL_BUFFER_USAGE */
+   {  1908, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */
+   {  1928, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */
+   {  1947, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */
+   {  1973, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */
+   {  1996, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
+   {  2024, 0x0000877C }, /* GL_BUMP_TARGET_ATI */
+   {  2043, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */
+   {  2065, 0x00001400 }, /* GL_BYTE */
+   {  2073, 0x00002A24 }, /* GL_C3F_V3F */
+   {  2084, 0x00002A26 }, /* GL_C4F_N3F_V3F */
+   {  2099, 0x00002A22 }, /* GL_C4UB_V2F */
+   {  2111, 0x00002A23 }, /* GL_C4UB_V3F */
+   {  2123, 0x00000901 }, /* GL_CCW */
+   {  2130, 0x00002900 }, /* GL_CLAMP */
+   {  2139, 0x0000812D }, /* GL_CLAMP_TO_BORDER */
+   {  2158, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */
+   {  2181, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */
+   {  2205, 0x0000812F }, /* GL_CLAMP_TO_EDGE */
+   {  2222, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */
+   {  2244, 0x00001500 }, /* GL_CLEAR */
+   {  2253, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */
+   {  2278, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */
+   {  2307, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */
+   {  2333, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
+   {  2362, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */
+   {  2388, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */
+   {  2415, 0x00003000 }, /* GL_CLIP_PLANE0 */
+   {  2430, 0x00003001 }, /* GL_CLIP_PLANE1 */
+   {  2445, 0x00003002 }, /* GL_CLIP_PLANE2 */
+   {  2460, 0x00003003 }, /* GL_CLIP_PLANE3 */
+   {  2475, 0x00003004 }, /* GL_CLIP_PLANE4 */
+   {  2490, 0x00003005 }, /* GL_CLIP_PLANE5 */
+   {  2505, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
+   {  2538, 0x00000A00 }, /* GL_COEFF */
+   {  2547, 0x00001800 }, /* GL_COLOR */
+   {  2556, 0x00008076 }, /* GL_COLOR_ARRAY */
+   {  2571, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */
+   {  2601, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   {  2635, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */
+   {  2658, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */
+   {  2678, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */
+   {  2700, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */
+   {  2720, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */
+   {  2741, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */
+   {  2766, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */
+   {  2787, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */
+   {  2809, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */
+   {  2835, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */
+   {  2857, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */
+   {  2883, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */
+   {  2905, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */
+   {  2931, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */
+   {  2953, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */
+   {  2979, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */
+   {  3001, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */
+   {  3027, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */
+   {  3049, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */
+   {  3075, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */
+   {  3100, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */
+   {  3121, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */
+   {  3146, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */
+   {  3167, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */
+   {  3192, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */
+   {  3213, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */
+   {  3238, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */
+   {  3259, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */
+   {  3284, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */
+   {  3305, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */
+   {  3330, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */
+   {  3351, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */
+   {  3376, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */
+   {  3397, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */
+   {  3422, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */
+   {  3443, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */
+   {  3468, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */
+   {  3488, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */
+   {  3509, 0x00001900 }, /* GL_COLOR_INDEX */
+   {  3524, 0x00001603 }, /* GL_COLOR_INDEXES */
+   {  3541, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */
+   {  3559, 0x00000B57 }, /* GL_COLOR_MATERIAL */
+   {  3577, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */
+   {  3600, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */
+   {  3628, 0x000080B1 }, /* GL_COLOR_MATRIX */
+   {  3644, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */
+   {  3664, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */
+   {  3692, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */
+   {  3724, 0x00008458 }, /* GL_COLOR_SUM */
+   {  3737, 0x00008458 }, /* GL_COLOR_SUM_ARB */
+   {  3754, 0x000080D0 }, /* GL_COLOR_TABLE */
+   {  3769, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */
+   {  3795, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */
+   {  3825, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */
+   {  3855, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */
+   {  3875, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */
+   {  3899, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */
+   {  3924, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */
+   {  3953, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */
+   {  3982, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */
+   {  4004, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */
+   {  4030, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */
+   {  4056, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */
+   {  4082, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */
+   {  4112, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */
+   {  4142, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */
+   {  4172, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */
+   {  4206, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */
+   {  4240, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
+   {  4270, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */
+   {  4304, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */
+   {  4338, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */
+   {  4362, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */
+   {  4390, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */
+   {  4418, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */
+   {  4439, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */
+   {  4464, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */
+   {  4485, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */
+   {  4510, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */
+   {  4535, 0x00000C23 }, /* GL_COLOR_WRITEMASK */
+   {  4554, 0x00008570 }, /* GL_COMBINE */
+   {  4565, 0x00008503 }, /* GL_COMBINE4 */
+   {  4577, 0x00008572 }, /* GL_COMBINE_ALPHA */
+   {  4594, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */
+   {  4615, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */
+   {  4636, 0x00008570 }, /* GL_COMBINE_ARB */
+   {  4651, 0x00008570 }, /* GL_COMBINE_EXT */
+   {  4666, 0x00008571 }, /* GL_COMBINE_RGB */
+   {  4681, 0x00008571 }, /* GL_COMBINE_RGB_ARB */
+   {  4700, 0x00008571 }, /* GL_COMBINE_RGB_EXT */
+   {  4719, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */
+   {  4755, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */
+   {  4779, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */
+   {  4807, 0x00001300 }, /* GL_COMPILE */
+   {  4818, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */
+   {  4841, 0x00008B81 }, /* GL_COMPILE_STATUS */
+   {  4859, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */
+   {  4879, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */
+   {  4903, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */
+   {  4927, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */
+   {  4955, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */
+   {  4979, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */
+   {  5009, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */
+   {  5043, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */
+   {  5071, 0x000084ED }, /* GL_COMPRESSED_RGB */
+   {  5089, 0x000084EE }, /* GL_COMPRESSED_RGBA */
+   {  5108, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */
+   {  5131, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
+   {  5160, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
+   {  5193, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
+   {  5226, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
+   {  5259, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */
+   {  5281, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */
+   {  5309, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
+   {  5341, 0x00008C4A }, /* GL_COMPRESSED_SLUMINANCE */
+   {  5366, 0x00008C4B }, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
+   {  5397, 0x00008C48 }, /* GL_COMPRESSED_SRGB */
+   {  5416, 0x00008C49 }, /* GL_COMPRESSED_SRGB_ALPHA */
+   {  5441, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */
+   {  5471, 0x0000911C }, /* GL_CONDITION_SATISFIED */
+   {  5494, 0x00008576 }, /* GL_CONSTANT */
+   {  5506, 0x00008003 }, /* GL_CONSTANT_ALPHA */
+   {  5524, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */
+   {  5546, 0x00008576 }, /* GL_CONSTANT_ARB */
+   {  5562, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */
+   {  5586, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */
+   {  5608, 0x00008001 }, /* GL_CONSTANT_COLOR */
+   {  5626, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */
+   {  5648, 0x00008576 }, /* GL_CONSTANT_EXT */
+   {  5664, 0x00008010 }, /* GL_CONVOLUTION_1D */
+   {  5682, 0x00008011 }, /* GL_CONVOLUTION_2D */
+   {  5700, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */
+   {  5728, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */
+   {  5759, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */
+   {  5786, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */
+   {  5817, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */
+   {  5844, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */
+   {  5875, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */
+   {  5903, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */
+   {  5935, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */
+   {  5957, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */
+   {  5983, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */
+   {  6005, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */
+   {  6031, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */
+   {  6052, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */
+   {  6077, 0x00008862 }, /* GL_COORD_REPLACE */
+   {  6094, 0x00008862 }, /* GL_COORD_REPLACE_ARB */
+   {  6115, 0x00008862 }, /* GL_COORD_REPLACE_NV */
+   {  6135, 0x00001503 }, /* GL_COPY */
+   {  6143, 0x0000150C }, /* GL_COPY_INVERTED */
+   {  6160, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */
+   {  6180, 0x00008F36 }, /* GL_COPY_READ_BUFFER */
+   {  6200, 0x00008F37 }, /* GL_COPY_WRITE_BUFFER */
+   {  6221, 0x00000B44 }, /* GL_CULL_FACE */
+   {  6234, 0x00000B45 }, /* GL_CULL_FACE_MODE */
+   {  6252, 0x000081AA }, /* GL_CULL_VERTEX_EXT */
+   {  6271, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
+   {  6303, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
+   {  6338, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */
+   {  6359, 0x00000001 }, /* GL_CURRENT_BIT */
+   {  6374, 0x00000B00 }, /* GL_CURRENT_COLOR */
+   {  6391, 0x00008453 }, /* GL_CURRENT_FOG_COORD */
+   {  6412, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */
+   {  6438, 0x00000B01 }, /* GL_CURRENT_INDEX */
+   {  6455, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */
+   {  6477, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */
+   {  6505, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */
+   {  6526, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
+   {  6560, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */
+   {  6593, 0x00000B02 }, /* GL_CURRENT_NORMAL */
+   {  6611, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */
+   {  6641, 0x00008B8D }, /* GL_CURRENT_PROGRAM */
+   {  6660, 0x00008865 }, /* GL_CURRENT_QUERY */
+   {  6677, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */
+   {  6698, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */
+   {  6722, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */
+   {  6749, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */
+   {  6773, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */
+   {  6800, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */
+   {  6833, 0x0000845F }, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
+   {  6867, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
+   {  6900, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */
+   {  6927, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */
+   {  6953, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */
+   {  6978, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
+   {  7007, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */
+   {  7029, 0x00000900 }, /* GL_CW */
+   {  7035, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */
+   {  7056, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */
+   {  7077, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */
+   {  7097, 0x00002101 }, /* GL_DECAL */
+   {  7106, 0x00001E03 }, /* GL_DECR */
+   {  7114, 0x00008508 }, /* GL_DECR_WRAP */
+   {  7127, 0x00008508 }, /* GL_DECR_WRAP_EXT */
+   {  7144, 0x00008B80 }, /* GL_DELETE_STATUS */
+   {  7161, 0x00001801 }, /* GL_DEPTH */
+   {  7170, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */
+   {  7190, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */
+   {  7210, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */
+   {  7234, 0x00000D1F }, /* GL_DEPTH_BIAS */
+   {  7248, 0x00000D56 }, /* GL_DEPTH_BITS */
+   {  7262, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
+   {  7282, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
+   {  7307, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
+   {  7327, 0x0000864F }, /* GL_DEPTH_CLAMP */
+   {  7342, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
+   {  7360, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
+   {  7381, 0x00001902 }, /* GL_DEPTH_COMPONENT */
+   {  7400, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
+   {  7421, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
+   {  7446, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
+   {  7472, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
+   {  7493, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
+   {  7518, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
+   {  7544, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
+   {  7565, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
+   {  7590, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
+   {  7616, 0x00000B74 }, /* GL_DEPTH_FUNC */
+   {  7630, 0x00000B70 }, /* GL_DEPTH_RANGE */
+   {  7645, 0x00000D1E }, /* GL_DEPTH_SCALE */
+   {  7660, 0x000084F9 }, /* GL_DEPTH_STENCIL */
+   {  7677, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
+   {  7705, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
+   {  7725, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+   {  7753, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+   {  7781, 0x00000B71 }, /* GL_DEPTH_TEST */
+   {  7795, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
+   {  7817, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
+   {  7843, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
+   {  7862, 0x00001201 }, /* GL_DIFFUSE */
+   {  7873, 0x00000BD0 }, /* GL_DITHER */
+   {  7883, 0x00000A02 }, /* GL_DOMAIN */
+   {  7893, 0x00001100 }, /* GL_DONT_CARE */
+   {  7906, 0x000086AE }, /* GL_DOT3_RGB */
+   {  7918, 0x000086AF }, /* GL_DOT3_RGBA */
+   {  7931, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
+   {  7948, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
+   {  7965, 0x000086AE }, /* GL_DOT3_RGB_ARB */
+   {  7981, 0x00008740 }, /* GL_DOT3_RGB_EXT */
+   {  7997, 0x0000140A }, /* GL_DOUBLE */
+   {  8007, 0x00000C32 }, /* GL_DOUBLEBUFFER */
+   {  8023, 0x00000C01 }, /* GL_DRAW_BUFFER */
+   {  8038, 0x00008825 }, /* GL_DRAW_BUFFER0 */
+   {  8054, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
+   {  8074, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
+   {  8094, 0x00008826 }, /* GL_DRAW_BUFFER1 */
+   {  8110, 0x0000882F }, /* GL_DRAW_BUFFER10 */
+   {  8127, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
+   {  8148, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
+   {  8169, 0x00008830 }, /* GL_DRAW_BUFFER11 */
+   {  8186, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
+   {  8207, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
+   {  8228, 0x00008831 }, /* GL_DRAW_BUFFER12 */
+   {  8245, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
+   {  8266, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
+   {  8287, 0x00008832 }, /* GL_DRAW_BUFFER13 */
+   {  8304, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
+   {  8325, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
+   {  8346, 0x00008833 }, /* GL_DRAW_BUFFER14 */
+   {  8363, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
+   {  8384, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
+   {  8405, 0x00008834 }, /* GL_DRAW_BUFFER15 */
+   {  8422, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
+   {  8443, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
+   {  8464, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
+   {  8484, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
+   {  8504, 0x00008827 }, /* GL_DRAW_BUFFER2 */
+   {  8520, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
+   {  8540, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
+   {  8560, 0x00008828 }, /* GL_DRAW_BUFFER3 */
+   {  8576, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
+   {  8596, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
+   {  8616, 0x00008829 }, /* GL_DRAW_BUFFER4 */
+   {  8632, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
+   {  8652, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
+   {  8672, 0x0000882A }, /* GL_DRAW_BUFFER5 */
+   {  8688, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
+   {  8708, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
+   {  8728, 0x0000882B }, /* GL_DRAW_BUFFER6 */
+   {  8744, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
+   {  8764, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
+   {  8784, 0x0000882C }, /* GL_DRAW_BUFFER7 */
+   {  8800, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
+   {  8820, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
+   {  8840, 0x0000882D }, /* GL_DRAW_BUFFER8 */
+   {  8856, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
+   {  8876, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
+   {  8896, 0x0000882E }, /* GL_DRAW_BUFFER9 */
+   {  8912, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
+   {  8932, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
+   {  8952, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
+   {  8972, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+   {  9004, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
+   {  9028, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
+   {  9048, 0x00000304 }, /* GL_DST_ALPHA */
+   {  9061, 0x00000306 }, /* GL_DST_COLOR */
+   {  9074, 0x0000877A }, /* GL_DU8DV8_ATI */
+   {  9088, 0x00008779 }, /* GL_DUDV_ATI */
+   {  9100, 0x000088EA }, /* GL_DYNAMIC_COPY */
+   {  9116, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
+   {  9136, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
+   {  9152, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
+   {  9172, 0x000088E9 }, /* GL_DYNAMIC_READ */
+   {  9188, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
+   {  9208, 0x00000B43 }, /* GL_EDGE_FLAG */
+   {  9221, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
+   {  9240, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+   {  9274, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
+   {  9312, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
+   {  9339, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+   {  9365, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
+   {  9389, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+   {  9421, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
+   {  9457, 0x00001600 }, /* GL_EMISSION */
+   {  9469, 0x00002000 }, /* GL_ENABLE_BIT */
+   {  9483, 0x00000202 }, /* GL_EQUAL */
+   {  9492, 0x00001509 }, /* GL_EQUIV */
+   {  9501, 0x00010000 }, /* GL_EVAL_BIT */
+   {  9513, 0x00000800 }, /* GL_EXP */
+   {  9520, 0x00000801 }, /* GL_EXP2 */
+   {  9528, 0x00001F03 }, /* GL_EXTENSIONS */
+   {  9542, 0x00002400 }, /* GL_EYE_LINEAR */
+   {  9556, 0x00002502 }, /* GL_EYE_PLANE */
+   {  9569, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
+   {  9594, 0x0000855B }, /* GL_EYE_RADIAL_NV */
+   {  9611, 0x00000000 }, /* GL_FALSE */
+   {  9620, 0x00001101 }, /* GL_FASTEST */
+   {  9631, 0x00001C01 }, /* GL_FEEDBACK */
+   {  9643, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
+   {  9670, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
+   {  9694, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
+   {  9718, 0x00001B02 }, /* GL_FILL */
+   {  9726, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+   {  9757, 0x00001D00 }, /* GL_FLAT */
+   {  9765, 0x00001406 }, /* GL_FLOAT */
+   {  9774, 0x00008B5A }, /* GL_FLOAT_MAT2 */
+   {  9788, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
+   {  9806, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
+   {  9822, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
+   {  9838, 0x00008B5B }, /* GL_FLOAT_MAT3 */
+   {  9852, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
+   {  9870, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
+   {  9886, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
+   {  9902, 0x00008B5C }, /* GL_FLOAT_MAT4 */
+   {  9916, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
+   {  9934, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
+   {  9950, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
+   {  9966, 0x00008B50 }, /* GL_FLOAT_VEC2 */
+   {  9980, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
+   {  9998, 0x00008B51 }, /* GL_FLOAT_VEC3 */
+   { 10012, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
+   { 10030, 0x00008B52 }, /* GL_FLOAT_VEC4 */
+   { 10044, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
+   { 10062, 0x00000B60 }, /* GL_FOG */
+   { 10069, 0x00000080 }, /* GL_FOG_BIT */
+   { 10080, 0x00000B66 }, /* GL_FOG_COLOR */
+   { 10093, 0x00008451 }, /* GL_FOG_COORD */
+   { 10106, 0x00008451 }, /* GL_FOG_COORDINATE */
+   { 10124, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
+   { 10148, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+   { 10187, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
+   { 10230, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+   { 10262, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+   { 10293, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+   { 10322, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
+   { 10347, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
+   { 10366, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
+   { 10400, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
+   { 10427, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
+   { 10453, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
+   { 10477, 0x00008450 }, /* GL_FOG_COORD_SRC */
+   { 10494, 0x00000B62 }, /* GL_FOG_DENSITY */
+   { 10509, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
+   { 10533, 0x00000B64 }, /* GL_FOG_END */
+   { 10544, 0x00000C54 }, /* GL_FOG_HINT */
+   { 10556, 0x00000B61 }, /* GL_FOG_INDEX */
+   { 10569, 0x00000B65 }, /* GL_FOG_MODE */
+   { 10581, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
+   { 10600, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
+   { 10625, 0x00000B63 }, /* GL_FOG_START */
+   { 10638, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
+   { 10656, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
+   { 10680, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
+   { 10699, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
+   { 10722, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+   { 10757, 0x00008D40 }, /* GL_FRAMEBUFFER */
+   { 10772, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+   { 10809, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+   { 10845, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+   { 10886, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+   { 10927, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+   { 10964, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+   { 11001, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+   { 11039, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
+   { 11081, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+   { 11119, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
+   { 11161, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+   { 11196, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+   { 11235, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
+   { 11284, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+   { 11332, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
+   { 11384, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+   { 11424, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+   { 11468, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+   { 11508, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
+   { 11552, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
+   { 11579, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
+   { 11603, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
+   { 11631, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
+   { 11654, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
+   { 11673, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+   { 11710, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
+   { 11751, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+   { 11792, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+   { 11834, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+   { 11885, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+   { 11923, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+   { 11968, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
+   { 12017, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+   { 12055, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+   { 12097, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+   { 12129, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
+   { 12154, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
+   { 12181, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
+   { 12212, 0x00000404 }, /* GL_FRONT */
+   { 12221, 0x00000408 }, /* GL_FRONT_AND_BACK */
+   { 12239, 0x00000B46 }, /* GL_FRONT_FACE */
+   { 12253, 0x00000400 }, /* GL_FRONT_LEFT */
+   { 12267, 0x00000401 }, /* GL_FRONT_RIGHT */
+   { 12282, 0x00008006 }, /* GL_FUNC_ADD */
+   { 12294, 0x00008006 }, /* GL_FUNC_ADD_EXT */
+   { 12310, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
+   { 12335, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
+   { 12364, 0x0000800A }, /* GL_FUNC_SUBTRACT */
+   { 12381, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
+   { 12402, 0x00008191 }, /* GL_GENERATE_MIPMAP */
+   { 12421, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
+   { 12445, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
+   { 12474, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
+   { 12498, 0x00000206 }, /* GL_GEQUAL */
+   { 12508, 0x00000204 }, /* GL_GREATER */
+   { 12519, 0x00001904 }, /* GL_GREEN */
+   { 12528, 0x00000D19 }, /* GL_GREEN_BIAS */
+   { 12542, 0x00000D53 }, /* GL_GREEN_BITS */
+   { 12556, 0x00000D18 }, /* GL_GREEN_SCALE */
+   { 12571, 0x00008000 }, /* GL_HINT_BIT */
+   { 12583, 0x00008024 }, /* GL_HISTOGRAM */
+   { 12596, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
+   { 12620, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
+   { 12648, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
+   { 12671, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
+   { 12698, 0x00008024 }, /* GL_HISTOGRAM_EXT */
+   { 12715, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
+   { 12735, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
+   { 12759, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
+   { 12783, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
+   { 12811, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+   { 12839, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
+   { 12871, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
+   { 12893, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
+   { 12919, 0x0000802D }, /* GL_HISTOGRAM_SINK */
+   { 12937, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
+   { 12959, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
+   { 12978, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
+   { 13001, 0x0000862A }, /* GL_IDENTITY_NV */
+   { 13016, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
+   { 13036, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+   { 13076, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+   { 13114, 0x00001E02 }, /* GL_INCR */
+   { 13122, 0x00008507 }, /* GL_INCR_WRAP */
+   { 13135, 0x00008507 }, /* GL_INCR_WRAP_EXT */
+   { 13152, 0x00008222 }, /* GL_INDEX */
+   { 13161, 0x00008077 }, /* GL_INDEX_ARRAY */
+   { 13176, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+   { 13206, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
+   { 13240, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
+   { 13263, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
+   { 13285, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
+   { 13305, 0x00000D51 }, /* GL_INDEX_BITS */
+   { 13319, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
+   { 13340, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
+   { 13358, 0x00000C30 }, /* GL_INDEX_MODE */
+   { 13372, 0x00000D13 }, /* GL_INDEX_OFFSET */
+   { 13388, 0x00000D12 }, /* GL_INDEX_SHIFT */
+   { 13403, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
+   { 13422, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
+   { 13441, 0x00001404 }, /* GL_INT */
+   { 13448, 0x00008049 }, /* GL_INTENSITY */
+   { 13461, 0x0000804C }, /* GL_INTENSITY12 */
+   { 13476, 0x0000804C }, /* GL_INTENSITY12_EXT */
+   { 13495, 0x0000804D }, /* GL_INTENSITY16 */
+   { 13510, 0x0000804D }, /* GL_INTENSITY16_EXT */
+   { 13529, 0x0000804A }, /* GL_INTENSITY4 */
+   { 13543, 0x0000804A }, /* GL_INTENSITY4_EXT */
+   { 13561, 0x0000804B }, /* GL_INTENSITY8 */
+   { 13575, 0x0000804B }, /* GL_INTENSITY8_EXT */
+   { 13593, 0x00008049 }, /* GL_INTENSITY_EXT */
+   { 13610, 0x00008575 }, /* GL_INTERPOLATE */
+   { 13625, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+   { 13644, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+   { 13663, 0x00008B53 }, /* GL_INT_VEC2 */
+   { 13675, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+   { 13691, 0x00008B54 }, /* GL_INT_VEC3 */
+   { 13703, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+   { 13719, 0x00008B55 }, /* GL_INT_VEC4 */
+   { 13731, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+   { 13747, 0x00000500 }, /* GL_INVALID_ENUM */
+   { 13763, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+   { 13796, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+   { 13833, 0x00000502 }, /* GL_INVALID_OPERATION */
+   { 13854, 0x00000501 }, /* GL_INVALID_VALUE */
+   { 13871, 0x0000862B }, /* GL_INVERSE_NV */
+   { 13885, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+   { 13909, 0x0000150A }, /* GL_INVERT */
+   { 13919, 0x00001E00 }, /* GL_KEEP */
+   { 13927, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
+   { 13957, 0x00000406 }, /* GL_LEFT */
+   { 13965, 0x00000203 }, /* GL_LEQUAL */
+   { 13975, 0x00000201 }, /* GL_LESS */
+   { 13983, 0x00004000 }, /* GL_LIGHT0 */
+   { 13993, 0x00004001 }, /* GL_LIGHT1 */
+   { 14003, 0x00004002 }, /* GL_LIGHT2 */
+   { 14013, 0x00004003 }, /* GL_LIGHT3 */
+   { 14023, 0x00004004 }, /* GL_LIGHT4 */
+   { 14033, 0x00004005 }, /* GL_LIGHT5 */
+   { 14043, 0x00004006 }, /* GL_LIGHT6 */
+   { 14053, 0x00004007 }, /* GL_LIGHT7 */
+   { 14063, 0x00000B50 }, /* GL_LIGHTING */
+   { 14075, 0x00000040 }, /* GL_LIGHTING_BIT */
+   { 14091, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+   { 14114, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+   { 14143, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+   { 14176, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+   { 14204, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+   { 14228, 0x00001B01 }, /* GL_LINE */
+   { 14236, 0x00002601 }, /* GL_LINEAR */
+   { 14246, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+   { 14268, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+   { 14298, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+   { 14329, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+   { 14353, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+   { 14378, 0x00000001 }, /* GL_LINES */
+   { 14387, 0x00000004 }, /* GL_LINE_BIT */
+   { 14399, 0x00000002 }, /* GL_LINE_LOOP */
+   { 14412, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+   { 14432, 0x00000B20 }, /* GL_LINE_SMOOTH */
+   { 14447, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+   { 14467, 0x00000B24 }, /* GL_LINE_STIPPLE */
+   { 14483, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+   { 14507, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+   { 14530, 0x00000003 }, /* GL_LINE_STRIP */
+   { 14544, 0x00000702 }, /* GL_LINE_TOKEN */
+   { 14558, 0x00000B21 }, /* GL_LINE_WIDTH */
+   { 14572, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+   { 14598, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+   { 14618, 0x00008B82 }, /* GL_LINK_STATUS */
+   { 14633, 0x00000B32 }, /* GL_LIST_BASE */
+   { 14646, 0x00020000 }, /* GL_LIST_BIT */
+   { 14658, 0x00000B33 }, /* GL_LIST_INDEX */
+   { 14672, 0x00000B30 }, /* GL_LIST_MODE */
+   { 14685, 0x00000101 }, /* GL_LOAD */
+   { 14693, 0x00000BF1 }, /* GL_LOGIC_OP */
+   { 14705, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+   { 14722, 0x00008CA1 }, /* GL_LOWER_LEFT */
+   { 14736, 0x00001909 }, /* GL_LUMINANCE */
+   { 14749, 0x00008041 }, /* GL_LUMINANCE12 */
+   { 14764, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+   { 14787, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+   { 14814, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+   { 14836, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+   { 14862, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+   { 14881, 0x00008042 }, /* GL_LUMINANCE16 */
+   { 14896, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+   { 14919, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+   { 14946, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+   { 14965, 0x0000803F }, /* GL_LUMINANCE4 */
+   { 14979, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+   { 15000, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+   { 15025, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+   { 15043, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+   { 15064, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+   { 15089, 0x00008040 }, /* GL_LUMINANCE8 */
+   { 15103, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+   { 15124, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+   { 15149, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+   { 15167, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+   { 15186, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+   { 15202, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+   { 15222, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+   { 15244, 0x00000D91 }, /* GL_MAP1_INDEX */
+   { 15258, 0x00000D92 }, /* GL_MAP1_NORMAL */
+   { 15273, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+   { 15297, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+   { 15321, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+   { 15345, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+   { 15369, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+   { 15386, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+   { 15403, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+   { 15431, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+   { 15460, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+   { 15489, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+   { 15518, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+   { 15547, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+   { 15576, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+   { 15605, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+   { 15633, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+   { 15661, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+   { 15689, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+   { 15717, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+   { 15745, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+   { 15773, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+   { 15801, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+   { 15829, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+   { 15857, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+   { 15873, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+   { 15893, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+   { 15915, 0x00000DB1 }, /* GL_MAP2_INDEX */
+   { 15929, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+   { 15944, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+   { 15968, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+   { 15992, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+   { 16016, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+   { 16040, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+   { 16057, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+   { 16074, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+   { 16102, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+   { 16131, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+   { 16160, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+   { 16189, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+   { 16218, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+   { 16247, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+   { 16276, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+   { 16304, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+   { 16332, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+   { 16360, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+   { 16388, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+   { 16416, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+   { 16444, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+   { 16472, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+   { 16500, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+   { 16528, 0x00000D10 }, /* GL_MAP_COLOR */
+   { 16541, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
+   { 16567, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
+   { 16596, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
+   { 16624, 0x00000001 }, /* GL_MAP_READ_BIT */
+   { 16640, 0x00000D11 }, /* GL_MAP_STENCIL */
+   { 16655, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
+   { 16681, 0x00000002 }, /* GL_MAP_WRITE_BIT */
+   { 16698, 0x000088C0 }, /* GL_MATRIX0_ARB */
+   { 16713, 0x00008630 }, /* GL_MATRIX0_NV */
+   { 16727, 0x000088CA }, /* GL_MATRIX10_ARB */
+   { 16743, 0x000088CB }, /* GL_MATRIX11_ARB */
+   { 16759, 0x000088CC }, /* GL_MATRIX12_ARB */
+   { 16775, 0x000088CD }, /* GL_MATRIX13_ARB */
+   { 16791, 0x000088CE }, /* GL_MATRIX14_ARB */
+   { 16807, 0x000088CF }, /* GL_MATRIX15_ARB */
+   { 16823, 0x000088D0 }, /* GL_MATRIX16_ARB */
+   { 16839, 0x000088D1 }, /* GL_MATRIX17_ARB */
+   { 16855, 0x000088D2 }, /* GL_MATRIX18_ARB */
+   { 16871, 0x000088D3 }, /* GL_MATRIX19_ARB */
+   { 16887, 0x000088C1 }, /* GL_MATRIX1_ARB */
+   { 16902, 0x00008631 }, /* GL_MATRIX1_NV */
+   { 16916, 0x000088D4 }, /* GL_MATRIX20_ARB */
+   { 16932, 0x000088D5 }, /* GL_MATRIX21_ARB */
+   { 16948, 0x000088D6 }, /* GL_MATRIX22_ARB */
+   { 16964, 0x000088D7 }, /* GL_MATRIX23_ARB */
+   { 16980, 0x000088D8 }, /* GL_MATRIX24_ARB */
+   { 16996, 0x000088D9 }, /* GL_MATRIX25_ARB */
+   { 17012, 0x000088DA }, /* GL_MATRIX26_ARB */
+   { 17028, 0x000088DB }, /* GL_MATRIX27_ARB */
+   { 17044, 0x000088DC }, /* GL_MATRIX28_ARB */
+   { 17060, 0x000088DD }, /* GL_MATRIX29_ARB */
+   { 17076, 0x000088C2 }, /* GL_MATRIX2_ARB */
+   { 17091, 0x00008632 }, /* GL_MATRIX2_NV */
+   { 17105, 0x000088DE }, /* GL_MATRIX30_ARB */
+   { 17121, 0x000088DF }, /* GL_MATRIX31_ARB */
+   { 17137, 0x000088C3 }, /* GL_MATRIX3_ARB */
+   { 17152, 0x00008633 }, /* GL_MATRIX3_NV */
+   { 17166, 0x000088C4 }, /* GL_MATRIX4_ARB */
+   { 17181, 0x00008634 }, /* GL_MATRIX4_NV */
+   { 17195, 0x000088C5 }, /* GL_MATRIX5_ARB */
+   { 17210, 0x00008635 }, /* GL_MATRIX5_NV */
+   { 17224, 0x000088C6 }, /* GL_MATRIX6_ARB */
+   { 17239, 0x00008636 }, /* GL_MATRIX6_NV */
+   { 17253, 0x000088C7 }, /* GL_MATRIX7_ARB */
+   { 17268, 0x00008637 }, /* GL_MATRIX7_NV */
+   { 17282, 0x000088C8 }, /* GL_MATRIX8_ARB */
+   { 17297, 0x000088C9 }, /* GL_MATRIX9_ARB */
+   { 17312, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+   { 17338, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+   { 17372, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+   { 17403, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+   { 17436, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+   { 17467, 0x00000BA0 }, /* GL_MATRIX_MODE */
+   { 17482, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+   { 17504, 0x00008008 }, /* GL_MAX */
+   { 17511, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+   { 17534, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+   { 17566, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+   { 17592, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+   { 17625, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+   { 17651, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 17685, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+   { 17704, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+   { 17733, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+   { 17765, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+   { 17801, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+   { 17837, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+   { 17877, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+   { 17903, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+   { 17933, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+   { 17958, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+   { 17987, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+   { 18016, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+   { 18049, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
+   { 18069, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+   { 18093, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+   { 18117, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+   { 18141, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+   { 18166, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+   { 18184, 0x00008008 }, /* GL_MAX_EXT */
+   { 18195, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+   { 18230, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+   { 18269, 0x00000D31 }, /* GL_MAX_LIGHTS */
+   { 18283, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+   { 18303, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+   { 18341, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+   { 18370, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+   { 18394, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+   { 18422, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+   { 18445, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 18482, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 18518, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+   { 18545, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+   { 18574, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+   { 18608, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+   { 18644, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+   { 18671, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+   { 18703, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+   { 18739, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+   { 18768, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+   { 18797, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+   { 18825, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+   { 18863, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 18907, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 18950, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 18984, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 19023, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 19060, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 19098, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 19141, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 19184, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+   { 19214, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+   { 19245, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 19281, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 19317, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+   { 19347, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+   { 19381, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+   { 19414, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+   { 19443, 0x00008D57 }, /* GL_MAX_SAMPLES */
+   { 19458, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+   { 19485, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+   { 19505, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+   { 19529, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
+   { 19551, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+   { 19577, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+   { 19604, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+   { 19635, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+   { 19659, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 19693, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+   { 19713, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+   { 19740, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+   { 19761, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+   { 19786, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+   { 19811, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+   { 19846, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
+   { 19868, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+   { 19894, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
+   { 19916, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+   { 19942, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+   { 19976, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+   { 20014, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+   { 20047, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+   { 20084, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+   { 20108, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+   { 20129, 0x00008007 }, /* GL_MIN */
+   { 20136, 0x0000802E }, /* GL_MINMAX */
+   { 20146, 0x0000802E }, /* GL_MINMAX_EXT */
+   { 20160, 0x0000802F }, /* GL_MINMAX_FORMAT */
+   { 20177, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+   { 20198, 0x00008030 }, /* GL_MINMAX_SINK */
+   { 20213, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+   { 20232, 0x00008007 }, /* GL_MIN_EXT */
+   { 20243, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+   { 20262, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+   { 20285, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+   { 20308, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+   { 20328, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+   { 20348, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+   { 20378, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+   { 20406, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+   { 20434, 0x00001700 }, /* GL_MODELVIEW */
+   { 20447, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+   { 20465, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+   { 20484, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+   { 20503, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+   { 20522, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+   { 20541, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+   { 20560, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+   { 20579, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+   { 20598, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+   { 20617, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+   { 20636, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+   { 20655, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+   { 20673, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+   { 20692, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+   { 20711, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+   { 20730, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+   { 20749, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+   { 20768, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+   { 20787, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+   { 20806, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+   { 20825, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+   { 20844, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+   { 20863, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+   { 20881, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+   { 20900, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+   { 20919, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+   { 20937, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+   { 20955, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+   { 20973, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+   { 20991, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+   { 21009, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+   { 21027, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+   { 21045, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+   { 21065, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+   { 21092, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+   { 21117, 0x00002100 }, /* GL_MODULATE */
+   { 21129, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+   { 21149, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+   { 21176, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+   { 21201, 0x00000103 }, /* GL_MULT */
+   { 21209, 0x0000809D }, /* GL_MULTISAMPLE */
+   { 21224, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+   { 21244, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+   { 21263, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+   { 21282, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+   { 21306, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+   { 21329, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+   { 21359, 0x00002A25 }, /* GL_N3F_V3F */
+   { 21370, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+   { 21390, 0x0000150E }, /* GL_NAND */
+   { 21398, 0x00002600 }, /* GL_NEAREST */
+   { 21409, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+   { 21440, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+   { 21472, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+   { 21497, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+   { 21523, 0x00000200 }, /* GL_NEVER */
+   { 21532, 0x00001102 }, /* GL_NICEST */
+   { 21542, 0x00000000 }, /* GL_NONE */
+   { 21550, 0x00001505 }, /* GL_NOOP */
+   { 21558, 0x00001508 }, /* GL_NOR */
+   { 21565, 0x00000BA1 }, /* GL_NORMALIZE */
+   { 21578, 0x00008075 }, /* GL_NORMAL_ARRAY */
+   { 21594, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+   { 21625, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+   { 21660, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+   { 21684, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+   { 21707, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+   { 21728, 0x00008511 }, /* GL_NORMAL_MAP */
+   { 21742, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+   { 21760, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+   { 21777, 0x00000205 }, /* GL_NOTEQUAL */
+   { 21789, 0x00000000 }, /* GL_NO_ERROR */
+   { 21801, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+   { 21835, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
+   { 21873, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+   { 21905, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+   { 21947, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+   { 21977, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+   { 22017, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+   { 22048, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+   { 22077, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+   { 22105, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+   { 22135, 0x00002401 }, /* GL_OBJECT_LINEAR */
+   { 22152, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+   { 22178, 0x00002501 }, /* GL_OBJECT_PLANE */
+   { 22194, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+   { 22229, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+   { 22251, 0x00009112 }, /* GL_OBJECT_TYPE */
+   { 22266, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+   { 22285, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+   { 22315, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+   { 22336, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+   { 22364, 0x00000001 }, /* GL_ONE */
+   { 22371, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+   { 22399, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+   { 22431, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+   { 22459, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+   { 22491, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+   { 22514, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+   { 22537, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+   { 22560, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+   { 22583, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+   { 22601, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+   { 22623, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+   { 22645, 0x00008590 }, /* GL_OPERAND0_RGB */
+   { 22661, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+   { 22681, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+   { 22701, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+   { 22719, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+   { 22741, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+   { 22763, 0x00008591 }, /* GL_OPERAND1_RGB */
+   { 22779, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+   { 22799, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+   { 22819, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+   { 22837, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+   { 22859, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+   { 22881, 0x00008592 }, /* GL_OPERAND2_RGB */
+   { 22897, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+   { 22917, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+   { 22937, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+   { 22958, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+   { 22977, 0x00001507 }, /* GL_OR */
+   { 22983, 0x00000A01 }, /* GL_ORDER */
+   { 22992, 0x0000150D }, /* GL_OR_INVERTED */
+   { 23007, 0x0000150B }, /* GL_OR_REVERSE */
+   { 23021, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+   { 23038, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+   { 23056, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+   { 23077, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+   { 23097, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+   { 23115, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+   { 23134, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+   { 23154, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+   { 23174, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+   { 23192, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+   { 23211, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+   { 23236, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+   { 23260, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+   { 23281, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+   { 23303, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+   { 23325, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+   { 23350, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+   { 23374, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+   { 23395, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+   { 23417, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+   { 23439, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+   { 23461, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+   { 23492, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+   { 23512, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+   { 23537, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+   { 23557, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+   { 23582, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+   { 23602, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+   { 23627, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+   { 23647, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+   { 23672, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+   { 23692, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+   { 23717, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+   { 23737, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+   { 23762, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+   { 23782, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+   { 23807, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+   { 23827, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+   { 23852, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+   { 23872, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+   { 23897, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+   { 23917, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+   { 23942, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+   { 23960, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
+   { 23981, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
+   { 24010, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+   { 24043, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+   { 24068, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
+   { 24091, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+   { 24122, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+   { 24157, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+   { 24184, 0x00001B00 }, /* GL_POINT */
+   { 24193, 0x00000000 }, /* GL_POINTS */
+   { 24203, 0x00000002 }, /* GL_POINT_BIT */
+   { 24216, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+   { 24246, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+   { 24280, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+   { 24314, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+   { 24349, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+   { 24378, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+   { 24411, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+   { 24444, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+   { 24478, 0x00000B11 }, /* GL_POINT_SIZE */
+   { 24492, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+   { 24518, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+   { 24536, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+   { 24558, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+   { 24580, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+   { 24603, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+   { 24621, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+   { 24643, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+   { 24665, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+   { 24688, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+   { 24708, 0x00000B10 }, /* GL_POINT_SMOOTH */
+   { 24724, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+   { 24745, 0x00008861 }, /* GL_POINT_SPRITE */
+   { 24761, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+   { 24781, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+   { 24810, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+   { 24829, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+   { 24855, 0x00000701 }, /* GL_POINT_TOKEN */
+   { 24870, 0x00000009 }, /* GL_POLYGON */
+   { 24881, 0x00000008 }, /* GL_POLYGON_BIT */
+   { 24896, 0x00000B40 }, /* GL_POLYGON_MODE */
+   { 24912, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+   { 24935, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+   { 24960, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+   { 24983, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+   { 25006, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+   { 25030, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+   { 25054, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+   { 25072, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+   { 25095, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+   { 25114, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+   { 25137, 0x00000703 }, /* GL_POLYGON_TOKEN */
+   { 25154, 0x00001203 }, /* GL_POSITION */
+   { 25166, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+   { 25198, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+   { 25234, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+   { 25267, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+   { 25304, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+   { 25335, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+   { 25370, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+   { 25402, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+   { 25438, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 25471, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+   { 25503, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+   { 25539, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+   { 25572, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+   { 25609, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+   { 25639, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+   { 25673, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+   { 25704, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+   { 25739, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+   { 25770, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+   { 25805, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+   { 25837, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+   { 25873, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+   { 25903, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+   { 25937, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+   { 25968, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+   { 26003, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+   { 26035, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+   { 26066, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+   { 26101, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+   { 26133, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+   { 26169, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+   { 26198, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+   { 26231, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+   { 26261, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+   { 26295, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+   { 26334, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+   { 26367, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+   { 26407, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+   { 26441, 0x00008578 }, /* GL_PREVIOUS */
+   { 26453, 0x00008578 }, /* GL_PREVIOUS_ARB */
+   { 26469, 0x00008578 }, /* GL_PREVIOUS_EXT */
+   { 26485, 0x00008577 }, /* GL_PRIMARY_COLOR */
+   { 26502, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+   { 26523, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+   { 26544, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 26577, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 26609, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+   { 26632, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+   { 26655, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+   { 26685, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+   { 26714, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+   { 26742, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+   { 26764, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+   { 26792, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+   { 26820, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+   { 26842, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+   { 26863, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 26903, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 26942, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 26972, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 27007, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 27040, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 27074, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 27113, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 27152, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+   { 27174, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+   { 27200, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+   { 27224, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+   { 27247, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+   { 27269, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+   { 27290, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+   { 27311, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+   { 27338, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 27370, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 27402, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+   { 27437, 0x00001701 }, /* GL_PROJECTION */
+   { 27451, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+   { 27472, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+   { 27498, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
+   { 27522, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+   { 27543, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+   { 27562, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+   { 27585, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 27624, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+   { 27662, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+   { 27682, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+   { 27712, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+   { 27736, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+   { 27756, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+   { 27786, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+   { 27810, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+   { 27830, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+   { 27863, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+   { 27889, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+   { 27919, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+   { 27950, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+   { 27980, 0x00002003 }, /* GL_Q */
+   { 27985, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+   { 28010, 0x00000007 }, /* GL_QUADS */
+   { 28019, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+   { 28067, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+   { 28084, 0x00000008 }, /* GL_QUAD_STRIP */
+   { 28098, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+   { 28120, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+   { 28146, 0x00008866 }, /* GL_QUERY_RESULT */
+   { 28162, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+   { 28182, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+   { 28208, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+   { 28238, 0x00002002 }, /* GL_R */
+   { 28243, 0x00002A10 }, /* GL_R3_G3_B2 */
+   { 28255, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+   { 28288, 0x00000C02 }, /* GL_READ_BUFFER */
+   { 28303, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
+   { 28323, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+   { 28355, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
+   { 28379, 0x000088B8 }, /* GL_READ_ONLY */
+   { 28392, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+   { 28409, 0x000088BA }, /* GL_READ_WRITE */
+   { 28423, 0x000088BA }, /* GL_READ_WRITE_ARB */
+   { 28441, 0x00001903 }, /* GL_RED */
+   { 28448, 0x00008016 }, /* GL_REDUCE */
+   { 28458, 0x00008016 }, /* GL_REDUCE_EXT */
+   { 28472, 0x00000D15 }, /* GL_RED_BIAS */
+   { 28484, 0x00000D52 }, /* GL_RED_BITS */
+   { 28496, 0x00000D14 }, /* GL_RED_SCALE */
+   { 28509, 0x00008512 }, /* GL_REFLECTION_MAP */
+   { 28527, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+   { 28549, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+   { 28570, 0x00001C00 }, /* GL_RENDER */
+   { 28580, 0x00008D41 }, /* GL_RENDERBUFFER */
+   { 28596, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
+   { 28623, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+   { 28651, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
+   { 28677, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
+   { 28704, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+   { 28724, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
+   { 28751, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
+   { 28774, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+   { 28801, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+   { 28833, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+   { 28869, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
+   { 28894, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
+   { 28918, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
+   { 28947, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
+   { 28969, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+   { 28995, 0x00001F01 }, /* GL_RENDERER */
+   { 29007, 0x00000C40 }, /* GL_RENDER_MODE */
+   { 29022, 0x00002901 }, /* GL_REPEAT */
+   { 29032, 0x00001E01 }, /* GL_REPLACE */
+   { 29043, 0x00008062 }, /* GL_REPLACE_EXT */
+   { 29058, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+   { 29081, 0x0000803A }, /* GL_RESCALE_NORMAL */
+   { 29099, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+   { 29121, 0x00000102 }, /* GL_RETURN */
+   { 29131, 0x00001907 }, /* GL_RGB */
+   { 29138, 0x00008052 }, /* GL_RGB10 */
+   { 29147, 0x00008059 }, /* GL_RGB10_A2 */
+   { 29159, 0x00008059 }, /* GL_RGB10_A2_EXT */
+   { 29175, 0x00008052 }, /* GL_RGB10_EXT */
+   { 29188, 0x00008053 }, /* GL_RGB12 */
+   { 29197, 0x00008053 }, /* GL_RGB12_EXT */
+   { 29210, 0x00008054 }, /* GL_RGB16 */
+   { 29219, 0x00008054 }, /* GL_RGB16_EXT */
+   { 29232, 0x0000804E }, /* GL_RGB2_EXT */
+   { 29244, 0x0000804F }, /* GL_RGB4 */
+   { 29252, 0x0000804F }, /* GL_RGB4_EXT */
+   { 29264, 0x000083A1 }, /* GL_RGB4_S3TC */
+   { 29277, 0x00008050 }, /* GL_RGB5 */
+   { 29285, 0x00008057 }, /* GL_RGB5_A1 */
+   { 29296, 0x00008057 }, /* GL_RGB5_A1_EXT */
+   { 29311, 0x00008050 }, /* GL_RGB5_EXT */
+   { 29323, 0x00008051 }, /* GL_RGB8 */
+   { 29331, 0x00008051 }, /* GL_RGB8_EXT */
+   { 29343, 0x00001908 }, /* GL_RGBA */
+   { 29351, 0x0000805A }, /* GL_RGBA12 */
+   { 29361, 0x0000805A }, /* GL_RGBA12_EXT */
+   { 29375, 0x0000805B }, /* GL_RGBA16 */
+   { 29385, 0x0000805B }, /* GL_RGBA16_EXT */
+   { 29399, 0x00008055 }, /* GL_RGBA2 */
+   { 29408, 0x00008055 }, /* GL_RGBA2_EXT */
+   { 29421, 0x00008056 }, /* GL_RGBA4 */
+   { 29430, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+   { 29449, 0x00008056 }, /* GL_RGBA4_EXT */
+   { 29462, 0x000083A3 }, /* GL_RGBA4_S3TC */
+   { 29476, 0x00008058 }, /* GL_RGBA8 */
+   { 29485, 0x00008058 }, /* GL_RGBA8_EXT */
+   { 29498, 0x00008F97 }, /* GL_RGBA8_SNORM */
+   { 29513, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+   { 29531, 0x00000C31 }, /* GL_RGBA_MODE */
+   { 29544, 0x000083A2 }, /* GL_RGBA_S3TC */
+   { 29557, 0x00008F93 }, /* GL_RGBA_SNORM */
+   { 29571, 0x000083A0 }, /* GL_RGB_S3TC */
+   { 29583, 0x00008573 }, /* GL_RGB_SCALE */
+   { 29596, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+   { 29613, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+   { 29630, 0x00000407 }, /* GL_RIGHT */
+   { 29639, 0x00002000 }, /* GL_S */
+   { 29644, 0x00008B5D }, /* GL_SAMPLER_1D */
+   { 29658, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
+   { 29679, 0x00008B5E }, /* GL_SAMPLER_2D */
+   { 29693, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
+   { 29714, 0x00008B5F }, /* GL_SAMPLER_3D */
+   { 29728, 0x00008B60 }, /* GL_SAMPLER_CUBE */
+   { 29744, 0x000080A9 }, /* GL_SAMPLES */
+   { 29755, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+   { 29771, 0x000080A9 }, /* GL_SAMPLES_ARB */
+   { 29786, 0x00008914 }, /* GL_SAMPLES_PASSED */
+   { 29804, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+   { 29826, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+   { 29854, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+   { 29886, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+   { 29909, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+   { 29936, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+   { 29954, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+   { 29977, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+   { 29999, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+   { 30018, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+   { 30041, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+   { 30067, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+   { 30097, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+   { 30122, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+   { 30151, 0x00080000 }, /* GL_SCISSOR_BIT */
+   { 30166, 0x00000C10 }, /* GL_SCISSOR_BOX */
+   { 30181, 0x00000C11 }, /* GL_SCISSOR_TEST */
+   { 30197, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+   { 30222, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+   { 30262, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   { 30306, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+   { 30339, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+   { 30369, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+   { 30401, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+   { 30431, 0x00001C02 }, /* GL_SELECT */
+   { 30441, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+   { 30469, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+   { 30494, 0x00008012 }, /* GL_SEPARABLE_2D */
+   { 30510, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+   { 30537, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+   { 30568, 0x0000150F }, /* GL_SET */
+   { 30575, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+   { 30596, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
+   { 30620, 0x00008B4F }, /* GL_SHADER_TYPE */
+   { 30635, 0x00000B54 }, /* GL_SHADE_MODEL */
+   { 30650, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
+   { 30678, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+   { 30701, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+   { 30731, 0x00001601 }, /* GL_SHININESS */
+   { 30744, 0x00001402 }, /* GL_SHORT */
+   { 30753, 0x00009119 }, /* GL_SIGNALED */
+   { 30765, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
+   { 30786, 0x000081F9 }, /* GL_SINGLE_COLOR */
+   { 30802, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+   { 30822, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+   { 30841, 0x00008C46 }, /* GL_SLUMINANCE */
+   { 30855, 0x00008C47 }, /* GL_SLUMINANCE8 */
+   { 30870, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
+   { 30892, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
+   { 30912, 0x00001D01 }, /* GL_SMOOTH */
+   { 30922, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+   { 30955, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+   { 30982, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+   { 31015, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+   { 31042, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+   { 31059, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+   { 31080, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+   { 31101, 0x00008580 }, /* GL_SOURCE0_RGB */
+   { 31116, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+   { 31135, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+   { 31154, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+   { 31171, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+   { 31192, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+   { 31213, 0x00008581 }, /* GL_SOURCE1_RGB */
+   { 31228, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+   { 31247, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+   { 31266, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+   { 31283, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+   { 31304, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+   { 31325, 0x00008582 }, /* GL_SOURCE2_RGB */
+   { 31340, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+   { 31359, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+   { 31378, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+   { 31398, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+   { 31416, 0x00001202 }, /* GL_SPECULAR */
+   { 31428, 0x00002402 }, /* GL_SPHERE_MAP */
+   { 31442, 0x00001206 }, /* GL_SPOT_CUTOFF */
+   { 31457, 0x00001204 }, /* GL_SPOT_DIRECTION */
+   { 31475, 0x00001205 }, /* GL_SPOT_EXPONENT */
+   { 31492, 0x00008588 }, /* GL_SRC0_ALPHA */
+   { 31506, 0x00008580 }, /* GL_SRC0_RGB */
+   { 31518, 0x00008589 }, /* GL_SRC1_ALPHA */
+   { 31532, 0x00008581 }, /* GL_SRC1_RGB */
+   { 31544, 0x0000858A }, /* GL_SRC2_ALPHA */
+   { 31558, 0x00008582 }, /* GL_SRC2_RGB */
+   { 31570, 0x00000302 }, /* GL_SRC_ALPHA */
+   { 31583, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+   { 31605, 0x00000300 }, /* GL_SRC_COLOR */
+   { 31618, 0x00008C40 }, /* GL_SRGB */
+   { 31626, 0x00008C41 }, /* GL_SRGB8 */
+   { 31635, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
+   { 31651, 0x00008C42 }, /* GL_SRGB_ALPHA */
+   { 31665, 0x00000503 }, /* GL_STACK_OVERFLOW */
+   { 31683, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+   { 31702, 0x000088E6 }, /* GL_STATIC_COPY */
+   { 31717, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+   { 31736, 0x000088E4 }, /* GL_STATIC_DRAW */
+   { 31751, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+   { 31770, 0x000088E5 }, /* GL_STATIC_READ */
+   { 31785, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+   { 31804, 0x00001802 }, /* GL_STENCIL */
+   { 31815, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
+   { 31837, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+   { 31863, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
+   { 31884, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
+   { 31909, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
+   { 31930, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
+   { 31955, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+   { 31987, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
+   { 32023, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+   { 32055, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
+   { 32091, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
+   { 32111, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
+   { 32138, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
+   { 32164, 0x00000D57 }, /* GL_STENCIL_BITS */
+   { 32180, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+   { 32202, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+   { 32225, 0x00000B94 }, /* GL_STENCIL_FAIL */
+   { 32241, 0x00000B92 }, /* GL_STENCIL_FUNC */
+   { 32257, 0x00001901 }, /* GL_STENCIL_INDEX */
+   { 32274, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+   { 32297, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+   { 32319, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+   { 32341, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+   { 32363, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+   { 32384, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+   { 32411, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+   { 32438, 0x00000B97 }, /* GL_STENCIL_REF */
+   { 32453, 0x00000B90 }, /* GL_STENCIL_TEST */
+   { 32469, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+   { 32498, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+   { 32520, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+   { 32541, 0x00000C33 }, /* GL_STEREO */
+   { 32551, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
+   { 32575, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
+   { 32600, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
+   { 32624, 0x000088E2 }, /* GL_STREAM_COPY */
+   { 32639, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+   { 32658, 0x000088E0 }, /* GL_STREAM_DRAW */
+   { 32673, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+   { 32692, 0x000088E1 }, /* GL_STREAM_READ */
+   { 32707, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+   { 32726, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+   { 32743, 0x000084E7 }, /* GL_SUBTRACT */
+   { 32755, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+   { 32771, 0x00009113 }, /* GL_SYNC_CONDITION */
+   { 32789, 0x00009116 }, /* GL_SYNC_FENCE */
+   { 32803, 0x00009115 }, /* GL_SYNC_FLAGS */
+   { 32817, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
+   { 32844, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+   { 32874, 0x00009114 }, /* GL_SYNC_STATUS */
+   { 32889, 0x00002001 }, /* GL_T */
+   { 32894, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+   { 32909, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+   { 32928, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+   { 32944, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+   { 32959, 0x00002A27 }, /* GL_T2F_V3F */
+   { 32970, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+   { 32989, 0x00002A28 }, /* GL_T4F_V4F */
+   { 33000, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+   { 33023, 0x00001702 }, /* GL_TEXTURE */
+   { 33034, 0x000084C0 }, /* GL_TEXTURE0 */
+   { 33046, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+   { 33062, 0x000084C1 }, /* GL_TEXTURE1 */
+   { 33074, 0x000084CA }, /* GL_TEXTURE10 */
+   { 33087, 0x000084CA }, /* GL_TEXTURE10_ARB */
+   { 33104, 0x000084CB }, /* GL_TEXTURE11 */
+   { 33117, 0x000084CB }, /* GL_TEXTURE11_ARB */
+   { 33134, 0x000084CC }, /* GL_TEXTURE12 */
+   { 33147, 0x000084CC }, /* GL_TEXTURE12_ARB */
+   { 33164, 0x000084CD }, /* GL_TEXTURE13 */
+   { 33177, 0x000084CD }, /* GL_TEXTURE13_ARB */
+   { 33194, 0x000084CE }, /* GL_TEXTURE14 */
+   { 33207, 0x000084CE }, /* GL_TEXTURE14_ARB */
+   { 33224, 0x000084CF }, /* GL_TEXTURE15 */
+   { 33237, 0x000084CF }, /* GL_TEXTURE15_ARB */
+   { 33254, 0x000084D0 }, /* GL_TEXTURE16 */
+   { 33267, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+   { 33284, 0x000084D1 }, /* GL_TEXTURE17 */
+   { 33297, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+   { 33314, 0x000084D2 }, /* GL_TEXTURE18 */
+   { 33327, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+   { 33344, 0x000084D3 }, /* GL_TEXTURE19 */
+   { 33357, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+   { 33374, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+   { 33390, 0x000084C2 }, /* GL_TEXTURE2 */
+   { 33402, 0x000084D4 }, /* GL_TEXTURE20 */
+   { 33415, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+   { 33432, 0x000084D5 }, /* GL_TEXTURE21 */
+   { 33445, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+   { 33462, 0x000084D6 }, /* GL_TEXTURE22 */
+   { 33475, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+   { 33492, 0x000084D7 }, /* GL_TEXTURE23 */
+   { 33505, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+   { 33522, 0x000084D8 }, /* GL_TEXTURE24 */
+   { 33535, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+   { 33552, 0x000084D9 }, /* GL_TEXTURE25 */
+   { 33565, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+   { 33582, 0x000084DA }, /* GL_TEXTURE26 */
+   { 33595, 0x000084DA }, /* GL_TEXTURE26_ARB */
+   { 33612, 0x000084DB }, /* GL_TEXTURE27 */
+   { 33625, 0x000084DB }, /* GL_TEXTURE27_ARB */
+   { 33642, 0x000084DC }, /* GL_TEXTURE28 */
+   { 33655, 0x000084DC }, /* GL_TEXTURE28_ARB */
+   { 33672, 0x000084DD }, /* GL_TEXTURE29 */
+   { 33685, 0x000084DD }, /* GL_TEXTURE29_ARB */
+   { 33702, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+   { 33718, 0x000084C3 }, /* GL_TEXTURE3 */
+   { 33730, 0x000084DE }, /* GL_TEXTURE30 */
+   { 33743, 0x000084DE }, /* GL_TEXTURE30_ARB */
+   { 33760, 0x000084DF }, /* GL_TEXTURE31 */
+   { 33773, 0x000084DF }, /* GL_TEXTURE31_ARB */
+   { 33790, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+   { 33806, 0x000084C4 }, /* GL_TEXTURE4 */
+   { 33818, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+   { 33834, 0x000084C5 }, /* GL_TEXTURE5 */
+   { 33846, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+   { 33862, 0x000084C6 }, /* GL_TEXTURE6 */
+   { 33874, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+   { 33890, 0x000084C7 }, /* GL_TEXTURE7 */
+   { 33902, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+   { 33918, 0x000084C8 }, /* GL_TEXTURE8 */
+   { 33930, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+   { 33946, 0x000084C9 }, /* GL_TEXTURE9 */
+   { 33958, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+   { 33974, 0x00000DE0 }, /* GL_TEXTURE_1D */
+   { 33988, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
+   { 34012, 0x00000DE1 }, /* GL_TEXTURE_2D */
+   { 34026, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
+   { 34050, 0x0000806F }, /* GL_TEXTURE_3D */
+   { 34064, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+   { 34086, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+   { 34112, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+   { 34134, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+   { 34156, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+   { 34188, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+   { 34210, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+   { 34242, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+   { 34264, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+   { 34292, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+   { 34324, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+   { 34357, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+   { 34389, 0x00040000 }, /* GL_TEXTURE_BIT */
+   { 34404, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+   { 34425, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+   { 34450, 0x00001005 }, /* GL_TEXTURE_BORDER */
+   { 34468, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+   { 34492, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+   { 34523, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+   { 34553, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+   { 34583, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+   { 34618, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+   { 34649, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 34687, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+   { 34714, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+   { 34746, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+   { 34780, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+   { 34804, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+   { 34832, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+   { 34856, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+   { 34884, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+   { 34917, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+   { 34941, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+   { 34963, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+   { 34985, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+   { 35011, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 35045, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+   { 35078, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+   { 35115, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+   { 35143, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+   { 35175, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+   { 35198, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+   { 35236, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+   { 35278, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+   { 35309, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+   { 35337, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+   { 35367, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+   { 35395, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+   { 35415, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+   { 35439, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+   { 35470, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+   { 35505, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+   { 35536, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+   { 35571, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+   { 35602, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+   { 35637, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+   { 35668, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+   { 35703, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+   { 35734, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+   { 35769, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+   { 35800, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+   { 35835, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+   { 35864, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+   { 35881, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+   { 35903, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+   { 35929, 0x00002300 }, /* GL_TEXTURE_ENV */
+   { 35944, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+   { 35965, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+   { 35985, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+   { 36011, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+   { 36031, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+   { 36048, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+   { 36065, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+   { 36082, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+   { 36099, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+   { 36124, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+   { 36146, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+   { 36172, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+   { 36190, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+   { 36216, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+   { 36242, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+   { 36272, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+   { 36299, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+   { 36324, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+   { 36344, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+   { 36368, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+   { 36395, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+   { 36422, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+   { 36449, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+   { 36475, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+   { 36505, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+   { 36527, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+   { 36545, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 36575, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+   { 36603, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+   { 36631, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+   { 36659, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+   { 36680, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+   { 36699, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+   { 36721, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+   { 36740, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+   { 36760, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+   { 36790, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+   { 36821, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+   { 36846, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+   { 36870, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+   { 36890, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+   { 36914, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+   { 36934, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+   { 36957, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
+   { 36981, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+   { 37011, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+   { 37036, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+   { 37070, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+   { 37087, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+   { 37105, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+   { 37123, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+   { 37141, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
+   { 37160, 0xFFFFFFFFFFFFFFFF }, /* GL_TIMEOUT_IGNORED */
+   { 37179, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
+   { 37199, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+   { 37218, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+   { 37247, 0x00001000 }, /* GL_TRANSFORM_BIT */
+   { 37264, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+   { 37290, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+   { 37320, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+   { 37352, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+   { 37382, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+   { 37416, 0x0000862C }, /* GL_TRANSPOSE_NV */
+   { 37432, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+   { 37463, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+   { 37498, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+   { 37526, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+   { 37558, 0x00000004 }, /* GL_TRIANGLES */
+   { 37571, 0x00000006 }, /* GL_TRIANGLE_FAN */
+   { 37587, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+   { 37608, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+   { 37626, 0x00000001 }, /* GL_TRUE */
+   { 37634, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+   { 37654, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+   { 37677, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+   { 37697, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+   { 37718, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+   { 37740, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+   { 37762, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+   { 37782, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+   { 37803, 0x00009118 }, /* GL_UNSIGNALED */
+   { 37817, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+   { 37834, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+   { 37861, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+   { 37884, 0x00001405 }, /* GL_UNSIGNED_INT */
+   { 37900, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+   { 37927, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
+   { 37948, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+   { 37972, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+   { 38003, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+   { 38027, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+   { 38055, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
+   { 38078, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+   { 38096, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+   { 38126, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+   { 38152, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+   { 38182, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+   { 38208, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+   { 38232, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+   { 38260, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+   { 38288, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+   { 38315, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+   { 38347, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+   { 38378, 0x00008CA2 }, /* GL_UPPER_LEFT */
+   { 38392, 0x00002A20 }, /* GL_V2F */
+   { 38399, 0x00002A21 }, /* GL_V3F */
+   { 38406, 0x00008B83 }, /* GL_VALIDATE_STATUS */
+   { 38425, 0x00001F00 }, /* GL_VENDOR */
+   { 38435, 0x00001F02 }, /* GL_VERSION */
+   { 38446, 0x00008074 }, /* GL_VERTEX_ARRAY */
+   { 38462, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
+   { 38486, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
+   { 38516, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+   { 38547, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+   { 38582, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+   { 38606, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+   { 38627, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+   { 38650, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+   { 38671, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+   { 38698, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+   { 38726, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+   { 38754, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+   { 38782, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+   { 38810, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+   { 38838, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+   { 38866, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+   { 38893, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+   { 38920, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+   { 38947, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+   { 38974, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+   { 39001, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+   { 39028, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+   { 39055, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+   { 39082, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+   { 39109, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+   { 39147, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+   { 39189, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+   { 39220, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+   { 39255, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+   { 39289, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+   { 39327, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+   { 39358, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+   { 39393, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+   { 39421, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+   { 39453, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+   { 39483, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+   { 39517, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+   { 39545, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+   { 39577, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+   { 39597, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+   { 39619, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+   { 39648, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+   { 39669, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+   { 39698, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+   { 39731, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   { 39763, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+   { 39790, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+   { 39821, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   { 39851, 0x00008B31 }, /* GL_VERTEX_SHADER */
+   { 39868, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+   { 39889, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+   { 39916, 0x00000BA2 }, /* GL_VIEWPORT */
+   { 39928, 0x00000800 }, /* GL_VIEWPORT_BIT */
+   { 39944, 0x0000911D }, /* GL_WAIT_FAILED */
+   { 39959, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+   { 39979, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+   { 40010, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+   { 40045, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+   { 40073, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+   { 40098, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+   { 40125, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+   { 40150, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+   { 40174, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+   { 40193, 0x000088B9 }, /* GL_WRITE_ONLY */
+   { 40207, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+   { 40225, 0x00001506 }, /* GL_XOR */
+   { 40232, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+   { 40251, 0x00008757 }, /* GL_YCBCR_MESA */
+   { 40265, 0x00000000 }, /* GL_ZERO */
+   { 40273, 0x00000D16 }, /* GL_ZOOM_X */
+   { 40283, 0x00000D17 }, /* GL_ZOOM_Y */
 };
 
-static const unsigned reduced_enums[1284] =
+static const unsigned reduced_enums[1347] =
 {
-       434, /* GL_FALSE */
-       643, /* GL_LINES */
-       645, /* GL_LINE_LOOP */
-       652, /* GL_LINE_STRIP */
-      1639, /* GL_TRIANGLES */
-      1642, /* GL_TRIANGLE_STRIP */
-      1640, /* GL_TRIANGLE_FAN */
-      1209, /* GL_QUADS */
-      1211, /* GL_QUAD_STRIP */
-      1097, /* GL_POLYGON */
-      1109, /* GL_POLYGON_STIPPLE_BIT */
-      1062, /* GL_PIXEL_MODE_BIT */
-       630, /* GL_LIGHTING_BIT */
-       456, /* GL_FOG_BIT */
+       476, /* GL_FALSE */
+       692, /* GL_LINES */
+       694, /* GL_LINE_LOOP */
+       701, /* GL_LINE_STRIP */
+      1744, /* GL_TRIANGLES */
+      1747, /* GL_TRIANGLE_STRIP */
+      1745, /* GL_TRIANGLE_FAN */
+      1272, /* GL_QUADS */
+      1275, /* GL_QUAD_STRIP */
+      1159, /* GL_POLYGON */
+      1171, /* GL_POLYGON_STIPPLE_BIT */
+      1120, /* GL_PIXEL_MODE_BIT */
+       679, /* GL_LIGHTING_BIT */
+       505, /* GL_FOG_BIT */
          8, /* GL_ACCUM */
-       662, /* GL_LOAD */
-      1251, /* GL_RETURN */
-       935, /* GL_MULT */
+       711, /* GL_LOAD */
+      1327, /* GL_RETURN */
+       992, /* GL_MULT */
         23, /* GL_ADD */
-       951, /* GL_NEVER */
-       620, /* GL_LESS */
-       424, /* GL_EQUAL */
-       619, /* GL_LEQUAL */
-       545, /* GL_GREATER */
-       966, /* GL_NOTEQUAL */
-       520, /* GL_GEQUAL */
-        46, /* GL_ALWAYS */
-      1384, /* GL_SRC_COLOR */
-       995, /* GL_ONE_MINUS_SRC_COLOR */
-      1382, /* GL_SRC_ALPHA */
-       994, /* GL_ONE_MINUS_SRC_ALPHA */
-       405, /* GL_DST_ALPHA */
-       992, /* GL_ONE_MINUS_DST_ALPHA */
-       406, /* GL_DST_COLOR */
-       993, /* GL_ONE_MINUS_DST_COLOR */
-      1383, /* GL_SRC_ALPHA_SATURATE */
-       508, /* GL_FRONT_LEFT */
-       509, /* GL_FRONT_RIGHT */
-        68, /* GL_BACK_LEFT */
-        69, /* GL_BACK_RIGHT */
-       505, /* GL_FRONT */
-        67, /* GL_BACK */
-       618, /* GL_LEFT */
-      1291, /* GL_RIGHT */
-       506, /* GL_FRONT_AND_BACK */
-        62, /* GL_AUX0 */
-        63, /* GL_AUX1 */
-        64, /* GL_AUX2 */
-        65, /* GL_AUX3 */
-       610, /* GL_INVALID_ENUM */
-       613, /* GL_INVALID_VALUE */
-       612, /* GL_INVALID_OPERATION */
-      1385, /* GL_STACK_OVERFLOW */
-      1386, /* GL_STACK_UNDERFLOW */
-      1020, /* GL_OUT_OF_MEMORY */
-       611, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+      1008, /* GL_NEVER */
+       669, /* GL_LESS */
+       466, /* GL_EQUAL */
+       668, /* GL_LEQUAL */
+       591, /* GL_GREATER */
+      1023, /* GL_NOTEQUAL */
+       590, /* GL_GEQUAL */
+        47, /* GL_ALWAYS */
+      1468, /* GL_SRC_COLOR */
+      1053, /* GL_ONE_MINUS_SRC_COLOR */
+      1466, /* GL_SRC_ALPHA */
+      1052, /* GL_ONE_MINUS_SRC_ALPHA */
+       445, /* GL_DST_ALPHA */
+      1050, /* GL_ONE_MINUS_DST_ALPHA */
+       446, /* GL_DST_COLOR */
+      1051, /* GL_ONE_MINUS_DST_COLOR */
+      1467, /* GL_SRC_ALPHA_SATURATE */
+       578, /* GL_FRONT_LEFT */
+       579, /* GL_FRONT_RIGHT */
+        69, /* GL_BACK_LEFT */
+        70, /* GL_BACK_RIGHT */
+       575, /* GL_FRONT */
+        68, /* GL_BACK */
+       667, /* GL_LEFT */
+      1369, /* GL_RIGHT */
+       576, /* GL_FRONT_AND_BACK */
+        63, /* GL_AUX0 */
+        64, /* GL_AUX1 */
+        65, /* GL_AUX2 */
+        66, /* GL_AUX3 */
+       657, /* GL_INVALID_ENUM */
+       661, /* GL_INVALID_VALUE */
+       660, /* GL_INVALID_OPERATION */
+      1473, /* GL_STACK_OVERFLOW */
+      1474, /* GL_STACK_UNDERFLOW */
+      1078, /* GL_OUT_OF_MEMORY */
+       658, /* GL_INVALID_FRAMEBUFFER_OPERATION */
          0, /* GL_2D */
          2, /* GL_3D */
          3, /* GL_3D_COLOR */
          4, /* GL_3D_COLOR_TEXTURE */
          6, /* GL_4D_COLOR_TEXTURE */
-      1040, /* GL_PASS_THROUGH_TOKEN */
-      1096, /* GL_POINT_TOKEN */
-       653, /* GL_LINE_TOKEN */
-      1110, /* GL_POLYGON_TOKEN */
-        73, /* GL_BITMAP_TOKEN */
-       404, /* GL_DRAW_PIXEL_TOKEN */
-       270, /* GL_COPY_PIXEL_TOKEN */
-       646, /* GL_LINE_RESET_TOKEN */
-       427, /* GL_EXP */
-       428, /* GL_EXP2 */
-       303, /* GL_CW */
-       115, /* GL_CCW */
-       136, /* GL_COEFF */
-      1017, /* GL_ORDER */
-       343, /* GL_DOMAIN */
-       278, /* GL_CURRENT_COLOR */
-       281, /* GL_CURRENT_INDEX */
-       287, /* GL_CURRENT_NORMAL */
-       299, /* GL_CURRENT_TEXTURE_COORDS */
-       292, /* GL_CURRENT_RASTER_COLOR */
-       294, /* GL_CURRENT_RASTER_INDEX */
-       297, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-       295, /* GL_CURRENT_RASTER_POSITION */
-       296, /* GL_CURRENT_RASTER_POSITION_VALID */
-       293, /* GL_CURRENT_RASTER_DISTANCE */
-      1089, /* GL_POINT_SMOOTH */
-      1078, /* GL_POINT_SIZE */
-      1088, /* GL_POINT_SIZE_RANGE */
-      1079, /* GL_POINT_SIZE_GRANULARITY */
-       647, /* GL_LINE_SMOOTH */
-       654, /* GL_LINE_WIDTH */
-       656, /* GL_LINE_WIDTH_RANGE */
-       655, /* GL_LINE_WIDTH_GRANULARITY */
-       649, /* GL_LINE_STIPPLE */
-       650, /* GL_LINE_STIPPLE_PATTERN */
-       651, /* GL_LINE_STIPPLE_REPEAT */
-       661, /* GL_LIST_MODE */
-       820, /* GL_MAX_LIST_NESTING */
-       658, /* GL_LIST_BASE */
-       660, /* GL_LIST_INDEX */
-      1099, /* GL_POLYGON_MODE */
-      1106, /* GL_POLYGON_SMOOTH */
-      1108, /* GL_POLYGON_STIPPLE */
-       413, /* GL_EDGE_FLAG */
-       271, /* GL_CULL_FACE */
-       272, /* GL_CULL_FACE_MODE */
-       507, /* GL_FRONT_FACE */
-       629, /* GL_LIGHTING */
-       634, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-       635, /* GL_LIGHT_MODEL_TWO_SIDE */
-       631, /* GL_LIGHT_MODEL_AMBIENT */
-      1337, /* GL_SHADE_MODEL */
-       167, /* GL_COLOR_MATERIAL_FACE */
-       168, /* GL_COLOR_MATERIAL_PARAMETER */
-       166, /* GL_COLOR_MATERIAL */
-       455, /* GL_FOG */
-       477, /* GL_FOG_INDEX */
-       473, /* GL_FOG_DENSITY */
-       481, /* GL_FOG_START */
-       475, /* GL_FOG_END */
-       478, /* GL_FOG_MODE */
-       457, /* GL_FOG_COLOR */
-       332, /* GL_DEPTH_RANGE */
-       337, /* GL_DEPTH_TEST */
-       340, /* GL_DEPTH_WRITEMASK */
-       320, /* GL_DEPTH_CLEAR_VALUE */
-       331, /* GL_DEPTH_FUNC */
+      1098, /* GL_PASS_THROUGH_TOKEN */
+      1158, /* GL_POINT_TOKEN */
+       702, /* GL_LINE_TOKEN */
+      1172, /* GL_POLYGON_TOKEN */
+        74, /* GL_BITMAP_TOKEN */
+       444, /* GL_DRAW_PIXEL_TOKEN */
+       301, /* GL_COPY_PIXEL_TOKEN */
+       695, /* GL_LINE_RESET_TOKEN */
+       469, /* GL_EXP */
+       470, /* GL_EXP2 */
+       337, /* GL_CW */
+       125, /* GL_CCW */
+       146, /* GL_COEFF */
+      1075, /* GL_ORDER */
+       382, /* GL_DOMAIN */
+       311, /* GL_CURRENT_COLOR */
+       314, /* GL_CURRENT_INDEX */
+       320, /* GL_CURRENT_NORMAL */
+       333, /* GL_CURRENT_TEXTURE_COORDS */
+       325, /* GL_CURRENT_RASTER_COLOR */
+       327, /* GL_CURRENT_RASTER_INDEX */
+       331, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
+       328, /* GL_CURRENT_RASTER_POSITION */
+       329, /* GL_CURRENT_RASTER_POSITION_VALID */
+       326, /* GL_CURRENT_RASTER_DISTANCE */
+      1151, /* GL_POINT_SMOOTH */
+      1140, /* GL_POINT_SIZE */
+      1150, /* GL_POINT_SIZE_RANGE */
+      1141, /* GL_POINT_SIZE_GRANULARITY */
+       696, /* GL_LINE_SMOOTH */
+       703, /* GL_LINE_WIDTH */
+       705, /* GL_LINE_WIDTH_RANGE */
+       704, /* GL_LINE_WIDTH_GRANULARITY */
+       698, /* GL_LINE_STIPPLE */
+       699, /* GL_LINE_STIPPLE_PATTERN */
+       700, /* GL_LINE_STIPPLE_REPEAT */
+       710, /* GL_LIST_MODE */
+       875, /* GL_MAX_LIST_NESTING */
+       707, /* GL_LIST_BASE */
+       709, /* GL_LIST_INDEX */
+      1161, /* GL_POLYGON_MODE */
+      1168, /* GL_POLYGON_SMOOTH */
+      1170, /* GL_POLYGON_STIPPLE */
+       455, /* GL_EDGE_FLAG */
+       304, /* GL_CULL_FACE */
+       305, /* GL_CULL_FACE_MODE */
+       577, /* GL_FRONT_FACE */
+       678, /* GL_LIGHTING */
+       683, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+       684, /* GL_LIGHT_MODEL_TWO_SIDE */
+       680, /* GL_LIGHT_MODEL_AMBIENT */
+      1415, /* GL_SHADE_MODEL */
+       193, /* GL_COLOR_MATERIAL_FACE */
+       194, /* GL_COLOR_MATERIAL_PARAMETER */
+       192, /* GL_COLOR_MATERIAL */
+       504, /* GL_FOG */
+       526, /* GL_FOG_INDEX */
+       522, /* GL_FOG_DENSITY */
+       530, /* GL_FOG_START */
+       524, /* GL_FOG_END */
+       527, /* GL_FOG_MODE */
+       506, /* GL_FOG_COLOR */
+       369, /* GL_DEPTH_RANGE */
+       376, /* GL_DEPTH_TEST */
+       379, /* GL_DEPTH_WRITEMASK */
+       357, /* GL_DEPTH_CLEAR_VALUE */
+       368, /* GL_DEPTH_FUNC */
         12, /* GL_ACCUM_CLEAR_VALUE */
-      1420, /* GL_STENCIL_TEST */
-      1408, /* GL_STENCIL_CLEAR_VALUE */
-      1410, /* GL_STENCIL_FUNC */
-      1422, /* GL_STENCIL_VALUE_MASK */
-      1409, /* GL_STENCIL_FAIL */
-      1417, /* GL_STENCIL_PASS_DEPTH_FAIL */
-      1418, /* GL_STENCIL_PASS_DEPTH_PASS */
-      1419, /* GL_STENCIL_REF */
-      1423, /* GL_STENCIL_WRITEMASK */
-       789, /* GL_MATRIX_MODE */
-       956, /* GL_NORMALIZE */
-      1729, /* GL_VIEWPORT */
-       930, /* GL_MODELVIEW_STACK_DEPTH */
-      1189, /* GL_PROJECTION_STACK_DEPTH */
-      1618, /* GL_TEXTURE_STACK_DEPTH */
-       928, /* GL_MODELVIEW_MATRIX */
-      1188, /* GL_PROJECTION_MATRIX */
-      1603, /* GL_TEXTURE_MATRIX */
-        60, /* GL_ATTRIB_STACK_DEPTH */
-       126, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
+      1509, /* GL_STENCIL_TEST */
+      1497, /* GL_STENCIL_CLEAR_VALUE */
+      1499, /* GL_STENCIL_FUNC */
+      1511, /* GL_STENCIL_VALUE_MASK */
+      1498, /* GL_STENCIL_FAIL */
+      1506, /* GL_STENCIL_PASS_DEPTH_FAIL */
+      1507, /* GL_STENCIL_PASS_DEPTH_PASS */
+      1508, /* GL_STENCIL_REF */
+      1512, /* GL_STENCIL_WRITEMASK */
+       844, /* GL_MATRIX_MODE */
+      1013, /* GL_NORMALIZE */
+      1838, /* GL_VIEWPORT */
+       987, /* GL_MODELVIEW_STACK_DEPTH */
+      1251, /* GL_PROJECTION_STACK_DEPTH */
+      1719, /* GL_TEXTURE_STACK_DEPTH */
+       985, /* GL_MODELVIEW_MATRIX */
+      1250, /* GL_PROJECTION_MATRIX */
+      1702, /* GL_TEXTURE_MATRIX */
+        61, /* GL_ATTRIB_STACK_DEPTH */
+       136, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
         43, /* GL_ALPHA_TEST */
         44, /* GL_ALPHA_TEST_FUNC */
         45, /* GL_ALPHA_TEST_REF */
-       342, /* GL_DITHER */
-        77, /* GL_BLEND_DST */
-        85, /* GL_BLEND_SRC */
-        74, /* GL_BLEND */
-       664, /* GL_LOGIC_OP_MODE */
-       584, /* GL_INDEX_LOGIC_OP */
-       165, /* GL_COLOR_LOGIC_OP */
-        66, /* GL_AUX_BUFFERS */
-       353, /* GL_DRAW_BUFFER */
-      1221, /* GL_READ_BUFFER */
-      1318, /* GL_SCISSOR_BOX */
-      1319, /* GL_SCISSOR_TEST */
-       583, /* GL_INDEX_CLEAR_VALUE */
-       588, /* GL_INDEX_WRITEMASK */
-       162, /* GL_COLOR_CLEAR_VALUE */
-       204, /* GL_COLOR_WRITEMASK */
-       585, /* GL_INDEX_MODE */
-      1285, /* GL_RGBA_MODE */
-       352, /* GL_DOUBLEBUFFER */
-      1424, /* GL_STEREO */
-      1244, /* GL_RENDER_MODE */
-      1041, /* GL_PERSPECTIVE_CORRECTION_HINT */
-      1090, /* GL_POINT_SMOOTH_HINT */
-       648, /* GL_LINE_SMOOTH_HINT */
-      1107, /* GL_POLYGON_SMOOTH_HINT */
-       476, /* GL_FOG_HINT */
-      1584, /* GL_TEXTURE_GEN_S */
-      1585, /* GL_TEXTURE_GEN_T */
-      1583, /* GL_TEXTURE_GEN_R */
-      1582, /* GL_TEXTURE_GEN_Q */
-      1054, /* GL_PIXEL_MAP_I_TO_I */
-      1060, /* GL_PIXEL_MAP_S_TO_S */
-      1056, /* GL_PIXEL_MAP_I_TO_R */
-      1052, /* GL_PIXEL_MAP_I_TO_G */
-      1050, /* GL_PIXEL_MAP_I_TO_B */
-      1048, /* GL_PIXEL_MAP_I_TO_A */
-      1058, /* GL_PIXEL_MAP_R_TO_R */
-      1046, /* GL_PIXEL_MAP_G_TO_G */
-      1044, /* GL_PIXEL_MAP_B_TO_B */
-      1042, /* GL_PIXEL_MAP_A_TO_A */
-      1055, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-      1061, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-      1057, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-      1053, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-      1051, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-      1049, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-      1059, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-      1047, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-      1045, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-      1043, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-      1651, /* GL_UNPACK_SWAP_BYTES */
-      1646, /* GL_UNPACK_LSB_FIRST */
-      1647, /* GL_UNPACK_ROW_LENGTH */
-      1650, /* GL_UNPACK_SKIP_ROWS */
-      1649, /* GL_UNPACK_SKIP_PIXELS */
-      1644, /* GL_UNPACK_ALIGNMENT */
-      1029, /* GL_PACK_SWAP_BYTES */
-      1024, /* GL_PACK_LSB_FIRST */
-      1025, /* GL_PACK_ROW_LENGTH */
-      1028, /* GL_PACK_SKIP_ROWS */
-      1027, /* GL_PACK_SKIP_PIXELS */
-      1021, /* GL_PACK_ALIGNMENT */
-       742, /* GL_MAP_COLOR */
-       743, /* GL_MAP_STENCIL */
-       587, /* GL_INDEX_SHIFT */
-       586, /* GL_INDEX_OFFSET */
-      1233, /* GL_RED_SCALE */
-      1231, /* GL_RED_BIAS */
-      1746, /* GL_ZOOM_X */
-      1747, /* GL_ZOOM_Y */
-       549, /* GL_GREEN_SCALE */
-       547, /* GL_GREEN_BIAS */
-        91, /* GL_BLUE_SCALE */
-        89, /* GL_BLUE_BIAS */
+       381, /* GL_DITHER */
+        78, /* GL_BLEND_DST */
+        87, /* GL_BLEND_SRC */
+        75, /* GL_BLEND */
+       713, /* GL_LOGIC_OP_MODE */
+       631, /* GL_INDEX_LOGIC_OP */
+       191, /* GL_COLOR_LOGIC_OP */
+        67, /* GL_AUX_BUFFERS */
+       392, /* GL_DRAW_BUFFER */
+      1285, /* GL_READ_BUFFER */
+      1396, /* GL_SCISSOR_BOX */
+      1397, /* GL_SCISSOR_TEST */
+       630, /* GL_INDEX_CLEAR_VALUE */
+       635, /* GL_INDEX_WRITEMASK */
+       188, /* GL_COLOR_CLEAR_VALUE */
+       230, /* GL_COLOR_WRITEMASK */
+       632, /* GL_INDEX_MODE */
+      1362, /* GL_RGBA_MODE */
+       391, /* GL_DOUBLEBUFFER */
+      1513, /* GL_STEREO */
+      1320, /* GL_RENDER_MODE */
+      1099, /* GL_PERSPECTIVE_CORRECTION_HINT */
+      1152, /* GL_POINT_SMOOTH_HINT */
+       697, /* GL_LINE_SMOOTH_HINT */
+      1169, /* GL_POLYGON_SMOOTH_HINT */
+       525, /* GL_FOG_HINT */
+      1683, /* GL_TEXTURE_GEN_S */
+      1684, /* GL_TEXTURE_GEN_T */
+      1682, /* GL_TEXTURE_GEN_R */
+      1681, /* GL_TEXTURE_GEN_Q */
+      1112, /* GL_PIXEL_MAP_I_TO_I */
+      1118, /* GL_PIXEL_MAP_S_TO_S */
+      1114, /* GL_PIXEL_MAP_I_TO_R */
+      1110, /* GL_PIXEL_MAP_I_TO_G */
+      1108, /* GL_PIXEL_MAP_I_TO_B */
+      1106, /* GL_PIXEL_MAP_I_TO_A */
+      1116, /* GL_PIXEL_MAP_R_TO_R */
+      1104, /* GL_PIXEL_MAP_G_TO_G */
+      1102, /* GL_PIXEL_MAP_B_TO_B */
+      1100, /* GL_PIXEL_MAP_A_TO_A */
+      1113, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+      1119, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+      1115, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+      1111, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+      1109, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+      1107, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+      1117, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+      1105, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+      1103, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+      1101, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+      1756, /* GL_UNPACK_SWAP_BYTES */
+      1751, /* GL_UNPACK_LSB_FIRST */
+      1752, /* GL_UNPACK_ROW_LENGTH */
+      1755, /* GL_UNPACK_SKIP_ROWS */
+      1754, /* GL_UNPACK_SKIP_PIXELS */
+      1749, /* GL_UNPACK_ALIGNMENT */
+      1087, /* GL_PACK_SWAP_BYTES */
+      1082, /* GL_PACK_LSB_FIRST */
+      1083, /* GL_PACK_ROW_LENGTH */
+      1086, /* GL_PACK_SKIP_ROWS */
+      1085, /* GL_PACK_SKIP_PIXELS */
+      1079, /* GL_PACK_ALIGNMENT */
+       791, /* GL_MAP_COLOR */
+       796, /* GL_MAP_STENCIL */
+       634, /* GL_INDEX_SHIFT */
+       633, /* GL_INDEX_OFFSET */
+      1298, /* GL_RED_SCALE */
+      1296, /* GL_RED_BIAS */
+      1856, /* GL_ZOOM_X */
+      1857, /* GL_ZOOM_Y */
+       595, /* GL_GREEN_SCALE */
+       593, /* GL_GREEN_BIAS */
+        93, /* GL_BLUE_SCALE */
+        91, /* GL_BLUE_BIAS */
         42, /* GL_ALPHA_SCALE */
         40, /* GL_ALPHA_BIAS */
-       333, /* GL_DEPTH_SCALE */
-       314, /* GL_DEPTH_BIAS */
-       815, /* GL_MAX_EVAL_ORDER */
-       819, /* GL_MAX_LIGHTS */
-       798, /* GL_MAX_CLIP_PLANES */
-       863, /* GL_MAX_TEXTURE_SIZE */
-       825, /* GL_MAX_PIXEL_MAP_TABLE */
-       794, /* GL_MAX_ATTRIB_STACK_DEPTH */
-       822, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-       823, /* GL_MAX_NAME_STACK_DEPTH */
-       851, /* GL_MAX_PROJECTION_STACK_DEPTH */
-       864, /* GL_MAX_TEXTURE_STACK_DEPTH */
-       878, /* GL_MAX_VIEWPORT_DIMS */
-       795, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-      1431, /* GL_SUBPIXEL_BITS */
-       582, /* GL_INDEX_BITS */
-      1232, /* GL_RED_BITS */
-       548, /* GL_GREEN_BITS */
-        90, /* GL_BLUE_BITS */
+       370, /* GL_DEPTH_SCALE */
+       350, /* GL_DEPTH_BIAS */
+       870, /* GL_MAX_EVAL_ORDER */
+       874, /* GL_MAX_LIGHTS */
+       853, /* GL_MAX_CLIP_PLANES */
+       920, /* GL_MAX_TEXTURE_SIZE */
+       880, /* GL_MAX_PIXEL_MAP_TABLE */
+       849, /* GL_MAX_ATTRIB_STACK_DEPTH */
+       877, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+       878, /* GL_MAX_NAME_STACK_DEPTH */
+       906, /* GL_MAX_PROJECTION_STACK_DEPTH */
+       921, /* GL_MAX_TEXTURE_STACK_DEPTH */
+       935, /* GL_MAX_VIEWPORT_DIMS */
+       850, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+      1523, /* GL_SUBPIXEL_BITS */
+       629, /* GL_INDEX_BITS */
+      1297, /* GL_RED_BITS */
+       594, /* GL_GREEN_BITS */
+        92, /* GL_BLUE_BITS */
         41, /* GL_ALPHA_BITS */
-       315, /* GL_DEPTH_BITS */
-      1406, /* GL_STENCIL_BITS */
+       351, /* GL_DEPTH_BITS */
+      1495, /* GL_STENCIL_BITS */
         14, /* GL_ACCUM_RED_BITS */
         13, /* GL_ACCUM_GREEN_BITS */
         10, /* GL_ACCUM_BLUE_BITS */
          9, /* GL_ACCUM_ALPHA_BITS */
-       944, /* GL_NAME_STACK_DEPTH */
-        61, /* GL_AUTO_NORMAL */
-       688, /* GL_MAP1_COLOR_4 */
-       691, /* GL_MAP1_INDEX */
-       692, /* GL_MAP1_NORMAL */
-       693, /* GL_MAP1_TEXTURE_COORD_1 */
-       694, /* GL_MAP1_TEXTURE_COORD_2 */
-       695, /* GL_MAP1_TEXTURE_COORD_3 */
-       696, /* GL_MAP1_TEXTURE_COORD_4 */
-       697, /* GL_MAP1_VERTEX_3 */
-       698, /* GL_MAP1_VERTEX_4 */
-       715, /* GL_MAP2_COLOR_4 */
-       718, /* GL_MAP2_INDEX */
-       719, /* GL_MAP2_NORMAL */
-       720, /* GL_MAP2_TEXTURE_COORD_1 */
-       721, /* GL_MAP2_TEXTURE_COORD_2 */
-       722, /* GL_MAP2_TEXTURE_COORD_3 */
-       723, /* GL_MAP2_TEXTURE_COORD_4 */
-       724, /* GL_MAP2_VERTEX_3 */
-       725, /* GL_MAP2_VERTEX_4 */
-       689, /* GL_MAP1_GRID_DOMAIN */
-       690, /* GL_MAP1_GRID_SEGMENTS */
-       716, /* GL_MAP2_GRID_DOMAIN */
-       717, /* GL_MAP2_GRID_SEGMENTS */
-      1508, /* GL_TEXTURE_1D */
-      1510, /* GL_TEXTURE_2D */
-       437, /* GL_FEEDBACK_BUFFER_POINTER */
-       438, /* GL_FEEDBACK_BUFFER_SIZE */
-       439, /* GL_FEEDBACK_BUFFER_TYPE */
-      1328, /* GL_SELECTION_BUFFER_POINTER */
-      1329, /* GL_SELECTION_BUFFER_SIZE */
-      1621, /* GL_TEXTURE_WIDTH */
-      1589, /* GL_TEXTURE_HEIGHT */
-      1545, /* GL_TEXTURE_COMPONENTS */
-      1529, /* GL_TEXTURE_BORDER_COLOR */
-      1528, /* GL_TEXTURE_BORDER */
-       344, /* GL_DONT_CARE */
-       435, /* GL_FASTEST */
-       952, /* GL_NICEST */
-        47, /* GL_AMBIENT */
-       341, /* GL_DIFFUSE */
-      1371, /* GL_SPECULAR */
-      1111, /* GL_POSITION */
-      1374, /* GL_SPOT_DIRECTION */
-      1375, /* GL_SPOT_EXPONENT */
-      1373, /* GL_SPOT_CUTOFF */
-       244, /* GL_CONSTANT_ATTENUATION */
-       638, /* GL_LINEAR_ATTENUATION */
-      1208, /* GL_QUADRATIC_ATTENUATION */
-       218, /* GL_COMPILE */
-       219, /* GL_COMPILE_AND_EXECUTE */
-       110, /* GL_BYTE */
-      1652, /* GL_UNSIGNED_BYTE */
-      1342, /* GL_SHORT */
-      1661, /* GL_UNSIGNED_SHORT */
-       590, /* GL_INT */
-      1655, /* GL_UNSIGNED_INT */
-       442, /* GL_FLOAT */
+      1001, /* GL_NAME_STACK_DEPTH */
+        62, /* GL_AUTO_NORMAL */
+       737, /* GL_MAP1_COLOR_4 */
+       740, /* GL_MAP1_INDEX */
+       741, /* GL_MAP1_NORMAL */
+       742, /* GL_MAP1_TEXTURE_COORD_1 */
+       743, /* GL_MAP1_TEXTURE_COORD_2 */
+       744, /* GL_MAP1_TEXTURE_COORD_3 */
+       745, /* GL_MAP1_TEXTURE_COORD_4 */
+       746, /* GL_MAP1_VERTEX_3 */
+       747, /* GL_MAP1_VERTEX_4 */
+       764, /* GL_MAP2_COLOR_4 */
+       767, /* GL_MAP2_INDEX */
+       768, /* GL_MAP2_NORMAL */
+       769, /* GL_MAP2_TEXTURE_COORD_1 */
+       770, /* GL_MAP2_TEXTURE_COORD_2 */
+       771, /* GL_MAP2_TEXTURE_COORD_3 */
+       772, /* GL_MAP2_TEXTURE_COORD_4 */
+       773, /* GL_MAP2_VERTEX_3 */
+       774, /* GL_MAP2_VERTEX_4 */
+       738, /* GL_MAP1_GRID_DOMAIN */
+       739, /* GL_MAP1_GRID_SEGMENTS */
+       765, /* GL_MAP2_GRID_DOMAIN */
+       766, /* GL_MAP2_GRID_SEGMENTS */
+      1606, /* GL_TEXTURE_1D */
+      1608, /* GL_TEXTURE_2D */
+       479, /* GL_FEEDBACK_BUFFER_POINTER */
+       480, /* GL_FEEDBACK_BUFFER_SIZE */
+       481, /* GL_FEEDBACK_BUFFER_TYPE */
+      1406, /* GL_SELECTION_BUFFER_POINTER */
+      1407, /* GL_SELECTION_BUFFER_SIZE */
+      1724, /* GL_TEXTURE_WIDTH */
+      1688, /* GL_TEXTURE_HEIGHT */
+      1643, /* GL_TEXTURE_COMPONENTS */
+      1627, /* GL_TEXTURE_BORDER_COLOR */
+      1626, /* GL_TEXTURE_BORDER */
+       383, /* GL_DONT_CARE */
+       477, /* GL_FASTEST */
+      1009, /* GL_NICEST */
+        48, /* GL_AMBIENT */
+       380, /* GL_DIFFUSE */
+      1455, /* GL_SPECULAR */
+      1173, /* GL_POSITION */
+      1458, /* GL_SPOT_DIRECTION */
+      1459, /* GL_SPOT_EXPONENT */
+      1457, /* GL_SPOT_CUTOFF */
+       275, /* GL_CONSTANT_ATTENUATION */
+       687, /* GL_LINEAR_ATTENUATION */
+      1271, /* GL_QUADRATIC_ATTENUATION */
+       244, /* GL_COMPILE */
+       245, /* GL_COMPILE_AND_EXECUTE */
+       120, /* GL_BYTE */
+      1758, /* GL_UNSIGNED_BYTE */
+      1420, /* GL_SHORT */
+      1769, /* GL_UNSIGNED_SHORT */
+       637, /* GL_INT */
+      1761, /* GL_UNSIGNED_INT */
+       485, /* GL_FLOAT */
          1, /* GL_2_BYTES */
          5, /* GL_3_BYTES */
          7, /* GL_4_BYTES */
-       351, /* GL_DOUBLE */
-       122, /* GL_CLEAR */
-        49, /* GL_AND */
-        51, /* GL_AND_REVERSE */
-       268, /* GL_COPY */
-        50, /* GL_AND_INVERTED */
-       954, /* GL_NOOP */
-      1742, /* GL_XOR */
-      1016, /* GL_OR */
-       955, /* GL_NOR */
-       425, /* GL_EQUIV */
-       616, /* GL_INVERT */
-      1019, /* GL_OR_REVERSE */
-       269, /* GL_COPY_INVERTED */
-      1018, /* GL_OR_INVERTED */
-       945, /* GL_NAND */
-      1333, /* GL_SET */
-       422, /* GL_EMISSION */
-      1341, /* GL_SHININESS */
-        48, /* GL_AMBIENT_AND_DIFFUSE */
-       164, /* GL_COLOR_INDEXES */
-       895, /* GL_MODELVIEW */
-      1187, /* GL_PROJECTION */
-      1443, /* GL_TEXTURE */
-       137, /* GL_COLOR */
-       312, /* GL_DEPTH */
-      1393, /* GL_STENCIL */
-       163, /* GL_COLOR_INDEX */
-      1411, /* GL_STENCIL_INDEX */
-       321, /* GL_DEPTH_COMPONENT */
-      1228, /* GL_RED */
-       546, /* GL_GREEN */
-        88, /* GL_BLUE */
+       390, /* GL_DOUBLE */
+       132, /* GL_CLEAR */
+        50, /* GL_AND */
+        52, /* GL_AND_REVERSE */
+       299, /* GL_COPY */
+        51, /* GL_AND_INVERTED */
+      1011, /* GL_NOOP */
+      1852, /* GL_XOR */
+      1074, /* GL_OR */
+      1012, /* GL_NOR */
+       467, /* GL_EQUIV */
+       664, /* GL_INVERT */
+      1077, /* GL_OR_REVERSE */
+       300, /* GL_COPY_INVERTED */
+      1076, /* GL_OR_INVERTED */
+      1002, /* GL_NAND */
+      1411, /* GL_SET */
+       464, /* GL_EMISSION */
+      1419, /* GL_SHININESS */
+        49, /* GL_AMBIENT_AND_DIFFUSE */
+       190, /* GL_COLOR_INDEXES */
+       952, /* GL_MODELVIEW */
+      1249, /* GL_PROJECTION */
+      1541, /* GL_TEXTURE */
+       147, /* GL_COLOR */
+       346, /* GL_DEPTH */
+      1481, /* GL_STENCIL */
+       189, /* GL_COLOR_INDEX */
+      1500, /* GL_STENCIL_INDEX */
+       358, /* GL_DEPTH_COMPONENT */
+      1293, /* GL_RED */
+       592, /* GL_GREEN */
+        90, /* GL_BLUE */
         31, /* GL_ALPHA */
-      1252, /* GL_RGB */
-      1271, /* GL_RGBA */
-       666, /* GL_LUMINANCE */
-       687, /* GL_LUMINANCE_ALPHA */
-        72, /* GL_BITMAP */
-      1067, /* GL_POINT */
-       636, /* GL_LINE */
-       440, /* GL_FILL */
-      1237, /* GL_RENDER */
-       436, /* GL_FEEDBACK */
-      1327, /* GL_SELECT */
-       441, /* GL_FLAT */
-      1346, /* GL_SMOOTH */
-       617, /* GL_KEEP */
-      1246, /* GL_REPLACE */
-       573, /* GL_INCR */
-       308, /* GL_DECR */
-      1676, /* GL_VENDOR */
-      1243, /* GL_RENDERER */
-      1677, /* GL_VERSION */
-       429, /* GL_EXTENSIONS */
-      1292, /* GL_S */
-      1434, /* GL_T */
-      1218, /* GL_R */
-      1207, /* GL_Q */
-       931, /* GL_MODULATE */
-       307, /* GL_DECAL */
-      1579, /* GL_TEXTURE_ENV_MODE */
-      1578, /* GL_TEXTURE_ENV_COLOR */
-      1577, /* GL_TEXTURE_ENV */
-       430, /* GL_EYE_LINEAR */
-       978, /* GL_OBJECT_LINEAR */
-      1372, /* GL_SPHERE_MAP */
-      1581, /* GL_TEXTURE_GEN_MODE */
-       980, /* GL_OBJECT_PLANE */
-       431, /* GL_EYE_PLANE */
-       946, /* GL_NEAREST */
-       637, /* GL_LINEAR */
-       950, /* GL_NEAREST_MIPMAP_NEAREST */
-       642, /* GL_LINEAR_MIPMAP_NEAREST */
-       949, /* GL_NEAREST_MIPMAP_LINEAR */
-       641, /* GL_LINEAR_MIPMAP_LINEAR */
-      1602, /* GL_TEXTURE_MAG_FILTER */
-      1610, /* GL_TEXTURE_MIN_FILTER */
-      1623, /* GL_TEXTURE_WRAP_S */
-      1624, /* GL_TEXTURE_WRAP_T */
-       116, /* GL_CLAMP */
-      1245, /* GL_REPEAT */
-      1105, /* GL_POLYGON_OFFSET_UNITS */
-      1104, /* GL_POLYGON_OFFSET_POINT */
-      1103, /* GL_POLYGON_OFFSET_LINE */
-      1219, /* GL_R3_G3_B2 */
-      1673, /* GL_V2F */
-      1674, /* GL_V3F */
-       113, /* GL_C4UB_V2F */
-       114, /* GL_C4UB_V3F */
-       111, /* GL_C3F_V3F */
-       943, /* GL_N3F_V3F */
-       112, /* GL_C4F_N3F_V3F */
-      1439, /* GL_T2F_V3F */
-      1441, /* GL_T4F_V4F */
-      1437, /* GL_T2F_C4UB_V3F */
-      1435, /* GL_T2F_C3F_V3F */
-      1438, /* GL_T2F_N3F_V3F */
-      1436, /* GL_T2F_C4F_N3F_V3F */
-      1440, /* GL_T4F_C4F_N3F_V4F */
-       129, /* GL_CLIP_PLANE0 */
-       130, /* GL_CLIP_PLANE1 */
-       131, /* GL_CLIP_PLANE2 */
-       132, /* GL_CLIP_PLANE3 */
-       133, /* GL_CLIP_PLANE4 */
-       134, /* GL_CLIP_PLANE5 */
-       621, /* GL_LIGHT0 */
-       622, /* GL_LIGHT1 */
-       623, /* GL_LIGHT2 */
-       624, /* GL_LIGHT3 */
-       625, /* GL_LIGHT4 */
-       626, /* GL_LIGHT5 */
-       627, /* GL_LIGHT6 */
-       628, /* GL_LIGHT7 */
-       550, /* GL_HINT_BIT */
-       246, /* GL_CONSTANT_COLOR */
-       990, /* GL_ONE_MINUS_CONSTANT_COLOR */
-       241, /* GL_CONSTANT_ALPHA */
-       988, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-        75, /* GL_BLEND_COLOR */
-       510, /* GL_FUNC_ADD */
-       879, /* GL_MIN */
-       791, /* GL_MAX */
-        80, /* GL_BLEND_EQUATION */
-       514, /* GL_FUNC_SUBTRACT */
-       512, /* GL_FUNC_REVERSE_SUBTRACT */
-       249, /* GL_CONVOLUTION_1D */
-       250, /* GL_CONVOLUTION_2D */
-      1330, /* GL_SEPARABLE_2D */
-       253, /* GL_CONVOLUTION_BORDER_MODE */
-       257, /* GL_CONVOLUTION_FILTER_SCALE */
-       255, /* GL_CONVOLUTION_FILTER_BIAS */
-      1229, /* GL_REDUCE */
-       259, /* GL_CONVOLUTION_FORMAT */
-       263, /* GL_CONVOLUTION_WIDTH */
-       261, /* GL_CONVOLUTION_HEIGHT */
-       806, /* GL_MAX_CONVOLUTION_WIDTH */
-       804, /* GL_MAX_CONVOLUTION_HEIGHT */
-      1144, /* GL_POST_CONVOLUTION_RED_SCALE */
-      1140, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-      1135, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-      1131, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-      1142, /* GL_POST_CONVOLUTION_RED_BIAS */
-      1138, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-      1133, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-      1129, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-       551, /* GL_HISTOGRAM */
-      1191, /* GL_PROXY_HISTOGRAM */
-       567, /* GL_HISTOGRAM_WIDTH */
-       557, /* GL_HISTOGRAM_FORMAT */
-       563, /* GL_HISTOGRAM_RED_SIZE */
-       559, /* GL_HISTOGRAM_GREEN_SIZE */
-       554, /* GL_HISTOGRAM_BLUE_SIZE */
-       552, /* GL_HISTOGRAM_ALPHA_SIZE */
-       561, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-       565, /* GL_HISTOGRAM_SINK */
-       880, /* GL_MINMAX */
-       882, /* GL_MINMAX_FORMAT */
-       884, /* GL_MINMAX_SINK */
-      1442, /* GL_TABLE_TOO_LARGE_EXT */
-      1654, /* GL_UNSIGNED_BYTE_3_3_2 */
-      1663, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-      1665, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-      1659, /* GL_UNSIGNED_INT_8_8_8_8 */
-      1656, /* GL_UNSIGNED_INT_10_10_10_2 */
-      1102, /* GL_POLYGON_OFFSET_FILL */
-      1101, /* GL_POLYGON_OFFSET_FACTOR */
-      1100, /* GL_POLYGON_OFFSET_BIAS */
-      1249, /* GL_RESCALE_NORMAL */
+      1328, /* GL_RGB */
+      1347, /* GL_RGBA */
+       715, /* GL_LUMINANCE */
+       736, /* GL_LUMINANCE_ALPHA */
+        73, /* GL_BITMAP */
+      1129, /* GL_POINT */
+       685, /* GL_LINE */
+       482, /* GL_FILL */
+      1302, /* GL_RENDER */
+       478, /* GL_FEEDBACK */
+      1405, /* GL_SELECT */
+       484, /* GL_FLAT */
+      1430, /* GL_SMOOTH */
+       665, /* GL_KEEP */
+      1322, /* GL_REPLACE */
+       619, /* GL_INCR */
+       342, /* GL_DECR */
+      1784, /* GL_VENDOR */
+      1319, /* GL_RENDERER */
+      1785, /* GL_VERSION */
+       471, /* GL_EXTENSIONS */
+      1370, /* GL_S */
+      1532, /* GL_T */
+      1282, /* GL_R */
+      1270, /* GL_Q */
+       988, /* GL_MODULATE */
+       341, /* GL_DECAL */
+      1678, /* GL_TEXTURE_ENV_MODE */
+      1677, /* GL_TEXTURE_ENV_COLOR */
+      1676, /* GL_TEXTURE_ENV */
+       472, /* GL_EYE_LINEAR */
+      1035, /* GL_OBJECT_LINEAR */
+      1456, /* GL_SPHERE_MAP */
+      1680, /* GL_TEXTURE_GEN_MODE */
+      1037, /* GL_OBJECT_PLANE */
+       473, /* GL_EYE_PLANE */
+      1003, /* GL_NEAREST */
+       686, /* GL_LINEAR */
+      1007, /* GL_NEAREST_MIPMAP_NEAREST */
+       691, /* GL_LINEAR_MIPMAP_NEAREST */
+      1006, /* GL_NEAREST_MIPMAP_LINEAR */
+       690, /* GL_LINEAR_MIPMAP_LINEAR */
+      1701, /* GL_TEXTURE_MAG_FILTER */
+      1709, /* GL_TEXTURE_MIN_FILTER */
+      1726, /* GL_TEXTURE_WRAP_S */
+      1727, /* GL_TEXTURE_WRAP_T */
+       126, /* GL_CLAMP */
+      1321, /* GL_REPEAT */
+      1167, /* GL_POLYGON_OFFSET_UNITS */
+      1166, /* GL_POLYGON_OFFSET_POINT */
+      1165, /* GL_POLYGON_OFFSET_LINE */
+      1283, /* GL_R3_G3_B2 */
+      1781, /* GL_V2F */
+      1782, /* GL_V3F */
+       123, /* GL_C4UB_V2F */
+       124, /* GL_C4UB_V3F */
+       121, /* GL_C3F_V3F */
+      1000, /* GL_N3F_V3F */
+       122, /* GL_C4F_N3F_V3F */
+      1537, /* GL_T2F_V3F */
+      1539, /* GL_T4F_V4F */
+      1535, /* GL_T2F_C4UB_V3F */
+      1533, /* GL_T2F_C3F_V3F */
+      1536, /* GL_T2F_N3F_V3F */
+      1534, /* GL_T2F_C4F_N3F_V3F */
+      1538, /* GL_T4F_C4F_N3F_V4F */
+       139, /* GL_CLIP_PLANE0 */
+       140, /* GL_CLIP_PLANE1 */
+       141, /* GL_CLIP_PLANE2 */
+       142, /* GL_CLIP_PLANE3 */
+       143, /* GL_CLIP_PLANE4 */
+       144, /* GL_CLIP_PLANE5 */
+       670, /* GL_LIGHT0 */
+       671, /* GL_LIGHT1 */
+       672, /* GL_LIGHT2 */
+       673, /* GL_LIGHT3 */
+       674, /* GL_LIGHT4 */
+       675, /* GL_LIGHT5 */
+       676, /* GL_LIGHT6 */
+       677, /* GL_LIGHT7 */
+       596, /* GL_HINT_BIT */
+       277, /* GL_CONSTANT_COLOR */
+      1048, /* GL_ONE_MINUS_CONSTANT_COLOR */
+       272, /* GL_CONSTANT_ALPHA */
+      1046, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+        76, /* GL_BLEND_COLOR */
+       580, /* GL_FUNC_ADD */
+       936, /* GL_MIN */
+       846, /* GL_MAX */
+        81, /* GL_BLEND_EQUATION */
+       584, /* GL_FUNC_SUBTRACT */
+       582, /* GL_FUNC_REVERSE_SUBTRACT */
+       280, /* GL_CONVOLUTION_1D */
+       281, /* GL_CONVOLUTION_2D */
+      1408, /* GL_SEPARABLE_2D */
+       284, /* GL_CONVOLUTION_BORDER_MODE */
+       288, /* GL_CONVOLUTION_FILTER_SCALE */
+       286, /* GL_CONVOLUTION_FILTER_BIAS */
+      1294, /* GL_REDUCE */
+       290, /* GL_CONVOLUTION_FORMAT */
+       294, /* GL_CONVOLUTION_WIDTH */
+       292, /* GL_CONVOLUTION_HEIGHT */
+       861, /* GL_MAX_CONVOLUTION_WIDTH */
+       859, /* GL_MAX_CONVOLUTION_HEIGHT */
+      1206, /* GL_POST_CONVOLUTION_RED_SCALE */
+      1202, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+      1197, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+      1193, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+      1204, /* GL_POST_CONVOLUTION_RED_BIAS */
+      1200, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+      1195, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+      1191, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+       597, /* GL_HISTOGRAM */
+      1254, /* GL_PROXY_HISTOGRAM */
+       613, /* GL_HISTOGRAM_WIDTH */
+       603, /* GL_HISTOGRAM_FORMAT */
+       609, /* GL_HISTOGRAM_RED_SIZE */
+       605, /* GL_HISTOGRAM_GREEN_SIZE */
+       600, /* GL_HISTOGRAM_BLUE_SIZE */
+       598, /* GL_HISTOGRAM_ALPHA_SIZE */
+       607, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+       611, /* GL_HISTOGRAM_SINK */
+       937, /* GL_MINMAX */
+       939, /* GL_MINMAX_FORMAT */
+       941, /* GL_MINMAX_SINK */
+      1540, /* GL_TABLE_TOO_LARGE_EXT */
+      1760, /* GL_UNSIGNED_BYTE_3_3_2 */
+      1771, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+      1773, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+      1766, /* GL_UNSIGNED_INT_8_8_8_8 */
+      1762, /* GL_UNSIGNED_INT_10_10_10_2 */
+      1164, /* GL_POLYGON_OFFSET_FILL */
+      1163, /* GL_POLYGON_OFFSET_FACTOR */
+      1162, /* GL_POLYGON_OFFSET_BIAS */
+      1325, /* GL_RESCALE_NORMAL */
         36, /* GL_ALPHA4 */
         38, /* GL_ALPHA8 */
         32, /* GL_ALPHA12 */
         34, /* GL_ALPHA16 */
-       677, /* GL_LUMINANCE4 */
-       683, /* GL_LUMINANCE8 */
-       667, /* GL_LUMINANCE12 */
-       673, /* GL_LUMINANCE16 */
-       678, /* GL_LUMINANCE4_ALPHA4 */
-       681, /* GL_LUMINANCE6_ALPHA2 */
-       684, /* GL_LUMINANCE8_ALPHA8 */
-       670, /* GL_LUMINANCE12_ALPHA4 */
-       668, /* GL_LUMINANCE12_ALPHA12 */
-       674, /* GL_LUMINANCE16_ALPHA16 */
-       591, /* GL_INTENSITY */
-       596, /* GL_INTENSITY4 */
-       598, /* GL_INTENSITY8 */
-       592, /* GL_INTENSITY12 */
-       594, /* GL_INTENSITY16 */
-      1261, /* GL_RGB2_EXT */
-      1262, /* GL_RGB4 */
-      1265, /* GL_RGB5 */
-      1269, /* GL_RGB8 */
-      1253, /* GL_RGB10 */
-      1257, /* GL_RGB12 */
-      1259, /* GL_RGB16 */
-      1276, /* GL_RGBA2 */
-      1278, /* GL_RGBA4 */
-      1266, /* GL_RGB5_A1 */
-      1282, /* GL_RGBA8 */
-      1254, /* GL_RGB10_A2 */
-      1272, /* GL_RGBA12 */
-      1274, /* GL_RGBA16 */
-      1615, /* GL_TEXTURE_RED_SIZE */
-      1587, /* GL_TEXTURE_GREEN_SIZE */
-      1526, /* GL_TEXTURE_BLUE_SIZE */
-      1513, /* GL_TEXTURE_ALPHA_SIZE */
-      1600, /* GL_TEXTURE_LUMINANCE_SIZE */
-      1591, /* GL_TEXTURE_INTENSITY_SIZE */
-      1247, /* GL_REPLACE_EXT */
-      1195, /* GL_PROXY_TEXTURE_1D */
-      1198, /* GL_PROXY_TEXTURE_2D */
-      1619, /* GL_TEXTURE_TOO_LARGE_EXT */
-      1612, /* GL_TEXTURE_PRIORITY */
-      1617, /* GL_TEXTURE_RESIDENT */
-      1516, /* GL_TEXTURE_BINDING_1D */
-      1518, /* GL_TEXTURE_BINDING_2D */
-      1520, /* GL_TEXTURE_BINDING_3D */
-      1026, /* GL_PACK_SKIP_IMAGES */
-      1022, /* GL_PACK_IMAGE_HEIGHT */
-      1648, /* GL_UNPACK_SKIP_IMAGES */
-      1645, /* GL_UNPACK_IMAGE_HEIGHT */
-      1512, /* GL_TEXTURE_3D */
-      1201, /* GL_PROXY_TEXTURE_3D */
-      1574, /* GL_TEXTURE_DEPTH */
-      1622, /* GL_TEXTURE_WRAP_R */
-       792, /* GL_MAX_3D_TEXTURE_SIZE */
-      1678, /* GL_VERTEX_ARRAY */
-       957, /* GL_NORMAL_ARRAY */
-       138, /* GL_COLOR_ARRAY */
-       576, /* GL_INDEX_ARRAY */
-      1553, /* GL_TEXTURE_COORD_ARRAY */
-       414, /* GL_EDGE_FLAG_ARRAY */
-      1683, /* GL_VERTEX_ARRAY_SIZE */
-      1685, /* GL_VERTEX_ARRAY_TYPE */
-      1684, /* GL_VERTEX_ARRAY_STRIDE */
-       962, /* GL_NORMAL_ARRAY_TYPE */
-       961, /* GL_NORMAL_ARRAY_STRIDE */
-       142, /* GL_COLOR_ARRAY_SIZE */
-       144, /* GL_COLOR_ARRAY_TYPE */
-       143, /* GL_COLOR_ARRAY_STRIDE */
-       581, /* GL_INDEX_ARRAY_TYPE */
-       580, /* GL_INDEX_ARRAY_STRIDE */
-      1557, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-      1559, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-      1558, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-       418, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-      1682, /* GL_VERTEX_ARRAY_POINTER */
-       960, /* GL_NORMAL_ARRAY_POINTER */
-       141, /* GL_COLOR_ARRAY_POINTER */
-       579, /* GL_INDEX_ARRAY_POINTER */
-      1556, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-       417, /* GL_EDGE_FLAG_ARRAY_POINTER */
-       936, /* GL_MULTISAMPLE */
-      1304, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-      1306, /* GL_SAMPLE_ALPHA_TO_ONE */
-      1311, /* GL_SAMPLE_COVERAGE */
-      1308, /* GL_SAMPLE_BUFFERS */
-      1299, /* GL_SAMPLES */
-      1315, /* GL_SAMPLE_COVERAGE_VALUE */
-      1313, /* GL_SAMPLE_COVERAGE_INVERT */
-       169, /* GL_COLOR_MATRIX */
-       171, /* GL_COLOR_MATRIX_STACK_DEPTH */
-       800, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-      1127, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-      1123, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-      1118, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-      1114, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-      1125, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-      1121, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-      1116, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-      1112, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-      1536, /* GL_TEXTURE_COLOR_TABLE_SGI */
-      1202, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-      1538, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-        79, /* GL_BLEND_DST_RGB */
-        87, /* GL_BLEND_SRC_RGB */
-        78, /* GL_BLEND_DST_ALPHA */
-        86, /* GL_BLEND_SRC_ALPHA */
-       175, /* GL_COLOR_TABLE */
-      1137, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-      1120, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-      1190, /* GL_PROXY_COLOR_TABLE */
-      1194, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-      1193, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-       199, /* GL_COLOR_TABLE_SCALE */
-       179, /* GL_COLOR_TABLE_BIAS */
-       184, /* GL_COLOR_TABLE_FORMAT */
-       201, /* GL_COLOR_TABLE_WIDTH */
-       196, /* GL_COLOR_TABLE_RED_SIZE */
-       187, /* GL_COLOR_TABLE_GREEN_SIZE */
-       181, /* GL_COLOR_TABLE_BLUE_SIZE */
-       176, /* GL_COLOR_TABLE_ALPHA_SIZE */
-       193, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-       190, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-        70, /* GL_BGR */
-        71, /* GL_BGRA */
-       814, /* GL_MAX_ELEMENTS_VERTICES */
-       813, /* GL_MAX_ELEMENTS_INDICES */
-      1590, /* GL_TEXTURE_INDEX_SIZE_EXT */
-       135, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-      1084, /* GL_POINT_SIZE_MIN */
-      1080, /* GL_POINT_SIZE_MAX */
-      1074, /* GL_POINT_FADE_THRESHOLD_SIZE */
-      1070, /* GL_POINT_DISTANCE_ATTENUATION */
-       117, /* GL_CLAMP_TO_BORDER */
-       120, /* GL_CLAMP_TO_EDGE */
-      1611, /* GL_TEXTURE_MIN_LOD */
-      1609, /* GL_TEXTURE_MAX_LOD */
-      1515, /* GL_TEXTURE_BASE_LEVEL */
-      1608, /* GL_TEXTURE_MAX_LEVEL */
-       570, /* GL_IGNORE_BORDER_HP */
-       245, /* GL_CONSTANT_BORDER_HP */
-      1248, /* GL_REPLICATE_BORDER_HP */
-       251, /* GL_CONVOLUTION_BORDER_COLOR */
-       985, /* GL_OCCLUSION_TEST_HP */
-       986, /* GL_OCCLUSION_TEST_RESULT_HP */
-       639, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-      1530, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-      1532, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-      1534, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-      1535, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1533, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-      1531, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-       796, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-       797, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1147, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-      1149, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-      1146, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-      1148, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-      1598, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-      1599, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-      1597, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-       516, /* GL_GENERATE_MIPMAP */
-       517, /* GL_GENERATE_MIPMAP_HINT */
-       479, /* GL_FOG_OFFSET_SGIX */
-       480, /* GL_FOG_OFFSET_VALUE_SGIX */
-      1544, /* GL_TEXTURE_COMPARE_SGIX */
-      1543, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-      1594, /* GL_TEXTURE_LEQUAL_R_SGIX */
-      1586, /* GL_TEXTURE_GEQUAL_R_SGIX */
-       322, /* GL_DEPTH_COMPONENT16 */
-       325, /* GL_DEPTH_COMPONENT24 */
-       328, /* GL_DEPTH_COMPONENT32 */
-       273, /* GL_CULL_VERTEX_EXT */
-       275, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-       274, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-      1739, /* GL_WRAP_BORDER_SUN */
-      1537, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-       632, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-      1343, /* GL_SINGLE_COLOR */
-      1331, /* GL_SEPARATE_SPECULAR_COLOR */
-      1340, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-      1653, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-      1666, /* GL_UNSIGNED_SHORT_5_6_5 */
-      1667, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-      1664, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-      1662, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-      1660, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-      1658, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-      1606, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-      1607, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-      1605, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-       887, /* GL_MIRRORED_REPEAT */
-      1287, /* GL_RGB_S3TC */
-      1264, /* GL_RGB4_S3TC */
-      1286, /* GL_RGBA_S3TC */
-      1281, /* GL_RGBA4_S3TC */
-      1284, /* GL_RGBA_DXT5_S3TC */
-      1279, /* GL_RGBA4_DXT5_S3TC */
-       238, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-       233, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-       234, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-       235, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-       948, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-       947, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-       640, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-       466, /* GL_FOG_COORDINATE_SOURCE */
-       458, /* GL_FOG_COORD */
-       482, /* GL_FRAGMENT_DEPTH */
-       279, /* GL_CURRENT_FOG_COORD */
-       465, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-       464, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-       463, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-       460, /* GL_FOG_COORDINATE_ARRAY */
-       173, /* GL_COLOR_SUM */
-       298, /* GL_CURRENT_SECONDARY_COLOR */
-      1324, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-      1326, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-      1325, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-      1323, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-      1320, /* GL_SECONDARY_COLOR_ARRAY */
-       526, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
+       726, /* GL_LUMINANCE4 */
+       732, /* GL_LUMINANCE8 */
+       716, /* GL_LUMINANCE12 */
+       722, /* GL_LUMINANCE16 */
+       727, /* GL_LUMINANCE4_ALPHA4 */
+       730, /* GL_LUMINANCE6_ALPHA2 */
+       733, /* GL_LUMINANCE8_ALPHA8 */
+       719, /* GL_LUMINANCE12_ALPHA4 */
+       717, /* GL_LUMINANCE12_ALPHA12 */
+       723, /* GL_LUMINANCE16_ALPHA16 */
+       638, /* GL_INTENSITY */
+       643, /* GL_INTENSITY4 */
+       645, /* GL_INTENSITY8 */
+       639, /* GL_INTENSITY12 */
+       641, /* GL_INTENSITY16 */
+      1337, /* GL_RGB2_EXT */
+      1338, /* GL_RGB4 */
+      1341, /* GL_RGB5 */
+      1345, /* GL_RGB8 */
+      1329, /* GL_RGB10 */
+      1333, /* GL_RGB12 */
+      1335, /* GL_RGB16 */
+      1352, /* GL_RGBA2 */
+      1354, /* GL_RGBA4 */
+      1342, /* GL_RGB5_A1 */
+      1358, /* GL_RGBA8 */
+      1330, /* GL_RGB10_A2 */
+      1348, /* GL_RGBA12 */
+      1350, /* GL_RGBA16 */
+      1716, /* GL_TEXTURE_RED_SIZE */
+      1686, /* GL_TEXTURE_GREEN_SIZE */
+      1624, /* GL_TEXTURE_BLUE_SIZE */
+      1611, /* GL_TEXTURE_ALPHA_SIZE */
+      1699, /* GL_TEXTURE_LUMINANCE_SIZE */
+      1690, /* GL_TEXTURE_INTENSITY_SIZE */
+      1323, /* GL_REPLACE_EXT */
+      1258, /* GL_PROXY_TEXTURE_1D */
+      1261, /* GL_PROXY_TEXTURE_2D */
+      1722, /* GL_TEXTURE_TOO_LARGE_EXT */
+      1711, /* GL_TEXTURE_PRIORITY */
+      1718, /* GL_TEXTURE_RESIDENT */
+      1614, /* GL_TEXTURE_BINDING_1D */
+      1616, /* GL_TEXTURE_BINDING_2D */
+      1618, /* GL_TEXTURE_BINDING_3D */
+      1084, /* GL_PACK_SKIP_IMAGES */
+      1080, /* GL_PACK_IMAGE_HEIGHT */
+      1753, /* GL_UNPACK_SKIP_IMAGES */
+      1750, /* GL_UNPACK_IMAGE_HEIGHT */
+      1610, /* GL_TEXTURE_3D */
+      1264, /* GL_PROXY_TEXTURE_3D */
+      1673, /* GL_TEXTURE_DEPTH */
+      1725, /* GL_TEXTURE_WRAP_R */
+       847, /* GL_MAX_3D_TEXTURE_SIZE */
+      1786, /* GL_VERTEX_ARRAY */
+      1014, /* GL_NORMAL_ARRAY */
+       148, /* GL_COLOR_ARRAY */
+       623, /* GL_INDEX_ARRAY */
+      1651, /* GL_TEXTURE_COORD_ARRAY */
+       456, /* GL_EDGE_FLAG_ARRAY */
+      1792, /* GL_VERTEX_ARRAY_SIZE */
+      1794, /* GL_VERTEX_ARRAY_TYPE */
+      1793, /* GL_VERTEX_ARRAY_STRIDE */
+      1019, /* GL_NORMAL_ARRAY_TYPE */
+      1018, /* GL_NORMAL_ARRAY_STRIDE */
+       152, /* GL_COLOR_ARRAY_SIZE */
+       154, /* GL_COLOR_ARRAY_TYPE */
+       153, /* GL_COLOR_ARRAY_STRIDE */
+       628, /* GL_INDEX_ARRAY_TYPE */
+       627, /* GL_INDEX_ARRAY_STRIDE */
+      1655, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+      1657, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+      1656, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+       460, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+      1791, /* GL_VERTEX_ARRAY_POINTER */
+      1017, /* GL_NORMAL_ARRAY_POINTER */
+       151, /* GL_COLOR_ARRAY_POINTER */
+       626, /* GL_INDEX_ARRAY_POINTER */
+      1654, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+       459, /* GL_EDGE_FLAG_ARRAY_POINTER */
+       993, /* GL_MULTISAMPLE */
+      1382, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+      1384, /* GL_SAMPLE_ALPHA_TO_ONE */
+      1389, /* GL_SAMPLE_COVERAGE */
+      1386, /* GL_SAMPLE_BUFFERS */
+      1377, /* GL_SAMPLES */
+      1393, /* GL_SAMPLE_COVERAGE_VALUE */
+      1391, /* GL_SAMPLE_COVERAGE_INVERT */
+       195, /* GL_COLOR_MATRIX */
+       197, /* GL_COLOR_MATRIX_STACK_DEPTH */
+       855, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+      1189, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+      1185, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+      1180, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+      1176, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+      1187, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+      1183, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+      1178, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+      1174, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+      1634, /* GL_TEXTURE_COLOR_TABLE_SGI */
+      1265, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+      1636, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+        80, /* GL_BLEND_DST_RGB */
+        89, /* GL_BLEND_SRC_RGB */
+        79, /* GL_BLEND_DST_ALPHA */
+        88, /* GL_BLEND_SRC_ALPHA */
+       201, /* GL_COLOR_TABLE */
+      1199, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+      1182, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+      1253, /* GL_PROXY_COLOR_TABLE */
+      1257, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+      1256, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+       225, /* GL_COLOR_TABLE_SCALE */
+       205, /* GL_COLOR_TABLE_BIAS */
+       210, /* GL_COLOR_TABLE_FORMAT */
+       227, /* GL_COLOR_TABLE_WIDTH */
+       222, /* GL_COLOR_TABLE_RED_SIZE */
+       213, /* GL_COLOR_TABLE_GREEN_SIZE */
+       207, /* GL_COLOR_TABLE_BLUE_SIZE */
+       202, /* GL_COLOR_TABLE_ALPHA_SIZE */
+       219, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
+       216, /* GL_COLOR_TABLE_INTENSITY_SIZE */
+        71, /* GL_BGR */
+        72, /* GL_BGRA */
+       869, /* GL_MAX_ELEMENTS_VERTICES */
+       868, /* GL_MAX_ELEMENTS_INDICES */
+      1689, /* GL_TEXTURE_INDEX_SIZE_EXT */
+       145, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
+      1146, /* GL_POINT_SIZE_MIN */
+      1142, /* GL_POINT_SIZE_MAX */
+      1136, /* GL_POINT_FADE_THRESHOLD_SIZE */
+      1132, /* GL_POINT_DISTANCE_ATTENUATION */
+       127, /* GL_CLAMP_TO_BORDER */
+       130, /* GL_CLAMP_TO_EDGE */
+      1710, /* GL_TEXTURE_MIN_LOD */
+      1708, /* GL_TEXTURE_MAX_LOD */
+      1613, /* GL_TEXTURE_BASE_LEVEL */
+      1707, /* GL_TEXTURE_MAX_LEVEL */
+       616, /* GL_IGNORE_BORDER_HP */
+       276, /* GL_CONSTANT_BORDER_HP */
+      1324, /* GL_REPLICATE_BORDER_HP */
+       282, /* GL_CONVOLUTION_BORDER_COLOR */
+      1043, /* GL_OCCLUSION_TEST_HP */
+      1044, /* GL_OCCLUSION_TEST_RESULT_HP */
+       688, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+      1628, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+      1630, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+      1632, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+      1633, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1631, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+      1629, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+       851, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+       852, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1209, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+      1211, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+      1208, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+      1210, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+      1697, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+      1698, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+      1696, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+       586, /* GL_GENERATE_MIPMAP */
+       587, /* GL_GENERATE_MIPMAP_HINT */
+       528, /* GL_FOG_OFFSET_SGIX */
+       529, /* GL_FOG_OFFSET_VALUE_SGIX */
+      1642, /* GL_TEXTURE_COMPARE_SGIX */
+      1641, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+      1693, /* GL_TEXTURE_LEQUAL_R_SGIX */
+      1685, /* GL_TEXTURE_GEQUAL_R_SGIX */
+       359, /* GL_DEPTH_COMPONENT16 */
+       362, /* GL_DEPTH_COMPONENT24 */
+       365, /* GL_DEPTH_COMPONENT32 */
+       306, /* GL_CULL_VERTEX_EXT */
+       308, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
+       307, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
+      1849, /* GL_WRAP_BORDER_SUN */
+      1635, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+       681, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+      1423, /* GL_SINGLE_COLOR */
+      1409, /* GL_SEPARATE_SPECULAR_COLOR */
+      1418, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+       539, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+       540, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+       547, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+       542, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+       538, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+       537, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+       541, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+       548, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+       559, /* GL_FRAMEBUFFER_DEFAULT */
+       572, /* GL_FRAMEBUFFER_UNDEFINED */
+       372, /* GL_DEPTH_STENCIL_ATTACHMENT */
+       622, /* GL_INDEX */
+      1759, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+      1774, /* GL_UNSIGNED_SHORT_5_6_5 */
+      1775, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+      1772, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+      1770, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+      1767, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+      1765, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+      1705, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+      1706, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+      1704, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+       944, /* GL_MIRRORED_REPEAT */
+      1365, /* GL_RGB_S3TC */
+      1340, /* GL_RGB4_S3TC */
+      1363, /* GL_RGBA_S3TC */
+      1357, /* GL_RGBA4_S3TC */
+      1361, /* GL_RGBA_DXT5_S3TC */
+      1355, /* GL_RGBA4_DXT5_S3TC */
+       264, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
+       259, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
+       260, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
+       261, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
+      1005, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+      1004, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+       689, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+       515, /* GL_FOG_COORDINATE_SOURCE */
+       507, /* GL_FOG_COORD */
+       531, /* GL_FRAGMENT_DEPTH */
+       312, /* GL_CURRENT_FOG_COORD */
+       514, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+       513, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+       512, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+       509, /* GL_FOG_COORDINATE_ARRAY */
+       199, /* GL_COLOR_SUM */
+       332, /* GL_CURRENT_SECONDARY_COLOR */
+      1402, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+      1404, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+      1403, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+      1401, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+      1398, /* GL_SECONDARY_COLOR_ARRAY */
+       330, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
         28, /* GL_ALIASED_POINT_SIZE_RANGE */
         27, /* GL_ALIASED_LINE_WIDTH_RANGE */
-      1444, /* GL_TEXTURE0 */
-      1446, /* GL_TEXTURE1 */
-      1468, /* GL_TEXTURE2 */
-      1490, /* GL_TEXTURE3 */
-      1496, /* GL_TEXTURE4 */
-      1498, /* GL_TEXTURE5 */
-      1500, /* GL_TEXTURE6 */
-      1502, /* GL_TEXTURE7 */
-      1504, /* GL_TEXTURE8 */
-      1506, /* GL_TEXTURE9 */
-      1447, /* GL_TEXTURE10 */
-      1449, /* GL_TEXTURE11 */
-      1451, /* GL_TEXTURE12 */
-      1453, /* GL_TEXTURE13 */
-      1455, /* GL_TEXTURE14 */
-      1457, /* GL_TEXTURE15 */
-      1459, /* GL_TEXTURE16 */
-      1461, /* GL_TEXTURE17 */
-      1463, /* GL_TEXTURE18 */
-      1465, /* GL_TEXTURE19 */
-      1469, /* GL_TEXTURE20 */
-      1471, /* GL_TEXTURE21 */
-      1473, /* GL_TEXTURE22 */
-      1475, /* GL_TEXTURE23 */
-      1477, /* GL_TEXTURE24 */
-      1479, /* GL_TEXTURE25 */
-      1481, /* GL_TEXTURE26 */
-      1483, /* GL_TEXTURE27 */
-      1485, /* GL_TEXTURE28 */
-      1487, /* GL_TEXTURE29 */
-      1491, /* GL_TEXTURE30 */
-      1493, /* GL_TEXTURE31 */
+      1542, /* GL_TEXTURE0 */
+      1544, /* GL_TEXTURE1 */
+      1566, /* GL_TEXTURE2 */
+      1588, /* GL_TEXTURE3 */
+      1594, /* GL_TEXTURE4 */
+      1596, /* GL_TEXTURE5 */
+      1598, /* GL_TEXTURE6 */
+      1600, /* GL_TEXTURE7 */
+      1602, /* GL_TEXTURE8 */
+      1604, /* GL_TEXTURE9 */
+      1545, /* GL_TEXTURE10 */
+      1547, /* GL_TEXTURE11 */
+      1549, /* GL_TEXTURE12 */
+      1551, /* GL_TEXTURE13 */
+      1553, /* GL_TEXTURE14 */
+      1555, /* GL_TEXTURE15 */
+      1557, /* GL_TEXTURE16 */
+      1559, /* GL_TEXTURE17 */
+      1561, /* GL_TEXTURE18 */
+      1563, /* GL_TEXTURE19 */
+      1567, /* GL_TEXTURE20 */
+      1569, /* GL_TEXTURE21 */
+      1571, /* GL_TEXTURE22 */
+      1573, /* GL_TEXTURE23 */
+      1575, /* GL_TEXTURE24 */
+      1577, /* GL_TEXTURE25 */
+      1579, /* GL_TEXTURE26 */
+      1581, /* GL_TEXTURE27 */
+      1583, /* GL_TEXTURE28 */
+      1585, /* GL_TEXTURE29 */
+      1589, /* GL_TEXTURE30 */
+      1591, /* GL_TEXTURE31 */
         18, /* GL_ACTIVE_TEXTURE */
-       123, /* GL_CLIENT_ACTIVE_TEXTURE */
-       865, /* GL_MAX_TEXTURE_UNITS */
-      1632, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-      1635, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-      1637, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-      1629, /* GL_TRANSPOSE_COLOR_MATRIX */
-      1432, /* GL_SUBTRACT */
-       854, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-       221, /* GL_COMPRESSED_ALPHA */
-       225, /* GL_COMPRESSED_LUMINANCE */
-       226, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-       223, /* GL_COMPRESSED_INTENSITY */
-       229, /* GL_COMPRESSED_RGB */
-       230, /* GL_COMPRESSED_RGBA */
-      1551, /* GL_TEXTURE_COMPRESSION_HINT */
-      1613, /* GL_TEXTURE_RECTANGLE_ARB */
-      1523, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-      1205, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-       852, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-       334, /* GL_DEPTH_STENCIL_NV */
-      1657, /* GL_UNSIGNED_INT_24_8_NV */
-       861, /* GL_MAX_TEXTURE_LOD_BIAS */
-      1604, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-       862, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-      1580, /* GL_TEXTURE_FILTER_CONTROL */
-      1595, /* GL_TEXTURE_LOD_BIAS */
-       206, /* GL_COMBINE4 */
-       855, /* GL_MAX_SHININESS_NV */
-       856, /* GL_MAX_SPOT_EXPONENT_NV */
-       574, /* GL_INCR_WRAP */
-       309, /* GL_DECR_WRAP */
-       907, /* GL_MODELVIEW1_ARB */
-       963, /* GL_NORMAL_MAP */
-      1234, /* GL_REFLECTION_MAP */
-      1560, /* GL_TEXTURE_CUBE_MAP */
-      1521, /* GL_TEXTURE_BINDING_CUBE_MAP */
-      1568, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-      1562, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-      1570, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-      1564, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-      1572, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-      1566, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-      1203, /* GL_PROXY_TEXTURE_CUBE_MAP */
-       808, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-       942, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-       474, /* GL_FOG_DISTANCE_MODE_NV */
-       433, /* GL_EYE_RADIAL_NV */
-       432, /* GL_EYE_PLANE_ABSOLUTE_NV */
-       205, /* GL_COMBINE */
-       212, /* GL_COMBINE_RGB */
-       207, /* GL_COMBINE_ALPHA */
-      1288, /* GL_RGB_SCALE */
+       133, /* GL_CLIENT_ACTIVE_TEXTURE */
+       922, /* GL_MAX_TEXTURE_UNITS */
+      1737, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+      1740, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+      1742, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+      1734, /* GL_TRANSPOSE_COLOR_MATRIX */
+      1524, /* GL_SUBTRACT */
+       909, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+       247, /* GL_COMPRESSED_ALPHA */
+       251, /* GL_COMPRESSED_LUMINANCE */
+       252, /* GL_COMPRESSED_LUMINANCE_ALPHA */
+       249, /* GL_COMPRESSED_INTENSITY */
+       255, /* GL_COMPRESSED_RGB */
+       256, /* GL_COMPRESSED_RGBA */
+      1649, /* GL_TEXTURE_COMPRESSION_HINT */
+      1714, /* GL_TEXTURE_RECTANGLE_ARB */
+      1621, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+      1268, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+       907, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+       371, /* GL_DEPTH_STENCIL */
+      1763, /* GL_UNSIGNED_INT_24_8 */
+       918, /* GL_MAX_TEXTURE_LOD_BIAS */
+      1703, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+       919, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+      1679, /* GL_TEXTURE_FILTER_CONTROL */
+      1694, /* GL_TEXTURE_LOD_BIAS */
+       232, /* GL_COMBINE4 */
+       912, /* GL_MAX_SHININESS_NV */
+       913, /* GL_MAX_SPOT_EXPONENT_NV */
+       620, /* GL_INCR_WRAP */
+       343, /* GL_DECR_WRAP */
+       964, /* GL_MODELVIEW1_ARB */
+      1020, /* GL_NORMAL_MAP */
+      1299, /* GL_REFLECTION_MAP */
+      1658, /* GL_TEXTURE_CUBE_MAP */
+      1619, /* GL_TEXTURE_BINDING_CUBE_MAP */
+      1666, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+      1660, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+      1668, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+      1662, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+      1670, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+      1664, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+      1266, /* GL_PROXY_TEXTURE_CUBE_MAP */
+       863, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+       999, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+       523, /* GL_FOG_DISTANCE_MODE_NV */
+       475, /* GL_EYE_RADIAL_NV */
+       474, /* GL_EYE_PLANE_ABSOLUTE_NV */
+       231, /* GL_COMBINE */
+       238, /* GL_COMBINE_RGB */
+       233, /* GL_COMBINE_ALPHA */
+      1366, /* GL_RGB_SCALE */
         24, /* GL_ADD_SIGNED */
-       601, /* GL_INTERPOLATE */
-       240, /* GL_CONSTANT */
-      1153, /* GL_PRIMARY_COLOR */
-      1150, /* GL_PREVIOUS */
-      1354, /* GL_SOURCE0_RGB */
-      1360, /* GL_SOURCE1_RGB */
-      1366, /* GL_SOURCE2_RGB */
-      1370, /* GL_SOURCE3_RGB_NV */
-      1351, /* GL_SOURCE0_ALPHA */
-      1357, /* GL_SOURCE1_ALPHA */
-      1363, /* GL_SOURCE2_ALPHA */
-      1369, /* GL_SOURCE3_ALPHA_NV */
-       999, /* GL_OPERAND0_RGB */
-      1005, /* GL_OPERAND1_RGB */
-      1011, /* GL_OPERAND2_RGB */
-      1015, /* GL_OPERAND3_RGB_NV */
-       996, /* GL_OPERAND0_ALPHA */
-      1002, /* GL_OPERAND1_ALPHA */
-      1008, /* GL_OPERAND2_ALPHA */
-      1014, /* GL_OPERAND3_ALPHA_NV */
-      1679, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-      1743, /* GL_YCBCR_422_APPLE */
-      1668, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-      1670, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-      1345, /* GL_SLICE_ACCUM_SUN */
-      1210, /* GL_QUAD_MESH_SUN */
-      1641, /* GL_TRIANGLE_MESH_SUN */
-      1717, /* GL_VERTEX_PROGRAM_ARB */
-      1728, /* GL_VERTEX_STATE_PROGRAM_NV */
-      1704, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-      1710, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-      1712, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-      1714, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-       300, /* GL_CURRENT_VERTEX_ATTRIB */
-      1166, /* GL_PROGRAM_LENGTH_ARB */
-      1180, /* GL_PROGRAM_STRING_ARB */
-       929, /* GL_MODELVIEW_PROJECTION_NV */
-       569, /* GL_IDENTITY_NV */
-       614, /* GL_INVERSE_NV */
-      1634, /* GL_TRANSPOSE_NV */
-       615, /* GL_INVERSE_TRANSPOSE_NV */
-       838, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-       837, /* GL_MAX_PROGRAM_MATRICES_ARB */
-       745, /* GL_MATRIX0_NV */
-       757, /* GL_MATRIX1_NV */
-       769, /* GL_MATRIX2_NV */
-       773, /* GL_MATRIX3_NV */
-       775, /* GL_MATRIX4_NV */
-       777, /* GL_MATRIX5_NV */
-       779, /* GL_MATRIX6_NV */
-       781, /* GL_MATRIX7_NV */
-       285, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-       282, /* GL_CURRENT_MATRIX_ARB */
-      1720, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-      1723, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-      1178, /* GL_PROGRAM_PARAMETER_NV */
-      1708, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-      1182, /* GL_PROGRAM_TARGET_NV */
-      1179, /* GL_PROGRAM_RESIDENT_NV */
-      1626, /* GL_TRACK_MATRIX_NV */
-      1627, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-      1718, /* GL_VERTEX_PROGRAM_BINDING_NV */
-      1160, /* GL_PROGRAM_ERROR_POSITION_ARB */
-       319, /* GL_DEPTH_CLAMP_NV */
-      1686, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-      1693, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-      1694, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-      1695, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-      1696, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-      1697, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-      1698, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-      1699, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-      1700, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-      1701, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-      1687, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-      1688, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-      1689, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-      1690, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-      1691, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-      1692, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-       699, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-       706, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-       707, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-       708, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-       709, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-       710, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-       711, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-       712, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-       713, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-       714, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-       700, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-       701, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-       702, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-       703, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-       704, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-       705, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-       726, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-       733, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-       734, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-       735, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-       736, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-       737, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-       738, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-      1159, /* GL_PROGRAM_BINDING_ARB */
-       740, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-       741, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-       727, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-       728, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-       729, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-       730, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-       731, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-       732, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-      1549, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-      1546, /* GL_TEXTURE_COMPRESSED */
-       968, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-       239, /* GL_COMPRESSED_TEXTURE_FORMATS */
-       877, /* GL_MAX_VERTEX_UNITS_ARB */
+       648, /* GL_INTERPOLATE */
+       271, /* GL_CONSTANT */
+      1215, /* GL_PRIMARY_COLOR */
+      1212, /* GL_PREVIOUS */
+      1438, /* GL_SOURCE0_RGB */
+      1444, /* GL_SOURCE1_RGB */
+      1450, /* GL_SOURCE2_RGB */
+      1454, /* GL_SOURCE3_RGB_NV */
+      1435, /* GL_SOURCE0_ALPHA */
+      1441, /* GL_SOURCE1_ALPHA */
+      1447, /* GL_SOURCE2_ALPHA */
+      1453, /* GL_SOURCE3_ALPHA_NV */
+      1057, /* GL_OPERAND0_RGB */
+      1063, /* GL_OPERAND1_RGB */
+      1069, /* GL_OPERAND2_RGB */
+      1073, /* GL_OPERAND3_RGB_NV */
+      1054, /* GL_OPERAND0_ALPHA */
+      1060, /* GL_OPERAND1_ALPHA */
+      1066, /* GL_OPERAND2_ALPHA */
+      1072, /* GL_OPERAND3_ALPHA_NV */
+      1787, /* GL_VERTEX_ARRAY_BINDING */
+      1712, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+      1713, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+      1853, /* GL_YCBCR_422_APPLE */
+      1776, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+      1778, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+      1721, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+      1515, /* GL_STORAGE_PRIVATE_APPLE */
+      1514, /* GL_STORAGE_CACHED_APPLE */
+      1516, /* GL_STORAGE_SHARED_APPLE */
+      1425, /* GL_SLICE_ACCUM_SUN */
+      1274, /* GL_QUAD_MESH_SUN */
+      1746, /* GL_TRIANGLE_MESH_SUN */
+      1826, /* GL_VERTEX_PROGRAM_ARB */
+      1837, /* GL_VERTEX_STATE_PROGRAM_NV */
+      1813, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+      1819, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+      1821, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+      1823, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+       334, /* GL_CURRENT_VERTEX_ATTRIB */
+      1228, /* GL_PROGRAM_LENGTH_ARB */
+      1242, /* GL_PROGRAM_STRING_ARB */
+       986, /* GL_MODELVIEW_PROJECTION_NV */
+       615, /* GL_IDENTITY_NV */
+       662, /* GL_INVERSE_NV */
+      1739, /* GL_TRANSPOSE_NV */
+       663, /* GL_INVERSE_TRANSPOSE_NV */
+       893, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+       892, /* GL_MAX_PROGRAM_MATRICES_ARB */
+       800, /* GL_MATRIX0_NV */
+       812, /* GL_MATRIX1_NV */
+       824, /* GL_MATRIX2_NV */
+       828, /* GL_MATRIX3_NV */
+       830, /* GL_MATRIX4_NV */
+       832, /* GL_MATRIX5_NV */
+       834, /* GL_MATRIX6_NV */
+       836, /* GL_MATRIX7_NV */
+       318, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
+       315, /* GL_CURRENT_MATRIX_ARB */
+      1829, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+      1832, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+      1240, /* GL_PROGRAM_PARAMETER_NV */
+      1817, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+      1244, /* GL_PROGRAM_TARGET_NV */
+      1241, /* GL_PROGRAM_RESIDENT_NV */
+      1731, /* GL_TRACK_MATRIX_NV */
+      1732, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+      1827, /* GL_VERTEX_PROGRAM_BINDING_NV */
+      1222, /* GL_PROGRAM_ERROR_POSITION_ARB */
+       355, /* GL_DEPTH_CLAMP */
+      1795, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+      1802, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+      1803, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+      1804, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+      1805, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+      1806, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+      1807, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+      1808, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+      1809, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+      1810, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+      1796, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+      1797, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+      1798, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+      1799, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+      1800, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+      1801, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+       748, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+       755, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+       756, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+       757, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+       758, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+       759, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+       760, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+       761, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+       762, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+       763, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+       749, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+       750, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+       751, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+       752, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+       753, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+       754, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+       775, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+       782, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+       783, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+       784, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+       785, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+       786, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+       787, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+      1221, /* GL_PROGRAM_BINDING_ARB */
+       789, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+       790, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+       776, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+       777, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+       778, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+       779, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+       780, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+       781, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+      1647, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+      1644, /* GL_TEXTURE_COMPRESSED */
+      1025, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+       269, /* GL_COMPRESSED_TEXTURE_FORMATS */
+       934, /* GL_MAX_VERTEX_UNITS_ARB */
         22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-      1738, /* GL_WEIGHT_SUM_UNITY_ARB */
-      1716, /* GL_VERTEX_BLEND_ARB */
-       302, /* GL_CURRENT_WEIGHT_ARB */
-      1737, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-      1736, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-      1735, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-      1734, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-      1731, /* GL_WEIGHT_ARRAY_ARB */
-       345, /* GL_DOT3_RGB */
-       346, /* GL_DOT3_RGBA */
-       237, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-       232, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-       937, /* GL_MULTISAMPLE_3DFX */
-      1309, /* GL_SAMPLE_BUFFERS_3DFX */
-      1300, /* GL_SAMPLES_3DFX */
-       918, /* GL_MODELVIEW2_ARB */
-       921, /* GL_MODELVIEW3_ARB */
-       922, /* GL_MODELVIEW4_ARB */
-       923, /* GL_MODELVIEW5_ARB */
-       924, /* GL_MODELVIEW6_ARB */
-       925, /* GL_MODELVIEW7_ARB */
-       926, /* GL_MODELVIEW8_ARB */
-       927, /* GL_MODELVIEW9_ARB */
-       897, /* GL_MODELVIEW10_ARB */
-       898, /* GL_MODELVIEW11_ARB */
-       899, /* GL_MODELVIEW12_ARB */
-       900, /* GL_MODELVIEW13_ARB */
-       901, /* GL_MODELVIEW14_ARB */
-       902, /* GL_MODELVIEW15_ARB */
-       903, /* GL_MODELVIEW16_ARB */
-       904, /* GL_MODELVIEW17_ARB */
-       905, /* GL_MODELVIEW18_ARB */
-       906, /* GL_MODELVIEW19_ARB */
-       908, /* GL_MODELVIEW20_ARB */
-       909, /* GL_MODELVIEW21_ARB */
-       910, /* GL_MODELVIEW22_ARB */
-       911, /* GL_MODELVIEW23_ARB */
-       912, /* GL_MODELVIEW24_ARB */
-       913, /* GL_MODELVIEW25_ARB */
-       914, /* GL_MODELVIEW26_ARB */
-       915, /* GL_MODELVIEW27_ARB */
-       916, /* GL_MODELVIEW28_ARB */
-       917, /* GL_MODELVIEW29_ARB */
-       919, /* GL_MODELVIEW30_ARB */
-       920, /* GL_MODELVIEW31_ARB */
-       350, /* GL_DOT3_RGB_EXT */
-       348, /* GL_DOT3_RGBA_EXT */
-       891, /* GL_MIRROR_CLAMP_EXT */
-       894, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-       932, /* GL_MODULATE_ADD_ATI */
-       933, /* GL_MODULATE_SIGNED_ADD_ATI */
-       934, /* GL_MODULATE_SUBTRACT_ATI */
-      1744, /* GL_YCBCR_MESA */
-      1023, /* GL_PACK_INVERT_MESA */
-       305, /* GL_DEBUG_OBJECT_MESA */
-       306, /* GL_DEBUG_PRINT_MESA */
-       304, /* GL_DEBUG_ASSERT_MESA */
-       106, /* GL_BUFFER_SIZE */
-       108, /* GL_BUFFER_USAGE */
-      1397, /* GL_STENCIL_BACK_FUNC */
-      1395, /* GL_STENCIL_BACK_FAIL */
-      1399, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-      1401, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-       483, /* GL_FRAGMENT_PROGRAM_ARB */
-      1157, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-      1185, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-      1184, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-      1169, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-      1175, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-      1174, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       827, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-       850, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-       849, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-       840, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-       846, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-       845, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       810, /* GL_MAX_DRAW_BUFFERS */
-       354, /* GL_DRAW_BUFFER0 */
-       357, /* GL_DRAW_BUFFER1 */
-       378, /* GL_DRAW_BUFFER2 */
-       381, /* GL_DRAW_BUFFER3 */
-       384, /* GL_DRAW_BUFFER4 */
-       387, /* GL_DRAW_BUFFER5 */
-       390, /* GL_DRAW_BUFFER6 */
-       393, /* GL_DRAW_BUFFER7 */
-       396, /* GL_DRAW_BUFFER8 */
-       399, /* GL_DRAW_BUFFER9 */
-       358, /* GL_DRAW_BUFFER10 */
-       361, /* GL_DRAW_BUFFER11 */
-       364, /* GL_DRAW_BUFFER12 */
-       367, /* GL_DRAW_BUFFER13 */
-       370, /* GL_DRAW_BUFFER14 */
-       373, /* GL_DRAW_BUFFER15 */
-        81, /* GL_BLEND_EQUATION_ALPHA */
-       790, /* GL_MATRIX_PALETTE_ARB */
-       821, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-       824, /* GL_MAX_PALETTE_MATRICES_ARB */
-       288, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-       784, /* GL_MATRIX_INDEX_ARRAY_ARB */
-       283, /* GL_CURRENT_MATRIX_INDEX_ARB */
-       786, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-       788, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-       787, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-       785, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-      1575, /* GL_TEXTURE_DEPTH_SIZE */
-       338, /* GL_DEPTH_TEXTURE_MODE */
-      1541, /* GL_TEXTURE_COMPARE_MODE */
-      1539, /* GL_TEXTURE_COMPARE_FUNC */
-       216, /* GL_COMPARE_R_TO_TEXTURE */
-      1091, /* GL_POINT_SPRITE */
-       265, /* GL_COORD_REPLACE */
-      1095, /* GL_POINT_SPRITE_R_MODE_NV */
-      1212, /* GL_QUERY_COUNTER_BITS */
-       290, /* GL_CURRENT_QUERY */
-      1214, /* GL_QUERY_RESULT */
-      1216, /* GL_QUERY_RESULT_AVAILABLE */
-       871, /* GL_MAX_VERTEX_ATTRIBS */
-      1706, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-       336, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-       335, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-       857, /* GL_MAX_TEXTURE_COORDS */
-       859, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-      1162, /* GL_PROGRAM_ERROR_STRING_ARB */
-      1164, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-      1163, /* GL_PROGRAM_FORMAT_ARB */
-      1620, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-       317, /* GL_DEPTH_BOUNDS_TEST_EXT */
-       316, /* GL_DEPTH_BOUNDS_EXT */
-        52, /* GL_ARRAY_BUFFER */
-       419, /* GL_ELEMENT_ARRAY_BUFFER */
-        53, /* GL_ARRAY_BUFFER_BINDING */
-       420, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-      1680, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-       958, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-       139, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-       577, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-      1554, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-       415, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-      1321, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-       461, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-      1732, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-      1702, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-      1165, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-       833, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-      1171, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-       842, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-      1183, /* GL_PROGRAM_TEMPORARIES_ARB */
-       848, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-      1173, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-       844, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-      1177, /* GL_PROGRAM_PARAMETERS_ARB */
-       847, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-      1172, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-       843, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-      1158, /* GL_PROGRAM_ATTRIBS_ARB */
-       828, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-      1170, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-       841, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-      1156, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-       826, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-      1168, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       839, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       834, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-       830, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-      1186, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-      1631, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-      1224, /* GL_READ_ONLY */
-      1740, /* GL_WRITE_ONLY */
-      1226, /* GL_READ_WRITE */
-       100, /* GL_BUFFER_ACCESS */
-       102, /* GL_BUFFER_MAPPED */
-       104, /* GL_BUFFER_MAP_POINTER */
-      1625, /* GL_TIME_ELAPSED_EXT */
-       744, /* GL_MATRIX0_ARB */
-       756, /* GL_MATRIX1_ARB */
-       768, /* GL_MATRIX2_ARB */
-       772, /* GL_MATRIX3_ARB */
-       774, /* GL_MATRIX4_ARB */
-       776, /* GL_MATRIX5_ARB */
-       778, /* GL_MATRIX6_ARB */
-       780, /* GL_MATRIX7_ARB */
-       782, /* GL_MATRIX8_ARB */
-       783, /* GL_MATRIX9_ARB */
-       746, /* GL_MATRIX10_ARB */
-       747, /* GL_MATRIX11_ARB */
-       748, /* GL_MATRIX12_ARB */
-       749, /* GL_MATRIX13_ARB */
-       750, /* GL_MATRIX14_ARB */
-       751, /* GL_MATRIX15_ARB */
-       752, /* GL_MATRIX16_ARB */
-       753, /* GL_MATRIX17_ARB */
-       754, /* GL_MATRIX18_ARB */
-       755, /* GL_MATRIX19_ARB */
-       758, /* GL_MATRIX20_ARB */
-       759, /* GL_MATRIX21_ARB */
-       760, /* GL_MATRIX22_ARB */
-       761, /* GL_MATRIX23_ARB */
-       762, /* GL_MATRIX24_ARB */
-       763, /* GL_MATRIX25_ARB */
-       764, /* GL_MATRIX26_ARB */
-       765, /* GL_MATRIX27_ARB */
-       766, /* GL_MATRIX28_ARB */
-       767, /* GL_MATRIX29_ARB */
-       770, /* GL_MATRIX30_ARB */
-       771, /* GL_MATRIX31_ARB */
-      1427, /* GL_STREAM_DRAW */
-      1429, /* GL_STREAM_READ */
-      1425, /* GL_STREAM_COPY */
-      1389, /* GL_STATIC_DRAW */
-      1391, /* GL_STATIC_READ */
-      1387, /* GL_STATIC_COPY */
-       409, /* GL_DYNAMIC_DRAW */
-       411, /* GL_DYNAMIC_READ */
-       407, /* GL_DYNAMIC_COPY */
-       533, /* GL_GL_PIXEL_PACK_BUFFER */
-       535, /* GL_GL_PIXEL_UNPACK_BUFFER */
-       534, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-       536, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-       831, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-       829, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-       832, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-       836, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-       835, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-       793, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-      1421, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+      1848, /* GL_WEIGHT_SUM_UNITY_ARB */
+      1825, /* GL_VERTEX_BLEND_ARB */
+       336, /* GL_CURRENT_WEIGHT_ARB */
+      1847, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+      1846, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+      1845, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+      1844, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+      1841, /* GL_WEIGHT_ARRAY_ARB */
+       384, /* GL_DOT3_RGB */
+       385, /* GL_DOT3_RGBA */
+       263, /* GL_COMPRESSED_RGB_FXT1_3DFX */
+       258, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
+       994, /* GL_MULTISAMPLE_3DFX */
+      1387, /* GL_SAMPLE_BUFFERS_3DFX */
+      1378, /* GL_SAMPLES_3DFX */
+       975, /* GL_MODELVIEW2_ARB */
+       978, /* GL_MODELVIEW3_ARB */
+       979, /* GL_MODELVIEW4_ARB */
+       980, /* GL_MODELVIEW5_ARB */
+       981, /* GL_MODELVIEW6_ARB */
+       982, /* GL_MODELVIEW7_ARB */
+       983, /* GL_MODELVIEW8_ARB */
+       984, /* GL_MODELVIEW9_ARB */
+       954, /* GL_MODELVIEW10_ARB */
+       955, /* GL_MODELVIEW11_ARB */
+       956, /* GL_MODELVIEW12_ARB */
+       957, /* GL_MODELVIEW13_ARB */
+       958, /* GL_MODELVIEW14_ARB */
+       959, /* GL_MODELVIEW15_ARB */
+       960, /* GL_MODELVIEW16_ARB */
+       961, /* GL_MODELVIEW17_ARB */
+       962, /* GL_MODELVIEW18_ARB */
+       963, /* GL_MODELVIEW19_ARB */
+       965, /* GL_MODELVIEW20_ARB */
+       966, /* GL_MODELVIEW21_ARB */
+       967, /* GL_MODELVIEW22_ARB */
+       968, /* GL_MODELVIEW23_ARB */
+       969, /* GL_MODELVIEW24_ARB */
+       970, /* GL_MODELVIEW25_ARB */
+       971, /* GL_MODELVIEW26_ARB */
+       972, /* GL_MODELVIEW27_ARB */
+       973, /* GL_MODELVIEW28_ARB */
+       974, /* GL_MODELVIEW29_ARB */
+       976, /* GL_MODELVIEW30_ARB */
+       977, /* GL_MODELVIEW31_ARB */
+       389, /* GL_DOT3_RGB_EXT */
+       387, /* GL_DOT3_RGBA_EXT */
+       948, /* GL_MIRROR_CLAMP_EXT */
+       951, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+       989, /* GL_MODULATE_ADD_ATI */
+       990, /* GL_MODULATE_SIGNED_ADD_ATI */
+       991, /* GL_MODULATE_SUBTRACT_ATI */
+      1854, /* GL_YCBCR_MESA */
+      1081, /* GL_PACK_INVERT_MESA */
+       339, /* GL_DEBUG_OBJECT_MESA */
+       340, /* GL_DEBUG_PRINT_MESA */
+       338, /* GL_DEBUG_ASSERT_MESA */
+       110, /* GL_BUFFER_SIZE */
+       112, /* GL_BUFFER_USAGE */
+       116, /* GL_BUMP_ROT_MATRIX_ATI */
+       117, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
+       115, /* GL_BUMP_NUM_TEX_UNITS_ATI */
+       119, /* GL_BUMP_TEX_UNITS_ATI */
+       448, /* GL_DUDV_ATI */
+       447, /* GL_DU8DV8_ATI */
+       114, /* GL_BUMP_ENVMAP_ATI */
+       118, /* GL_BUMP_TARGET_ATI */
+      1486, /* GL_STENCIL_BACK_FUNC */
+      1484, /* GL_STENCIL_BACK_FAIL */
+      1488, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+      1490, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+       532, /* GL_FRAGMENT_PROGRAM_ARB */
+      1219, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1247, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1246, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1231, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1237, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1236, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       882, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+       905, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+       904, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+       895, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+       901, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+       900, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       865, /* GL_MAX_DRAW_BUFFERS */
+       393, /* GL_DRAW_BUFFER0 */
+       396, /* GL_DRAW_BUFFER1 */
+       417, /* GL_DRAW_BUFFER2 */
+       420, /* GL_DRAW_BUFFER3 */
+       423, /* GL_DRAW_BUFFER4 */
+       426, /* GL_DRAW_BUFFER5 */
+       429, /* GL_DRAW_BUFFER6 */
+       432, /* GL_DRAW_BUFFER7 */
+       435, /* GL_DRAW_BUFFER8 */
+       438, /* GL_DRAW_BUFFER9 */
+       397, /* GL_DRAW_BUFFER10 */
+       400, /* GL_DRAW_BUFFER11 */
+       403, /* GL_DRAW_BUFFER12 */
+       406, /* GL_DRAW_BUFFER13 */
+       409, /* GL_DRAW_BUFFER14 */
+       412, /* GL_DRAW_BUFFER15 */
+        82, /* GL_BLEND_EQUATION_ALPHA */
+       845, /* GL_MATRIX_PALETTE_ARB */
+       876, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+       879, /* GL_MAX_PALETTE_MATRICES_ARB */
+       321, /* GL_CURRENT_PALETTE_MATRIX_ARB */
+       839, /* GL_MATRIX_INDEX_ARRAY_ARB */
+       316, /* GL_CURRENT_MATRIX_INDEX_ARB */
+       841, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+       843, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+       842, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+       840, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+      1674, /* GL_TEXTURE_DEPTH_SIZE */
+       377, /* GL_DEPTH_TEXTURE_MODE */
+      1639, /* GL_TEXTURE_COMPARE_MODE */
+      1637, /* GL_TEXTURE_COMPARE_FUNC */
+       242, /* GL_COMPARE_R_TO_TEXTURE */
+      1153, /* GL_POINT_SPRITE */
+       296, /* GL_COORD_REPLACE */
+      1157, /* GL_POINT_SPRITE_R_MODE_NV */
+      1276, /* GL_QUERY_COUNTER_BITS */
+       323, /* GL_CURRENT_QUERY */
+      1278, /* GL_QUERY_RESULT */
+      1280, /* GL_QUERY_RESULT_AVAILABLE */
+       928, /* GL_MAX_VERTEX_ATTRIBS */
+      1815, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+       375, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+       374, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+       914, /* GL_MAX_TEXTURE_COORDS */
+       916, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+      1224, /* GL_PROGRAM_ERROR_STRING_ARB */
+      1226, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+      1225, /* GL_PROGRAM_FORMAT_ARB */
+      1723, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+       353, /* GL_DEPTH_BOUNDS_TEST_EXT */
+       352, /* GL_DEPTH_BOUNDS_EXT */
+        53, /* GL_ARRAY_BUFFER */
+       461, /* GL_ELEMENT_ARRAY_BUFFER */
+        54, /* GL_ARRAY_BUFFER_BINDING */
+       462, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+      1789, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+      1015, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+       149, /* GL_COLOR_ARRAY_BUFFER_BINDING */
+       624, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+      1652, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+       457, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+      1399, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+       510, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+      1842, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+      1811, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+      1227, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+       888, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+      1233, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+       897, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1245, /* GL_PROGRAM_TEMPORARIES_ARB */
+       903, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+      1235, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+       899, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1239, /* GL_PROGRAM_PARAMETERS_ARB */
+       902, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+      1234, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+       898, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1220, /* GL_PROGRAM_ATTRIBS_ARB */
+       883, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+      1232, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+       896, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1218, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+       881, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1230, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       894, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       889, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+       885, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+      1248, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+      1736, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+      1289, /* GL_READ_ONLY */
+      1850, /* GL_WRITE_ONLY */
+      1291, /* GL_READ_WRITE */
+       102, /* GL_BUFFER_ACCESS */
+       105, /* GL_BUFFER_MAPPED */
+       107, /* GL_BUFFER_MAP_POINTER */
+      1730, /* GL_TIME_ELAPSED_EXT */
+       799, /* GL_MATRIX0_ARB */
+       811, /* GL_MATRIX1_ARB */
+       823, /* GL_MATRIX2_ARB */
+       827, /* GL_MATRIX3_ARB */
+       829, /* GL_MATRIX4_ARB */
+       831, /* GL_MATRIX5_ARB */
+       833, /* GL_MATRIX6_ARB */
+       835, /* GL_MATRIX7_ARB */
+       837, /* GL_MATRIX8_ARB */
+       838, /* GL_MATRIX9_ARB */
+       801, /* GL_MATRIX10_ARB */
+       802, /* GL_MATRIX11_ARB */
+       803, /* GL_MATRIX12_ARB */
+       804, /* GL_MATRIX13_ARB */
+       805, /* GL_MATRIX14_ARB */
+       806, /* GL_MATRIX15_ARB */
+       807, /* GL_MATRIX16_ARB */
+       808, /* GL_MATRIX17_ARB */
+       809, /* GL_MATRIX18_ARB */
+       810, /* GL_MATRIX19_ARB */
+       813, /* GL_MATRIX20_ARB */
+       814, /* GL_MATRIX21_ARB */
+       815, /* GL_MATRIX22_ARB */
+       816, /* GL_MATRIX23_ARB */
+       817, /* GL_MATRIX24_ARB */
+       818, /* GL_MATRIX25_ARB */
+       819, /* GL_MATRIX26_ARB */
+       820, /* GL_MATRIX27_ARB */
+       821, /* GL_MATRIX28_ARB */
+       822, /* GL_MATRIX29_ARB */
+       825, /* GL_MATRIX30_ARB */
+       826, /* GL_MATRIX31_ARB */
+      1519, /* GL_STREAM_DRAW */
+      1521, /* GL_STREAM_READ */
+      1517, /* GL_STREAM_COPY */
+      1477, /* GL_STATIC_DRAW */
+      1479, /* GL_STATIC_READ */
+      1475, /* GL_STATIC_COPY */
+       451, /* GL_DYNAMIC_DRAW */
+       453, /* GL_DYNAMIC_READ */
+       449, /* GL_DYNAMIC_COPY */
+      1121, /* GL_PIXEL_PACK_BUFFER */
+      1125, /* GL_PIXEL_UNPACK_BUFFER */
+      1122, /* GL_PIXEL_PACK_BUFFER_BINDING */
+      1126, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+       347, /* GL_DEPTH24_STENCIL8 */
+      1720, /* GL_TEXTURE_STENCIL_SIZE */
+      1672, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+       884, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+       887, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+       891, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+       890, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+       848, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+      1510, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
         17, /* GL_ACTIVE_STENCIL_FACE_EXT */
-       892, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-      1302, /* GL_SAMPLES_PASSED */
-       484, /* GL_FRAGMENT_SHADER */
-      1726, /* GL_VERTEX_SHADER */
-      1176, /* GL_PROGRAM_OBJECT_ARB */
-      1334, /* GL_SHADER_OBJECT_ARB */
-       817, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-       875, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-       869, /* GL_MAX_VARYING_FLOATS */
-       873, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-       802, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-       983, /* GL_OBJECT_TYPE_ARB */
-      1336, /* GL_SHADER_TYPE */
-       449, /* GL_FLOAT_VEC2 */
-       451, /* GL_FLOAT_VEC3 */
-       453, /* GL_FLOAT_VEC4 */
-       604, /* GL_INT_VEC2 */
-       606, /* GL_INT_VEC3 */
-       608, /* GL_INT_VEC4 */
-        92, /* GL_BOOL */
-        94, /* GL_BOOL_VEC2 */
-        96, /* GL_BOOL_VEC3 */
-        98, /* GL_BOOL_VEC4 */
-       443, /* GL_FLOAT_MAT2 */
-       445, /* GL_FLOAT_MAT3 */
-       447, /* GL_FLOAT_MAT4 */
-      1293, /* GL_SAMPLER_1D */
-      1295, /* GL_SAMPLER_2D */
-      1297, /* GL_SAMPLER_3D */
-      1298, /* GL_SAMPLER_CUBE */
-      1294, /* GL_SAMPLER_1D_SHADOW */
-      1296, /* GL_SAMPLER_2D_SHADOW */
-       527, /* GL_GL_FLOAT_MAT2x3 */
-       528, /* GL_GL_FLOAT_MAT2x4 */
-       529, /* GL_GL_FLOAT_MAT3x2 */
-       530, /* GL_GL_FLOAT_MAT3x4 */
-       531, /* GL_GL_FLOAT_MAT4x2 */
-       532, /* GL_GL_FLOAT_MAT4x3 */
-       311, /* GL_DELETE_STATUS */
-       220, /* GL_COMPILE_STATUS */
-       657, /* GL_LINK_STATUS */
-      1675, /* GL_VALIDATE_STATUS */
-       589, /* GL_INFO_LOG_LENGTH */
-        55, /* GL_ATTACHED_SHADERS */
+       949, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+      1380, /* GL_SAMPLES_PASSED */
+       109, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
+       104, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
+       533, /* GL_FRAGMENT_SHADER */
+      1835, /* GL_VERTEX_SHADER */
+      1238, /* GL_PROGRAM_OBJECT_ARB */
+      1412, /* GL_SHADER_OBJECT_ARB */
+       872, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+       932, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+       926, /* GL_MAX_VARYING_FLOATS */
+       930, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+       857, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+      1041, /* GL_OBJECT_TYPE_ARB */
+      1414, /* GL_SHADER_TYPE */
+       498, /* GL_FLOAT_VEC2 */
+       500, /* GL_FLOAT_VEC3 */
+       502, /* GL_FLOAT_VEC4 */
+       651, /* GL_INT_VEC2 */
+       653, /* GL_INT_VEC3 */
+       655, /* GL_INT_VEC4 */
+        94, /* GL_BOOL */
+        96, /* GL_BOOL_VEC2 */
+        98, /* GL_BOOL_VEC3 */
+       100, /* GL_BOOL_VEC4 */
+       486, /* GL_FLOAT_MAT2 */
+       490, /* GL_FLOAT_MAT3 */
+       494, /* GL_FLOAT_MAT4 */
+      1371, /* GL_SAMPLER_1D */
+      1373, /* GL_SAMPLER_2D */
+      1375, /* GL_SAMPLER_3D */
+      1376, /* GL_SAMPLER_CUBE */
+      1372, /* GL_SAMPLER_1D_SHADOW */
+      1374, /* GL_SAMPLER_2D_SHADOW */
+       488, /* GL_FLOAT_MAT2x3 */
+       489, /* GL_FLOAT_MAT2x4 */
+       492, /* GL_FLOAT_MAT3x2 */
+       493, /* GL_FLOAT_MAT3x4 */
+       496, /* GL_FLOAT_MAT4x2 */
+       497, /* GL_FLOAT_MAT4x3 */
+       345, /* GL_DELETE_STATUS */
+       246, /* GL_COMPILE_STATUS */
+       706, /* GL_LINK_STATUS */
+      1783, /* GL_VALIDATE_STATUS */
+       636, /* GL_INFO_LOG_LENGTH */
+        56, /* GL_ATTACHED_SHADERS */
         20, /* GL_ACTIVE_UNIFORMS */
         21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-      1335, /* GL_SHADER_SOURCE_LENGTH */
+      1413, /* GL_SHADER_SOURCE_LENGTH */
         15, /* GL_ACTIVE_ATTRIBUTES */
         16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-       486, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-      1338, /* GL_SHADING_LANGUAGE_VERSION */
-       289, /* GL_CURRENT_PROGRAM */
-      1032, /* GL_PALETTE4_RGB8_OES */
-      1034, /* GL_PALETTE4_RGBA8_OES */
-      1030, /* GL_PALETTE4_R5_G6_B5_OES */
-      1033, /* GL_PALETTE4_RGBA4_OES */
-      1031, /* GL_PALETTE4_RGB5_A1_OES */
-      1037, /* GL_PALETTE8_RGB8_OES */
-      1039, /* GL_PALETTE8_RGBA8_OES */
-      1035, /* GL_PALETTE8_R5_G6_B5_OES */
-      1038, /* GL_PALETTE8_RGBA4_OES */
-      1036, /* GL_PALETTE8_RGB5_A1_OES */
-       572, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-       571, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-      1509, /* GL_TEXTURE_1D_ARRAY_EXT */
-      1196, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-      1511, /* GL_TEXTURE_2D_ARRAY_EXT */
-      1199, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-      1517, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-      1519, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-       541, /* GL_GL_SRGB */
-       542, /* GL_GL_SRGB8 */
-       544, /* GL_GL_SRGB_ALPHA */
-       543, /* GL_GL_SRGB8_ALPHA8 */
-       540, /* GL_GL_SLUMINANCE_ALPHA */
-       539, /* GL_GL_SLUMINANCE8_ALPHA8 */
-       537, /* GL_GL_SLUMINANCE */
-       538, /* GL_GL_SLUMINANCE8 */
-       524, /* GL_GL_COMPRESSED_SRGB */
-       525, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-       522, /* GL_GL_COMPRESSED_SLUMINANCE */
-       523, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-      1093, /* GL_POINT_SPRITE_COORD_ORIGIN */
-       665, /* GL_LOWER_LEFT */
-      1672, /* GL_UPPER_LEFT */
-      1403, /* GL_STENCIL_BACK_REF */
-      1404, /* GL_STENCIL_BACK_VALUE_MASK */
-      1405, /* GL_STENCIL_BACK_WRITEMASK */
-       402, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-      1238, /* GL_RENDERBUFFER_BINDING_EXT */
-      1223, /* GL_READ_FRAMEBUFFER_EXT */
-       403, /* GL_DRAW_FRAMEBUFFER_EXT */
-      1222, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-       488, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-       487, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-       492, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-       490, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-       489, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-       494, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-       496, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-       501, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-       499, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-       497, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-       500, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-       498, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-       502, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-       504, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-       503, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-       799, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-       145, /* GL_COLOR_ATTACHMENT0_EXT */
-       152, /* GL_COLOR_ATTACHMENT1_EXT */
-       153, /* GL_COLOR_ATTACHMENT2_EXT */
-       154, /* GL_COLOR_ATTACHMENT3_EXT */
-       155, /* GL_COLOR_ATTACHMENT4_EXT */
-       156, /* GL_COLOR_ATTACHMENT5_EXT */
-       157, /* GL_COLOR_ATTACHMENT6_EXT */
-       158, /* GL_COLOR_ATTACHMENT7_EXT */
-       159, /* GL_COLOR_ATTACHMENT8_EXT */
-       160, /* GL_COLOR_ATTACHMENT9_EXT */
-       146, /* GL_COLOR_ATTACHMENT10_EXT */
-       147, /* GL_COLOR_ATTACHMENT11_EXT */
-       148, /* GL_COLOR_ATTACHMENT12_EXT */
-       149, /* GL_COLOR_ATTACHMENT13_EXT */
-       150, /* GL_COLOR_ATTACHMENT14_EXT */
-       151, /* GL_COLOR_ATTACHMENT15_EXT */
-       313, /* GL_DEPTH_ATTACHMENT_EXT */
-      1394, /* GL_STENCIL_ATTACHMENT_EXT */
-       495, /* GL_FRAMEBUFFER_EXT */
-      1239, /* GL_RENDERBUFFER_EXT */
-      1242, /* GL_RENDERBUFFER_WIDTH_EXT */
-      1240, /* GL_RENDERBUFFER_HEIGHT_EXT */
-      1241, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-      1416, /* GL_STENCIL_INDEX_EXT */
-      1413, /* GL_STENCIL_INDEX1_EXT */
-      1414, /* GL_STENCIL_INDEX4_EXT */
-      1415, /* GL_STENCIL_INDEX8_EXT */
-      1412, /* GL_STENCIL_INDEX16_EXT */
-       426, /* GL_EVAL_BIT */
-      1220, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-       659, /* GL_LIST_BIT */
-      1525, /* GL_TEXTURE_BIT */
-      1317, /* GL_SCISSOR_BIT */
+       535, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+      1416, /* GL_SHADING_LANGUAGE_VERSION */
+       322, /* GL_CURRENT_PROGRAM */
+      1090, /* GL_PALETTE4_RGB8_OES */
+      1092, /* GL_PALETTE4_RGBA8_OES */
+      1088, /* GL_PALETTE4_R5_G6_B5_OES */
+      1091, /* GL_PALETTE4_RGBA4_OES */
+      1089, /* GL_PALETTE4_RGB5_A1_OES */
+      1095, /* GL_PALETTE8_RGB8_OES */
+      1097, /* GL_PALETTE8_RGBA8_OES */
+      1093, /* GL_PALETTE8_R5_G6_B5_OES */
+      1096, /* GL_PALETTE8_RGBA4_OES */
+      1094, /* GL_PALETTE8_RGB5_A1_OES */
+       618, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+       617, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+      1768, /* GL_UNSIGNED_NORMALIZED */
+      1607, /* GL_TEXTURE_1D_ARRAY_EXT */
+      1259, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+      1609, /* GL_TEXTURE_2D_ARRAY_EXT */
+      1262, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+      1615, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+      1617, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+      1469, /* GL_SRGB */
+      1470, /* GL_SRGB8 */
+      1472, /* GL_SRGB_ALPHA */
+      1471, /* GL_SRGB8_ALPHA8 */
+      1429, /* GL_SLUMINANCE_ALPHA */
+      1428, /* GL_SLUMINANCE8_ALPHA8 */
+      1426, /* GL_SLUMINANCE */
+      1427, /* GL_SLUMINANCE8 */
+       267, /* GL_COMPRESSED_SRGB */
+       268, /* GL_COMPRESSED_SRGB_ALPHA */
+       265, /* GL_COMPRESSED_SLUMINANCE */
+       266, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
+      1155, /* GL_POINT_SPRITE_COORD_ORIGIN */
+       714, /* GL_LOWER_LEFT */
+      1780, /* GL_UPPER_LEFT */
+      1492, /* GL_STENCIL_BACK_REF */
+      1493, /* GL_STENCIL_BACK_VALUE_MASK */
+      1494, /* GL_STENCIL_BACK_WRITEMASK */
+       442, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+      1305, /* GL_RENDERBUFFER_BINDING_EXT */
+      1286, /* GL_READ_FRAMEBUFFER */
+       441, /* GL_DRAW_FRAMEBUFFER */
+      1287, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+      1315, /* GL_RENDERBUFFER_SAMPLES */
+       545, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+       543, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+       554, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+       550, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+       552, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+       557, /* GL_FRAMEBUFFER_COMPLETE */
+       561, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+       567, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+       565, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+       563, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+       566, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+       564, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+       570, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+       573, /* GL_FRAMEBUFFER_UNSUPPORTED */
+       571, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+       854, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+       155, /* GL_COLOR_ATTACHMENT0 */
+       157, /* GL_COLOR_ATTACHMENT1 */
+       171, /* GL_COLOR_ATTACHMENT2 */
+       173, /* GL_COLOR_ATTACHMENT3 */
+       175, /* GL_COLOR_ATTACHMENT4 */
+       177, /* GL_COLOR_ATTACHMENT5 */
+       179, /* GL_COLOR_ATTACHMENT6 */
+       181, /* GL_COLOR_ATTACHMENT7 */
+       183, /* GL_COLOR_ATTACHMENT8 */
+       185, /* GL_COLOR_ATTACHMENT9 */
+       158, /* GL_COLOR_ATTACHMENT10 */
+       160, /* GL_COLOR_ATTACHMENT11 */
+       162, /* GL_COLOR_ATTACHMENT12 */
+       164, /* GL_COLOR_ATTACHMENT13 */
+       166, /* GL_COLOR_ATTACHMENT14 */
+       168, /* GL_COLOR_ATTACHMENT15 */
+       348, /* GL_DEPTH_ATTACHMENT */
+      1482, /* GL_STENCIL_ATTACHMENT */
+       536, /* GL_FRAMEBUFFER */
+      1303, /* GL_RENDERBUFFER */
+      1317, /* GL_RENDERBUFFER_WIDTH */
+      1310, /* GL_RENDERBUFFER_HEIGHT */
+      1312, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+      1505, /* GL_STENCIL_INDEX_EXT */
+      1502, /* GL_STENCIL_INDEX1_EXT */
+      1503, /* GL_STENCIL_INDEX4_EXT */
+      1504, /* GL_STENCIL_INDEX8_EXT */
+      1501, /* GL_STENCIL_INDEX16_EXT */
+      1314, /* GL_RENDERBUFFER_RED_SIZE */
+      1309, /* GL_RENDERBUFFER_GREEN_SIZE */
+      1306, /* GL_RENDERBUFFER_BLUE_SIZE */
+      1304, /* GL_RENDERBUFFER_ALPHA_SIZE */
+      1307, /* GL_RENDERBUFFER_DEPTH_SIZE */
+      1316, /* GL_RENDERBUFFER_STENCIL_SIZE */
+       569, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+       910, /* GL_MAX_SAMPLES */
+      1273, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+       483, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+       666, /* GL_LAST_VERTEX_CONVENTION_EXT */
+      1252, /* GL_PROVOKING_VERTEX_EXT */
+       302, /* GL_COPY_READ_BUFFER */
+       303, /* GL_COPY_WRITE_BUFFER */
+      1364, /* GL_RGBA_SNORM */
+      1360, /* GL_RGBA8_SNORM */
+      1422, /* GL_SIGNED_NORMALIZED */
+       911, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+      1040, /* GL_OBJECT_TYPE */
+      1526, /* GL_SYNC_CONDITION */
+      1531, /* GL_SYNC_STATUS */
+      1528, /* GL_SYNC_FLAGS */
+      1527, /* GL_SYNC_FENCE */
+      1530, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+      1757, /* GL_UNSIGNALED */
+      1421, /* GL_SIGNALED */
+        46, /* GL_ALREADY_SIGNALED */
+      1728, /* GL_TIMEOUT_EXPIRED */
+       270, /* GL_CONDITION_SATISFIED */
+      1840, /* GL_WAIT_FAILED */
+       468, /* GL_EVAL_BIT */
+      1284, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+       708, /* GL_LIST_BIT */
+      1623, /* GL_TEXTURE_BIT */
+      1395, /* GL_SCISSOR_BIT */
         29, /* GL_ALL_ATTRIB_BITS */
-       939, /* GL_MULTISAMPLE_BIT */
+       996, /* GL_MULTISAMPLE_BIT */
         30, /* GL_ALL_CLIENT_ATTRIB_BITS */
+      1729, /* GL_TIMEOUT_IGNORED */
 };
 
-#define Elements(x) sizeof(x)/sizeof(*x)
-
 typedef int (*cfunc)(const void *, const void *);
 
 /**
@@ -4881,6 +5163,29 @@ const char *_mesa_lookup_enum_by_nr( int nr )
    }
 }
 
+/* Get the name of an enum given that it is a primitive type.  Avoids
+ * GL_FALSE/GL_POINTS ambiguity and others.
+ */
+const char *_mesa_lookup_prim_by_nr( int nr )
+{
+   switch (nr) {
+   case GL_POINTS: return "GL_POINTS";
+   case GL_LINES: return "GL_LINES";
+   case GL_LINE_STRIP: return "GL_LINE_STRIP";
+   case GL_LINE_LOOP: return "GL_LINE_LOOP";
+   case GL_TRIANGLES: return "GL_TRIANGLES";
+   case GL_TRIANGLE_STRIP: return "GL_TRIANGLE_STRIP";
+   case GL_TRIANGLE_FAN: return "GL_TRIANGLE_FAN";
+   case GL_QUADS: return "GL_QUADS";
+   case GL_QUAD_STRIP: return "GL_QUAD_STRIP";
+   case GL_POLYGON: return "GL_POLYGON";
+   case GL_POLYGON+1: return "OUTSIDE_BEGIN_END";
+   default: return "<invalid>";
+   }
+}
+
+
+
 int _mesa_lookup_enum_by_name( const char *symbol )
 {
    enum_elt * f = NULL;
diff --git a/src/mesa/main/enums.h b/src/mesa/main/enums.h
index 23a4767f35..b5f69001b8 100644
--- a/src/mesa/main/enums.h
+++ b/src/mesa/main/enums.h
@@ -40,6 +40,12 @@
 #if defined(_HAVE_FULL_GL) && _HAVE_FULL_GL
 
 extern const char *_mesa_lookup_enum_by_nr( int nr );
+
+/* Get the name of an enum given that it is a primitive type.  Avoids
+ * GL_FALSE/GL_POINTS ambiguity and others.
+ */
+const char *_mesa_lookup_prim_by_nr( int nr );
+
 extern int _mesa_lookup_enum_by_name( const char *symbol );
 
 #else
diff --git a/src/mesa/main/eval.c b/src/mesa/main/eval.c
index 3f89f9c1ea..47f99270ce 100644
--- a/src/mesa/main/eval.c
+++ b/src/mesa/main/eval.c
@@ -44,6 +44,10 @@
 #include "eval.h"
 #include "macros.h"
 #include "mtypes.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_eval
 
 
 /*
@@ -797,6 +801,41 @@ _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
 }
 
 
+void 
+_mesa_install_eval_vtxfmt(struct _glapi_table *disp,
+                          const GLvertexformat *vfmt)
+{
+   SET_EvalCoord1f(disp, vfmt->EvalCoord1f);
+   SET_EvalCoord1fv(disp, vfmt->EvalCoord1fv);
+   SET_EvalCoord2f(disp, vfmt->EvalCoord2f);
+   SET_EvalCoord2fv(disp, vfmt->EvalCoord2fv);
+   SET_EvalPoint1(disp, vfmt->EvalPoint1);
+   SET_EvalPoint2(disp, vfmt->EvalPoint2);
+
+   SET_EvalMesh1(disp, vfmt->EvalMesh1);
+   SET_EvalMesh2(disp, vfmt->EvalMesh2);
+}
+
+
+void 
+_mesa_init_eval_dispatch(struct _glapi_table *disp)
+{
+   SET_GetMapdv(disp, _mesa_GetMapdv);
+   SET_GetMapfv(disp, _mesa_GetMapfv);
+   SET_GetMapiv(disp, _mesa_GetMapiv);
+   SET_Map1d(disp, _mesa_Map1d);
+   SET_Map1f(disp, _mesa_Map1f);
+   SET_Map2d(disp, _mesa_Map2d);
+   SET_Map2f(disp, _mesa_Map2f);
+   SET_MapGrid1d(disp, _mesa_MapGrid1d);
+   SET_MapGrid1f(disp, _mesa_MapGrid1f);
+   SET_MapGrid2d(disp, _mesa_MapGrid2d);
+   SET_MapGrid2f(disp, _mesa_MapGrid2f);
+}
+
+
+#endif /* FEATURE_eval */
+
 
 /**********************************************************************/
 /*****                      Initialization                        *****/
diff --git a/src/mesa/main/eval.h b/src/mesa/main/eval.h
index b3ff0a96f8..49fd37a057 100644
--- a/src/mesa/main/eval.h
+++ b/src/mesa/main/eval.h
@@ -37,13 +37,22 @@
 #define EVAL_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
-#if _HAVE_FULL_GL
 
-extern void _mesa_init_eval( GLcontext *ctx );
-extern void _mesa_free_eval_data( GLcontext *ctx );
+#if FEATURE_eval
 
+#define _MESA_INIT_EVAL_VTXFMT(vfmt, impl)         \
+   do {                                            \
+      (vfmt)->EvalCoord1f  = impl ## EvalCoord1f;  \
+      (vfmt)->EvalCoord1fv = impl ## EvalCoord1fv; \
+      (vfmt)->EvalCoord2f  = impl ## EvalCoord2f;  \
+      (vfmt)->EvalCoord2fv = impl ## EvalCoord2fv; \
+      (vfmt)->EvalPoint1   = impl ## EvalPoint1;   \
+      (vfmt)->EvalPoint2   = impl ## EvalPoint2;   \
+      (vfmt)->EvalMesh1    = impl ## EvalMesh1;    \
+      (vfmt)->EvalMesh2    = impl ## EvalMesh2;    \
+   } while (0)
 
 extern GLuint _mesa_evaluator_components( GLenum target );
 
@@ -115,14 +124,32 @@ _mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v );
 extern void GLAPIENTRY
 _mesa_GetMapiv( GLenum target, GLenum query, GLint *v );
 
-#else
+extern void 
+_mesa_install_eval_vtxfmt(struct _glapi_table *disp,
+                          const GLvertexformat *vfmt);
+
+extern void 
+_mesa_init_eval_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_eval */
+
+#define _MESA_INIT_EVAL_VTXFMT(vfmt, impl) do { } while (0)
 
-/** No-op */
-#define _mesa_init_eval( c ) ((void)0)
+static INLINE void 
+_mesa_install_eval_vtxfmt(struct _glapi_table *disp,
+                          const GLvertexformat *vfmt)
+{
+}
 
-/** No-op */
-#define _mesa_free_eval_data( c ) ((void)0)
+static INLINE void 
+_mesa_init_eval_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_eval */
+
+extern void _mesa_init_eval( GLcontext *ctx );
+extern void _mesa_free_eval_data( GLcontext *ctx );
 
-#endif
 
-#endif
+#endif /* EVAL_H */
diff --git a/src/mesa/main/execmem.c b/src/mesa/main/execmem.c
index f95c31862a..57c1e117c8 100644
--- a/src/mesa/main/execmem.c
+++ b/src/mesa/main/execmem.c
@@ -24,7 +24,7 @@
 
 
 /**
- * \file exemem.c
+ * \file execmem.c
  * Functions for allocating executable memory.
  *
  * \author Keith Whitwell
@@ -36,7 +36,7 @@
 
 
 
-#if defined(__linux__) || defined(__OpenBSD__) || defined(_NetBSD__)
+#if defined(__linux__) || defined(__OpenBSD__) || defined(_NetBSD__) || defined(__sun)
 
 /*
  * Allocate a large block of memory which can hold code then dole it out
diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c
index 9522f04ae5..5b54c1cf8c 100644
--- a/src/mesa/main/extensions.c
+++ b/src/mesa/main/extensions.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -31,7 +32,7 @@
 #include "mtypes.h"
 
 
-#define F(x) (int)(uintptr_t)&(((struct gl_extensions *)0)->x)
+#define F(x) offsetof(struct gl_extensions, x)
 #define ON GL_TRUE
 #define OFF GL_FALSE
 
@@ -44,26 +45,33 @@ static const struct {
    const char *name;
    int flag_offset;
 } default_extensions[] = {
+   { OFF, "GL_ARB_copy_buffer",                F(ARB_copy_buffer) },
    { OFF, "GL_ARB_depth_texture",              F(ARB_depth_texture) },
-   { OFF, "GL_ARB_draw_buffers",               F(ARB_draw_buffers) },
+   { OFF, "GL_ARB_depth_clamp",                F(ARB_depth_clamp) },
+   { ON,  "GL_ARB_draw_buffers",               F(ARB_draw_buffers) },
+   { OFF, "GL_ARB_draw_elements_base_vertex",  F(ARB_draw_elements_base_vertex) },
    { OFF, "GL_ARB_fragment_program",           F(ARB_fragment_program) },
    { OFF, "GL_ARB_fragment_program_shadow",    F(ARB_fragment_program_shadow) },
    { OFF, "GL_ARB_fragment_shader",            F(ARB_fragment_shader) },
+   { OFF, "GL_ARB_framebuffer_object",         F(ARB_framebuffer_object) },
    { OFF, "GL_ARB_half_float_pixel",           F(ARB_half_float_pixel) },
    { OFF, "GL_ARB_imaging",                    F(ARB_imaging) },
-   { OFF, "GL_ARB_multisample",                F(ARB_multisample) },
+   { OFF, "GL_ARB_map_buffer_range",           F(ARB_map_buffer_range) },
+   { ON,  "GL_ARB_multisample",                F(ARB_multisample) },
    { OFF, "GL_ARB_multitexture",               F(ARB_multitexture) },
    { OFF, "GL_ARB_occlusion_query",            F(ARB_occlusion_query) },
    { OFF, "GL_ARB_pixel_buffer_object",        F(EXT_pixel_buffer_object) },
    { OFF, "GL_ARB_point_parameters",           F(EXT_point_parameters) },
    { OFF, "GL_ARB_point_sprite",               F(ARB_point_sprite) },
+   { OFF, "GL_ARB_seamless_cube_map",          F(ARB_seamless_cube_map) },
    { OFF, "GL_ARB_shader_objects",             F(ARB_shader_objects) },
    { OFF, "GL_ARB_shading_language_100",       F(ARB_shading_language_100) },
    { OFF, "GL_ARB_shading_language_120",       F(ARB_shading_language_120) },
    { OFF, "GL_ARB_shadow",                     F(ARB_shadow) },
-   { OFF, "GL_ARB_shadow_ambient",             F(SGIX_shadow_ambient) },
+   { OFF, "GL_ARB_shadow_ambient",             F(ARB_shadow_ambient) },
+   { OFF, "GL_ARB_sync",                       F(ARB_sync) },
    { OFF, "GL_ARB_texture_border_clamp",       F(ARB_texture_border_clamp) },
-   { OFF, "GL_ARB_texture_compression",        F(ARB_texture_compression) },
+   { ON,  "GL_ARB_texture_compression",        F(ARB_texture_compression) },
    { OFF, "GL_ARB_texture_cube_map",           F(ARB_texture_cube_map) },
    { OFF, "GL_ARB_texture_env_add",            F(EXT_texture_env_add) },
    { OFF, "GL_ARB_texture_env_combine",        F(ARB_texture_env_combine) },
@@ -74,7 +82,9 @@ static const struct {
    { OFF, "GL_ARB_texture_non_power_of_two",   F(ARB_texture_non_power_of_two)},
    { OFF, "GL_ARB_texture_rectangle",          F(NV_texture_rectangle) },
    { ON,  "GL_ARB_transpose_matrix",           F(ARB_transpose_matrix) },
-   { OFF, "GL_ARB_vertex_buffer_object",       F(ARB_vertex_buffer_object) },
+   { OFF, "GL_ARB_vertex_array_bgra",          F(EXT_vertex_array_bgra) },
+   { OFF, "GL_ARB_vertex_array_object",        F(ARB_vertex_array_object) },
+   { ON,  "GL_ARB_vertex_buffer_object",       F(ARB_vertex_buffer_object) },
    { OFF, "GL_ARB_vertex_program",             F(ARB_vertex_program) },
    { OFF, "GL_ARB_vertex_shader",              F(ARB_vertex_shader) },
    { ON,  "GL_ARB_window_pos",                 F(ARB_window_pos) },
@@ -86,7 +96,7 @@ static const struct {
    { OFF, "GL_EXT_blend_logic_op",             F(EXT_blend_logic_op) },
    { OFF, "GL_EXT_blend_minmax",               F(EXT_blend_minmax) },
    { OFF, "GL_EXT_blend_subtract",             F(EXT_blend_subtract) },
-   { ON,  "GL_EXT_clip_volume_hint",           F(EXT_clip_volume_hint) },
+   { OFF, "GL_EXT_clip_volume_hint",           F(EXT_clip_volume_hint) },
    { OFF, "GL_EXT_cull_vertex",                F(EXT_cull_vertex) },
    { ON,  "GL_EXT_compiled_vertex_array",      F(EXT_compiled_vertex_array) },
    { OFF, "GL_EXT_convolution",                F(EXT_convolution) },
@@ -98,13 +108,14 @@ static const struct {
    { OFF, "GL_EXT_fog_coord",                  F(EXT_fog_coord) },
    { OFF, "GL_EXT_gpu_program_parameters",     F(EXT_gpu_program_parameters) },
    { OFF, "GL_EXT_histogram",                  F(EXT_histogram) },
-   { OFF, "GL_EXT_multi_draw_arrays",          F(EXT_multi_draw_arrays) },
+   { ON,  "GL_EXT_multi_draw_arrays",          F(EXT_multi_draw_arrays) },
    { OFF, "GL_EXT_packed_depth_stencil",       F(EXT_packed_depth_stencil) },
    { ON,  "GL_EXT_packed_pixels",              F(EXT_packed_pixels) },
    { OFF, "GL_EXT_paletted_texture",           F(EXT_paletted_texture) },
    { OFF, "GL_EXT_pixel_buffer_object",        F(EXT_pixel_buffer_object) },
    { OFF, "GL_EXT_point_parameters",           F(EXT_point_parameters) },
    { ON,  "GL_EXT_polygon_offset",             F(EXT_polygon_offset) },
+   { OFF, "GL_EXT_provoking_vertex",           F(EXT_provoking_vertex) },
    { ON,  "GL_EXT_rescale_normal",             F(EXT_rescale_normal) },
    { OFF, "GL_EXT_secondary_color",            F(EXT_secondary_color) },
    { ON,  "GL_EXT_separate_specular_color",    F(EXT_separate_specular_color) },
@@ -126,33 +137,38 @@ static const struct {
    { ON,  "GL_EXT_texture_object",             F(EXT_texture_object) },
    { OFF, "GL_EXT_texture_rectangle",          F(NV_texture_rectangle) },
    { OFF, "GL_EXT_texture_sRGB",               F(EXT_texture_sRGB) },
+   { OFF, "GL_EXT_texture_swizzle",            F(EXT_texture_swizzle) },
    { OFF, "GL_EXT_timer_query",                F(EXT_timer_query) },
    { ON,  "GL_EXT_vertex_array",               F(EXT_vertex_array) },
+   { OFF, "GL_EXT_vertex_array_bgra",          F(EXT_vertex_array_bgra) },
    { OFF, "GL_EXT_vertex_array_set",           F(EXT_vertex_array_set) },
    { OFF, "GL_3DFX_texture_compression_FXT1",  F(TDFX_texture_compression_FXT1) },
    { OFF, "GL_APPLE_client_storage",           F(APPLE_client_storage) },
    { ON,  "GL_APPLE_packed_pixels",            F(APPLE_packed_pixels) },
    { OFF, "GL_APPLE_vertex_array_object",      F(APPLE_vertex_array_object) },
    { OFF, "GL_ATI_blend_equation_separate",    F(EXT_blend_equation_separate) },
+   { OFF, "GL_ATI_envmap_bumpmap",             F(ATI_envmap_bumpmap) },
    { OFF, "GL_ATI_texture_env_combine3",       F(ATI_texture_env_combine3)},
    { OFF, "GL_ATI_texture_mirror_once",        F(ATI_texture_mirror_once)},
    { OFF, "GL_ATI_fragment_shader",            F(ATI_fragment_shader)},
    { OFF, "GL_ATI_separate_stencil",           F(ATI_separate_stencil)},
-   { OFF, "GL_IBM_multimode_draw_arrays",      F(IBM_multimode_draw_arrays) },
+   { ON,  "GL_IBM_multimode_draw_arrays",      F(IBM_multimode_draw_arrays) },
    { ON,  "GL_IBM_rasterpos_clip",             F(IBM_rasterpos_clip) },
    { OFF, "GL_IBM_texture_mirrored_repeat",    F(ARB_texture_mirrored_repeat)},
    { OFF, "GL_INGR_blend_func_separate",       F(EXT_blend_func_separate) },
    { OFF, "GL_MESA_pack_invert",               F(MESA_pack_invert) },
    { OFF, "GL_MESA_packed_depth_stencil",      F(MESA_packed_depth_stencil) },
-   { OFF, "GL_MESA_program_debug",             F(MESA_program_debug) },
    { OFF, "GL_MESA_resize_buffers",            F(MESA_resize_buffers) },
    { OFF, "GL_MESA_texture_array",             F(MESA_texture_array) },
+   { OFF, "GL_MESA_texture_signed_rgba",       F(MESA_texture_signed_rgba) },
    { OFF, "GL_MESA_ycbcr_texture",             F(MESA_ycbcr_texture) },
    { ON,  "GL_MESA_window_pos",                F(ARB_window_pos) },
    { OFF, "GL_NV_blend_square",                F(NV_blend_square) },
+   { OFF, "GL_NV_depth_clamp",                 F(ARB_depth_clamp) },
    { OFF, "GL_NV_fragment_program",            F(NV_fragment_program) },
    { ON,  "GL_NV_light_max_exponent",          F(NV_light_max_exponent) },
    { OFF, "GL_NV_point_sprite",                F(NV_point_sprite) },
+   { OFF, "GL_NV_texture_env_combine4",        F(NV_texture_env_combine4) },
    { OFF, "GL_NV_texture_rectangle",           F(NV_texture_rectangle) },
    { ON,  "GL_NV_texgen_reflection",           F(NV_texgen_reflection) },
    { OFF, "GL_NV_vertex_program",              F(NV_vertex_program) },
@@ -165,11 +181,14 @@ static const struct {
    { OFF, "GL_SGIS_texture_border_clamp",      F(ARB_texture_border_clamp) },
    { ON,  "GL_SGIS_texture_edge_clamp",        F(SGIS_texture_edge_clamp) },
    { ON,  "GL_SGIS_texture_lod",               F(SGIS_texture_lod) },
-   { OFF, "GL_SGIX_depth_texture",             F(ARB_depth_texture) },
-   { OFF, "GL_SGIX_shadow",                    F(SGIX_shadow) },
-   { OFF, "GL_SGIX_shadow_ambient",            F(SGIX_shadow_ambient) },
-   { OFF, "GL_SUN_multi_draw_arrays",          F(EXT_multi_draw_arrays) },
+   { ON,  "GL_SUN_multi_draw_arrays",          F(EXT_multi_draw_arrays) },
    { OFF, "GL_S3_s3tc",                        F(S3_s3tc) },
+#if FEATURE_OES_draw_texture
+   { OFF, "GL_OES_draw_texture",               F(OES_draw_texture) },
+#endif /* FEATURE_OES_draw_texture */
+#if FEATURE_OES_EGL_image
+   { OFF, "GL_OES_EGL_image",                  F(OES_EGL_image) },
+#endif
 };
 
 
@@ -181,8 +200,11 @@ static const struct {
 void
 _mesa_enable_sw_extensions(GLcontext *ctx)
 {
+   ctx->Extensions.ARB_copy_buffer = GL_TRUE;
+   ctx->Extensions.ARB_depth_clamp = GL_TRUE;
    ctx->Extensions.ARB_depth_texture = GL_TRUE;
-   ctx->Extensions.ARB_draw_buffers = GL_TRUE;
+   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
+   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 #if FEATURE_ARB_fragment_program
    ctx->Extensions.ARB_fragment_program = GL_TRUE;
    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
@@ -190,10 +212,14 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
 #if FEATURE_ARB_fragment_shader
    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 #endif
+#if FEATURE_ARB_framebuffer_object
+   ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
+#endif
    ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
    ctx->Extensions.ARB_imaging = GL_TRUE;
+   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
    ctx->Extensions.ARB_multitexture = GL_TRUE;
-#if FEATURE_ARB_occlusion_query
+#if FEATURE_queryobj
    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
 #endif
    ctx->Extensions.ARB_point_sprite = GL_TRUE;
@@ -204,9 +230,10 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
    ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
 #endif
 #if FEATURE_ARB_shading_language_120
-   ctx->Extensions.ARB_shading_language_120 = GL_FALSE; /* not quite done */
+   ctx->Extensions.ARB_shading_language_120 = GL_TRUE;
 #endif
    ctx->Extensions.ARB_shadow = GL_TRUE;
+   ctx->Extensions.ARB_shadow_ambient = GL_TRUE;
    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
@@ -215,6 +242,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
    /*ctx->Extensions.ARB_texture_float = GL_TRUE;*/
    ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
+   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;
 #if FEATURE_ARB_vertex_program
    ctx->Extensions.ARB_vertex_program = GL_TRUE;
 #endif
@@ -222,9 +250,13 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 #endif
 #if FEATURE_ARB_vertex_buffer_object
-   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;
+   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/
+#endif
+#if FEATURE_ARB_sync
+   ctx->Extensions.ARB_sync = GL_TRUE;
 #endif
    ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;
+   ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE;
 #if FEATURE_ATI_fragment_shader
    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
 #endif
@@ -247,18 +279,19 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
    ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
 #endif
    ctx->Extensions.EXT_histogram = GL_TRUE;
-   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;
+   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/
    ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
    ctx->Extensions.EXT_paletted_texture = GL_TRUE;
 #if FEATURE_EXT_pixel_buffer_object
    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
 #endif
    ctx->Extensions.EXT_point_parameters = GL_TRUE;
+   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
    ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
    ctx->Extensions.EXT_secondary_color = GL_TRUE;
    ctx->Extensions.EXT_shared_texture_palette = GL_TRUE;
    ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
-   ctx->Extensions.EXT_stencil_two_side = GL_FALSE; /* obsolete */
+   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
    ctx->Extensions.EXT_texture_env_add = GL_TRUE;
    ctx->Extensions.EXT_texture_env_combine = GL_TRUE;
    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
@@ -267,17 +300,17 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
 #if FEATURE_EXT_texture_sRGB
    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 #endif
-   ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;
+   ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
+   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
+   /*ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;*/
    ctx->Extensions.MESA_pack_invert = GL_TRUE;
-#if FEATURE_MESA_program_debug
-   ctx->Extensions.MESA_program_debug = GL_TRUE;
-#endif
    ctx->Extensions.MESA_resize_buffers = GL_TRUE;
    ctx->Extensions.MESA_texture_array = GL_TRUE;
    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
    ctx->Extensions.NV_blend_square = GL_TRUE;
    /*ctx->Extensions.NV_light_max_exponent = GL_TRUE;*/
    ctx->Extensions.NV_point_sprite = GL_TRUE;
+   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
    /*ctx->Extensions.NV_texgen_reflection = GL_TRUE;*/
 #if FEATURE_NV_vertex_program
@@ -292,8 +325,6 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
    ctx->Extensions.SGI_texture_color_table = GL_TRUE;
    ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;
    ctx->Extensions.SGIS_texture_edge_clamp = GL_TRUE;
-   ctx->Extensions.SGIX_shadow = GL_TRUE;
-   ctx->Extensions.SGIX_shadow_ambient = GL_TRUE;
 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
 #endif
@@ -335,10 +366,10 @@ _mesa_enable_imaging_extensions(GLcontext *ctx)
 void
 _mesa_enable_1_3_extensions(GLcontext *ctx)
 {
-   ctx->Extensions.ARB_multisample = GL_TRUE;
+   /*ctx->Extensions.ARB_multisample = GL_TRUE;*/
    ctx->Extensions.ARB_multitexture = GL_TRUE;
    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
-   ctx->Extensions.ARB_texture_compression = GL_TRUE;
+   /*ctx->Extensions.ARB_texture_compression = GL_TRUE;*/
    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
@@ -365,7 +396,7 @@ _mesa_enable_1_4_extensions(GLcontext *ctx)
    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
    ctx->Extensions.EXT_blend_subtract = GL_TRUE;
    ctx->Extensions.EXT_fog_coord = GL_TRUE;
-   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;
+   /*ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;*/
    ctx->Extensions.EXT_point_parameters = GL_TRUE;
    ctx->Extensions.EXT_secondary_color = GL_TRUE;
    ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
@@ -382,7 +413,7 @@ void
 _mesa_enable_1_5_extensions(GLcontext *ctx)
 {
    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
-   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;
+   /*ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;*/
    ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
 }
 
@@ -394,11 +425,12 @@ _mesa_enable_1_5_extensions(GLcontext *ctx)
 void
 _mesa_enable_2_0_extensions(GLcontext *ctx)
 {
-   ctx->Extensions.ARB_draw_buffers = GL_TRUE;
+   /*ctx->Extensions.ARB_draw_buffers = GL_TRUE;*/
 #if FEATURE_ARB_fragment_shader
    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 #endif
    ctx->Extensions.ARB_point_sprite = GL_TRUE;
+   ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
 #if FEATURE_ARB_shader_objects
    ctx->Extensions.ARB_shader_objects = GL_TRUE;
@@ -406,7 +438,7 @@ _mesa_enable_2_0_extensions(GLcontext *ctx)
 #if FEATURE_ARB_shading_language_100
    ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
 #endif
-   ctx->Extensions.EXT_stencil_two_side = GL_FALSE; /* obsolete */
+   ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
 #if FEATURE_ARB_vertex_shader
    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 #endif
@@ -427,7 +459,7 @@ _mesa_enable_2_1_extensions(GLcontext *ctx)
    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 #endif
 #ifdef FEATURE_ARB_shading_language_120
-   ctx->Extensions.ARB_shading_language_120 = GL_FALSE; /* not quite done */
+   ctx->Extensions.ARB_shading_language_120 = GL_TRUE;
 #endif
 }
 
@@ -435,8 +467,9 @@ _mesa_enable_2_1_extensions(GLcontext *ctx)
 
 /**
  * Either enable or disable the named extension.
+ * \return GL_TRUE for success, GL_FALSE if invalid extension name
  */
-static void
+static GLboolean
 set_extension( GLcontext *ctx, const char *name, GLboolean state )
 {
    GLboolean *base = (GLboolean *) &ctx->Extensions;
@@ -445,7 +478,7 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state )
    if (ctx->Extensions.String) {
       /* The string was already queried - can't change it now! */
       _mesa_problem(ctx, "Trying to enable/disable extension after glGetString(GL_EXTENSIONS): %s", name);
-      return;
+      return GL_FALSE;
    }
 
    for (i = 0 ; i < Elements(default_extensions) ; i++) {
@@ -454,10 +487,10 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state )
             GLboolean *enabled = base + default_extensions[i].flag_offset;
             *enabled = state;
          }
-         return;
+         return GL_TRUE;
       }
    }
-   _mesa_problem(ctx, "Trying to enable unknown extension: %s", name);
+   return GL_FALSE;
 }
 
 
@@ -468,7 +501,8 @@ set_extension( GLcontext *ctx, const char *name, GLboolean state )
 void
 _mesa_enable_extension( GLcontext *ctx, const char *name )
 {
-   set_extension(ctx, name, GL_TRUE);
+   if (!set_extension(ctx, name, GL_TRUE))
+      _mesa_problem(ctx, "Trying to enable unknown extension: %s", name);
 }
 
 
@@ -479,7 +513,8 @@ _mesa_enable_extension( GLcontext *ctx, const char *name )
 void
 _mesa_disable_extension( GLcontext *ctx, const char *name )
 {
-   set_extension(ctx, name, GL_FALSE);
+   if (!set_extension(ctx, name, GL_FALSE))
+      _mesa_problem(ctx, "Trying to disable unknown extension: %s", name);
 }
 
 
@@ -504,6 +539,80 @@ _mesa_extension_is_enabled( GLcontext *ctx, const char *name )
 
 
 /**
+ * Append string 'b' onto string 'a'.  Free 'a' and return new string.
+ */
+static char *
+append(const char *a, const char *b)
+{
+   const GLuint aLen = a ? _mesa_strlen(a) : 0;
+   const GLuint bLen = b ? _mesa_strlen(b) : 0;
+   char *s = _mesa_calloc(aLen + bLen + 1);
+   if (s) {
+      if (a)
+         _mesa_memcpy(s, a, aLen);
+      if (b)
+         _mesa_memcpy(s + aLen, b, bLen);
+      s[aLen + bLen] = '\0';
+   }
+   if (a)
+      _mesa_free((void *) a);
+   return s;
+}
+
+
+/**
+ * Check the MESA_EXTENSION_OVERRIDE env var.
+ * For extension names that are recognized, turn them on.  For extension
+ * names that are recognized and prefixed with '-', turn them off.
+ * Return a string of the unknown/leftover names.
+ */
+static const char *
+get_extension_override( GLcontext *ctx )
+{
+   const char *envExt = _mesa_getenv("MESA_EXTENSION_OVERRIDE");
+   char *extraExt = NULL;
+   char ext[1000];
+   GLuint extLen = 0;
+   GLuint i;
+   GLboolean disableExt = GL_FALSE;
+
+   if (!envExt)
+      return NULL;
+
+   for (i = 0; ; i++) {
+      if (envExt[i] == '\0' || envExt[i] == ' ') {
+         /* terminate/process 'ext' if extLen > 0 */
+         if (extLen > 0) {
+            assert(extLen < sizeof(ext));
+            /* enable extension named by 'ext' */
+            ext[extLen] = 0;
+            if (!set_extension(ctx, ext, !disableExt)) {
+               /* unknown extension name, append it to extraExt */
+               if (extraExt) {
+                  extraExt = append(extraExt, " ");
+               }
+               extraExt = append(extraExt, ext);
+            }
+            extLen = 0;
+            disableExt = GL_FALSE;
+         }
+         if (envExt[i] == '\0')
+            break;
+      }
+      else if (envExt[i] == '-') {
+         disableExt = GL_TRUE;
+      }
+      else {
+         /* accumulate this non-space character */
+         ext[extLen++] = envExt[i];
+      }
+   }
+
+   return extraExt;
+}
+
+
+/**
  * Run through the default_extensions array above and set the
  * ctx->Extensions.ARB/EXT_* flags accordingly.
  * To be called during context initialization.
@@ -531,8 +640,9 @@ GLubyte *
 _mesa_make_extension_string( GLcontext *ctx )
 {
    const GLboolean *base = (const GLboolean *) &ctx->Extensions;
+   const char *extraExt = get_extension_override(ctx);
    GLuint extStrLen = 0;
-   GLubyte *s;
+   char *s;
    GLuint i;
 
    /* first, compute length of the extension string */
@@ -542,7 +652,14 @@ _mesa_make_extension_string( GLcontext *ctx )
          extStrLen += (GLuint)_mesa_strlen(default_extensions[i].name) + 1;
       }
    }
-   s = (GLubyte *) _mesa_malloc(extStrLen);
+
+   if (extraExt)
+      extStrLen += _mesa_strlen(extraExt) + 1; /* +1 for space */
+
+   /* allocate the extension string */
+   s = (char *) _mesa_malloc(extStrLen);
+   if (!s)
+      return NULL;
 
    /* second, build the extension string */
    extStrLen = 0;
@@ -552,13 +669,18 @@ _mesa_make_extension_string( GLcontext *ctx )
          GLuint len = (GLuint)_mesa_strlen(default_extensions[i].name);
          _mesa_memcpy(s + extStrLen, default_extensions[i].name, len);
          extStrLen += len;
-         s[extStrLen] = (GLubyte) ' ';
+         s[extStrLen] = ' ';
          extStrLen++;
       }
    }
    ASSERT(extStrLen > 0);
 
-   s[extStrLen - 1] = 0;
+   s[extStrLen - 1] = 0; /* -1 to overwrite trailing the ' ' */
 
-   return s;
+   if (extraExt) {
+      s = append(s, " ");
+      s = append(s, extraExt);
+   }
+
+   return (GLubyte *) s;
 }
diff --git a/src/mesa/main/fbobject.c b/src/mesa/main/fbobject.c
index 876d691c65..877ec00ae4 100644
--- a/src/mesa/main/fbobject.c
+++ b/src/mesa/main/fbobject.c
@@ -3,6 +3,7 @@
  * Version:  7.1
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2009  VMware, Inc.  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"),
@@ -24,6 +25,8 @@
 
 
 /*
+ * GL_EXT/ARB_framebuffer_object extensions
+ *
  * Authors:
  *   Brian Paul
  */
@@ -34,6 +37,7 @@
 #include "fbobject.h"
 #include "framebuffer.h"
 #include "hash.h"
+#include "macros.h"
 #include "mipmap.h"
 #include "renderbuffer.h"
 #include "state.h"
@@ -122,8 +126,22 @@ _mesa_lookup_framebuffer(GLcontext *ctx, GLuint id)
 
 
 /**
+ * Mark the given framebuffer as invalid.  This will force the
+ * test for framebuffer completeness to be done before the framebuffer
+ * is used.
+ */
+static void
+invalidate_framebuffer(struct gl_framebuffer *fb)
+{
+   fb->_Status = 0; /* "indeterminate" */
+}
+
+
+/**
  * Given a GL_*_ATTACHMENTn token, return a pointer to the corresponding
  * gl_renderbuffer_attachment object.
+ * If \p attachment is GL_DEPTH_STENCIL_ATTACHMENT, return a pointer to
+ * the depth buffer attachment point.
  */
 struct gl_renderbuffer_attachment *
 _mesa_get_attachment(GLcontext *ctx, struct gl_framebuffer *fb,
@@ -153,6 +171,8 @@ _mesa_get_attachment(GLcontext *ctx, struct gl_framebuffer *fb,
 	 return NULL;
       }
       return &fb->Attachment[BUFFER_COLOR0 + i];
+   case GL_DEPTH_STENCIL_ATTACHMENT:
+      /* fall-through */
    case GL_DEPTH_ATTACHMENT_EXT:
       return &fb->Attachment[BUFFER_DEPTH];
    case GL_STENCIL_ATTACHMENT_EXT:
@@ -173,7 +193,7 @@ _mesa_remove_attachment(GLcontext *ctx, struct gl_renderbuffer_attachment *att)
    if (att->Type == GL_TEXTURE) {
       ASSERT(att->Texture);
       if (ctx->Driver.FinishRenderTexture) {
-         /* tell driver we're done rendering to this texobj */
+         /* tell driver that we're done rendering to this texture. */
          ctx->Driver.FinishRenderTexture(ctx, att);
       }
       _mesa_reference_texobj(&att->Texture, NULL); /* unbind */
@@ -226,6 +246,8 @@ _mesa_set_texture_attachment(GLcontext *ctx,
    if (att->Texture->Image[att->CubeMapFace][att->TextureLevel]) {
       ctx->Driver.RenderTexture(ctx, fb, att);
    }
+
+   invalidate_framebuffer(fb);
 }
 
 
@@ -263,16 +285,38 @@ _mesa_framebuffer_renderbuffer(GLcontext *ctx, struct gl_framebuffer *fb,
    ASSERT(att);
    if (rb) {
       _mesa_set_renderbuffer_attachment(ctx, att, rb);
+      if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+         /* do stencil attachment here (depth already done above) */
+         att = _mesa_get_attachment(ctx, fb, GL_STENCIL_ATTACHMENT_EXT);
+         assert(att);
+         _mesa_set_renderbuffer_attachment(ctx, att, rb);
+      }
    }
    else {
       _mesa_remove_attachment(ctx, att);
    }
 
+   invalidate_framebuffer(fb);
+
    _glthread_UNLOCK_MUTEX(fb->Mutex);
 }
 
 
 /**
+ * For debug only.
+ */
+static void
+att_incomplete(const char *msg)
+{
+#if 0
+   _mesa_printf("attachment incomplete: %s\n", msg);
+#else
+   (void) msg;
+#endif
+}
+
+
+/**
  * Test if an attachment point is complete and update its Complete field.
  * \param format if GL_COLOR, this is a color attachment point,
  *               if GL_DEPTH, this is a depth component attachment point,
@@ -293,20 +337,26 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
       struct gl_texture_image *texImage;
 
       if (!texObj) {
+         att_incomplete("no texobj");
          att->Complete = GL_FALSE;
          return;
       }
 
       texImage = texObj->Image[att->CubeMapFace][att->TextureLevel];
       if (!texImage) {
+         att_incomplete("no teximage");
          att->Complete = GL_FALSE;
          return;
       }
       if (texImage->Width < 1 || texImage->Height < 1) {
+         att_incomplete("teximage width/height=0");
+         _mesa_printf("texobj = %u\n", texObj->Name);
+         _mesa_printf("level = %d\n", att->TextureLevel);
          att->Complete = GL_FALSE;
          return;
       }
       if (texObj->Target == GL_TEXTURE_3D && att->Zoffset >= texImage->Depth) {
+         att_incomplete("bad z offset");
          att->Complete = GL_FALSE;
          return;
       }
@@ -314,6 +364,12 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
       if (format == GL_COLOR) {
          if (texImage->TexFormat->BaseFormat != GL_RGB &&
              texImage->TexFormat->BaseFormat != GL_RGBA) {
+            att_incomplete("bad format");
+            att->Complete = GL_FALSE;
+            return;
+         }
+         if (texImage->TexFormat->TexelBytes == 0) {
+            att_incomplete("compressed internalformat");
             att->Complete = GL_FALSE;
             return;
          }
@@ -323,18 +379,30 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
             /* OK */
          }
          else if (ctx->Extensions.EXT_packed_depth_stencil &&
+                  ctx->Extensions.ARB_depth_texture &&
                   texImage->TexFormat->BaseFormat == GL_DEPTH_STENCIL_EXT) {
             /* OK */
          }
          else {
             att->Complete = GL_FALSE;
+            att_incomplete("bad depth format");
             return;
          }
       }
       else {
-         /* no such thing as stencil textures */
-         att->Complete = GL_FALSE;
-         return;
+         ASSERT(format == GL_STENCIL);
+         ASSERT(att->Renderbuffer->StencilBits);
+         if (ctx->Extensions.EXT_packed_depth_stencil &&
+             ctx->Extensions.ARB_depth_texture &&
+             att->Renderbuffer->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
+            /* OK */
+         }
+         else {
+            /* no such thing as stencil-only textures */
+            att_incomplete("illegal stencil texture");
+            att->Complete = GL_FALSE;
+            return;
+         }
       }
    }
    else if (att->Type == GL_RENDERBUFFER_EXT) {
@@ -342,45 +410,51 @@ test_attachment_completeness(const GLcontext *ctx, GLenum format,
       if (!att->Renderbuffer->InternalFormat ||
           att->Renderbuffer->Width < 1 ||
           att->Renderbuffer->Height < 1) {
+         att_incomplete("0x0 renderbuffer");
          att->Complete = GL_FALSE;
          return;
       }
       if (format == GL_COLOR) {
          if (att->Renderbuffer->_BaseFormat != GL_RGB &&
              att->Renderbuffer->_BaseFormat != GL_RGBA) {
-            ASSERT(att->Renderbuffer->RedBits);
-            ASSERT(att->Renderbuffer->GreenBits);
-            ASSERT(att->Renderbuffer->BlueBits);
+            att_incomplete("bad renderbuffer color format");
             att->Complete = GL_FALSE;
             return;
          }
+         ASSERT(att->Renderbuffer->RedBits);
+         ASSERT(att->Renderbuffer->GreenBits);
+         ASSERT(att->Renderbuffer->BlueBits);
       }
       else if (format == GL_DEPTH) {
-         ASSERT(att->Renderbuffer->DepthBits);
          if (att->Renderbuffer->_BaseFormat == GL_DEPTH_COMPONENT) {
+            ASSERT(att->Renderbuffer->DepthBits);
             /* OK */
          }
          else if (ctx->Extensions.EXT_packed_depth_stencil &&
                   att->Renderbuffer->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
+            ASSERT(att->Renderbuffer->DepthBits);
             /* OK */
          }
          else {
+            att_incomplete("bad renderbuffer depth format");
             att->Complete = GL_FALSE;
             return;
          }
       }
       else {
          assert(format == GL_STENCIL);
-         ASSERT(att->Renderbuffer->StencilBits);
          if (att->Renderbuffer->_BaseFormat == GL_STENCIL_INDEX) {
+            ASSERT(att->Renderbuffer->StencilBits);
             /* OK */
          }
          else if (ctx->Extensions.EXT_packed_depth_stencil &&
                   att->Renderbuffer->_BaseFormat == GL_DEPTH_STENCIL_EXT) {
+            ASSERT(att->Renderbuffer->StencilBits);
             /* OK */
          }
          else {
             att->Complete = GL_FALSE;
+            att_incomplete("bad renderbuffer stencil format");
             return;
          }
       }
@@ -410,15 +484,18 @@ fbo_incomplete(const char *msg, int index)
 /**
  * Test if the given framebuffer object is complete and update its
  * Status field with the results.
+ * Calls the ctx->Driver.ValidateFramebuffer() function to allow the
+ * driver to make hardware-specific validation/completeness checks.
  * Also update the framebuffer's Width and Height fields if the
  * framebuffer is complete.
  */
 void
 _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
 {
-   GLuint numImages, width = 0, height = 0;
-   GLenum intFormat = GL_NONE;
-   GLuint w = 0, h = 0;
+   GLuint numImages;
+   GLenum intFormat = GL_NONE; /* color buffers' internal format */
+   GLuint minWidth = ~0, minHeight = ~0, maxWidth = 0, maxHeight = 0;
+   GLint numSamples = -1;
    GLint i;
    GLuint j;
 
@@ -428,11 +505,22 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
    fb->Width = 0;
    fb->Height = 0;
 
-   /* Start at -2 to more easily loop over all attachment points */
+   /* Start at -2 to more easily loop over all attachment points.
+    *  -2: depth buffer
+    *  -1: stencil buffer
+    * >=0: color buffer
+    */
    for (i = -2; i < (GLint) ctx->Const.MaxColorAttachments; i++) {
       struct gl_renderbuffer_attachment *att;
       GLenum f;
 
+      /*
+       * XXX for ARB_fbo, only check color buffers that are named by
+       * GL_READ_BUFFER and GL_DRAW_BUFFERi.
+       */
+
+      /* check for attachment completeness
+       */
       if (i == -2) {
          att = &fb->Attachment[BUFFER_DEPTH];
          test_attachment_completeness(ctx, GL_DEPTH, att);
@@ -461,11 +549,15 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
          }
       }
 
+      /* get width, height, format of the renderbuffer/texture
+       */
       if (att->Type == GL_TEXTURE) {
          const struct gl_texture_image *texImg
             = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
-         w = texImg->Width;
-         h = texImg->Height;
+         minWidth = MIN2(minWidth, texImg->Width);
+         maxWidth = MAX2(maxWidth, texImg->Width);
+         minHeight = MIN2(minHeight, texImg->Height);
+         maxHeight = MAX2(maxHeight, texImg->Height);
          f = texImg->_BaseFormat;
          numImages++;
          if (f != GL_RGB && f != GL_RGBA && f != GL_DEPTH_COMPONENT
@@ -476,8 +568,10 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
          }
       }
       else if (att->Type == GL_RENDERBUFFER_EXT) {
-         w = att->Renderbuffer->Width;
-         h = att->Renderbuffer->Height;
+         minWidth = MIN2(minWidth, att->Renderbuffer->Width);
+         maxWidth = MAX2(minWidth, att->Renderbuffer->Width);
+         minHeight = MIN2(minHeight, att->Renderbuffer->Height);
+         maxHeight = MAX2(minHeight, att->Renderbuffer->Height);
          f = att->Renderbuffer->InternalFormat;
          numImages++;
       }
@@ -486,25 +580,41 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
          continue;
       }
 
+      if (numSamples < 0) {
+         /* first buffer */
+         numSamples = att->Renderbuffer->NumSamples;
+      }
+
+      /* Error-check width, height, format, samples
+       */
       if (numImages == 1) {
-         /* set required width, height and format */
-         width = w;
-         height = h;
-         if (i >= 0)
+         /* save format, num samples */
+         if (i >= 0) {
             intFormat = f;
+         }
       }
       else {
-         /* check that width, height, format are same */
-         if (w != width || h != height) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT;
-            fbo_incomplete("width or height mismatch", -1);
-            return;
+         if (!ctx->Extensions.ARB_framebuffer_object) {
+            /* check that width, height, format are same */
+            if (minWidth != maxWidth || minHeight != maxHeight) {
+               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT;
+               fbo_incomplete("width or height mismatch", -1);
+               return;
+            }
+            /* check that all color buffer have same format */
+            if (intFormat != GL_NONE && f != intFormat) {
+               fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;
+               fbo_incomplete("format mismatch", -1);
+               return;
+            }
          }
-         if (intFormat != GL_NONE && f != intFormat) {
-            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;
-            fbo_incomplete("format mismatch", -1);
+         if (att->Renderbuffer &&
+             att->Renderbuffer->NumSamples != numSamples) {
+            fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;
+            fbo_incomplete("inconsistant number of samples", i);
             return;
-         }
+         }            
+
       }
    }
 
@@ -534,6 +644,8 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
          return;
       }
    }
+#else
+   (void) j;
 #endif
 
    if (numImages == 0) {
@@ -542,12 +654,32 @@ _mesa_test_framebuffer_completeness(GLcontext *ctx, struct gl_framebuffer *fb)
       return;
    }
 
-   /*
-    * If we get here, the framebuffer is complete!
-    */
+   /* Provisionally set status = COMPLETE ... */
    fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
-   fb->Width = w;
-   fb->Height = h;
+
+   /* ... but the driver may say the FB is incomplete.
+    * Drivers will most likely set the status to GL_FRAMEBUFFER_UNSUPPORTED
+    * if anything.
+    */
+   if (ctx->Driver.ValidateFramebuffer) {
+      ctx->Driver.ValidateFramebuffer(ctx, fb);
+      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+         fbo_incomplete("driver marked FBO as incomplete", -1);
+      }
+   }
+
+   if (fb->_Status == GL_FRAMEBUFFER_COMPLETE_EXT) {
+      /*
+       * Note that if ARB_framebuffer_object is supported and the attached
+       * renderbuffers/textures are different sizes, the framebuffer
+       * width/height will be set to the smallest width/height.
+       */
+      fb->Width = minWidth;
+      fb->Height = minHeight;
+
+      /* finally, update the visual info for the framebuffer */
+      _mesa_update_framebuffer_visual(fb);
+   }
 }
 
 
@@ -579,7 +711,7 @@ _mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
       return;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    /* The above doesn't fully flush the drivers in the way that a
     * glFlush does, but that is required here:
     */
@@ -593,6 +725,12 @@ _mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
          /* ID was reserved, but no real renderbuffer object made yet */
          newRb = NULL;
       }
+      else if (!newRb && ctx->Extensions.ARB_framebuffer_object) {
+         /* All RB IDs must be Gen'd */
+         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindRenderbuffer(buffer)");
+         return;
+      }
+
       if (!newRb) {
 	 /* create new renderbuffer object */
 	 newRb = ctx->Driver.NewRenderbuffer(ctx, renderbuffer);
@@ -615,6 +753,27 @@ _mesa_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
 }
 
 
+/**
+ * If the given renderbuffer is anywhere attached to the framebuffer, detach
+ * the renderbuffer.
+ * This is used when a renderbuffer object is deleted.
+ * The spec calls for unbinding.
+ */
+static void
+detach_renderbuffer(GLcontext *ctx,
+                    struct gl_framebuffer *fb,
+                    struct gl_renderbuffer *rb)
+{
+   GLuint i;
+   for (i = 0; i < BUFFER_COUNT; i++) {
+      if (fb->Attachment[i].Renderbuffer == rb) {
+         _mesa_remove_attachment(ctx, &fb->Attachment[i]);
+      }
+   }
+   invalidate_framebuffer(fb);
+}
+
+
 void GLAPIENTRY
 _mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)
 {
@@ -636,6 +795,13 @@ _mesa_DeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)
                _mesa_BindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
             }
 
+            if (ctx->DrawBuffer->Name) {
+               detach_renderbuffer(ctx, ctx->DrawBuffer, rb);
+            }
+            if (ctx->ReadBuffer->Name && ctx->ReadBuffer != ctx->DrawBuffer) {
+               detach_renderbuffer(ctx, ctx->ReadBuffer, rb);
+            }
+
 	    /* Remove from hash table immediately, to free the ID.
              * But the object will not be freed until it's no longer
              * referenced anywhere else.
@@ -737,10 +903,21 @@ _mesa_base_fbo_format(GLcontext *ctx, GLenum internalFormat)
 }
 
 
-void GLAPIENTRY
-_mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
-                             GLsizei width, GLsizei height)
+/** sentinal value, see below */
+#define NO_SAMPLES 1000
+
+
+/**
+ * Helper function used by _mesa_RenderbufferStorageEXT() and 
+ * _mesa_RenderbufferStorageMultisample().
+ * samples will be NO_SAMPLES if called by _mesa_RenderbufferStorageEXT().
+ */
+static void
+renderbuffer_storage(GLenum target, GLenum internalFormat,
+                     GLsizei width, GLsizei height, GLsizei samples)
 {
+   const char *func = samples == NO_SAMPLES ?
+      "glRenderbufferStorage" : "RenderbufferStorageMultisample";
    struct gl_renderbuffer *rb;
    GLenum baseFormat;
    GET_CURRENT_CONTEXT(ctx);
@@ -748,31 +925,39 @@ _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (target != GL_RENDERBUFFER_EXT) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glRenderbufferStorageEXT(target)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", func);
       return;
    }
 
    baseFormat = _mesa_base_fbo_format(ctx, internalFormat);
    if (baseFormat == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glRenderbufferStorageEXT(internalFormat)");
+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(internalFormat)", func);
       return;
    }
 
    if (width < 1 || width > (GLsizei) ctx->Const.MaxRenderbufferSize) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glRenderbufferStorageEXT(width)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(width)", func);
       return;
    }
 
    if (height < 1 || height > (GLsizei) ctx->Const.MaxRenderbufferSize) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glRenderbufferStorageEXT(height)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(height)", func);
       return;
    }
 
-   rb = ctx->CurrentRenderbuffer;
+   if (samples == NO_SAMPLES) {
+      /* NumSamples == 0 indicates non-multisampling */
+      samples = 0;
+   }
+   else if (samples > ctx->Const.MaxSamples) {
+      /* note: driver may choose to use more samples than what's requested */
+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(samples)", func);
+      return;
+   }
 
+   rb = ctx->CurrentRenderbuffer;
    if (!rb) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glRenderbufferStorageEXT");
+      _mesa_error(ctx, GL_INVALID_OPERATION, func);
       return;
    }
 
@@ -794,6 +979,7 @@ _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
    rb->IndexBits =
    rb->DepthBits =
    rb->StencilBits = 0;
+   rb->NumSamples = samples;
 
    /* Now allocate the storage */
    ASSERT(rb->AllocStorage);
@@ -820,7 +1006,8 @@ _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
       rb->AlphaBits =
       rb->IndexBits =
       rb->DepthBits =
-      rb->StencilBits = 0;
+      rb->StencilBits =
+      rb->NumSamples = 0;
    }
 
    /*
@@ -833,8 +1020,31 @@ _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
 
 
 void GLAPIENTRY
+_mesa_RenderbufferStorageEXT(GLenum target, GLenum internalFormat,
+                             GLsizei width, GLsizei height)
+{
+   /* GL_ARB_fbo says calling this function is equivalent to calling
+    * glRenderbufferStorageMultisample() with samples=0.  We pass in
+    * a token value here just for error reporting purposes.
+    */
+   renderbuffer_storage(target, internalFormat, width, height, NO_SAMPLES);
+}
+
+
+void GLAPIENTRY
+_mesa_RenderbufferStorageMultisample(GLenum target, GLsizei samples,
+                                     GLenum internalFormat,
+                                     GLsizei width, GLsizei height)
+{
+   renderbuffer_storage(target, internalFormat, width, height, samples);
+}
+
+
+
+void GLAPIENTRY
 _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
 {
+   struct gl_renderbuffer *rb;
    GET_CURRENT_CONTEXT(ctx);
 
    ASSERT_OUTSIDE_BEGIN_END(ctx);
@@ -845,7 +1055,8 @@ _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
       return;
    }
 
-   if (!ctx->CurrentRenderbuffer) {
+   rb = ctx->CurrentRenderbuffer;
+   if (!rb) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glGetRenderbufferParameterivEXT");
       return;
@@ -855,32 +1066,38 @@ _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
 
    switch (pname) {
    case GL_RENDERBUFFER_WIDTH_EXT:
-      *params = ctx->CurrentRenderbuffer->Width;
+      *params = rb->Width;
       return;
    case GL_RENDERBUFFER_HEIGHT_EXT:
-      *params = ctx->CurrentRenderbuffer->Height;
+      *params = rb->Height;
       return;
    case GL_RENDERBUFFER_INTERNAL_FORMAT_EXT:
-      *params = ctx->CurrentRenderbuffer->InternalFormat;
+      *params = rb->InternalFormat;
       return;
    case GL_RENDERBUFFER_RED_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->RedBits;
+      *params = rb->RedBits;
       break;
    case GL_RENDERBUFFER_GREEN_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->GreenBits;
+      *params = rb->GreenBits;
       break;
    case GL_RENDERBUFFER_BLUE_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->BlueBits;
+      *params = rb->BlueBits;
       break;
    case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->AlphaBits;
+      *params = rb->AlphaBits;
       break;
    case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->DepthBits;
+      *params = rb->DepthBits;
       break;
    case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
-      *params = ctx->CurrentRenderbuffer->StencilBits;
+      *params = rb->StencilBits;
       break;
+   case GL_RENDERBUFFER_SAMPLES:
+      if (ctx->Extensions.ARB_framebuffer_object) {
+         *params = rb->NumSamples;
+         break;
+      }
+      /* fallthrough */
    default:
       _mesa_error(ctx, GL_INVALID_ENUM,
                   "glGetRenderbufferParameterivEXT(target)");
@@ -946,6 +1163,13 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
    GLboolean bindReadBuf, bindDrawBuf;
    GET_CURRENT_CONTEXT(ctx);
 
+#ifdef DEBUG
+   if (ctx->Extensions.ARB_framebuffer_object) {
+      ASSERT(ctx->Extensions.EXT_framebuffer_object);
+      ASSERT(ctx->Extensions.EXT_framebuffer_blit);
+   }
+#endif
+
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!ctx->Extensions.EXT_framebuffer_object) {
@@ -982,8 +1206,7 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
       return;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
-
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    if (ctx->Driver.Flush) {  
       ctx->Driver.Flush(ctx);
    }
@@ -995,6 +1218,12 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
          /* ID was reserved, but no real framebuffer object made yet */
          newFb = NULL;
       }
+      else if (!newFb && ctx->Extensions.ARB_framebuffer_object) {
+         /* All FBO IDs must be Gen'd */
+         _mesa_error(ctx, GL_INVALID_OPERATION, "glBindFramebuffer(buffer)");
+         return;
+      }
+
       if (!newFb) {
 	 /* create new framebuffer object */
 	 newFb = ctx->Driver.NewFramebuffer(ctx, framebuffer);
@@ -1018,19 +1247,26 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
    ASSERT(newFb != &DummyFramebuffer);
 
    /*
-    * XXX check if re-binding same buffer and skip some of this code.
+    * OK, now bind the new Draw/Read framebuffers, if they're changing.
     */
 
    if (bindReadBuf) {
-      _mesa_reference_framebuffer(&ctx->ReadBuffer, newFbread);
+      if (ctx->ReadBuffer == newFbread)
+         bindReadBuf = GL_FALSE; /* no change */
+      else
+         _mesa_reference_framebuffer(&ctx->ReadBuffer, newFbread);
    }
 
    if (bindDrawBuf) {
       /* check if old FB had any texture attachments */
-      check_end_texture_render(ctx, ctx->DrawBuffer);
+      if (ctx->DrawBuffer->Name != 0) {
+         check_end_texture_render(ctx, ctx->DrawBuffer);
+      }
 
-      /* check if time to delete this framebuffer */
-      _mesa_reference_framebuffer(&ctx->DrawBuffer, newFb);
+      if (ctx->DrawBuffer == newFb)
+         bindDrawBuf = GL_FALSE; /* no change */
+      else
+         _mesa_reference_framebuffer(&ctx->DrawBuffer, newFb);
 
       if (newFb->Name != 0) {
          /* check if newly bound framebuffer has any texture attachments */
@@ -1038,7 +1274,7 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
       }
    }
 
-   if (ctx->Driver.BindFramebuffer) {
+   if ((bindDrawBuf || bindReadBuf) && ctx->Driver.BindFramebuffer) {
       ctx->Driver.BindFramebuffer(ctx, target, newFb, newFbread);
    }
 }
@@ -1051,7 +1287,7 @@ _mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
    GET_CURRENT_CONTEXT(ctx);
 
    ASSERT_OUTSIDE_BEGIN_END(ctx);
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    /* The above doesn't fully flush the drivers in the way that a
     * glFlush does, but that is required here:
     */
@@ -1069,7 +1305,12 @@ _mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
             if (fb == ctx->DrawBuffer) {
                /* bind default */
                ASSERT(fb->RefCount >= 2);
-               _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+               _mesa_BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
+            }
+            if (fb == ctx->ReadBuffer) {
+               /* bind default */
+               ASSERT(fb->RefCount >= 2);
+               _mesa_BindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
             }
 
 	    /* remove from hash table immediately, to free the ID */
@@ -1079,7 +1320,7 @@ _mesa_DeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
                /* But the object will not be freed until it's no longer
                 * bound in any context.
                 */
-               _mesa_unreference_framebuffer(&fb);
+               _mesa_reference_framebuffer(&fb, NULL);
 	    }
 	 }
       }
@@ -1158,7 +1399,10 @@ _mesa_CheckFramebufferStatusEXT(GLenum target)
 
    FLUSH_VERTICES(ctx, _NEW_BUFFERS);
 
-   _mesa_test_framebuffer_completeness(ctx, buffer);
+   if (buffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
+      _mesa_test_framebuffer_completeness(ctx, buffer);
+   }
+
    return buffer->_Status;
 }
 
@@ -1175,16 +1419,31 @@ framebuffer_texture(GLcontext *ctx, const char *caller, GLenum target,
    struct gl_renderbuffer_attachment *att;
    struct gl_texture_object *texObj = NULL;
    struct gl_framebuffer *fb;
+   GLboolean error = GL_FALSE;
 
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (target != GL_FRAMEBUFFER_EXT) {
+   switch (target) {
+   case GL_READ_FRAMEBUFFER_EXT:
+      error = !ctx->Extensions.EXT_framebuffer_blit;
+      fb = ctx->ReadBuffer;
+      break;
+   case GL_DRAW_FRAMEBUFFER_EXT:
+      error = !ctx->Extensions.EXT_framebuffer_blit;
+      /* fall-through */
+   case GL_FRAMEBUFFER_EXT:
+      fb = ctx->DrawBuffer;
+      break;
+   default:
+      error = GL_TRUE;
+   }
+
+   if (error) {
       _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glFramebufferTexture%sEXT(target)", caller);
+                  "glFramebufferTexture%sEXT(target=0x%x)", caller, target);
       return;
    }
 
-   fb = ctx->DrawBuffer;
    ASSERT(fb);
 
    /* check framebuffer binding */
@@ -1239,7 +1498,6 @@ framebuffer_texture(GLcontext *ctx, const char *caller, GLenum target,
          }
       }
 
-
       if ((level < 0) || 
           (level >= _mesa_max_texture_levels(ctx, texObj->Target))) {
          _mesa_error(ctx, GL_INVALID_VALUE,
@@ -1255,7 +1513,19 @@ framebuffer_texture(GLcontext *ctx, const char *caller, GLenum target,
       return;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+   if (texObj && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      /* the texture format must be depth+stencil */
+      const struct gl_texture_image *texImg;
+      texImg = texObj->Image[0][texObj->BaseLevel];
+      if (!texImg || texImg->_BaseFormat != GL_DEPTH_STENCIL) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glFramebufferTexture%sEXT(texture is not"
+                     " DEPTH_STENCIL format)", caller);
+         return;
+      }
+   }
+
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    /* The above doesn't fully flush the drivers in the way that a
     * glFlush does, but that is required here:
     */
@@ -1266,10 +1536,22 @@ framebuffer_texture(GLcontext *ctx, const char *caller, GLenum target,
    if (texObj) {
       _mesa_set_texture_attachment(ctx, fb, att, texObj, textarget,
                                    level, zoffset);
+      /* Set the render-to-texture flag.  We'll check this flag in
+       * glTexImage() and friends to determine if we need to revalidate
+       * any FBOs that might be rendering into this texture.
+       * This flag never gets cleared since it's non-trivial to determine
+       * when all FBOs might be done rendering to this texture.  That's OK
+       * though since it's uncommon to render to a texture then repeatedly
+       * call glTexImage() to change images in the texture.
+       */
+      texObj->_RenderToTexture = GL_TRUE;
    }
    else {
       _mesa_remove_attachment(ctx, att);
    }
+
+   invalidate_framebuffer(fb);
+
    _glthread_UNLOCK_MUTEX(fb->Mutex);
 }
 
@@ -1303,7 +1585,7 @@ _mesa_FramebufferTexture2DEXT(GLenum target, GLenum attachment,
        (textarget != GL_TEXTURE_RECTANGLE_ARB) &&
        (!IS_CUBE_FACE(textarget))) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glFramebufferTexture2DEXT(textarget)");
+                  "glFramebufferTexture2DEXT(textarget=0x%x)", textarget);
       return;
    }
 
@@ -1413,7 +1695,18 @@ _mesa_FramebufferRenderbufferEXT(GLenum target, GLenum attachment,
       rb = NULL;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      /* make sure the renderbuffer is a depth/stencil format */
+      if (rb->_BaseFormat != GL_DEPTH_STENCIL) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glFramebufferRenderbufferEXT(renderbuffer"
+                     " is not DEPTH_STENCIL format)");
+         return;
+      }
+   }
+
+
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    /* The above doesn't fully flush the drivers in the way that a
     * glFlush does, but that is required here:
     */
@@ -1481,7 +1774,20 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment,
       return;
    }
 
-   FLUSH_VERTICES(ctx, _NEW_BUFFERS);
+   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+      /* the depth and stencil attachments must point to the same buffer */
+      const struct gl_renderbuffer_attachment *depthAtt, *stencilAtt;
+      depthAtt = _mesa_get_attachment(ctx, buffer, GL_DEPTH_ATTACHMENT);
+      stencilAtt = _mesa_get_attachment(ctx, buffer, GL_STENCIL_ATTACHMENT);
+      if (depthAtt->Renderbuffer != stencilAtt->Renderbuffer) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glGetFramebufferAttachmentParameterivEXT(DEPTH/STENCIL"
+                     " attachments differ)");
+         return;
+      }
+   }
+
+   FLUSH_CURRENT(ctx, _NEW_BUFFERS);
    /* The above doesn't fully flush the drivers in the way that a
     * glFlush does, but that is required here:
     */
@@ -1541,6 +1847,79 @@ _mesa_GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment,
 		     "glGetFramebufferAttachmentParameterivEXT(pname)");
       }
       return;
+   case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->ColorEncoding;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+         return;
+      }
+      else {
+         *params = att->Renderbuffer->ComponentType;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->RedBits;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->GreenBits;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->BlueBits;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->AlphaBits;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->DepthBits;
+      }
+      return;
+   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+      if (!ctx->Extensions.ARB_framebuffer_object) {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glGetFramebufferAttachmentParameterivEXT(pname)");
+      }
+      else {
+         *params = att->Renderbuffer->StencilBits;
+      }
+      return;
    default:
       _mesa_error(ctx, GL_INVALID_ENUM,
                   "glGetFramebufferAttachmentParameterivEXT(pname)");
@@ -1590,11 +1969,22 @@ _mesa_GenerateMipmapEXT(GLenum target)
 
 
 #if FEATURE_EXT_framebuffer_blit
+/**
+ * Blit rectangular region, optionally from one framebuffer to another.
+ *
+ * Note, if the src buffer is multisampled and the dest is not, this is
+ * when the samples must be resolved to a single color.
+ */
 void GLAPIENTRY
 _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
                          GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
                          GLbitfield mask, GLenum filter)
 {
+   const GLbitfield legalMaskBits = (GL_COLOR_BUFFER_BIT |
+                                     GL_DEPTH_BUFFER_BIT |
+                                     GL_STENCIL_BUFFER_BIT);
+   const struct gl_framebuffer *readFb, *drawFb;
+   const struct gl_renderbuffer *colorReadRb, *colorDrawRb;
    GET_CURRENT_CONTEXT(ctx);
 
    ASSERT_OUTSIDE_BEGIN_END(ctx);
@@ -1604,13 +1994,19 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       _mesa_update_state(ctx);
    }
 
-   if (!ctx->ReadBuffer) {
-      /* XXX */
+   readFb = ctx->ReadBuffer;
+   drawFb = ctx->DrawBuffer;
+
+   if (!readFb || !drawFb) {
+      /* This will normally never happen but someday we may want to
+       * support MakeCurrent() with no drawables.
+       */
+      return;
    }
 
    /* check for complete framebuffers */
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||
-       ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+   if (drawFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||
+       readFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
                   "glBlitFramebufferEXT(incomplete draw/read buffers)");
       return;
@@ -1621,9 +2017,7 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       return;
    }
 
-   if (mask & ~(GL_COLOR_BUFFER_BIT |
-                GL_DEPTH_BUFFER_BIT |
-                GL_STENCIL_BUFFER_BIT)) {
+   if (mask & ~legalMaskBits) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glBlitFramebufferEXT(mask)");
       return;
    }
@@ -1636,10 +2030,21 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       return;
    }
 
+   /* get color read/draw renderbuffers */
+   if (mask & GL_COLOR_BUFFER_BIT) {
+      colorReadRb = readFb->_ColorReadBuffer;
+      colorDrawRb = drawFb->_ColorDrawBuffers[0];
+   }
+   else {
+      colorReadRb = colorDrawRb = NULL;
+   }
+
    if (mask & GL_STENCIL_BUFFER_BIT) {
-      struct gl_renderbuffer *readRb = ctx->ReadBuffer->_StencilBuffer;
-      struct gl_renderbuffer *drawRb = ctx->DrawBuffer->_StencilBuffer;
-      if (readRb->StencilBits != drawRb->StencilBits) {
+      struct gl_renderbuffer *readRb = readFb->_StencilBuffer;
+      struct gl_renderbuffer *drawRb = drawFb->_StencilBuffer;
+      if (!readRb ||
+          !drawRb ||
+          readRb->StencilBits != drawRb->StencilBits) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glBlitFramebufferEXT(stencil buffer size mismatch");
          return;
@@ -1647,15 +2052,45 @@ _mesa_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
    }
 
    if (mask & GL_DEPTH_BUFFER_BIT) {
-      struct gl_renderbuffer *readRb = ctx->ReadBuffer->_DepthBuffer;
-      struct gl_renderbuffer *drawRb = ctx->DrawBuffer->_DepthBuffer;
-      if (readRb->DepthBits != drawRb->DepthBits) {
+      struct gl_renderbuffer *readRb = readFb->_DepthBuffer;
+      struct gl_renderbuffer *drawRb = drawFb->_DepthBuffer;
+      if (!readRb ||
+          !drawRb ||
+          readRb->DepthBits != drawRb->DepthBits) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glBlitFramebufferEXT(depth buffer size mismatch");
          return;
       }
    }
 
+   if (readFb->Visual.samples > 0 &&
+       drawFb->Visual.samples > 0 &&
+       readFb->Visual.samples != drawFb->Visual.samples) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glBlitFramebufferEXT(mismatched samples");
+      return;
+   }
+
+   /* extra checks for multisample copies... */
+   if (readFb->Visual.samples > 0 || drawFb->Visual.samples > 0) {
+      /* src and dest region sizes must be the same */
+      if (srcX1 - srcX0 != dstX1 - dstX0 ||
+          srcY1 - srcY0 != dstY1 - dstY0) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                "glBlitFramebufferEXT(bad src/dst multisample region sizes");
+         return;
+      }
+
+      /* color formats must match */
+      if (colorReadRb &&
+          colorDrawRb &&
+          colorReadRb->_ActualFormat != colorDrawRb->_ActualFormat) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                "glBlitFramebufferEXT(bad src/dst multisample pixel formats");
+         return;
+      }
+   }
+
    if (!ctx->Extensions.EXT_framebuffer_blit) {
       _mesa_error(ctx, GL_INVALID_OPERATION, "glBlitFramebufferEXT");
       return;
diff --git a/src/mesa/main/fbobject.h b/src/mesa/main/fbobject.h
index b6154719ab..5409394073 100644
--- a/src/mesa/main/fbobject.h
+++ b/src/mesa/main/fbobject.h
@@ -84,6 +84,11 @@ _mesa_RenderbufferStorageEXT(GLenum target, GLenum internalformat,
                              GLsizei width, GLsizei height);
 
 extern void GLAPIENTRY
+_mesa_RenderbufferStorageMultisample(GLenum target, GLsizei samples,
+                                     GLenum internalformat,
+                                     GLsizei width, GLsizei height);
+
+extern void GLAPIENTRY
 _mesa_GetRenderbufferParameterivEXT(GLenum target, GLenum pname,
                                     GLint *params);
 
diff --git a/src/mesa/main/feedback.c b/src/mesa/main/feedback.c
index 48c2ccbff3..46759dc99e 100644
--- a/src/mesa/main/feedback.c
+++ b/src/mesa/main/feedback.c
@@ -1,13 +1,9 @@
-/**
- * \file feedback.c
- * Selection and feedback modes functions.
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  5.1
+ * Version:  7.5
  *
- * Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -27,6 +23,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+/**
+ * \file feedback.c
+ * Selection and feedback modes functions.
+ */
+
 
 #include "glheader.h"
 #include "colormac.h"
@@ -35,9 +36,10 @@
 #include "feedback.h"
 #include "macros.h"
 #include "mtypes.h"
+#include "glapi/dispatch.h"
 
 
-#if _HAVE_FULL_GL
+#if FEATURE_feedback
 
 
 #define FB_3D		0x01
@@ -110,61 +112,47 @@ _mesa_PassThrough( GLfloat token )
 
    if (ctx->RenderMode==GL_FEEDBACK) {
       FLUSH_VERTICES(ctx, 0);
-      FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
-      FEEDBACK_TOKEN( ctx, token );
+      _mesa_feedback_token( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
+      _mesa_feedback_token( ctx, token );
    }
 }
 
 
-
-/*
+/**
  * Put a vertex into the feedback buffer.
  */
-void _mesa_feedback_vertex( GLcontext *ctx,
-                            const GLfloat win[4],
-                            const GLfloat color[4],
-                            GLfloat index,
-                            const GLfloat texcoord[4] )
+void
+_mesa_feedback_vertex(GLcontext *ctx,
+                      const GLfloat win[4],
+                      const GLfloat color[4],
+                      GLfloat index,
+                      const GLfloat texcoord[4])
 {
-#if 0
-   {
-      /* snap window x, y to fractional pixel position */
-      const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1);
-      GLfixed x, y;
-      x = FloatToFixed(win[0]) & snapMask;
-      y = FloatToFixed(win[1]) & snapMask;
-      FEEDBACK_TOKEN(ctx, FixedToFloat(x));
-      FEEDBACK_TOKEN(ctx, FixedToFloat(y) );
-   }
-#else
-   FEEDBACK_TOKEN( ctx, win[0] );
-   FEEDBACK_TOKEN( ctx, win[1] );
-#endif
+   _mesa_feedback_token( ctx, win[0] );
+   _mesa_feedback_token( ctx, win[1] );
    if (ctx->Feedback._Mask & FB_3D) {
-      FEEDBACK_TOKEN( ctx, win[2] );
+      _mesa_feedback_token( ctx, win[2] );
    }
    if (ctx->Feedback._Mask & FB_4D) {
-      FEEDBACK_TOKEN( ctx, win[3] );
+      _mesa_feedback_token( ctx, win[3] );
    }
    if (ctx->Feedback._Mask & FB_INDEX) {
-      FEEDBACK_TOKEN( ctx, (GLfloat) index );
+      _mesa_feedback_token( ctx, (GLfloat) index );
    }
    if (ctx->Feedback._Mask & FB_COLOR) {
-      FEEDBACK_TOKEN( ctx, color[0] );
-      FEEDBACK_TOKEN( ctx, color[1] );
-      FEEDBACK_TOKEN( ctx, color[2] );
-      FEEDBACK_TOKEN( ctx, color[3] );
+      _mesa_feedback_token( ctx, color[0] );
+      _mesa_feedback_token( ctx, color[1] );
+      _mesa_feedback_token( ctx, color[2] );
+      _mesa_feedback_token( ctx, color[3] );
    }
    if (ctx->Feedback._Mask & FB_TEXTURE) {
-      FEEDBACK_TOKEN( ctx, texcoord[0] );
-      FEEDBACK_TOKEN( ctx, texcoord[1] );
-      FEEDBACK_TOKEN( ctx, texcoord[2] );
-      FEEDBACK_TOKEN( ctx, texcoord[3] );
+      _mesa_feedback_token( ctx, texcoord[0] );
+      _mesa_feedback_token( ctx, texcoord[1] );
+      _mesa_feedback_token( ctx, texcoord[2] );
+      _mesa_feedback_token( ctx, texcoord[3] );
    }
 }
 
-#endif
-
 
 /**********************************************************************/
 /** \name Selection */
@@ -207,17 +195,20 @@ _mesa_SelectBuffer( GLsizei size, GLuint *buffer )
 /**
  * Write a value of a record into the selection buffer.
  * 
- * \param CTX GL context.
- * \param V value.
+ * \param ctx GL context.
+ * \param value value.
  *
  * Verifies there is free space in the buffer to write the value and
  * increments the pointer.
  */
-#define WRITE_RECORD( CTX, V )					\
-	if (CTX->Select.BufferCount < CTX->Select.BufferSize) {	\
-	   CTX->Select.Buffer[CTX->Select.BufferCount] = (V);	\
-	}							\
-	CTX->Select.BufferCount++;
+static INLINE void
+write_record(GLcontext *ctx, GLuint value)
+{
+   if (ctx->Select.BufferCount < ctx->Select.BufferSize) {
+      ctx->Select.Buffer[ctx->Select.BufferCount] = value;
+   }
+   ctx->Select.BufferCount++;
+}
 
 
 /**
@@ -229,7 +220,8 @@ _mesa_SelectBuffer( GLsizei size, GLuint *buffer )
  * Sets gl_selection::HitFlag and updates gl_selection::HitMinZ and
  * gl_selection::HitMaxZ.
  */
-void _mesa_update_hitflag( GLcontext *ctx, GLfloat z )
+void
+_mesa_update_hitflag(GLcontext *ctx, GLfloat z)
 {
    ctx->Select.HitFlag = GL_TRUE;
    if (z < ctx->Select.HitMinZ) {
@@ -252,7 +244,8 @@ void _mesa_update_hitflag( GLcontext *ctx, GLfloat z )
  *
  * \sa gl_selection.
  */
-static void write_hit_record( GLcontext *ctx )
+static void
+write_hit_record(GLcontext *ctx)
 {
    GLuint i;
    GLuint zmin, zmax, zscale = (~0u);
@@ -264,11 +257,11 @@ static void write_hit_record( GLcontext *ctx )
    zmin = (GLuint) ((GLfloat) zscale * ctx->Select.HitMinZ);
    zmax = (GLuint) ((GLfloat) zscale * ctx->Select.HitMaxZ);
 
-   WRITE_RECORD( ctx, ctx->Select.NameStackDepth );
-   WRITE_RECORD( ctx, zmin );
-   WRITE_RECORD( ctx, zmax );
+   write_record( ctx, ctx->Select.NameStackDepth );
+   write_record( ctx, zmin );
+   write_record( ctx, zmax );
    for (i = 0; i < ctx->Select.NameStackDepth; i++) {
-      WRITE_RECORD( ctx, ctx->Select.NameStack[i] );
+      write_record( ctx, ctx->Select.NameStack[i] );
    }
 
    ctx->Select.Hits++;
@@ -512,6 +505,23 @@ _mesa_RenderMode( GLenum mode )
 /*@}*/
 
 
+void 
+_mesa_init_feedback_dispatch(struct _glapi_table *disp)
+{
+   SET_InitNames(disp, _mesa_InitNames);
+   SET_FeedbackBuffer(disp, _mesa_FeedbackBuffer);
+   SET_LoadName(disp, _mesa_LoadName);
+   SET_PassThrough(disp, _mesa_PassThrough);
+   SET_PopName(disp, _mesa_PopName);
+   SET_PushName(disp, _mesa_PushName);
+   SET_SelectBuffer(disp, _mesa_SelectBuffer);
+   SET_RenderMode(disp, _mesa_RenderMode);
+}
+
+
+#endif /* FEATURE_feedback */
+
+
 /**********************************************************************/
 /** \name Initialization */
 /*@{*/
diff --git a/src/mesa/main/feedback.h b/src/mesa/main/feedback.h
index 6c448ad631..6ed1a12525 100644
--- a/src/mesa/main/feedback.h
+++ b/src/mesa/main/feedback.h
@@ -1,13 +1,9 @@
-/**
- * \file feedback.h
- * Selection and feedback modes functions.
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  7.5
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -27,31 +23,40 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
 #ifndef FEEDBACK_H
 #define FEEDBACK_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
+
 
+#if FEATURE_feedback
 
-#define FEEDBACK_TOKEN( CTX, T )				\
-	if (CTX->Feedback.Count < CTX->Feedback.BufferSize) {	\
-	   CTX->Feedback.Buffer[CTX->Feedback.Count] = (GLfloat) (T); \
-	}							\
-	CTX->Feedback.Count++;
+#define _MESA_INIT_FEEDBACK_FUNCTIONS(driver, impl) \
+   do {                                             \
+      (driver)->RenderMode = impl ## RenderMode;    \
+   } while (0)
 
+extern void
+_mesa_feedback_vertex( GLcontext *ctx,
+                       const GLfloat win[4],
+                       const GLfloat color[4],
+                       GLfloat index,
+                       const GLfloat texcoord[4] );
 
-extern void _mesa_init_feedback( GLcontext * ctx );
 
-extern void _mesa_feedback_vertex( GLcontext *ctx,
-                                const GLfloat win[4],
-                                const GLfloat color[4],
-				GLfloat index,
-                                const GLfloat texcoord[4] );
+static INLINE void
+_mesa_feedback_token( GLcontext *ctx, GLfloat token )
+{
+   if (ctx->Feedback.Count < ctx->Feedback.BufferSize) {
+      ctx->Feedback.Buffer[ctx->Feedback.Count] = token;
+   }
+   ctx->Feedback.Count++;
+}
 
 
-extern void _mesa_update_hitflag( GLcontext *ctx, GLfloat z );
+extern void
+_mesa_update_hitflag( GLcontext *ctx, GLfloat z );
 
 
 extern void GLAPIENTRY
@@ -78,5 +83,47 @@ _mesa_PopName( void );
 extern GLint GLAPIENTRY
 _mesa_RenderMode( GLenum mode );
 
+extern void 
+_mesa_init_feedback_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_feedback */
+
+#define _MESA_INIT_FEEDBACK_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void
+_mesa_feedback_vertex( GLcontext *ctx,
+                       const GLfloat win[4],
+                       const GLfloat color[4],
+                       GLfloat index,
+                       const GLfloat texcoord[4] )
+{
+   /* render mode is always GL_RENDER */
+   ASSERT_NO_FEATURE();
+}
+
+
+static INLINE void
+_mesa_feedback_token( GLcontext *ctx, GLfloat token )
+{
+   /* render mode is always GL_RENDER */
+   ASSERT_NO_FEATURE();
+}
+
+static INLINE void
+_mesa_update_hitflag( GLcontext *ctx, GLfloat z )
+{
+   /* render mode is always GL_RENDER */
+   ASSERT_NO_FEATURE();
+}
+
+static INLINE void 
+_mesa_init_feedback_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_feedback */
+
+extern void
+_mesa_init_feedback( GLcontext *ctx );
 
-#endif
+#endif /* FEEDBACK_H */
diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c
index cc1b44de64..356476e35a 100644
--- a/src/mesa/main/ffvertex_prog.c
+++ b/src/mesa/main/ffvertex_prog.c
@@ -1,8 +1,8 @@
 /**************************************************************************
- * 
+ *
  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
@@ -10,11 +10,11 @@
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
@@ -22,7 +22,7 @@
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- * 
+ *
  **************************************************************************/
 
 /**
@@ -46,32 +46,33 @@
 #include "shader/prog_statevars.h"
 
 
+/** Max of number of lights and texture coord units */
+#define NUM_UNITS MAX2(MAX_TEXTURE_COORD_UNITS, MAX_LIGHTS)
+
 struct state_key {
+   unsigned light_color_material_mask:12;
    unsigned light_global_enabled:1;
    unsigned light_local_viewer:1;
    unsigned light_twoside:1;
-   unsigned light_color_material:1;
-   unsigned light_color_material_mask:12;
-   unsigned light_material_mask:12;
    unsigned material_shininess_is_zero:1;
-
    unsigned need_eye_coords:1;
    unsigned normalize:1;
    unsigned rescale_normals:1;
+
    unsigned fog_source_is_depth:1;
-   unsigned tnl_do_vertex_fog:1;
    unsigned separate_specular:1;
-   unsigned fog_mode:2;
    unsigned point_attenuated:1;
    unsigned point_array:1;
    unsigned texture_enabled_global:1;
    unsigned fragprog_inputs_read:12;
 
+   unsigned varying_vp_inputs;
+
    struct {
       unsigned light_enabled:1;
       unsigned light_eyepos3_is_zero:1;
       unsigned light_spotcutoff_is_180:1;
-      unsigned light_attenuated:1;      
+      unsigned light_attenuated:1;
       unsigned texunit_really_enabled:1;
       unsigned texmat_enabled:1;
       unsigned texgen_enabled:4;
@@ -79,27 +80,10 @@ struct state_key {
       unsigned texgen_mode1:4;
       unsigned texgen_mode2:4;
       unsigned texgen_mode3:4;
-   } unit[8];
+   } unit[NUM_UNITS];
 };
 
 
-
-#define FOG_NONE   0
-#define FOG_LINEAR 1
-#define FOG_EXP    2
-#define FOG_EXP2   3
-
-static GLuint translate_fog_mode( GLenum mode )
-{
-   switch (mode) {
-   case GL_LINEAR: return FOG_LINEAR;
-   case GL_EXP: return FOG_EXP;
-   case GL_EXP2: return FOG_EXP2;
-   default: return FOG_NONE;
-   }
-}
-
-
 #define TXG_NONE           0
 #define TXG_OBJ_LINEAR     1
 #define TXG_EYE_LINEAR     2
@@ -123,42 +107,6 @@ static GLuint translate_texgen( GLboolean enabled, GLenum mode )
 }
 
 
-/**
- * Returns bitmask of flags indicating which materials are set per-vertex
- * in the current VB.
- * XXX get these from the VBO...
- */
-static GLbitfield
-tnl_get_per_vertex_materials(GLcontext *ctx)
-{
-   GLbitfield mask = 0x0;
-#if 0
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   struct vertex_buffer *VB = &tnl->vb;
-   GLuint i;
-
-   for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++) 
-      if (VB->AttribPtr[i] && VB->AttribPtr[i]->stride) 
-         mask |= 1 << (i - _TNL_FIRST_MAT);
-#endif
-   return mask;
-}
-
-
-/**
- * Should fog be computed per-vertex?
- */
-static GLboolean
-tnl_get_per_vertex_fog(GLcontext *ctx)
-{
-#if 0
-   TNLcontext *tnl = TNL_CONTEXT(ctx);
-   return tnl->_DoVertexFog;
-#else
-   return GL_FALSE;
-#endif
-}
-
 
 static GLboolean check_active_shininess( GLcontext *ctx,
                                          const struct state_key *key,
@@ -166,10 +114,11 @@ static GLboolean check_active_shininess( GLcontext *ctx,
 {
    GLuint bit = 1 << (MAT_ATTRIB_FRONT_SHININESS + side);
 
-   if (key->light_color_material_mask & bit)
+   if ((key->varying_vp_inputs & VERT_BIT_COLOR0) &&
+       (key->light_color_material_mask & bit))
       return GL_TRUE;
 
-   if (key->light_material_mask & bit)
+   if (key->varying_vp_inputs & (bit << 16))
       return GL_TRUE;
 
    if (ctx->Light.Material.Attrib[MAT_ATTRIB_FRONT_SHININESS + side][0] != 0.0F)
@@ -194,6 +143,7 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
    key->need_eye_coords = ctx->_NeedEyeCoords;
 
    key->fragprog_inputs_read = fp->Base.InputsRead;
+   key->varying_vp_inputs = ctx->varying_vp_inputs;
 
    if (ctx->RenderMode == GL_FEEDBACK) {
       /* make sure the vertprog emits color and tex0 */
@@ -213,12 +163,9 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
 	 key->light_twoside = 1;
 
       if (ctx->Light.ColorMaterialEnabled) {
-	 key->light_color_material = 1;
 	 key->light_color_material_mask = ctx->Light.ColorMaterialBitmask;
       }
 
-      key->light_material_mask = tnl_get_per_vertex_materials(ctx);
-
       for (i = 0; i < MAX_LIGHTS; i++) {
 	 struct gl_light *light = &ctx->Light.Light[i];
 
@@ -227,7 +174,7 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
 
 	    if (light->EyePosition[3] == 0.0)
 	       key->unit[i].light_eyepos3_is_zero = 1;
-	    
+
 	    if (light->SpotCutoff == 180.0)
 	       key->unit[i].light_spotcutoff_is_180 = 1;
 
@@ -256,12 +203,8 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
    if (ctx->Transform.RescaleNormals)
       key->rescale_normals = 1;
 
-   key->fog_mode = translate_fog_mode(fp->FogOption);
-   
    if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
       key->fog_source_is_depth = 1;
-   
-   key->tnl_do_vertex_fog = tnl_get_per_vertex_fog(ctx);
 
    if (ctx->Point._Attenuated)
       key->point_attenuated = 1;
@@ -275,52 +218,46 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
        ctx->Texture._TexMatEnabled ||
        ctx->Texture._EnabledUnits)
       key->texture_enabled_global = 1;
-      
+
    for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
 
       if (texUnit->_ReallyEnabled)
 	 key->unit[i].texunit_really_enabled = 1;
 
-      if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))      
+      if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
 	 key->unit[i].texmat_enabled = 1;
-      
+
       if (texUnit->TexGenEnabled) {
 	 key->unit[i].texgen_enabled = 1;
-      
-	 key->unit[i].texgen_mode0 = 
+
+	 key->unit[i].texgen_mode0 =
 	    translate_texgen( texUnit->TexGenEnabled & (1<<0),
-			      texUnit->GenModeS );
-	 key->unit[i].texgen_mode1 = 
+			      texUnit->GenS.Mode );
+	 key->unit[i].texgen_mode1 =
 	    translate_texgen( texUnit->TexGenEnabled & (1<<1),
-			      texUnit->GenModeT );
-	 key->unit[i].texgen_mode2 = 
+			      texUnit->GenT.Mode );
+	 key->unit[i].texgen_mode2 =
 	    translate_texgen( texUnit->TexGenEnabled & (1<<2),
-			      texUnit->GenModeR );
-	 key->unit[i].texgen_mode3 = 
+			      texUnit->GenR.Mode );
+	 key->unit[i].texgen_mode3 =
 	    translate_texgen( texUnit->TexGenEnabled & (1<<3),
-			      texUnit->GenModeQ );
+			      texUnit->GenQ.Mode );
       }
    }
 }
 
 
-   
+
 /* Very useful debugging tool - produces annotated listing of
  * generated program with line/function references for each
  * instruction back into this file:
  */
 #define DISASSEM 0
 
-/* Should be tunable by the driver - do we want to do matrix
- * multiplications with DP4's or with MUL/MAD's?  SSE works better
- * with the latter, drivers may differ.
- */
-#define PREFER_DP4 0
-
 
 /* Use uregs to represent registers internally, translate to Mesa's
- * expected formats on emit.  
+ * expected formats on emit.
  *
  * NOTE: These are passed by value extensively in this file rather
  * than as usual by pointer reference.  If this disturbs you, try
@@ -345,10 +282,11 @@ struct tnl_program {
    const struct state_key *state;
    struct gl_vertex_program *program;
    GLint max_inst;  /** number of instructions allocated for program */
-   
+   GLboolean mvp_with_dp4;
+
    GLuint temp_in_use;
    GLuint temp_reserved;
-   
+
    struct ureg eye_position;
    struct ureg eye_position_z;
    struct ureg eye_position_normalized;
@@ -360,7 +298,7 @@ struct tnl_program {
 };
 
 
-static const struct ureg undef = { 
+static const struct ureg undef = {
    PROGRAM_UNDEFINED,
    0,
    0,
@@ -395,7 +333,7 @@ static struct ureg negate( struct ureg reg )
 {
    reg.negate ^= 1;
    return reg;
-} 
+}
 
 
 static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
@@ -404,7 +342,6 @@ static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
 			   GET_SWZ(reg.swz, y),
 			   GET_SWZ(reg.swz, z),
 			   GET_SWZ(reg.swz, w));
-
    return reg;
 }
 
@@ -447,20 +384,52 @@ static void release_temp( struct tnl_program *p, struct ureg reg )
    }
 }
 
-
 static void release_temps( struct tnl_program *p )
 {
    p->temp_in_use = p->temp_reserved;
 }
 
 
+static struct ureg register_param5(struct tnl_program *p,
+				   GLint s0,
+				   GLint s1,
+				   GLint s2,
+				   GLint s3,
+                                   GLint s4)
+{
+   gl_state_index tokens[STATE_LENGTH];
+   GLint idx;
+   tokens[0] = s0;
+   tokens[1] = s1;
+   tokens[2] = s2;
+   tokens[3] = s3;
+   tokens[4] = s4;
+   idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
+   return make_ureg(PROGRAM_STATE_VAR, idx);
+}
+
+
+#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)
+#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)
+#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
+#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
+
+
+
 /**
  * \param input  one of VERT_ATTRIB_x tokens.
  */
 static struct ureg register_input( struct tnl_program *p, GLuint input )
 {
-   p->program->Base.InputsRead |= (1<<input);
-   return make_ureg(PROGRAM_INPUT, input);
+   assert(input < 32);
+
+   if (p->state->varying_vp_inputs & (1<<input)) {
+      p->program->Base.InputsRead |= (1<<input);
+      return make_ureg(PROGRAM_INPUT, input);
+   }
+   else {
+      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, input );
+   }
 }
 
 
@@ -474,7 +443,7 @@ static struct ureg register_output( struct tnl_program *p, GLuint output )
 }
 
 
-static struct ureg register_const4f( struct tnl_program *p, 
+static struct ureg register_const4f( struct tnl_program *p,
 			      GLfloat s0,
 			      GLfloat s1,
 			      GLfloat s2,
@@ -493,7 +462,6 @@ static struct ureg register_const4f( struct tnl_program *p,
    return make_ureg(PROGRAM_CONSTANT, idx);
 }
 
-
 #define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
 #define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
 #define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
@@ -507,38 +475,12 @@ static GLboolean is_undef( struct ureg reg )
 
 static struct ureg get_identity_param( struct tnl_program *p )
 {
-   if (is_undef(p->identity)) 
+   if (is_undef(p->identity))
       p->identity = register_const4f(p, 0,0,0,1);
 
    return p->identity;
 }
 
-
-static struct ureg register_param5(struct tnl_program *p, 
-				   GLint s0,
-				   GLint s1,
-				   GLint s2,
-				   GLint s3,
-                                   GLint s4)
-{
-   gl_state_index tokens[STATE_LENGTH];
-   GLint idx;
-   tokens[0] = s0;
-   tokens[1] = s1;
-   tokens[2] = s2;
-   tokens[3] = s3;
-   tokens[4] = s4;
-   idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
-   return make_ureg(PROGRAM_STATE_VAR, idx);
-}
-
-
-#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)
-#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)
-#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
-#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
-
-
 static void register_matrix_param5( struct tnl_program *p,
 				    GLint s0, /* modelview, projection, etc */
 				    GLint s1, /* texture matrix number */
@@ -552,7 +494,7 @@ static void register_matrix_param5( struct tnl_program *p,
    /* This is a bit sad as the support is there to pull the whole
     * matrix out in one go:
     */
-   for (i = 0; i <= s3 - s2; i++) 
+   for (i = 0; i <= s3 - s2; i++)
       matrix[i] = register_param5( p, s0, s1, i, i, s4 );
 }
 
@@ -563,9 +505,8 @@ static void emit_arg( struct prog_src_register *src,
    src->File = reg.file;
    src->Index = reg.idx;
    src->Swizzle = reg.swz;
-   src->NegateBase = reg.negate ? NEGATE_XYZW : 0;
+   src->Negate = reg.negate ? NEGATE_XYZW : NEGATE_NONE;
    src->Abs = 0;
-   src->NegateAbs = 0;
    src->RelAddr = 0;
    /* Check that bitfield sizes aren't exceeded */
    ASSERT(src->Index == reg.idx);
@@ -578,7 +519,7 @@ static void emit_dst( struct prog_dst_register *dst,
    dst->File = reg.file;
    dst->Index = reg.idx;
    /* allow zero as a shorthand for xyzw */
-   dst->WriteMask = mask ? mask : WRITEMASK_XYZW; 
+   dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
    dst->CondMask = COND_TR;  /* always pass cond test */
    dst->CondSwizzle = SWIZZLE_NOOP;
    dst->CondSrc = 0;
@@ -593,12 +534,12 @@ static void debug_insn( struct prog_instruction *inst, const char *fn,
 {
    if (DISASSEM) {
       static const char *last_fn;
-   
+
       if (fn != last_fn) {
 	 last_fn = fn;
 	 _mesa_printf("%s:\n", fn);
       }
-	 
+
       _mesa_printf("%d:\t", line);
       _mesa_print_instruction(inst);
    }
@@ -617,7 +558,7 @@ static void emit_op3fn(struct tnl_program *p,
 {
    GLuint nr;
    struct prog_instruction *inst;
-      
+
    assert((GLint) p->program->Base.NumInstructions <= p->max_inst);
 
    if (p->program->Base.NumInstructions == p->max_inst) {
@@ -642,17 +583,16 @@ static void emit_op3fn(struct tnl_program *p,
 
       p->program->Base.Instructions = newInst;
    }
-      
+
    nr = p->program->Base.NumInstructions++;
 
    inst = &p->program->Base.Instructions[nr];
-   inst->Opcode = (enum prog_opcode) op; 
-   inst->StringPos = 0;
+   inst->Opcode = (enum prog_opcode) op;
    inst->Data = 0;
-   
+
    emit_arg( &inst->SrcReg[0], src0 );
    emit_arg( &inst->SrcReg[1], src1 );
-   emit_arg( &inst->SrcReg[2], src2 );   
+   emit_arg( &inst->SrcReg[2], src2 );
 
    emit_dst( &inst->DstReg, dest, mask );
 
@@ -672,7 +612,7 @@ static void emit_op3fn(struct tnl_program *p,
 
 static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
 {
-   if (reg.file == PROGRAM_TEMPORARY && 
+   if (reg.file == PROGRAM_TEMPORARY &&
        !(p->temp_reserved & (1<<reg.idx)))
       return reg;
    else {
@@ -753,24 +693,24 @@ static void emit_normalize_vec3( struct tnl_program *p,
 }
 
 
-static void emit_passthrough( struct tnl_program *p, 
+static void emit_passthrough( struct tnl_program *p,
 			      GLuint input,
 			      GLuint output )
 {
    struct ureg out = register_output(p, output);
-   emit_op1(p, OPCODE_MOV, out, 0, register_input(p, input)); 
+   emit_op1(p, OPCODE_MOV, out, 0, register_input(p, input));
 }
 
 
 static struct ureg get_eye_position( struct tnl_program *p )
 {
    if (is_undef(p->eye_position)) {
-      struct ureg pos = register_input( p, VERT_ATTRIB_POS ); 
+      struct ureg pos = register_input( p, VERT_ATTRIB_POS );
       struct ureg modelview[4];
 
       p->eye_position = reserve_temp(p);
 
-      if (PREFER_DP4) {
+      if (p->mvp_with_dp4) {
 	 register_matrix_param5( p, STATE_MODELVIEW_MATRIX, 0, 0, 3,
                                  0, modelview );
 
@@ -783,18 +723,18 @@ static struct ureg get_eye_position( struct tnl_program *p )
 	 emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
       }
    }
-   
+
    return p->eye_position;
 }
 
 
 static struct ureg get_eye_position_z( struct tnl_program *p )
 {
-   if (!is_undef(p->eye_position)) 
+   if (!is_undef(p->eye_position))
       return swizzle1(p->eye_position, Z);
 
    if (is_undef(p->eye_position_z)) {
-      struct ureg pos = register_input( p, VERT_ATTRIB_POS ); 
+      struct ureg pos = register_input( p, VERT_ATTRIB_POS );
       struct ureg modelview[4];
 
       p->eye_position_z = reserve_temp(p);
@@ -804,10 +744,10 @@ static struct ureg get_eye_position_z( struct tnl_program *p )
 
       emit_op2(p, OPCODE_DP4, p->eye_position_z, 0, pos, modelview[2]);
    }
-   
+
    return p->eye_position_z;
 }
-   
+
 
 static struct ureg get_eye_position_normalized( struct tnl_program *p )
 {
@@ -816,7 +756,7 @@ static struct ureg get_eye_position_normalized( struct tnl_program *p )
       p->eye_position_normalized = reserve_temp(p);
       emit_normalize_vec3(p, p->eye_position_normalized, eye);
    }
-   
+
    return p->eye_position_normalized;
 }
 
@@ -830,7 +770,7 @@ static struct ureg get_transformed_normal( struct tnl_program *p )
    {
       p->transformed_normal = register_input(p, VERT_ATTRIB_NORMAL );
    }
-   else if (is_undef(p->transformed_normal)) 
+   else if (is_undef(p->transformed_normal))
    {
       struct ureg normal = register_input(p, VERT_ATTRIB_NORMAL );
       struct ureg mvinv[3];
@@ -861,7 +801,7 @@ static struct ureg get_transformed_normal( struct tnl_program *p )
 	 emit_op2( p, OPCODE_MUL, transformed_normal, 0, normal, rescale );
          normal = transformed_normal;
       }
-      
+
       assert(normal.file == PROGRAM_TEMPORARY);
       p->transformed_normal = normal;
    }
@@ -872,17 +812,17 @@ static struct ureg get_transformed_normal( struct tnl_program *p )
 
 static void build_hpos( struct tnl_program *p )
 {
-   struct ureg pos = register_input( p, VERT_ATTRIB_POS ); 
+   struct ureg pos = register_input( p, VERT_ATTRIB_POS );
    struct ureg hpos = register_output( p, VERT_RESULT_HPOS );
    struct ureg mvp[4];
 
-   if (PREFER_DP4) {
-      register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3, 
+   if (p->mvp_with_dp4) {
+      register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
 			      0, mvp );
       emit_matrix_transform_vec4( p, hpos, mvp, pos );
    }
    else {
-      register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3, 
+      register_matrix_param5( p, STATE_MVP_MATRIX, 0, 0, 3,
 			      STATE_MATRIX_TRANSPOSE, mvp );
       emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
    }
@@ -891,8 +831,7 @@ static void build_hpos( struct tnl_program *p )
 
 static GLuint material_attrib( GLuint side, GLuint property )
 {
-   return ((property - STATE_AMBIENT) * 2 + 
-	   side);
+   return (property - STATE_AMBIENT) * 2 + side;
 }
 
 
@@ -904,27 +843,28 @@ static void set_material_flags( struct tnl_program *p )
    p->color_materials = 0;
    p->materials = 0;
 
-   if (p->state->light_color_material) {
-      p->materials = 
+   if (p->state->varying_vp_inputs & VERT_BIT_COLOR0) {
+      p->materials =
 	 p->color_materials = p->state->light_color_material_mask;
    }
 
-   p->materials |= p->state->light_material_mask;
+   p->materials |= (p->state->varying_vp_inputs >> 16);
 }
 
 
-/* XXX temporary!!! */
-#define _TNL_ATTRIB_MAT_FRONT_AMBIENT 32
-
-static struct ureg get_material( struct tnl_program *p, GLuint side, 
+static struct ureg get_material( struct tnl_program *p, GLuint side,
 				 GLuint property )
 {
    GLuint attrib = material_attrib(side, property);
 
    if (p->color_materials & (1<<attrib))
       return register_input(p, VERT_ATTRIB_COLOR0);
-   else if (p->materials & (1<<attrib)) 
-      return register_input( p, attrib + _TNL_ATTRIB_MAT_FRONT_AMBIENT );
+   else if (p->materials & (1<<attrib)) {
+      /* Put material values in the GENERIC slots -- they are not used
+       * for anything in fixed function mode.
+       */
+      return register_input( p, attrib + VERT_ATTRIB_GENERIC0 );
+   }
    else
       return register_param3( p, STATE_MATERIAL, side, property );
 }
@@ -953,7 +893,7 @@ static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
       struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
       struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
       struct ureg tmp = make_temp(p, material_diffuse);
-      emit_op3(p, OPCODE_MAD, tmp,  WRITEMASK_XYZ, lm_ambient, 
+      emit_op3(p, OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
 	       material_ambient, material_emission);
       return tmp;
    }
@@ -962,16 +902,16 @@ static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
 }
 
 
-static struct ureg get_lightprod( struct tnl_program *p, GLuint light, 
+static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
 				  GLuint side, GLuint property )
 {
    GLuint attrib = material_attrib(side, property);
    if (p->materials & (1<<attrib)) {
-      struct ureg light_value = 
+      struct ureg light_value =
 	 register_param3(p, STATE_LIGHT, light, property);
       struct ureg material_value = get_material(p, side, property);
       struct ureg tmp = get_temp(p);
-      emit_op2(p, OPCODE_MUL, tmp,  0, light_value, material_value);
+      emit_op2(p, OPCODE_MUL, tmp, 0, light_value, material_value);
       return tmp;
    }
    else
@@ -980,7 +920,7 @@ static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
 
 
 static struct ureg calculate_light_attenuation( struct tnl_program *p,
-						GLuint i, 
+						GLuint i,
 						struct ureg VPpli,
 						struct ureg dist )
 {
@@ -1008,28 +948,28 @@ static struct ureg calculate_light_attenuation( struct tnl_program *p,
    /* Calculate distance attenuation:
     */
    if (p->state->unit[i].light_attenuated) {
-
       /* 1/d,d,d,1/d */
-      emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist); 
+      emit_op1(p, OPCODE_RCP, dist, WRITEMASK_YZ, dist);
       /* 1,d,d*d,1/d */
-      emit_op2(p, OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y)); 
+      emit_op2(p, OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
       /* 1/dist-atten */
-      emit_op2(p, OPCODE_DP3, dist, 0, attenuation, dist); 
+      emit_op2(p, OPCODE_DP3, dist, 0, attenuation, dist);
 
       if (!p->state->unit[i].light_spotcutoff_is_180) {
 	 /* dist-atten */
-	 emit_op1(p, OPCODE_RCP, dist, 0, dist); 
+	 emit_op1(p, OPCODE_RCP, dist, 0, dist);
 	 /* spot-atten * dist-atten */
-	 emit_op2(p, OPCODE_MUL, att, 0, dist, att);	
-      } else {
+	 emit_op2(p, OPCODE_MUL, att, 0, dist, att);
+      }
+      else {
 	 /* dist-atten */
-	 emit_op1(p, OPCODE_RCP, att, 0, dist); 
+	 emit_op1(p, OPCODE_RCP, att, 0, dist);
       }
    }
 
    return att;
 }
-						
+
 
 /**
  * Compute:
@@ -1048,7 +988,7 @@ static void emit_degenerate_lit( struct tnl_program *p,
 
    /* MAX lit, id, dots;
     */
-   emit_op2(p, OPCODE_MAX, lit, WRITEMASK_XYZW, id, dots); 
+   emit_op2(p, OPCODE_MAX, lit, WRITEMASK_XYZW, id, dots);
 
    /* result[2] = (in > 0 ? 1 : 0)
     * SLT lit.z, id.z, dots;   # lit.z = (0 < dots.z) ? 1 : 0
@@ -1075,22 +1015,22 @@ static void build_lighting( struct tnl_program *p )
 
    /*
     * NOTE:
-    * dot.x = dot(normal, VPpli)
-    * dot.y = dot(normal, halfAngle)
-    * dot.z = back.shininess
-    * dot.w = front.shininess
+    * dots.x = dot(normal, VPpli)
+    * dots.y = dot(normal, halfAngle)
+    * dots.z = back.shininess
+    * dots.w = front.shininess
     */
 
-   for (i = 0; i < MAX_LIGHTS; i++) 
+   for (i = 0; i < MAX_LIGHTS; i++)
       if (p->state->unit[i].light_enabled)
 	 nr_lights++;
-   
+
    set_material_flags(p);
 
    {
       if (!p->state->material_shininess_is_zero) {
          struct ureg shininess = get_material(p, 0, STATE_SHININESS);
-         emit_op1(p, OPCODE_MOV, dots,  WRITEMASK_W, swizzle1(shininess,X));
+         emit_op1(p, OPCODE_MOV, dots, WRITEMASK_W, swizzle1(shininess,X));
          release_temp(p, shininess);
       }
 
@@ -1099,13 +1039,15 @@ static void build_lighting( struct tnl_program *p )
 	 _col1 = make_temp(p, get_identity_param(p));
       else
 	 _col1 = _col0;
-
    }
 
    if (twoside) {
       if (!p->state->material_shininess_is_zero) {
+         /* Note that we negate the back-face specular exponent here.
+          * The negation will be un-done later in the back-face code below.
+          */
          struct ureg shininess = get_material(p, 1, STATE_SHININESS);
-         emit_op1(p, OPCODE_MOV, dots, WRITEMASK_Z, 
+         emit_op1(p, OPCODE_MOV, dots, WRITEMASK_Z,
                   negate(swizzle1(shininess,X)));
          release_temp(p, shininess);
       }
@@ -1133,12 +1075,12 @@ static void build_lighting( struct tnl_program *p )
       struct ureg res0 = register_output( p, VERT_RESULT_BFC0 );
       emit_op1(p, OPCODE_MOV, res0, 0, _bfc0);
    }
-      
+
    if (twoside && separate) {
       struct ureg res1 = register_output( p, VERT_RESULT_BFC1 );
       emit_op1(p, OPCODE_MOV, res1, 0, _bfc1);
    }
-      
+
    if (nr_lights == 0) {
       release_temps(p);
       return;
@@ -1148,39 +1090,40 @@ static void build_lighting( struct tnl_program *p )
       if (p->state->unit[i].light_enabled) {
 	 struct ureg half = undef;
 	 struct ureg att = undef, VPpli = undef;
-	  
+
 	 count++;
 
 	 if (p->state->unit[i].light_eyepos3_is_zero) {
 	    /* Can used precomputed constants in this case.
 	     * Attenuation never applies to infinite lights.
 	     */
-	    VPpli = register_param3(p, STATE_INTERNAL, 
-				    STATE_LIGHT_POSITION_NORMALIZED, i); 
-            
+	    VPpli = register_param3(p, STATE_INTERNAL,
+				    STATE_LIGHT_POSITION_NORMALIZED, i);
+
             if (!p->state->material_shininess_is_zero) {
                if (p->state->light_local_viewer) {
                   struct ureg eye_hat = get_eye_position_normalized(p);
                   half = get_temp(p);
                   emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
                   emit_normalize_vec3(p, half, half);
-               } else {
-                  half = register_param3(p, STATE_INTERNAL, 
+               }
+               else {
+                  half = register_param3(p, STATE_INTERNAL,
                                          STATE_LIGHT_HALF_VECTOR, i);
                }
             }
-	 } 
+	 }
 	 else {
-	    struct ureg Ppli = register_param3(p, STATE_INTERNAL, 
-					       STATE_LIGHT_POSITION, i); 
+	    struct ureg Ppli = register_param3(p, STATE_INTERNAL,
+					       STATE_LIGHT_POSITION, i);
 	    struct ureg V = get_eye_position(p);
 	    struct ureg dist = get_temp(p);
 
-	    VPpli = get_temp(p); 
- 
+	    VPpli = get_temp(p);
+
 	    /* Calculate VPpli vector
 	     */
-	    emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V); 
+	    emit_op2(p, OPCODE_SUB, VPpli, 0, Ppli, V);
 
 	    /* Normalize VPpli.  The dist value also used in
 	     * attenuation below.
@@ -1190,7 +1133,7 @@ static void build_lighting( struct tnl_program *p )
 	    emit_op2(p, OPCODE_MUL, VPpli, 0, VPpli, dist);
 
 	    /* Calculate attenuation:
-	     */ 
+	     */
 	    if (!p->state->unit[i].light_spotcutoff_is_180 ||
 		p->state->unit[i].light_attenuated) {
 	       att = calculate_light_attenuation(p, i, VPpli, dist);
@@ -1206,7 +1149,7 @@ static void build_lighting( struct tnl_program *p )
                   emit_op2(p, OPCODE_SUB, half, 0, VPpli, eye_hat);
                }
                else {
-                  struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z); 
+                  struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
                   emit_op2(p, OPCODE_ADD, half, 0, VPpli, z_dir);
                }
 
@@ -1248,7 +1191,8 @@ static void build_lighting( struct tnl_program *p )
 		  res0 = _col0;
 		  res1 = register_output( p, VERT_RESULT_COL0 );
 	       }
-	    } else {
+	    }
+            else {
 	       mask0 = 0;
 	       mask1 = 0;
 	       res0 = _col0;
@@ -1260,12 +1204,12 @@ static void build_lighting( struct tnl_program *p )
                emit_op1(p, OPCODE_LIT, lit, 0, dots);
                emit_op2(p, OPCODE_MUL, lit, 0, lit, att);
                emit_op3(p, OPCODE_MAD, _col0, 0, swizzle1(lit,X), ambient, _col0);
-            } 
+            }
             else if (!p->state->material_shininess_is_zero) {
                /* there's a non-zero specular term */
                emit_op1(p, OPCODE_LIT, lit, 0, dots);
                emit_op2(p, OPCODE_ADD, _col0, 0, ambient, _col0);
-            } 
+            }
             else {
                /* no attenutation, no specular */
                emit_degenerate_lit(p, lit, dots);
@@ -1274,7 +1218,7 @@ static void build_lighting( struct tnl_program *p )
 
 	    emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _col0);
 	    emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _col1);
-      
+
 	    release_temp(p, ambient);
 	    release_temp(p, diffuse);
 	    release_temp(p, specular);
@@ -1288,7 +1232,7 @@ static void build_lighting( struct tnl_program *p )
 	    struct ureg specular = get_lightprod(p, i, 1, STATE_SPECULAR);
 	    struct ureg res0, res1;
 	    GLuint mask0, mask1;
-	       
+
 	    if (count == nr_lights) {
 	       if (separate) {
 		  mask0 = WRITEMASK_XYZ;
@@ -1302,13 +1246,19 @@ static void build_lighting( struct tnl_program *p )
 		  res0 = _bfc0;
 		  res1 = register_output( p, VERT_RESULT_BFC0 );
 	       }
-	    } else {
+	    }
+            else {
 	       res0 = _bfc0;
 	       res1 = _bfc1;
 	       mask0 = 0;
 	       mask1 = 0;
 	    }
 
+            /* For the back face we need to negate the X and Y component
+             * dot products.  dots.Z has the negated back-face specular
+             * exponent.  We swizzle that into the W position.  This
+             * negation makes the back-face specular term positive again.
+             */
             dots = negate(swizzle(dots,X,Y,W,Z));
 
 	    if (!is_undef(att)) {
@@ -1318,8 +1268,8 @@ static void build_lighting( struct tnl_program *p )
             }
             else if (!p->state->material_shininess_is_zero) {
                emit_op1(p, OPCODE_LIT, lit, 0, dots);
-               emit_op2(p, OPCODE_ADD, _bfc0, 0, ambient, _bfc0);
-            } 
+               emit_op2(p, OPCODE_ADD, _bfc0, 0, ambient, _bfc0); /**/
+            }
             else {
                emit_degenerate_lit(p, lit, dots);
                emit_op2(p, OPCODE_ADD, _bfc0, 0, ambient, _bfc0);
@@ -1327,8 +1277,10 @@ static void build_lighting( struct tnl_program *p )
 
 	    emit_op3(p, OPCODE_MAD, res0, mask0, swizzle1(lit,Y), diffuse, _bfc0);
 	    emit_op3(p, OPCODE_MAD, res1, mask1, swizzle1(lit,Z), specular, _bfc1);
-            /* restore negate flag for next lighting */
-            dots = negate(dots);
+            /* restore dots to its original state for subsequent lights
+             * by negating and swizzling again.
+             */
+            dots = negate(swizzle(dots,X,Y,W,Z));
 
 	    release_temp(p, ambient);
 	    release_temp(p, diffuse);
@@ -1357,52 +1309,12 @@ static void build_fog( struct tnl_program *p )
       input = swizzle1(register_input(p, VERT_ATTRIB_FOG), X);
    }
 
-   if (p->state->fog_mode && p->state->tnl_do_vertex_fog) {
-      struct ureg params = register_param2(p, STATE_INTERNAL,
-					   STATE_FOG_PARAMS_OPTIMIZED);
-      struct ureg tmp = get_temp(p);
-      GLboolean useabs = (p->state->fog_mode != FOG_EXP2);
-
-      if (useabs) {
-	 emit_op1(p, OPCODE_ABS, tmp, 0, input);
-      }
-
-      switch (p->state->fog_mode) {
-      case FOG_LINEAR: {
-	 struct ureg id = get_identity_param(p);
-	 emit_op3(p, OPCODE_MAD, tmp, 0, useabs ? tmp : input,
-			swizzle1(params,X), swizzle1(params,Y));
-	 emit_op2(p, OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
-	 emit_op2(p, OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
-	 break;
-      }
-      case FOG_EXP:
-	 emit_op2(p, OPCODE_MUL, tmp, 0, useabs ? tmp : input,
-			swizzle1(params,Z));
-	 emit_op1(p, OPCODE_EX2, fog, WRITEMASK_X, negate(tmp));
-	 break;
-      case FOG_EXP2:
-	 emit_op2(p, OPCODE_MUL, tmp, 0, input, swizzle1(params,W));
-	 emit_op2(p, OPCODE_MUL, tmp, 0, tmp, tmp);
-	 emit_op1(p, OPCODE_EX2, fog, WRITEMASK_X, negate(tmp));
-	 break;
-      }
-
-      release_temp(p, tmp);
-   }
-   else {
-      /* results = incoming fog coords (compute fog per-fragment later) 
-       *
-       * KW:  Is it really necessary to do anything in this case?
-       * BP: Yes, we always need to compute the absolute value, unless
-       * we want to push that down into the fragment program...
-       */
-      GLboolean useabs = GL_TRUE;
-      emit_op1(p, useabs ? OPCODE_ABS : OPCODE_MOV, fog, WRITEMASK_X, input);
-   }
+   /* result.fog = {abs(f),0,0,1}; */
+   emit_op1(p, OPCODE_ABS, fog, WRITEMASK_X, input);
+   emit_op1(p, OPCODE_MOV, fog, WRITEMASK_YZW, get_identity_param(p));
 }
 
- 
+
 static void build_reflect_texgen( struct tnl_program *p,
 				  struct ureg dest,
 				  GLuint writemask )
@@ -1412,9 +1324,9 @@ static void build_reflect_texgen( struct tnl_program *p,
    struct ureg tmp = get_temp(p);
 
    /* n.u */
-   emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat); 
+   emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
    /* 2n.u */
-   emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp); 
+   emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
    /* (-2n.u)n + u */
    emit_op3(p, OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
 
@@ -1443,22 +1355,22 @@ static void build_sphere_texgen( struct tnl_program *p,
     */
 
    /* n.u */
-   emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat); 
+   emit_op2(p, OPCODE_DP3, tmp, 0, normal, eye_hat);
    /* 2n.u */
-   emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp); 
+   emit_op2(p, OPCODE_ADD, tmp, 0, tmp, tmp);
    /* (-2n.u)n + u */
-   emit_op3(p, OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat); 
+   emit_op3(p, OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
    /* r + 0,0,1 */
-   emit_op2(p, OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z)); 
+   emit_op2(p, OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
    /* rx^2 + ry^2 + (rz+1)^2 */
-   emit_op2(p, OPCODE_DP3, tmp, 0, tmp, tmp); 
+   emit_op2(p, OPCODE_DP3, tmp, 0, tmp, tmp);
    /* 2/m */
-   emit_op1(p, OPCODE_RSQ, tmp, 0, tmp); 
+   emit_op1(p, OPCODE_RSQ, tmp, 0, tmp);
    /* 1/m */
-   emit_op2(p, OPCODE_MUL, inv_m, 0, tmp, half); 
+   emit_op2(p, OPCODE_MUL, inv_m, 0, tmp, half);
    /* r/m + 1/2 */
-   emit_op3(p, OPCODE_MAD, dest, writemask, r, inv_m, half); 
-	       
+   emit_op3(p, OPCODE_MAD, dest, writemask, r, inv_m, half);
+
    release_temp(p, tmp);
    release_temp(p, r);
    release_temp(p, inv_m);
@@ -1473,10 +1385,10 @@ static void build_texture_transform( struct tnl_program *p )
 
       if (!(p->state->fragprog_inputs_read & FRAG_BIT_TEX(i)))
 	 continue;
-							     
-      if (p->state->unit[i].texgen_enabled || 
+
+      if (p->state->unit[i].texgen_enabled ||
 	  p->state->unit[i].texmat_enabled) {
-	 
+
 	 GLuint texmat_enabled = p->state->unit[i].texmat_enabled;
 	 struct ureg out = register_output(p, VERT_RESULT_TEX0 + i);
 	 struct ureg out_texgen = undef;
@@ -1487,8 +1399,8 @@ static void build_texture_transform( struct tnl_program *p )
 	    GLuint reflect_mask = 0;
 	    GLuint normal_mask = 0;
 	    GLuint modes[4];
-	 
-	    if (texmat_enabled) 
+
+	    if (texmat_enabled)
 	       out_texgen = get_temp(p);
 	    else
 	       out_texgen = out;
@@ -1502,31 +1414,31 @@ static void build_texture_transform( struct tnl_program *p )
 	       switch (modes[j]) {
 	       case TXG_OBJ_LINEAR: {
 		  struct ureg obj = register_input(p, VERT_ATTRIB_POS);
-		  struct ureg plane = 
+		  struct ureg plane =
 		     register_param3(p, STATE_TEXGEN, i,
 				     STATE_TEXGEN_OBJECT_S + j);
 
-		  emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j, 
+		  emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
 			   obj, plane );
 		  break;
 	       }
 	       case TXG_EYE_LINEAR: {
 		  struct ureg eye = get_eye_position(p);
-		  struct ureg plane = 
-		     register_param3(p, STATE_TEXGEN, i, 
+		  struct ureg plane =
+		     register_param3(p, STATE_TEXGEN, i,
 				     STATE_TEXGEN_EYE_S + j);
 
-		  emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j, 
+		  emit_op2(p, OPCODE_DP4, out_texgen, WRITEMASK_X << j,
 			   eye, plane );
 		  break;
 	       }
-	       case TXG_SPHERE_MAP: 
+	       case TXG_SPHERE_MAP:
 		  sphere_mask |= WRITEMASK_X << j;
 		  break;
 	       case TXG_REFLECTION_MAP:
 		  reflect_mask |= WRITEMASK_X << j;
 		  break;
-	       case TXG_NORMAL_MAP: 
+	       case TXG_NORMAL_MAP:
 		  normal_mask |= WRITEMASK_X << j;
 		  break;
 	       case TXG_NONE:
@@ -1555,10 +1467,10 @@ static void build_texture_transform( struct tnl_program *p )
 
 	 if (texmat_enabled) {
 	    struct ureg texmat[4];
-	    struct ureg in = (!is_undef(out_texgen) ? 
-			      out_texgen : 
+	    struct ureg in = (!is_undef(out_texgen) ?
+			      out_texgen :
 			      register_input(p, VERT_ATTRIB_TEX0+i));
-	    if (PREFER_DP4) {
+	    if (p->mvp_with_dp4) {
 	       register_matrix_param5( p, STATE_TEXTURE_MATRIX, i, 0, 3,
 				       0, texmat );
 	       emit_matrix_transform_vec4( p, out, texmat, in );
@@ -1571,7 +1483,7 @@ static void build_texture_transform( struct tnl_program *p )
 	 }
 
 	 release_temps(p);
-      } 
+      }
       else {
 	 emit_passthrough(p, VERT_ATTRIB_TEX0+i, VERT_RESULT_TEX0+i);
       }
@@ -1618,17 +1530,6 @@ static void build_atten_pointsize( struct tnl_program *p )
 
 
 /**
- * Emit constant point size.
- */
-static void build_constant_pointsize( struct tnl_program *p )
-{
-   struct ureg state_size = register_param1(p, STATE_POINT_SIZE);
-   struct ureg out = register_output(p, VERT_RESULT_PSIZ);
-   emit_op1(p, OPCODE_MOV, out, WRITEMASK_X, state_size);
-}
-
-
-/**
  * Pass-though per-vertex point size, from user's point size array.
  */
 static void build_array_pointsize( struct tnl_program *p )
@@ -1640,7 +1541,8 @@ static void build_array_pointsize( struct tnl_program *p )
 
 
 static void build_tnl_program( struct tnl_program *p )
-{   /* Emit the program, starting with modelviewproject:
+{
+   /* Emit the program, starting with modelviewproject:
     */
    build_hpos(p);
 
@@ -1658,8 +1560,7 @@ static void build_tnl_program( struct tnl_program *p )
       }
    }
 
-   if ((p->state->fragprog_inputs_read & FRAG_BIT_FOGC) ||
-       p->state->fog_mode != FOG_NONE)
+   if (p->state->fragprog_inputs_read & FRAG_BIT_FOGC)
       build_fog(p);
 
    if (p->state->fragprog_inputs_read & FRAG_BITS_TEX_ANY)
@@ -1669,12 +1570,6 @@ static void build_tnl_program( struct tnl_program *p )
       build_atten_pointsize(p);
    else if (p->state->point_array)
       build_array_pointsize(p);
-#if 0
-   else
-      build_constant_pointsize(p);
-#else
-   (void) build_constant_pointsize;
-#endif
 
    /* Finish up:
     */
@@ -1691,6 +1586,7 @@ static void build_tnl_program( struct tnl_program *p )
 static void
 create_new_program( const struct state_key *key,
                     struct gl_vertex_program *program,
+                    GLboolean mvp_with_dp4,
                     GLuint max_temps)
 {
    struct tnl_program p;
@@ -1704,7 +1600,8 @@ create_new_program( const struct state_key *key,
    p.transformed_normal = undef;
    p.identity = undef;
    p.temp_in_use = 0;
-   
+   p.mvp_with_dp4 = mvp_with_dp4;
+
    if (max_temps >= sizeof(int) * 8)
       p.temp_reserved = 0;
    else
@@ -1747,23 +1644,24 @@ _mesa_get_fixed_func_vertex_program(GLcontext *ctx)
     */
    prog = (struct gl_vertex_program *)
       _mesa_search_program_cache(ctx->VertexProgram.Cache, &key, sizeof(key));
-   
+
    if (!prog) {
       /* OK, we'll have to build a new one */
       if (0)
          _mesa_printf("Build new TNL program\n");
-	 
+
       prog = (struct gl_vertex_program *)
-         ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); 
+         ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
       if (!prog)
          return NULL;
 
       create_new_program( &key, prog,
+                          ctx->mvp_with_dp4,
                           ctx->Const.VertexProgram.MaxTemps );
 
 #if 0
       if (ctx->Driver.ProgramStringNotify)
-         ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB, 
+         ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB,
                                           &prog->Base );
 #endif
       _mesa_program_cache_insert(ctx, ctx->VertexProgram.Cache,
diff --git a/src/mesa/main/fog.c b/src/mesa/main/fog.c
index 50a61bd84b..4323d3db82 100644
--- a/src/mesa/main/fog.c
+++ b/src/mesa/main/fog.c
@@ -67,7 +67,7 @@ _mesa_Fogiv(GLenum pname, const GLint *params )
 	 break;
       default:
          /* Error will be caught later in _mesa_Fogfv */
-         ;
+         ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
    }
    _mesa_Fogfv(pname, p);
 }
diff --git a/src/mesa/main/framebuffer.c b/src/mesa/main/framebuffer.c
index af78363ad3..dc79b8ca61 100644
--- a/src/mesa/main/framebuffer.c
+++ b/src/mesa/main/framebuffer.c
@@ -35,6 +35,7 @@
 #include "buffers.h"
 #include "context.h"
 #include "depthstencil.h"
+#include "macros.h"
 #include "mtypes.h"
 #include "fbobject.h"
 #include "framebuffer.h"
@@ -115,6 +116,7 @@ _mesa_new_framebuffer(GLcontext *ctx, GLuint name)
       fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT;
       fb->_ColorReadBufferIndex = BUFFER_COLOR0;
       fb->Delete = _mesa_destroy_framebuffer;
+      _glthread_INIT_MUTEX(fb->Mutex);
    }
    return fb;
 }
@@ -222,45 +224,32 @@ _mesa_reference_framebuffer(struct gl_framebuffer **ptr,
       /* no change */
       return;
    }
-   if (*ptr) {
-      _mesa_unreference_framebuffer(ptr);
-   }
-   assert(!*ptr);
-   assert(fb);
-   _glthread_LOCK_MUTEX(fb->Mutex);
-   fb->RefCount++;
-   _glthread_UNLOCK_MUTEX(fb->Mutex);
-   *ptr = fb;
-}
-
 
-/**
- * Undo/remove a reference to a framebuffer object.
- * Decrement the framebuffer object's reference count and delete it when
- * the refcount hits zero.
- * Note: we pass the address of a pointer and set it to NULL.
- */
-void
-_mesa_unreference_framebuffer(struct gl_framebuffer **fb)
-{
-   assert(fb);
-   if (*fb) {
+   if (*ptr) {
+      /* unreference old renderbuffer */
       GLboolean deleteFlag = GL_FALSE;
+      struct gl_framebuffer *oldFb = *ptr;
 
-      _glthread_LOCK_MUTEX((*fb)->Mutex);
-      ASSERT((*fb)->RefCount > 0);
-      (*fb)->RefCount--;
-      deleteFlag = ((*fb)->RefCount == 0);
-      _glthread_UNLOCK_MUTEX((*fb)->Mutex);
+      _glthread_LOCK_MUTEX(oldFb->Mutex);
+      ASSERT(oldFb->RefCount > 0);
+      oldFb->RefCount--;
+      deleteFlag = (oldFb->RefCount == 0);
+      _glthread_UNLOCK_MUTEX(oldFb->Mutex);
       
       if (deleteFlag)
-         (*fb)->Delete(*fb);
+         oldFb->Delete(oldFb);
 
-      *fb = NULL;
+      *ptr = NULL;
    }
-}
-
+   assert(!*ptr);
 
+   if (fb) {
+      _glthread_LOCK_MUTEX(fb->Mutex);
+      fb->RefCount++;
+      _glthread_UNLOCK_MUTEX(fb->Mutex);
+      *ptr = fb;
+   }
+}
 
 
 /**
@@ -418,14 +407,14 @@ _mesa_ResizeBuffersMESA( void )
 /**
  * Examine all the framebuffer's renderbuffers to update the Width/Height
  * fields of the framebuffer.  If we have renderbuffers with different
- * sizes, set the framebuffer's width and height to zero.
+ * sizes, set the framebuffer's width and height to the min size.
  * Note: this is only intended for user-created framebuffers, not
  * window-system framebuffes.
  */
 static void
-update_framebuffer_size(struct gl_framebuffer *fb)
+update_framebuffer_size(GLcontext *ctx, struct gl_framebuffer *fb)
 {
-   GLboolean haveSize = GL_FALSE;
+   GLuint minWidth = ~0, minHeight = ~0;
    GLuint i;
 
    /* user-created framebuffers only */
@@ -435,21 +424,19 @@ update_framebuffer_size(struct gl_framebuffer *fb)
       struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
       const struct gl_renderbuffer *rb = att->Renderbuffer;
       if (rb) {
-         if (haveSize) {
-            if (rb->Width != fb->Width && rb->Height != fb->Height) {
-               /* size mismatch! */
-               fb->Width = 0;
-               fb->Height = 0;
-               return;
-            }
-         }
-         else {
-            fb->Width = rb->Width;
-            fb->Height = rb->Height;
-            haveSize = GL_TRUE;
-         }
+         minWidth = MIN2(minWidth, rb->Width);
+         minHeight = MIN2(minHeight, rb->Height);
       }
    }
+
+   if (minWidth != ~0) {
+      fb->Width = minWidth;
+      fb->Height = minHeight;
+   }
+   else {
+      fb->Width = 0;
+      fb->Height = 0;
+   }
 }
 
 
@@ -469,7 +456,7 @@ _mesa_update_draw_buffer_bounds(GLcontext *ctx)
 
    if (buffer->Name) {
       /* user-created framebuffer size depends on the renderbuffers */
-      update_framebuffer_size(buffer);
+      update_framebuffer_size(ctx, buffer);
    }
 
    buffer->_Xmin = 0;
@@ -544,6 +531,7 @@ _mesa_update_framebuffer_visual(struct gl_framebuffer *fb)
             fb->Visual.rgbBits = fb->Visual.redBits
                + fb->Visual.greenBits + fb->Visual.blueBits;
             fb->Visual.floatMode = GL_FALSE;
+            fb->Visual.samples = rb->NumSamples;
             break;
          }
          else if (rb->_BaseFormat == GL_COLOR_INDEX) {
@@ -793,8 +781,9 @@ update_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
       /* This is a user-created framebuffer.
        * Completeness only matters for user-created framebuffers.
        */
-      _mesa_test_framebuffer_completeness(ctx, fb);
-      _mesa_update_framebuffer_visual(fb);
+      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE) {
+         _mesa_test_framebuffer_completeness(ctx, fb);
+      }
    }
 
    /* Strictly speaking, we don't need to update the draw-state
@@ -828,7 +817,7 @@ _mesa_update_framebuffer(GLcontext *ctx)
 
 /**
  * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,
- * glCopyTex[Sub]Image, etc. exists.
+ * glCopyTex[Sub]Image, etc) exists.
  * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
  *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
  * \return GL_TRUE if buffer exists, GL_FALSE otherwise
@@ -836,8 +825,12 @@ _mesa_update_framebuffer(GLcontext *ctx)
 GLboolean
 _mesa_source_buffer_exists(GLcontext *ctx, GLenum format)
 {
-   const struct gl_renderbuffer_attachment *att
-      = ctx->ReadBuffer->Attachment;
+   const struct gl_renderbuffer_attachment *att = ctx->ReadBuffer->Attachment;
+
+   /* If we don't know the framebuffer status, update it now */
+   if (ctx->ReadBuffer->_Status == 0) {
+      _mesa_test_framebuffer_completeness(ctx, ctx->ReadBuffer);
+   }
 
    if (ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       return GL_FALSE;
@@ -861,10 +854,8 @@ _mesa_source_buffer_exists(GLcontext *ctx, GLenum format)
       if (ctx->ReadBuffer->_ColorReadBuffer == NULL) {
          return GL_FALSE;
       }
-      /* XXX enable this post 6.5 release:
       ASSERT(ctx->ReadBuffer->_ColorReadBuffer->RedBits > 0 ||
              ctx->ReadBuffer->_ColorReadBuffer->IndexBits > 0);
-      */
       break;
    case GL_DEPTH:
    case GL_DEPTH_COMPONENT:
@@ -902,13 +893,17 @@ _mesa_source_buffer_exists(GLcontext *ctx, GLenum format)
 
 /**
  * As above, but for drawing operations.
- * XXX code do some code merging w/ above function.
+ * XXX could do some code merging w/ above function.
  */
 GLboolean
 _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format)
 {
-   const struct gl_renderbuffer_attachment *att
-      = ctx->ReadBuffer->Attachment;
+   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;
+
+   /* If we don't know the framebuffer status, update it now */
+   if (ctx->DrawBuffer->_Status == 0) {
+      _mesa_test_framebuffer_completeness(ctx, ctx->DrawBuffer);
+   }
 
    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
       return GL_FALSE;
@@ -929,7 +924,7 @@ _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format)
    case GL_BGRA:
    case GL_ABGR_EXT:
    case GL_COLOR_INDEX:
-      /* nothing special */
+      /* Nothing special since GL_DRAW_BUFFER could be GL_NONE. */
       /* Could assert that colorbuffer has RedBits > 0 */
       break;
    case GL_DEPTH:
@@ -956,7 +951,7 @@ _mesa_dest_buffer_exists(GLcontext *ctx, GLenum format)
       break;
    default:
       _mesa_problem(ctx,
-                    "Unexpected format 0x%x in _mesa_source_buffer_exists",
+                    "Unexpected format 0x%x in _mesa_dest_buffer_exists",
                     format);
       return GL_FALSE;
    }
diff --git a/src/mesa/main/framebuffer.h b/src/mesa/main/framebuffer.h
index e9eeed28cb..45a4703ba9 100644
--- a/src/mesa/main/framebuffer.h
+++ b/src/mesa/main/framebuffer.h
@@ -47,9 +47,6 @@ _mesa_reference_framebuffer(struct gl_framebuffer **ptr,
                             struct gl_framebuffer *fb);
 
 extern void
-_mesa_unreference_framebuffer(struct gl_framebuffer **fb);
-
-extern void
 _mesa_resize_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb,
                          GLuint width, GLuint height);
 
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index 8ce9b0ae69..a6e004a816 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -19,9 +19,15 @@
 
 #define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
 
+#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
+#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
+
 #define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
+#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
 #define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
 
+#define ENUM_TO_INT64(E)      ( (GLint64) (E) )
+
 
 /*
  * Check if named extension is enabled, if not generate error and return.
@@ -276,6 +282,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
       case GL_CURRENT_TEXTURE_COORDS:
          {
          const GLuint texUnit = ctx->Texture.CurrentUnit;
+         FLUSH_CURRENT(ctx, 0);
          params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
          params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
          params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
@@ -460,7 +467,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = INT_TO_BOOLEAN(ctx->List.ListBase);
          break;
       case GL_LIST_INDEX:
-         params[0] = INT_TO_BOOLEAN(ctx->ListState.CurrentListNum);
+         params[0] = INT_TO_BOOLEAN((ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0));
          break;
       case GL_LIST_MODE:
          {
@@ -884,21 +891,21 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = _mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT);
          break;
       case GL_TEXTURE_BINDING_1D:
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_2D:
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_3D:
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name);
          break;
       case GL_TEXTURE_GEN_S:
          params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0);
@@ -1071,22 +1078,19 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name);
          break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
          break;
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Hint.TextureCompression);
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
          {
          GLint formats[100];
          GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
@@ -1368,35 +1372,27 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureMaxAnisotropy);
          break;
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = ctx->Multisample.Enabled;
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = ctx->Multisample.SampleAlphaToCoverage;
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = ctx->Multisample.SampleAlphaToOne;
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = ctx->Multisample.SampleCoverage;
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = FLOAT_TO_BOOLEAN(ctx->Multisample.SampleCoverageValue);
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = ctx->Multisample.SampleCoverageInvert;
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.sampleBuffers);
          break;
       case GL_SAMPLES_ARB:
-         CHECK_EXT1(ARB_multisample, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.samples);
          break;
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
@@ -1569,7 +1565,7 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_TEXTURE_BINDING_RECTANGLE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name);
          break;
       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
@@ -1592,43 +1588,33 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxSpotExponent);
          break;
       case GL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayBufferObj->Name);
          break;
       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
          break;
       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.BufferObj->Name);
          break;
       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.BufferObj->Name);
          break;
       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Index.BufferObj->Name);
          break;
       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
          break;
       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
          break;
       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
          break;
       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
          break;
       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Array.ElementArrayBufferObj->Name);
          break;
       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
@@ -1736,32 +1722,17 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
          params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
          break;
-      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-         params[0] = ctx->FragmentProgram.CallbackEnabled;
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-         params[0] = ctx->VertexProgram.CallbackEnabled;
-         break;
-      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.CurrentPosition);
-         break;
-      case GL_VERTEX_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-         params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.CurrentPosition);
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetBooleanv");
+         params[0] = ctx->Transform.DepthClamp;
          break;
       case GL_MAX_DRAW_BUFFERS_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
          break;
       case GL_DRAW_BUFFER0_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
          params[0] = ENUM_TO_BOOLEAN(ctx->DrawBuffer->ColorDrawBuffer[0]);
          break;
       case GL_DRAW_BUFFER1_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -1773,7 +1744,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          }
          break;
       case GL_DRAW_BUFFER2_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -1785,7 +1755,6 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          }
          break;
       case GL_DRAW_BUFFER3_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -1877,6 +1846,14 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          CHECK_EXT1(EXT_framebuffer_blit, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->ReadBuffer->Name);
          break;
+      case GL_PROVOKING_VERTEX_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetBooleanv");
+         params[0] = ctx->Light.ProvokingVertex;
+         break;
+      case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetBooleanv");
+         params[0] = ctx->Const.QuadsFollowProvokingVertexConvention;
+         break;
       case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
          CHECK_EXT1(ARB_fragment_shader, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Const.FragmentProgram.MaxUniformComponents);
@@ -1905,6 +1882,22 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          CHECK_EXT1(ARB_shader_objects, "GetBooleanv");
          params[0] = INT_TO_BOOLEAN(ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0);
          break;
+      case GL_MAX_SAMPLES:
+         CHECK_EXT1(ARB_framebuffer_object, "GetBooleanv");
+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxSamples);
+         break;
+      case GL_VERTEX_ARRAY_BINDING_APPLE:
+         CHECK_EXT1(APPLE_vertex_array_object, "GetBooleanv");
+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Name);
+         break;
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+         CHECK_EXT1(ARB_seamless_cube_map, "GetBooleanv");
+         params[0] = ctx->Texture.CubeMapSeamless;
+         break;
+      case GL_MAX_SERVER_WAIT_TIMEOUT:
+         CHECK_EXT1(ARB_sync, "GetBooleanv");
+         params[0] = INT64_TO_BOOLEAN(ctx->Const.MaxServerWaitTimeout);
+         break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname);
    }
@@ -2124,6 +2117,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
       case GL_CURRENT_TEXTURE_COORDS:
          {
          const GLuint texUnit = ctx->Texture.CurrentUnit;
+         FLUSH_CURRENT(ctx, 0);
          params[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
          params[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
          params[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
@@ -2308,7 +2302,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = (GLfloat)(ctx->List.ListBase);
          break;
       case GL_LIST_INDEX:
-         params[0] = (GLfloat)(ctx->ListState.CurrentListNum);
+         params[0] = (GLfloat)((ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0));
          break;
       case GL_LIST_MODE:
          {
@@ -2732,21 +2726,21 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT));
          break;
       case GL_TEXTURE_BINDING_1D:
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_2D:
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_3D:
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetFloatv");
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name);
          break;
       case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetFloatv");
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name);
          break;
       case GL_TEXTURE_GEN_S:
          params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
@@ -2919,22 +2913,19 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name);
          break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
          params[0] = (GLfloat)((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
          break;
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
          params[0] = (GLfloat)(ctx->Hint.TextureCompression);
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
          params[0] = (GLfloat)(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
          {
          GLint formats[100];
          GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
@@ -3216,35 +3207,27 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = ctx->Const.MaxTextureMaxAnisotropy;
          break;
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.Enabled);
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToCoverage);
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToOne);
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverage);
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = ctx->Multisample.SampleCoverageValue;
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverageInvert);
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = (GLfloat)(ctx->DrawBuffer->Visual.sampleBuffers);
          break;
       case GL_SAMPLES_ARB:
-         CHECK_EXT1(ARB_multisample, "GetFloatv");
          params[0] = (GLfloat)(ctx->DrawBuffer->Visual.samples);
          break;
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
@@ -3417,7 +3400,7 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_TEXTURE_BINDING_RECTANGLE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name);
          break;
       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
@@ -3440,43 +3423,33 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = ctx->Const.MaxSpotExponent;
          break;
       case GL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayBufferObj->Name);
          break;
       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
          break;
       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->Normal.BufferObj->Name);
          break;
       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.BufferObj->Name);
          break;
       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->Index.BufferObj->Name);
          break;
       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
          break;
       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
          break;
       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
          break;
       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
          break;
       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
          params[0] = (GLfloat)(ctx->Array.ElementArrayBufferObj->Name);
          break;
       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
@@ -3584,32 +3557,17 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          params[0] = ctx->Depth.BoundsMin;
          params[1] = ctx->Depth.BoundsMax;
          break;
-      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-         params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.CallbackEnabled);
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-         params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.CallbackEnabled);
-         break;
-      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-         params[0] = (GLfloat)(ctx->FragmentProgram.CurrentPosition);
-         break;
-      case GL_VERTEX_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-         params[0] = (GLfloat)(ctx->VertexProgram.CurrentPosition);
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetFloatv");
+         params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.DepthClamp);
          break;
       case GL_MAX_DRAW_BUFFERS_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
          params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
          break;
       case GL_DRAW_BUFFER0_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
          params[0] = ENUM_TO_FLOAT(ctx->DrawBuffer->ColorDrawBuffer[0]);
          break;
       case GL_DRAW_BUFFER1_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -3621,7 +3579,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          }
          break;
       case GL_DRAW_BUFFER2_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -3633,7 +3590,6 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          }
          break;
       case GL_DRAW_BUFFER3_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -3725,6 +3681,14 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          CHECK_EXT1(EXT_framebuffer_blit, "GetFloatv");
          params[0] = (GLfloat)(ctx->ReadBuffer->Name);
          break;
+      case GL_PROVOKING_VERTEX_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetFloatv");
+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.ProvokingVertex);
+         break;
+      case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetFloatv");
+         params[0] = BOOLEAN_TO_FLOAT(ctx->Const.QuadsFollowProvokingVertexConvention);
+         break;
       case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
          CHECK_EXT1(ARB_fragment_shader, "GetFloatv");
          params[0] = (GLfloat)(ctx->Const.FragmentProgram.MaxUniformComponents);
@@ -3753,6 +3717,22 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          CHECK_EXT1(ARB_shader_objects, "GetFloatv");
          params[0] = (GLfloat)(ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0);
          break;
+      case GL_MAX_SAMPLES:
+         CHECK_EXT1(ARB_framebuffer_object, "GetFloatv");
+         params[0] = (GLfloat)(ctx->Const.MaxSamples);
+         break;
+      case GL_VERTEX_ARRAY_BINDING_APPLE:
+         CHECK_EXT1(APPLE_vertex_array_object, "GetFloatv");
+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Name);
+         break;
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+         CHECK_EXT1(ARB_seamless_cube_map, "GetFloatv");
+         params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.CubeMapSeamless);
+         break;
+      case GL_MAX_SERVER_WAIT_TIMEOUT:
+         CHECK_EXT1(ARB_sync, "GetFloatv");
+         params[0] = (GLfloat)(ctx->Const.MaxServerWaitTimeout);
+         break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(pname=0x%x)", pname);
    }
@@ -3972,6 +3952,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
       case GL_CURRENT_TEXTURE_COORDS:
          {
          const GLuint texUnit = ctx->Texture.CurrentUnit;
+         FLUSH_CURRENT(ctx, 0);
          params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
          params[1] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
          params[2] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
@@ -4156,7 +4137,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = ctx->List.ListBase;
          break;
       case GL_LIST_INDEX:
-         params[0] = ctx->ListState.CurrentListNum;
+         params[0] = (ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0);
          break;
       case GL_LIST_MODE:
          {
@@ -4580,21 +4561,21 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT));
          break;
       case GL_TEXTURE_BINDING_1D:
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name;
          break;
       case GL_TEXTURE_BINDING_2D:
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name;
          break;
       case GL_TEXTURE_BINDING_3D:
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name;
          break;
       case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetIntegerv");
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name;
          break;
       case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
          CHECK_EXT1(MESA_texture_array, "GetIntegerv");
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name;
          break;
       case GL_TEXTURE_GEN_S:
          params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
@@ -4767,22 +4748,19 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name;
          break;
       case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
          CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
          params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
          break;
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
          params[0] = ctx->Hint.TextureCompression;
          break;
       case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
          params[0] = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
          break;
       case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
          {
          GLint formats[100];
          GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
@@ -5064,35 +5042,27 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = IROUND(ctx->Const.MaxTextureMaxAnisotropy);
          break;
       case GL_MULTISAMPLE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = BOOLEAN_TO_INT(ctx->Multisample.Enabled);
          break;
       case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToCoverage);
          break;
       case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToOne);
          break;
       case GL_SAMPLE_COVERAGE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverage);
          break;
       case GL_SAMPLE_COVERAGE_VALUE_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = IROUND(ctx->Multisample.SampleCoverageValue);
          break;
       case GL_SAMPLE_COVERAGE_INVERT_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverageInvert);
          break;
       case GL_SAMPLE_BUFFERS_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = ctx->DrawBuffer->Visual.sampleBuffers;
          break;
       case GL_SAMPLES_ARB:
-         CHECK_EXT1(ARB_multisample, "GetIntegerv");
          params[0] = ctx->DrawBuffer->Visual.samples;
          break;
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
@@ -5265,7 +5235,7 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_TEXTURE_BINDING_RECTANGLE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name;
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name;
          break;
       case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
          CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
@@ -5288,43 +5258,33 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = IROUND(ctx->Const.MaxSpotExponent);
          break;
       case GL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayBufferObj->Name;
          break;
       case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->Vertex.BufferObj->Name;
          break;
       case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->Normal.BufferObj->Name;
          break;
       case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->Color.BufferObj->Name;
          break;
       case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->Index.BufferObj->Name;
          break;
       case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
          break;
       case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name;
          break;
       case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name;
          break;
       case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ArrayObj->FogCoord.BufferObj->Name;
          break;
       case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
          params[0] = ctx->Array.ElementArrayBufferObj->Name;
          break;
       case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
@@ -5432,32 +5392,17 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          params[0] = IROUND(ctx->Depth.BoundsMin);
          params[1] = IROUND(ctx->Depth.BoundsMax);
          break;
-      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-         params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.CallbackEnabled);
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-         params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.CallbackEnabled);
-         break;
-      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-         params[0] = ctx->FragmentProgram.CurrentPosition;
-         break;
-      case GL_VERTEX_PROGRAM_POSITION_MESA:
-         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-         params[0] = ctx->VertexProgram.CurrentPosition;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetIntegerv");
+         params[0] = BOOLEAN_TO_INT(ctx->Transform.DepthClamp);
          break;
       case GL_MAX_DRAW_BUFFERS_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
          params[0] = ctx->Const.MaxDrawBuffers;
          break;
       case GL_DRAW_BUFFER0_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
          params[0] = ENUM_TO_INT(ctx->DrawBuffer->ColorDrawBuffer[0]);
          break;
       case GL_DRAW_BUFFER1_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -5469,7 +5414,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          }
          break;
       case GL_DRAW_BUFFER2_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -5481,7 +5425,6 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          }
          break;
       case GL_DRAW_BUFFER3_ARB:
-         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
          {
          GLenum buffer;
          if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
@@ -5573,6 +5516,14 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          CHECK_EXT1(EXT_framebuffer_blit, "GetIntegerv");
          params[0] = ctx->ReadBuffer->Name;
          break;
+      case GL_PROVOKING_VERTEX_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetIntegerv");
+         params[0] = BOOLEAN_TO_INT(ctx->Light.ProvokingVertex);
+         break;
+      case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetIntegerv");
+         params[0] = BOOLEAN_TO_INT(ctx->Const.QuadsFollowProvokingVertexConvention);
+         break;
       case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
          CHECK_EXT1(ARB_fragment_shader, "GetIntegerv");
          params[0] = ctx->Const.FragmentProgram.MaxUniformComponents;
@@ -5601,11 +5552,1864 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          CHECK_EXT1(ARB_shader_objects, "GetIntegerv");
          params[0] = ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0;
          break;
+      case GL_MAX_SAMPLES:
+         CHECK_EXT1(ARB_framebuffer_object, "GetIntegerv");
+         params[0] = ctx->Const.MaxSamples;
+         break;
+      case GL_VERTEX_ARRAY_BINDING_APPLE:
+         CHECK_EXT1(APPLE_vertex_array_object, "GetIntegerv");
+         params[0] = ctx->Array.ArrayObj->Name;
+         break;
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+         CHECK_EXT1(ARB_seamless_cube_map, "GetIntegerv");
+         params[0] = BOOLEAN_TO_INT(ctx->Texture.CubeMapSeamless);
+         break;
+      case GL_MAX_SERVER_WAIT_TIMEOUT:
+         CHECK_EXT1(ARB_sync, "GetIntegerv");
+         params[0] = INT64_TO_INT(ctx->Const.MaxServerWaitTimeout);
+         break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname);
    }
 }
 
+#if FEATURE_ARB_sync
+void GLAPIENTRY
+_mesa_GetInteger64v( GLenum pname, GLint64 *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!params)
+      return;
+
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
+
+   if (ctx->Driver.GetInteger64v &&
+       ctx->Driver.GetInteger64v(ctx, pname, params))
+      return;
+
+   switch (pname) {
+      case GL_ACCUM_RED_BITS:
+         params[0] = ctx->DrawBuffer->Visual.accumRedBits;
+         break;
+      case GL_ACCUM_GREEN_BITS:
+         params[0] = ctx->DrawBuffer->Visual.accumGreenBits;
+         break;
+      case GL_ACCUM_BLUE_BITS:
+         params[0] = ctx->DrawBuffer->Visual.accumBlueBits;
+         break;
+      case GL_ACCUM_ALPHA_BITS:
+         params[0] = ctx->DrawBuffer->Visual.accumAlphaBits;
+         break;
+      case GL_ACCUM_CLEAR_VALUE:
+         params[0] = FLOAT_TO_INT64(ctx->Accum.ClearColor[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Accum.ClearColor[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Accum.ClearColor[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Accum.ClearColor[3]);
+         break;
+      case GL_ALPHA_BIAS:
+         params[0] = IROUND64(ctx->Pixel.AlphaBias);
+         break;
+      case GL_ALPHA_BITS:
+         params[0] = ctx->DrawBuffer->Visual.alphaBits;
+         break;
+      case GL_ALPHA_SCALE:
+         params[0] = IROUND64(ctx->Pixel.AlphaScale);
+         break;
+      case GL_ALPHA_TEST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Color.AlphaEnabled);
+         break;
+      case GL_ALPHA_TEST_FUNC:
+         params[0] = ENUM_TO_INT64(ctx->Color.AlphaFunc);
+         break;
+      case GL_ALPHA_TEST_REF:
+         params[0] = FLOAT_TO_INT64(ctx->Color.AlphaRef);
+         break;
+      case GL_ATTRIB_STACK_DEPTH:
+         params[0] = ctx->AttribStackDepth;
+         break;
+      case GL_AUTO_NORMAL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.AutoNormal);
+         break;
+      case GL_AUX_BUFFERS:
+         params[0] = ctx->DrawBuffer->Visual.numAuxBuffers;
+         break;
+      case GL_BLEND:
+         params[0] = BOOLEAN_TO_INT64(ctx->Color.BlendEnabled);
+         break;
+      case GL_BLEND_DST:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendDstRGB);
+         break;
+      case GL_BLEND_SRC:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcRGB);
+         break;
+      case GL_BLEND_SRC_RGB_EXT:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcRGB);
+         break;
+      case GL_BLEND_DST_RGB_EXT:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendDstRGB);
+         break;
+      case GL_BLEND_SRC_ALPHA_EXT:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendSrcA);
+         break;
+      case GL_BLEND_DST_ALPHA_EXT:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendDstA);
+         break;
+      case GL_BLEND_EQUATION:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendEquationRGB );
+         break;
+      case GL_BLEND_EQUATION_ALPHA_EXT:
+         params[0] = ENUM_TO_INT64(ctx->Color.BlendEquationA );
+         break;
+      case GL_BLEND_COLOR_EXT:
+         params[0] = FLOAT_TO_INT64(ctx->Color.BlendColor[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Color.BlendColor[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Color.BlendColor[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Color.BlendColor[3]);
+         break;
+      case GL_BLUE_BIAS:
+         params[0] = IROUND64(ctx->Pixel.BlueBias);
+         break;
+      case GL_BLUE_BITS:
+         params[0] = ctx->DrawBuffer->Visual.blueBits;
+         break;
+      case GL_BLUE_SCALE:
+         params[0] = IROUND64(ctx->Pixel.BlueScale);
+         break;
+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
+         params[0] = ctx->ClientAttribStackDepth;
+         break;
+      case GL_CLIP_PLANE0:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
+         break;
+      case GL_CLIP_PLANE1:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
+         break;
+      case GL_CLIP_PLANE2:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
+         break;
+      case GL_CLIP_PLANE3:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
+         break;
+      case GL_CLIP_PLANE4:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
+         break;
+      case GL_CLIP_PLANE5:
+         params[0] = BOOLEAN_TO_INT64((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
+         break;
+      case GL_COLOR_CLEAR_VALUE:
+         params[0] = FLOAT_TO_INT64(ctx->Color.ClearColor[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Color.ClearColor[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Color.ClearColor[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Color.ClearColor[3]);
+         break;
+      case GL_COLOR_MATERIAL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.ColorMaterialEnabled);
+         break;
+      case GL_COLOR_MATERIAL_FACE:
+         params[0] = ENUM_TO_INT64(ctx->Light.ColorMaterialFace);
+         break;
+      case GL_COLOR_MATERIAL_PARAMETER:
+         params[0] = ENUM_TO_INT64(ctx->Light.ColorMaterialMode);
+         break;
+      case GL_COLOR_WRITEMASK:
+         params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
+         params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
+         params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
+         params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
+         break;
+      case GL_CULL_FACE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.CullFlag);
+         break;
+      case GL_CULL_FACE_MODE:
+         params[0] = ENUM_TO_INT64(ctx->Polygon.CullFaceMode);
+         break;
+      case GL_CURRENT_COLOR:
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
+         params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
+         params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
+         params[3] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
+         }
+         break;
+      case GL_CURRENT_INDEX:
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]);
+         }
+         break;
+      case GL_CURRENT_NORMAL:
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
+         params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
+         params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
+         }
+         break;
+      case GL_CURRENT_RASTER_COLOR:
+         params[0] = FLOAT_TO_INT64(ctx->Current.RasterColor[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Current.RasterColor[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Current.RasterColor[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Current.RasterColor[3]);
+         break;
+      case GL_CURRENT_RASTER_DISTANCE:
+         params[0] = IROUND64(ctx->Current.RasterDistance);
+         break;
+      case GL_CURRENT_RASTER_INDEX:
+         params[0] = IROUND64(ctx->Current.RasterIndex);
+         break;
+      case GL_CURRENT_RASTER_POSITION:
+         params[0] = IROUND64(ctx->Current.RasterPos[0]);
+         params[1] = IROUND64(ctx->Current.RasterPos[1]);
+         params[2] = IROUND64(ctx->Current.RasterPos[2]);
+         params[3] = IROUND64(ctx->Current.RasterPos[3]);
+         break;
+      case GL_CURRENT_RASTER_SECONDARY_COLOR:
+         params[0] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Current.RasterSecondaryColor[3]);
+         break;
+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
+         {
+         const GLuint texUnit = ctx->Texture.CurrentUnit;
+         params[0] = IROUND64(ctx->Current.RasterTexCoords[texUnit][0]);
+         params[1] = IROUND64(ctx->Current.RasterTexCoords[texUnit][1]);
+         params[2] = IROUND64(ctx->Current.RasterTexCoords[texUnit][2]);
+         params[3] = IROUND64(ctx->Current.RasterTexCoords[texUnit][3]);
+         }
+         break;
+      case GL_CURRENT_RASTER_POSITION_VALID:
+         params[0] = BOOLEAN_TO_INT64(ctx->Current.RasterPosValid);
+         break;
+      case GL_CURRENT_TEXTURE_COORDS:
+         {
+         const GLuint texUnit = ctx->Texture.CurrentUnit;
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
+         params[1] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
+         params[2] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
+         params[3] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
+         }
+         break;
+      case GL_DEPTH_BIAS:
+         params[0] = IROUND64(ctx->Pixel.DepthBias);
+         break;
+      case GL_DEPTH_BITS:
+         params[0] = ctx->DrawBuffer->Visual.depthBits;
+         break;
+      case GL_DEPTH_CLEAR_VALUE:
+         params[0] = FLOAT_TO_INT64(((GLfloat) ctx->Depth.Clear));
+         break;
+      case GL_DEPTH_FUNC:
+         params[0] = ENUM_TO_INT64(ctx->Depth.Func);
+         break;
+      case GL_DEPTH_RANGE:
+         params[0] = FLOAT_TO_INT64(ctx->Viewport.Near);
+         params[1] = FLOAT_TO_INT64(ctx->Viewport.Far);
+         break;
+      case GL_DEPTH_SCALE:
+         params[0] = IROUND64(ctx->Pixel.DepthScale);
+         break;
+      case GL_DEPTH_TEST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Depth.Test);
+         break;
+      case GL_DEPTH_WRITEMASK:
+         params[0] = BOOLEAN_TO_INT64(ctx->Depth.Mask);
+         break;
+      case GL_DITHER:
+         params[0] = BOOLEAN_TO_INT64(ctx->Color.DitherFlag);
+         break;
+      case GL_DOUBLEBUFFER:
+         params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.doubleBufferMode);
+         break;
+      case GL_DRAW_BUFFER:
+         params[0] = ENUM_TO_INT64(ctx->DrawBuffer->ColorDrawBuffer[0]);
+         break;
+      case GL_EDGE_FLAG:
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = BOOLEAN_TO_INT64((ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0));
+         }
+         break;
+      case GL_FEEDBACK_BUFFER_SIZE:
+         params[0] = ctx->Feedback.BufferSize;
+         break;
+      case GL_FEEDBACK_BUFFER_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Feedback.Type);
+         break;
+      case GL_FOG:
+         params[0] = BOOLEAN_TO_INT64(ctx->Fog.Enabled);
+         break;
+      case GL_FOG_COLOR:
+         params[0] = FLOAT_TO_INT64(ctx->Fog.Color[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Fog.Color[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Fog.Color[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Fog.Color[3]);
+         break;
+      case GL_FOG_DENSITY:
+         params[0] = IROUND64(ctx->Fog.Density);
+         break;
+      case GL_FOG_END:
+         params[0] = IROUND64(ctx->Fog.End);
+         break;
+      case GL_FOG_HINT:
+         params[0] = ENUM_TO_INT64(ctx->Hint.Fog);
+         break;
+      case GL_FOG_INDEX:
+         params[0] = IROUND64(ctx->Fog.Index);
+         break;
+      case GL_FOG_MODE:
+         params[0] = ENUM_TO_INT64(ctx->Fog.Mode);
+         break;
+      case GL_FOG_START:
+         params[0] = IROUND64(ctx->Fog.Start);
+         break;
+      case GL_FRONT_FACE:
+         params[0] = ENUM_TO_INT64(ctx->Polygon.FrontFace);
+         break;
+      case GL_GREEN_BIAS:
+         params[0] = IROUND64(ctx->Pixel.GreenBias);
+         break;
+      case GL_GREEN_BITS:
+         params[0] = ctx->DrawBuffer->Visual.greenBits;
+         break;
+      case GL_GREEN_SCALE:
+         params[0] = IROUND64(ctx->Pixel.GreenScale);
+         break;
+      case GL_INDEX_BITS:
+         params[0] = ctx->DrawBuffer->Visual.indexBits;
+         break;
+      case GL_INDEX_CLEAR_VALUE:
+         params[0] = ctx->Color.ClearIndex;
+         break;
+      case GL_INDEX_MODE:
+         params[0] = BOOLEAN_TO_INT64(!ctx->DrawBuffer->Visual.rgbMode);
+         break;
+      case GL_INDEX_OFFSET:
+         params[0] = ctx->Pixel.IndexOffset;
+         break;
+      case GL_INDEX_SHIFT:
+         params[0] = ctx->Pixel.IndexShift;
+         break;
+      case GL_INDEX_WRITEMASK:
+         params[0] = ctx->Color.IndexMask;
+         break;
+      case GL_LIGHT0:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[0].Enabled);
+         break;
+      case GL_LIGHT1:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[1].Enabled);
+         break;
+      case GL_LIGHT2:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[2].Enabled);
+         break;
+      case GL_LIGHT3:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[3].Enabled);
+         break;
+      case GL_LIGHT4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[4].Enabled);
+         break;
+      case GL_LIGHT5:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[5].Enabled);
+         break;
+      case GL_LIGHT6:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[6].Enabled);
+         break;
+      case GL_LIGHT7:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Light[7].Enabled);
+         break;
+      case GL_LIGHTING:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Enabled);
+         break;
+      case GL_LIGHT_MODEL_AMBIENT:
+         params[0] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[0]);
+         params[1] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[1]);
+         params[2] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[2]);
+         params[3] = FLOAT_TO_INT64(ctx->Light.Model.Ambient[3]);
+         break;
+      case GL_LIGHT_MODEL_COLOR_CONTROL:
+         params[0] = ENUM_TO_INT64(ctx->Light.Model.ColorControl);
+         break;
+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Model.LocalViewer);
+         break;
+      case GL_LIGHT_MODEL_TWO_SIDE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.Model.TwoSide);
+         break;
+      case GL_LINE_SMOOTH:
+         params[0] = BOOLEAN_TO_INT64(ctx->Line.SmoothFlag);
+         break;
+      case GL_LINE_SMOOTH_HINT:
+         params[0] = ENUM_TO_INT64(ctx->Hint.LineSmooth);
+         break;
+      case GL_LINE_STIPPLE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Line.StippleFlag);
+         break;
+      case GL_LINE_STIPPLE_PATTERN:
+         params[0] = ctx->Line.StipplePattern;
+         break;
+      case GL_LINE_STIPPLE_REPEAT:
+         params[0] = ctx->Line.StippleFactor;
+         break;
+      case GL_LINE_WIDTH:
+         params[0] = IROUND64(ctx->Line.Width);
+         break;
+      case GL_LINE_WIDTH_GRANULARITY:
+         params[0] = IROUND64(ctx->Const.LineWidthGranularity);
+         break;
+      case GL_LINE_WIDTH_RANGE:
+         params[0] = IROUND64(ctx->Const.MinLineWidthAA);
+         params[1] = IROUND64(ctx->Const.MaxLineWidthAA);
+         break;
+      case GL_ALIASED_LINE_WIDTH_RANGE:
+         params[0] = IROUND64(ctx->Const.MinLineWidth);
+         params[1] = IROUND64(ctx->Const.MaxLineWidth);
+         break;
+      case GL_LIST_BASE:
+         params[0] = ctx->List.ListBase;
+         break;
+      case GL_LIST_INDEX:
+         params[0] = (ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0);
+         break;
+      case GL_LIST_MODE:
+         {
+         GLenum mode;
+         if (!ctx->CompileFlag)
+            mode = 0;
+         else if (ctx->ExecuteFlag)
+            mode = GL_COMPILE_AND_EXECUTE;
+         else
+            mode = GL_COMPILE;
+         params[0] = ENUM_TO_INT64(mode);
+         }
+         break;
+      case GL_INDEX_LOGIC_OP:
+         params[0] = BOOLEAN_TO_INT64(ctx->Color.IndexLogicOpEnabled);
+         break;
+      case GL_COLOR_LOGIC_OP:
+         params[0] = BOOLEAN_TO_INT64(ctx->Color.ColorLogicOpEnabled);
+         break;
+      case GL_LOGIC_OP_MODE:
+         params[0] = ENUM_TO_INT64(ctx->Color.LogicOp);
+         break;
+      case GL_MAP1_COLOR_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Color4);
+         break;
+      case GL_MAP1_GRID_DOMAIN:
+         params[0] = IROUND64(ctx->Eval.MapGrid1u1);
+         params[1] = IROUND64(ctx->Eval.MapGrid1u2);
+         break;
+      case GL_MAP1_GRID_SEGMENTS:
+         params[0] = ctx->Eval.MapGrid1un;
+         break;
+      case GL_MAP1_INDEX:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Index);
+         break;
+      case GL_MAP1_NORMAL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Normal);
+         break;
+      case GL_MAP1_TEXTURE_COORD_1:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord1);
+         break;
+      case GL_MAP1_TEXTURE_COORD_2:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord2);
+         break;
+      case GL_MAP1_TEXTURE_COORD_3:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord3);
+         break;
+      case GL_MAP1_TEXTURE_COORD_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1TextureCoord4);
+         break;
+      case GL_MAP1_VERTEX_3:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Vertex3);
+         break;
+      case GL_MAP1_VERTEX_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Vertex4);
+         break;
+      case GL_MAP2_COLOR_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Color4);
+         break;
+      case GL_MAP2_GRID_DOMAIN:
+         params[0] = IROUND64(ctx->Eval.MapGrid2u1);
+         params[1] = IROUND64(ctx->Eval.MapGrid2u2);
+         params[2] = IROUND64(ctx->Eval.MapGrid2v1);
+         params[3] = IROUND64(ctx->Eval.MapGrid2v2);
+         break;
+      case GL_MAP2_GRID_SEGMENTS:
+         params[0] = ctx->Eval.MapGrid2un;
+         params[1] = ctx->Eval.MapGrid2vn;
+         break;
+      case GL_MAP2_INDEX:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Index);
+         break;
+      case GL_MAP2_NORMAL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Normal);
+         break;
+      case GL_MAP2_TEXTURE_COORD_1:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord1);
+         break;
+      case GL_MAP2_TEXTURE_COORD_2:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord2);
+         break;
+      case GL_MAP2_TEXTURE_COORD_3:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord3);
+         break;
+      case GL_MAP2_TEXTURE_COORD_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2TextureCoord4);
+         break;
+      case GL_MAP2_VERTEX_3:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Vertex3);
+         break;
+      case GL_MAP2_VERTEX_4:
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map2Vertex4);
+         break;
+      case GL_MAP_COLOR:
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MapColorFlag);
+         break;
+      case GL_MAP_STENCIL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MapStencilFlag);
+         break;
+      case GL_MATRIX_MODE:
+         params[0] = ENUM_TO_INT64(ctx->Transform.MatrixMode);
+         break;
+      case GL_MAX_ATTRIB_STACK_DEPTH:
+         params[0] = MAX_ATTRIB_STACK_DEPTH;
+         break;
+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+         params[0] = MAX_CLIENT_ATTRIB_STACK_DEPTH;
+         break;
+      case GL_MAX_CLIP_PLANES:
+         params[0] = ctx->Const.MaxClipPlanes;
+         break;
+      case GL_MAX_ELEMENTS_VERTICES:
+         params[0] = ctx->Const.MaxArrayLockSize;
+         break;
+      case GL_MAX_ELEMENTS_INDICES:
+         params[0] = ctx->Const.MaxArrayLockSize;
+         break;
+      case GL_MAX_EVAL_ORDER:
+         params[0] = MAX_EVAL_ORDER;
+         break;
+      case GL_MAX_LIGHTS:
+         params[0] = ctx->Const.MaxLights;
+         break;
+      case GL_MAX_LIST_NESTING:
+         params[0] = MAX_LIST_NESTING;
+         break;
+      case GL_MAX_MODELVIEW_STACK_DEPTH:
+         params[0] = MAX_MODELVIEW_STACK_DEPTH;
+         break;
+      case GL_MAX_NAME_STACK_DEPTH:
+         params[0] = MAX_NAME_STACK_DEPTH;
+         break;
+      case GL_MAX_PIXEL_MAP_TABLE:
+         params[0] = MAX_PIXEL_MAP_TABLE;
+         break;
+      case GL_MAX_PROJECTION_STACK_DEPTH:
+         params[0] = MAX_PROJECTION_STACK_DEPTH;
+         break;
+      case GL_MAX_TEXTURE_SIZE:
+         params[0] = 1 << (ctx->Const.MaxTextureLevels - 1);
+         break;
+      case GL_MAX_3D_TEXTURE_SIZE:
+         params[0] = 1 << (ctx->Const.Max3DTextureLevels - 1);
+         break;
+      case GL_MAX_TEXTURE_STACK_DEPTH:
+         params[0] = MAX_TEXTURE_STACK_DEPTH;
+         break;
+      case GL_MAX_VIEWPORT_DIMS:
+         params[0] = ctx->Const.MaxViewportWidth;
+         params[1] = ctx->Const.MaxViewportHeight;
+         break;
+      case GL_MODELVIEW_MATRIX:
+         {
+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[1]);
+         params[2] = IROUND64(matrix[2]);
+         params[3] = IROUND64(matrix[3]);
+         params[4] = IROUND64(matrix[4]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[6]);
+         params[7] = IROUND64(matrix[7]);
+         params[8] = IROUND64(matrix[8]);
+         params[9] = IROUND64(matrix[9]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[11]);
+         params[12] = IROUND64(matrix[12]);
+         params[13] = IROUND64(matrix[13]);
+         params[14] = IROUND64(matrix[14]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_MODELVIEW_STACK_DEPTH:
+         params[0] = ctx->ModelviewMatrixStack.Depth + 1;
+         break;
+      case GL_NAME_STACK_DEPTH:
+         params[0] = ctx->Select.NameStackDepth;
+         break;
+      case GL_NORMALIZE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Transform.Normalize);
+         break;
+      case GL_PACK_ALIGNMENT:
+         params[0] = ctx->Pack.Alignment;
+         break;
+      case GL_PACK_LSB_FIRST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Pack.LsbFirst);
+         break;
+      case GL_PACK_ROW_LENGTH:
+         params[0] = ctx->Pack.RowLength;
+         break;
+      case GL_PACK_SKIP_PIXELS:
+         params[0] = ctx->Pack.SkipPixels;
+         break;
+      case GL_PACK_SKIP_ROWS:
+         params[0] = ctx->Pack.SkipRows;
+         break;
+      case GL_PACK_SWAP_BYTES:
+         params[0] = BOOLEAN_TO_INT64(ctx->Pack.SwapBytes);
+         break;
+      case GL_PACK_SKIP_IMAGES_EXT:
+         params[0] = ctx->Pack.SkipImages;
+         break;
+      case GL_PACK_IMAGE_HEIGHT_EXT:
+         params[0] = ctx->Pack.ImageHeight;
+         break;
+      case GL_PACK_INVERT_MESA:
+         params[0] = BOOLEAN_TO_INT64(ctx->Pack.Invert);
+         break;
+      case GL_PERSPECTIVE_CORRECTION_HINT:
+         params[0] = ENUM_TO_INT64(ctx->Hint.PerspectiveCorrection);
+         break;
+      case GL_PIXEL_MAP_A_TO_A_SIZE:
+         params[0] = ctx->PixelMaps.AtoA.Size;
+         break;
+      case GL_PIXEL_MAP_B_TO_B_SIZE:
+         params[0] = ctx->PixelMaps.BtoB.Size;
+         break;
+      case GL_PIXEL_MAP_G_TO_G_SIZE:
+         params[0] = ctx->PixelMaps.GtoG.Size;
+         break;
+      case GL_PIXEL_MAP_I_TO_A_SIZE:
+         params[0] = ctx->PixelMaps.ItoA.Size;
+         break;
+      case GL_PIXEL_MAP_I_TO_B_SIZE:
+         params[0] = ctx->PixelMaps.ItoB.Size;
+         break;
+      case GL_PIXEL_MAP_I_TO_G_SIZE:
+         params[0] = ctx->PixelMaps.ItoG.Size;
+         break;
+      case GL_PIXEL_MAP_I_TO_I_SIZE:
+         params[0] = ctx->PixelMaps.ItoI.Size;
+         break;
+      case GL_PIXEL_MAP_I_TO_R_SIZE:
+         params[0] = ctx->PixelMaps.ItoR.Size;
+         break;
+      case GL_PIXEL_MAP_R_TO_R_SIZE:
+         params[0] = ctx->PixelMaps.RtoR.Size;
+         break;
+      case GL_PIXEL_MAP_S_TO_S_SIZE:
+         params[0] = ctx->PixelMaps.StoS.Size;
+         break;
+      case GL_POINT_SIZE:
+         params[0] = IROUND64(ctx->Point.Size);
+         break;
+      case GL_POINT_SIZE_GRANULARITY:
+         params[0] = IROUND64(ctx->Const.PointSizeGranularity);
+         break;
+      case GL_POINT_SIZE_RANGE:
+         params[0] = IROUND64(ctx->Const.MinPointSizeAA);
+         params[1] = IROUND64(ctx->Const.MaxPointSizeAA);
+         break;
+      case GL_ALIASED_POINT_SIZE_RANGE:
+         params[0] = IROUND64(ctx->Const.MinPointSize);
+         params[1] = IROUND64(ctx->Const.MaxPointSize);
+         break;
+      case GL_POINT_SMOOTH:
+         params[0] = BOOLEAN_TO_INT64(ctx->Point.SmoothFlag);
+         break;
+      case GL_POINT_SMOOTH_HINT:
+         params[0] = ENUM_TO_INT64(ctx->Hint.PointSmooth);
+         break;
+      case GL_POINT_SIZE_MIN_EXT:
+         params[0] = IROUND64(ctx->Point.MinSize);
+         break;
+      case GL_POINT_SIZE_MAX_EXT:
+         params[0] = IROUND64(ctx->Point.MaxSize);
+         break;
+      case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
+         params[0] = IROUND64(ctx->Point.Threshold);
+         break;
+      case GL_DISTANCE_ATTENUATION_EXT:
+         params[0] = IROUND64(ctx->Point.Params[0]);
+         params[1] = IROUND64(ctx->Point.Params[1]);
+         params[2] = IROUND64(ctx->Point.Params[2]);
+         break;
+      case GL_POLYGON_MODE:
+         params[0] = ENUM_TO_INT64(ctx->Polygon.FrontMode);
+         params[1] = ENUM_TO_INT64(ctx->Polygon.BackMode);
+         break;
+      case GL_POLYGON_OFFSET_BIAS_EXT:
+         params[0] = IROUND64(ctx->Polygon.OffsetUnits);
+         break;
+      case GL_POLYGON_OFFSET_FACTOR:
+         params[0] = IROUND64(ctx->Polygon.OffsetFactor );
+         break;
+      case GL_POLYGON_OFFSET_UNITS:
+         params[0] = IROUND64(ctx->Polygon.OffsetUnits );
+         break;
+      case GL_POLYGON_OFFSET_POINT:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetPoint);
+         break;
+      case GL_POLYGON_OFFSET_LINE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetLine);
+         break;
+      case GL_POLYGON_OFFSET_FILL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.OffsetFill);
+         break;
+      case GL_POLYGON_SMOOTH:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.SmoothFlag);
+         break;
+      case GL_POLYGON_SMOOTH_HINT:
+         params[0] = ENUM_TO_INT64(ctx->Hint.PolygonSmooth);
+         break;
+      case GL_POLYGON_STIPPLE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Polygon.StippleFlag);
+         break;
+      case GL_PROJECTION_MATRIX:
+         {
+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[1]);
+         params[2] = IROUND64(matrix[2]);
+         params[3] = IROUND64(matrix[3]);
+         params[4] = IROUND64(matrix[4]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[6]);
+         params[7] = IROUND64(matrix[7]);
+         params[8] = IROUND64(matrix[8]);
+         params[9] = IROUND64(matrix[9]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[11]);
+         params[12] = IROUND64(matrix[12]);
+         params[13] = IROUND64(matrix[13]);
+         params[14] = IROUND64(matrix[14]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_PROJECTION_STACK_DEPTH:
+         params[0] = ctx->ProjectionMatrixStack.Depth + 1;
+         break;
+      case GL_READ_BUFFER:
+         params[0] = ENUM_TO_INT64(ctx->ReadBuffer->ColorReadBuffer);
+         break;
+      case GL_RED_BIAS:
+         params[0] = IROUND64(ctx->Pixel.RedBias);
+         break;
+      case GL_RED_BITS:
+         params[0] = ctx->DrawBuffer->Visual.redBits;
+         break;
+      case GL_RED_SCALE:
+         params[0] = IROUND64(ctx->Pixel.RedScale);
+         break;
+      case GL_RENDER_MODE:
+         params[0] = ENUM_TO_INT64(ctx->RenderMode);
+         break;
+      case GL_RESCALE_NORMAL:
+         params[0] = BOOLEAN_TO_INT64(ctx->Transform.RescaleNormals);
+         break;
+      case GL_RGBA_MODE:
+         params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.rgbMode);
+         break;
+      case GL_SCISSOR_BOX:
+         params[0] = ctx->Scissor.X;
+         params[1] = ctx->Scissor.Y;
+         params[2] = ctx->Scissor.Width;
+         params[3] = ctx->Scissor.Height;
+         break;
+      case GL_SCISSOR_TEST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Scissor.Enabled);
+         break;
+      case GL_SELECTION_BUFFER_SIZE:
+         params[0] = ctx->Select.BufferSize;
+         break;
+      case GL_SHADE_MODEL:
+         params[0] = ENUM_TO_INT64(ctx->Light.ShadeModel);
+         break;
+      case GL_SHARED_TEXTURE_PALETTE_EXT:
+         params[0] = BOOLEAN_TO_INT64(ctx->Texture.SharedPalette);
+         break;
+      case GL_STENCIL_BITS:
+         params[0] = ctx->DrawBuffer->Visual.stencilBits;
+         break;
+      case GL_STENCIL_CLEAR_VALUE:
+         params[0] = ctx->Stencil.Clear;
+         break;
+      case GL_STENCIL_FAIL:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
+         break;
+      case GL_STENCIL_FUNC:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
+         break;
+      case GL_STENCIL_PASS_DEPTH_FAIL:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
+         break;
+      case GL_STENCIL_PASS_DEPTH_PASS:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
+         break;
+      case GL_STENCIL_REF:
+         params[0] = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
+         break;
+      case GL_STENCIL_TEST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Stencil.Enabled);
+         break;
+      case GL_STENCIL_VALUE_MASK:
+         params[0] = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
+         break;
+      case GL_STENCIL_WRITEMASK:
+         params[0] = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
+         break;
+      case GL_STEREO:
+         params[0] = BOOLEAN_TO_INT64(ctx->DrawBuffer->Visual.stereoMode);
+         break;
+      case GL_SUBPIXEL_BITS:
+         params[0] = ctx->Const.SubPixelBits;
+         break;
+      case GL_TEXTURE_1D:
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_1D));
+         break;
+      case GL_TEXTURE_2D:
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_2D));
+         break;
+      case GL_TEXTURE_3D:
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_3D));
+         break;
+      case GL_TEXTURE_1D_ARRAY_EXT:
+         CHECK_EXT1(MESA_texture_array, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_1D_ARRAY_EXT));
+         break;
+      case GL_TEXTURE_2D_ARRAY_EXT:
+         CHECK_EXT1(MESA_texture_array, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT));
+         break;
+      case GL_TEXTURE_BINDING_1D:
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name;
+         break;
+      case GL_TEXTURE_BINDING_2D:
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name;
+         break;
+      case GL_TEXTURE_BINDING_3D:
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name;
+         break;
+      case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
+         CHECK_EXT1(MESA_texture_array, "GetInteger64v");
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name;
+         break;
+      case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
+         CHECK_EXT1(MESA_texture_array, "GetInteger64v");
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name;
+         break;
+      case GL_TEXTURE_GEN_S:
+         params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
+         break;
+      case GL_TEXTURE_GEN_T:
+         params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
+         break;
+      case GL_TEXTURE_GEN_R:
+         params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
+         break;
+      case GL_TEXTURE_GEN_Q:
+         params[0] = BOOLEAN_TO_INT64(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
+         break;
+      case GL_TEXTURE_MATRIX:
+         {
+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[1]);
+         params[2] = IROUND64(matrix[2]);
+         params[3] = IROUND64(matrix[3]);
+         params[4] = IROUND64(matrix[4]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[6]);
+         params[7] = IROUND64(matrix[7]);
+         params[8] = IROUND64(matrix[8]);
+         params[9] = IROUND64(matrix[9]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[11]);
+         params[12] = IROUND64(matrix[12]);
+         params[13] = IROUND64(matrix[13]);
+         params[14] = IROUND64(matrix[14]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_TEXTURE_STACK_DEPTH:
+         params[0] = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1;
+         break;
+      case GL_UNPACK_ALIGNMENT:
+         params[0] = ctx->Unpack.Alignment;
+         break;
+      case GL_UNPACK_LSB_FIRST:
+         params[0] = BOOLEAN_TO_INT64(ctx->Unpack.LsbFirst);
+         break;
+      case GL_UNPACK_ROW_LENGTH:
+         params[0] = ctx->Unpack.RowLength;
+         break;
+      case GL_UNPACK_SKIP_PIXELS:
+         params[0] = ctx->Unpack.SkipPixels;
+         break;
+      case GL_UNPACK_SKIP_ROWS:
+         params[0] = ctx->Unpack.SkipRows;
+         break;
+      case GL_UNPACK_SWAP_BYTES:
+         params[0] = BOOLEAN_TO_INT64(ctx->Unpack.SwapBytes);
+         break;
+      case GL_UNPACK_SKIP_IMAGES_EXT:
+         params[0] = ctx->Unpack.SkipImages;
+         break;
+      case GL_UNPACK_IMAGE_HEIGHT_EXT:
+         params[0] = ctx->Unpack.ImageHeight;
+         break;
+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
+         params[0] = BOOLEAN_TO_INT64(ctx->Unpack.ClientStorage);
+         break;
+      case GL_VIEWPORT:
+         params[0] = ctx->Viewport.X;
+         params[1] = ctx->Viewport.Y;
+         params[2] = ctx->Viewport.Width;
+         params[3] = ctx->Viewport.Height;
+         break;
+      case GL_ZOOM_X:
+         params[0] = IROUND64(ctx->Pixel.ZoomX);
+         break;
+      case GL_ZOOM_Y:
+         params[0] = IROUND64(ctx->Pixel.ZoomY);
+         break;
+      case GL_VERTEX_ARRAY:
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Vertex.Enabled);
+         break;
+      case GL_VERTEX_ARRAY_SIZE:
+         params[0] = ctx->Array.ArrayObj->Vertex.Size;
+         break;
+      case GL_VERTEX_ARRAY_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Vertex.Type);
+         break;
+      case GL_VERTEX_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->Vertex.Stride;
+         break;
+      case GL_VERTEX_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_NORMAL_ARRAY:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Normal.Enabled);
+         break;
+      case GL_NORMAL_ARRAY_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Normal.Type);
+         break;
+      case GL_NORMAL_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->Normal.Stride;
+         break;
+      case GL_NORMAL_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_COLOR_ARRAY:
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Color.Enabled);
+         break;
+      case GL_COLOR_ARRAY_SIZE:
+         params[0] = ctx->Array.ArrayObj->Color.Size;
+         break;
+      case GL_COLOR_ARRAY_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Color.Type);
+         break;
+      case GL_COLOR_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->Color.Stride;
+         break;
+      case GL_COLOR_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_INDEX_ARRAY:
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->Index.Enabled);
+         break;
+      case GL_INDEX_ARRAY_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->Index.Type);
+         break;
+      case GL_INDEX_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->Index.Stride;
+         break;
+      case GL_INDEX_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_TEXTURE_COORD_ARRAY:
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled);
+         break;
+      case GL_TEXTURE_COORD_ARRAY_SIZE:
+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size;
+         break;
+      case GL_TEXTURE_COORD_ARRAY_TYPE:
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
+         break;
+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride;
+         break;
+      case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_EDGE_FLAG_ARRAY:
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->EdgeFlag.Enabled);
+         break;
+      case GL_EDGE_FLAG_ARRAY_STRIDE:
+         params[0] = ctx->Array.ArrayObj->EdgeFlag.Stride;
+         break;
+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
+         params[0] = 0;
+         break;
+      case GL_MAX_TEXTURE_UNITS_ARB:
+         CHECK_EXT1(ARB_multitexture, "GetInteger64v");
+         params[0] = ctx->Const.MaxTextureUnits;
+         break;
+      case GL_ACTIVE_TEXTURE_ARB:
+         CHECK_EXT1(ARB_multitexture, "GetInteger64v");
+         params[0] = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
+         break;
+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
+         CHECK_EXT1(ARB_multitexture, "GetInteger64v");
+         params[0] = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
+         break;
+      case GL_TEXTURE_CUBE_MAP_ARB:
+         CHECK_EXT1(ARB_texture_cube_map, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
+         break;
+      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
+         CHECK_EXT1(ARB_texture_cube_map, "GetInteger64v");
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name;
+         break;
+      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
+         CHECK_EXT1(ARB_texture_cube_map, "GetInteger64v");
+         params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
+         break;
+      case GL_TEXTURE_COMPRESSION_HINT_ARB:
+         params[0] = ctx->Hint.TextureCompression;
+         break;
+      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
+         params[0] = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
+         break;
+      case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
+         {
+         GLint formats[100];
+         GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
+         ASSERT(n <= 100);
+         for (i = 0; i < n; i++)
+            params[i] = ENUM_TO_INT64(formats[i]);
+         }
+         break;
+      case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
+         CHECK_EXT1(EXT_compiled_vertex_array, "GetInteger64v");
+         params[0] = ctx->Array.LockFirst;
+         break;
+      case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
+         CHECK_EXT1(EXT_compiled_vertex_array, "GetInteger64v");
+         params[0] = ctx->Array.LockCount;
+         break;
+      case GL_TRANSPOSE_COLOR_MATRIX_ARB:
+         {
+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[4]);
+         params[2] = IROUND64(matrix[8]);
+         params[3] = IROUND64(matrix[12]);
+         params[4] = IROUND64(matrix[1]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[9]);
+         params[7] = IROUND64(matrix[13]);
+         params[8] = IROUND64(matrix[2]);
+         params[9] = IROUND64(matrix[6]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[14]);
+         params[12] = IROUND64(matrix[3]);
+         params[13] = IROUND64(matrix[7]);
+         params[14] = IROUND64(matrix[11]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
+         {
+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[4]);
+         params[2] = IROUND64(matrix[8]);
+         params[3] = IROUND64(matrix[12]);
+         params[4] = IROUND64(matrix[1]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[9]);
+         params[7] = IROUND64(matrix[13]);
+         params[8] = IROUND64(matrix[2]);
+         params[9] = IROUND64(matrix[6]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[14]);
+         params[12] = IROUND64(matrix[3]);
+         params[13] = IROUND64(matrix[7]);
+         params[14] = IROUND64(matrix[11]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
+         {
+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[4]);
+         params[2] = IROUND64(matrix[8]);
+         params[3] = IROUND64(matrix[12]);
+         params[4] = IROUND64(matrix[1]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[9]);
+         params[7] = IROUND64(matrix[13]);
+         params[8] = IROUND64(matrix[2]);
+         params[9] = IROUND64(matrix[6]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[14]);
+         params[12] = IROUND64(matrix[3]);
+         params[13] = IROUND64(matrix[7]);
+         params[14] = IROUND64(matrix[11]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
+         {
+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[4]);
+         params[2] = IROUND64(matrix[8]);
+         params[3] = IROUND64(matrix[12]);
+         params[4] = IROUND64(matrix[1]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[9]);
+         params[7] = IROUND64(matrix[13]);
+         params[8] = IROUND64(matrix[2]);
+         params[9] = IROUND64(matrix[6]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[14]);
+         params[12] = IROUND64(matrix[3]);
+         params[13] = IROUND64(matrix[7]);
+         params[14] = IROUND64(matrix[11]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_COLOR_MATRIX_SGI:
+         {
+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[1]);
+         params[2] = IROUND64(matrix[2]);
+         params[3] = IROUND64(matrix[3]);
+         params[4] = IROUND64(matrix[4]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[6]);
+         params[7] = IROUND64(matrix[7]);
+         params[8] = IROUND64(matrix[8]);
+         params[9] = IROUND64(matrix[9]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[11]);
+         params[12] = IROUND64(matrix[12]);
+         params[13] = IROUND64(matrix[13]);
+         params[14] = IROUND64(matrix[14]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
+         params[0] = ctx->ColorMatrixStack.Depth + 1;
+         break;
+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
+         params[0] = MAX_COLOR_STACK_DEPTH;
+         break;
+      case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[0]);
+         break;
+      case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[1]);
+         break;
+      case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[2]);
+         break;
+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixScale[3]);
+         break;
+      case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[0]);
+         break;
+      case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[1]);
+         break;
+      case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[2]);
+         break;
+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
+         params[0] = IROUND64(ctx->Pixel.PostColorMatrixBias[3]);
+         break;
+      case GL_CONVOLUTION_1D_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Convolution1DEnabled);
+         break;
+      case GL_CONVOLUTION_2D_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Convolution2DEnabled);
+         break;
+      case GL_SEPARABLE_2D_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.Separable2DEnabled);
+         break;
+      case GL_POST_CONVOLUTION_RED_SCALE_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[0]);
+         break;
+      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[1]);
+         break;
+      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[2]);
+         break;
+      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionScale[3]);
+         break;
+      case GL_POST_CONVOLUTION_RED_BIAS_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[0]);
+         break;
+      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[1]);
+         break;
+      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[2]);
+         break;
+      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
+         CHECK_EXT1(EXT_convolution, "GetInteger64v");
+         params[0] = IROUND64(ctx->Pixel.PostConvolutionBias[3]);
+         break;
+      case GL_HISTOGRAM:
+         CHECK_EXT1(EXT_histogram, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.HistogramEnabled);
+         break;
+      case GL_MINMAX:
+         CHECK_EXT1(EXT_histogram, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.MinMaxEnabled);
+         break;
+      case GL_COLOR_TABLE_SGI:
+         CHECK_EXT1(SGI_color_table, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_PRECONVOLUTION]);
+         break;
+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
+         CHECK_EXT1(SGI_color_table, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCONVOLUTION]);
+         break;
+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
+         CHECK_EXT1(SGI_color_table, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Pixel.ColorTableEnabled[COLORTABLE_POSTCOLORMATRIX]);
+         break;
+      case GL_TEXTURE_COLOR_TABLE_SGI:
+         CHECK_EXT1(SGI_texture_color_table, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
+         break;
+      case GL_COLOR_SUM_EXT:
+         CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Fog.ColorSumEnabled);
+         break;
+      case GL_CURRENT_SECONDARY_COLOR_EXT:
+         CHECK_EXT1(EXT_secondary_color, "GetInteger64v");
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
+         params[1] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
+         params[2] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
+         params[3] = FLOAT_TO_INT64(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
+         }
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_EXT:
+         CHECK_EXT1(EXT_secondary_color, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->SecondaryColor.Enabled);
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
+         CHECK_EXT1(EXT_secondary_color, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->SecondaryColor.Type);
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
+         CHECK_EXT1(EXT_secondary_color, "GetInteger64v");
+         params[0] = ctx->Array.ArrayObj->SecondaryColor.Stride;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
+         CHECK_EXT1(EXT_secondary_color, "GetInteger64v");
+         params[0] = ctx->Array.ArrayObj->SecondaryColor.Size;
+         break;
+      case GL_CURRENT_FOG_COORDINATE_EXT:
+         CHECK_EXT1(EXT_fog_coord, "GetInteger64v");
+         {
+         FLUSH_CURRENT(ctx, 0);
+         params[0] = IROUND64(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
+         }
+         break;
+      case GL_FOG_COORDINATE_ARRAY_EXT:
+         CHECK_EXT1(EXT_fog_coord, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->FogCoord.Enabled);
+         break;
+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
+         CHECK_EXT1(EXT_fog_coord, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Array.ArrayObj->FogCoord.Type);
+         break;
+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
+         CHECK_EXT1(EXT_fog_coord, "GetInteger64v");
+         params[0] = ctx->Array.ArrayObj->FogCoord.Stride;
+         break;
+      case GL_FOG_COORDINATE_SOURCE_EXT:
+         CHECK_EXT1(EXT_fog_coord, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Fog.FogCoordinateSource);
+         break;
+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
+         CHECK_EXT1(EXT_texture_lod_bias, "GetInteger64v");
+         params[0] = IROUND64(ctx->Const.MaxTextureLodBias);
+         break;
+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+         CHECK_EXT1(EXT_texture_filter_anisotropic, "GetInteger64v");
+         params[0] = IROUND64(ctx->Const.MaxTextureMaxAnisotropy);
+         break;
+      case GL_MULTISAMPLE_ARB:
+         params[0] = BOOLEAN_TO_INT64(ctx->Multisample.Enabled);
+         break;
+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
+         params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleAlphaToCoverage);
+         break;
+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
+         params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleAlphaToOne);
+         break;
+      case GL_SAMPLE_COVERAGE_ARB:
+         params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleCoverage);
+         break;
+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
+         params[0] = IROUND64(ctx->Multisample.SampleCoverageValue);
+         break;
+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
+         params[0] = BOOLEAN_TO_INT64(ctx->Multisample.SampleCoverageInvert);
+         break;
+      case GL_SAMPLE_BUFFERS_ARB:
+         params[0] = ctx->DrawBuffer->Visual.sampleBuffers;
+         break;
+      case GL_SAMPLES_ARB:
+         params[0] = ctx->DrawBuffer->Visual.samples;
+         break;
+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
+         CHECK_EXT1(IBM_rasterpos_clip, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Transform.RasterPositionUnclipped);
+         break;
+      case GL_POINT_SPRITE_NV:
+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Point.PointSprite);
+         break;
+      case GL_POINT_SPRITE_R_MODE_NV:
+         CHECK_EXT1(NV_point_sprite, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Point.SpriteRMode);
+         break;
+      case GL_POINT_SPRITE_COORD_ORIGIN:
+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Point.SpriteOrigin);
+         break;
+      case GL_GENERATE_MIPMAP_HINT_SGIS:
+         CHECK_EXT1(SGIS_generate_mipmap, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Hint.GenerateMipmap);
+         break;
+      case GL_VERTEX_PROGRAM_BINDING_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = (ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[1].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[2].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[3].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[4].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[5].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[6].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[7].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[8].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[9].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[10].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[11].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[12].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[13].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[14].Enabled);
+         break;
+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Array.ArrayObj->VertexAttrib[15].Enabled);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[0]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[1]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[2]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[3]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[4]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[5]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[6]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[7]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[8]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[9]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[10]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[11]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[12]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[13]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[14]);
+         break;
+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
+         CHECK_EXT1(NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Eval.Map1Attrib[15]);
+         break;
+      case GL_FRAGMENT_PROGRAM_NV:
+         CHECK_EXT1(NV_fragment_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->FragmentProgram.Enabled);
+         break;
+      case GL_FRAGMENT_PROGRAM_BINDING_NV:
+         CHECK_EXT1(NV_fragment_program, "GetInteger64v");
+         params[0] = ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
+         break;
+      case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
+         CHECK_EXT1(NV_fragment_program, "GetInteger64v");
+         params[0] = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
+         break;
+      case GL_TEXTURE_RECTANGLE_NV:
+         CHECK_EXT1(NV_texture_rectangle, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
+         break;
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+         CHECK_EXT1(NV_texture_rectangle, "GetInteger64v");
+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name;
+         break;
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+         CHECK_EXT1(NV_texture_rectangle, "GetInteger64v");
+         params[0] = ctx->Const.MaxTextureRectSize;
+         break;
+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
+         CHECK_EXT1(EXT_stencil_two_side, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Stencil.TestTwoSide);
+         break;
+      case GL_ACTIVE_STENCIL_FACE_EXT:
+         CHECK_EXT1(EXT_stencil_two_side, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
+         break;
+      case GL_MAX_SHININESS_NV:
+         CHECK_EXT1(NV_light_max_exponent, "GetInteger64v");
+         params[0] = IROUND64(ctx->Const.MaxShininess);
+         break;
+      case GL_MAX_SPOT_EXPONENT_NV:
+         CHECK_EXT1(NV_light_max_exponent, "GetInteger64v");
+         params[0] = IROUND64(ctx->Const.MaxSpotExponent);
+         break;
+      case GL_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayBufferObj->Name;
+         break;
+      case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->Vertex.BufferObj->Name;
+         break;
+      case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->Normal.BufferObj->Name;
+         break;
+      case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->Color.BufferObj->Name;
+         break;
+      case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->Index.BufferObj->Name;
+         break;
+      case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
+         break;
+      case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name;
+         break;
+      case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name;
+         break;
+      case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ArrayObj->FogCoord.BufferObj->Name;
+         break;
+      case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
+         params[0] = ctx->Array.ElementArrayBufferObj->Name;
+         break;
+      case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
+         CHECK_EXT1(EXT_pixel_buffer_object, "GetInteger64v");
+         params[0] = ctx->Pack.BufferObj->Name;
+         break;
+      case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
+         CHECK_EXT1(EXT_pixel_buffer_object, "GetInteger64v");
+         params[0] = ctx->Unpack.BufferObj->Name;
+         break;
+      case GL_VERTEX_PROGRAM_ARB:
+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.Enabled);
+         break;
+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.PointSizeEnabled);
+         break;
+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->VertexProgram.TwoSideEnabled);
+         break;
+      case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v");
+         params[0] = ctx->Const.MaxProgramMatrixStackDepth;
+         break;
+      case GL_MAX_PROGRAM_MATRICES_ARB:
+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v");
+         params[0] = ctx->Const.MaxProgramMatrices;
+         break;
+      case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->CurrentStack->Depth + 1);
+         break;
+      case GL_CURRENT_MATRIX_ARB:
+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetInteger64v");
+         {
+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[1]);
+         params[2] = IROUND64(matrix[2]);
+         params[3] = IROUND64(matrix[3]);
+         params[4] = IROUND64(matrix[4]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[6]);
+         params[7] = IROUND64(matrix[7]);
+         params[8] = IROUND64(matrix[8]);
+         params[9] = IROUND64(matrix[9]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[11]);
+         params[12] = IROUND64(matrix[12]);
+         params[13] = IROUND64(matrix[13]);
+         params[14] = IROUND64(matrix[14]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
+         CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetInteger64v");
+         {
+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
+         params[0] = IROUND64(matrix[0]);
+         params[1] = IROUND64(matrix[4]);
+         params[2] = IROUND64(matrix[8]);
+         params[3] = IROUND64(matrix[12]);
+         params[4] = IROUND64(matrix[1]);
+         params[5] = IROUND64(matrix[5]);
+         params[6] = IROUND64(matrix[9]);
+         params[7] = IROUND64(matrix[13]);
+         params[8] = IROUND64(matrix[2]);
+         params[9] = IROUND64(matrix[6]);
+         params[10] = IROUND64(matrix[10]);
+         params[11] = IROUND64(matrix[14]);
+         params[12] = IROUND64(matrix[3]);
+         params[13] = IROUND64(matrix[7]);
+         params[14] = IROUND64(matrix[11]);
+         params[15] = IROUND64(matrix[15]);
+         }
+         break;
+      case GL_MAX_VERTEX_ATTRIBS_ARB:
+         CHECK_EXT1(ARB_vertex_program, "GetInteger64v");
+         params[0] = ctx->Const.VertexProgram.MaxAttribs;
+         break;
+      case GL_PROGRAM_ERROR_POSITION_ARB:
+         CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetInteger64v");
+         params[0] = ctx->Program.ErrorPos;
+         break;
+      case GL_FRAGMENT_PROGRAM_ARB:
+         CHECK_EXT1(ARB_fragment_program, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->FragmentProgram.Enabled);
+         break;
+      case GL_MAX_TEXTURE_COORDS_ARB:
+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetInteger64v");
+         params[0] = ctx->Const.MaxTextureCoordUnits;
+         break;
+      case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetInteger64v");
+         params[0] = ctx->Const.MaxTextureImageUnits;
+         break;
+      case GL_DEPTH_BOUNDS_TEST_EXT:
+         CHECK_EXT1(EXT_depth_bounds_test, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Depth.BoundsTest);
+         break;
+      case GL_DEPTH_BOUNDS_EXT:
+         CHECK_EXT1(EXT_depth_bounds_test, "GetInteger64v");
+         params[0] = IROUND64(ctx->Depth.BoundsMin);
+         params[1] = IROUND64(ctx->Depth.BoundsMax);
+         break;
+      case GL_DEPTH_CLAMP:
+         CHECK_EXT1(ARB_depth_clamp, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Transform.DepthClamp);
+         break;
+      case GL_MAX_DRAW_BUFFERS_ARB:
+         params[0] = ctx->Const.MaxDrawBuffers;
+         break;
+      case GL_DRAW_BUFFER0_ARB:
+         params[0] = ENUM_TO_INT64(ctx->DrawBuffer->ColorDrawBuffer[0]);
+         break;
+      case GL_DRAW_BUFFER1_ARB:
+         {
+         GLenum buffer;
+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
+            return;
+         }
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
+         params[0] = ENUM_TO_INT64(buffer);
+         }
+         break;
+      case GL_DRAW_BUFFER2_ARB:
+         {
+         GLenum buffer;
+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
+            return;
+         }
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
+         params[0] = ENUM_TO_INT64(buffer);
+         }
+         break;
+      case GL_DRAW_BUFFER3_ARB:
+         {
+         GLenum buffer;
+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
+            return;
+         }
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
+         params[0] = ENUM_TO_INT64(buffer);
+         }
+         break;
+      case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
+         CHECK_EXT1(OES_read_format, "GetInteger64v");
+         params[0] = ctx->Const.ColorReadType;
+         break;
+      case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
+         CHECK_EXT1(OES_read_format, "GetInteger64v");
+         params[0] = ctx->Const.ColorReadFormat;
+         break;
+      case GL_NUM_FRAGMENT_REGISTERS_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 6;
+         break;
+      case GL_NUM_FRAGMENT_CONSTANTS_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 8;
+         break;
+      case GL_NUM_PASSES_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 2;
+         break;
+      case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 8;
+         break;
+      case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 16;
+         break;
+      case GL_COLOR_ALPHA_PAIRING_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(GL_TRUE);
+         break;
+      case GL_NUM_LOOPBACK_COMPONENTS_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 3;
+         break;
+      case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
+         CHECK_EXT1(ATI_fragment_shader, "GetInteger64v");
+         params[0] = 3;
+         break;
+      case GL_STENCIL_BACK_FUNC:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.Function[1]);
+         break;
+      case GL_STENCIL_BACK_VALUE_MASK:
+         params[0] = ctx->Stencil.ValueMask[1];
+         break;
+      case GL_STENCIL_BACK_WRITEMASK:
+         params[0] = ctx->Stencil.WriteMask[1];
+         break;
+      case GL_STENCIL_BACK_REF:
+         params[0] = ctx->Stencil.Ref[1];
+         break;
+      case GL_STENCIL_BACK_FAIL:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.FailFunc[1]);
+         break;
+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.ZFailFunc[1]);
+         break;
+      case GL_STENCIL_BACK_PASS_DEPTH_PASS:
+         params[0] = ENUM_TO_INT64(ctx->Stencil.ZPassFunc[1]);
+         break;
+      case GL_FRAMEBUFFER_BINDING_EXT:
+         CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v");
+         params[0] = ctx->DrawBuffer->Name;
+         break;
+      case GL_RENDERBUFFER_BINDING_EXT:
+         CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v");
+         params[0] = ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
+         break;
+      case GL_MAX_COLOR_ATTACHMENTS_EXT:
+         CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v");
+         params[0] = ctx->Const.MaxColorAttachments;
+         break;
+      case GL_MAX_RENDERBUFFER_SIZE_EXT:
+         CHECK_EXT1(EXT_framebuffer_object, "GetInteger64v");
+         params[0] = ctx->Const.MaxRenderbufferSize;
+         break;
+      case GL_READ_FRAMEBUFFER_BINDING_EXT:
+         CHECK_EXT1(EXT_framebuffer_blit, "GetInteger64v");
+         params[0] = ctx->ReadBuffer->Name;
+         break;
+      case GL_PROVOKING_VERTEX_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Light.ProvokingVertex);
+         break;
+      case GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT:
+         CHECK_EXT1(EXT_provoking_vertex, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Const.QuadsFollowProvokingVertexConvention);
+         break;
+      case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
+         CHECK_EXT1(ARB_fragment_shader, "GetInteger64v");
+         params[0] = ctx->Const.FragmentProgram.MaxUniformComponents;
+         break;
+      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
+         CHECK_EXT1(ARB_fragment_shader, "GetInteger64v");
+         params[0] = ENUM_TO_INT64(ctx->Hint.FragmentShaderDerivative);
+         break;
+      case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
+         CHECK_EXT1(ARB_vertex_shader, "GetInteger64v");
+         params[0] = ctx->Const.VertexProgram.MaxUniformComponents;
+         break;
+      case GL_MAX_VARYING_FLOATS_ARB:
+         CHECK_EXT1(ARB_vertex_shader, "GetInteger64v");
+         params[0] = ctx->Const.MaxVarying * 4;
+         break;
+      case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
+         CHECK_EXT1(ARB_vertex_shader, "GetInteger64v");
+         params[0] = ctx->Const.MaxVertexTextureImageUnits;
+         break;
+      case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
+         CHECK_EXT1(ARB_vertex_shader, "GetInteger64v");
+         params[0] = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+         break;
+      case GL_CURRENT_PROGRAM:
+         CHECK_EXT1(ARB_shader_objects, "GetInteger64v");
+         params[0] = ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0;
+         break;
+      case GL_MAX_SAMPLES:
+         CHECK_EXT1(ARB_framebuffer_object, "GetInteger64v");
+         params[0] = ctx->Const.MaxSamples;
+         break;
+      case GL_VERTEX_ARRAY_BINDING_APPLE:
+         CHECK_EXT1(APPLE_vertex_array_object, "GetInteger64v");
+         params[0] = ctx->Array.ArrayObj->Name;
+         break;
+      case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+         CHECK_EXT1(ARB_seamless_cube_map, "GetInteger64v");
+         params[0] = BOOLEAN_TO_INT64(ctx->Texture.CubeMapSeamless);
+         break;
+      case GL_MAX_SERVER_WAIT_TIMEOUT:
+         CHECK_EXT1(ARB_sync, "GetInteger64v");
+         params[0] = ctx->Const.MaxServerWaitTimeout;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetInteger64v(pname=0x%x)", pname);
+   }
+}
+#endif /* FEATURE_ARB_sync */
+
 
 void GLAPIENTRY
 _mesa_GetDoublev( GLenum pname, GLdouble *params )
diff --git a/src/mesa/main/get.h b/src/mesa/main/get.h
index 9b47b230a9..77a9a7d04b 100644
--- a/src/mesa/main/get.h
+++ b/src/mesa/main/get.h
@@ -48,6 +48,9 @@ extern void GLAPIENTRY
 _mesa_GetIntegerv( GLenum pname, GLint *params );
 
 extern void GLAPIENTRY
+_mesa_GetInteger64v( GLenum pname, GLint64 *params );
+
+extern void GLAPIENTRY
 _mesa_GetPointerv( GLenum pname, GLvoid **params );
 
 extern const GLubyte * GLAPIENTRY
diff --git a/src/mesa/main/get_gen.py b/src/mesa/main/get_gen.py
index a191b045d3..364d8c55c4 100644
--- a/src/mesa/main/get_gen.py
+++ b/src/mesa/main/get_gen.py
@@ -35,6 +35,7 @@ GLfloat = 3
 GLdouble = 4
 GLboolean = 5
 GLfloatN = 6    # A normalized value, such as a color or depth range
+GLint64 = 7
 
 
 TypeStrings = {
@@ -42,7 +43,8 @@ TypeStrings = {
 	GLenum : "GLenum",
 	GLfloat : "GLfloat",
 	GLdouble : "GLdouble",
-	GLboolean : "GLboolean"
+	GLboolean : "GLboolean",
+	GLint64 : "GLint64"
 }
 
 
@@ -176,7 +178,8 @@ StateVars = [
 	   "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]",
 	   "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]",
 	   "ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]"],
-	  "const GLuint texUnit = ctx->Texture.CurrentUnit;", None ),
+	  """const GLuint texUnit = ctx->Texture.CurrentUnit;
+         FLUSH_CURRENT(ctx, 0);""", None ),
 	( "GL_DEPTH_BIAS", GLfloat, ["ctx->Pixel.DepthBias"], "", None ),
 	( "GL_DEPTH_BITS", GLint, ["ctx->DrawBuffer->Visual.depthBits"],
 	  "", None ),
@@ -254,7 +257,7 @@ StateVars = [
 	  ["ctx->Const.MinLineWidth",
 	   "ctx->Const.MaxLineWidth"], "", None ),
 	( "GL_LIST_BASE", GLint, ["ctx->List.ListBase"], "", None ),
-	( "GL_LIST_INDEX", GLint, ["ctx->ListState.CurrentListNum"], "", None ),
+	( "GL_LIST_INDEX", GLint, ["(ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0)"], "", None ),
 	( "GL_LIST_MODE", GLenum, ["mode"],
 	  """GLenum mode;
          if (!ctx->CompileFlag)
@@ -432,15 +435,15 @@ StateVars = [
 	( "GL_TEXTURE_1D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_1D_ARRAY_EXT)"], "", ["MESA_texture_array"] ),
 	( "GL_TEXTURE_2D_ARRAY_EXT", GLboolean, ["_mesa_IsEnabled(GL_TEXTURE_2D_ARRAY_EXT)"], "", ["MESA_texture_array"] ),
 	( "GL_TEXTURE_BINDING_1D", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name"], "", None ),
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_INDEX]->Name"], "", None ),
 	( "GL_TEXTURE_BINDING_2D", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name"], "", None ),
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_INDEX]->Name"], "", None ),
 	( "GL_TEXTURE_BINDING_3D", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name"], "", None ),
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_3D_INDEX]->Name"], "", None ),
 	( "GL_TEXTURE_BINDING_1D_ARRAY_EXT", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1DArray->Name"], "", ["MESA_texture_array"] ),
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_1D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ),
 	( "GL_TEXTURE_BINDING_2D_ARRAY_EXT", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2DArray->Name"], "", ["MESA_texture_array"] ),
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_2D_ARRAY_INDEX]->Name"], "", ["MESA_texture_array"] ),
 	( "GL_TEXTURE_GEN_S", GLboolean,
 	  ["((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0)"], "", None ),
 	( "GL_TEXTURE_GEN_T", GLboolean,
@@ -515,7 +518,7 @@ StateVars = [
 	( "GL_TEXTURE_CUBE_MAP_ARB", GLboolean,
 	  ["_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB)"], "", ["ARB_texture_cube_map"] ),
 	( "GL_TEXTURE_BINDING_CUBE_MAP_ARB", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name"],
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_CUBE_INDEX]->Name"],
 	  "", ["ARB_texture_cube_map"] ),
 	( "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB", GLint,
 	  ["(1 << (ctx->Const.MaxCubeTextureLevels - 1))"],
@@ -523,10 +526,10 @@ StateVars = [
 
 	# GL_ARB_texture_compression */
 	( "GL_TEXTURE_COMPRESSION_HINT_ARB", GLint,
-	  ["ctx->Hint.TextureCompression"], "", ["ARB_texture_compression"] ),
+	  ["ctx->Hint.TextureCompression"], "", None ),
 	( "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB", GLint,
 	  ["_mesa_get_compressed_formats(ctx, NULL, GL_FALSE)"],
-	  "", ["ARB_texture_compression"] ),
+	  "", None ),
 	( "GL_COMPRESSED_TEXTURE_FORMATS_ARB", GLenum,
 	  [],
 	  """GLint formats[100];
@@ -534,7 +537,7 @@ StateVars = [
          ASSERT(n <= 100);
          for (i = 0; i < n; i++)
             params[i] = CONVERSION(formats[i]);""",
-	  ["ARB_texture_compression"] ),
+	  None ),
 
 	# GL_EXT_compiled_vertex_array
 	( "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT", GLint, ["ctx->Array.LockFirst"],
@@ -681,21 +684,21 @@ StateVars = [
 
 	# GL_ARB_multisample
 	( "GL_MULTISAMPLE_ARB", GLboolean,
-	  ["ctx->Multisample.Enabled"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.Enabled"], "", None ),
 	( "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB", GLboolean,
-	  ["ctx->Multisample.SampleAlphaToCoverage"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.SampleAlphaToCoverage"], "", None ),
 	( "GL_SAMPLE_ALPHA_TO_ONE_ARB", GLboolean,
-	  ["ctx->Multisample.SampleAlphaToOne"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.SampleAlphaToOne"], "", None ),
 	( "GL_SAMPLE_COVERAGE_ARB", GLboolean,
-	  ["ctx->Multisample.SampleCoverage"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.SampleCoverage"], "", None ),
 	( "GL_SAMPLE_COVERAGE_VALUE_ARB", GLfloat,
-	  ["ctx->Multisample.SampleCoverageValue"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.SampleCoverageValue"], "", None ),
 	( "GL_SAMPLE_COVERAGE_INVERT_ARB", GLboolean,
-	  ["ctx->Multisample.SampleCoverageInvert"], "", ["ARB_multisample"] ),
+	  ["ctx->Multisample.SampleCoverageInvert"], "", None ),
 	( "GL_SAMPLE_BUFFERS_ARB", GLint,
-	  ["ctx->DrawBuffer->Visual.sampleBuffers"], "", ["ARB_multisample"] ),
+	  ["ctx->DrawBuffer->Visual.sampleBuffers"], "", None ),
 	( "GL_SAMPLES_ARB", GLint,
-	  ["ctx->DrawBuffer->Visual.samples"], "", ["ARB_multisample"] ),
+	  ["ctx->DrawBuffer->Visual.samples"], "", None ),
 
 	# GL_IBM_rasterpos_clip
 	( "GL_RASTER_POSITION_UNCLIPPED_IBM", GLboolean,
@@ -795,7 +798,7 @@ StateVars = [
 	( "GL_TEXTURE_RECTANGLE_NV", GLboolean,
 	  ["_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV)"], "", ["NV_texture_rectangle"] ),
 	( "GL_TEXTURE_BINDING_RECTANGLE_NV", GLint,
-	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name"],
+	  ["ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentTex[TEXTURE_RECT_INDEX]->Name"],
 	  "", ["NV_texture_rectangle"] ),
 	( "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV", GLint,
 	  ["ctx->Const.MaxTextureRectSize"], "", ["NV_texture_rectangle"] ),
@@ -815,30 +818,30 @@ StateVars = [
 
 	# GL_ARB_vertex_buffer_object
 	( "GL_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayBufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayBufferObj->Name"], "", None ),
 	( "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayObj->Vertex.BufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayObj->Vertex.BufferObj->Name"], "", None ),
 	( "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayObj->Normal.BufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayObj->Normal.BufferObj->Name"], "", None ),
 	( "GL_COLOR_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayObj->Color.BufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayObj->Color.BufferObj->Name"], "", None ),
 	( "GL_INDEX_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayObj->Index.BufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayObj->Index.BufferObj->Name"], "", None ),
 	( "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB", GLint,
 	  ["ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name"],
-	  "", ["ARB_vertex_buffer_object"] ),
+	  "", None ),
 	( "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB", GLint,
-	  ["ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name"], "", ["ARB_vertex_buffer_object"] ),
+	  ["ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name"], "", None ),
 	( "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB", GLint,
 	  ["ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name"],
-	  "", ["ARB_vertex_buffer_object"] ),
+	  "", None ),
 	( "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB", GLint,
 	  ["ctx->Array.ArrayObj->FogCoord.BufferObj->Name"],
-	  "", ["ARB_vertex_buffer_object"] ),
+	  "", None ),
 	# GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported
 	( "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB", GLint,
 	  ["ctx->Array.ElementArrayBufferObj->Name"],
-	  "", ["ARB_vertex_buffer_object"] ),
+	  "", None ),
 
 	# GL_EXT_pixel_buffer_object
 	( "GL_PIXEL_PACK_BUFFER_BINDING_EXT", GLint,
@@ -902,21 +905,15 @@ StateVars = [
 	  ["ctx->Depth.BoundsMin", "ctx->Depth.BoundsMax"],
 	  "", ["EXT_depth_bounds_test"] ),
 
-	# GL_MESA_program_debug
-	( "GL_FRAGMENT_PROGRAM_CALLBACK_MESA", GLboolean,
-	  ["ctx->FragmentProgram.CallbackEnabled"], "", ["MESA_program_debug"] ),
-	( "GL_VERTEX_PROGRAM_CALLBACK_MESA", GLboolean,
-	  ["ctx->VertexProgram.CallbackEnabled"], "", ["MESA_program_debug"] ),
-	( "GL_FRAGMENT_PROGRAM_POSITION_MESA", GLint,
-	  ["ctx->FragmentProgram.CurrentPosition"], "", ["MESA_program_debug"] ),
-	( "GL_VERTEX_PROGRAM_POSITION_MESA", GLint,
-	  ["ctx->VertexProgram.CurrentPosition"], "", ["MESA_program_debug"] ),
+	# GL_ARB_depth_clamp
+	( "GL_DEPTH_CLAMP", GLboolean, ["ctx->Transform.DepthClamp"], "",
+	  ["ARB_depth_clamp"] ),
 
 	# GL_ARB_draw_buffers
 	( "GL_MAX_DRAW_BUFFERS_ARB", GLint,
-	  ["ctx->Const.MaxDrawBuffers"], "", ["ARB_draw_buffers"] ),
+	  ["ctx->Const.MaxDrawBuffers"], "", None ),
 	( "GL_DRAW_BUFFER0_ARB", GLenum,
-	  ["ctx->DrawBuffer->ColorDrawBuffer[0]"], "", ["ARB_draw_buffers"] ),
+	  ["ctx->DrawBuffer->ColorDrawBuffer[0]"], "", None ),
 	( "GL_DRAW_BUFFER1_ARB", GLenum,
 	  ["buffer"],
 	  """GLenum buffer;
@@ -924,7 +921,7 @@ StateVars = [
             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
             return;
          }
-         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];""", ["ARB_draw_buffers"] ),
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];""", None ),
 	( "GL_DRAW_BUFFER2_ARB", GLenum,
 	  ["buffer"],
 	  """GLenum buffer;
@@ -932,7 +929,7 @@ StateVars = [
             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
             return;
          }
-         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];""", ["ARB_draw_buffers"] ),
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];""", None ),
 	( "GL_DRAW_BUFFER3_ARB", GLenum,
 	  ["buffer"],
 	  """GLenum buffer;
@@ -940,7 +937,7 @@ StateVars = [
             _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
             return;
          }
-         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];""", ["ARB_draw_buffers"] ),
+         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];""", None ),
 	# XXX Add more GL_DRAW_BUFFERn_ARB entries as needed in the future
 
 	# GL_OES_read_format
@@ -986,6 +983,13 @@ StateVars = [
 	( "GL_READ_FRAMEBUFFER_BINDING_EXT", GLint, ["ctx->ReadBuffer->Name"], "",
 	  ["EXT_framebuffer_blit"] ),
 
+	# GL_EXT_provoking_vertex
+	( "GL_PROVOKING_VERTEX_EXT", GLboolean,
+	  ["ctx->Light.ProvokingVertex"], "", ["EXT_provoking_vertex"] ),
+	( "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT", GLboolean,
+	  ["ctx->Const.QuadsFollowProvokingVertexConvention"], "",
+	  ["EXT_provoking_vertex"] ),
+
 	# GL_ARB_fragment_shader
 	( "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB", GLint,
 	  ["ctx->Const.FragmentProgram.MaxUniformComponents"], "",
@@ -1009,7 +1013,23 @@ StateVars = [
 	# close enough for now.
 	( "GL_CURRENT_PROGRAM", GLint,
 	  ["ctx->Shader.CurrentProgram ? ctx->Shader.CurrentProgram->Name : 0"],
-	  "", ["ARB_shader_objects"] )
+	  "", ["ARB_shader_objects"] ),
+
+	# GL_ARB_framebuffer_object
+	( "GL_MAX_SAMPLES", GLint, ["ctx->Const.MaxSamples"], "",
+	  ["ARB_framebuffer_object"] ),
+
+	# GL_APPLE_vertex_array_object
+	( "GL_VERTEX_ARRAY_BINDING_APPLE", GLint, ["ctx->Array.ArrayObj->Name"], "",
+	  ["APPLE_vertex_array_object"] ),
+
+	# GL_ARB_seamless_cube_map
+	( "GL_TEXTURE_CUBE_MAP_SEAMLESS", GLboolean, ["ctx->Texture.CubeMapSeamless"], "",
+	  ["ARB_seamless_cube_map"] ),
+
+	# GL_ARB_sync
+	( "GL_MAX_SERVER_WAIT_TIMEOUT", GLint64, ["ctx->Const.MaxServerWaitTimeout"], "",
+	  ["ARB_sync"] ),
 ]
 
 
@@ -1019,10 +1039,16 @@ def ConversionFunc(fromType, toType):
 		return ""
 	elif fromType == GLfloat and toType == GLint:
 		return "IROUND"
+	elif fromType == GLfloat and toType == GLint64:
+		return "IROUND64"
 	elif fromType == GLfloatN and toType == GLfloat:
 		return ""
 	elif fromType == GLint and toType == GLfloat: # but not GLfloatN!
 		return "(GLfloat)"
+	elif fromType == GLint and toType == GLint64:
+		return ""
+	elif fromType == GLint64 and toType == GLfloat: # but not GLfloatN!
+		return "(GLfloat)"
 	else:
 		if fromType == GLfloatN:
 			fromType = GLfloat
@@ -1037,6 +1063,7 @@ def EmitGetFunction(stateVars, returnType):
 	"""Emit the code to implement glGetBooleanv, glGetIntegerv or glGetFloatv."""
 	assert (returnType == GLboolean or
 			returnType == GLint or
+			returnType == GLint64 or
 			returnType == GLfloat)
 
 	strType = TypeStrings[returnType]
@@ -1047,9 +1074,14 @@ def EmitGetFunction(stateVars, returnType):
 		function = "GetBooleanv"
 	elif returnType == GLfloat:
 		function = "GetFloatv"
+	elif returnType == GLint64:
+		function = "GetInteger64v"
 	else:
 		abort()
 
+	if returnType == GLint64:
+		print "#if FEATURE_ARB_sync"
+
 	print "void GLAPIENTRY"
 	print "_mesa_%s( GLenum pname, %s *params )" % (function, strType)
 	print "{"
@@ -1103,6 +1135,8 @@ def EmitGetFunction(stateVars, returnType):
 	print '         _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(pname=0x%%x)", pname);' % function
 	print "   }"
 	print "}"
+	if returnType == GLint64:
+		print "#endif /* FEATURE_ARB_sync */"
 	print ""
 	return
 
@@ -1131,9 +1165,15 @@ def EmitHeader():
 
 #define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
 
+#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
+#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
+
 #define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
+#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
 #define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
 
+#define ENUM_TO_INT64(E)      ( (GLint64) (E) )
+
 
 /*
  * Check if named extension is enabled, if not generate error and return.
@@ -1211,5 +1251,6 @@ EmitHeader()
 EmitGetFunction(StateVars, GLboolean)
 EmitGetFunction(StateVars, GLfloat)
 EmitGetFunction(StateVars, GLint)
+EmitGetFunction(StateVars, GLint64)
 EmitGetDoublev()
 
diff --git a/src/mesa/main/getstring.c b/src/mesa/main/getstring.c
index 94bf5de1e8..4b1f4b0ea1 100644
--- a/src/mesa/main/getstring.c
+++ b/src/mesa/main/getstring.c
@@ -82,9 +82,18 @@ compute_version(const GLcontext *ctx)
                               ctx->Extensions.ARB_vertex_shader &&
                               ctx->Extensions.ARB_fragment_shader &&
                               ctx->Extensions.ARB_texture_non_power_of_two &&
-                              ctx->Extensions.EXT_blend_equation_separate);
+                              ctx->Extensions.EXT_blend_equation_separate &&
+
+			      /* Technically, 2.0 requires the functionality
+			       * of the EXT version.  Enable 2.0 if either
+			       * extension is available, and assume that a
+			       * driver that only exposes the ATI extension
+			       * will fallback to software when necessary.
+			       */
+			      (ctx->Extensions.EXT_stencil_two_side
+			       || ctx->Extensions.ATI_separate_stencil));
    const GLboolean ver_2_1 = (ver_2_0 &&
-                              /*ctx->Extensions.ARB_shading_language_120 &&*/
+                              ctx->Extensions.ARB_shading_language_120 &&
                               ctx->Extensions.EXT_pixel_buffer_object &&
                               ctx->Extensions.EXT_texture_sRGB);
    if (ver_2_1)
@@ -233,34 +242,9 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params )
       case GL_SELECTION_BUFFER_POINTER:
          *params = ctx->Select.Buffer;
          break;
-#if FEATURE_MESA_program_debug
-      case GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA:
-         if (!ctx->Extensions.MESA_program_debug) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv");
-            return;
-         }
-         *params = *(GLvoid **) &ctx->FragmentProgram.Callback;
-         break;
-      case GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA:
-         if (!ctx->Extensions.MESA_program_debug) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv");
-            return;
-         }
-         *params = ctx->FragmentProgram.CallbackData;
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA:
-         if (!ctx->Extensions.MESA_program_debug) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv");
-            return;
-         }
-         *params = *(GLvoid **) &ctx->VertexProgram.Callback;
-         break;
-      case GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA:
-         if (!ctx->Extensions.MESA_program_debug) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetPointerv");
-            return;
-         }
-         *params = ctx->VertexProgram.CallbackData;
+#if FEATURE_point_size_array
+      case GL_POINT_SIZE_ARRAY_POINTER_OES:
+         *params = (GLvoid *) ctx->Array.ArrayObj->PointSize.Ptr;
          break;
 #endif
       default:
@@ -287,5 +271,6 @@ _mesa_GetError( void )
       _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e));
 
    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
+   ctx->ErrorDebugCount = 0;
    return e;
 }
diff --git a/src/mesa/main/glheader.h b/src/mesa/main/glheader.h
index 626806d35f..81d4ccf919 100644
--- a/src/mesa/main/glheader.h
+++ b/src/mesa/main/glheader.h
@@ -1,28 +1,8 @@
-/**
- * \file glheader.h
- * Top-most include file.
- *
- * This is the top-most include file of the Mesa sources.
- * It includes gl.h and all system headers which are needed.
- * Other Mesa source files should \e not directly include any system
- * headers.  This allows system-dependent hacks/workarounds to be
- * collected in one place.
- *
- * \note Actually, a lot of system-dependent stuff is now in imports.[ch].
- *
- * If you touch this file, everything gets recompiled!
- *
- * This file should be included before any other header in the .c files.
- *
- * Put compiler/OS/assembly pragmas and macros here to avoid
- * cluttering other source files.
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  6.5
+ * Version:  7.5
  *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  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"),
@@ -43,88 +23,22 @@
  */
 
 
-#ifndef GLHEADER_H
-#define GLHEADER_H
-
-#include <assert.h>
-#include <ctype.h>
-#if defined(__alpha__) && defined(CCPML)
-#include <cpml.h> /* use Compaq's Fast Math Library on Alpha */
-#else
-#include <math.h>
-#endif
-#include <limits.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#if defined(__linux__) && defined(__i386__)
-#include <fpu_control.h>
-#endif
-#include <float.h>
-#include <stdarg.h>
-
-
-/* Get typedefs for uintptr_t and friends */
-#if defined(__MINGW32__) || defined(__NetBSD__)
-#  include <stdint.h>
-#elif defined(_WIN32)
-#  include <BaseTsd.h>
-#  if _MSC_VER == 1200
-     typedef UINT_PTR uintptr_t;
-#  endif 
-#elif defined(__INTERIX)
-/* Interix 3.x has a gcc that shadows this. */
-#  ifndef _UINTPTR_T_DEFINED
-     typedef unsigned long uintptr_t;
-#  define _UINTPTR_T_DEFINED
-#  endif
-#else
-#  include <inttypes.h>
-#endif
-
+/**
+ * \file glheader.h
+ * Wrapper for GL/gl.h and GL/glext.h
+ */
 
-/* Sun compilers define __i386 instead of the gcc-style __i386__ */
-#ifdef __SUNPRO_C
-# if !defined(__i386__) && defined(__i386)
-#  define __i386__
-# elif !defined(__amd64__) && defined(__amd64)
-#  define __amd64__
-# elif !defined(__sparc__) && defined(__sparc)
-#  define __sparc__
-# endif
-# if !defined(__volatile)
-#  define __volatile volatile
-# endif
-#endif
 
-#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__) && !defined(BUILD_FOR_SNAP)
-#  define __WIN32__
-#  define finite _finite
-#endif
+#ifndef GLHEADER_H
+#define GLHEADER_H
 
-#if defined(__WATCOMC__)
-#  define finite _finite
-#  pragma disable_message(201) /* Disable unreachable code warnings */
-#endif
 
 #ifdef WGLAPI
-#	undef WGLAPI
+#undef WGLAPI
 #endif
 
+
 #if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__)) && !defined(BUILD_FOR_SNAP)
-#  if !defined(__GNUC__) /* mingw environment */
-#    pragma warning( disable : 4068 ) /* unknown pragma */
-#    pragma warning( disable : 4710 ) /* function 'foo' not inlined */
-#    pragma warning( disable : 4711 ) /* function 'foo' selected for automatic inline expansion */
-#    pragma warning( disable : 4127 ) /* conditional expression is constant */
-#    if defined(MESA_MINWARN)
-#      pragma warning( disable : 4244 ) /* '=' : conversion from 'const double ' to 'float ', possible loss of data */
-#      pragma warning( disable : 4018 ) /* '<' : signed/unsigned mismatch */
-#      pragma warning( disable : 4305 ) /* '=' : truncation from 'const double ' to 'float ' */
-#      pragma warning( disable : 4550 ) /* 'function' undefined; assuming extern returning int */
-#      pragma warning( disable : 4761 ) /* integral size mismatch in argument; conversion supplied */
-#    endif
-#  endif
 #  if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */
 #    define WGLAPI __declspec(dllexport)
 #  elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
@@ -135,31 +49,10 @@
 #endif /* WIN32 / CYGWIN bracket */
 
 
-/*
- * Either define MESA_BIG_ENDIAN or MESA_LITTLE_ENDIAN.
- * Do not use them unless absolutely necessary!
- * Try to use a runtime test instead.
- * For now, only used by some DRI hardware drivers for color/texel packing.
- */
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-#if defined(__linux__)
-#include <byteswap.h>
-#define CPU_TO_LE32( x )	bswap_32( x )
-#else /*__linux__*/
-#include <sys/endian.h>
-#define CPU_TO_LE32( x )	bswap32( x )
-#endif /*__linux__*/
-#define MESA_BIG_ENDIAN 1
-#else
-#define CPU_TO_LE32( x )	( x )
-#define MESA_LITTLE_ENDIAN 1
-#endif
-#define LE32_TO_CPU( x )	CPU_TO_LE32( x )
-
-
 #define GL_GLEXT_PROTOTYPES
 #include "GL/gl.h"
 #include "GL/glext.h"
+#include "GL/internal/glcore.h"
 
 
 #ifndef GL_FIXED
@@ -181,129 +74,15 @@
 #endif
 
 
-#if !defined(CAPI) && defined(WIN32) && !defined(BUILD_FOR_SNAP)
-#define CAPI _cdecl
-#endif
-
-
-/* This is a macro on IRIX */
-#ifdef _P
-#undef _P
-#endif
-
-
-/* Turn off macro checking systems used by other libraries */
-#ifdef CHECK
-#undef CHECK
+#ifndef GL_PROGRAM_BINARY_LENGTH_OES
+#define GL_PROGRAM_BINARY_LENGTH_OES 0x8741
 #endif
 
 
-/* Create a macro so that asm functions can be linked into compilers other
- * than GNU C
- */
-#ifndef _ASMAPI
-#if defined(WIN32) && !defined(BUILD_FOR_SNAP)/* was: !defined( __GNUC__ ) && !defined( VMS ) && !defined( __INTEL_COMPILER )*/
-#define _ASMAPI __cdecl
-#else
-#define _ASMAPI
-#endif
-#ifdef	PTR_DECL_IN_FRONT
-#define	_ASMAPIP * _ASMAPI
-#else
-#define	_ASMAPIP _ASMAPI *
-#endif
-#endif
-
-#ifdef USE_X86_ASM
-#define _NORMAPI _ASMAPI
-#define _NORMAPIP _ASMAPIP
-#else
-#define _NORMAPI
-#define _NORMAPIP *
-#endif
-
-
-/* Function inlining */
-#if defined(__GNUC__)
-#  define INLINE __inline__
-#elif defined(__MSC__)
-#  define INLINE __inline
-#elif defined(_MSC_VER)
-#  define INLINE __inline
-#elif defined(__ICL)
-#  define INLINE __inline
-#elif defined(__INTEL_COMPILER)
-#  define INLINE inline
-#elif defined(__WATCOMC__) && (__WATCOMC__ >= 1100)
-#  define INLINE __inline
-#elif defined(__SUNPRO_C) && defined(__C99FEATURES__)
-#  define INLINE inline
-#  define __inline inline
-#  define __inline__ inline
-#elif (__STDC_VERSION__ >= 199901L) /* C99 */
-#  define INLINE inline
-#else
-#  define INLINE
-#endif
-
-
-/* If we build the library with gcc's -fvisibility=hidden flag, we'll
- * use the PUBLIC macro to mark functions that are to be exported.
- *
- * We also need to define a USED attribute, so the optimizer doesn't 
- * inline a static function that we later use in an alias. - ajax
- */
-#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
-#  define PUBLIC __attribute__((visibility("default")))
-#  define USED __attribute__((used))
-#else
-#  define PUBLIC
-#  define USED
-#endif
-
-
-/* Some compilers don't like some of Mesa's const usage */
-#ifdef NO_CONST
-#  define CONST
-#else
-#  define CONST const
-#endif
-
-
-#if !defined(_WIN32_WCE)
-#if defined(BUILD_FOR_SNAP) && defined(CHECKED)
-#  define ASSERT(X)   _CHECK(X) 
-#elif defined(DEBUG)
-#  define ASSERT(X)   assert(X)
-#else
-#  define ASSERT(X)
-#endif
-#endif
-
-
-#if (!defined(__GNUC__) || __GNUC__ < 3) && (!defined(__IBMC__) || __IBMC__ < 900)
-#  define __builtin_expect(x, y) x
-#endif
-
-/* The __FUNCTION__ gcc variable is generally only used for debugging.
- * If we're not using gcc, define __FUNCTION__ as a cpp symbol here.
- * Don't define it if using a newer Windows compiler.
+/**
+ * Special, internal token
  */
-#ifndef __FUNCTION__
-# if defined(__VMS)
-#  define __FUNCTION__ "VMS$NL:"
-# elif ((!defined __GNUC__) || (__GNUC__ < 2)) && (!defined __xlC__) && \
-      (!defined(_MSC_VER) || _MSC_VER < 1300)
-#  if (__STDC_VERSION__ >= 199901L) /* C99 */ || \
-    (defined(__SUNPRO_C) && defined(__C99FEATURES__))
-#   define __FUNCTION__ __func__
-#  else
-#   define __FUNCTION__ "<unknown>"
-#  endif
-# endif
-#endif
-
+#define GL_SHADER_PROGRAM_MESA 0x9999
 
-#include "config.h"
 
 #endif /* GLHEADER_H */
diff --git a/src/mesa/main/hash.c b/src/mesa/main/hash.c
index ffb2c4d946..08c64568c8 100644
--- a/src/mesa/main/hash.c
+++ b/src/mesa/main/hash.c
@@ -63,6 +63,7 @@ struct _mesa_HashTable {
    struct HashEntry *Table[TABLE_SIZE];  /**< the lookup table */
    GLuint MaxKey;                        /**< highest key inserted so far */
    _glthread_Mutex Mutex;                /**< mutual exclusion lock */
+   _glthread_Mutex WalkMutex;            /**< for _mesa_HashWalk() */
    GLboolean InDeleteAll;                /**< Debug check */
 };
 
@@ -79,6 +80,7 @@ _mesa_NewHashTable(void)
    struct _mesa_HashTable *table = CALLOC_STRUCT(_mesa_HashTable);
    if (table) {
       _glthread_INIT_MUTEX(table->Mutex);
+      _glthread_INIT_MUTEX(table->WalkMutex);
    }
    return table;
 }
@@ -111,6 +113,7 @@ _mesa_DeleteHashTable(struct _mesa_HashTable *table)
       }
    }
    _glthread_DESTROY_MUTEX(table->Mutex);
+   _glthread_DESTROY_MUTEX(table->WalkMutex);
    _mesa_free(table);
 }
 
@@ -285,6 +288,11 @@ _mesa_HashDeleteAll(struct _mesa_HashTable *table,
 
 /**
  * Walk over all entries in a hash table, calling callback function for each.
+ * Note: we use a separate mutex in this function to avoid a recursive
+ * locking deadlock (in case the callback calls _mesa_HashRemove()) and to
+ * prevent multiple threads/contexts from getting tangled up.
+ * A lock-less version of this function could be used when the table will
+ * not be modified.
  * \param table  the hash table to walk
  * \param callback  the callback function
  * \param userData  arbitrary pointer to pass along to the callback
@@ -300,14 +308,16 @@ _mesa_HashWalk(const struct _mesa_HashTable *table,
    GLuint pos;
    ASSERT(table);
    ASSERT(callback);
-   _glthread_UNLOCK_MUTEX(table2->Mutex);
+   _glthread_LOCK_MUTEX(table2->WalkMutex);
    for (pos = 0; pos < TABLE_SIZE; pos++) {
-      struct HashEntry *entry;
-      for (entry = table->Table[pos]; entry; entry = entry->Next) {
+      struct HashEntry *entry, *next;
+      for (entry = table->Table[pos]; entry; entry = next) {
+         /* save 'next' pointer now in case the callback deletes the entry */
+         next = entry->Next;
          callback(entry->Key, entry->Data, userData);
       }
    }
-   _glthread_UNLOCK_MUTEX(table2->Mutex);
+   _glthread_UNLOCK_MUTEX(table2->WalkMutex);
 }
 
 
diff --git a/src/mesa/main/hint.c b/src/mesa/main/hint.c
index dcfa9c7363..e2d4129a38 100644
--- a/src/mesa/main/hint.c
+++ b/src/mesa/main/hint.c
@@ -89,10 +89,6 @@ _mesa_Hint( GLenum target, GLenum mode )
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSION_HINT_ARB:
-         if (!ctx->Extensions.ARB_texture_compression) {
-            _mesa_error(ctx, GL_INVALID_ENUM, "glHint(target)");
-	    return;
-         }
 	 if (ctx->Hint.TextureCompression == mode)
 	    return;
 	 FLUSH_VERTICES(ctx, _NEW_HINT);
diff --git a/src/mesa/main/histogram.c b/src/mesa/main/histogram.c
index 905c1ad830..3632adc03e 100644
--- a/src/mesa/main/histogram.c
+++ b/src/mesa/main/histogram.c
@@ -29,8 +29,11 @@
 #include "context.h"
 #include "image.h"
 #include "histogram.h"
+#include "glapi/dispatch.h"
 
 
+#if FEATURE_histogram
+
 
 /*
  * XXX the packed pixel formats haven't been tested.
@@ -649,29 +652,11 @@ _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvo
       return;
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack min/max values into a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Pack, 2, 1, 1,
-                                     format, type, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetMinMax(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,"glGetMinMax(PBO is mapped)");
-         return;
-      }
-      values = ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
-      /* not an error */
+
+   values = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack, 2, 1, 1,
+                                        format, type, values, "glGetMinmax");
+   if (!values)
       return;
-   }
 
    {
       GLfloat minmax[2][4];
@@ -687,10 +672,7 @@ _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvo
                                  format, type, values, &ctx->Pack, 0x0);
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 
    if (reset) {
       _mesa_ResetMinmax(GL_MINMAX);
@@ -733,38 +715,18 @@ _mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, G
       return;
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack min/max values into a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(1, &ctx->Pack, ctx->Histogram.Width, 1, 1,
-                                     format, type, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetHistogram(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx,GL_INVALID_OPERATION,"glGetHistogram(PBO is mapped)");
-         return;
-      }
-      values = ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
-      /* not an error */
+   values = _mesa_map_validate_pbo_dest(ctx, 1, &ctx->Pack,
+                                        ctx->Histogram.Width, 1, 1,
+                                        format, type, values,
+                                        "glGetHistogram");
+   if (!values)
       return;
-   }
 
    pack_histogram(ctx, ctx->Histogram.Width,
                   (CONST GLuint (*)[4]) ctx->Histogram.Count,
                   format, type, values, &ctx->Pack);
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 
    if (reset) {
       GLuint i;
@@ -975,6 +937,8 @@ _mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean s
       }
    }
 
+   FLUSH_VERTICES(ctx, _NEW_PIXEL);
+
    /* reset histograms */
    for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
       ctx->Histogram.Count[i][0] = 0;
@@ -1002,8 +966,6 @@ _mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean s
       ctx->Histogram.AlphaSize     = 8 * sizeof(GLuint);
       ctx->Histogram.LuminanceSize = 8 * sizeof(GLuint);
    }
-
-   ctx->NewState |= _NEW_PIXEL;
 }
 
 
@@ -1058,8 +1020,6 @@ _mesa_ResetHistogram(GLenum target)
       ctx->Histogram.Count[i][2] = 0;
       ctx->Histogram.Count[i][3] = 0;
    }
-
-   ctx->NewState |= _NEW_PIXEL;
 }
 
 
@@ -1083,10 +1043,27 @@ _mesa_ResetMinmax(GLenum target)
    ctx->MinMax.Min[GCOMP] = 1000;    ctx->MinMax.Max[GCOMP] = -1000;
    ctx->MinMax.Min[BCOMP] = 1000;    ctx->MinMax.Max[BCOMP] = -1000;
    ctx->MinMax.Min[ACOMP] = 1000;    ctx->MinMax.Max[ACOMP] = -1000;
-   ctx->NewState |= _NEW_PIXEL;
 }
 
 
+void
+_mesa_init_histogram_dispatch(struct _glapi_table *disp)
+{
+   SET_GetHistogram(disp, _mesa_GetHistogram);
+   SET_GetHistogramParameterfv(disp, _mesa_GetHistogramParameterfv);
+   SET_GetHistogramParameteriv(disp, _mesa_GetHistogramParameteriv);
+   SET_GetMinmax(disp, _mesa_GetMinmax);
+   SET_GetMinmaxParameterfv(disp, _mesa_GetMinmaxParameterfv);
+   SET_GetMinmaxParameteriv(disp, _mesa_GetMinmaxParameteriv);
+   SET_Histogram(disp, _mesa_Histogram);
+   SET_Minmax(disp, _mesa_Minmax);
+   SET_ResetHistogram(disp, _mesa_ResetHistogram);
+   SET_ResetMinmax(disp, _mesa_ResetMinmax);
+}
+
+
+#endif /* FEATURE_histogram */
+
 
 /**********************************************************************/
 /*****                      Initialization                        *****/
diff --git a/src/mesa/main/histogram.h b/src/mesa/main/histogram.h
index 367e9b11ba..ce3246baf4 100644
--- a/src/mesa/main/histogram.h
+++ b/src/mesa/main/histogram.h
@@ -36,10 +36,9 @@
 #ifndef HISTOGRAM_H
 #define HISTOGRAM_H
 
-#include "glheader.h"
-#include "mtypes.h"
+#include "main/mtypes.h"
 
-#if _HAVE_FULL_GL
+#if FEATURE_histogram
 
 extern void GLAPIENTRY 
 _mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values);
@@ -71,13 +70,18 @@ _mesa_ResetHistogram(GLenum target);
 extern void GLAPIENTRY 
 _mesa_ResetMinmax(GLenum target);
 
-extern void _mesa_init_histogram( GLcontext * ctx );
+extern void
+_mesa_init_histogram_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_histogram */
 
-#else
+static INLINE void
+_mesa_init_histogram_dispatch(struct _glapi_table *disp)
+{
+}
 
-/** No-op */
-#define _mesa_init_histogram( c ) ((void) 0)
+#endif /* FEATURE_histogram */
 
-#endif
+extern void _mesa_init_histogram( GLcontext * ctx );
 
-#endif
+#endif /* HISTOGRAM_H */
diff --git a/src/mesa/main/image.c b/src/mesa/main/image.c
index 4d86c54777..baecbab0a3 100644
--- a/src/mesa/main/image.c
+++ b/src/mesa/main/image.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -181,6 +182,8 @@ _mesa_sizeof_type( GLenum type )
 	 return sizeof(GLint);
       case GL_FLOAT:
 	 return sizeof(GLfloat);
+      case GL_DOUBLE:
+	 return sizeof(GLdouble);
       case GL_HALF_FLOAT_ARB:
 	 return sizeof(GLhalfARB);
       default:
@@ -293,6 +296,9 @@ _mesa_components_in_format( GLenum format )
          return 2;
       case GL_DEPTH_STENCIL_EXT:
          return 2;
+      case GL_DUDV_ATI:
+      case GL_DU8DV8_ATI:
+         return 2;
       default:
          return -1;
    }
@@ -503,6 +509,20 @@ _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type )
             return GL_TRUE;
          else
             return GL_FALSE;
+      case GL_DUDV_ATI:
+      case GL_DU8DV8_ATI:
+         switch (type) {
+            case GL_BYTE:
+            case GL_UNSIGNED_BYTE:
+            case GL_SHORT:
+            case GL_UNSIGNED_SHORT:
+            case GL_INT:
+            case GL_UNSIGNED_INT:
+            case GL_FLOAT:
+               return GL_TRUE;
+            default:
+               return GL_FALSE;
+         }
       default:
          ; /* fall-through */
    }
@@ -511,6 +531,226 @@ _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type )
 
 
 /**
+ * Test if the given image format is a color/RGBA format (i.e., not color
+ * index, depth, stencil, etc).
+ * \param format  the image format value (may by an internal texture format)
+ * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
+ */
+GLboolean
+_mesa_is_color_format(GLenum format)
+{
+   switch (format) {
+      case GL_RED:
+      case GL_GREEN:
+      case GL_BLUE:
+      case GL_ALPHA:
+      case GL_ALPHA4:
+      case GL_ALPHA8:
+      case GL_ALPHA12:
+      case GL_ALPHA16:
+      case 1:
+      case GL_LUMINANCE:
+      case GL_LUMINANCE4:
+      case GL_LUMINANCE8:
+      case GL_LUMINANCE12:
+      case GL_LUMINANCE16:
+      case 2:
+      case GL_LUMINANCE_ALPHA:
+      case GL_LUMINANCE4_ALPHA4:
+      case GL_LUMINANCE6_ALPHA2:
+      case GL_LUMINANCE8_ALPHA8:
+      case GL_LUMINANCE12_ALPHA4:
+      case GL_LUMINANCE12_ALPHA12:
+      case GL_LUMINANCE16_ALPHA16:
+      case GL_INTENSITY:
+      case GL_INTENSITY4:
+      case GL_INTENSITY8:
+      case GL_INTENSITY12:
+      case GL_INTENSITY16:
+      case 3:
+      case GL_RGB:
+      case GL_BGR:
+      case GL_R3_G3_B2:
+      case GL_RGB4:
+      case GL_RGB5:
+      case GL_RGB8:
+      case GL_RGB10:
+      case GL_RGB12:
+      case GL_RGB16:
+      case 4:
+      case GL_ABGR_EXT:
+      case GL_RGBA:
+      case GL_BGRA:
+      case GL_RGBA2:
+      case GL_RGBA4:
+      case GL_RGB5_A1:
+      case GL_RGBA8:
+      case GL_RGB10_A2:
+      case GL_RGBA12:
+      case GL_RGBA16:
+      /* float texture formats */
+      case GL_ALPHA16F_ARB:
+      case GL_ALPHA32F_ARB:
+      case GL_LUMINANCE16F_ARB:
+      case GL_LUMINANCE32F_ARB:
+      case GL_LUMINANCE_ALPHA16F_ARB:
+      case GL_LUMINANCE_ALPHA32F_ARB:
+      case GL_INTENSITY16F_ARB:
+      case GL_INTENSITY32F_ARB:
+      case GL_RGB16F_ARB:
+      case GL_RGB32F_ARB:
+      case GL_RGBA16F_ARB:
+      case GL_RGBA32F_ARB:
+      /* compressed formats */
+      case GL_COMPRESSED_ALPHA:
+      case GL_COMPRESSED_LUMINANCE:
+      case GL_COMPRESSED_LUMINANCE_ALPHA:
+      case GL_COMPRESSED_INTENSITY:
+      case GL_COMPRESSED_RGB:
+      case GL_COMPRESSED_RGBA:
+      case GL_RGB_S3TC:
+      case GL_RGB4_S3TC:
+      case GL_RGBA_S3TC:
+      case GL_RGBA4_S3TC:
+      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+      case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+      case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+      case GL_COMPRESSED_RGB_FXT1_3DFX:
+      case GL_COMPRESSED_RGBA_FXT1_3DFX:
+#if FEATURE_EXT_texture_sRGB
+      case GL_SRGB_EXT:
+      case GL_SRGB8_EXT:
+      case GL_SRGB_ALPHA_EXT:
+      case GL_SRGB8_ALPHA8_EXT:
+      case GL_SLUMINANCE_ALPHA_EXT:
+      case GL_SLUMINANCE8_ALPHA8_EXT:
+      case GL_SLUMINANCE_EXT:
+      case GL_SLUMINANCE8_EXT:
+      case GL_COMPRESSED_SRGB_EXT:
+      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+      case GL_COMPRESSED_SRGB_ALPHA_EXT:
+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
+      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
+      case GL_COMPRESSED_SLUMINANCE_EXT:
+      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
+#endif /* FEATURE_EXT_texture_sRGB */
+         return GL_TRUE;
+      /* signed texture formats */
+      case GL_RGBA_SNORM:
+      case GL_RGBA8_SNORM:
+         return GL_TRUE;
+      case GL_YCBCR_MESA:  /* not considered to be RGB */
+         /* fall-through */
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
+ * Test if the given image format is a color index format.
+ */
+GLboolean
+_mesa_is_index_format(GLenum format)
+{
+   switch (format) {
+      case GL_COLOR_INDEX:
+      case GL_COLOR_INDEX1_EXT:
+      case GL_COLOR_INDEX2_EXT:
+      case GL_COLOR_INDEX4_EXT:
+      case GL_COLOR_INDEX8_EXT:
+      case GL_COLOR_INDEX12_EXT:
+      case GL_COLOR_INDEX16_EXT:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
+ * Test if the given image format is a depth component format.
+ */
+GLboolean
+_mesa_is_depth_format(GLenum format)
+{
+   switch (format) {
+      case GL_DEPTH_COMPONENT:
+      case GL_DEPTH_COMPONENT16:
+      case GL_DEPTH_COMPONENT24:
+      case GL_DEPTH_COMPONENT32:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
+ * Test if the given image format is a stencil format.
+ */
+GLboolean
+_mesa_is_stencil_format(GLenum format)
+{
+   switch (format) {
+      case GL_STENCIL_INDEX:
+      case GL_DEPTH_STENCIL:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
+ * Test if the given image format is a YCbCr format.
+ */
+GLboolean
+_mesa_is_ycbcr_format(GLenum format)
+{
+   switch (format) {
+      case GL_YCBCR_MESA:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
+ * Test if the given image format is a depth+stencil format.
+ */
+GLboolean
+_mesa_is_depthstencil_format(GLenum format)
+{
+   switch (format) {
+      case GL_DEPTH24_STENCIL8_EXT:
+      case GL_DEPTH_STENCIL_EXT:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+/**
+ * Test if the given image format is a dudv format.
+ */
+GLboolean
+_mesa_is_dudv_format(GLenum format)
+{
+   switch (format) {
+      case GL_DUDV_ATI:
+      case GL_DU8DV8_ATI:
+         return GL_TRUE;
+      default:
+         return GL_FALSE;
+   }
+}
+
+
+/**
  * Return the address of a specific pixel in an image (1D, 2D or 3D).
  *
  * Pixel unpacking/packing parameters are observed according to \p packing.
@@ -738,12 +978,20 @@ _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
                           GLint width, GLint height,
                           GLenum format, GLenum type )
 {
+   GLint bytesPerRow, bytesPerImage, remainder;
+
    ASSERT(packing);
-   ASSERT(type != GL_BITMAP);
 
-   {
+   if (type == GL_BITMAP) {
+      if (packing->RowLength == 0) {
+         bytesPerRow = (width + 7) / 8;
+      }
+      else {
+         bytesPerRow = (packing->RowLength + 7) / 8;
+      }
+   }
+   else {
       const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
-      GLint bytesPerRow, bytesPerImage, remainder;
 
       if (bytesPerPixel <= 0)
          return -1;  /* error */
@@ -753,17 +1001,18 @@ _mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
       else {
          bytesPerRow = bytesPerPixel * packing->RowLength;
       }
-      remainder = bytesPerRow % packing->Alignment;
-      if (remainder > 0)
-         bytesPerRow += (packing->Alignment - remainder);
+   }
 
-      if (packing->ImageHeight == 0)
-         bytesPerImage = bytesPerRow * height;
-      else
-         bytesPerImage = bytesPerRow * packing->ImageHeight;
+   remainder = bytesPerRow % packing->Alignment;
+   if (remainder > 0)
+      bytesPerRow += (packing->Alignment - remainder);
 
-      return bytesPerImage;
-   }
+   if (packing->ImageHeight == 0)
+      bytesPerImage = bytesPerRow * height;
+   else
+      bytesPerImage = bytesPerRow * packing->ImageHeight;
+
+   return bytesPerImage;
 }
 
 
@@ -1010,6 +1259,91 @@ _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
 }
 
 
+/**
+ * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel.
+ * This is typically used to convert a bitmap into a GLubyte/pixel texture.
+ * "On" bits will set texels to \p onValue.
+ * "Off" bits will not modify texels.
+ * \param width  src bitmap width in pixels
+ * \param height  src bitmap height in pixels
+ * \param unpack  bitmap unpacking state
+ * \param bitmap  the src bitmap data
+ * \param destBuffer  start of dest buffer
+ * \param destStride  row stride in dest buffer
+ * \param onValue  if bit is 1, set destBuffer pixel to this value
+ */
+void
+_mesa_expand_bitmap(GLsizei width, GLsizei height,
+                    const struct gl_pixelstore_attrib *unpack,
+                    const GLubyte *bitmap,
+                    GLubyte *destBuffer, GLint destStride,
+                    GLubyte onValue)
+{
+   const GLubyte *srcRow = (const GLubyte *)
+      _mesa_image_address2d(unpack, bitmap, width, height,
+                            GL_COLOR_INDEX, GL_BITMAP, 0, 0);
+   const GLint srcStride = _mesa_image_row_stride(unpack, width,
+                                                  GL_COLOR_INDEX, GL_BITMAP);
+   GLint row, col;
+
+#define SET_PIXEL(COL, ROW) \
+   destBuffer[(ROW) * destStride + (COL)] = onValue;
+
+   for (row = 0; row < height; row++) {
+      const GLubyte *src = srcRow;
+
+      if (unpack->LsbFirst) {
+         /* Lsb first */
+         GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
+         for (col = 0; col < width; col++) {
+
+            if (*src & mask) {
+               SET_PIXEL(col, row);
+            }
+
+            if (mask == 128U) {
+               src++;
+               mask = 1U;
+            }
+            else {
+               mask = mask << 1;
+            }
+         }
+
+         /* get ready for next row */
+         if (mask != 1)
+            src++;
+      }
+      else {
+         /* Msb first */
+         GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
+         for (col = 0; col < width; col++) {
+
+            if (*src & mask) {
+               SET_PIXEL(col, row);
+            }
+
+            if (mask == 1U) {
+               src++;
+               mask = 128U;
+            }
+            else {
+               mask = mask >> 1;
+            }
+         }
+
+         /* get ready for next row */
+         if (mask != 128)
+            src++;
+      }
+
+      srcRow += srcStride;
+   } /* row */
+
+#undef SET_PIXEL
+}
+
+
 /**********************************************************************/
 /*****                  Pixel processing functions               ******/
 /**********************************************************************/
@@ -1660,7 +1994,6 @@ _mesa_apply_stencil_transfer_ops(const GLcontext *ctx, GLuint n,
  * Used to pack an array [][4] of RGBA float colors as specified
  * by the dstFormat, dstType and dstPacking.  Used by glReadPixels,
  * glGetConvolutionFilter(), etc.
- * Incoming colors will be clamped to [0,1] if needed.
  * Note: the rgba values will be modified by this function when any pixel
  * transfer ops are enabled.
  */
@@ -1675,6 +2008,10 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
    const GLint comps = _mesa_components_in_format(dstFormat);
    GLuint i;
 
+   /* XXX
+    * This test should probably go away.  Have the caller set/clear the
+    * IMAGE_CLAMP_BIT as needed.
+    */
    if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {
       /* need to clamp to [0, 1] */
       transferOps |= IMAGE_CLAMP_BIT;
@@ -1774,6 +2111,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -1847,6 +2191,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -1920,6 +2271,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -1993,6 +2351,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -2066,6 +2431,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -2139,6 +2511,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -2212,6 +2591,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = rgba[i][RCOMP];
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = rgba[i][RCOMP];
+                     dst[i*2+1] = rgba[i][GCOMP];
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -2285,6 +2671,13 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
                      dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
                   }
                   break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                  }
+                  break;
                default:
                   _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
             }
@@ -2294,9 +2687,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGB) {
             GLubyte *dst = (GLubyte *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
-                      | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
-                      | (((GLint) (rgba[i][BCOMP] * 3.0F))     );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
+                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
+                      | (IROUND(rgba[i][BCOMP] * 3.0F)     );
             }
          }
          break;
@@ -2304,9 +2697,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGB) {
             GLubyte *dst = (GLubyte *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F))     )
-                      | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
-                      | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 6);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F)     )
+                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
+                      | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
             }
          }
          break;
@@ -2314,9 +2707,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGB) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
-                      | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F))      );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F)      );
             }
          }
          break;
@@ -2324,9 +2717,9 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGB) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
-                      | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
             }
          }
          break;
@@ -2334,28 +2727,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
+               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12)
-                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][RCOMP] * 15.0F))      );
+               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F)      );
             }
          }
          break;
@@ -2363,28 +2756,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F))      )
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F))      )
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
+               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F))      )
-                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
-                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
-                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
+               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
             }
          }
          break;
@@ -2392,28 +2785,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  1)
-                      | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
-                      | (((GLint) (rgba[i][RCOMP] * 31.0F)) <<  1)
-                      | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
+               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][RCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  6)
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  1)
-                      | (((GLint) (rgba[i][RCOMP] *  1.0F))      );
+               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][RCOMP] *  1.0F)      );
             }
          }
          break;
@@ -2421,28 +2814,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
-                      | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F))      )
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
-                      | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
-                      | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
+               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLushort *dst = (GLushort *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F))      )
-                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  5)
-                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
-                      | (((GLint) (rgba[i][RCOMP] *  1.0F)) << 15);
+               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][RCOMP] *  1.0F) << 15);
             }
          }
          break;
@@ -2450,28 +2843,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][BCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 255.F)      );
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
+               dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][RCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 255.F)      );
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
-                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][RCOMP] * 255.0F))      );
+               dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 255.F)      );
             }
          }
          break;
@@ -2479,28 +2872,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F))      )
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F))      )
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
+               dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F))      )
-                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
-                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
-                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
+               dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
             }
          }
          break;
@@ -2508,28 +2901,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
-                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) <<  2)
-                      | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
+               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
-                      | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) <<  2)
-                      | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
+               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][RCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
-                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) <<  2)
-                      | (((GLuint) (rgba[i][RCOMP] *    3.0F))      );
+               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][RCOMP] *    3.0F)      );
             }
          }
          break;
@@ -2537,28 +2930,28 @@ _mesa_pack_rgba_span_float(GLcontext *ctx, GLuint n, GLfloat rgba[][4],
          if (dstFormat == GL_RGBA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F))      )
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
-                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
-                      | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
+               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
             }
          }
          else if (dstFormat == GL_BGRA) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F))      )
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
-                      | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
-                      | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
+               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
             }
          }
          else if (dstFormat == GL_ABGR_EXT) {
             GLuint *dst = (GLuint *) dstAddr;
             for (i=0;i<n;i++) {
-               dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F))      )
-                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
-                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
-                      | (((GLuint) (rgba[i][RCOMP] *    3.0F)) << 30);
+               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][RCOMP] *    3.0F) << 30);
             }
          }
          break;
@@ -2786,7 +3179,7 @@ extract_uint_indexes(GLuint n, GLuint indexes[],
             }
             else {
                for (i = 0; i < n; i++)
-                  indexes[i] = s[i] & 0xfff;  /* lower 8 bits */
+                  indexes[i] = s[i] & 0xff;  /* lower 8 bits */
             }
          }
          break;
@@ -2834,7 +3227,8 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4],
           srcFormat == GL_BGR ||
           srcFormat == GL_RGBA ||
           srcFormat == GL_BGRA ||
-          srcFormat == GL_ABGR_EXT);
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_DUDV_ATI);
 
    ASSERT(srcType == GL_UNSIGNED_BYTE ||
           srcType == GL_BYTE ||
@@ -2949,6 +3343,13 @@ extract_float_rgba(GLuint n, GLfloat rgba[][4],
          aComp = 0;
          stride = 4;
          break;
+      case GL_DUDV_ATI:
+         redIndex = 0;
+         greenIndex = 1;
+         blueIndex = -1;
+         alphaIndex = -1;
+         stride = 2;
+         break;
       default:
          _mesa_problem(NULL, "bad srcFormat in extract float data");
          return;
@@ -3877,6 +4278,62 @@ _mesa_unpack_color_span_float( GLcontext *ctx,
    }
 }
 
+/**
+ * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
+ * directly return GLbyte data, no transfer ops apply.
+ */
+void
+_mesa_unpack_dudv_span_byte( GLcontext *ctx,
+                             GLuint n, GLenum dstFormat, GLbyte dest[],
+                             GLenum srcFormat, GLenum srcType,
+                             const GLvoid *source,
+                             const struct gl_pixelstore_attrib *srcPacking,
+                             GLbitfield transferOps )
+{
+   ASSERT(dstFormat == GL_DUDV_ATI);
+   ASSERT(srcFormat == GL_DUDV_ATI);
+
+   ASSERT(srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT);
+
+   /* general solution */
+   {
+      GLint dstComponents;
+      GLfloat rgba[MAX_WIDTH][4];
+      GLbyte *dst = dest;
+      GLuint i;
+
+      dstComponents = _mesa_components_in_format( dstFormat );
+      /* source & dest image formats should have been error checked by now */
+      assert(dstComponents > 0);
+
+      /*
+       * Extract image data and convert to RGBA floats
+       */
+      assert(n <= MAX_WIDTH);
+      extract_float_rgba(n, rgba, srcFormat, srcType, source,
+                         srcPacking->SwapBytes);
+
+
+      /* Now determine which color channels we need to produce.
+       * And determine the dest index (offset) within each color tuple.
+       */
+
+      /* Now pack results in the requested dstFormat */
+      for (i = 0; i < n; i++) {
+         /* not sure - need clamp[-1,1] here? */
+         dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+         dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+         dst += dstComponents;
+      }
+   }
+}
 
 /*
  * Unpack a row of color index data from a client buffer according to
@@ -4406,6 +4863,17 @@ _mesa_unpack_depth_span( const GLcontext *ctx, GLuint n,
          }
          return;
       }
+      if (srcType == GL_UNSIGNED_INT_24_8
+          && dstType == GL_UNSIGNED_INT
+          && depthMax == 0xffffff) {
+         const GLuint *src = (const GLuint *) source;
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = src[i] >> 8;
+         }
+         return;
+      }
       /* XXX may want to add additional cases here someday */
    }
 
@@ -5172,3 +5640,181 @@ _mesa_clip_to_region(GLint xmin, GLint ymin,
 
    return GL_TRUE;
 }
+
+
+/**
+ * Clip dst coords against Xmax (or Ymax).
+ */
+static INLINE void
+clip_right_or_top(GLint *srcX0, GLint *srcX1,
+                  GLint *dstX0, GLint *dstX1,
+                  GLint maxValue)
+{
+   GLfloat t, bias;
+
+   if (*dstX1 > maxValue) {
+      /* X1 outside right edge */
+      ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */
+      t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
+      /* chop off [t, 1] part */
+      ASSERT(t >= 0.0 && t <= 1.0);
+      *dstX1 = maxValue;
+      bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
+      *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
+   }
+   else if (*dstX0 > maxValue) {
+      /* X0 outside right edge */
+      ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */
+      t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
+      /* chop off [t, 1] part */
+      ASSERT(t >= 0.0 && t <= 1.0);
+      *dstX0 = maxValue;
+      bias = (*srcX0 < *srcX1) ? -0.5 : 0.5;
+      *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
+   }
+}
+
+
+/**
+ * Clip dst coords against Xmin (or Ymin).
+ */
+static INLINE void
+clip_left_or_bottom(GLint *srcX0, GLint *srcX1,
+                    GLint *dstX0, GLint *dstX1,
+                    GLint minValue)
+{
+   GLfloat t, bias;
+
+   if (*dstX0 < minValue) {
+      /* X0 outside left edge */
+      ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */
+      t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0);
+      /* chop off [0, t] part */
+      ASSERT(t >= 0.0 && t <= 1.0);
+      *dstX0 = minValue;
+      bias = (*srcX0 < *srcX1) ? 0.5 : -0.5; /* flipped??? */
+      *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias);
+   }
+   else if (*dstX1 < minValue) {
+      /* X1 outside left edge */
+      ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */
+      t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1);
+      /* chop off [0, t] part */
+      ASSERT(t >= 0.0 && t <= 1.0);
+      *dstX1 = minValue;
+      bias = (*srcX0 < *srcX1) ? 0.5 : -0.5;
+      *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias);
+   }
+}
+
+
+/**
+ * Do clipping of blit src/dest rectangles.
+ * The dest rect is clipped against both the buffer bounds and scissor bounds.
+ * The src rect is just clipped against the buffer bounds.
+ *
+ * When either the src or dest rect is clipped, the other is also clipped
+ * proportionately!
+ *
+ * Note that X0 need not be less than X1 (same for Y) for either the source
+ * and dest rects.  That makes the clipping a little trickier.
+ *
+ * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped
+ */
+GLboolean
+_mesa_clip_blit(GLcontext *ctx,
+                GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,
+                GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1)
+{
+   const GLint srcXmin = 0;
+   const GLint srcXmax = ctx->ReadBuffer->Width;
+   const GLint srcYmin = 0;
+   const GLint srcYmax = ctx->ReadBuffer->Height;
+
+   /* these include scissor bounds */
+   const GLint dstXmin = ctx->DrawBuffer->_Xmin;
+   const GLint dstXmax = ctx->DrawBuffer->_Xmax;
+   const GLint dstYmin = ctx->DrawBuffer->_Ymin;
+   const GLint dstYmax = ctx->DrawBuffer->_Ymax;
+
+   /*
+   printf("PreClipX:  src: %d .. %d  dst: %d .. %d\n",
+          *srcX0, *srcX1, *dstX0, *dstX1);
+   printf("PreClipY:  src: %d .. %d  dst: %d .. %d\n",
+          *srcY0, *srcY1, *dstY0, *dstY1);
+   */
+
+   /* trivial rejection tests */
+   if (*dstX0 == *dstX1)
+      return GL_FALSE; /* no width */
+   if (*dstX0 <= dstXmin && *dstX1 <= dstXmin)
+      return GL_FALSE; /* totally out (left) of bounds */
+   if (*dstX0 >= dstXmax && *dstX1 >= dstXmax)
+      return GL_FALSE; /* totally out (right) of bounds */
+
+   if (*dstY0 == *dstY1)
+      return GL_FALSE;
+   if (*dstY0 <= dstYmin && *dstY1 <= dstYmin)
+      return GL_FALSE;
+   if (*dstY0 >= dstYmax && *dstY1 >= dstYmax)
+      return GL_FALSE;
+
+   if (*srcX0 == *srcX1)
+      return GL_FALSE;
+   if (*srcX0 <= srcXmin && *srcX1 <= srcXmin)
+      return GL_FALSE;
+   if (*srcX0 >= srcXmax && *srcX1 >= srcXmax)
+      return GL_FALSE;
+
+   if (*srcY0 == *srcY1)
+      return GL_FALSE;
+   if (*srcY0 <= srcYmin && *srcY1 <= srcYmin)
+      return GL_FALSE;
+   if (*srcY0 >= srcYmax && *srcY1 >= srcYmax)
+      return GL_FALSE;
+
+   /*
+    * dest clip
+    */
+   clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax);
+   clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax);
+   clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin);
+   clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin);
+
+   /*
+    * src clip (just swap src/dst values from above)
+    */
+   clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax);
+   clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax);
+   clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin);
+   clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin);
+
+   /*
+   printf("PostClipX: src: %d .. %d  dst: %d .. %d\n",
+          *srcX0, *srcX1, *dstX0, *dstX1);
+   printf("PostClipY: src: %d .. %d  dst: %d .. %d\n",
+          *srcY0, *srcY1, *dstY0, *dstY1);
+   */
+
+   ASSERT(*dstX0 >= dstXmin);
+   ASSERT(*dstX0 <= dstXmax);
+   ASSERT(*dstX1 >= dstXmin);
+   ASSERT(*dstX1 <= dstXmax);
+
+   ASSERT(*dstY0 >= dstYmin);
+   ASSERT(*dstY0 <= dstYmax);
+   ASSERT(*dstY1 >= dstYmin);
+   ASSERT(*dstY1 <= dstYmax);
+
+   ASSERT(*srcX0 >= srcXmin);
+   ASSERT(*srcX0 <= srcXmax);
+   ASSERT(*srcX1 >= srcXmin);
+   ASSERT(*srcX1 <= srcXmax);
+
+   ASSERT(*srcY0 >= srcYmin);
+   ASSERT(*srcY0 <= srcYmax);
+   ASSERT(*srcY1 >= srcYmin);
+   ASSERT(*srcY1 <= srcYmax);
+
+   return GL_TRUE;
+}
diff --git a/src/mesa/main/image.h b/src/mesa/main/image.h
index 0e0bbd96d8..72717d6787 100644
--- a/src/mesa/main/image.h
+++ b/src/mesa/main/image.h
@@ -54,6 +54,27 @@ _mesa_bytes_per_pixel( GLenum format, GLenum type );
 extern GLboolean
 _mesa_is_legal_format_and_type( GLcontext *ctx, GLenum format, GLenum type );
 
+extern GLboolean
+_mesa_is_color_format(GLenum format);
+
+extern GLboolean
+_mesa_is_index_format(GLenum format);
+
+extern GLboolean
+_mesa_is_depth_format(GLenum format);
+
+extern GLboolean
+_mesa_is_stencil_format(GLenum format);
+
+extern GLboolean
+_mesa_is_ycbcr_format(GLenum format);
+
+extern GLboolean
+_mesa_is_depthstencil_format(GLenum format);
+
+extern GLboolean
+_mesa_is_dudv_format(GLenum format);
+
 
 extern GLvoid *
 _mesa_image_address( GLuint dimensions,
@@ -113,6 +134,13 @@ extern void
 _mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
                    GLubyte *dest, const struct gl_pixelstore_attrib *packing );
 
+extern void
+_mesa_expand_bitmap(GLsizei width, GLsizei height,
+                    const struct gl_pixelstore_attrib *unpack,
+                    const GLubyte *bitmap,
+                    GLubyte *destBuffer, GLint destStride,
+                    GLubyte onValue);
+
 
 /** \name Pixel processing functions */
 /*@{*/
@@ -198,6 +226,13 @@ _mesa_unpack_color_span_float( GLcontext *ctx,
                                const struct gl_pixelstore_attrib *srcPacking,
                                GLbitfield transferOps );
 
+extern void
+_mesa_unpack_dudv_span_byte( GLcontext *ctx,
+                             GLuint n, GLenum dstFormat, GLbyte dest[],
+                             GLenum srcFormat, GLenum srcType,
+                             const GLvoid *source,
+                             const struct gl_pixelstore_attrib *srcPacking,
+                             GLbitfield transferOps );
 
 extern void
 _mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
@@ -284,4 +319,10 @@ _mesa_clip_to_region(GLint xmin, GLint ymin,
                      GLint *x, GLint *y,
                      GLsizei *width, GLsizei *height );
 
+extern GLboolean
+_mesa_clip_blit(GLcontext *ctx,
+                GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1,
+                GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1);
+
+
 #endif
diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c
index 5cf1a2baa4..6ffaddcde9 100644
--- a/src/mesa/main/imports.c
+++ b/src/mesa/main/imports.c
@@ -557,7 +557,7 @@ _mesa_pow(double x, double y)
  * Find the first bit set in a word.
  */
 int
-_mesa_ffs(int i)
+_mesa_ffs(int32_t i)
 {
 #if (defined(_WIN32) ) || defined(__IBMC__) || defined(__IBMCPP__)
    register int bit = 0;
@@ -594,11 +594,7 @@ _mesa_ffs(int i)
  *          if no bits set.
  */
 int
-#ifdef __MINGW32__
-_mesa_ffsll(long val)
-#else
-_mesa_ffsll(long long val)
-#endif
+_mesa_ffsll(int64_t val)
 {
 #ifdef ffsll
    return ffsll(val);
@@ -607,11 +603,11 @@ _mesa_ffsll(long long val)
 
    assert(sizeof(val) == 8);
 
-   bit = _mesa_ffs(val);
+   bit = _mesa_ffs((int32_t)val);
    if (bit != 0)
       return bit;
 
-   bit = _mesa_ffs(val >> 32);
+   bit = _mesa_ffs((int32_t)(val >> 32));
    if (bit != 0)
       return 32 + bit;
 
@@ -915,6 +911,20 @@ _mesa_strtod( const char *s, char **end )
    return strtod(s, end);
 }
 
+/** Compute simple checksum/hash for a string */
+unsigned int
+_mesa_str_checksum(const char *str)
+{
+   /* This could probably be much better */
+   unsigned int sum, i;
+   const char *c;
+   sum = i = 1;
+   for (c = str; *c; c++)
+      sum += *c * (i % 100);
+   return sum;
+}
+
+
 /*@}*/
 
 
@@ -950,14 +960,25 @@ _mesa_snprintf( char *str, size_t size, const char *fmt, ... )
 void
 _mesa_printf( const char *fmtString, ... )
 {
+   va_list args;
+   va_start( args, fmtString );  
+   vfprintf(stderr, fmtString, args);
+   va_end( args );
+}
+
+/** Wrapper around fprintf(), using vsprintf() for the formatting. */
+void
+_mesa_fprintf( FILE *f, const char *fmtString, ... )
+{
    char s[MAXSTRING];
    va_list args;
    va_start( args, fmtString );  
    vsnprintf(s, MAXSTRING, fmtString, args);
    va_end( args );
-   fprintf(stderr,"%s", s);
+   fprintf(f, "%s", s);
 }
 
+
 /** Wrapper around vsprintf() */
 int
 _mesa_vsprintf( char *str, const char *fmt, va_list args )
@@ -972,39 +993,130 @@ _mesa_vsprintf( char *str, const char *fmt, va_list args )
 /** \name Diagnostics */
 /*@{*/
 
+static void
+output_if_debug(const char *prefixString, const char *outputString,
+                GLboolean newline)
+{
+   static int debug = -1;
+
+   /* Check the MESA_DEBUG environment variable if it hasn't
+    * been checked yet.  We only have to check it once...
+    */
+   if (debug == -1) {
+      char *env = _mesa_getenv("MESA_DEBUG");
+
+      /* In a debug build, we print warning messages *unless*
+       * MESA_DEBUG is 0.  In a non-debug build, we don't
+       * print warning messages *unless* MESA_DEBUG is
+       * set *to any value*.
+       */
+#ifdef DEBUG
+      debug = (env != NULL && _mesa_atoi(env) == 0) ? 0 : 1;
+#else
+      debug = (env != NULL) ? 1 : 0;
+#endif
+   }
+
+   /* Now only print the string if we're required to do so. */
+   if (debug) {
+      fprintf(stderr, "%s: %s", prefixString, outputString);
+      if (newline)
+         fprintf(stderr, "\n");
+
+#if defined(_WIN32) && !defined(_WIN32_WCE)
+      /* stderr from windows applications without console is not usually 
+       * visible, so communicate with the debugger instead */ 
+      {
+         char buf[4096];
+         _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
+         OutputDebugStringA(buf);
+      }
+#endif
+   }
+}
+
+
+/**
+ * Return string version of GL error code.
+ */
+static const char *
+error_string( GLenum error )
+{
+   switch (error) {
+   case GL_NO_ERROR:
+      return "GL_NO_ERROR";
+   case GL_INVALID_VALUE:
+      return "GL_INVALID_VALUE";
+   case GL_INVALID_ENUM:
+      return "GL_INVALID_ENUM";
+   case GL_INVALID_OPERATION:
+      return "GL_INVALID_OPERATION";
+   case GL_STACK_OVERFLOW:
+      return "GL_STACK_OVERFLOW";
+   case GL_STACK_UNDERFLOW:
+      return "GL_STACK_UNDERFLOW";
+   case GL_OUT_OF_MEMORY:
+      return "GL_OUT_OF_MEMORY";
+   case GL_TABLE_TOO_LARGE:
+      return "GL_TABLE_TOO_LARGE";
+   case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
+      return "GL_INVALID_FRAMEBUFFER_OPERATION";
+   default:
+      return "unknown";
+   }
+}
+
+
+/**
+ * When a new type of error is recorded, print a message describing
+ * previous errors which were accumulated.
+ */
+static void
+flush_delayed_errors( GLcontext *ctx )
+{
+   char s[MAXSTRING];
+
+   if (ctx->ErrorDebugCount) {
+      _mesa_snprintf(s, MAXSTRING, "%d similar %s errors", 
+                     ctx->ErrorDebugCount,
+                     error_string(ctx->ErrorValue));
+
+      output_if_debug("Mesa", s, GL_TRUE);
+
+      ctx->ErrorDebugCount = 0;
+   }
+}
+
+
 /**
  * Report a warning (a recoverable error condition) to stderr if
  * either DEBUG is defined or the MESA_DEBUG env var is set.
  *
  * \param ctx GL context.
- * \param fmtString printf() alike format string.
+ * \param fmtString printf()-like format string.
  */
 void
 _mesa_warning( GLcontext *ctx, const char *fmtString, ... )
 {
-   GLboolean debug;
    char str[MAXSTRING];
    va_list args;
-   (void) ctx;
    va_start( args, fmtString );  
    (void) vsnprintf( str, MAXSTRING, fmtString, args );
    va_end( args );
-#ifdef DEBUG
-   debug = GL_TRUE; /* always print warning */
-#else
-   debug = _mesa_getenv("MESA_DEBUG") ? GL_TRUE : GL_FALSE;
-#endif
-   if (debug) {
-      fprintf(stderr, "Mesa warning: %s\n", str);
-   }
+   
+   if (ctx)
+      flush_delayed_errors( ctx );
+
+   output_if_debug("Mesa warning", str, GL_TRUE);
 }
 
+
 /**
- * Report an internla implementation problem.
+ * Report an internal implementation problem.
  * Prints the message to stderr via fprintf().
  *
  * \param ctx GL context.
- * \param s problem description string.
+ * \param fmtString problem description string.
  */
 void
 _mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
@@ -1021,8 +1133,9 @@ _mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
    fprintf(stderr, "Please report at bugzilla.freedesktop.org\n");
 }
 
+
 /**
- * Record an OpenGL state error.  These usually occur when the users
+ * Record an OpenGL state error.  These usually occur when the user
  * passes invalid parameters to a GL function.
  *
  * If debugging is enabled (either at compile-time via the DEBUG macro, or
@@ -1036,69 +1149,52 @@ _mesa_problem( const GLcontext *ctx, const char *fmtString, ... )
 void
 _mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... )
 {
-   const char *debugEnv;
-   GLboolean debug;
+   static GLint debug = -1;
 
-   debugEnv = _mesa_getenv("MESA_DEBUG");
+   /* Check debug environment variable only once:
+    */
+   if (debug == -1) {
+      const char *debugEnv = _mesa_getenv("MESA_DEBUG");
 
 #ifdef DEBUG
-   if (debugEnv && _mesa_strstr(debugEnv, "silent"))
-      debug = GL_FALSE;
-   else
-      debug = GL_TRUE;
+      if (debugEnv && _mesa_strstr(debugEnv, "silent"))
+         debug = GL_FALSE;
+      else
+         debug = GL_TRUE;
 #else
-   if (debugEnv)
-      debug = GL_TRUE;
-   else
-      debug = GL_FALSE;
+      if (debugEnv)
+         debug = GL_TRUE;
+      else
+         debug = GL_FALSE;
 #endif
+   }
 
-   if (debug) {
-      va_list args;
-      char where[MAXSTRING];
-      const char *errstr;
-
-      va_start( args, fmtString );  
-      vsnprintf( where, MAXSTRING, fmtString, args );
-      va_end( args );
-
-      switch (error) {
-	 case GL_NO_ERROR:
-	    errstr = "GL_NO_ERROR";
-	    break;
-	 case GL_INVALID_VALUE:
-	    errstr = "GL_INVALID_VALUE";
-	    break;
-	 case GL_INVALID_ENUM:
-	    errstr = "GL_INVALID_ENUM";
-	    break;
-	 case GL_INVALID_OPERATION:
-	    errstr = "GL_INVALID_OPERATION";
-	    break;
-	 case GL_STACK_OVERFLOW:
-	    errstr = "GL_STACK_OVERFLOW";
-	    break;
-	 case GL_STACK_UNDERFLOW:
-	    errstr = "GL_STACK_UNDERFLOW";
-	    break;
-	 case GL_OUT_OF_MEMORY:
-	    errstr = "GL_OUT_OF_MEMORY";
-	    break;
-         case GL_TABLE_TOO_LARGE:
-            errstr = "GL_TABLE_TOO_LARGE";
-            break;
-         case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
-            errstr = "GL_INVALID_FRAMEBUFFER_OPERATION";
-            break;
-	 default:
-	    errstr = "unknown";
-	    break;
+   if (debug) {      
+      if (ctx->ErrorValue == error &&
+          ctx->ErrorDebugFmtString == fmtString) {
+         ctx->ErrorDebugCount++;
+      }
+      else {
+         char s[MAXSTRING], s2[MAXSTRING];
+         va_list args;
+
+         flush_delayed_errors( ctx );
+         
+         va_start(args, fmtString);
+         vsnprintf(s, MAXSTRING, fmtString, args);
+         va_end(args);
+
+         _mesa_snprintf(s2, MAXSTRING, "%s in %s", error_string(error), s);
+         output_if_debug("Mesa: User error", s2, GL_TRUE);
+         
+         ctx->ErrorDebugFmtString = fmtString;
+         ctx->ErrorDebugCount = 0;
       }
-      _mesa_debug(ctx, "User error: %s in %s\n", errstr, where);
    }
 
    _mesa_record_error(ctx, error);
-}  
+}
+
 
 /**
  * Report debug information.  Print error message to stderr via fprintf().
@@ -1116,7 +1212,7 @@ _mesa_debug( const GLcontext *ctx, const char *fmtString, ... )
    va_start(args, fmtString);
    vsnprintf(s, MAXSTRING, fmtString, args);
    va_end(args);
-   fprintf(stderr, "Mesa: %s", s);
+   output_if_debug("Mesa", s, GL_FALSE);
 #endif /* DEBUG */
    (void) ctx;
    (void) fmtString;
diff --git a/src/mesa/main/imports.h b/src/mesa/main/imports.h
index 13b571d1cb..7d4012a856 100644
--- a/src/mesa/main/imports.h
+++ b/src/mesa/main/imports.h
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  *
@@ -36,10 +36,8 @@
 #define IMPORTS_H
 
 
-/* XXX some of the stuff in glheader.h should be moved into this file.
- */
+#include "compiler.h"
 #include "glheader.h"
-#include <GL/internal/glcore.h>
 
 
 #ifdef __cplusplus
@@ -48,26 +46,6 @@ extern "C" {
 
 
 /**********************************************************************/
-/** \name General macros */
-/*@{*/
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-
-/** gcc -pedantic warns about long string literals, LONGSTRING silences that */
-#if !defined(__GNUC__) || (__GNUC__ < 2) || \
-    ((__GNUC__ == 2) && (__GNUC_MINOR__ <= 7))
-# define LONGSTRING
-#else
-# define LONGSTRING __extension__
-#endif
-
-/*@}*/
-
-
-/**********************************************************************/
 /** Memory macros */
 /*@{*/
 
@@ -130,49 +108,11 @@ typedef union { GLfloat f; GLint i; } fi_type;
 #define MAX_GLUSHORT	0xffff
 #define MAX_GLUINT	0xffffffff
 
-#ifndef M_PI
-#define M_PI (3.1415926536)
-#endif
-
-#ifndef M_E
-#define M_E (2.7182818284590452354)
-#endif
-
-#ifndef ONE_DIV_LN2
-#define ONE_DIV_LN2 (1.442695040888963456)
-#endif
-
-#ifndef ONE_DIV_SQRT_LN2
-#define ONE_DIV_SQRT_LN2 (1.201122408786449815)
-#endif
-
-#ifndef FLT_MAX_EXP
-#define FLT_MAX_EXP 128
-#endif
-
 /* Degrees to radians conversion: */
 #define DEG2RAD (M_PI/180.0)
 
 
 /***
- *** USE_IEEE: Determine if we're using IEEE floating point
- ***/
-#if defined(__i386__) || defined(__386__) || defined(__sparc__) || \
-    defined(__s390x__) || defined(__powerpc__) || \
-    defined(__x86_64__) || \
-    defined(ia64) || defined(__ia64__) || \
-    defined(__hppa__) || defined(hpux) || \
-    defined(__mips) || defined(_MIPS_ARCH) || \
-    defined(__arm__) || \
-    defined(__sh__) || defined(__m32r__) || \
-    (defined(__sun) && defined(_IEEE_754)) || \
-    (defined(__alpha__) && (defined(__IEEE_FLOAT) || !defined(VMS)))
-#define USE_IEEE
-#define IEEE_ONE 0x3f800000
-#endif
-
-
-/***
  *** SQRTF: single-precision square root
  ***/
 #if 0 /* _mesa_sqrtf() not accurate enough - temporarily disabled */
@@ -316,16 +256,9 @@ static INLINE int GET_FLOAT_BITS( float x )
 /***
  *** IROUND: return (as an integer) float rounded to nearest integer
  ***/
-#if defined(USE_SPARC_ASM) && defined(__GNUC__) && defined(__sparc__)
-static INLINE int iround(float f)
-{
-   int r;
-   __asm__ ("fstoi %1, %0" : "=f" (r) : "f" (f));
-   return r;
-}
-#define IROUND(x)  iround(x)
-#elif defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) && \
-			(!defined(__BEOS__) || (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)))
+#if defined(USE_X86_ASM) && defined(__GNUC__) && defined(__i386__) && \
+			(!(defined(__BEOS__) || defined(__HAIKU__))  || \
+			(__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)))
 static INLINE int iround(float f)
 {
    int r;
@@ -358,6 +291,7 @@ long iround(float f);
 #define IROUND(f)  ((int) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
 #endif
 
+#define IROUND64(f)  ((GLint64) (((f) >= 0.0F) ? ((f) + 0.5F) : ((f) - 0.5F)))
 
 /***
  *** IROUND_POS: return (as an integer) positive float rounded to nearest int
@@ -508,113 +442,6 @@ _mesa_is_pow_two(int x)
 #endif
 
 
-/***
- *** START_FAST_MATH: Set x86 FPU to faster, 32-bit precision mode (and save
- ***                  original mode to a temporary).
- *** END_FAST_MATH: Restore x86 FPU to original mode.
- ***/
-#if defined(__GNUC__) && defined(__i386__)
-/*
- * Set the x86 FPU control word to guarentee only 32 bits of precision
- * are stored in registers.  Allowing the FPU to store more introduces
- * differences between situations where numbers are pulled out of memory
- * vs. situations where the compiler is able to optimize register usage.
- *
- * In the worst case, we force the compiler to use a memory access to
- * truncate the float, by specifying the 'volatile' keyword.
- */
-/* Hardware default: All exceptions masked, extended double precision,
- * round to nearest (IEEE compliant):
- */
-#define DEFAULT_X86_FPU		0x037f
-/* All exceptions masked, single precision, round to nearest:
- */
-#define FAST_X86_FPU		0x003f
-/* The fldcw instruction will cause any pending FP exceptions to be
- * raised prior to entering the block, and we clear any pending
- * exceptions before exiting the block.  Hence, asm code has free
- * reign over the FPU while in the fast math block.
- */
-#if defined(NO_FAST_MATH)
-#define START_FAST_MATH(x)						\
-do {									\
-   static GLuint mask = DEFAULT_X86_FPU;				\
-   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
-   __asm__ ( "fldcw %0" : : "m" (mask) );				\
-} while (0)
-#else
-#define START_FAST_MATH(x)						\
-do {									\
-   static GLuint mask = FAST_X86_FPU;					\
-   __asm__ ( "fnstcw %0" : "=m" (*&(x)) );				\
-   __asm__ ( "fldcw %0" : : "m" (mask) );				\
-} while (0)
-#endif
-/* Restore original FPU mode, and clear any exceptions that may have
- * occurred in the FAST_MATH block.
- */
-#define END_FAST_MATH(x)						\
-do {									\
-   __asm__ ( "fnclex ; fldcw %0" : : "m" (*&(x)) );			\
-} while (0)
-
-#elif defined(__WATCOMC__) && defined(__386__)
-#define DEFAULT_X86_FPU		0x037f /* See GCC comments above */
-#define FAST_X86_FPU		0x003f /* See GCC comments above */
-void _watcom_start_fast_math(unsigned short *x,unsigned short *mask);
-#pragma aux _watcom_start_fast_math =                                   \
-   "fnstcw  word ptr [eax]"                                             \
-   "fldcw   word ptr [ecx]"                                             \
-   parm [eax] [ecx]                                                     \
-   modify exact [];
-void _watcom_end_fast_math(unsigned short *x);
-#pragma aux _watcom_end_fast_math =                                     \
-   "fnclex"                                                             \
-   "fldcw   word ptr [eax]"                                             \
-   parm [eax]                                                           \
-   modify exact [];
-#if defined(NO_FAST_MATH)
-#define START_FAST_MATH(x)                                              \
-do {                                                                    \
-   static GLushort mask = DEFAULT_X86_FPU;	                            \
-   _watcom_start_fast_math(&x,&mask);                                   \
-} while (0)
-#else
-#define START_FAST_MATH(x)                                              \
-do {                                                                    \
-   static GLushort mask = FAST_X86_FPU;                                 \
-   _watcom_start_fast_math(&x,&mask);                                   \
-} while (0)
-#endif
-#define END_FAST_MATH(x)  _watcom_end_fast_math(&x)
-
-#elif defined(_MSC_VER) && defined(_M_IX86)
-#define DEFAULT_X86_FPU		0x037f /* See GCC comments above */
-#define FAST_X86_FPU		0x003f /* See GCC comments above */
-#if defined(NO_FAST_MATH)
-#define START_FAST_MATH(x) do {\
-	static GLuint mask = DEFAULT_X86_FPU;\
-	__asm fnstcw word ptr [x]\
-	__asm fldcw word ptr [mask]\
-} while(0)
-#else
-#define START_FAST_MATH(x) do {\
-	static GLuint mask = FAST_X86_FPU;\
-	__asm fnstcw word ptr [x]\
-	__asm fldcw word ptr [mask]\
-} while(0)
-#endif
-#define END_FAST_MATH(x) do {\
-	__asm fnclex\
-	__asm fldcw word ptr [x]\
-} while(0)
-
-#else
-#define START_FAST_MATH(x)  x = 0
-#define END_FAST_MATH(x)  (void)(x)
-#endif
-
-
 /**
  * Return 1 if this is a little endian machine, 0 if big endian.
  */
@@ -708,14 +535,10 @@ extern double
 _mesa_pow(double x, double y);
 
 extern int
-_mesa_ffs(int i);
+_mesa_ffs(int32_t i);
 
 extern int
-#ifdef __MINGW32__
-_mesa_ffsll(long i);
-#else
-_mesa_ffsll(long long i);
-#endif
+_mesa_ffsll(int64_t i);
 
 extern unsigned int
 _mesa_bitcount(unsigned int n);
@@ -764,6 +587,9 @@ _mesa_atoi( const char *s );
 extern double
 _mesa_strtod( const char *s, char **end );
 
+extern unsigned int
+_mesa_str_checksum(const char *str);
+
 extern int
 _mesa_sprintf( char *str, const char *fmt, ... );
 
@@ -773,6 +599,9 @@ _mesa_snprintf( char *str, size_t size, const char *fmt, ... );
 extern void
 _mesa_printf( const char *fmtString, ... );
 
+extern void
+_mesa_fprintf( FILE *f, const char *fmtString, ... );
+
 extern int 
 _mesa_vsprintf( char *str, const char *fmt, va_list args );
 
diff --git a/src/mesa/main/light.c b/src/mesa/main/light.c
index ce50224d30..10c89f4368 100644
--- a/src/mesa/main/light.c
+++ b/src/mesa/main/light.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.0
+ * Version:  7.5
  *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -64,6 +65,37 @@ _mesa_ShadeModel( GLenum mode )
 
 
 /**
+ * Set the provoking vertex (the vertex which specifies the prim's
+ * color when flat shading) to either the first or last vertex of the
+ * triangle or line.
+ */
+void GLAPIENTRY
+_mesa_ProvokingVertexEXT(GLenum mode)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (MESA_VERBOSE&VERBOSE_API)
+      _mesa_debug(ctx, "glProvokingVertexEXT 0x%x\n", mode);
+
+   switch (mode) {
+   case GL_FIRST_VERTEX_CONVENTION_EXT:
+   case GL_LAST_VERTEX_CONVENTION_EXT:
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glProvokingVertexEXT(0x%x)", mode);
+      return;
+   }
+
+   if (ctx->Light.ProvokingVertex == mode)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_LIGHT);
+   ctx->Light.ProvokingVertex = mode;
+}
+
+
+/**
  * Helper function called by _mesa_Lightfv and _mesa_PopAttrib to set
  * per-light state.
  * For GL_POSITION and GL_SPOT_DIRECTION the params position/direction
@@ -110,10 +142,10 @@ _mesa_light(GLcontext *ctx, GLuint lnum, GLenum pname, const GLfloat *params)
       break;
    case GL_SPOT_DIRECTION:
       /* NOTE: Direction already transformed by inverse ModelView! */
-      if (TEST_EQ_3V(light->EyeDirection, params))
+      if (TEST_EQ_3V(light->SpotDirection, params))
 	 return;
       FLUSH_VERTICES(ctx, _NEW_LIGHT);
-      COPY_3V(light->EyeDirection, params);
+      COPY_3V(light->SpotDirection, params);
       break;
    case GL_SPOT_EXPONENT:
       ASSERT(params[0] >= 0.0);
@@ -209,7 +241,6 @@ _mesa_Lightfv( GLenum light, GLenum pname, const GLfloat *params )
 	 _math_matrix_analyse(ctx->ModelviewMatrixStack.Top);
       }
       TRANSFORM_DIRECTION(temp, params, ctx->ModelviewMatrixStack.Top->m);
-      NORMALIZE_3FV(temp);
       params = temp;
       break;
    case GL_SPOT_EXPONENT:
@@ -326,7 +357,7 @@ _mesa_GetLightfv( GLenum light, GLenum pname, GLfloat *params )
          COPY_4V( params, ctx->Light.Light[l].EyePosition );
          break;
       case GL_SPOT_DIRECTION:
-         COPY_3V( params, ctx->Light.Light[l].EyeDirection );
+         COPY_3V( params, ctx->Light.Light[l].SpotDirection );
          break;
       case GL_SPOT_EXPONENT:
          params[0] = ctx->Light.Light[l].SpotExponent;
@@ -388,9 +419,9 @@ _mesa_GetLightiv( GLenum light, GLenum pname, GLint *params )
          params[3] = (GLint) ctx->Light.Light[l].EyePosition[3];
          break;
       case GL_SPOT_DIRECTION:
-         params[0] = (GLint) ctx->Light.Light[l].EyeDirection[0];
-         params[1] = (GLint) ctx->Light.Light[l].EyeDirection[1];
-         params[2] = (GLint) ctx->Light.Light[l].EyeDirection[2];
+         params[0] = (GLint) ctx->Light.Light[l].SpotDirection[0];
+         params[1] = (GLint) ctx->Light.Light[l].SpotDirection[1];
+         params[2] = (GLint) ctx->Light.Light[l].SpotDirection[2];
          break;
       case GL_SPOT_EXPONENT:
          params[0] = (GLint) ctx->Light.Light[l].SpotExponent;
@@ -497,7 +528,7 @@ _mesa_LightModeliv( GLenum pname, const GLint *params )
          break;
       default:
          /* Error will be caught later in gl_LightModelfv */
-         ;
+         ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);
    }
    _mesa_LightModelfv( pname, fparam );
 }
@@ -1137,20 +1168,26 @@ compute_light_positions( GLcontext *ctx )
       }
 
       if (light->_Flags & LIGHT_SPOT) {
+         /* Note: we normalize the spot direction now */
+
 	 if (ctx->_NeedEyeCoords) {
-	    COPY_3V( light->_NormDirection, light->EyeDirection );
+	    COPY_3V( light->_NormSpotDirection, light->SpotDirection );
+            NORMALIZE_3FV( light->_NormSpotDirection );
 	 }
          else {
-	    TRANSFORM_NORMAL( light->_NormDirection,
-			      light->EyeDirection,
+            GLfloat spotDir[3];
+            COPY_3V(spotDir, light->SpotDirection);
+            NORMALIZE_3FV(spotDir);
+	    TRANSFORM_NORMAL( light->_NormSpotDirection,
+			      spotDir,
 			      ctx->ModelviewMatrixStack.Top->m);
 	 }
 
-	 NORMALIZE_3FV( light->_NormDirection );
+	 NORMALIZE_3FV( light->_NormSpotDirection );
 
 	 if (!(light->_Flags & LIGHT_POSITIONAL)) {
 	    GLfloat PV_dot_dir = - DOT3(light->_VP_inf_norm,
-					light->_NormDirection);
+					light->_NormSpotDirection);
 
 	    if (PV_dot_dir > light->_CosCutoff) {
 	       double x = PV_dot_dir * (EXP_TABLE_SIZE-1);
@@ -1219,15 +1256,15 @@ _mesa_update_tnl_spaces( GLcontext *ctx, GLuint new_state )
 	 ctx->Driver.LightingSpaceChange( ctx );
    }
    else {
-      GLuint new_state = ctx->NewState;
+      GLuint new_state2 = ctx->NewState;
 
       /* Recalculate that same state only if it has been invalidated
        * by other statechanges.
        */
-      if (new_state & _NEW_MODELVIEW)
+      if (new_state2 & _NEW_MODELVIEW)
 	 update_modelview_scale(ctx);
 
-      if (new_state & (_NEW_LIGHT|_NEW_MODELVIEW))
+      if (new_state2 & (_NEW_LIGHT|_NEW_MODELVIEW))
 	 compute_light_positions( ctx );
    }
 }
@@ -1274,7 +1311,7 @@ init_light( struct gl_light *l, GLuint n )
       ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
    }
    ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
-   ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
+   ASSIGN_3V( l->SpotDirection, 0.0, 0.0, -1.0 );
    l->SpotExponent = 0.0;
    _mesa_invalidate_spot_exp_table( l );
    l->SpotCutoff = 180.0;
@@ -1343,6 +1380,7 @@ _mesa_init_lighting( GLcontext *ctx )
    init_lightmodel( &ctx->Light.Model );
    init_material( &ctx->Light.Material );
    ctx->Light.ShadeModel = GL_SMOOTH;
+   ctx->Light.ProvokingVertex = GL_LAST_VERTEX_CONVENTION_EXT;
    ctx->Light.Enabled = GL_FALSE;
    ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
    ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
@@ -1368,6 +1406,7 @@ _mesa_init_lighting( GLcontext *ctx )
    /* Miscellaneous */
    ctx->Light._NeedEyeCoords = GL_FALSE;
    ctx->_NeedEyeCoords = GL_FALSE;
+   ctx->_ForceEyeCoords = GL_FALSE;
    ctx->_ModelViewInvScale = 1.0;
 }
 
diff --git a/src/mesa/main/light.h b/src/mesa/main/light.h
index b97e17b5be..9c1a5eefad 100644
--- a/src/mesa/main/light.h
+++ b/src/mesa/main/light.h
@@ -1,13 +1,9 @@
-/**
- * \file light.h
- * Lighting.
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  7.5
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -37,6 +33,10 @@
 extern void GLAPIENTRY
 _mesa_ShadeModel( GLenum mode );
 
+extern void GLAPIENTRY
+_mesa_ProvokingVertexEXT(GLenum mode);
+
+
 #if _HAVE_FULL_GL
 extern void GLAPIENTRY
 _mesa_ColorMaterial( GLenum face, GLenum mode );
diff --git a/src/mesa/main/macros.h b/src/mesa/main/macros.h
index 2630855a0e..3d9a1aba98 100644
--- a/src/mesa/main/macros.h
+++ b/src/mesa/main/macros.h
@@ -54,33 +54,61 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256];
 #define FLOAT_TO_BYTE(X)    ( (((GLint) (255.0F * (X))) - 1) / 2 )
 
 
-/** Convert GLushort in [0,65536] to GLfloat in [0.0,1.0] */
+/** Convert GLbyte in [-128,127] to GLfloat in [-1.0,1.0], texture/fb data */
+#define BYTE_TO_FLOAT_TEX(B)    ((B) == -128 ? -1.0F : (B) * (1.0F/127.0F))
+
+/** Convert GLfloat in [-1.0,1.0] to GLbyte in [-128,127], texture/fb data */
+#define FLOAT_TO_BYTE_TEX(X)    ( (GLint) (127.0F * (X)) )
+
+
+/** Convert GLushort in [0,65535] to GLfloat in [0.0,1.0] */
 #define USHORT_TO_FLOAT(S)  ((GLfloat) (S) * (1.0F / 65535.0F))
 
+/** Convert GLfloat in [0.0,1.0] to GLushort in [0, 65535] */
+#define FLOAT_TO_USHORT(X)   ((GLuint) ((X) * 65535.0F))
+
+
 /** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0] */
 #define SHORT_TO_FLOAT(S)   ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))
 
-/** Convert GLfloat in [0.0,1.0] to GLshort in [-32768,32767] */
+/** Convert GLfloat in [-1.0,1.0] to GLshort in [-32768,32767] */
 #define FLOAT_TO_SHORT(X)   ( (((GLint) (65535.0F * (X))) - 1) / 2 )
 
 
+/** Convert GLshort in [-32768,32767] to GLfloat in [-1.0,1.0], texture/fb data */
+#define SHORT_TO_FLOAT_TEX(S)    ((S) == -32768 ? -1.0F : (S) * (1.0F/32767.0F))
+
+/** Convert GLfloat in [-1.0,1.0] to GLshort in [-32768,32767], texture/fb data */
+#define FLOAT_TO_SHORT_TEX(X)    ( (GLint) (32767.0F * (X)) )
+
+
 /** Convert GLuint in [0,4294967295] to GLfloat in [0.0,1.0] */
-#define UINT_TO_FLOAT(U)    ((GLfloat) (U) * (1.0F / 4294967295.0F))
+#define UINT_TO_FLOAT(U)    ((GLfloat) (U) * (1.0F / 4294967295.0))
 
 /** Convert GLfloat in [0.0,1.0] to GLuint in [0,4294967295] */
 #define FLOAT_TO_UINT(X)    ((GLuint) ((X) * 4294967295.0))
 
 
 /** Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0] */
-#define INT_TO_FLOAT(I)     ((2.0F * (I) + 1.0F) * (1.0F/4294967294.0F))
+#define INT_TO_FLOAT(I)     ((2.0F * (I) + 1.0F) * (1.0F/4294967294.0))
 
 /** Convert GLfloat in [-1.0,1.0] to GLint in [-2147483648,2147483647] */
 /* causes overflow:
-#define FLOAT_TO_INT(X)     ( (((GLint) (4294967294.0F * (X))) - 1) / 2 )
+#define FLOAT_TO_INT(X)     ( (((GLint) (4294967294.0 * (X))) - 1) / 2 )
 */
 /* a close approximation: */
 #define FLOAT_TO_INT(X)     ( (GLint) (2147483647.0 * (X)) )
 
+/** Convert GLfloat in [-1.0,1.0] to GLint64 in [-(1<<63),(1 << 63) -1] */
+#define FLOAT_TO_INT64(X)     ( (GLint64) (9223372036854775807.0 * (double)(X)) )
+
+
+/** Convert GLint in [-2147483648,2147483647] to GLfloat in [-1.0,1.0], texture/fb data */
+#define INT_TO_FLOAT_TEX(I)    ((I) == -2147483648 ? -1.0F : (I) * (1.0F/2147483647.0))
+
+/** Convert GLfloat in [-1.0,1.0] to GLint in [-2147483648,2147483647], texture/fb data */
+#define FLOAT_TO_INT_TEX(X)    ( (GLint) (2147483647.0 * (X)) )
+
 
 #define BYTE_TO_UBYTE(b)   ((GLubyte) ((b) < 0 ? 0 : (GLubyte) (b)))
 #define SHORT_TO_UBYTE(s)  ((GLubyte) ((s) < 0 ? 0 : (GLubyte) ((s) >> 7)))
@@ -95,7 +123,7 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256];
 #define INT_TO_USHORT(i)   ((i) < 0 ? 0 : ((GLushort) ((i) >> 15)))
 #define UINT_TO_USHORT(i)  ((i) < 0 ? 0 : ((GLushort) ((i) >> 16)))
 #define UNCLAMPED_FLOAT_TO_USHORT(us, f)  \
-        us = ( (GLushort) IROUND( CLAMP((f), 0.0, 1.0) * 65535.0F) )
+        us = ( (GLushort) IROUND( CLAMP((f), 0.0F, 1.0F) * 65535.0F) )
 #define CLAMPED_FLOAT_TO_USHORT(us, f)  \
         us = ( (GLushort) IROUND( (f) * 65535.0F) )
 
diff --git a/src/mesa/main/matrix.c b/src/mesa/main/matrix.c
index 0f96f94909..ebc3cbd59c 100644
--- a/src/mesa/main/matrix.c
+++ b/src/mesa/main/matrix.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  6.5.3
+ * Version:  7.5
  *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -42,7 +43,6 @@
 #include "matrix.h"
 #include "mtypes.h"
 #include "math/m_matrix.h"
-#include "math/m_xform.h"
 
 
 /**
@@ -160,10 +160,21 @@ _mesa_MatrixMode( GLenum mode )
       ctx->CurrentStack = &ctx->ProjectionMatrixStack;
       break;
    case GL_TEXTURE:
+      /* This error check is disabled because if we're called from
+       * glPopAttrib() when the active texture unit is >= MaxTextureCoordUnits
+       * we'll generate an unexpected error.
+       * From the GL_ARB_vertex_shader spec it sounds like we should instead
+       * do error checking in other places when we actually try to access
+       * texture matrices beyond MaxTextureCoordUnits.
+       */
+#if 0
       if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glMatrixMode(texcoord unit)");
+         _mesa_error(ctx, GL_INVALID_OPERATION, "glMatrixMode(invalid tex unit %d)",
+                     ctx->Texture.CurrentUnit);
          return;
       }
+#endif
+      ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->TextureMatrixStack));
       ctx->CurrentStack = &ctx->TextureMatrixStack[ctx->Texture.CurrentUnit];
       break;
    case GL_COLOR:
@@ -536,120 +547,6 @@ _mesa_MultTransposeMatrixdARB( const GLdouble *m )
 }
 #endif
 
-/**
- * Set the viewport.
- * 
- * \param x, y coordinates of the lower-left corner of the viewport rectangle.
- * \param width width of the viewport rectangle.
- * \param height height of the viewport rectangle.
- *
- * \sa Called via glViewport() or display list execution.
- *
- * Flushes the vertices and calls _mesa_set_viewport() with the given
- * parameters.
- */
-void GLAPIENTRY
-_mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_set_viewport(ctx, x, y, width, height);
-}
-
-
-/**
- * Set new viewport parameters and update derived state (the _WindowMap
- * matrix).  Usually called from _mesa_Viewport().
- * 
- * \param ctx GL context.
- * \param x, y coordinates of the lower left corner of the viewport rectangle.
- * \param width width of the viewport rectangle.
- * \param height height of the viewport rectangle.
- */
-void
-_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y,
-                    GLsizei width, GLsizei height )
-{
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glViewport %d %d %d %d\n", x, y, width, height);
-
-   if (width < 0 || height < 0) {
-      _mesa_error( ctx,  GL_INVALID_VALUE,
-                   "glViewport(%d, %d, %d, %d)", x, y, width, height );
-      return;
-   }
-
-   /* clamp width and height to the implementation dependent range */
-   width  = CLAMP(width,  1, (GLsizei) ctx->Const.MaxViewportWidth);
-   height = CLAMP(height, 1, (GLsizei) ctx->Const.MaxViewportHeight);
-
-   ctx->Viewport.X = x;
-   ctx->Viewport.Width = width;
-   ctx->Viewport.Y = y;
-   ctx->Viewport.Height = height;
-   ctx->NewState |= _NEW_VIEWPORT;
-
-#if 1
-   /* XXX remove this someday.  Currently the DRI drivers rely on
-    * the WindowMap matrix being up to date in the driver's Viewport
-    * and DepthRange functions.
-    */
-   _math_matrix_viewport(&ctx->Viewport._WindowMap,
-                         ctx->Viewport.X, ctx->Viewport.Y,
-                         ctx->Viewport.Width, ctx->Viewport.Height,
-                         ctx->Viewport.Near, ctx->Viewport.Far,
-                         ctx->DrawBuffer->_DepthMaxF);
-#endif
-
-   if (ctx->Driver.Viewport) {
-      /* Many drivers will use this call to check for window size changes
-       * and reallocate the z/stencil/accum/etc buffers if needed.
-       */
-      (*ctx->Driver.Viewport)( ctx, x, y, width, height );
-   }
-}
-
-
-#if _HAVE_FULL_GL
-/**
- * Called by glDepthRange
- *
- * \param nearval  specifies the Z buffer value which should correspond to
- *                 the near clip plane
- * \param farval  specifies the Z buffer value which should correspond to
- *                the far clip plane
- */
-void GLAPIENTRY
-_mesa_DepthRange( GLclampd nearval, GLclampd farval )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   if (MESA_VERBOSE&VERBOSE_API)
-      _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval);
-
-   ctx->Viewport.Near = (GLfloat) CLAMP( nearval, 0.0, 1.0 );
-   ctx->Viewport.Far = (GLfloat) CLAMP( farval, 0.0, 1.0 );
-   ctx->NewState |= _NEW_VIEWPORT;
-
-#if 1
-   /* XXX remove this someday.  Currently the DRI drivers rely on
-    * the WindowMap matrix being up to date in the driver's Viewport
-    * and DepthRange functions.
-    */
-   _math_matrix_viewport(&ctx->Viewport._WindowMap,
-                         ctx->Viewport.X, ctx->Viewport.Y,
-                         ctx->Viewport.Width, ctx->Viewport.Height,
-                         ctx->Viewport.Near, ctx->Viewport.Far,
-                         ctx->DrawBuffer->_DepthMaxF);
-#endif
-
-   if (ctx->Driver.DepthRange) {
-      (*ctx->Driver.DepthRange)( ctx, nearval, farval );
-   }
-}
-#endif
-
 
 
 /**********************************************************************/
@@ -893,41 +790,4 @@ void _mesa_init_transform( GLcontext *ctx )
 }
 
 
-/** 
- * Initialize the context viewport attribute group.
- *
- * \param ctx GL context.
- * 
- * \todo Move this to a new file with other 'viewport' routines.
- */
-void _mesa_init_viewport( GLcontext *ctx )
-{
-   GLfloat depthMax = 65535.0F; /* sorf of arbitrary */
-
-   /* Viewport group */
-   ctx->Viewport.X = 0;
-   ctx->Viewport.Y = 0;
-   ctx->Viewport.Width = 0;
-   ctx->Viewport.Height = 0;
-   ctx->Viewport.Near = 0.0;
-   ctx->Viewport.Far = 1.0;
-   _math_matrix_ctr(&ctx->Viewport._WindowMap);
-
-   _math_matrix_viewport(&ctx->Viewport._WindowMap, 0, 0, 0, 0,
-                         0.0F, 1.0F, depthMax);
-}
-
-
-/** 
- * Free the context viewport attribute group data.
- *
- * \param ctx GL context.
- * 
- * \todo Move this to a new file with other 'viewport' routines.
- */
-void _mesa_free_viewport_data( GLcontext *ctx )
-{
-   _math_matrix_dtr(&ctx->Viewport._WindowMap);
-}
-
 /*@}*/
diff --git a/src/mesa/main/matrix.h b/src/mesa/main/matrix.h
index 38769867a7..a53d1045c7 100644
--- a/src/mesa/main/matrix.h
+++ b/src/mesa/main/matrix.h
@@ -1,13 +1,9 @@
-/**
- * \file matrix.h
- * Matrix operations.
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
+ * Version:  7.5
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.   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"),
@@ -99,15 +95,6 @@ _mesa_MultTransposeMatrixfARB( const GLfloat *m );
 extern void GLAPIENTRY
 _mesa_MultTransposeMatrixdARB( const GLdouble *m );
 
-extern void GLAPIENTRY
-_mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height );
-
-extern void 
-_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height );
-
-extern void GLAPIENTRY
-_mesa_DepthRange( GLclampd nearval, GLclampd farval );
-
 
 extern void 
 _mesa_init_matrix( GLcontext * ctx );
@@ -115,16 +102,10 @@ _mesa_init_matrix( GLcontext * ctx );
 extern void 
 _mesa_init_transform( GLcontext *ctx );
 
-extern void 
-_mesa_init_viewport( GLcontext *ctx );
-
 extern void
 _mesa_free_matrix_data( GLcontext *ctx );
 
 extern void 
-_mesa_free_viewport_data( GLcontext *ctx );
-
-extern void 
 _mesa_update_modelview_project( GLcontext *ctx, GLuint newstate );
 
 
diff --git a/src/mesa/main/mfeatures.h b/src/mesa/main/mfeatures.h
index 3819da3d68..02083ecc3b 100644
--- a/src/mesa/main/mfeatures.h
+++ b/src/mesa/main/mfeatures.h
@@ -31,35 +31,73 @@
 #ifndef FEATURES_H
 #define FEATURES_H
 
+#include "compiler.h"
 
 #ifndef _HAVE_FULL_GL
 #define _HAVE_FULL_GL 1
 #endif
 
+/* assert that a feature is disabled and should never be used */
+#define ASSERT_NO_FEATURE() ASSERT(0)
+
+/**
+ * A feature can be anything.  But most of them share certain characteristics.
+ *
+ * When a feature defines driver entries, they can be initialized by
+ *   _MESA_INIT_<FEATURE>_FUNCTIONS
+ *
+ * When a feature defines vtxfmt entries, they can be initialized and
+ * installed by
+ *   _MESA_INIT_<FEATURE>_VTXFMT
+ *   _mesa_install_<feature>_vtxfmt
+ *
+ * When a feature defines dispatch entries, they are initialized by
+ *   _mesa_init_<feature>_dispatch
+ *
+ * When a feature has states, they are initialized and freed by
+ *   _mesa_init_<feature>
+ *   _mesa_free_<feature>_data
+ *
+ * Except for states, the others compile to no-op when a feature is disabled.
+ *
+ * The GLAPIENTRYs and helper functions defined by a feature should also
+ * compile to no-op when it is disabled.  But to save typings and to catch
+ * bugs, some of them may be unavailable, or compile to ASSERT_NO_FEATURE()
+ * when the feature is disabled.
+ *
+ * A feature following the convensions may be used without knowing if it is
+ * enabled or not.
+ */
+
 #define FEATURE_accum  _HAVE_FULL_GL
+#define FEATURE_arrayelt  _HAVE_FULL_GL
 #define FEATURE_attrib_stack  _HAVE_FULL_GL
 #define FEATURE_colortable  _HAVE_FULL_GL
 #define FEATURE_convolve  _HAVE_FULL_GL
 #define FEATURE_dispatch  _HAVE_FULL_GL
-#define FEATURE_dlist  _HAVE_FULL_GL
+#define FEATURE_dlist  (_HAVE_FULL_GL && FEATURE_arrayelt && FEATURE_beginend)
 #define FEATURE_draw_read_buffer  _HAVE_FULL_GL
 #define FEATURE_drawpix  _HAVE_FULL_GL
-#define FEATURE_evaluators  _HAVE_FULL_GL
+#define FEATURE_eval  _HAVE_FULL_GL
 #define FEATURE_feedback  _HAVE_FULL_GL
 #define FEATURE_fixedpt 0
 #define FEATURE_histogram  _HAVE_FULL_GL
 #define FEATURE_pixel_transfer  _HAVE_FULL_GL
 #define FEATURE_point_size_array 0
+#define FEATURE_queryobj  _HAVE_FULL_GL
+#define FEATURE_rastpos  _HAVE_FULL_GL
 #define FEATURE_texgen  _HAVE_FULL_GL
 #define FEATURE_texture_fxt1  _HAVE_FULL_GL
 #define FEATURE_texture_s3tc  _HAVE_FULL_GL
 #define FEATURE_userclip  _HAVE_FULL_GL
+#define FEATURE_beginend  _HAVE_FULL_GL
 #define FEATURE_vertex_array_byte 0
-#define FEATURE_windowpos  _HAVE_FULL_GL
 #define FEATURE_es2_glsl 0
 
-#define FEATURE_ARB_occlusion_query  _HAVE_FULL_GL
 #define FEATURE_ARB_fragment_program  _HAVE_FULL_GL
+#define FEATURE_ARB_framebuffer_object  _HAVE_FULL_GL
+#define FEATURE_ARB_map_buffer_range  _HAVE_FULL_GL
+#define FEATURE_ARB_pixel_buffer_object  _HAVE_FULL_GL
 #define FEATURE_ARB_vertex_buffer_object  _HAVE_FULL_GL
 #define FEATURE_ARB_vertex_program  _HAVE_FULL_GL
 #define FEATURE_ARB_vertex_shader _HAVE_FULL_GL
@@ -67,14 +105,13 @@
 #define FEATURE_ARB_shader_objects (FEATURE_ARB_vertex_shader || FEATURE_ARB_fragment_shader)
 #define FEATURE_ARB_shading_language_100 FEATURE_ARB_shader_objects
 #define FEATURE_ARB_shading_language_120 FEATURE_ARB_shader_objects
+#define FEATURE_ARB_sync _HAVE_FULL_GL
 
 #define FEATURE_EXT_framebuffer_blit _HAVE_FULL_GL
 #define FEATURE_EXT_framebuffer_object _HAVE_FULL_GL
 #define FEATURE_EXT_pixel_buffer_object  _HAVE_FULL_GL
 #define FEATURE_EXT_texture_sRGB _HAVE_FULL_GL
-#define FEATURE_EXT_timer_query  _HAVE_FULL_GL
 #define FEATURE_ATI_fragment_shader _HAVE_FULL_GL
-#define FEATURE_MESA_program_debug  _HAVE_FULL_GL
 #define FEATURE_NV_fence  _HAVE_FULL_GL
 #define FEATURE_NV_fragment_program  _HAVE_FULL_GL
 #define FEATURE_NV_vertex_program  _HAVE_FULL_GL
diff --git a/src/mesa/main/mipmap.c b/src/mesa/main/mipmap.c
index 3dd4b3391b..3dca09d9f2 100644
--- a/src/mesa/main/mipmap.c
+++ b/src/mesa/main/mipmap.c
@@ -85,7 +85,22 @@ bytes_per_pixel(GLenum datatype, GLuint comps)
                                 rowC[j][e], rowC[k][e], \
                                 rowD[j][e], rowD[k][e]); \
    } while(0)
-   
+
+#define FILTER_SUM_3D_SIGNED(Aj, Ak, Bj, Bk, Cj, Ck, Dj, Dk) \
+   (Aj + Ak \
+    + Bj + Bk \
+    + Cj + Ck \
+    + Dj + Dk \
+    + 4) / 8
+
+#define FILTER_3D_SIGNED(e) \
+   do { \
+      dst[i][e] = FILTER_SUM_3D_SIGNED(rowA[j][e], rowA[k][e], \
+                                       rowB[j][e], rowB[k][e], \
+                                       rowC[j][e], rowC[k][e], \
+                                       rowD[j][e], rowD[k][e]); \
+   } while(0)
+
 #define FILTER_F_3D(e) \
    do { \
       dst[i][e] = (rowA[j][e] + rowA[k][e] \
@@ -180,6 +195,53 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth,
       }
    }
 
+   else if (datatype == GL_BYTE && comps == 4) {
+      GLuint i, j, k;
+      const GLbyte(*rowA)[4] = (const GLbyte(*)[4]) srcRowA;
+      const GLbyte(*rowB)[4] = (const GLbyte(*)[4]) srcRowB;
+      GLbyte(*dst)[4] = (GLbyte(*)[4]) dstRow;
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
+         dst[i][3] = (rowA[j][3] + rowA[k][3] + rowB[j][3] + rowB[k][3]) / 4;
+      }
+   }
+   else if (datatype == GL_BYTE && comps == 3) {
+      GLuint i, j, k;
+      const GLbyte(*rowA)[3] = (const GLbyte(*)[3]) srcRowA;
+      const GLbyte(*rowB)[3] = (const GLbyte(*)[3]) srcRowB;
+      GLbyte(*dst)[3] = (GLbyte(*)[3]) dstRow;
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
+         dst[i][2] = (rowA[j][2] + rowA[k][2] + rowB[j][2] + rowB[k][2]) / 4;
+      }
+   }
+   else if (datatype == GL_BYTE && comps == 2) {
+      GLuint i, j, k;
+      const GLbyte(*rowA)[2] = (const GLbyte(*)[2]) srcRowA;
+      const GLbyte(*rowB)[2] = (const GLbyte(*)[2]) srcRowB;
+      GLbyte(*dst)[2] = (GLbyte(*)[2]) dstRow;
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         dst[i][0] = (rowA[j][0] + rowA[k][0] + rowB[j][0] + rowB[k][0]) / 4;
+         dst[i][1] = (rowA[j][1] + rowA[k][1] + rowB[j][1] + rowB[k][1]) / 4;
+      }
+   }
+   else if (datatype == GL_BYTE && comps == 1) {
+      GLuint i, j, k;
+      const GLbyte *rowA = (const GLbyte *) srcRowA;
+      const GLbyte *rowB = (const GLbyte *) srcRowB;
+      GLbyte *dst = (GLbyte *) dstRow;
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
+      }
+   }
+
    else if (datatype == GL_UNSIGNED_SHORT && comps == 4) {
       GLuint i, j, k;
       const GLushort(*rowA)[4] = (const GLushort(*)[4]) srcRowA;
@@ -226,7 +288,6 @@ do_row(GLenum datatype, GLuint comps, GLint srcWidth,
          dst[i] = (rowA[j] + rowA[k] + rowB[j] + rowB[k]) / 4;
       }
    }
-
    else if (datatype == GL_FLOAT && comps == 4) {
       GLuint i, j, k;
       const GLfloat(*rowA)[4] = (const GLfloat(*)[4]) srcRowA;
@@ -545,6 +606,44 @@ do_row_3D(GLenum datatype, GLuint comps, GLint srcWidth,
          FILTER_3D(0);
       }
    }
+   if ((datatype == GL_BYTE) && (comps == 4)) {
+      DECLARE_ROW_POINTERS(GLbyte, 4);
+
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         FILTER_3D_SIGNED(0);
+         FILTER_3D_SIGNED(1);
+         FILTER_3D_SIGNED(2);
+         FILTER_3D_SIGNED(3);
+      }
+   }
+   else if ((datatype == GL_BYTE) && (comps == 3)) {
+      DECLARE_ROW_POINTERS(GLbyte, 3);
+
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         FILTER_3D_SIGNED(0);
+         FILTER_3D_SIGNED(1);
+         FILTER_3D_SIGNED(2);
+      }
+   }
+   else if ((datatype == GL_BYTE) && (comps == 2)) {
+      DECLARE_ROW_POINTERS(GLbyte, 2);
+
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         FILTER_3D_SIGNED(0);
+         FILTER_3D_SIGNED(1);
+       }
+   }
+   else if ((datatype == GL_BYTE) && (comps == 1)) {
+      DECLARE_ROW_POINTERS(GLbyte, 1);
+
+      for (i = j = 0, k = k0; i < (GLuint) dstWidth;
+           i++, j += colStride, k += colStride) {
+         FILTER_3D_SIGNED(0);
+      }
+   }
    else if ((datatype == GL_UNSIGNED_SHORT) && (comps == 4)) {
       DECLARE_ROW_POINTERS(GLushort, 4);
 
@@ -1176,7 +1275,7 @@ make_1d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
 
 
 /**
- * \bugs
+ * \bug
  * There is quite a bit of refactoring that could be done with this function
  * and \c make_2d_mipmap.
  */
@@ -1271,6 +1370,9 @@ make_2d_stack_mipmap(GLenum datatype, GLuint comps, GLint border,
 
 /**
  * Down-sample a texture image to produce the next lower mipmap level.
+ * \param comps  components per texel (1, 2, 3 or 4)
+ * \param srcRowStride  stride between source rows, in texels
+ * \param dstRowStride  stride between destination rows, in texels
  */
 void
 _mesa_generate_mipmap_level(GLenum target,
@@ -1379,9 +1481,12 @@ next_mipmap_level_size(GLenum target, GLint border,
 
 
 /**
- * For GL_SGIX_generate_mipmap:
- * Generate a complete set of mipmaps from texObj's base-level image.
+ * Automatic mipmap generation.
+ * This is the fallback/default function for ctx->Driver.GenerateMipmap().
+ * Generate a complete set of mipmaps from texObj's BaseLevel image.
  * Stop at texObj's MaxLevel or when we get to the 1x1 texture.
+ * For cube maps, target will be one of
+ * GL_TEXTURE_CUBE_MAP_POSITIVE/NEGATIVE_X/Y/Z; never GL_TEXTURE_CUBE_MAP.
  */
 void
 _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
@@ -1496,9 +1601,6 @@ _mesa_generate_mipmap(GLcontext *ctx, GLenum target,
          return;
       }
 
-      if (dstImage->ImageOffsets)
-         _mesa_free(dstImage->ImageOffsets);
-
       /* Free old image data */
       if (dstImage->Data)
          ctx->Driver.FreeTexImageData(ctx, dstImage);
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 2014745a7a..6ce9ae1d6a 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1,9 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.5
  *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- * Copyright (C) 1999-2008  VMware, Inc.  All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -30,22 +30,17 @@
  * Please try to mark derived values with a leading underscore ('_').
  */
 
-#ifndef TYPES_H
-#define TYPES_H
+#ifndef MTYPES_H
+#define MTYPES_H
 
 
-#include "glheader.h"
-#include <GL/internal/glcore.h>	/* __GLcontextModes (GLvisual) */
-#include "config.h"		/* Hardwired parameters */
+#include "main/glheader.h"
+#include "main/config.h"
+#include "main/compiler.h"
+#include "main/mfeatures.h"
 #include "glapi/glapi.h"
 #include "math/m_matrix.h"	/* GLmatrix */
-#include "bitset.h"
-
-
-/**
- * Special, internal token
- */
-#define GL_SHADER_PROGRAM_MESA 0x9999
+#include "main/simple_list.h"	/* struct simple_node */
 
 
 /**
@@ -84,47 +79,18 @@
 
 
 /**
- * Fixed point data type.
- */
-typedef int GLfixed;
-/*
- * Fixed point arithmetic macros
- */
-#ifndef FIXED_FRAC_BITS
-#define FIXED_FRAC_BITS 11
-#endif
-
-#define FIXED_SHIFT     FIXED_FRAC_BITS
-#define FIXED_ONE       (1 << FIXED_SHIFT)
-#define FIXED_HALF      (1 << (FIXED_SHIFT-1))
-#define FIXED_FRAC_MASK (FIXED_ONE - 1)
-#define FIXED_INT_MASK  (~FIXED_FRAC_MASK)
-#define FIXED_EPSILON   1
-#define FIXED_SCALE     ((float) FIXED_ONE)
-#define FIXED_DBL_SCALE ((double) FIXED_ONE)
-#define FloatToFixed(X) (IROUND((X) * FIXED_SCALE))
-#define FixedToDouble(X) ((X) * (1.0 / FIXED_DBL_SCALE))
-#define IntToFixed(I)   ((I) << FIXED_SHIFT)
-#define FixedToInt(X)   ((X) >> FIXED_SHIFT)
-#define FixedToUns(X)   (((unsigned int)(X)) >> FIXED_SHIFT)
-#define FixedCeil(X)    (((X) + FIXED_ONE - FIXED_EPSILON) & FIXED_INT_MASK)
-#define FixedFloor(X)   ((X) & FIXED_INT_MASK)
-#define FixedToFloat(X) ((X) * (1.0F / FIXED_SCALE))
-#define PosFloatToFixed(X)      FloatToFixed(X)
-#define SignedFloatToFixed(X)   FloatToFixed(X)
-
-
-
-/**
  * \name Some forward type declarations
  */
 /*@{*/
 struct _mesa_HashTable;
+struct gl_attrib_node;
+struct gl_meta_state;
 struct gl_pixelstore_attrib;
 struct gl_program_cache;
 struct gl_texture_format;
 struct gl_texture_image;
 struct gl_texture_object;
+struct st_context;
 typedef struct __GLcontextRec GLcontext;
 typedef struct __GLcontextModesRec GLvisual;
 typedef struct gl_framebuffer GLframebuffer;
@@ -139,7 +105,7 @@ typedef struct gl_framebuffer GLframebuffer;
  * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the
  * generic attributes are distinct/separate).
  */
-enum
+typedef enum
 {
    VERT_ATTRIB_POS = 0,
    VERT_ATTRIB_WEIGHT = 1,
@@ -175,7 +141,7 @@ enum
    VERT_ATTRIB_GENERIC14 = 30,
    VERT_ATTRIB_GENERIC15 = 31,
    VERT_ATTRIB_MAX = 32
-};
+} gl_vert_attrib;
 
 /**
  * Bitflags for vertex attributes.
@@ -223,32 +189,33 @@ enum
 /**
  * Indexes for vertex program result attributes
  */
-/*@{*/
-#define VERT_RESULT_HPOS 0
-#define VERT_RESULT_COL0 1
-#define VERT_RESULT_COL1 2
-#define VERT_RESULT_FOGC 3
-#define VERT_RESULT_TEX0 4
-#define VERT_RESULT_TEX1 5
-#define VERT_RESULT_TEX2 6
-#define VERT_RESULT_TEX3 7
-#define VERT_RESULT_TEX4 8
-#define VERT_RESULT_TEX5 9
-#define VERT_RESULT_TEX6 10
-#define VERT_RESULT_TEX7 11
-#define VERT_RESULT_PSIZ 12
-#define VERT_RESULT_BFC0 13
-#define VERT_RESULT_BFC1 14
-#define VERT_RESULT_EDGE 15
-#define VERT_RESULT_VAR0 16  /**< shader varying */
-#define VERT_RESULT_MAX  (VERT_RESULT_VAR0 + MAX_VARYING)
-/*@}*/
+typedef enum
+{
+   VERT_RESULT_HPOS = 0,
+   VERT_RESULT_COL0 = 1,
+   VERT_RESULT_COL1 = 2,
+   VERT_RESULT_FOGC = 3,
+   VERT_RESULT_TEX0 = 4,
+   VERT_RESULT_TEX1 = 5,
+   VERT_RESULT_TEX2 = 6,
+   VERT_RESULT_TEX3 = 7,
+   VERT_RESULT_TEX4 = 8,
+   VERT_RESULT_TEX5 = 9,
+   VERT_RESULT_TEX6 = 10,
+   VERT_RESULT_TEX7 = 11,
+   VERT_RESULT_PSIZ = 12,
+   VERT_RESULT_BFC0 = 13,
+   VERT_RESULT_BFC1 = 14,
+   VERT_RESULT_EDGE = 15,
+   VERT_RESULT_VAR0 = 16  /**< shader varying */,
+   VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)
+} gl_vert_result;
 
 
 /**
  * Indexes for fragment program input attributes.
  */
-enum
+typedef enum
 {
    FRAG_ATTRIB_WPOS = 0,
    FRAG_ATTRIB_COL0 = 1,
@@ -262,9 +229,11 @@ enum
    FRAG_ATTRIB_TEX5 = 9,
    FRAG_ATTRIB_TEX6 = 10,
    FRAG_ATTRIB_TEX7 = 11,
-   FRAG_ATTRIB_VAR0 = 12,  /**< shader varying */
+   FRAG_ATTRIB_FACE = 12,  /**< front/back face */
+   FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */
+   FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */
    FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)
-};
+} gl_frag_attrib;
 
 /**
  * Bitflags for fragment program input attributes.
@@ -274,6 +243,8 @@ enum
 #define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)
 #define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)
 #define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)
+#define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)
+#define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)
 #define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)
 #define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)
 #define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)
@@ -301,41 +272,41 @@ enum
 /**
  * Fragment program results
  */
-enum
+typedef enum
 {
-   FRAG_RESULT_COLR = 0,
-   FRAG_RESULT_COLH = 1,
-   FRAG_RESULT_DEPR = 2,
-   FRAG_RESULT_DATA0 = 3,
+   FRAG_RESULT_DEPTH = 0,
+   FRAG_RESULT_COLOR = 1,
+   FRAG_RESULT_DATA0 = 2,
    FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)
-};
+} gl_frag_result;
 
 
 /**
  * Indexes for all renderbuffers
  */
-enum {
-   BUFFER_FRONT_LEFT  = 0,  /* the four standard color buffers */
-   BUFFER_BACK_LEFT   = 1,
-   BUFFER_FRONT_RIGHT = 2,
-   BUFFER_BACK_RIGHT  = 3,
-   BUFFER_AUX0        = 4,  /* optional aux buffer */
-   BUFFER_AUX1        = 5,
-   BUFFER_AUX2        = 6,
-   BUFFER_AUX3        = 7,
-   BUFFER_DEPTH       = 8,
-   BUFFER_STENCIL     = 9,
-   BUFFER_ACCUM       = 10,
-   BUFFER_COLOR0      = 11, /* generic renderbuffers */
-   BUFFER_COLOR1      = 12,
-   BUFFER_COLOR2      = 13,
-   BUFFER_COLOR3      = 14,
-   BUFFER_COLOR4      = 15,
-   BUFFER_COLOR5      = 16,
-   BUFFER_COLOR6      = 17,
-   BUFFER_COLOR7      = 18,
-   BUFFER_COUNT       = 19
-};
+typedef enum
+{
+   /* the four standard color buffers */
+   BUFFER_FRONT_LEFT,
+   BUFFER_BACK_LEFT,
+   BUFFER_FRONT_RIGHT,
+   BUFFER_BACK_RIGHT,
+   BUFFER_DEPTH,
+   BUFFER_STENCIL,
+   BUFFER_ACCUM,
+   /* optional aux buffer */
+   BUFFER_AUX0,
+   /* generic renderbuffers */
+   BUFFER_COLOR0,
+   BUFFER_COLOR1,
+   BUFFER_COLOR2,
+   BUFFER_COLOR3,
+   BUFFER_COLOR4,
+   BUFFER_COLOR5,
+   BUFFER_COLOR6,
+   BUFFER_COLOR7,
+   BUFFER_COUNT
+} gl_buffer_index;
 
 /**
  * Bit flags for all renderbuffers
@@ -368,9 +339,6 @@ enum {
                             BUFFER_BIT_FRONT_RIGHT | \
                             BUFFER_BIT_BACK_RIGHT | \
                             BUFFER_BIT_AUX0 | \
-                            BUFFER_BIT_AUX1 | \
-                            BUFFER_BIT_AUX2 | \
-                            BUFFER_BIT_AUX3 | \
                             BUFFER_BIT_COLOR0 | \
                             BUFFER_BIT_COLOR1 | \
                             BUFFER_BIT_COLOR2 | \
@@ -382,12 +350,13 @@ enum {
 
 
 /** The pixel transfer path has three color tables: */
-/*@{*/
-#define COLORTABLE_PRECONVOLUTION  0
-#define COLORTABLE_POSTCONVOLUTION 1
-#define COLORTABLE_POSTCOLORMATRIX 2
-#define COLORTABLE_MAX 3
-/*@}*/
+typedef enum
+{
+   COLORTABLE_PRECONVOLUTION,
+   COLORTABLE_POSTCONVOLUTION,
+   COLORTABLE_POSTCOLORMATRIX,
+   COLORTABLE_MAX
+} gl_colortable_index;
 
 
 /**
@@ -497,7 +466,7 @@ struct gl_light
    GLfloat Diffuse[4];		/**< diffuse color */
    GLfloat Specular[4];		/**< specular color */
    GLfloat EyePosition[4];	/**< position in eye coordinates */
-   GLfloat EyeDirection[4];	/**< spotlight dir in eye coordinates */
+   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */
    GLfloat SpotExponent;
    GLfloat SpotCutoff;		/**< in degrees */
    GLfloat _CosCutoffNeg;	/**< = cos(SpotCutoff) */
@@ -516,7 +485,7 @@ struct gl_light
    GLfloat _Position[4];	/**< position in eye/obj coordinates */
    GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */
    GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */
-   GLfloat _NormDirection[4];	/**< normalized spotlight direction */
+   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */
    GLfloat _VP_inf_spot_attenuation;
 
    GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */
@@ -624,9 +593,7 @@ struct gl_current_attrib
     * \note Index and Edgeflag current values are stored as floats in the 
     * SIX and SEVEN attribute slots.
     */
-   /*@{*/
    GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */
-   /*@}*/
 
    /**
     * \name Current raster position attributes (always valid).
@@ -659,84 +626,6 @@ struct gl_depthbuffer_attrib
 
 
 /**
- * glEnable()/glDisable() attribute group (GL_ENABLE_BIT).
- */
-struct gl_enable_attrib
-{
-   GLboolean AlphaTest;
-   GLboolean AutoNormal;
-   GLboolean Blend;
-   GLbitfield ClipPlanes;
-   GLboolean ColorMaterial;
-   GLboolean ColorTable[COLORTABLE_MAX];
-   GLboolean Convolution1D;
-   GLboolean Convolution2D;
-   GLboolean Separable2D;
-   GLboolean CullFace;
-   GLboolean DepthTest;
-   GLboolean Dither;
-   GLboolean Fog;
-   GLboolean Histogram;
-   GLboolean Light[MAX_LIGHTS];
-   GLboolean Lighting;
-   GLboolean LineSmooth;
-   GLboolean LineStipple;
-   GLboolean IndexLogicOp;
-   GLboolean ColorLogicOp;
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean MinMax;
-   GLboolean Normalize;
-   GLboolean PixelTexture;
-   GLboolean PointSmooth;
-   GLboolean PolygonOffsetPoint;
-   GLboolean PolygonOffsetLine;
-   GLboolean PolygonOffsetFill;
-   GLboolean PolygonSmooth;
-   GLboolean PolygonStipple;
-   GLboolean RescaleNormals;
-   GLboolean Scissor;
-   GLboolean Stencil;
-   GLboolean StencilTwoSide;          /* GL_EXT_stencil_two_side */
-   GLboolean MultisampleEnabled;      /* GL_ARB_multisample */
-   GLboolean SampleAlphaToCoverage;   /* GL_ARB_multisample */
-   GLboolean SampleAlphaToOne;        /* GL_ARB_multisample */
-   GLboolean SampleCoverage;          /* GL_ARB_multisample */
-   GLboolean SampleCoverageInvert;    /* GL_ARB_multisample */
-   GLboolean RasterPositionUnclipped; /* GL_IBM_rasterpos_clip */
-   GLuint Texture[MAX_TEXTURE_UNITS];
-   GLuint TexGen[MAX_TEXTURE_UNITS];
-   /* SGI_texture_color_table */
-   GLboolean TextureColorTable[MAX_TEXTURE_UNITS];
-   /* GL_ARB_vertex_program / GL_NV_vertex_program */
-   GLboolean VertexProgram;
-   GLboolean VertexProgramPointSize;
-   GLboolean VertexProgramTwoSide;
-   /* GL_ARB_point_sprite / GL_NV_point_sprite */
-   GLboolean PointSprite;
-   GLboolean FragmentShaderATI;
-};
-
-
-/**
  * Evaluator attribute group (GL_EVAL_BIT).
  */
 struct gl_eval_attrib
@@ -823,11 +712,11 @@ struct gl_hint_attrib
  */
 struct gl_histogram_attrib
 {
-   GLuint Width;				/**< number of table entries */
-   GLint Format;				/**< GL_ALPHA, GL_RGB, etc */
-   GLuint Count[HISTOGRAM_TABLE_SIZE][4];	/**< the histogram */
-   GLboolean Sink;				/**< terminate image transfer? */
-   GLubyte RedSize;				/**< Bits per counter */
+   GLuint Width;                            /**< number of table entries */
+   GLint Format;                            /**< GL_ALPHA, GL_RGB, etc */
+   GLuint Count[HISTOGRAM_TABLE_SIZE][4];   /**< the histogram */
+   GLboolean Sink;                          /**< terminate image transfer? */
+   GLubyte RedSize;                         /**< Bits per counter */
    GLubyte GreenSize;
    GLubyte BlueSize;
    GLubyte AlphaSize;
@@ -887,6 +776,7 @@ struct gl_light_attrib
 
    GLboolean Enabled;			/**< Lighting enabled flag */
    GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */
+   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */
    GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */
    GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */
    GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */
@@ -901,7 +791,7 @@ struct gl_light_attrib
    /*@{*/
    GLboolean _NeedEyeCoords;		
    GLboolean _NeedVertices;		/**< Use fast shader? */
-   GLbitfield  _Flags;		        /**< LIGHT_* flags, see above */
+   GLbitfield _Flags;		        /**< LIGHT_* flags, see above */
    GLfloat _BaseColor[2][3];
    /*@}*/
 };
@@ -1006,13 +896,15 @@ struct gl_pixel_attrib
    /*--- Begin Pixel Transfer State ---*/
    /* Fields are in the order in which they're applied... */
 
-   /* Scale & Bias (index shift, offset) */
+   /** Scale & Bias (index shift, offset) */
+   /*@{*/
    GLfloat RedBias, RedScale;
    GLfloat GreenBias, GreenScale;
    GLfloat BlueBias, BlueScale;
    GLfloat AlphaBias, AlphaScale;
    GLfloat DepthBias, DepthScale;
    GLint IndexShift, IndexOffset;
+   /*@}*/
 
    /* Pixel Maps */
    /* Note: actual pixel maps are not part of this attrib group */
@@ -1028,7 +920,7 @@ struct gl_pixel_attrib
    GLboolean Convolution1DEnabled;
    GLboolean Convolution2DEnabled;
    GLboolean Separable2DEnabled;
-   GLfloat ConvolutionBorderColor[3][4];
+   GLfloat ConvolutionBorderColor[3][4];  /**< RGBA */
    GLenum ConvolutionBorderMode[3];
    GLfloat ConvolutionFilterScale[3][4];  /**< RGBA */
    GLfloat ConvolutionFilterBias[3][4];   /**< RGBA */
@@ -1047,12 +939,12 @@ struct gl_pixel_attrib
 
    /*--- End Pixel Transfer State ---*/
 
-   /* Pixel Zoom */
+   /** glPixelZoom */
    GLfloat ZoomX, ZoomY;
 
    /** GL_SGI_texture_color_table */
-   GLfloat TextureColorTableScale[4];
-   GLfloat TextureColorTableBias[4];
+   GLfloat TextureColorTableScale[4]; /**< RGBA */
+   GLfloat TextureColorTableBias[4];  /**< RGBA */
 };
 
 
@@ -1108,51 +1000,69 @@ struct gl_scissor_attrib
 
 /**
  * Stencil attribute group (GL_STENCIL_BUFFER_BIT).
+ *
+ * Three sets of stencil data are tracked so that OpenGL 2.0,
+ * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported
+ * simultaneously.  In each of the stencil state arrays, element 0 corresponds
+ * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /
+ * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the
+ * GL_EXT_stencil_two_side GL_BACK state.
+ *
+ * The derived value \c _BackFace is either 1 or 2 depending on whether or
+ * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.
+ *
+ * The derived value \c _TestTwoSide is set when the front-face and back-face
+ * stencil state are different.
  */
 struct gl_stencil_attrib
 {
    GLboolean Enabled;		/**< Enabled flag */
    GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */
-   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 1) */
+   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */
+   GLboolean _Enabled;          /**< Enabled and stencil buffer present */
    GLboolean _TestTwoSide;
-   GLenum Function[2];		/**< Stencil function */
-   GLenum FailFunc[2];		/**< Fail function */
-   GLenum ZPassFunc[2];		/**< Depth buffer pass function */
-   GLenum ZFailFunc[2];		/**< Depth buffer fail function */
-   GLint Ref[2];		/**< Reference value */
-   GLuint ValueMask[2];		/**< Value mask */
-   GLuint WriteMask[2];		/**< Write mask */
+   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */
+   GLenum Function[3];		/**< Stencil function */
+   GLenum FailFunc[3];		/**< Fail function */
+   GLenum ZPassFunc[3];		/**< Depth buffer pass function */
+   GLenum ZFailFunc[3];		/**< Depth buffer fail function */
+   GLint Ref[3];		/**< Reference value */
+   GLuint ValueMask[3];		/**< Value mask */
+   GLuint WriteMask[3];		/**< Write mask */
    GLuint Clear;		/**< Clear value */
 };
 
 
-#define NUM_TEXTURE_TARGETS 7   /* 1D, 2D, 3D, CUBE, RECT, 1D_STACK, and 2D_STACK */
-
 /**
- * An index for each type of texture object
+ * An index for each type of texture object.  These correspond to the GL
+ * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.
+ * Note: the order is from highest priority to lowest priority.
  */
-/*@{*/
-#define TEXTURE_1D_INDEX       0
-#define TEXTURE_2D_INDEX       1
-#define TEXTURE_3D_INDEX       2
-#define TEXTURE_CUBE_INDEX     3
-#define TEXTURE_RECT_INDEX     4
-#define TEXTURE_1D_ARRAY_INDEX 5
-#define TEXTURE_2D_ARRAY_INDEX 6
-/*@}*/
+typedef enum
+{
+   TEXTURE_2D_ARRAY_INDEX,
+   TEXTURE_1D_ARRAY_INDEX,
+   TEXTURE_CUBE_INDEX,
+   TEXTURE_3D_INDEX,
+   TEXTURE_RECT_INDEX,
+   TEXTURE_2D_INDEX,
+   TEXTURE_1D_INDEX,
+   NUM_TEXTURE_TARGETS
+} gl_texture_index;
+
 
 /**
  * Bit flags for each type of texture object
  * Used for Texture.Unit[]._ReallyEnabled flags.
  */
 /*@{*/
-#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
-#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
-#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
+#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
+#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
 #define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)
+#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
 #define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)
-#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
-#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
+#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
+#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
 /*@}*/
 
 
@@ -1187,27 +1097,12 @@ struct gl_stencil_attrib
 /*@}*/
 
 
-/* A selection of state flags to make driver and module's lives easier. */
-#define ENABLE_TEXGEN0        0x1
-#define ENABLE_TEXGEN1        0x2
-#define ENABLE_TEXGEN2        0x4
-#define ENABLE_TEXGEN3        0x8
-#define ENABLE_TEXGEN4        0x10
-#define ENABLE_TEXGEN5        0x20
-#define ENABLE_TEXGEN6        0x40
-#define ENABLE_TEXGEN7        0x80
 
-#define ENABLE_TEXMAT0        0x1	/* Ie. not the identity matrix */
-#define ENABLE_TEXMAT1        0x2
-#define ENABLE_TEXMAT2        0x4
-#define ENABLE_TEXMAT3        0x8
-#define ENABLE_TEXMAT4        0x10
-#define ENABLE_TEXMAT5        0x20
-#define ENABLE_TEXMAT6        0x40
-#define ENABLE_TEXMAT7        0x80
+/** Tex-gen enabled for texture unit? */
+#define ENABLE_TEXGEN(unit) (1 << (unit))
 
-#define ENABLE_TEXGEN(i) (ENABLE_TEXGEN0 << (i))
-#define ENABLE_TEXMAT(i) (ENABLE_TEXMAT0 << (i))
+/** Non-identity texture matrix for texture unit? */
+#define ENABLE_TEXMAT(unit) (1 << (unit))
 
 
 /**
@@ -1383,15 +1278,16 @@ struct gl_texture_image
 /**
  * Indexes for cube map faces.
  */
-/*@{*/
-#define FACE_POS_X   0
-#define FACE_NEG_X   1
-#define FACE_POS_Y   2
-#define FACE_NEG_Y   3
-#define FACE_POS_Z   4
-#define FACE_NEG_Z   5
-#define MAX_FACES    6
-/*@}*/
+typedef enum
+{
+   FACE_POS_X = 0,
+   FACE_NEG_X = 1,
+   FACE_POS_Y = 2,
+   FACE_NEG_Y = 3,
+   FACE_POS_Z = 4,
+   FACE_NEG_Z = 5,
+   MAX_FACES = 6
+} gl_face_index;
 
 
 /**
@@ -1407,7 +1303,6 @@ struct gl_texture_object
    GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
    GLfloat Priority;		/**< in [0,1] */
    GLfloat BorderColor[4];	/**< unclamped */
-   GLchan _BorderChan[4];	/**< clamped, as GLchan */
    GLenum WrapS;		/**< S-axis texture image wrap mode */
    GLenum WrapT;		/**< T-axis texture image wrap mode */
    GLenum WrapR;		/**< R-axis texture image wrap mode */
@@ -1419,21 +1314,18 @@ struct gl_texture_object
    GLint BaseLevel;		/**< min mipmap level, OpenGL 1.2 */
    GLint MaxLevel;		/**< max mipmap level, OpenGL 1.2 */
    GLfloat MaxAnisotropy;	/**< GL_EXT_texture_filter_anisotropic */
-   GLboolean CompareFlag;	/**< GL_SGIX_shadow */
-   GLenum CompareOperator;	/**< GL_SGIX_shadow */
-   GLfloat ShadowAmbient;       /**< GL_ARB_shadow_ambient */
    GLenum CompareMode;		/**< GL_ARB_shadow */
    GLenum CompareFunc;		/**< GL_ARB_shadow */
-   GLenum _Function;		/**< Comparison function derived from 
-				 * \c CompareOperator, \c CompareMode, and
-				 * \c CompareFunc.
-				 */
+   GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */
    GLenum DepthMode;		/**< GL_ARB_depth_texture */
    GLint _MaxLevel;		/**< actual max mipmap level (q in the spec) */
    GLfloat _MaxLambda;		/**< = _MaxLevel - BaseLevel (q - b in spec) */
    GLint CropRect[4];           /**< GL_OES_draw_texture */
+   GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */
+   GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */
    GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */
    GLboolean _Complete;		/**< Is texture object complete? */
+   GLboolean _RenderToTexture;  /**< Any rendering to this texture? */
 
    /** Actual texture images, indexed by [cube face] and [mipmap level] */
    struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
@@ -1452,25 +1344,39 @@ struct gl_texture_object
 };
 
 
+/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */
+#define MAX_COMBINER_TERMS 4
+
+
 /**
  * Texture combine environment state.
- * 
- * \todo
- * If GL_NV_texture_env_combine4 is ever supported, the arrays in this
- * structure will need to be expanded for 4 elements.
  */
 struct gl_tex_env_combine_state
 {
    GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
    GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
-   GLenum SourceRGB[3];  /**< GL_PRIMARY_COLOR, GL_TEXTURE, etc. */
-   GLenum SourceA[3];    /**< GL_PRIMARY_COLOR, GL_TEXTURE, etc. */
-   GLenum OperandRGB[3]; /**< SRC_COLOR, ONE_MINUS_SRC_COLOR, etc */
-   GLenum OperandA[3];   /**< SRC_ALPHA, ONE_MINUS_SRC_ALPHA, etc */
+   /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
+   GLenum SourceRGB[MAX_COMBINER_TERMS];
+   GLenum SourceA[MAX_COMBINER_TERMS];
+   /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
+   GLenum OperandRGB[MAX_COMBINER_TERMS];
+   GLenum OperandA[MAX_COMBINER_TERMS];
    GLuint ScaleShiftRGB; /**< 0, 1 or 2 */
    GLuint ScaleShiftA;   /**< 0, 1 or 2 */
-   GLuint _NumArgsRGB;   /**< Number of inputs used for the combine mode. */
-   GLuint _NumArgsA;     /**< Number of inputs used for the combine mode. */
+   GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */
+   GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */
+};
+
+
+/**
+ * Texture coord generation state.
+ */
+struct gl_texgen
+{
+   GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
+   GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
+   GLfloat ObjectPlane[4];
+   GLfloat EyePlane[4];
 };
 
 
@@ -1486,29 +1392,17 @@ struct gl_texture_unit
 
    GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
    GLfloat EnvColor[4];
+
+   struct gl_texgen GenS;
+   struct gl_texgen GenT;
+   struct gl_texgen GenR;
+   struct gl_texgen GenQ;
    GLbitfield TexGenEnabled;	/**< Bitwise-OR of [STRQ]_BIT values */
-   /** \name Tex coord generation mode
-    * Either GL_OBJECT_LINEAR, GL_EYE_LINEAR or GL_SPHERE_MAP. */
-   /*@{*/
-   GLenum GenModeS;		
-   GLenum GenModeT;
-   GLenum GenModeR;
-   GLenum GenModeQ;
-   /*@}*/
-   GLbitfield _GenBitS;
-   GLbitfield _GenBitT;
-   GLbitfield _GenBitR;
-   GLbitfield _GenBitQ;
-   GLbitfield _GenFlags;	/**< bitwise or of _GenBit[STRQ] */
-   GLfloat ObjectPlaneS[4];
-   GLfloat ObjectPlaneT[4];
-   GLfloat ObjectPlaneR[4];
-   GLfloat ObjectPlaneQ[4];
-   GLfloat EyePlaneS[4];
-   GLfloat EyePlaneT[4];
-   GLfloat EyePlaneR[4];
-   GLfloat EyePlaneQ[4];
+   GLbitfield _GenFlags;	/**< Bitwise-OR of Gen[STRQ]._ModeBit */
+
    GLfloat LodBias;		/**< for biasing mipmap levels */
+   GLenum BumpTarget;
+   GLfloat RotMatrix[4]; /* 2x2 matrix */
 
    /** 
     * \name GL_EXT_texture_env_combine 
@@ -1527,15 +1421,11 @@ struct gl_texture_unit
     */
    struct gl_tex_env_combine_state *_CurrentCombine;
 
-   struct gl_texture_object *Current1D;
-   struct gl_texture_object *Current2D;
-   struct gl_texture_object *Current3D;
-   struct gl_texture_object *CurrentCubeMap; /**< GL_ARB_texture_cube_map */
-   struct gl_texture_object *CurrentRect;    /**< GL_NV_texture_rectangle */
-   struct gl_texture_object *Current1DArray; /**< GL_MESA_texture_array */
-   struct gl_texture_object *Current2DArray; /**< GL_MESA_texture_array */
+   /** Current texture object pointers */
+   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
 
-   struct gl_texture_object *_Current; /**< Points to really enabled tex obj */
+   /** Points to highest priority, complete and enabled texture object */
+   struct gl_texture_object *_Current;
 
    /** GL_SGI_texture_color_table */
    /*@{*/
@@ -1546,32 +1436,37 @@ struct gl_texture_unit
 };
 
 
-
 /**
  * Texture attribute group (GL_TEXTURE_BIT).
  */
 struct gl_texture_attrib
 {
-   /**
-    * name multitexture 
-    */
-   /**@{*/
-   GLuint CurrentUnit;   /**< Active texture unit [0, MaxTextureImageUnits-1] */
-   GLbitfield _EnabledUnits;  /**< one bit set for each really-enabled unit */
-   GLbitfield _EnabledCoordUnits;   /**< one bit per enabled coordinate unit */
-   GLbitfield _GenFlags;            /**< for texgen */
-   GLbitfield _TexGenEnabled;
-   GLbitfield _TexMatEnabled;
-   /**@}*/
-
+   GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */
    struct gl_texture_unit Unit[MAX_TEXTURE_UNITS];
 
-   /** Proxy texture objects */
    struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
 
+   /** GL_ARB_seamless_cubemap */
+   GLboolean CubeMapSeamless;
+
    /** GL_EXT_shared_texture_palette */
    GLboolean SharedPalette;
    struct gl_color_table Palette;
+
+   /** Texture units/samplers used by vertex or fragment texturing */
+   GLbitfield _EnabledUnits;
+
+   /** Texture coord units/sets used for fragment texturing */
+   GLbitfield _EnabledCoordUnits;
+
+   /** Texture coord units that have texgen enabled */
+   GLbitfield _TexGenEnabled;
+
+   /** Texture coord units that have non-identity matrices */
+   GLbitfield _TexMatEnabled;
+
+   /** Bitwise-OR of all Texture.Unit[i]._GenFlags */
+   GLbitfield _GenFlags;
 };
 
 
@@ -1587,6 +1482,7 @@ struct gl_transform_attrib
    GLboolean Normalize;				/**< Normalize all normals? */
    GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */
    GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */
+   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */
 
    GLboolean CullVertexFlag;	/**< True if GL_CULL_VERTEX_EXT is enabled */
    GLfloat CullEyePos[4];
@@ -1607,33 +1503,26 @@ struct gl_viewport_attrib
 
 
 /**
- * Node for the attribute stack.
- */
-struct gl_attrib_node
-{
-   GLbitfield kind;
-   void *data;
-   struct gl_attrib_node *next;
-};
-
-
-/**
  * GL_ARB_vertex/pixel_buffer_object buffer object
  */
 struct gl_buffer_object
 {
    GLint RefCount;
    GLuint Name;
-   GLenum Usage;
-   GLenum Access;
-   GLvoid *Pointer;          /**< Only valid while buffer is mapped */
-   GLsizeiptrARB Size;       /**< Size of storage in bytes */
-   GLubyte *Data;            /**< Location of storage either in RAM or VRAM. */
-   GLboolean OnCard;         /**< Is buffer in VRAM? (hardware drivers) */
+   GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
+   GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */
+   GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */
+   /** Fields describing a mapped buffer */
+   /*@{*/
+   GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
+   GLvoid *Pointer;     /**< User-space address of mapping */
+   GLintptr Offset;     /**< Mapped offset */
+   GLsizeiptr Length;   /**< Mapped length */
+   /*@}*/
+   GLboolean Written;   /**< Ever written to? (for debugging) */
 };
 
 
-
 /**
  * Client pixel packing/unpacking attributes
  */
@@ -1643,8 +1532,8 @@ struct gl_pixelstore_attrib
    GLint RowLength;
    GLint SkipPixels;
    GLint SkipRows;
-   GLint ImageHeight;     /**< for GL_EXT_texture3D */
-   GLint SkipImages;      /**< for GL_EXT_texture3D */
+   GLint ImageHeight;
+   GLint SkipImages;
    GLboolean SwapBytes;
    GLboolean LsbFirst;
    GLboolean ClientStorage; /**< GL_APPLE_client_storage */
@@ -1653,7 +1542,6 @@ struct gl_pixelstore_attrib
 };
 
 
-
 /**
  * Client vertex array attributes
  */
@@ -1661,15 +1549,16 @@ struct gl_client_array
 {
    GLint Size;                  /**< components per element (1,2,3,4) */
    GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */
+   GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */
    GLsizei Stride;		/**< user-specified stride */
    GLsizei StrideB;		/**< actual stride in bytes */
    const GLubyte *Ptr;          /**< Points to array data */
    GLboolean Enabled;		/**< Enabled flag is a boolean */
    GLboolean Normalized;        /**< GL_ARB_vertex_program */
+   GLuint _ElementSize;         /**< size of each element in bytes */
 
-   /**< GL_ARB_vertex_buffer_object */
-   struct gl_buffer_object *BufferObj;
-   GLuint _MaxElement;
+   struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */
+   GLuint _MaxElement;          /**< max element index into array buffer + 1 */
 };
 
 
@@ -1682,9 +1571,14 @@ struct gl_array_object
    /** Name of the array object as received from glGenVertexArrayAPPLE. */
    GLuint Name;
 
+   GLint RefCount;
+   _glthread_Mutex Mutex;
+   GLboolean VBOonly;  /**< require all arrays to live in VBOs? */
+
    /** Conventional vertex arrays */
    /*@{*/
    struct gl_client_array Vertex;
+   struct gl_client_array Weight;
    struct gl_client_array Normal;
    struct gl_client_array Color;
    struct gl_client_array SecondaryColor;
@@ -1695,11 +1589,22 @@ struct gl_array_object
    struct gl_client_array PointSize;
    /*@}*/
 
-   /** Generic arrays for vertex programs/shaders */
-   struct gl_client_array VertexAttrib[VERT_ATTRIB_MAX];
+   /**
+    * Generic arrays for vertex programs/shaders.
+    * For NV vertex programs, these attributes alias and take priority
+    * over the conventional attribs above.  For ARB vertex programs and
+    * GLSL vertex shaders, these attributes are separate.
+    */
+   struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
 
    /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */
    GLbitfield _Enabled;
+
+   /**
+    * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs
+    * we can determine the max legal (in bounds) glDrawElements array index.
+    */
+   GLuint _MaxElement;
 };
 
 
@@ -1708,9 +1613,15 @@ struct gl_array_object
  */
 struct gl_array_attrib
 {
+   /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */
    struct gl_array_object *ArrayObj;
+
+   /** The default vertex array object */
    struct gl_array_object *DefaultArrayObj;
 
+   /** Array objects (GL_ARB/APPLE_vertex_array_object) */
+   struct _mesa_HashTable *Objects;
+
    GLint ActiveTexture;		/**< Client Active Texture */
    GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */
    GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */
@@ -1718,11 +1629,9 @@ struct gl_array_attrib
    GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */
 
 #if FEATURE_ARB_vertex_buffer_object
-   struct gl_buffer_object *NullBufferObj;
    struct gl_buffer_object *ArrayBufferObj;
    struct gl_buffer_object *ElementArrayBufferObj;
 #endif
-   GLuint _MaxElement;          /* Min of all enabled array's maxes */
 };
 
 
@@ -1732,7 +1641,7 @@ struct gl_array_attrib
 struct gl_feedback
 {
    GLenum Type;
-   GLbitfield _Mask;		/* FB_* bits */
+   GLbitfield _Mask;    /**< FB_* bits */
    GLfloat *Buffer;
    GLuint BufferSize;
    GLuint Count;
@@ -1830,24 +1739,24 @@ struct gl_evaluators
  * be "uniform" variables since they can only be set outside glBegin/End.
  * They're also all stored in the same Parameters array.
  */
-enum register_file
-{
-   PROGRAM_TEMPORARY = 0,   /**< machine->Temporary[] */
-   PROGRAM_LOCAL_PARAM = 1, /**< gl_program->LocalParams[] */
-   PROGRAM_ENV_PARAM = 2,   /**< gl_program->Parameters[] */
-   PROGRAM_STATE_VAR = 3,   /**< gl_program->Parameters[] */
-   PROGRAM_INPUT = 4,       /**< machine->Inputs[] */
-   PROGRAM_OUTPUT = 5,      /**< machine->Outputs[] */
-   PROGRAM_NAMED_PARAM = 6, /**< gl_program->Parameters[] */
-   PROGRAM_CONSTANT = 7,    /**< gl_program->Parameters[] */
-   PROGRAM_UNIFORM = 8,     /**< gl_program->Parameters[] */
-   PROGRAM_VARYING = 9,     /**< machine->Inputs[]/Outputs[] */
-   PROGRAM_WRITE_ONLY = 10, /**< A dummy, write-only register */
-   PROGRAM_ADDRESS = 11,    /**< machine->AddressReg */
-   PROGRAM_SAMPLER = 12,    /**< for shader samplers, compile-time only */
-   PROGRAM_UNDEFINED = 13,  /**< Invalid value */
+typedef enum
+{
+   PROGRAM_TEMPORARY,   /**< machine->Temporary[] */
+   PROGRAM_INPUT,       /**< machine->Inputs[] */
+   PROGRAM_OUTPUT,      /**< machine->Outputs[] */
+   PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */
+   PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */
+   PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */
+   PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */
+   PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */
+   PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */
+   PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */
+   PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */
+   PROGRAM_ADDRESS,     /**< machine->AddressReg */
+   PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */
+   PROGRAM_UNDEFINED,   /**< Invalid/TBD value */
    PROGRAM_FILE_MAX
-};
+} gl_register_file;
 
 
 /** Vertex and fragment instructions */
@@ -1892,7 +1801,7 @@ struct gl_program
    /** Map from sampler unit to texture unit (set by glUniform1i()) */
    GLubyte SamplerUnits[MAX_SAMPLERS];
    /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
-   GLubyte SamplerTargets[MAX_SAMPLERS];
+   gl_texture_index SamplerTargets[MAX_SAMPLERS];
 
    /** Logical counts */
    /*@{*/
@@ -1935,9 +1844,6 @@ struct gl_fragment_program
    struct gl_program Base;   /**< base class */
    GLenum FogOption;
    GLboolean UsesKill;          /**< shader uses KIL instruction */
-   GLboolean UsesPointCoord;    /**< shader uses gl_PointCoord */
-   GLboolean UsesFrontFacing;   /**< shader used gl_FrontFacing */
-   GLboolean UsesFogFragCoord;  /**< shader used gl_FogFragCoord */
 };
 
 
@@ -1956,14 +1862,14 @@ struct gl_program_state
  */
 struct gl_vertex_program_state
 {
-   GLboolean Enabled;               /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
-   GLboolean _Enabled;              /**< Enabled and _valid_ user program? */
-   GLboolean PointSizeEnabled;      /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
-   GLboolean TwoSideEnabled;        /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
+   GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
+   GLboolean _Enabled;           /**< Enabled and _valid_ user program? */
+   GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
+   GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
    struct gl_vertex_program *Current;  /**< User-bound vertex program */
 
-   /** Currently enabled and valid vertex program (including internal programs,
-    * user-defined vertex programs and GLSL vertex shaders).
+   /** Currently enabled and valid vertex program (including internal
+    * programs, user-defined vertex programs and GLSL vertex shaders).
     * This is the program we must use when rendering.
     */
    struct gl_vertex_program *_Current;
@@ -1983,12 +1889,7 @@ struct gl_vertex_program_state
    /** Cache of fixed-function programs */
    struct gl_program_cache *Cache;
 
-#if FEATURE_MESA_program_debug
-   GLprogramcallbackMESA Callback;
-   GLvoid *CallbackData;
-   GLboolean CallbackEnabled;
-   GLuint CurrentPosition;
-#endif
+   GLboolean _Overriden;
 };
 
 
@@ -2001,8 +1902,8 @@ struct gl_fragment_program_state
    GLboolean _Enabled;    /**< Enabled and _valid_ user program? */
    struct gl_fragment_program *Current;  /**< User-bound fragment program */
 
-   /** Currently enabled and valid fragment program (including internal programs,
-    * user-defined fragment programs and GLSL fragment shaders).
+   /** Currently enabled and valid fragment program (including internal
+    * programs, user-defined fragment programs and GLSL fragment shaders).
     * This is the program we must use when rendering.
     */
    struct gl_fragment_program *_Current;
@@ -2017,13 +1918,6 @@ struct gl_fragment_program_state
 
    /** Cache of fixed-function programs */
    struct gl_program_cache *Cache;
-
-#if FEATURE_MESA_program_debug
-   GLprogramcallbackMESA Callback;
-   GLvoid *CallbackData;
-   GLboolean CallbackEnabled;
-   GLuint CurrentPosition;
-#endif
 };
 
 
@@ -2094,9 +1988,26 @@ struct gl_query_state
 };
 
 
+/** Sync object state */
+struct gl_sync_object {
+   struct simple_node link;
+   GLenum Type;               /**< GL_SYNC_FENCE */
+   GLuint Name;               /**< Fence name */
+   GLint RefCount;            /**< Reference count */
+   GLboolean DeletePending;   /**< Object was deleted while there were still
+			       * live references (e.g., sync not yet finished)
+			       */
+   GLenum SyncCondition;
+   GLbitfield Flags;          /**< Flags passed to glFenceSync */
+   GLuint StatusFlag:1;       /**< Has the sync object been signaled? */
+};
+
+
 /** Set by #pragma directives */
 struct gl_sl_pragmas
 {
+   GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */
+   GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */
    GLboolean Optimize;  /**< defaults on */
    GLboolean Debug;     /**< defaults off */
 };
@@ -2113,7 +2024,9 @@ struct gl_shader
    GLboolean DeletePending;
    GLboolean CompileStatus;
    GLboolean Main;  /**< shader defines main() */
+   GLboolean UnresolvedRefs;
    const GLchar *Source;  /**< Source code string */
+   GLuint SourceChecksum;       /**< for debug/logging purposes */
    struct gl_program *Program;  /**< Post-compile assembly code */
    GLchar *InfoLog;
    struct gl_sl_pragmas Pragmas;
@@ -2144,10 +2057,18 @@ struct gl_shader_program
    struct gl_program_parameter_list *Varying;
    GLboolean LinkStatus;   /**< GL_LINK_STATUS */
    GLboolean Validated;
+   GLboolean _Used;        /**< Ever used for drawing? */
    GLchar *InfoLog;
 };   
 
 
+#define GLSL_DUMP      0x1  /**< Dump shaders to stdout */
+#define GLSL_LOG       0x2  /**< Write shaders to files */
+#define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */
+#define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */
+#define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */
+
+
 /**
  * Context state for GLSL vertex/fragment shaders.
  */
@@ -2156,9 +2077,12 @@ struct gl_shader_state
    struct gl_shader_program *CurrentProgram; /**< The user-bound program */
    /** Driver-selectable options: */
    GLboolean EmitHighLevelInstructions; /**< IF/ELSE/ENDIF vs. BRA, etc. */
+   GLboolean EmitContReturn;            /**< Emit CONT/RET opcodes? */
    GLboolean EmitCondCodes;             /**< Use condition codes? */
    GLboolean EmitComments;              /**< Annotated instructions */
    void *MemPool;
+   GLbitfield Flags;                    /**< Mask of GLSL_x flags */
+   struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */
 };
 
 
@@ -2172,18 +2096,11 @@ struct gl_shared_state
    struct _mesa_HashTable *DisplayList;	   /**< Display lists hash table */
    struct _mesa_HashTable *TexObjects;	   /**< Texture objects hash table */
 
-   /**
-    * \name Default texture objects (shared by all multi-texture units)
-    */
-   /*@{*/
-   struct gl_texture_object *Default1D;
-   struct gl_texture_object *Default2D;
-   struct gl_texture_object *Default3D;
-   struct gl_texture_object *DefaultCubeMap;
-   struct gl_texture_object *DefaultRect;
-   struct gl_texture_object *Default1DArray;
-   struct gl_texture_object *Default2DArray;
-   /*@}*/
+   /** Default texture objects (shared by all texture units) */
+   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];
+
+   /** Fallback texture used when a bound texture is incomplete */
+   struct gl_texture_object *FallbackTex;
 
    /**
     * \name Thread safety and statechange notification for texture
@@ -2196,6 +2113,8 @@ struct gl_shared_state
    GLuint TextureStateStamp;	        /**< state notification for shared tex */
    /*@}*/
 
+   /** Default buffer object for vertex arrays that aren't in VBOs */
+   struct gl_buffer_object *NullBufferObj;
 
    /**
     * \name Vertex/fragment programs
@@ -2229,8 +2148,9 @@ struct gl_shared_state
    struct _mesa_HashTable *FrameBuffers;
 #endif
 
-   /** Objects associated with the GL_APPLE_vertex_array_object extension. */
-   struct _mesa_HashTable *ArrayObjects;
+#if FEATURE_ARB_sync
+   struct simple_node SyncObjects;
+#endif
 
    void *DriverData;  /**< Device driver shared state */
 };
@@ -2260,7 +2180,9 @@ struct gl_renderbuffer
    GLenum _ActualFormat;  /**< The driver-chosen format */
    GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
                                GL_STENCIL_INDEX. */
-   GLenum DataType;      /**< Type of values passed to the Get/Put functions */
+   GLenum ColorEncoding; /**< GL_LINEAR or GL_SRGB */
+   GLenum ComponentType; /**< GL_FLOAT, GL_INT, GL_UNSIGNED_INT,
+                              GL_UNSIGNED_NORMALIZED or GL_INDEX */
    GLubyte RedBits;      /**< Bits of red per pixel */
    GLubyte GreenBits;
    GLubyte BlueBits;
@@ -2268,6 +2190,9 @@ struct gl_renderbuffer
    GLubyte IndexBits;
    GLubyte DepthBits;
    GLubyte StencilBits;
+   GLubyte NumSamples;
+
+   GLenum DataType;      /**< Type of values passed to the Get/Put functions */
    GLvoid *Data;        /**< This may not be used by some kinds of RBs */
 
    /* Used to wrap one renderbuffer around another: */
@@ -2342,9 +2267,8 @@ struct gl_renderbuffer
 
 
 /**
- * A renderbuffer attachment point points to either a texture object
- * (and specifies a mipmap level, cube face or 3D texture slice) or
- * points to a renderbuffer.
+ * A renderbuffer attachment points to either a texture object (and specifies
+ * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.
  */
 struct gl_renderbuffer_attachment
 {
@@ -2376,14 +2300,24 @@ struct gl_renderbuffer_attachment
  */
 struct gl_framebuffer
 {
-   _glthread_Mutex Mutex;		   /**< for thread safety */
-   GLuint Name;      /* if zero, this is a window system framebuffer */
+   _glthread_Mutex Mutex;  /**< for thread safety */
+   /**
+    * If zero, this is a window system framebuffer.  If non-zero, this
+    * is a FBO framebuffer; note that for some devices (i.e. those with
+    * a natural pixel coordinate system for FBOs that differs from the
+    * OpenGL/Mesa coordinate system), this means that the viewport,
+    * polygon face orientation, and polygon stipple will have to be inverted.
+    */
+   GLuint Name;
+
    GLint RefCount;
    GLboolean DeletePending;
 
-   GLvisual Visual;	/**< The framebuffer's visual.
-                             Immutable if this is a window system buffer.
-                             Computed from attachments if user-made FBO. */
+   /**
+    * The framebuffer's visual. Immutable if this is a window system buffer.
+    * Computed from attachments if user-made FBO.
+    */
+   GLvisual Visual;
 
    GLboolean Initialized;
 
@@ -2402,9 +2336,10 @@ struct gl_framebuffer
    GLfloat _MRD;	/**< minimum resolvable difference in Z values */
    /*@}*/
 
-   GLenum _Status; /* One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
+   /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
+   GLenum _Status;
 
-   /* Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
+   /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
    struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
 
    /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
@@ -2466,50 +2401,69 @@ struct gl_program_constants
  */
 struct gl_constants
 {
-   GLint MaxTextureLevels;		/**< Maximum number of allowed mipmap levels. */ 
-   GLint Max3DTextureLevels;		/**< Maximum number of allowed mipmap levels for 3D texture targets. */
-   GLint MaxCubeTextureLevels;          /**< Maximum number of allowed mipmap levels for GL_ARB_texture_cube_map */
-   GLint MaxArrayTextureLayers;         /**< Maximum number of layers in an array texture. */
-   GLint MaxTextureRectSize;            /* GL_NV_texture_rectangle */
+   GLint MaxTextureLevels;      /**< Max mipmap levels. */ 
+   GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */
+   GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */
+   GLint MaxArrayTextureLayers; /**< Max layers in array textures */
+   GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */
    GLuint MaxTextureCoordUnits;
    GLuint MaxTextureImageUnits;
-   GLuint MaxTextureUnits;              /**< = MIN(CoordUnits, ImageUnits) */
-   GLfloat MaxTextureMaxAnisotropy;     /**< GL_EXT_texture_filter_anisotropic */
-   GLfloat MaxTextureLodBias;           /**< GL_EXT_texture_lod_bias */
+   GLuint MaxVertexTextureImageUnits;
+   GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */
+   GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */
+   GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */
+
    GLuint MaxArrayLockSize;
+
    GLint SubPixelBits;
-   GLfloat MinPointSize, MaxPointSize;		/* aliased */
-   GLfloat MinPointSizeAA, MaxPointSizeAA;	/* antialiased */
+
+   GLfloat MinPointSize, MaxPointSize;	     /**< aliased */
+   GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */
    GLfloat PointSizeGranularity;
-   GLfloat MinLineWidth, MaxLineWidth;		/* aliased */
-   GLfloat MinLineWidthAA, MaxLineWidthAA;	/* antialiased */
+   GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */
+   GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */
    GLfloat LineWidthGranularity;
+
    GLuint MaxColorTableSize;
    GLuint MaxConvolutionWidth;
    GLuint MaxConvolutionHeight;
+
    GLuint MaxClipPlanes;
    GLuint MaxLights;
-   GLfloat MaxShininess;			/* GL_NV_light_max_exponent */
-   GLfloat MaxSpotExponent;			/* GL_NV_light_max_exponent */
+   GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */
+   GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */
+
    GLuint MaxViewportWidth, MaxViewportHeight;
-   struct gl_program_constants VertexProgram;    /* GL_ARB_vertex_program */
-   struct gl_program_constants FragmentProgram;  /* GL_ARB_fragment_program */
-   /* shared by vertex and fragment program: */
+
+   struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */
+   struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */
    GLuint MaxProgramMatrices;
    GLuint MaxProgramMatrixStackDepth;
-   /* vertex array / buffer object bounds checking */
+
+   /** vertex array / buffer object bounds checking */
    GLboolean CheckArrayBounds;
-   /* GL_ARB_draw_buffers */
-   GLuint MaxDrawBuffers;
-   /* GL_OES_read_format */
-   GLenum ColorReadFormat;
-   GLenum ColorReadType;
-   /* GL_EXT_framebuffer_object */
-   GLuint MaxColorAttachments;
-   GLuint MaxRenderbufferSize;
-   /* GL_ARB_vertex_shader */
-   GLuint MaxVertexTextureImageUnits;
-   GLuint MaxVarying;  /**< Number of float[4] vectors */
+
+   GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */
+
+   GLenum ColorReadFormat;   /**< GL_OES_read_format */
+   GLenum ColorReadType;     /**< GL_OES_read_format */
+
+   GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */
+   GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */
+   GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */
+
+   GLuint MaxVarying;  /**< Number of float[4] varying parameters */
+
+   GLbitfield SupportedBumpUnits; /**> units supporting GL_ATI_envmap_bumpmap as targets */
+
+   /**
+    * Maximum amount of time, measured in nanseconds, that the server can wait.
+    */
+   GLuint64 MaxServerWaitTimeout;
+
+
+   /**< GL_EXT_provoking_vertex */
+   GLboolean QuadsFollowProvokingVertexConvention;
 };
 
 
@@ -2519,28 +2473,30 @@ struct gl_constants
  */
 struct gl_extensions
 {
-   /**
-    * \name Flags to quickly test if certain extensions are available.
-    * 
-    * Not every extension needs to have such a flag, but it's encouraged.
-    */
-   /*@{*/
    GLboolean dummy;  /* don't remove this! */
+   GLboolean ARB_copy_buffer;
    GLboolean ARB_depth_texture;
+   GLboolean ARB_depth_clamp;
    GLboolean ARB_draw_buffers;
+   GLboolean ARB_draw_elements_base_vertex;
    GLboolean ARB_fragment_program;
    GLboolean ARB_fragment_program_shadow;
    GLboolean ARB_fragment_shader;
+   GLboolean ARB_framebuffer_object;
    GLboolean ARB_half_float_pixel;
    GLboolean ARB_imaging;
+   GLboolean ARB_map_buffer_range;
    GLboolean ARB_multisample;
    GLboolean ARB_multitexture;
    GLboolean ARB_occlusion_query;
    GLboolean ARB_point_sprite;
+   GLboolean ARB_seamless_cube_map;
    GLboolean ARB_shader_objects;
    GLboolean ARB_shading_language_100;
    GLboolean ARB_shading_language_120;
    GLboolean ARB_shadow;
+   GLboolean ARB_shadow_ambient; /* or GL_ARB_shadow_ambient */
+   GLboolean ARB_sync;
    GLboolean ARB_texture_border_clamp;
    GLboolean ARB_texture_compression;
    GLboolean ARB_texture_cube_map;
@@ -2551,6 +2507,7 @@ struct gl_extensions
    GLboolean ARB_texture_mirrored_repeat;
    GLboolean ARB_texture_non_power_of_two;
    GLboolean ARB_transpose_matrix;
+   GLboolean ARB_vertex_array_object;
    GLboolean ARB_vertex_buffer_object;
    GLboolean ARB_vertex_program;
    GLboolean ARB_vertex_shader;
@@ -2582,6 +2539,7 @@ struct gl_extensions
    GLboolean EXT_pixel_buffer_object;
    GLboolean EXT_point_parameters;
    GLboolean EXT_polygon_offset;
+   GLboolean EXT_provoking_vertex;
    GLboolean EXT_rescale_normal;
    GLboolean EXT_shadow_funcs;
    GLboolean EXT_secondary_color;
@@ -2601,13 +2559,16 @@ struct gl_extensions
    GLboolean EXT_texture_lod_bias;
    GLboolean EXT_texture_mirror_clamp;
    GLboolean EXT_texture_sRGB;
+   GLboolean EXT_texture_swizzle;
    GLboolean EXT_timer_query;
    GLboolean EXT_vertex_array;
+   GLboolean EXT_vertex_array_bgra;
    GLboolean EXT_vertex_array_set;
    /* vendor extensions */
    GLboolean APPLE_client_storage;
    GLboolean APPLE_packed_pixels;
    GLboolean APPLE_vertex_array_object;
+   GLboolean ATI_envmap_bumpmap;
    GLboolean ATI_texture_mirror_once;
    GLboolean ATI_texture_env_combine3;
    GLboolean ATI_fragment_shader;
@@ -2616,15 +2577,16 @@ struct gl_extensions
    GLboolean IBM_multimode_draw_arrays;
    GLboolean MESA_pack_invert;
    GLboolean MESA_packed_depth_stencil;
-   GLboolean MESA_program_debug;
    GLboolean MESA_resize_buffers;
    GLboolean MESA_ycbcr_texture;
    GLboolean MESA_texture_array;
+   GLboolean MESA_texture_signed_rgba;
    GLboolean NV_blend_square;
    GLboolean NV_fragment_program;
    GLboolean NV_light_max_exponent;
    GLboolean NV_point_sprite;
    GLboolean NV_texgen_reflection;
+   GLboolean NV_texture_env_combine4;
    GLboolean NV_texture_rectangle;
    GLboolean NV_vertex_program;
    GLboolean NV_vertex_program1_1;
@@ -2635,12 +2597,15 @@ struct gl_extensions
    GLboolean SGIS_generate_mipmap;
    GLboolean SGIS_texture_edge_clamp;
    GLboolean SGIS_texture_lod;
-   GLboolean SGIX_shadow;
-   GLboolean SGIX_shadow_ambient; /* or GL_ARB_shadow_ambient */
    GLboolean TDFX_texture_compression_FXT1;
    GLboolean S3_s3tc;
-   /*@}*/
-   /* The extension string */
+#if FEATURE_OES_draw_texture
+   GLboolean OES_draw_texture;
+#endif /* FEATURE_OES_draw_texture */
+#if FEATURE_OES_EGL_image
+   GLboolean OES_EGL_image;
+#endif
+   /** The extension string */
    const GLubyte *String;
 };
 
@@ -2660,7 +2625,6 @@ struct gl_matrix_stack
 
 /**
  * \name Bits for image transfer operations 
- *
  * \sa __GLcontextRec::ImageTransferState.
  */
 /*@{*/
@@ -2675,7 +2639,7 @@ struct gl_matrix_stack
 #define IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT   0x100
 #define IMAGE_HISTOGRAM_BIT                       0x200
 #define IMAGE_MIN_MAX_BIT                         0x400
-#define IMAGE_CLAMP_BIT                           0x800 /* extra */
+#define IMAGE_CLAMP_BIT                           0x800
 
 
 /** Pixel Transfer ops up to convolution */
@@ -2728,6 +2692,9 @@ struct gl_matrix_stack
 #define _NEW_MULTISAMPLE        0x2000000  /**< __GLcontextRec::Multisample */
 #define _NEW_TRACK_MATRIX       0x4000000  /**< __GLcontextRec::VertexProgram */
 #define _NEW_PROGRAM            0x8000000  /**< __GLcontextRec::VertexProgram */
+#define _NEW_CURRENT_ATTRIB     0x10000000  /**< __GLcontextRec::Current */
+#define _NEW_PROGRAM_CONSTANTS  0x20000000
+#define _NEW_BUFFER_OBJECT      0x40000000
 #define _NEW_ALL ~0
 /*@}*/
 
@@ -2810,6 +2777,10 @@ struct gl_matrix_stack
 /*@}*/
 
 
+/**
+ * Composite state flags
+ */
+/*@{*/
 #define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\
                                            _NEW_TEXTURE |	\
                                            _NEW_POINT |		\
@@ -2819,17 +2790,12 @@ struct gl_matrix_stack
 #define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\
                                            _NEW_TEXTURE)
 
-#define _IMAGE_NEW_TRANSFER_STATE         (_NEW_PIXEL | _NEW_COLOR_MATRIX)
-
+#define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL |		\
+                                           _NEW_COLOR_MATRIX)
+/*@}*/
 
 
 
-/*
- * Forward declaration of display list data types:
- */
-union node;
-typedef union node Node;
-
 
 /* This has to be included here. */
 #include "dd.h"
@@ -2860,21 +2826,31 @@ struct gl_tnl_module
    /*@}*/
 };
 
-/* Strictly this is a tnl/ private concept, but it doesn't seem
+
+/**
+ * Display list flags.
+ * Strictly this is a tnl-private concept, but it doesn't seem
  * worthwhile adding a tnl private structure just to hold this one bit
  * of information:
  */
-#define MESA_DLIST_DANGLING_REFS     0x1 
+#define DLIST_DANGLING_REFS     0x1 
+
 
-/* Provide a location where information about a display list can be
+/** Opaque declaration of display list payload data type */
+union gl_dlist_node;
+
+
+/**
+ * Provide a location where information about a display list can be
  * collected.  Could be extended with driverPrivate structures,
  * etc. in the future.
  */
-struct mesa_display_list
+struct gl_display_list
 {
-   Node *node;
-   GLuint id;
-   GLbitfield flags;
+   GLuint Name;
+   GLbitfield Flags;  /**< DLIST_x flags */
+   /** The dlist commands are in a linked list of nodes */
+   union gl_dlist_node *Head;
 };
 
 
@@ -2885,10 +2861,8 @@ struct gl_dlist_state
 {
    GLuint CallDepth;		/**< Current recursion calling depth */
 
-   struct mesa_display_list *CurrentList;
-   Node *CurrentListPtr;	/**< Head of list being compiled */
-   GLuint CurrentListNum;	/**< Number of the list being compiled */
-   Node *CurrentBlock;		/**< Pointer to current block of nodes */
+   struct gl_display_list *CurrentList; /**< List currently being compiled */
+   union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */
    GLuint CurrentPos;		/**< Index into current block of nodes */
 
    GLvertexformat ListVtxfmt;
@@ -2904,6 +2878,13 @@ struct gl_dlist_state
    
    GLubyte ActiveEdgeFlag;
    GLboolean CurrentEdgeFlag;
+
+   struct {
+      /* State known to have been set by the currently-compiling display
+       * list.  Used to eliminate some redundant state changes.
+       */
+      GLenum ShadeModel;
+   } Current;
 };
 
 
@@ -3030,31 +3011,41 @@ struct __GLcontextRec
 
    struct gl_color_table ColorTable[COLORTABLE_MAX];
    struct gl_color_table ProxyColorTable[COLORTABLE_MAX];
-#if 0
-   struct gl_color_table PostConvolutionColorTable;
-   struct gl_color_table ProxyPostConvolutionColorTable;
-   struct gl_color_table PostColorMatrixColorTable;
-   struct gl_color_table ProxyPostColorMatrixColorTable;
-#endif
-
-   struct gl_program_state Program;        /**< for vertex or fragment progs */
-   struct gl_vertex_program_state VertexProgram;   /**< GL_ARB/NV_vertex_program */
-   struct gl_fragment_program_state FragmentProgram;  /**< GL_ARB/NV_vertex_program */
-   struct gl_ati_fragment_shader_state ATIFragmentShader;  /**< GL_ATI_fragment_shader */
 
-   struct gl_query_state Query;  /**< GL_ARB_occlusion_query */
+   struct gl_program_state Program;  /**< general program state */
+   struct gl_vertex_program_state VertexProgram;
+   struct gl_fragment_program_state FragmentProgram;
+   struct gl_ati_fragment_shader_state ATIFragmentShader;
 
    struct gl_shader_state Shader; /**< GLSL shader object state */
+
+   struct gl_query_state Query;  /**< occlusion, timer queries */
+
+   struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */
+   struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */
    /*@}*/
 
+   struct gl_meta_state *Meta;  /**< for "meta" operations */
+
 #if FEATURE_EXT_framebuffer_object
    struct gl_renderbuffer *CurrentRenderbuffer;
 #endif
 
    GLenum ErrorValue;        /**< Last error code */
+
+   /**
+    * Recognize and silence repeated error debug messages in buggy apps.
+    */
+   const char *ErrorDebugFmtString;
+   GLuint ErrorDebugCount;
+
    GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
    GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */
 
+   GLboolean ViewportInitialized;  /**< has viewport size been initialized? */
+
+   GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */
+
    /** \name Derived state */
    /*@{*/
    /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before
@@ -3066,9 +3057,8 @@ struct __GLcontextRec
    GLfloat _ModelViewInvScale;
    GLboolean _NeedEyeCoords;
    GLboolean _ForceEyeCoords; 
-   GLenum _CurrentProgram;    /* currently executing program */
 
-   GLuint TextureStateTimestamp; /* detect changes to shared state */
+   GLuint TextureStateTimestamp; /**< detect changes to shared state */
 
    struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */
    struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */
@@ -3087,6 +3077,12 @@ struct __GLcontextRec
    /** software compression/decompression supported or not */
    GLboolean Mesa_DXTn;
 
+   /** 
+    * Use dp4 (rather than mul/mad) instructions for position
+    * transformation?
+    */
+   GLboolean mvp_with_dp4;
+
    /** Core tnl module support */
    struct gl_tnl_module TnlModule;
 
@@ -3100,7 +3096,7 @@ struct __GLcontextRec
    void *swsetup_context;
    void *swtnl_context;
    void *swtnl_im;
-   void *acache_context;
+   struct st_context *st;
    void *aelt_context;
    /*@}*/
 };
@@ -3138,8 +3134,6 @@ enum _verbose
    VERBOSE_PRIMS		= 0x0400,
    VERBOSE_VERTS		= 0x0800,
    VERBOSE_DISASSEM		= 0x1000,
-   VERBOSE_GLSL			= 0x2000,
-   VERBOSE_GLSL_DUMP		= 0x4000
 };
 
 
@@ -3150,7 +3144,4 @@ enum _debug
 
 
 
-#define Elements(x) sizeof(x)/sizeof(*(x))
-
-
-#endif /* TYPES_H */
+#endif /* MTYPES_H */
diff --git a/src/mesa/main/multisample.c b/src/mesa/main/multisample.c
index b9cfad9216..01b68df7af 100644
--- a/src/mesa/main/multisample.c
+++ b/src/mesa/main/multisample.c
@@ -37,11 +37,6 @@ _mesa_SampleCoverageARB(GLclampf value, GLboolean invert)
 {
    GET_CURRENT_CONTEXT(ctx);
 
-   if (!ctx->Extensions.ARB_multisample) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glSampleCoverageARB");
-      return;
-   }
-
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
 
    ctx->Multisample.SampleCoverageValue = (GLfloat) CLAMP(value, 0.0, 1.0);
diff --git a/src/mesa/main/pixel.c b/src/mesa/main/pixel.c
index 8d24a201f0..23a5c9b9f7 100644
--- a/src/mesa/main/pixel.c
+++ b/src/mesa/main/pixel.c
@@ -36,6 +36,10 @@
 #include "macros.h"
 #include "pixel.h"
 #include "mtypes.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_pixel_transfer
 
 
 /**********************************************************************/
@@ -136,6 +140,33 @@ store_pixelmap(GLcontext *ctx, GLenum map, GLsizei mapsize,
 }
 
 
+/**
+ * Convenience wrapper for _mesa_validate_pbo_access() for gl[Get]PixelMap().
+ */
+static GLboolean
+validate_pbo_access(GLcontext *ctx, struct gl_pixelstore_attrib *pack,
+                    GLsizei mapsize, GLenum format, GLenum type,
+                    const GLvoid *ptr)
+{
+   GLboolean ok;
+
+   /* Note, need to use DefaultPacking and Unpack's buffer object */
+   ctx->DefaultPacking.BufferObj = pack->BufferObj;
+
+   ok = _mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
+                                  format, type, ptr);
+
+   /* restore */
+   ctx->DefaultPacking.BufferObj = ctx->Shared->NullBufferObj;
+
+   if (!ok) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glPixelMap(invalid PBO access)");
+   }
+   return ok;
+}
+
+
 void GLAPIENTRY
 _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
 {
@@ -158,40 +189,23 @@ _mesa_PixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
 
    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack pixelmap from PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Unpack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_FLOAT, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapfv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
+                            GL_INTENSITY, GL_FLOAT, values)) {
+      return;
+   }
+
+   values = (const GLfloat *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glPixelMapfv(PBO is mapped)");
-         return;
       }
-      values = (const GLfloat *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
    store_pixelmap(ctx, map, mapsize, values);
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 }
 
 
@@ -217,31 +231,17 @@ _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
 
    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack pixelmap from PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Unpack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_UNSIGNED_INT, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapuiv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
+                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {
+      return;
+   }
+
+   values = (const GLuint *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glPixelMapuiv(PBO is mapped)");
-         return;
       }
-      values = (const GLuint *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
@@ -259,10 +259,7 @@ _mesa_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values )
       }
    }
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 
    store_pixelmap(ctx, map, mapsize, fvalues);
 }
@@ -290,32 +287,17 @@ _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
 
    FLUSH_VERTICES(ctx, _NEW_PIXEL);
 
-   if (ctx->Unpack.BufferObj->Name) {
-      /* unpack pixelmap from PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Unpack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Unpack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_UNSIGNED_SHORT,
-                                     values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPixelMapusv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Unpack, mapsize,
+                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {
+      return;
+   }
+
+   values = (const GLushort *) _mesa_map_pbo_source(ctx, &ctx->Unpack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Unpack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glPixelMapusv(PBO is mapped)");
-         return;
       }
-      values = (const GLushort *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
@@ -333,10 +315,7 @@ _mesa_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values )
       }
    }
 
-   if (ctx->Unpack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 
    store_pixelmap(ctx, map, mapsize, fvalues);
 }
@@ -359,31 +338,17 @@ _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
 
    mapsize = pm->Size;
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack pixelmap into PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Pack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_FLOAT, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapfv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
+                            GL_INTENSITY, GL_FLOAT, values)) {
+      return;
+   }
+
+   values = (GLfloat *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glGetPixelMapfv(PBO is mapped)");
-         return;
       }
-      values = (GLfloat *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
@@ -397,10 +362,7 @@ _mesa_GetPixelMapfv( GLenum map, GLfloat *values )
       MEMCPY(values, pm->Map, mapsize * sizeof(GLfloat));
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
@@ -420,31 +382,17 @@ _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
    }
    mapsize = pm->Size;
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack pixelmap into PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Pack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_UNSIGNED_INT, values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapuiv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
+                            GL_INTENSITY, GL_UNSIGNED_INT, values)) {
+      return;
+   }
+
+   values = (GLuint *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glGetPixelMapuiv(PBO is mapped)");
-         return;
       }
-      values = (GLuint *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
@@ -458,10 +406,7 @@ _mesa_GetPixelMapuiv( GLenum map, GLuint *values )
       }
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
@@ -481,32 +426,17 @@ _mesa_GetPixelMapusv( GLenum map, GLushort *values )
    }
    mapsize = pm ? pm->Size : 0;
 
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack pixelmap into PBO */
-      GLubyte *buf;
-      /* Note, need to use DefaultPacking and Pack's buffer object */
-      ctx->DefaultPacking.BufferObj = ctx->Pack.BufferObj;
-      if (!_mesa_validate_pbo_access(1, &ctx->DefaultPacking, mapsize, 1, 1,
-                                     GL_INTENSITY, GL_UNSIGNED_SHORT,
-                                     values)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPixelMapusv(invalid PBO access)");
-         return;
-      }
-      /* restore */
-      ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
+   if (!validate_pbo_access(ctx, &ctx->Pack, mapsize,
+                            GL_INTENSITY, GL_UNSIGNED_SHORT, values)) {
+      return;
+   }
+
+   values = (GLushort *) _mesa_map_pbo_dest(ctx, &ctx->Pack, values);
+   if (!values) {
+      if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "glGetPixelMapusv(PBO is mapped)");
-         return;
       }
-      values = (GLushort *) ADD_POINTERS(buf, values);
-   }
-   else if (!values) {
       return;
    }
 
@@ -528,10 +458,7 @@ _mesa_GetPixelMapusv( GLenum map, GLushort *values )
       }
    }
 
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
@@ -819,7 +746,7 @@ update_image_transfer_state(GLcontext *ctx)
 
 
 /**
- * Update meas pixel transfer derived state.
+ * Update mesa pixel transfer derived state.
  */
 void _mesa_update_pixel( GLcontext *ctx, GLuint new_state )
 {
@@ -828,11 +755,29 @@ void _mesa_update_pixel( GLcontext *ctx, GLuint new_state )
 
    /* References ColorMatrix.type (derived above).
     */
-   if (new_state & _IMAGE_NEW_TRANSFER_STATE)
+   if (new_state & _MESA_NEW_TRANSFER_STATE)
       update_image_transfer_state(ctx);
 }
 
 
+void 
+_mesa_init_pixel_dispatch(struct _glapi_table *disp)
+{
+   SET_GetPixelMapfv(disp, _mesa_GetPixelMapfv);
+   SET_GetPixelMapuiv(disp, _mesa_GetPixelMapuiv);
+   SET_GetPixelMapusv(disp, _mesa_GetPixelMapusv);
+   SET_PixelMapfv(disp, _mesa_PixelMapfv);
+   SET_PixelMapuiv(disp, _mesa_PixelMapuiv);
+   SET_PixelMapusv(disp, _mesa_PixelMapusv);
+   SET_PixelTransferf(disp, _mesa_PixelTransferf);
+   SET_PixelTransferi(disp, _mesa_PixelTransferi);
+   SET_PixelZoom(disp, _mesa_PixelZoom);
+}
+
+
+#endif /* FEATURE_pixel_transfer */
+
+
 /**********************************************************************/
 /*****                      Initialization                        *****/
 /**********************************************************************/
diff --git a/src/mesa/main/pixel.h b/src/mesa/main/pixel.h
index cb6c5262a3..7a901aec10 100644
--- a/src/mesa/main/pixel.h
+++ b/src/mesa/main/pixel.h
@@ -33,9 +33,11 @@
 #define PIXEL_H
 
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
 
+#if FEATURE_pixel_transfer
+
 /** \name API functions */
 /*@{*/
 
@@ -68,13 +70,30 @@ _mesa_PixelZoom( GLfloat xfactor, GLfloat yfactor );
 
 /*@}*/
 
-
 extern void 
 _mesa_update_pixel( GLcontext *ctx, GLuint newstate );
 
 extern void 
+_mesa_init_pixel_dispatch( struct _glapi_table * disp );
+
+#else /* FEATURE_pixel_transfer */
+
+static INLINE void
+_mesa_update_pixel(GLcontext *ctx, GLuint newstate)
+{
+}
+
+static INLINE void
+_mesa_init_pixel_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_pixel_transfer */
+
+
+extern void 
 _mesa_init_pixel( GLcontext * ctx );
 
 /*@}*/
 
-#endif
+#endif /* PIXEL_H */
diff --git a/src/mesa/main/pixelstore.c b/src/mesa/main/pixelstore.c
index ff1a6344cc..6a641f83f2 100644
--- a/src/mesa/main/pixelstore.c
+++ b/src/mesa/main/pixelstore.c
@@ -245,7 +245,8 @@ _mesa_init_pixelstore( GLcontext *ctx )
    ctx->Pack.ClientStorage = GL_FALSE;
    ctx->Pack.Invert = GL_FALSE;
 #if FEATURE_EXT_pixel_buffer_object
-   ctx->Pack.BufferObj = ctx->Array.NullBufferObj;
+   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj,
+                                 ctx->Shared->NullBufferObj);
 #endif
    ctx->Unpack.Alignment = 4;
    ctx->Unpack.RowLength = 0;
@@ -258,7 +259,8 @@ _mesa_init_pixelstore( GLcontext *ctx )
    ctx->Unpack.ClientStorage = GL_FALSE;
    ctx->Unpack.Invert = GL_FALSE;
 #if FEATURE_EXT_pixel_buffer_object
-   ctx->Unpack.BufferObj = ctx->Array.NullBufferObj;
+   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj,
+                                 ctx->Shared->NullBufferObj);
 #endif
 
    /*
@@ -278,6 +280,7 @@ _mesa_init_pixelstore( GLcontext *ctx )
    ctx->DefaultPacking.ClientStorage = GL_FALSE;
    ctx->DefaultPacking.Invert = GL_FALSE;
 #if FEATURE_EXT_pixel_buffer_object
-   ctx->DefaultPacking.BufferObj = ctx->Array.NullBufferObj;
+   _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj,
+                                 ctx->Shared->NullBufferObj);
 #endif
 }
diff --git a/src/mesa/main/polygon.c b/src/mesa/main/polygon.c
index 564250b881..376a87a396 100644
--- a/src/mesa/main/polygon.c
+++ b/src/mesa/main/polygon.c
@@ -193,32 +193,16 @@ _mesa_PolygonMode( GLenum face, GLenum mode )
 void
 _mesa_polygon_stipple(GLcontext *ctx, const GLubyte *pattern)
 {
-   if (ctx->Unpack.BufferObj->Name) {
-      /* Get/unpack the stipple pattern from a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(2, &ctx->Unpack, 32, 32, 1,
-                                     GL_COLOR_INDEX, GL_BITMAP, pattern)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPolygonStipple(bad PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                                              GL_READ_ONLY_ARB,
-                                              ctx->Unpack.BufferObj);
-      if (!buf) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glPolygonStipple(PBO mapped)");
-         return;
-      }
-      buf = ADD_POINTERS(buf, pattern);
-      _mesa_unpack_polygon_stipple(buf, ctx->PolygonStipple, &ctx->Unpack);
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
-                              ctx->Unpack.BufferObj);
-   }
-   else {
-      /* Get/unpack the stipple pattern from user memory */
-      _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);
-   }
+   pattern = _mesa_map_validate_pbo_source(ctx, 2,
+                                           &ctx->Unpack, 32, 32, 1,
+                                           GL_COLOR_INDEX, GL_BITMAP, pattern,
+                                           "glPolygonStipple");
+   if (!pattern)
+      return;
+
+   _mesa_unpack_polygon_stipple(pattern, ctx->PolygonStipple, &ctx->Unpack);
+
+   _mesa_unmap_pbo_source(ctx, &ctx->Unpack);
 }
 
 
@@ -255,35 +239,16 @@ _mesa_GetPolygonStipple( GLubyte *dest )
    if (MESA_VERBOSE&VERBOSE_API)
       _mesa_debug(ctx, "glGetPolygonStipple\n");
 
-   /* XXX someday we may put this code into a separate function and call
-    * it with ctx->Driver.GetPolygonStipple().
-    */
-   if (ctx->Pack.BufferObj->Name) {
-      /* Put/pack the stipple pattern into a PBO */
-      GLubyte *buf;
-      if (!_mesa_validate_pbo_access(2, &ctx->Pack, 32, 32, 1,
-                                     GL_COLOR_INDEX, GL_BITMAP, dest)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPolygonStipple(bad PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetPolygonStipple(PBO mapped)");
-         return;
-      }
-      buf = ADD_POINTERS(buf, dest);
-      _mesa_pack_polygon_stipple(ctx->PolygonStipple, buf, &ctx->Pack);
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
-   else {
-      /* Put/pack the stipple pattern into user memory */
-      _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack);
-   }
+   dest = _mesa_map_validate_pbo_dest(ctx, 2,
+                                      &ctx->Pack, 32, 32, 1,
+                                      GL_COLOR_INDEX, GL_BITMAP, dest,
+                                      "glGetPolygonStipple");
+   if (!dest)
+      return;
+
+   _mesa_pack_polygon_stipple(ctx->PolygonStipple, dest, &ctx->Pack);
+
+   _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
 
 
diff --git a/src/mesa/main/queryobj.c b/src/mesa/main/queryobj.c
index 554e0b0d18..3cadaba9f3 100644
--- a/src/mesa/main/queryobj.c
+++ b/src/mesa/main/queryobj.c
@@ -29,6 +29,10 @@
 #include "imports.h"
 #include "queryobj.h"
 #include "mtypes.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_queryobj
 
 
 /**
@@ -38,7 +42,7 @@
  * \param id - the new object's ID
  * \return pointer to new query_object object or NULL if out of memory.
  */
-struct gl_query_object *
+static struct gl_query_object *
 _mesa_new_query_object(GLcontext *ctx, GLuint id)
 {
    struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);
@@ -57,7 +61,7 @@ _mesa_new_query_object(GLcontext *ctx, GLuint id)
  * Begin a query.  Software driver fallback.
  * Called via ctx->Driver.BeginQuery().
  */
-void
+static void
 _mesa_begin_query(GLcontext *ctx, struct gl_query_object *q)
 {
    /* no-op */
@@ -68,7 +72,7 @@ _mesa_begin_query(GLcontext *ctx, struct gl_query_object *q)
  * End a query.  Software driver fallback.
  * Called via ctx->Driver.EndQuery().
  */
-void
+static void
 _mesa_end_query(GLcontext *ctx, struct gl_query_object *q)
 {
    q->Ready = GL_TRUE;
@@ -79,21 +83,35 @@ _mesa_end_query(GLcontext *ctx, struct gl_query_object *q)
  * Wait for query to complete.  Software driver fallback.
  * Called via ctx->Driver.WaitQuery().
  */
-void
+static void
 _mesa_wait_query(GLcontext *ctx, struct gl_query_object *q)
 {
    /* For software drivers, _mesa_end_query() should have completed the query.
-    * For real hardware, implement a proper WaitQuery() driver function.
+    * For real hardware, implement a proper WaitQuery() driver function,
+    * which may require issuing a flush.
     */
    assert(q->Ready);
 }
 
 
 /**
+ * Check if a query results are ready.  Software driver fallback.
+ * Called via ctx->Driver.CheckQuery().
+ */
+static void
+_mesa_check_query(GLcontext *ctx, struct gl_query_object *q)
+{
+   /* No-op for sw rendering.
+    * HW drivers may need to flush at this time.
+    */
+}
+
+
+/**
  * Delete a query object.  Called via ctx->Driver.DeleteQuery().
  * Not removed from hash table here.
  */
-void
+static void
 _mesa_delete_query(GLcontext *ctx, struct gl_query_object *q)
 {
    _mesa_free(q);
@@ -109,6 +127,18 @@ lookup_query_object(GLcontext *ctx, GLuint id)
 
 
 
+void
+_mesa_init_query_object_functions(struct dd_function_table *driver)
+{
+   driver->NewQueryObject = _mesa_new_query_object;
+   driver->DeleteQuery = _mesa_delete_query;
+   driver->BeginQuery = _mesa_begin_query;
+   driver->EndQuery = _mesa_end_query;
+   driver->WaitQuery = _mesa_wait_query;
+   driver->CheckQuery = _mesa_check_query;
+}
+
+
 void GLAPIENTRY
 _mesa_GenQueriesARB(GLsizei n, GLuint *ids)
 {
@@ -210,7 +240,6 @@ _mesa_BeginQueryARB(GLenum target, GLuint id)
             return;
          }
          break;
-#if FEATURE_EXT_timer_query
       case GL_TIME_ELAPSED_EXT:
          if (!ctx->Extensions.EXT_timer_query) {
             _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");
@@ -221,7 +250,6 @@ _mesa_BeginQueryARB(GLenum target, GLuint id)
             return;
          }
          break;
-#endif
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");
          return;
@@ -259,11 +287,9 @@ _mesa_BeginQueryARB(GLenum target, GLuint id)
    if (target == GL_SAMPLES_PASSED_ARB) {
       ctx->Query.CurrentOcclusionObject = q;
    }
-#if FEATURE_EXT_timer_query
    else if (target == GL_TIME_ELAPSED_EXT) {
       ctx->Query.CurrentTimerObject = q;
    }
-#endif
 
    ctx->Driver.BeginQuery(ctx, q);
 }
@@ -287,7 +313,6 @@ _mesa_EndQueryARB(GLenum target)
          q = ctx->Query.CurrentOcclusionObject;
          ctx->Query.CurrentOcclusionObject = NULL;
          break;
-#if FEATURE_EXT_timer_query
       case GL_TIME_ELAPSED_EXT:
          if (!ctx->Extensions.EXT_timer_query) {
             _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
@@ -296,7 +321,6 @@ _mesa_EndQueryARB(GLenum target)
          q = ctx->Query.CurrentTimerObject;
          ctx->Query.CurrentTimerObject = NULL;
          break;
-#endif
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
          return;
@@ -328,7 +352,6 @@ _mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)
          }
          q = ctx->Query.CurrentOcclusionObject;
          break;
-#if FEATURE_EXT_timer_query
       case GL_TIME_ELAPSED_EXT:
          if (!ctx->Extensions.EXT_timer_query) {
             _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
@@ -336,7 +359,6 @@ _mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)
          }
          q = ctx->Query.CurrentTimerObject;
          break;
-#endif
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(target)");
          return;
@@ -436,8 +458,6 @@ _mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
 }
 
 
-#if FEATURE_EXT_timer_query
-
 /**
  * New with GL_EXT_timer_query
  */
@@ -511,19 +531,35 @@ _mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)
    }
 }
 
-#endif /* FEATURE_EXT_timer_query */
+
+void
+_mesa_init_queryobj_dispatch(struct _glapi_table *disp)
+{
+   SET_GenQueriesARB(disp, _mesa_GenQueriesARB);
+   SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);
+   SET_IsQueryARB(disp, _mesa_IsQueryARB);
+   SET_BeginQueryARB(disp, _mesa_BeginQueryARB);
+   SET_EndQueryARB(disp, _mesa_EndQueryARB);
+   SET_GetQueryivARB(disp, _mesa_GetQueryivARB);
+   SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);
+   SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);
+
+   SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);
+   SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);
+}
+
+
+#endif /* FEATURE_queryobj */
 
 
 /**
  * Allocate/init the context state related to query objects.
  */
 void
-_mesa_init_query(GLcontext *ctx)
+_mesa_init_queryobj(GLcontext *ctx)
 {
-#if FEATURE_ARB_occlusion_query
    ctx->Query.QueryObjects = _mesa_NewHashTable();
    ctx->Query.CurrentOcclusionObject = NULL;
-#endif
 }
 
 
@@ -543,7 +579,7 @@ delete_queryobj_cb(GLuint id, void *data, void *userData)
  * Free the context state related to query objects.
  */
 void
-_mesa_free_query_data(GLcontext *ctx)
+_mesa_free_queryobj_data(GLcontext *ctx)
 {
    _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);
    _mesa_DeleteHashTable(ctx->Query.QueryObjects);
diff --git a/src/mesa/main/queryobj.h b/src/mesa/main/queryobj.h
index 9a9774641b..861e6ba566 100644
--- a/src/mesa/main/queryobj.h
+++ b/src/mesa/main/queryobj.h
@@ -23,31 +23,24 @@
  */
 
 
-#ifndef OCCLUDE_H
-#define OCCLUDE_H
+#ifndef QUERYOBJ_H
+#define QUERYOBJ_H
 
 
-extern struct gl_query_object *
-_mesa_new_query_object(GLcontext *ctx, GLuint id);
+#include "main/mtypes.h"
 
-extern void
-_mesa_init_query(GLcontext *ctx);
-
-extern void
-_mesa_free_query_data(GLcontext *ctx);
-
-extern void
-_mesa_delete_query(GLcontext *ctx, struct gl_query_object *q);
-
-extern void
-_mesa_begin_query(GLcontext *ctx, struct gl_query_object *q);
-
-extern void
-_mesa_end_query(GLcontext *ctx, struct gl_query_object *q);
 
-extern void
-_mesa_wait_query(GLcontext *ctx, struct gl_query_object *q);
+#if FEATURE_queryobj
 
+#define _MESA_INIT_QUERYOBJ_FUNCTIONS(driver, impl)      \
+   do {                                                  \
+      (driver)->NewQueryObject = impl ## NewQueryObject; \
+      (driver)->DeleteQuery    = impl ## DeleteQuery;    \
+      (driver)->BeginQuery     = impl ## BeginQuery;     \
+      (driver)->EndQuery       = impl ## EndQuery;       \
+      (driver)->WaitQuery      = impl ## WaitQuery;      \
+      (driver)->CheckQuery     = impl ## CheckQuery;     \
+   } while (0)
 
 extern void GLAPIENTRY
 _mesa_GenQueriesARB(GLsizei n, GLuint *ids);
@@ -79,5 +72,33 @@ _mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params);
 extern void GLAPIENTRY
 _mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params);
 
+extern void
+_mesa_init_query_object_functions(struct dd_function_table *driver);
+
+extern void
+_mesa_init_queryobj_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_queryobj */
+
+#define _MESA_INIT_QUERYOBJ_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void
+_mesa_init_query_object_functions(struct dd_function_table *driver)
+{
+}
+
+static INLINE void
+_mesa_init_queryobj_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_queryobj */
+
+extern void
+_mesa_init_queryobj(GLcontext *ctx);
+
+extern void
+_mesa_free_queryobj_data(GLcontext *ctx);
+
 
-#endif /* OCCLUDE_H */
+#endif /* QUERYOBJ_H */
diff --git a/src/mesa/main/rastpos.c b/src/mesa/main/rastpos.c
index 9f309d6ab8..77eb84103f 100644
--- a/src/mesa/main/rastpos.c
+++ b/src/mesa/main/rastpos.c
@@ -34,6 +34,10 @@
 #include "macros.h"
 #include "rastpos.h"
 #include "state.h"
+#include "glapi/dispatch.h"
+
+
+#if FEATURE_rastpos
 
 
 /**
@@ -211,7 +215,7 @@ _mesa_RasterPos4sv(const GLshort *v)
 /***           GL_ARB_window_pos / GL_MESA_window_pos               ***/
 /**********************************************************************/
 
-#if FEATURE_drawpix
+
 /**
  * All glWindowPosMESA and glWindowPosARB commands call this function to
  * update the current raster position.
@@ -436,7 +440,6 @@ _mesa_WindowPos4svMESA(const GLshort *v)
    window_pos4f(v[0], v[1], v[2], v[3]);
 }
 
-#endif
 
 #if 0
 
@@ -477,6 +480,65 @@ void glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
 #endif
 
 
+void 
+_mesa_init_rastpos_dispatch(struct _glapi_table *disp)
+{
+   SET_RasterPos2f(disp, _mesa_RasterPos2f);
+   SET_RasterPos2fv(disp, _mesa_RasterPos2fv);
+   SET_RasterPos2i(disp, _mesa_RasterPos2i);
+   SET_RasterPos2iv(disp, _mesa_RasterPos2iv);
+   SET_RasterPos2d(disp, _mesa_RasterPos2d);
+   SET_RasterPos2dv(disp, _mesa_RasterPos2dv);
+   SET_RasterPos2s(disp, _mesa_RasterPos2s);
+   SET_RasterPos2sv(disp, _mesa_RasterPos2sv);
+   SET_RasterPos3d(disp, _mesa_RasterPos3d);
+   SET_RasterPos3dv(disp, _mesa_RasterPos3dv);
+   SET_RasterPos3f(disp, _mesa_RasterPos3f);
+   SET_RasterPos3fv(disp, _mesa_RasterPos3fv);
+   SET_RasterPos3i(disp, _mesa_RasterPos3i);
+   SET_RasterPos3iv(disp, _mesa_RasterPos3iv);
+   SET_RasterPos3s(disp, _mesa_RasterPos3s);
+   SET_RasterPos3sv(disp, _mesa_RasterPos3sv);
+   SET_RasterPos4d(disp, _mesa_RasterPos4d);
+   SET_RasterPos4dv(disp, _mesa_RasterPos4dv);
+   SET_RasterPos4f(disp, _mesa_RasterPos4f);
+   SET_RasterPos4fv(disp, _mesa_RasterPos4fv);
+   SET_RasterPos4i(disp, _mesa_RasterPos4i);
+   SET_RasterPos4iv(disp, _mesa_RasterPos4iv);
+   SET_RasterPos4s(disp, _mesa_RasterPos4s);
+   SET_RasterPos4sv(disp, _mesa_RasterPos4sv);
+
+   /* 197. GL_MESA_window_pos */
+   SET_WindowPos2dMESA(disp, _mesa_WindowPos2dMESA);
+   SET_WindowPos2dvMESA(disp, _mesa_WindowPos2dvMESA);
+   SET_WindowPos2fMESA(disp, _mesa_WindowPos2fMESA);
+   SET_WindowPos2fvMESA(disp, _mesa_WindowPos2fvMESA);
+   SET_WindowPos2iMESA(disp, _mesa_WindowPos2iMESA);
+   SET_WindowPos2ivMESA(disp, _mesa_WindowPos2ivMESA);
+   SET_WindowPos2sMESA(disp, _mesa_WindowPos2sMESA);
+   SET_WindowPos2svMESA(disp, _mesa_WindowPos2svMESA);
+   SET_WindowPos3dMESA(disp, _mesa_WindowPos3dMESA);
+   SET_WindowPos3dvMESA(disp, _mesa_WindowPos3dvMESA);
+   SET_WindowPos3fMESA(disp, _mesa_WindowPos3fMESA);
+   SET_WindowPos3fvMESA(disp, _mesa_WindowPos3fvMESA);
+   SET_WindowPos3iMESA(disp, _mesa_WindowPos3iMESA);
+   SET_WindowPos3ivMESA(disp, _mesa_WindowPos3ivMESA);
+   SET_WindowPos3sMESA(disp, _mesa_WindowPos3sMESA);
+   SET_WindowPos3svMESA(disp, _mesa_WindowPos3svMESA);
+   SET_WindowPos4dMESA(disp, _mesa_WindowPos4dMESA);
+   SET_WindowPos4dvMESA(disp, _mesa_WindowPos4dvMESA);
+   SET_WindowPos4fMESA(disp, _mesa_WindowPos4fMESA);
+   SET_WindowPos4fvMESA(disp, _mesa_WindowPos4fvMESA);
+   SET_WindowPos4iMESA(disp, _mesa_WindowPos4iMESA);
+   SET_WindowPos4ivMESA(disp, _mesa_WindowPos4ivMESA);
+   SET_WindowPos4sMESA(disp, _mesa_WindowPos4sMESA);
+   SET_WindowPos4svMESA(disp, _mesa_WindowPos4svMESA);
+}
+
+
+#endif /* FEATURE_rastpos */
+
+
 /**********************************************************************/
 /** \name Initialization                                              */
 /**********************************************************************/
diff --git a/src/mesa/main/rastpos.h b/src/mesa/main/rastpos.h
index 363f86ad87..767d6f2677 100644
--- a/src/mesa/main/rastpos.h
+++ b/src/mesa/main/rastpos.h
@@ -32,9 +32,16 @@
 #define RASTPOS_H
 
 
-#include "glheader.h"
+#include "main/mtypes.h"
 
 
+#if FEATURE_rastpos
+
+#define _MESA_INIT_RASTPOS_FUNCTIONS(driver, impl) \
+   do {                                            \
+      (driver)->RasterPos = impl ## RasterPos;     \
+   } while (0)
+
 extern void GLAPIENTRY
 _mesa_RasterPos2d(GLdouble x, GLdouble y);
 
@@ -186,8 +193,22 @@ extern void GLAPIENTRY
 _mesa_WindowPos4svMESA(const GLshort *v);
 
 extern void 
-_mesa_init_rastpos( GLcontext * ctx );
+_mesa_init_rastpos_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_rastpos */
+
+#define _MESA_INIT_RASTPOS_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void 
+_mesa_init_rastpos_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_rastpos */
+
+extern void 
+_mesa_init_rastpos(GLcontext *ctx);
 
 /*@}*/
 
-#endif
+#endif /* RASTPOS_H */
diff --git a/src/mesa/main/readpix.c b/src/mesa/main/readpix.c
index dfdd297b6e..feea1d375f 100644
--- a/src/mesa/main/readpix.c
+++ b/src/mesa/main/readpix.c
@@ -44,6 +44,10 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type,
                               GLboolean drawing)
 {
    const char *readDraw = drawing ? "Draw" : "Read";
+   const GLboolean reading = !drawing;
+
+   /* state validation should have already been done */
+   ASSERT(ctx->NewState == 0x0);
 
    if (ctx->Extensions.EXT_packed_depth_stencil
        && type == GL_UNSIGNED_INT_24_8_EXT
@@ -73,32 +77,45 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type,
    case GL_RGBA:
    case GL_BGRA:
    case GL_ABGR_EXT:
-      if (drawing && !ctx->Visual.rgbMode) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
+      if (drawing) {
+         if (!ctx->DrawBuffer->Visual.rgbMode) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
                    "glDrawPixels(drawing RGB pixels into color index buffer)");
-         return GL_TRUE;
+            return GL_TRUE;
+         }
       }
-      if (!drawing && !_mesa_dest_buffer_exists(ctx, GL_COLOR)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glReadPixels(no color buffer)");
-         return GL_TRUE;
+      else {
+         /* reading */
+         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                        "glReadPixels(no color buffer)");
+            return GL_TRUE;
+         }
       }
       break;
    case GL_COLOR_INDEX:
-      if (!drawing && ctx->Visual.rgbMode) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                    "glReadPixels(reading color index format from RGB buffer)");
-         return GL_TRUE;
+      if (drawing) {
+         if (ctx->DrawBuffer->Visual.rgbMode &&
+             (ctx->PixelMaps.ItoR.Size == 0 ||
+              ctx->PixelMaps.ItoG.Size == 0 ||
+              ctx->PixelMaps.ItoB.Size == 0)) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                   "glDrawPixels(drawing color index pixels into RGB buffer)");
+            return GL_TRUE;
+         }
       }
-      if (!drawing && !_mesa_dest_buffer_exists(ctx, GL_COLOR)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glReadPixels(no color buffer)");
-         return GL_TRUE;
+      else {
+         /* reading */
+         if (!_mesa_source_buffer_exists(ctx, GL_COLOR)) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                        "glReadPixels(no color buffer)");
+            return GL_TRUE;
+         }
       }
       break;
    case GL_STENCIL_INDEX:
       if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
-          (!drawing && !_mesa_source_buffer_exists(ctx, format))) {
+          (reading && !_mesa_source_buffer_exists(ctx, format))) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "gl%sPixels(no stencil buffer)", readDraw);
          return GL_TRUE;
@@ -118,7 +135,7 @@ _mesa_error_check_format_type(GLcontext *ctx, GLenum format, GLenum type,
          return GL_TRUE;
       }
       if ((drawing && !_mesa_dest_buffer_exists(ctx, format)) ||
-          (!drawing && !_mesa_source_buffer_exists(ctx, format))) {
+          (reading && !_mesa_source_buffer_exists(ctx, format))) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "gl%sPixels(no depth or stencil buffer)", readDraw);
          return GL_TRUE;
@@ -170,7 +187,10 @@ _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
       return;
    }
 
-   if (ctx->Pack.BufferObj->Name) {
+   if (width == 0 || height == 0)
+      return; /* nothing to do */
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
       if (!_mesa_validate_pbo_access(2, &ctx->Pack, width, height, 1,
                                      format, type, pixels)) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
@@ -178,7 +198,7 @@ _mesa_ReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
          return;
       }
 
-      if (ctx->Pack.BufferObj->Pointer) {
+      if (_mesa_bufferobj_mapped(ctx->Pack.BufferObj)) {
          /* buffer is mapped - that's an error */
          _mesa_error(ctx, GL_INVALID_OPERATION, "glReadPixels(PBO is mapped)");
          return;
diff --git a/src/mesa/main/renderbuffer.c b/src/mesa/main/renderbuffer.c
index 6f1d7c3960..38be8266e0 100644
--- a/src/mesa/main/renderbuffer.c
+++ b/src/mesa/main/renderbuffer.c
@@ -1199,7 +1199,8 @@ _mesa_soft_renderbuffer_storage(GLcontext *ctx, struct gl_renderbuffer *rb,
 
    if (width > 0 && height > 0) {
       /* allocate new buffer storage */
-      rb->Data = _mesa_malloc(width * height * pixelSize);
+      rb->Data = malloc(width * height * pixelSize);
+
       if (rb->Data == NULL) {
          rb->Width = 0;
          rb->Height = 0;
@@ -1487,11 +1488,16 @@ _mesa_init_renderbuffer(struct gl_renderbuffer *rb, GLuint name)
    rb->InternalFormat = GL_NONE;
    rb->_ActualFormat = GL_NONE;
    rb->_BaseFormat = GL_NONE;
-   rb->DataType = GL_NONE;
+
+   rb->ComponentType = GL_UNSIGNED_NORMALIZED; /* ARB_fbo */
+   rb->ColorEncoding = GL_LINEAR; /* ARB_fbo */
+
    rb->RedBits = rb->GreenBits = rb->BlueBits = rb->AlphaBits = 0;
    rb->IndexBits = 0;
    rb->DepthBits = 0;
    rb->StencilBits = 0;
+
+   rb->DataType = GL_NONE;
    rb->Data = NULL;
 
    /* Point back to ourself so that we don't have to check for Wrapped==NULL
diff --git a/src/mesa/main/shaders.c b/src/mesa/main/shaders.c
index 7491d00c35..bc76b91291 100644
--- a/src/mesa/main/shaders.c
+++ b/src/mesa/main/shaders.c
@@ -374,6 +374,43 @@ _mesa_LinkProgramARB(GLhandleARB programObj)
 }
 
 
+
+/**
+ * Read shader source code from a file.
+ * Useful for debugging to override an app's shader.
+ */
+static GLcharARB *
+_mesa_read_shader(const char *fname)
+{
+   const int max = 50*1000;
+   FILE *f = fopen(fname, "r");
+   GLcharARB *buffer, *shader;
+   int len;
+
+   if (!f) {
+      _mesa_fprintf(stderr, "Unable to open shader file %s\n", fname);
+      return NULL;
+   }
+
+   buffer = (char *) malloc(max);
+   len = fread(buffer, 1, max, f);
+   buffer[len] = 0;
+
+   fclose(f);
+
+   shader = _mesa_strdup(buffer);
+   free(buffer);
+
+   if (0) {
+      _mesa_fprintf(stderr, "Read shader %s:\n", fname);
+      _mesa_fprintf(stderr, "%s\n", shader);
+   }
+
+   return shader;
+}
+
+
+
 /**
  * Called via glShaderSource() and glShaderSourceARB() API functions.
  * Basically, concatenate the source code strings into one long string
@@ -438,6 +475,20 @@ _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
    source[totalLength - 1] = '\0';
    source[totalLength - 2] = '\0';
 
+#if 0
+   if (0) {
+      GLcharARB *newSource;
+
+      newSource = _mesa_read_shader("newshader.frag");
+      if (newSource) {
+         _mesa_free(source);
+         source = newSource;
+      }
+   }
+#else
+   (void) _mesa_read_shader;
+#endif
+
    ctx->Driver.ShaderSource(ctx, shaderObj, source);
 
    _mesa_free(offsets);
@@ -587,8 +638,7 @@ _mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
                           const GLfloat * value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 2, 2, GL_FLOAT_MAT2,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 2, 2, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -596,8 +646,7 @@ _mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
                           const GLfloat * value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 3, 3, GL_FLOAT_MAT3,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 3, 3, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -605,8 +654,7 @@ _mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
                           const GLfloat * value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 4, 4, GL_FLOAT_MAT4,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 4, 4, location, count, transpose, value);
 }
 
 
@@ -618,8 +666,7 @@ _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 2, 3, GL_FLOAT_MAT2x3,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 2, 3, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -627,8 +674,7 @@ _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 3, 2, GL_FLOAT_MAT3x2,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 3, 2, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -636,8 +682,7 @@ _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 2, 4, GL_FLOAT_MAT2x4,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 2, 4, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -645,8 +690,7 @@ _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 4, 2, GL_FLOAT_MAT4x2,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 4, 2, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -654,8 +698,7 @@ _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 3, 4, GL_FLOAT_MAT3x4,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 3, 4, location, count, transpose, value);
 }
 
 void GLAPIENTRY
@@ -663,8 +706,7 @@ _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
                          const GLfloat *value)
 {
    GET_CURRENT_CONTEXT(ctx);
-   ctx->Driver.UniformMatrix(ctx, 4, 3, GL_FLOAT_MAT4x3,
-                             location, count, transpose, value);
+   ctx->Driver.UniformMatrix(ctx, 4, 3, location, count, transpose, value);
 }
 
 
diff --git a/src/mesa/main/shared.c b/src/mesa/main/shared.c
new file mode 100644
index 0000000000..4d01e8abc6
--- /dev/null
+++ b/src/mesa/main/shared.c
@@ -0,0 +1,370 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file shared.c
+ * Shared-context state
+ */
+
+
+
+#include "imports.h"
+#include "mtypes.h"
+#include "hash.h"
+#include "arrayobj.h"
+#include "bufferobj.h"
+#include "shared.h"
+#include "shader/program.h"
+#include "shader/shader_api.h"
+#include "dlist.h"
+#if FEATURE_ATI_fragment_shader
+#include "shader/atifragshader.h"
+#endif
+#if FEATURE_ARB_sync
+#include "syncobj.h"
+#endif
+
+/**
+ * Allocate and initialize a shared context state structure.
+ * Initializes the display list, texture objects and vertex programs hash
+ * tables, allocates the texture objects. If it runs out of memory, frees
+ * everything already allocated before returning NULL.
+ *
+ * \return pointer to a gl_shared_state structure on success, or NULL on
+ * failure.
+ */
+struct gl_shared_state *
+_mesa_alloc_shared_state(GLcontext *ctx)
+{
+   struct gl_shared_state *shared;
+   GLuint i;
+
+   shared = CALLOC_STRUCT(gl_shared_state);
+   if (!shared)
+      return NULL;
+
+   _glthread_INIT_MUTEX(shared->Mutex);
+
+   shared->DisplayList = _mesa_NewHashTable();
+   shared->TexObjects = _mesa_NewHashTable();
+   shared->Programs = _mesa_NewHashTable();
+
+#if FEATURE_ARB_vertex_program
+   shared->DefaultVertexProgram = (struct gl_vertex_program *)
+      ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
+#endif
+
+#if FEATURE_ARB_fragment_program
+   shared->DefaultFragmentProgram = (struct gl_fragment_program *)
+      ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
+#endif
+
+#if FEATURE_ATI_fragment_shader
+   shared->ATIShaders = _mesa_NewHashTable();
+   shared->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
+#endif
+
+#if FEATURE_ARB_shader_objects
+   shared->ShaderObjects = _mesa_NewHashTable();
+#endif
+
+#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
+   shared->BufferObjects = _mesa_NewHashTable();
+#endif
+
+   /* Allocate the default buffer object and set refcount so high that
+    * it never gets deleted.
+    * XXX with recent/improved refcounting this may not longer be needed.
+    */
+   shared->NullBufferObj = ctx->Driver.NewBufferObject(ctx, 0, 0);
+   shared->NullBufferObj->RefCount = 1000 * 1000 * 1000;
+
+   /* Create default texture objects */
+   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
+      /* NOTE: the order of these enums matches the TEXTURE_x_INDEX values */
+      static const GLenum targets[NUM_TEXTURE_TARGETS] = {
+         GL_TEXTURE_2D_ARRAY_EXT,
+         GL_TEXTURE_1D_ARRAY_EXT,
+         GL_TEXTURE_CUBE_MAP,
+         GL_TEXTURE_3D,
+         GL_TEXTURE_RECTANGLE_NV,
+         GL_TEXTURE_2D,
+         GL_TEXTURE_1D
+      };
+      shared->DefaultTex[i] = ctx->Driver.NewTextureObject(ctx, 0, targets[i]);
+   }
+
+   /* sanity check */
+   assert(shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount == 1);
+
+   /* Mutex and timestamp for texobj state validation */
+   _glthread_INIT_MUTEX(shared->TexMutex);
+   shared->TextureStateStamp = 0;
+
+#if FEATURE_EXT_framebuffer_object
+   shared->FrameBuffers = _mesa_NewHashTable();
+   shared->RenderBuffers = _mesa_NewHashTable();
+#endif
+
+#if FEATURE_ARB_sync
+   make_empty_list(& shared->SyncObjects);
+#endif
+
+   return shared;
+}
+
+
+/**
+ * Callback for deleting a display list.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_displaylist_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_display_list *list = (struct gl_display_list *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   _mesa_delete_list(ctx, list);
+}
+
+
+/**
+ * Callback for deleting a texture object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_texture_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_texture_object *texObj = (struct gl_texture_object *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   ctx->Driver.DeleteTexture(ctx, texObj);
+}
+
+
+/**
+ * Callback for deleting a program object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_program_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_program *prog = (struct gl_program *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   if(prog != &_mesa_DummyProgram) {
+      ASSERT(prog->RefCount == 1); /* should only be referenced by hash table */
+      prog->RefCount = 0;  /* now going away */
+      ctx->Driver.DeleteProgram(ctx, prog);
+   }
+}
+
+
+#if FEATURE_ATI_fragment_shader
+/**
+ * Callback for deleting an ATI fragment shader object.
+ * Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_fragshader_cb(GLuint id, void *data, void *userData)
+{
+   struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   _mesa_delete_ati_fragment_shader(ctx, shader);
+}
+#endif
+
+
+/**
+ * Callback for deleting a buffer object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_bufferobj_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   if (_mesa_bufferobj_mapped(bufObj)) {
+      ctx->Driver.UnmapBuffer(ctx, 0, bufObj);
+      bufObj->Pointer = NULL;
+   }
+   ctx->Driver.DeleteBuffer(ctx, bufObj);
+}
+
+
+/**
+ * Callback for freeing shader program data. Call it before delete_shader_cb
+ * to avoid memory access error.
+ */
+static void
+free_shader_program_data_cb(GLuint id, void *data, void *userData)
+{
+   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_shader_program *shProg = (struct gl_shader_program *) data;
+
+   if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
+       _mesa_free_shader_program_data(ctx, shProg);
+   }
+}
+
+
+/**
+ * Callback for deleting shader and shader programs objects.
+ * Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_shader_cb(GLuint id, void *data, void *userData)
+{
+   GLcontext *ctx = (GLcontext *) userData;
+   struct gl_shader *sh = (struct gl_shader *) data;
+   if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
+      _mesa_free_shader(ctx, sh);
+   }
+   else {
+      struct gl_shader_program *shProg = (struct gl_shader_program *) data;
+      ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
+      _mesa_free_shader_program(ctx, shProg);
+   }
+}
+
+
+/**
+ * Callback for deleting a framebuffer object.  Called by _mesa_HashDeleteAll()
+ */
+static void
+delete_framebuffer_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
+   /* The fact that the framebuffer is in the hashtable means its refcount
+    * is one, but we're removing from the hashtable now.  So clear refcount.
+    */
+   /*assert(fb->RefCount == 1);*/
+   fb->RefCount = 0;
+
+   /* NOTE: Delete should always be defined but there are two reports
+    * of it being NULL (bugs 13507, 14293).  Work-around for now.
+    */
+   if (fb->Delete)
+      fb->Delete(fb);
+}
+
+
+/**
+ * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll()
+ */
+static void
+delete_renderbuffer_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
+   rb->RefCount = 0;  /* see comment for FBOs above */
+   if (rb->Delete)
+      rb->Delete(rb);
+}
+
+
+/**
+ * Deallocate a shared state object and all children structures.
+ *
+ * \param ctx GL context.
+ * \param shared shared state pointer.
+ * 
+ * Frees the display lists, the texture objects (calling the driver texture
+ * deletion callback to free its private data) and the vertex programs, as well
+ * as their hash tables.
+ *
+ * \sa alloc_shared_state().
+ */
+void
+_mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared)
+{
+   GLuint i;
+
+   /*
+    * Free display lists
+    */
+   _mesa_HashDeleteAll(shared->DisplayList, delete_displaylist_cb, ctx);
+   _mesa_DeleteHashTable(shared->DisplayList);
+
+#if FEATURE_ARB_shader_objects
+   _mesa_HashWalk(shared->ShaderObjects, free_shader_program_data_cb, ctx);
+   _mesa_HashDeleteAll(shared->ShaderObjects, delete_shader_cb, ctx);
+   _mesa_DeleteHashTable(shared->ShaderObjects);
+#endif
+
+   _mesa_HashDeleteAll(shared->Programs, delete_program_cb, ctx);
+   _mesa_DeleteHashTable(shared->Programs);
+
+#if FEATURE_ARB_vertex_program
+   _mesa_reference_vertprog(ctx, &shared->DefaultVertexProgram, NULL);
+#endif
+
+#if FEATURE_ARB_fragment_program
+   _mesa_reference_fragprog(ctx, &shared->DefaultFragmentProgram, NULL);
+#endif
+
+#if FEATURE_ATI_fragment_shader
+   _mesa_HashDeleteAll(shared->ATIShaders, delete_fragshader_cb, ctx);
+   _mesa_DeleteHashTable(shared->ATIShaders);
+   _mesa_delete_ati_fragment_shader(ctx, shared->DefaultFragmentShader);
+#endif
+
+#if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
+   _mesa_HashDeleteAll(shared->BufferObjects, delete_bufferobj_cb, ctx);
+   _mesa_DeleteHashTable(shared->BufferObjects);
+#endif
+
+#if FEATURE_EXT_framebuffer_object
+   _mesa_HashDeleteAll(shared->FrameBuffers, delete_framebuffer_cb, ctx);
+   _mesa_DeleteHashTable(shared->FrameBuffers);
+   _mesa_HashDeleteAll(shared->RenderBuffers, delete_renderbuffer_cb, ctx);
+   _mesa_DeleteHashTable(shared->RenderBuffers);
+#endif
+
+#if FEATURE_ARB_vertex_buffer_object
+   ctx->Driver.DeleteBuffer(ctx, shared->NullBufferObj);
+#endif
+
+#if FEATURE_ARB_sync
+   {
+      struct simple_node *node;
+      struct simple_node *temp;
+
+      foreach_s(node, temp, & shared->SyncObjects) {
+	 _mesa_unref_sync_object(ctx, (struct gl_sync_object *) node);
+      }
+   }
+#endif
+
+   /*
+    * Free texture objects (after FBOs since some textures might have
+    * been bound to FBOs).
+    */
+   ASSERT(ctx->Driver.DeleteTexture);
+   /* the default textures */
+   for (i = 0; i < NUM_TEXTURE_TARGETS; i++) {
+      ctx->Driver.DeleteTexture(ctx, shared->DefaultTex[i]);
+   }
+
+   /* all other textures */
+   _mesa_HashDeleteAll(shared->TexObjects, delete_texture_cb, ctx);
+   _mesa_DeleteHashTable(shared->TexObjects);
+
+   _glthread_DESTROY_MUTEX(shared->Mutex);
+   _glthread_DESTROY_MUTEX(shared->TexMutex);
+
+   _mesa_free(shared);
+}
diff --git a/src/mesa/main/shared.h b/src/mesa/main/shared.h
new file mode 100644
index 0000000000..e59177e968
--- /dev/null
+++ b/src/mesa/main/shared.h
@@ -0,0 +1,37 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef SHARED_H
+#define SHARED_H
+
+
+struct gl_shared_state *
+_mesa_alloc_shared_state(GLcontext *ctx);
+
+
+void
+_mesa_free_shared_state(GLcontext *ctx, struct gl_shared_state *shared);
+
+
+#endif
diff --git a/src/mesa/main/simple_list.h b/src/mesa/main/simple_list.h
index 63475f6f74..ff7f888238 100644
--- a/src/mesa/main/simple_list.h
+++ b/src/mesa/main/simple_list.h
@@ -37,6 +37,11 @@
 #ifndef _SIMPLE_LIST_H
 #define _SIMPLE_LIST_H
 
+struct simple_node {
+   struct simple_node *next;
+   struct simple_node *prev;
+};
+
 /**
  * Remove an element from list.
  *
diff --git a/src/mesa/main/sources b/src/mesa/main/sources
index 1b43e7e00f..5d9d99040e 100644
--- a/src/mesa/main/sources
+++ b/src/mesa/main/sources
@@ -63,6 +63,7 @@ texenv.c \
 texenvprogram.c \
 texformat.c \
 texgen.c \
+texgetimage.c \
 teximage.c \
 texobj.c \
 texparam.c \
@@ -79,7 +80,6 @@ vsnprintf.c
 MESA_MAIN_HEADERS = \
 accum.h \
 api_arrayelt.h \
-api_eval.h \
 api_exec.h \
 api_loopback.h \
 api_noop.h \
diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c
index 6fe54c753f..f10e6b04b7 100644
--- a/src/mesa/main/state.c
+++ b/src/mesa/main/state.c
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.3
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  *
@@ -40,15 +40,15 @@
 #include "framebuffer.h"
 #include "light.h"
 #include "matrix.h"
-#if FEATURE_pixel_transfer
 #include "pixel.h"
-#endif
 #include "shader/program.h"
+#include "shader/prog_parameter.h"
 #include "state.h"
 #include "stencil.h"
 #include "texenvprogram.h"
 #include "texobj.h"
 #include "texstate.h"
+#include "viewport.h"
 
 
 static void
@@ -62,124 +62,172 @@ update_separate_specular(GLcontext *ctx)
 
 
 /**
- * Update state dependent on vertex arrays.
+ * Compute the index of the last array element that can be safely accessed
+ * in a vertex array.  We can really only do this when the array lives in
+ * a VBO.
+ * The array->_MaxElement field will be updated.
+ * Later in glDrawArrays/Elements/etc we can do some bounds checking.
+ */
+static void
+compute_max_element(struct gl_client_array *array)
+{
+   assert(array->Enabled);
+   if (array->BufferObj->Name) {
+      GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr;
+      GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size;
+
+      if (offset < obj_size) {
+	 array->_MaxElement = (obj_size - offset +
+			       array->StrideB -
+			       array->_ElementSize) / array->StrideB;
+      } else {
+	 array->_MaxElement = 0;
+      }
+      /* Compute the max element we can access in the VBO without going
+       * out of bounds.
+       */
+      array->_MaxElement = ((GLsizeiptrARB) array->BufferObj->Size
+                            - (GLsizeiptrARB) array->Ptr + array->StrideB
+                            - array->_ElementSize) / array->StrideB;
+   }
+   else {
+      /* user-space array, no idea how big it is */
+      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
+   }
+}
+
+
+/**
+ * Helper for update_arrays().
+ * \return  min(current min, array->_MaxElement).
+ */
+static GLuint
+update_min(GLuint min, struct gl_client_array *array)
+{
+   compute_max_element(array);
+   return MIN2(min, array->_MaxElement);
+}
+
+
+/**
+ * Update ctx->Array._MaxElement (the max legal index into all enabled arrays).
+ * Need to do this upon new array state or new buffer object state.
  */
 static void
 update_arrays( GLcontext *ctx )
 {
-   GLuint i, min;
+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
+   GLuint i, min = ~0;
 
    /* find min of _MaxElement values for all enabled arrays */
 
    /* 0 */
    if (ctx->VertexProgram._Current
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
-      min = ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS]._MaxElement;
-   }
-   else if (ctx->Array.ArrayObj->Vertex.Enabled) {
-      min = ctx->Array.ArrayObj->Vertex._MaxElement;
+       && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);
    }
-   else {
-      /* can't draw anything without vertex positions! */
-      min = 0;
+   else if (arrayObj->Vertex.Enabled) {
+      min = update_min(min, &arrayObj->Vertex);
    }
 
    /* 1 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]);
    }
    /* no conventional vertex weight array */
 
    /* 2 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);
    }
-   else if (ctx->Array.ArrayObj->Normal.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->Normal._MaxElement);
+   else if (arrayObj->Normal.Enabled) {
+      min = update_min(min, &arrayObj->Normal);
    }
 
    /* 3 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);
    }
-   else if (ctx->Array.ArrayObj->Color.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->Color._MaxElement);
+   else if (arrayObj->Color.Enabled) {
+      min = update_min(min, &arrayObj->Color);
    }
 
    /* 4 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);
    }
-   else if (ctx->Array.ArrayObj->SecondaryColor.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->SecondaryColor._MaxElement);
+   else if (arrayObj->SecondaryColor.Enabled) {
+      min = update_min(min, &arrayObj->SecondaryColor);
    }
 
    /* 5 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_FOG]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);
    }
-   else if (ctx->Array.ArrayObj->FogCoord.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->FogCoord._MaxElement);
+   else if (arrayObj->FogCoord.Enabled) {
+      min = update_min(min, &arrayObj->FogCoord);
    }
 
    /* 6 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);
    }
-   else if (ctx->Array.ArrayObj->Index.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->Index._MaxElement);
+   else if (arrayObj->Index.Enabled) {
+      min = update_min(min, &arrayObj->Index);
    }
 
-
    /* 7 */
    if (ctx->VertexProgram._Enabled
-       && ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]._MaxElement);
+       && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);
    }
 
    /* 8..15 */
    for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {
       if (ctx->VertexProgram._Enabled
-          && ctx->Array.ArrayObj->VertexAttrib[i].Enabled) {
-         min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement);
+          && arrayObj->VertexAttrib[i].Enabled) {
+         min = update_min(min, &arrayObj->VertexAttrib[i]);
       }
       else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits
-               && ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {
-         min = MIN2(min, ctx->Array.ArrayObj->TexCoord[i - VERT_ATTRIB_TEX0]._MaxElement);
+               && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {
+         min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]);
       }
    }
 
    /* 16..31 */
    if (ctx->VertexProgram._Current) {
-      for (i = VERT_ATTRIB_GENERIC0; i < VERT_ATTRIB_MAX; i++) {
-         if (ctx->Array.ArrayObj->VertexAttrib[i].Enabled) {
-            min = MIN2(min, ctx->Array.ArrayObj->VertexAttrib[i]._MaxElement);
+      for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {
+         if (arrayObj->VertexAttrib[i].Enabled) {
+            min = update_min(min, &arrayObj->VertexAttrib[i]);
          }
       }
    }
 
-   if (ctx->Array.ArrayObj->EdgeFlag.Enabled) {
-      min = MIN2(min, ctx->Array.ArrayObj->EdgeFlag._MaxElement);
+   if (arrayObj->EdgeFlag.Enabled) {
+      min = update_min(min, &arrayObj->EdgeFlag);
    }
 
    /* _MaxElement is one past the last legal array element */
-   ctx->Array._MaxElement = min;
+   arrayObj->_MaxElement = min;
 }
 
 
+/**
+ * Update the following fields:
+ *   ctx->VertexProgram._Enabled
+ *   ctx->FragmentProgram._Enabled
+ *   ctx->ATIFragmentShader._Enabled
+ * This needs to be done before texture state validation.
+ */
 static void
-update_program(GLcontext *ctx)
+update_program_enables(GLcontext *ctx)
 {
-   const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
-   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
-   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
-
    /* These _Enabled flags indicate if the program is enabled AND valid. */
    ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled
       && ctx->VertexProgram.Current->Base.Instructions;
@@ -187,6 +235,29 @@ update_program(GLcontext *ctx)
       && ctx->FragmentProgram.Current->Base.Instructions;
    ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled
       && ctx->ATIFragmentShader.Current->Instructions[0];
+}
+
+
+/**
+ * Update vertex/fragment program state.  In particular, update these fields:
+ *   ctx->VertexProgram._Current
+ *   ctx->VertexProgram._TnlProgram,
+ * These point to the highest priority enabled vertex/fragment program or are
+ * NULL if fixed-function processing is to be done.
+ *
+ * This function needs to be called after texture state validation in case
+ * we're generating a fragment program from fixed-function texture state.
+ *
+ * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex
+ * or fragment program is being used.
+ */
+static GLbitfield
+update_program(GLcontext *ctx)
+{
+   const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
+   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
+   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
+   GLbitfield new_state = 0x0;
 
    /*
     * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current
@@ -256,18 +327,56 @@ update_program(GLcontext *ctx)
 
    /* Let the driver know what's happening:
     */
-   if (ctx->FragmentProgram._Current != prevFP && ctx->Driver.BindProgram) {
-      ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
-                              (struct gl_program *) ctx->FragmentProgram._Current);
+   if (ctx->FragmentProgram._Current != prevFP) {
+      new_state |= _NEW_PROGRAM;
+      if (ctx->Driver.BindProgram) {
+         ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
+                          (struct gl_program *) ctx->FragmentProgram._Current);
+      }
    }
    
-   if (ctx->VertexProgram._Current != prevVP && ctx->Driver.BindProgram) {
-      ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
-                              (struct gl_program *) ctx->VertexProgram._Current);
+   if (ctx->VertexProgram._Current != prevVP) {
+      new_state |= _NEW_PROGRAM;
+      if (ctx->Driver.BindProgram) {
+         ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
+                            (struct gl_program *) ctx->VertexProgram._Current);
+      }
    }
+
+   return new_state;
 }
 
 
+/**
+ * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0.
+ */
+static GLbitfield
+update_program_constants(GLcontext *ctx)
+{
+   GLbitfield new_state = 0x0;
+
+   if (ctx->FragmentProgram._Current) {
+      const struct gl_program_parameter_list *params =
+         ctx->FragmentProgram._Current->Base.Parameters;
+      if (params && params->StateFlags & ctx->NewState) {
+         new_state |= _NEW_PROGRAM_CONSTANTS;
+      }
+   }
+
+   if (ctx->VertexProgram._Current) {
+      const struct gl_program_parameter_list *params =
+         ctx->VertexProgram._Current->Base.Parameters;
+      if (params && params->StateFlags & ctx->NewState) {
+         new_state |= _NEW_PROGRAM_CONSTANTS;
+      }
+   }
+
+   return new_state;
+}
+
+
+
+
 static void
 update_viewport_matrix(GLcontext *ctx)
 {
@@ -425,17 +534,41 @@ _mesa_update_state_locked( GLcontext *ctx )
 {
    GLbitfield new_state = ctx->NewState;
    GLbitfield prog_flags = _NEW_PROGRAM;
+   GLbitfield new_prog_state = 0x0;
+
+   if (new_state == _NEW_CURRENT_ATTRIB) 
+      goto out;
 
    if (MESA_VERBOSE & VERBOSE_STATE)
       _mesa_print_state("_mesa_update_state", new_state);
 
+   /* Determine which state flags effect vertex/fragment program state */
+   if (ctx->FragmentProgram._MaintainTexEnvProgram) {
+      prog_flags |= (_NEW_TEXTURE | _NEW_FOG |
+		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |
+		     _NEW_PROGRAM);
+   }
+   if (ctx->VertexProgram._MaintainTnlProgram) {
+      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
+                     _NEW_TRANSFORM | _NEW_POINT |
+                     _NEW_FOG | _NEW_LIGHT |
+                     _MESA_NEW_NEED_EYE_COORDS);
+   }
+
+   /*
+    * Now update derived state info
+    */
+
+   if (new_state & prog_flags)
+      update_program_enables( ctx );
+
    if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
       _mesa_update_modelview_project( ctx, new_state );
 
    if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))
       _mesa_update_texture( ctx, new_state );
 
-   if (new_state & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL))
+   if (new_state & _NEW_BUFFERS)
       _mesa_update_framebuffer(ctx);
 
    if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))
@@ -447,18 +580,16 @@ _mesa_update_state_locked( GLcontext *ctx )
    if (new_state & _NEW_LIGHT)
       _mesa_update_lighting( ctx );
 
-   if (new_state & _NEW_STENCIL)
+   if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
       _mesa_update_stencil( ctx );
 
-#if FEATURE_pixel_transfer
-   if (new_state & _IMAGE_NEW_TRANSFER_STATE)
+   if (new_state & _MESA_NEW_TRANSFER_STATE)
       _mesa_update_pixel( ctx, new_state );
-#endif
 
    if (new_state & _DD_NEW_SEPARATE_SPECULAR)
       update_separate_specular( ctx );
 
-   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM))
+   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
       update_arrays( ctx );
 
    if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
@@ -488,19 +619,17 @@ _mesa_update_state_locked( GLcontext *ctx )
    if (new_state & _MESA_NEW_NEED_EYE_COORDS) 
       _mesa_update_tnl_spaces( ctx, new_state );
 
-   if (ctx->FragmentProgram._MaintainTexEnvProgram) {
-      prog_flags |= (_NEW_TEXTURE | _NEW_FOG | _DD_NEW_SEPARATE_SPECULAR);
-   }
-   if (ctx->VertexProgram._MaintainTnlProgram) {
-      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
-                     _NEW_TRANSFORM | _NEW_POINT |
-                     _NEW_FOG | _NEW_LIGHT |
-                     _MESA_NEW_NEED_EYE_COORDS);
+   if (new_state & prog_flags) {
+      /* When we generate programs from fixed-function vertex/fragment state
+       * this call may generate/bind a new program.  If so, we need to
+       * propogate the _NEW_PROGRAM flag to the driver.
+       */
+      new_prog_state |= update_program( ctx );
    }
-   if (new_state & prog_flags)
-      update_program( ctx );
 
 
+ out:
+   new_prog_state |= update_program_constants(ctx);
 
    /*
     * Give the driver a chance to act upon the new_state flags.
@@ -511,7 +640,7 @@ _mesa_update_state_locked( GLcontext *ctx )
     * Set ctx->NewState to zero to avoid recursion if
     * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)
     */
-   new_state = ctx->NewState;
+   new_state = ctx->NewState | new_prog_state;
    ctx->NewState = 0;
    ctx->Driver.UpdateState(ctx, new_state);
    ctx->Array.NewState = 0;
@@ -527,3 +656,59 @@ _mesa_update_state( GLcontext *ctx )
    _mesa_update_state_locked(ctx);
    _mesa_unlock_context_textures(ctx);
 }
+
+
+
+
+/**
+ * Want to figure out which fragment program inputs are actually
+ * constant/current values from ctx->Current.  These should be
+ * referenced as a tracked state variable rather than a fragment
+ * program input, to save the overhead of putting a constant value in
+ * every submitted vertex, transferring it to hardware, interpolating
+ * it across the triangle, etc...
+ *
+ * When there is a VP bound, just use vp->outputs.  But when we're
+ * generating vp from fixed function state, basically want to
+ * calculate:
+ *
+ * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 
+ *                 potential_vp_outputs )
+ *
+ * Where potential_vp_outputs is calculated by looking at enabled
+ * texgen, etc.
+ * 
+ * The generated fragment program should then only declare inputs that
+ * may vary or otherwise differ from the ctx->Current values.
+ * Otherwise, the fp should track them as state values instead.
+ */
+void
+_mesa_set_varying_vp_inputs( GLcontext *ctx,
+                             GLbitfield varying_inputs )
+{
+   if (ctx->varying_vp_inputs != varying_inputs) {
+      ctx->varying_vp_inputs = varying_inputs;
+      ctx->NewState |= _NEW_ARRAY;
+      /*_mesa_printf("%s %x\n", __FUNCTION__, varying_inputs);*/
+   }
+}
+
+
+/**
+ * Used by drivers to tell core Mesa that the driver is going to
+ * install/ use its own vertex program.  In particular, this will
+ * prevent generated fragment programs from using state vars instead
+ * of ordinary varyings/inputs.
+ */
+void
+_mesa_set_vp_override(GLcontext *ctx, GLboolean flag)
+{
+   if (ctx->VertexProgram._Overriden != flag) {
+      ctx->VertexProgram._Overriden = flag;
+
+      /* Set one of the bits which will trigger fragment program
+       * regeneration:
+       */
+      ctx->NewState |= _NEW_PROGRAM;
+   }
+}
diff --git a/src/mesa/main/state.h b/src/mesa/main/state.h
index bb7cb8f32a..29db08a0b9 100644
--- a/src/mesa/main/state.h
+++ b/src/mesa/main/state.h
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.3
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  *
@@ -29,13 +29,21 @@
 #include "mtypes.h"
 
 extern void
-_mesa_update_state( GLcontext *ctx );
+_mesa_update_state(GLcontext *ctx);
 
 /* As above but can only be called between _mesa_lock_context_textures() and 
  * _mesa_unlock_context_textures().
  */
 extern void
-_mesa_update_state_locked( GLcontext *ctx );
+_mesa_update_state_locked(GLcontext *ctx);
+
+
+extern void
+_mesa_set_varying_vp_inputs(GLcontext *ctx, GLbitfield varying_inputs);
+
+
+extern void
+_mesa_set_vp_override(GLcontext *ctx, GLboolean flag);
 
 
 #endif
diff --git a/src/mesa/main/stencil.c b/src/mesa/main/stencil.c
index 2a4c38b1f2..15c98e2015 100644
--- a/src/mesa/main/stencil.c
+++ b/src/mesa/main/stencil.c
@@ -27,7 +27,7 @@
  * \file stencil.c
  * Stencil operations.
  *
- * Note: There's an incompatibility between GL_EXT_stencil_two_side and
+ * Note: There's some conflict between GL_EXT_stencil_two_side and
  * OpenGL 2.0's two-sided stencil feature.
  *
  * With GL_EXT_stencil_two_side, calling glStencilOp/Func/Mask() only the
@@ -36,12 +36,14 @@
  * But with OpenGL 2.0, calling glStencilOp/Func/Mask() sets BOTH the
  * front AND back state.
  *
- * So either we advertise the GL_EXT_stencil_two_side extension, or OpenGL
- * 2.0, but not both.
- *
  * Also, note that GL_ATI_separate_stencil is different as well:
  * glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, ...)  vs.
  * glStencilFuncSeparate(GLenum face, GLenum func, ...).
+ *
+ * This problem is solved by keeping three sets of stencil state:
+ *  state[0] = GL_FRONT state.
+ *  state[1] = OpenGL 2.0 / GL_ATI_separate_stencil GL_BACK state.
+ *  state[2] = GL_EXT_stencil_two_side GL_BACK state.
  */
 
 
@@ -198,6 +200,7 @@ _mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )
 {
    GET_CURRENT_CONTEXT(ctx);
    const GLint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
+   const GLint face = ctx->Stencil.ActiveFace;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!validate_stencil_func(ctx, func)) {
@@ -207,9 +210,7 @@ _mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )
 
    ref = CLAMP( ref, 0, stencilMax );
 
-   if (ctx->Extensions.EXT_stencil_two_side) {
-      /* only set active face state */
-      const GLint face = ctx->Stencil.ActiveFace;
+   if (face != 0) {
       if (ctx->Stencil.Function[face] == func &&
           ctx->Stencil.ValueMask[face] == mask &&
           ctx->Stencil.Ref[face] == ref)
@@ -218,9 +219,12 @@ _mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )
       ctx->Stencil.Function[face] = func;
       ctx->Stencil.Ref[face] = ref;
       ctx->Stencil.ValueMask[face] = mask;
-      if (ctx->Driver.StencilFuncSeparate) {
-         ctx->Driver.StencilFuncSeparate(ctx, face ? GL_BACK : GL_FRONT,
-                                         func, ref, mask);
+
+      /* Only propagate the change to the driver if EXT_stencil_two_side
+       * is enabled.
+       */
+      if (ctx->Driver.StencilFuncSeparate && ctx->Stencil.TestTwoSide) {
+         ctx->Driver.StencilFuncSeparate(ctx, GL_BACK, func, ref, mask);
       }
    }
    else {
@@ -237,7 +241,9 @@ _mesa_StencilFunc( GLenum func, GLint ref, GLuint mask )
       ctx->Stencil.Ref[0]       = ctx->Stencil.Ref[1]       = ref;
       ctx->Stencil.ValueMask[0] = ctx->Stencil.ValueMask[1] = mask;
       if (ctx->Driver.StencilFuncSeparate) {
-         ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT_AND_BACK,
+         ctx->Driver.StencilFuncSeparate(ctx,
+					 ((ctx->Stencil.TestTwoSide)
+					  ? GL_FRONT : GL_FRONT_AND_BACK),
                                          func, ref, mask);
       }
    }
@@ -259,17 +265,23 @@ void GLAPIENTRY
 _mesa_StencilMask( GLuint mask )
 {
    GET_CURRENT_CONTEXT(ctx);
+   const GLint face = ctx->Stencil.ActiveFace;
+
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (ctx->Extensions.EXT_stencil_two_side) {
-      /* only set active face state */
-      const GLint face = ctx->Stencil.ActiveFace;
+   if (face != 0) {
+      /* Only modify the EXT_stencil_two_side back-face state.
+       */
       if (ctx->Stencil.WriteMask[face] == mask)
          return;
       FLUSH_VERTICES(ctx, _NEW_STENCIL);
       ctx->Stencil.WriteMask[face] = mask;
-      if (ctx->Driver.StencilMaskSeparate) {
-         ctx->Driver.StencilMaskSeparate(ctx, face ? GL_BACK : GL_FRONT, mask);
+
+      /* Only propagate the change to the driver if EXT_stencil_two_side
+       * is enabled.
+       */
+      if (ctx->Driver.StencilMaskSeparate && ctx->Stencil.TestTwoSide) {
+         ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, mask);
       }
    }
    else {
@@ -280,7 +292,10 @@ _mesa_StencilMask( GLuint mask )
       FLUSH_VERTICES(ctx, _NEW_STENCIL);
       ctx->Stencil.WriteMask[0] = ctx->Stencil.WriteMask[1] = mask;
       if (ctx->Driver.StencilMaskSeparate) {
-         ctx->Driver.StencilMaskSeparate(ctx, GL_FRONT_AND_BACK, mask);
+         ctx->Driver.StencilMaskSeparate(ctx,
+					 ((ctx->Stencil.TestTwoSide)
+					  ? GL_FRONT : GL_FRONT_AND_BACK),
+					  mask);
       }
    }
 }
@@ -304,6 +319,8 @@ void GLAPIENTRY
 _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
    GET_CURRENT_CONTEXT(ctx);
+   const GLint face = ctx->Stencil.ActiveFace;
+
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (!validate_stencil_op(ctx, fail)) {
@@ -319,9 +336,8 @@ _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
       return;
    }
 
-   if (ctx->Extensions.EXT_stencil_two_side) {
+   if (face != 0) {
       /* only set active face state */
-      const GLint face = ctx->Stencil.ActiveFace;
       if (ctx->Stencil.ZFailFunc[face] == zfail &&
           ctx->Stencil.ZPassFunc[face] == zpass &&
           ctx->Stencil.FailFunc[face] == fail)
@@ -330,9 +346,12 @@ _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
       ctx->Stencil.ZFailFunc[face] = zfail;
       ctx->Stencil.ZPassFunc[face] = zpass;
       ctx->Stencil.FailFunc[face] = fail;
-      if (ctx->Driver.StencilOpSeparate) {
-         ctx->Driver.StencilOpSeparate(ctx, face ? GL_BACK : GL_FRONT,
-                                       fail, zfail, zpass);
+
+      /* Only propagate the change to the driver if EXT_stencil_two_side
+       * is enabled.
+       */
+      if (ctx->Driver.StencilOpSeparate && ctx->Stencil.TestTwoSide) {
+         ctx->Driver.StencilOpSeparate(ctx, GL_BACK, fail, zfail, zpass);
       }
    }
    else {
@@ -349,7 +368,9 @@ _mesa_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
       ctx->Stencil.ZPassFunc[0] = ctx->Stencil.ZPassFunc[1] = zpass;
       ctx->Stencil.FailFunc[0]  = ctx->Stencil.FailFunc[1]  = fail;
       if (ctx->Driver.StencilOpSeparate) {
-         ctx->Driver.StencilOpSeparate(ctx, GL_FRONT_AND_BACK,
+         ctx->Driver.StencilOpSeparate(ctx,
+				       ((ctx->Stencil.TestTwoSide)
+					? GL_FRONT : GL_FRONT_AND_BACK),
                                        fail, zfail, zpass);
       }
    }
@@ -372,7 +393,7 @@ _mesa_ActiveStencilFaceEXT(GLenum face)
 
    if (face == GL_FRONT || face == GL_BACK) {
       FLUSH_VERTICES(ctx, _NEW_STENCIL);
-      ctx->Stencil.ActiveFace = (face == GL_FRONT) ? 0 : 1;
+      ctx->Stencil.ActiveFace = (face == GL_FRONT) ? 0 : 2;
    }
    else {
       _mesa_error(ctx, GL_INVALID_ENUM, "glActiveStencilFaceEXT(face)");
@@ -513,19 +534,20 @@ _mesa_StencilMaskSeparate(GLenum face, GLuint mask)
 void
 _mesa_update_stencil(GLcontext *ctx)
 {
-   if (ctx->Extensions.EXT_stencil_two_side) {
-      ctx->Stencil._TestTwoSide = ctx->Stencil.TestTwoSide;
-   }
-   else {
-      ctx->Stencil._TestTwoSide = 
-         (ctx->Stencil.Function[0] != ctx->Stencil.Function[1] ||
-          ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[1] ||
-          ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[1] ||
-          ctx->Stencil.ZFailFunc[0] != ctx->Stencil.ZFailFunc[1] ||
-          ctx->Stencil.Ref[0] != ctx->Stencil.Ref[1] ||
-          ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[1] ||
-          ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[1]);
-   }
+   const GLint face = ctx->Stencil._BackFace;
+
+   ctx->Stencil._Enabled = (ctx->Stencil.Enabled &&
+                            ctx->DrawBuffer->Visual.stencilBits > 0);
+
+    ctx->Stencil._TestTwoSide =
+       ctx->Stencil._Enabled &&
+       (ctx->Stencil.Function[0] != ctx->Stencil.Function[face] ||
+	ctx->Stencil.FailFunc[0] != ctx->Stencil.FailFunc[face] ||
+	ctx->Stencil.ZPassFunc[0] != ctx->Stencil.ZPassFunc[face] ||
+	ctx->Stencil.ZFailFunc[0] != ctx->Stencil.ZFailFunc[face] ||
+	ctx->Stencil.Ref[0] != ctx->Stencil.Ref[face] ||
+	ctx->Stencil.ValueMask[0] != ctx->Stencil.ValueMask[face] ||
+	ctx->Stencil.WriteMask[0] != ctx->Stencil.WriteMask[face]);
 }
 
 
@@ -541,20 +563,28 @@ _mesa_init_stencil(GLcontext *ctx)
 {
    ctx->Stencil.Enabled = GL_FALSE;
    ctx->Stencil.TestTwoSide = GL_FALSE;
-   ctx->Stencil.ActiveFace = 0;  /* 0 = GL_FRONT, 1 = GL_BACK */
+   ctx->Stencil.ActiveFace = 0;  /* 0 = GL_FRONT, 2 = GL_BACK */
    ctx->Stencil.Function[0] = GL_ALWAYS;
    ctx->Stencil.Function[1] = GL_ALWAYS;
+   ctx->Stencil.Function[2] = GL_ALWAYS;
    ctx->Stencil.FailFunc[0] = GL_KEEP;
    ctx->Stencil.FailFunc[1] = GL_KEEP;
+   ctx->Stencil.FailFunc[2] = GL_KEEP;
    ctx->Stencil.ZPassFunc[0] = GL_KEEP;
    ctx->Stencil.ZPassFunc[1] = GL_KEEP;
+   ctx->Stencil.ZPassFunc[2] = GL_KEEP;
    ctx->Stencil.ZFailFunc[0] = GL_KEEP;
    ctx->Stencil.ZFailFunc[1] = GL_KEEP;
+   ctx->Stencil.ZFailFunc[2] = GL_KEEP;
    ctx->Stencil.Ref[0] = 0;
    ctx->Stencil.Ref[1] = 0;
+   ctx->Stencil.Ref[2] = 0;
    ctx->Stencil.ValueMask[0] = ~0U;
    ctx->Stencil.ValueMask[1] = ~0U;
+   ctx->Stencil.ValueMask[2] = ~0U;
    ctx->Stencil.WriteMask[0] = ~0U;
    ctx->Stencil.WriteMask[1] = ~0U;
+   ctx->Stencil.WriteMask[2] = ~0U;
    ctx->Stencil.Clear = 0;
+   ctx->Stencil._BackFace = 1;
 }
diff --git a/src/mesa/main/syncobj.c b/src/mesa/main/syncobj.c
new file mode 100644
index 0000000000..ac3f9eb175
--- /dev/null
+++ b/src/mesa/main/syncobj.c
@@ -0,0 +1,409 @@
+/*
+ * Copyright © 2009 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file syncobj.c
+ * Sync object management.
+ *
+ * Unlike textures and other objects that are shared between contexts, sync
+ * objects are not bound to the context.  As a result, the reference counting
+ * and delete behavior of sync objects is slightly different.  References to
+ * sync objects are added:
+ *
+ *    - By \c glFencSynce.  This sets the initial reference count to 1.
+ *    - At the start of \c glClientWaitSync.  The reference is held for the
+ *      duration of the wait call.
+ *
+ * References are removed:
+ *
+ *    - By \c glDeleteSync.
+ *    - At the end of \c glClientWaitSync.
+ *
+ * Additionally, drivers may call \c _mesa_ref_sync_object and
+ * \c _mesa_unref_sync_object as needed to implement \c ServerWaitSync.
+ *
+ * As with shader objects, sync object names become invalid as soon as
+ * \c glDeleteSync is called.  For this reason \c glDeleteSync sets the
+ * \c DeletePending flag.  All functions validate object handles by testing
+ * this flag.
+ *
+ * \note
+ * Only \c GL_ARB_sync objects are shared between contexts.  If support is ever
+ * added for either \c GL_NV_fence or \c GL_APPLE_fence different semantics
+ * will need to be implemented.
+ *
+ * \author Ian Romanick <ian.d.romanick@intel.com>
+ */
+
+#include "glheader.h"
+#include "imports.h"
+#include "context.h"
+#include "macros.h"
+
+#if FEATURE_ARB_sync
+#include "syncobj.h"
+
+static struct gl_sync_object *
+_mesa_new_sync_object(GLcontext *ctx, GLenum type)
+{
+   struct gl_sync_object *s = MALLOC_STRUCT(gl_sync_object);
+   (void) ctx;
+   (void) type;
+
+   return s;
+}
+
+
+static void
+_mesa_delete_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj)
+{
+   (void) ctx;
+   _mesa_free(syncObj);
+}
+
+
+static void
+_mesa_fence_sync(GLcontext *ctx, struct gl_sync_object *syncObj,
+		 GLenum condition, GLbitfield flags)
+{
+   (void) ctx;
+   (void) condition;
+   (void) flags;
+
+   syncObj->StatusFlag = 1;
+}
+
+
+static void
+_mesa_check_sync(GLcontext *ctx, struct gl_sync_object *syncObj)
+{
+   (void) ctx;
+   (void) syncObj;
+
+   /* No-op for software rendering.  Hardware drivers will need to determine
+    * whether the state of the sync object has changed.
+    */
+}
+
+
+static void
+_mesa_wait_sync(GLcontext *ctx, struct gl_sync_object *syncObj,
+		GLbitfield flags, GLuint64 timeout)
+{
+   (void) ctx;
+   (void) syncObj;
+   (void) flags;
+   (void) timeout;
+
+   /* No-op for software rendering.  Hardware drivers will need to wait until
+    * the state of the sync object changes or the timeout expires.
+    */
+}
+
+
+void
+_mesa_init_sync_object_functions(struct dd_function_table *driver)
+{
+   driver->NewSyncObject = _mesa_new_sync_object;
+   driver->FenceSync = _mesa_fence_sync;
+   driver->DeleteSyncObject = _mesa_delete_sync_object;
+   driver->CheckSync = _mesa_check_sync;
+
+   /* Use the same no-op wait function for both.
+    */
+   driver->ClientWaitSync = _mesa_wait_sync;
+   driver->ServerWaitSync = _mesa_wait_sync;
+}
+
+
+/**
+ * Allocate/init the context state related to sync objects.
+ */
+void
+_mesa_init_sync(GLcontext *ctx)
+{
+   (void) ctx;
+}
+
+
+/**
+ * Free the context state related to sync objects.
+ */
+void
+_mesa_free_sync_data(GLcontext *ctx)
+{
+   (void) ctx;
+}
+
+
+static int
+_mesa_validate_sync(struct gl_sync_object *syncObj)
+{
+   return (syncObj != NULL)
+      && (syncObj->Type == GL_SYNC_FENCE)
+      && !syncObj->DeletePending;
+}
+
+
+void
+_mesa_ref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj)
+{
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+   syncObj->RefCount++;
+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+}
+
+
+void
+_mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj)
+{
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+   syncObj->RefCount--;
+   if (syncObj->RefCount == 0) {
+      remove_from_list(& syncObj->link);
+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+      ctx->Driver.DeleteSyncObject(ctx, syncObj);
+   } else {
+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+   }
+}
+
+
+GLboolean GLAPIENTRY
+_mesa_IsSync(GLsync sync)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   return _mesa_validate_sync(syncObj) ? GL_TRUE : GL_FALSE;
+}
+
+
+void GLAPIENTRY
+_mesa_DeleteSync(GLsync sync)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   /* From the GL_ARB_sync spec:
+    *
+    *    DeleteSync will silently ignore a <sync> value of zero. An
+    *    INVALID_VALUE error is generated if <sync> is neither zero nor the
+    *    name of a sync object.
+    */
+   if (sync == 0) {
+      return;
+   }
+
+   if (!_mesa_validate_sync(syncObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteSync");
+      return;
+   }
+
+   /* If there are no client-waits or server-waits pending on this sync, delete
+    * the underlying object.
+    */
+   syncObj->DeletePending = GL_TRUE;
+   _mesa_unref_sync_object(ctx, syncObj);
+}
+
+
+GLsync GLAPIENTRY
+_mesa_FenceSync(GLenum condition, GLbitfield flags)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *syncObj;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
+
+   if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glFenceSync(condition=0x%x)",
+		  condition);
+      return 0;
+   }
+
+   if (flags != 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glFenceSync(flags=0x%x)",
+		  condition);
+      return 0;
+   }
+
+   syncObj = ctx->Driver.NewSyncObject(ctx, GL_SYNC_FENCE);
+   if (syncObj != NULL) {
+      syncObj->Type = GL_SYNC_FENCE;
+      /* The name is not currently used, and it is never visible to
+       * applications.  If sync support is extended to provide support for
+       * NV_fence, this field will be used.  We'll also need to add an object
+       * ID hashtable.
+       */
+      syncObj->Name = 1;
+      syncObj->RefCount = 1;
+      syncObj->DeletePending = GL_FALSE;
+      syncObj->SyncCondition = condition;
+      syncObj->Flags = flags;
+      syncObj->StatusFlag = 0;
+
+      ctx->Driver.FenceSync(ctx, syncObj, condition, flags);
+
+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+      insert_at_tail(& ctx->Shared->SyncObjects, & syncObj->link);
+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+      return (GLsync) syncObj;
+   }
+
+   return NULL;
+}
+
+
+GLenum GLAPIENTRY
+_mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync;
+   GLenum ret;
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_WAIT_FAILED);
+
+   if (!_mesa_validate_sync(syncObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glClientWaitSync");
+      return GL_WAIT_FAILED;
+   }
+
+   if ((flags & ~GL_SYNC_FLUSH_COMMANDS_BIT) != 0) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClientWaitSync(flags=0x%x)", flags);
+      return GL_WAIT_FAILED;
+   }
+
+   _mesa_ref_sync_object(ctx, syncObj);
+
+   /* From the GL_ARB_sync spec:
+    *
+    *    ClientWaitSync returns one of four status values. A return value of
+    *    ALREADY_SIGNALED indicates that <sync> was signaled at the time
+    *    ClientWaitSync was called. ALREADY_SIGNALED will always be returned
+    *    if <sync> was signaled, even if the value of <timeout> is zero.
+    */
+   ctx->Driver.CheckSync(ctx, syncObj);
+   if (syncObj->StatusFlag) {
+      ret = GL_ALREADY_SIGNALED;
+   } else {
+      ctx->Driver.ClientWaitSync(ctx, syncObj, flags, timeout);
+
+      ret = syncObj->StatusFlag ? GL_CONDITION_SATISFIED : GL_TIMEOUT_EXPIRED;
+   }
+
+   _mesa_unref_sync_object(ctx, syncObj);
+   return ret;
+}
+
+
+void GLAPIENTRY
+_mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!_mesa_validate_sync(syncObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glWaitSync");
+      return;
+   }
+
+   if (flags != 0) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glWaitSync(flags=0x%x)", flags);
+      return;
+   }
+
+   /* From the GL_ARB_sync spec:
+    *
+    *     If the value of <timeout> is zero, then WaitSync does nothing.
+    */
+   if (timeout == 0) {
+      return;
+   }
+
+   ctx->Driver.ServerWaitSync(ctx, syncObj, flags, timeout);
+}
+
+
+void GLAPIENTRY
+_mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
+		GLint *values)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct gl_sync_object *const syncObj = (struct gl_sync_object *) sync;
+   GLsizei size = 0;
+   GLint v[1];
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!_mesa_validate_sync(syncObj)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetSynciv");
+      return;
+   }
+
+   switch (pname) {
+   case GL_OBJECT_TYPE:
+      v[0] = syncObj->Type;
+      size = 1;
+      break;
+
+   case GL_SYNC_CONDITION:
+      v[0] = syncObj->SyncCondition;
+      size = 1;
+      break;
+
+   case GL_SYNC_STATUS:
+      /* Update the state of the sync by dipping into the driver.  Note that
+       * this call won't block.  It just updates state in the common object
+       * data from the current driver state.
+       */
+      ctx->Driver.CheckSync(ctx, syncObj);
+
+      v[0] = (syncObj->StatusFlag) ? GL_SIGNALED : GL_UNSIGNALED;
+      size = 1;
+      break;
+
+   case GL_SYNC_FLAGS:
+      v[0] = syncObj->Flags;
+      size = 1;
+      break;
+
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetSynciv(pname=0x%x)\n", pname);
+      return;
+   }
+
+   if (size > 0) {
+      const GLsizei copy_count = MIN2(size, bufSize);
+
+      _mesa_memcpy(values, v, sizeof(GLint) * copy_count);
+   }
+
+   if (length != NULL) {
+      *length = size;
+   }
+}
+
+#endif /* FEATURE_ARB_sync */
diff --git a/src/mesa/main/syncobj.h b/src/mesa/main/syncobj.h
new file mode 100644
index 0000000000..f23fa281e2
--- /dev/null
+++ b/src/mesa/main/syncobj.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2009 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file syncobj.h
+ * Sync object management.
+ *
+ * \author Ian Romanick <ian.d.romanick@intel.com>
+ */
+
+#ifndef SYNCOBJ_H
+#define SYNCOBJ_H
+
+#include "context.h"
+
+extern void
+_mesa_init_sync_object_functions(struct dd_function_table *driver);
+
+extern void
+_mesa_init_sync(GLcontext *);
+
+extern void
+_mesa_free_sync_data(GLcontext *);
+
+extern void
+_mesa_ref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj);
+
+extern void
+_mesa_unref_sync_object(GLcontext *ctx, struct gl_sync_object *syncObj);
+
+extern GLboolean GLAPIENTRY
+_mesa_IsSync(GLsync sync);
+
+extern void GLAPIENTRY
+_mesa_DeleteSync(GLsync sync);
+
+extern GLsync GLAPIENTRY
+_mesa_FenceSync(GLenum condition, GLbitfield flags);
+
+extern GLenum GLAPIENTRY
+_mesa_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+
+extern void GLAPIENTRY
+_mesa_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+
+extern void GLAPIENTRY
+_mesa_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length,
+		GLint *values);
+
+#endif /* SYNCOBJ_H */
diff --git a/src/mesa/main/texcompress.c b/src/mesa/main/texcompress.c
index 3ff633acd2..c1b8c7675a 100644
--- a/src/mesa/main/texcompress.c
+++ b/src/mesa/main/texcompress.c
@@ -3,6 +3,7 @@
  * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -56,60 +57,58 @@ GLuint
 _mesa_get_compressed_formats(GLcontext *ctx, GLint *formats, GLboolean all)
 {
    GLuint n = 0;
-   if (ctx->Extensions.ARB_texture_compression) {
-      if (ctx->Extensions.TDFX_texture_compression_FXT1) {
-         if (formats) {
-            formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX;
-            formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX;
-         }
-         else {
-            n += 2;
-         }
+   if (ctx->Extensions.TDFX_texture_compression_FXT1) {
+      if (formats) {
+         formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX;
+         formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX;
       }
-      if (ctx->Extensions.EXT_texture_compression_s3tc) {
-         if (formats) {
-            formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
-            /* This format has some restrictions/limitations and so should
-             * not be returned via the GL_COMPRESSED_TEXTURE_FORMATS query.
-             * Specifically, all transparent pixels become black.  NVIDIA
-             * omits this format too.
-             */
-            if (all)
-               formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-            formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-            formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-         }
-         else {
-            n += 3;
-            if (all)
-               n += 1;
-         }
+      else {
+         n += 2;
       }
-      if (ctx->Extensions.S3_s3tc) {
-         if (formats) {
-            formats[n++] = GL_RGB_S3TC;
-            formats[n++] = GL_RGB4_S3TC;
-            formats[n++] = GL_RGBA_S3TC;
-            formats[n++] = GL_RGBA4_S3TC;
-         }
-         else {
-            n += 4;
-         }
+   }
+   if (ctx->Extensions.EXT_texture_compression_s3tc) {
+      if (formats) {
+         formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+         /* This format has some restrictions/limitations and so should
+          * not be returned via the GL_COMPRESSED_TEXTURE_FORMATS query.
+          * Specifically, all transparent pixels become black.  NVIDIA
+          * omits this format too.
+          */
+         if (all)
+             formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+         formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+      }
+      else {
+         n += 3;
+         if (all)
+             n += 1;
+      }
+   }
+   if (ctx->Extensions.S3_s3tc) {
+      if (formats) {
+         formats[n++] = GL_RGB_S3TC;
+         formats[n++] = GL_RGB4_S3TC;
+         formats[n++] = GL_RGBA_S3TC;
+         formats[n++] = GL_RGBA4_S3TC;
+      }
+      else {
+         n += 4;
       }
+   }
 #if FEATURE_EXT_texture_sRGB
-      if (ctx->Extensions.EXT_texture_sRGB) {
-         if (formats) {
-            formats[n++] = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
-            formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
-            formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
-            formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
-         }
-         else {
-            n += 4;
-         }
+   if (ctx->Extensions.EXT_texture_sRGB) {
+      if (formats) {
+         formats[n++] = GL_COMPRESSED_SRGB_S3TC_DXT1_EXT;
+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
+         formats[n++] = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
+      }
+      else {
+         n += 4;
       }
-#endif /* FEATURE_EXT_texture_sRGB */
    }
+#endif /* FEATURE_EXT_texture_sRGB */
    return n;
 }
 
@@ -137,8 +136,10 @@ _mesa_compressed_texture_size( GLcontext *ctx,
 
    ASSERT(depth == 1);
    (void) depth;
+   (void) size;
 
    switch (mesaFormat) {
+#if FEATURE_texture_fxt1
    case MESA_FORMAT_RGB_FXT1:
    case MESA_FORMAT_RGBA_FXT1:
       /* round up width to next multiple of 8, height to next multiple of 4 */
@@ -150,8 +151,14 @@ _mesa_compressed_texture_size( GLcontext *ctx,
        * take 16 bytes.
        */
       return size;
+#endif
+#if FEATURE_texture_s3tc
    case MESA_FORMAT_RGB_DXT1:
    case MESA_FORMAT_RGBA_DXT1:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGB_DXT1:
+   case MESA_FORMAT_SRGBA_DXT1:
+#endif
       /* round up width, height to next multiple of 4 */
       width = (width + 3) & ~3;
       height = (height + 3) & ~3;
@@ -163,6 +170,10 @@ _mesa_compressed_texture_size( GLcontext *ctx,
       return size;
    case MESA_FORMAT_RGBA_DXT3:
    case MESA_FORMAT_RGBA_DXT5:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGBA_DXT3:
+   case MESA_FORMAT_SRGBA_DXT5:
+#endif
       /* round up width, height to next multiple of 4 */
       width = (width + 3) & ~3;
       height = (height + 3) & ~3;
@@ -172,6 +183,7 @@ _mesa_compressed_texture_size( GLcontext *ctx,
        * take 16 bytes.
        */
       return size;
+#endif
    default:
       _mesa_problem(ctx, "bad mesaFormat in _mesa_compressed_texture_size");
       return 0;
@@ -196,12 +208,15 @@ _mesa_compressed_texture_size_glenum(GLcontext *ctx,
    GLuint mesaFormat;
 
    switch (glformat) {
+#if FEATURE_texture_fxt1
    case GL_COMPRESSED_RGB_FXT1_3DFX:
       mesaFormat = MESA_FORMAT_RGB_FXT1;
       break;
    case GL_COMPRESSED_RGBA_FXT1_3DFX:
       mesaFormat = MESA_FORMAT_RGBA_FXT1;
       break;
+#endif
+#if FEATURE_texture_s3tc
    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
    case GL_RGB_S3TC:
       mesaFormat = MESA_FORMAT_RGB_DXT1;
@@ -218,6 +233,21 @@ _mesa_compressed_texture_size_glenum(GLcontext *ctx,
    case GL_RGBA4_S3TC:
       mesaFormat = MESA_FORMAT_RGBA_DXT5;
       break;
+#if FEATURE_EXT_texture_sRGB
+   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+      mesaFormat = MESA_FORMAT_SRGB_DXT1;
+      break;
+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
+      mesaFormat = MESA_FORMAT_SRGBA_DXT1;
+      break;
+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
+      mesaFormat = MESA_FORMAT_SRGBA_DXT3;
+      break;
+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
+      mesaFormat = MESA_FORMAT_SRGBA_DXT5;
+      break;
+#endif
+#endif
    default:
       return 0;
    }
@@ -239,18 +269,30 @@ _mesa_compressed_row_stride(GLuint mesaFormat, GLsizei width)
    GLint stride;
 
    switch (mesaFormat) {
+#if FEATURE_texture_fxt1
    case MESA_FORMAT_RGB_FXT1:
    case MESA_FORMAT_RGBA_FXT1:
       stride = ((width + 7) / 8) * 16; /* 16 bytes per 8x4 tile */
       break;
+#endif
+#if FEATURE_texture_s3tc
    case MESA_FORMAT_RGB_DXT1:
    case MESA_FORMAT_RGBA_DXT1:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGB_DXT1:
+   case MESA_FORMAT_SRGBA_DXT1:
+#endif
       stride = ((width + 3) / 4) * 8; /* 8 bytes per 4x4 tile */
       break;
    case MESA_FORMAT_RGBA_DXT3:
    case MESA_FORMAT_RGBA_DXT5:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGBA_DXT3:
+   case MESA_FORMAT_SRGBA_DXT5:
+#endif
       stride = ((width + 3) / 4) * 16; /* 16 bytes per 4x4 tile */
       break;
+#endif
    default:
       _mesa_problem(NULL, "bad mesaFormat in _mesa_compressed_row_stride");
       return 0;
@@ -287,18 +329,30 @@ _mesa_compressed_image_address(GLint col, GLint row, GLint img,
     */
 
    switch (mesaFormat) {
+#if FEATURE_texture_fxt1
    case MESA_FORMAT_RGB_FXT1:
    case MESA_FORMAT_RGBA_FXT1:
       addr = (GLubyte *) image + 16 * (((width + 7) / 8) * (row / 4) + col / 8);
       break;
+#endif
+#if FEATURE_texture_s3tc
    case MESA_FORMAT_RGB_DXT1:
    case MESA_FORMAT_RGBA_DXT1:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGB_DXT1:
+   case MESA_FORMAT_SRGBA_DXT1:
+#endif
       addr = (GLubyte *) image + 8 * (((width + 3) / 4) * (row / 4) + col / 4);
       break;
    case MESA_FORMAT_RGBA_DXT3:
    case MESA_FORMAT_RGBA_DXT5:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGBA_DXT3:
+   case MESA_FORMAT_SRGBA_DXT5:
+#endif
       addr = (GLubyte *) image + 16 * (((width + 3) / 4) * (row / 4) + col / 4);
       break;
+#endif
    default:
       _mesa_problem(NULL, "bad mesaFormat in _mesa_compressed_image_address");
       addr = NULL;
diff --git a/src/mesa/main/texcompress_fxt1.c b/src/mesa/main/texcompress_fxt1.c
index 45f344b0c5..14de935e71 100644
--- a/src/mesa/main/texcompress_fxt1.c
+++ b/src/mesa/main/texcompress_fxt1.c
@@ -41,6 +41,9 @@
 #include "texstore.h"
 
 
+#if FEATURE_texture_fxt1
+
+
 static void
 fxt1_encode (GLuint width, GLuint height, GLint comps,
              const void *source, GLint srcRowStride,
@@ -52,16 +55,6 @@ fxt1_decode_1 (const void *texture, GLint stride,
 
 
 /**
- * Called during context initialization.
- */
-void
-_mesa_init_texture_fxt1( GLcontext *ctx )
-{
-   (void) ctx;
-}
-
-
-/**
  * Called via TexFormat->StoreImage to store an RGB_FXT1 texture.
  */
 static GLboolean
@@ -224,6 +217,8 @@ fetch_texel_2d_f_rgb_fxt1( const struct gl_texture_image *texImage,
 }
 
 
+#endif /* FEATURE_texture_fxt1 */
+
 
 const struct gl_texture_format _mesa_texformat_rgb_fxt1 = {
    MESA_FORMAT_RGB_FXT1,		/* MesaFormat */
@@ -239,6 +234,7 @@ const struct gl_texture_format _mesa_texformat_rgb_fxt1 = {
    0,					/* DepthBits */
    0,					/* StencilBits */
    0,					/* TexelBytes */
+#if FEATURE_texture_fxt1
    texstore_rgb_fxt1,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
    fetch_texel_2d_rgb_fxt1, 		/* FetchTexel2D */
@@ -247,6 +243,10 @@ const struct gl_texture_format _mesa_texformat_rgb_fxt1 = {
    fetch_texel_2d_f_rgb_fxt1, 		/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
 };
 
 const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
@@ -263,6 +263,7 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
    0,					/* DepthBits */
    0,					/* StencilBits */
    0,					/* TexelBytes */
+#if FEATURE_texture_fxt1
    texstore_rgba_fxt1,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
    fetch_texel_2d_rgba_fxt1, 		/* FetchTexel2D */
@@ -271,9 +272,16 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
    fetch_texel_2d_f_rgba_fxt1, 		/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
 };
 
 
+#if FEATURE_texture_fxt1
+
+
 /***************************************************************************\
  * FXT1 encoder
  *
@@ -298,17 +306,17 @@ const struct gl_texture_format _mesa_texformat_rgba_fxt1 = {
 /*
  * Define a 64-bit unsigned integer type and macros
  */
-#ifdef GL_EXT_timer_query  /* this extensions defines the GLuint64EXT type */
+#if 1
 
 #define FX64_NATIVE 1
 
-typedef GLuint64EXT Fx64;
+typedef uint64_t Fx64;
 
 #define FX64_MOV32(a, b) a = b
 #define FX64_OR32(a, b)  a |= b
 #define FX64_SHL(a, c)   a <<= c
 
-#else  /* !GL_EXT_timer_query */
+#else
 
 #define FX64_NATIVE 0
 
@@ -330,7 +338,7 @@ typedef struct {
        }                                               \
    } while (0)
 
-#endif  /* !GL_EXT_timer_query */
+#endif
 
 
 #define F(i) (GLfloat)1 /* can be used to obtain an oblong metric: 0.30 / 0.59 / 0.11 */
@@ -1722,3 +1730,16 @@ fxt1_decode_1 (const void *texture, GLint stride, /* in pixels */
 
    decode_1[mode](code, t, rgba);
 }
+
+
+#endif /* FEATURE_texture_fxt1 */
+
+
+/**
+ * Called during context initialization.
+ */
+void
+_mesa_init_texture_fxt1( GLcontext *ctx )
+{
+   (void) ctx;
+}
diff --git a/src/mesa/main/texcompress_s3tc.c b/src/mesa/main/texcompress_s3tc.c
index a19c161b2c..754cb33cc0 100644
--- a/src/mesa/main/texcompress_s3tc.c
+++ b/src/mesa/main/texcompress_s3tc.c
@@ -3,6 +3,7 @@
  * Version:  6.5.3
  *
  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -54,6 +55,38 @@
 #endif
 
 
+#if FEATURE_texture_s3tc
+
+
+#if FEATURE_EXT_texture_sRGB
+/**
+ * Convert an 8-bit sRGB value from non-linear space to a
+ * linear RGB value in [0, 1].
+ * Implemented with a 256-entry lookup table.
+ */
+static INLINE GLfloat
+nonlinear_to_linear(GLubyte cs8)
+{
+   static GLfloat table[256];
+   static GLboolean tableReady = GL_FALSE;
+   if (!tableReady) {
+      /* compute lookup table now */
+      GLuint i;
+      for (i = 0; i < 256; i++) {
+         const GLfloat cs = UBYTE_TO_FLOAT(i);
+         if (cs <= 0.04045) {
+            table[i] = cs / 12.92f;
+         }
+         else {
+            table[i] = (GLfloat) _mesa_pow((cs + 0.055) / 1.055, 2.4);
+         }
+      }
+      tableReady = GL_TRUE;
+   }
+   return table[cs8];
+}
+#endif /* FEATURE_EXT_texture_sRGB */
+
 typedef void (*dxtFetchTexelFuncExt)( GLint srcRowstride, GLubyte *pixdata, GLint col, GLint row, GLvoid *texelOut );
 
 dxtFetchTexelFuncExt fetch_ext_rgb_dxt1 = NULL;
@@ -176,7 +209,7 @@ texstore_rgb_dxt1(TEXSTORE_PARAMS)
                               dst, dstRowStride);
    }
    else {
-      _mesa_warning(ctx, "external dxt library not available");
+      _mesa_warning(ctx, "external dxt library not available: texstore_rgb_dxt1");
    }
 
    if (tempImage)
@@ -238,7 +271,7 @@ texstore_rgba_dxt1(TEXSTORE_PARAMS)
                               dst, dstRowStride);
    }
    else {
-      _mesa_warning(ctx, "external dxt library not available");
+      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt1");
    }
 
    if (tempImage)
@@ -299,7 +332,7 @@ texstore_rgba_dxt3(TEXSTORE_PARAMS)
                               dst, dstRowStride);
    }
    else {
-      _mesa_warning(ctx, "external dxt library not available");
+      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt3");
    }
 
    if (tempImage)
@@ -360,7 +393,7 @@ texstore_rgba_dxt5(TEXSTORE_PARAMS)
                               dst, dstRowStride);
    }
    else {
-      _mesa_warning(ctx, "external dxt library not available");
+      _mesa_warning(ctx, "external dxt library not available: texstore_rgba_dxt5");
    }
 
    if (tempImage)
@@ -381,7 +414,7 @@ fetch_texel_2d_rgb_dxt1( const struct gl_texture_image *texImage,
                          (GLubyte *)(texImage)->Data, i, j, texel);
    }
    else
-      _mesa_debug(NULL, "attempted to decode s3tc texture without library available\n");
+      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgb_dxt1");
 }
 
 
@@ -409,7 +442,7 @@ fetch_texel_2d_rgba_dxt1( const struct gl_texture_image *texImage,
                           (GLubyte *)(texImage)->Data, i, j, texel);
    }
    else
-      _mesa_debug(NULL, "attempted to decode s3tc texture without library available\n");
+      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt1\n");
 }
 
 
@@ -438,7 +471,7 @@ fetch_texel_2d_rgba_dxt3( const struct gl_texture_image *texImage,
                           i, j, texel);
    }
    else
-      _mesa_debug(NULL, "attempted to decode s3tc texture without library available\n");
+      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt3\n");
 }
 
 
@@ -466,7 +499,7 @@ fetch_texel_2d_rgba_dxt5( const struct gl_texture_image *texImage,
                           i, j, texel);
    }
    else
-      _mesa_debug(NULL, "attempted to decode s3tc texture without library available\n");
+      _mesa_debug(NULL, "attempted to decode s3tc texture without library available: fetch_texel_2d_rgba_dxt5\n");
 }
 
 
@@ -483,6 +516,73 @@ fetch_texel_2d_f_rgba_dxt5( const struct gl_texture_image *texImage,
    texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]);
 }
 
+#if FEATURE_EXT_texture_sRGB
+static void
+fetch_texel_2d_f_srgb_dxt1( const struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* just sample as GLchan and convert to float here */
+   GLchan rgba[4];
+   fetch_texel_2d_rgb_dxt1(texImage, i, j, k, rgba);
+   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
+   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
+   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
+   texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]);
+}
+
+static void
+fetch_texel_2d_f_srgba_dxt1( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* just sample as GLchan and convert to float here */
+   GLchan rgba[4];
+   fetch_texel_2d_rgba_dxt1(texImage, i, j, k, rgba);
+   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
+   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
+   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
+   texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]);
+}
+
+static void
+fetch_texel_2d_f_srgba_dxt3( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* just sample as GLchan and convert to float here */
+   GLchan rgba[4];
+   fetch_texel_2d_rgba_dxt3(texImage, i, j, k, rgba);
+   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
+   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
+   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
+   texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]);
+}
+
+static void
+fetch_texel_2d_f_srgba_dxt5( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* just sample as GLchan and convert to float here */
+   GLchan rgba[4];
+   fetch_texel_2d_rgba_dxt5(texImage, i, j, k, rgba);
+   texel[RCOMP] = nonlinear_to_linear(rgba[RCOMP]);
+   texel[GCOMP] = nonlinear_to_linear(rgba[GCOMP]);
+   texel[BCOMP] = nonlinear_to_linear(rgba[BCOMP]);
+   texel[ACOMP] = CHAN_TO_FLOAT(rgba[ACOMP]);
+}
+#endif /* FEATURE_EXT_texture_sRGB */
+
+
+#else /* FEATURE_texture_s3tc */
+
+
+void
+_mesa_init_texture_s3tc( GLcontext *ctx )
+{
+   (void) ctx;
+}
+
+
+#endif /* FEATURE_texture_s3tc */
+
 
 const struct gl_texture_format _mesa_texformat_rgb_dxt1 = {
    MESA_FORMAT_RGB_DXT1,		/* MesaFormat */
@@ -498,6 +598,7 @@ const struct gl_texture_format _mesa_texformat_rgb_dxt1 = {
    0,					/* DepthBits */
    0,					/* StencilBits */
    0,					/* TexelBytes */
+#if FEATURE_texture_s3tc
    texstore_rgb_dxt1,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
    fetch_texel_2d_rgb_dxt1, 		/* FetchTexel2D */
@@ -506,6 +607,97 @@ const struct gl_texture_format _mesa_texformat_rgb_dxt1 = {
    fetch_texel_2d_f_rgb_dxt1, 		/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
+};
+
+const struct gl_texture_format _mesa_texformat_rgba_dxt1 = {
+   MESA_FORMAT_RGBA_DXT1,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
+   4, /*approx*/			/* RedBits */
+   4, /*approx*/			/* GreenBits */
+   4, /*approx*/			/* BlueBits */
+   1, /*approx*/			/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   0,					/* TexelBytes */
+#if FEATURE_texture_s3tc
+   texstore_rgba_dxt1,			/* StoreTexImageFunc */
+   NULL, /*impossible*/ 		/* FetchTexel1D */
+   fetch_texel_2d_rgba_dxt1, 		/* FetchTexel2D */
+   NULL, /*impossible*/ 		/* FetchTexel3D */
+   NULL, /*impossible*/ 		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba_dxt1, 		/* FetchTexel2Df */
+   NULL, /*impossible*/ 		/* FetchTexel3Df */
+   NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
+};
+
+const struct gl_texture_format _mesa_texformat_rgba_dxt3 = {
+   MESA_FORMAT_RGBA_DXT3,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
+   4, /*approx*/			/* RedBits */
+   4, /*approx*/			/* GreenBits */
+   4, /*approx*/			/* BlueBits */
+   4, /*approx*/			/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   0,					/* TexelBytes */
+#if FEATURE_texture_s3tc
+   texstore_rgba_dxt3,			/* StoreTexImageFunc */
+   NULL, /*impossible*/ 		/* FetchTexel1D */
+   fetch_texel_2d_rgba_dxt3, 		/* FetchTexel2D */
+   NULL, /*impossible*/ 		/* FetchTexel3D */
+   NULL, /*impossible*/ 		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba_dxt3, 		/* FetchTexel2Df */
+   NULL, /*impossible*/ 		/* FetchTexel3Df */
+   NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
+};
+
+const struct gl_texture_format _mesa_texformat_rgba_dxt5 = {
+   MESA_FORMAT_RGBA_DXT5,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
+   4,/*approx*/				/* RedBits */
+   4,/*approx*/				/* GreenBits */
+   4,/*approx*/				/* BlueBits */
+   4,/*approx*/				/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   0,					/* TexelBytes */
+#if FEATURE_texture_s3tc
+   texstore_rgba_dxt5,			/* StoreTexImageFunc */
+   NULL, /*impossible*/ 		/* FetchTexel1D */
+   fetch_texel_2d_rgba_dxt5, 		/* FetchTexel2D */
+   NULL, /*impossible*/ 		/* FetchTexel3D */
+   NULL, /*impossible*/ 		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba_dxt5, 		/* FetchTexel2Df */
+   NULL, /*impossible*/ 		/* FetchTexel3Df */
+   NULL					/* StoreTexel */
+#else
+   _mesa_texstore_null,
+   _MESA_TEXFORMAT_NULL_OPS
+#endif
 };
 
 #if FEATURE_EXT_texture_sRGB
@@ -525,17 +717,16 @@ const struct gl_texture_format _mesa_texformat_srgb_dxt1 = {
    0,					/* TexelBytes */
    texstore_rgb_dxt1,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
-   fetch_texel_2d_rgb_dxt1, 		/* FetchTexel2D */
+   NULL, 				/* FetchTexel2D */
    NULL, /*impossible*/ 		/* FetchTexel3D */
    NULL, /*impossible*/ 		/* FetchTexel1Df */
-   fetch_texel_2d_f_rgb_dxt1, 		/* FetchTexel2Df */
+   fetch_texel_2d_f_srgb_dxt1, 		/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
 };
-#endif
 
-const struct gl_texture_format _mesa_texformat_rgba_dxt1 = {
-   MESA_FORMAT_RGBA_DXT1,		/* MesaFormat */
+const struct gl_texture_format _mesa_texformat_srgba_dxt1 = {
+   MESA_FORMAT_SRGBA_DXT1,		/* MesaFormat */
    GL_RGBA,				/* BaseFormat */
    GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
    4, /*approx*/			/* RedBits */
@@ -550,16 +741,16 @@ const struct gl_texture_format _mesa_texformat_rgba_dxt1 = {
    0,					/* TexelBytes */
    texstore_rgba_dxt1,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
-   fetch_texel_2d_rgba_dxt1, 		/* FetchTexel2D */
+   NULL, 				/* FetchTexel2D */
    NULL, /*impossible*/ 		/* FetchTexel3D */
    NULL, /*impossible*/ 		/* FetchTexel1Df */
-   fetch_texel_2d_f_rgba_dxt1, 		/* FetchTexel2Df */
+   fetch_texel_2d_f_srgba_dxt1, 	/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
 };
 
-const struct gl_texture_format _mesa_texformat_rgba_dxt3 = {
-   MESA_FORMAT_RGBA_DXT3,		/* MesaFormat */
+const struct gl_texture_format _mesa_texformat_srgba_dxt3 = {
+   MESA_FORMAT_SRGBA_DXT3,		/* MesaFormat */
    GL_RGBA,				/* BaseFormat */
    GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
    4, /*approx*/			/* RedBits */
@@ -574,16 +765,16 @@ const struct gl_texture_format _mesa_texformat_rgba_dxt3 = {
    0,					/* TexelBytes */
    texstore_rgba_dxt3,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
-   fetch_texel_2d_rgba_dxt3, 		/* FetchTexel2D */
+   NULL, 				/* FetchTexel2D */
    NULL, /*impossible*/ 		/* FetchTexel3D */
    NULL, /*impossible*/ 		/* FetchTexel1Df */
-   fetch_texel_2d_f_rgba_dxt3, 		/* FetchTexel2Df */
+   fetch_texel_2d_f_srgba_dxt3, 	/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
 };
 
-const struct gl_texture_format _mesa_texformat_rgba_dxt5 = {
-   MESA_FORMAT_RGBA_DXT5,		/* MesaFormat */
+const struct gl_texture_format _mesa_texformat_srgba_dxt5 = {
+   MESA_FORMAT_SRGBA_DXT5,		/* MesaFormat */
    GL_RGBA,				/* BaseFormat */
    GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
    4,/*approx*/				/* RedBits */
@@ -598,10 +789,11 @@ const struct gl_texture_format _mesa_texformat_rgba_dxt5 = {
    0,					/* TexelBytes */
    texstore_rgba_dxt5,			/* StoreTexImageFunc */
    NULL, /*impossible*/ 		/* FetchTexel1D */
-   fetch_texel_2d_rgba_dxt5, 		/* FetchTexel2D */
+   NULL, 				/* FetchTexel2D */
    NULL, /*impossible*/ 		/* FetchTexel3D */
    NULL, /*impossible*/ 		/* FetchTexel1Df */
-   fetch_texel_2d_f_rgba_dxt5, 		/* FetchTexel2Df */
+   fetch_texel_2d_f_srgba_dxt5, 	/* FetchTexel2Df */
    NULL, /*impossible*/ 		/* FetchTexel3Df */
    NULL					/* StoreTexel */
 };
+#endif
diff --git a/src/mesa/main/texenv.c b/src/mesa/main/texenv.c
index e072cea136..6d86a4275c 100644
--- a/src/mesa/main/texenv.c
+++ b/src/mesa/main/texenv.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -34,7 +35,420 @@
 #include "main/enums.h"
 #include "main/macros.h"
 #include "main/texenv.h"
-#include "math/m_xform.h"
+#include "main/texstate.h"
+
+
+#define TE_ERROR(errCode, msg, value)				\
+   _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));
+
+
+/** Set texture env mode */
+static void
+set_env_mode(GLcontext *ctx,
+             struct gl_texture_unit *texUnit,
+             GLenum mode)
+{
+   GLboolean legal;
+
+   if (texUnit->EnvMode == mode)
+      return;
+
+   switch (mode) {
+   case GL_MODULATE:
+   case GL_BLEND:
+   case GL_DECAL:
+   case GL_REPLACE:
+      legal = GL_TRUE;
+      break;
+   case GL_REPLACE_EXT:
+      mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */
+      legal = GL_TRUE;
+      break;
+   case GL_ADD:
+      legal = ctx->Extensions.EXT_texture_env_add;
+      break;
+   case GL_COMBINE:
+      legal = (ctx->Extensions.EXT_texture_env_combine ||
+               ctx->Extensions.ARB_texture_env_combine);
+      break;
+   case GL_COMBINE4_NV:
+      legal = ctx->Extensions.NV_texture_env_combine4;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (legal) {
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->EnvMode = mode;
+   }
+   else {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+   }
+}
+
+
+static void
+set_env_color(GLcontext *ctx,
+              struct gl_texture_unit *texUnit,
+              const GLfloat *color)
+{
+   GLfloat tmp[4];
+   tmp[0] = CLAMP(color[0], 0.0F, 1.0F);
+   tmp[1] = CLAMP(color[1], 0.0F, 1.0F);
+   tmp[2] = CLAMP(color[2], 0.0F, 1.0F);
+   tmp[3] = CLAMP(color[3], 0.0F, 1.0F);
+   if (TEST_EQ_4V(tmp, texUnit->EnvColor))
+      return;
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+   COPY_4FV(texUnit->EnvColor, tmp);
+}
+
+
+/** Set an RGB or A combiner mode/function */
+static void
+set_combiner_mode(GLcontext *ctx,
+                  struct gl_texture_unit *texUnit,
+                  GLenum pname, GLenum mode)
+{
+   GLboolean legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   switch (mode) {
+   case GL_REPLACE:
+   case GL_MODULATE:
+   case GL_ADD:
+   case GL_ADD_SIGNED:
+   case GL_INTERPOLATE:
+      legal = GL_TRUE;
+      break;
+   case GL_SUBTRACT:
+      legal = ctx->Extensions.ARB_texture_env_combine;
+      break;
+   case GL_DOT3_RGB_EXT:
+   case GL_DOT3_RGBA_EXT:
+      legal = (ctx->Extensions.EXT_texture_env_dot3 &&
+               pname == GL_COMBINE_RGB);
+      break;
+   case GL_DOT3_RGB:
+   case GL_DOT3_RGBA:
+      legal = (ctx->Extensions.ARB_texture_env_dot3 &&
+               pname == GL_COMBINE_RGB);
+      break;
+   case GL_MODULATE_ADD_ATI:
+   case GL_MODULATE_SIGNED_ADD_ATI:
+   case GL_MODULATE_SUBTRACT_ATI:
+      legal = ctx->Extensions.ATI_texture_env_combine3;
+      break;
+   case GL_BUMP_ENVMAP_ATI:
+      legal = (ctx->Extensions.ATI_envmap_bumpmap &&
+               pname == GL_COMBINE_RGB);
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+      return;
+   }
+
+   switch (pname) {
+   case GL_COMBINE_RGB:
+      if (texUnit->Combine.ModeRGB == mode)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ModeRGB = mode;
+      break;
+
+   case GL_COMBINE_ALPHA:
+      if (texUnit->Combine.ModeA == mode)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ModeA = mode;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+   }
+}
+
+
+
+/** Set an RGB or A combiner source term */
+static void
+set_combiner_source(GLcontext *ctx,
+                    struct gl_texture_unit *texUnit,
+                    GLenum pname, GLenum param)
+{
+   GLuint term;
+   GLboolean alpha, legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   /*
+    * Translate pname to (term, alpha).
+    */
+   switch (pname) {
+   case GL_SOURCE0_RGB:
+      term = 0;
+      alpha = GL_FALSE;
+      break;
+   case GL_SOURCE1_RGB:
+      term = 1;
+      alpha = GL_FALSE;
+      break;
+   case GL_SOURCE2_RGB:
+      term = 2;
+      alpha = GL_FALSE;
+      break;
+   case GL_SOURCE3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         term = 3;
+         alpha = GL_FALSE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   case GL_SOURCE0_ALPHA:
+      term = 0;
+      alpha = GL_TRUE;
+      break;
+   case GL_SOURCE1_ALPHA:
+      term = 1;
+      alpha = GL_TRUE;
+      break;
+   case GL_SOURCE2_ALPHA:
+      term = 2;
+      alpha = GL_TRUE;
+      break;
+   case GL_SOURCE3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         term = 3;
+         alpha = GL_TRUE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   assert(term < MAX_COMBINER_TERMS);
+
+   /*
+    * Error-check param (the source term)
+    */
+   switch (param) {
+   case GL_TEXTURE:
+   case GL_CONSTANT:
+   case GL_PRIMARY_COLOR:
+   case GL_PREVIOUS:
+      legal = GL_TRUE;
+      break;
+   case GL_TEXTURE0:
+   case GL_TEXTURE1:
+   case GL_TEXTURE2:
+   case GL_TEXTURE3:
+   case GL_TEXTURE4:
+   case GL_TEXTURE5:
+   case GL_TEXTURE6:
+   case GL_TEXTURE7:
+      legal = (ctx->Extensions.ARB_texture_env_crossbar &&
+               param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits);
+      break;
+   case GL_ZERO:
+      legal = (ctx->Extensions.ATI_texture_env_combine3 ||
+               ctx->Extensions.NV_texture_env_combine4);
+      break;
+   case GL_ONE:
+      legal = ctx->Extensions.ATI_texture_env_combine3;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
+   if (alpha)
+      texUnit->Combine.SourceA[term] = param;
+   else
+      texUnit->Combine.SourceRGB[term] = param;
+}
+
+
+/** Set an RGB or A combiner operand term */
+static void
+set_combiner_operand(GLcontext *ctx,
+                     struct gl_texture_unit *texUnit,
+                     GLenum pname, GLenum param)
+{
+   GLuint term;
+   GLboolean alpha, legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_OPERAND0_RGB:
+      term = 0;
+      alpha = GL_FALSE;
+      break;
+   case GL_OPERAND1_RGB:
+      term = 1;
+      alpha = GL_FALSE;
+      break;
+   case GL_OPERAND2_RGB:
+      if (ctx->Extensions.ARB_texture_env_combine) {
+         term = 2;
+         alpha = GL_FALSE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   case GL_OPERAND3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         term = 3;
+         alpha = GL_FALSE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   case GL_OPERAND0_ALPHA:
+      term = 0;
+      alpha = GL_TRUE;
+      break;
+   case GL_OPERAND1_ALPHA:
+      term = 1;
+      alpha = GL_TRUE;
+      break;
+   case GL_OPERAND2_ALPHA:
+      if (ctx->Extensions.ARB_texture_env_combine) {
+         term = 2;
+         alpha = GL_TRUE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   case GL_OPERAND3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         term = 3;
+         alpha = GL_TRUE;
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+         return;
+      }
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   assert(term < MAX_COMBINER_TERMS);
+
+   /*
+    * Error-check param (the source operand)
+    */
+   switch (param) {
+   case GL_SRC_COLOR:
+   case GL_ONE_MINUS_SRC_COLOR:
+      legal = !alpha;
+      break;
+   case GL_SRC_ALPHA:
+   case GL_ONE_MINUS_SRC_ALPHA:
+      legal = GL_TRUE;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
+   if (alpha)
+      texUnit->Combine.OperandA[term] = param;
+   else
+      texUnit->Combine.OperandRGB[term] = param;
+}
+
+
+static void
+set_combiner_scale(GLcontext *ctx,
+                   struct gl_texture_unit *texUnit,
+                   GLenum pname, GLfloat scale)
+{
+   GLuint shift;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   if (scale == 1.0F) {
+      shift = 0;
+   }
+   else if (scale == 2.0F) {
+      shift = 1;
+   }
+   else if (scale == 4.0F) {
+      shift = 2;
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_VALUE,
+                   "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
+      return;
+   }
+
+   switch (pname) {
+   case GL_RGB_SCALE:
+      if (texUnit->Combine.ScaleShiftRGB == shift)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ScaleShiftRGB = shift;
+      break;
+   case GL_ALPHA_SCALE:
+      if (texUnit->Combine.ScaleShiftA == shift)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ScaleShiftA = shift;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+   }
+}
 
 
 
@@ -53,378 +467,62 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-
-#define TE_ERROR(errCode, msg, value)				\
-   _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    if (target == GL_TEXTURE_ENV) {
       switch (pname) {
       case GL_TEXTURE_ENV_MODE:
-         {
-            GLenum mode = (GLenum) (GLint) *param;
-            if (mode == GL_REPLACE_EXT)
-               mode = GL_REPLACE;
-	    if (texUnit->EnvMode == mode)
-	       return;
-            if (mode == GL_MODULATE ||
-                mode == GL_BLEND ||
-                mode == GL_DECAL ||
-                mode == GL_REPLACE ||
-                (mode == GL_ADD && ctx->Extensions.EXT_texture_env_add) ||
-                (mode == GL_COMBINE &&
-                 (ctx->Extensions.EXT_texture_env_combine ||
-                  ctx->Extensions.ARB_texture_env_combine))) {
-               /* legal */
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texUnit->EnvMode = mode;
-            }
-            else {
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-               return;
-            }
-         }
+         set_env_mode(ctx, texUnit, (GLenum) (GLint) param[0]);
          break;
       case GL_TEXTURE_ENV_COLOR:
-         {
-            GLfloat tmp[4];
-            tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
-            tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
-            tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
-            tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
-            if (TEST_EQ_4V(tmp, texUnit->EnvColor))
-               return;
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            COPY_4FV(texUnit->EnvColor, tmp);
-         }
+         set_env_color(ctx, texUnit, param);
          break;
       case GL_COMBINE_RGB:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum mode = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.ModeRGB == mode)
-	       return;
-	    switch (mode) {
-	    case GL_REPLACE:
-	    case GL_MODULATE:
-	    case GL_ADD:
-	    case GL_ADD_SIGNED:
-	    case GL_INTERPOLATE:
-               /* OK */
-	       break;
-            case GL_SUBTRACT:
-               if (!ctx->Extensions.ARB_texture_env_combine) {
-                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-                  return;
-               }
-               break;
-	    case GL_DOT3_RGB_EXT:
-	    case GL_DOT3_RGBA_EXT:
-	       if (!ctx->Extensions.EXT_texture_env_dot3) {
-                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-		  return;
-	       }
-	       break;
-	    case GL_DOT3_RGB:
-	    case GL_DOT3_RGBA:
-	       if (!ctx->Extensions.ARB_texture_env_dot3) {
-                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-		  return;
-	       }
-	       break;
-	    case GL_MODULATE_ADD_ATI:
-	    case GL_MODULATE_SIGNED_ADD_ATI:
-	    case GL_MODULATE_SUBTRACT_ATI:
-	       if (!ctx->Extensions.ATI_texture_env_combine3) {
-                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-		  return;
-	       }
-	       break;
-	    default:
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-	       return;
-	    }
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->Combine.ModeRGB = mode;
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
-         break;
       case GL_COMBINE_ALPHA:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum mode = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.ModeA == mode)
-	       return;
-            switch (mode) {
-	    case GL_REPLACE:
-	    case GL_MODULATE:
-	    case GL_ADD:
-	    case GL_ADD_SIGNED:
-	    case GL_INTERPOLATE:
-	       /* OK */
-	       break;
-	    case GL_SUBTRACT:
-	       if (!ctx->Extensions.ARB_texture_env_combine) {
-		  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-		  return;
-	       }
-	       break;
-	    case GL_MODULATE_ADD_ATI:
-	    case GL_MODULATE_SIGNED_ADD_ATI:
-	    case GL_MODULATE_SUBTRACT_ATI:
-	       if (!ctx->Extensions.ATI_texture_env_combine3) {
-                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-		  return;
-	       }
-	       break;
-	    default:
-	       TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
-	       return;
-	    }
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->Combine.ModeA = mode;
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
+         set_combiner_mode(ctx, texUnit, pname, (GLenum) (GLint) param[0]);
 	 break;
       case GL_SOURCE0_RGB:
       case GL_SOURCE1_RGB:
       case GL_SOURCE2_RGB:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-	     ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum source = (GLenum) (GLint) *param;
-	    const GLuint s = pname - GL_SOURCE0_RGB;
-	    if (texUnit->Combine.SourceRGB[s] == source)
-	       return;
-            if (source == GL_TEXTURE ||
-                source == GL_CONSTANT ||
-                source == GL_PRIMARY_COLOR ||
-                source == GL_PREVIOUS ||
-                (ctx->Extensions.ARB_texture_env_crossbar &&
-                 source >= GL_TEXTURE0 &&
-                 source < GL_TEXTURE0 + ctx->Const.MaxTextureUnits) ||
-                (ctx->Extensions.ATI_texture_env_combine3 &&
-                 (source == GL_ZERO || source == GL_ONE))) {
-               /* legal */
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.SourceRGB[s] = source;
-            }
-            else {
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
-	 break;
+      case GL_SOURCE3_RGB_NV:
       case GL_SOURCE0_ALPHA:
       case GL_SOURCE1_ALPHA:
       case GL_SOURCE2_ALPHA:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum source = (GLenum) (GLint) *param;
-	    const GLuint s = pname - GL_SOURCE0_ALPHA;
-	    if (texUnit->Combine.SourceA[s] == source)
-	       return;
-            if (source == GL_TEXTURE ||
-                source == GL_CONSTANT ||
-                source == GL_PRIMARY_COLOR ||
-                source == GL_PREVIOUS ||
-                (ctx->Extensions.ARB_texture_env_crossbar &&
-                 source >= GL_TEXTURE0 &&
-                 source < GL_TEXTURE0 + ctx->Const.MaxTextureUnits) ||
-		(ctx->Extensions.ATI_texture_env_combine3 &&
-                 (source == GL_ZERO || source == GL_ONE))) {
-               /* legal */
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.SourceA[s] = source;
-            }
-            else {
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
+      case GL_SOURCE3_ALPHA_NV:
+         set_combiner_source(ctx, texUnit, pname, (GLenum) (GLint) param[0]);
 	 break;
       case GL_OPERAND0_RGB:
       case GL_OPERAND1_RGB:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-	     ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    const GLuint s = pname - GL_OPERAND0_RGB;
-	    if (texUnit->Combine.OperandRGB[s] == operand)
-	       return;
-	    switch (operand) {
-	    case GL_SRC_COLOR:
-	    case GL_ONE_MINUS_SRC_COLOR:
-	    case GL_SRC_ALPHA:
-	    case GL_ONE_MINUS_SRC_ALPHA:
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.OperandRGB[s] = operand;
-	       break;
-	    default:
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
-	 break;
+      case GL_OPERAND2_RGB:
+      case GL_OPERAND3_RGB_NV:
       case GL_OPERAND0_ALPHA:
       case GL_OPERAND1_ALPHA:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.OperandA[pname-GL_OPERAND0_ALPHA] == operand)
-	       return;
-	    switch (operand) {
-	    case GL_SRC_ALPHA:
-	    case GL_ONE_MINUS_SRC_ALPHA:
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.OperandA[pname-GL_OPERAND0_ALPHA] = operand;
-	       break;
-	    default:
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
-	 break;
-      case GL_OPERAND2_RGB:
-	 if (ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.OperandRGB[2] == operand)
-	       return;
-	    switch (operand) {
-	    case GL_SRC_COLOR:           /* ARB combine only */
-	    case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
-	    case GL_SRC_ALPHA:
-	    case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.OperandRGB[2] = operand;
-               break;
-	    default:
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else if (ctx->Extensions.EXT_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.OperandRGB[2] == operand)
-	       return;
-	    /* operand must be GL_SRC_ALPHA which is the initial value - thus
-	       don't need to actually compare the operand to the possible value */
-	    else {
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
-	 break;
       case GL_OPERAND2_ALPHA:
-	 if (ctx->Extensions.ARB_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.OperandA[2] == operand)
-	       return;
-	    switch (operand) {
-	    case GL_SRC_ALPHA:
-	    case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
-	       FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	       texUnit->Combine.OperandA[2] = operand;
-	       break;
-	    default:
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else if (ctx->Extensions.EXT_texture_env_combine) {
-	    const GLenum operand = (GLenum) (GLint) *param;
-	    if (texUnit->Combine.OperandA[2] == operand)
-	       return;
-	    /* operand must be GL_SRC_ALPHA which is the initial value - thus
-	       don't need to actually compare the operand to the possible value */
-	    else {
-               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
-	       return;
-	    }
-	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
-	 }
+      case GL_OPERAND3_ALPHA_NV:
+         set_combiner_operand(ctx, texUnit, pname, (GLenum) (GLint) param[0]);
 	 break;
       case GL_RGB_SCALE:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    GLuint newshift;
-	    if (*param == 1.0) {
-	       newshift = 0;
-	    }
-	    else if (*param == 2.0) {
-	       newshift = 1;
-	    }
-	    else if (*param == 4.0) {
-	       newshift = 2;
-	    }
-	    else {
-	       _mesa_error( ctx, GL_INVALID_VALUE,
-                            "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
-	       return;
-	    }
-	    if (texUnit->Combine.ScaleShiftRGB == newshift)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->Combine.ScaleShiftRGB = newshift;
+      case GL_ALPHA_SCALE:
+         set_combiner_scale(ctx, texUnit, pname, param[0]);
+	 break;
+      case GL_BUMP_TARGET_ATI:
+         if (!ctx->Extensions.ATI_envmap_bumpmap) {
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
+	    return;
 	 }
-	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	 if (((GLenum) (GLint) param[0] < GL_TEXTURE0) ||
+	 ((GLenum) (GLint) param[0] > GL_TEXTURE31)) {
+	    /* spec doesn't say this but it seems logical */
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]);
 	    return;
 	 }
-	 break;
-      case GL_ALPHA_SCALE:
-	 if (ctx->Extensions.EXT_texture_env_combine ||
-             ctx->Extensions.ARB_texture_env_combine) {
-	    GLuint newshift;
-	    if (*param == 1.0) {
-	       newshift = 0;
-	    }
-	    else if (*param == 2.0) {
-	       newshift = 1;
-	    }
-	    else if (*param == 4.0) {
-	       newshift = 2;
-	    }
-	    else {
-	       _mesa_error( ctx, GL_INVALID_VALUE,
-                            "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
-	       return;
-	    }
-	    if (texUnit->Combine.ScaleShiftA == newshift)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->Combine.ScaleShiftA = newshift;
+	 if (!((1 << ((GLenum) (GLint) param[0] - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) {
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", (GLenum) (GLint) param[0]);
+	    return;
 	 }
 	 else {
-            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
-	    return;
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->BumpTarget = (GLenum) (GLint) param[0];
 	 }
 	 break;
       default:
@@ -533,6 +631,154 @@ _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
 }
 
 
+
+/**
+ * Helper for glGetTexEnvi/f()
+ * \return  value of queried pname or -1 if error.
+ */
+static GLint
+get_texenvi(GLcontext *ctx, const struct gl_texture_unit *texUnit,
+            GLenum pname)
+{
+   switch (pname) {
+   case GL_TEXTURE_ENV_MODE:
+      return texUnit->EnvMode;
+      break;
+   case GL_COMBINE_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return texUnit->Combine.ModeRGB;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_COMBINE_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return texUnit->Combine.ModeA;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE0_RGB:
+   case GL_SOURCE1_RGB:
+   case GL_SOURCE2_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned rgb_idx = pname - GL_SOURCE0_RGB;
+         return texUnit->Combine.SourceRGB[rgb_idx];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.SourceRGB[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE0_ALPHA:
+   case GL_SOURCE1_ALPHA:
+   case GL_SOURCE2_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;
+         return texUnit->Combine.SourceA[alpha_idx];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.SourceA[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND0_RGB:
+   case GL_OPERAND1_RGB:
+   case GL_OPERAND2_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned op_rgb = pname - GL_OPERAND0_RGB;
+         return texUnit->Combine.OperandRGB[op_rgb];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.OperandRGB[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND0_ALPHA:
+   case GL_OPERAND1_ALPHA:
+   case GL_OPERAND2_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;
+         return texUnit->Combine.OperandA[op_alpha];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.OperandA[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_RGB_SCALE:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return 1 << texUnit->Combine.ScaleShiftRGB;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_ALPHA_SCALE:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return 1 << texUnit->Combine.ScaleShiftA;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_BUMP_TARGET_ATI:
+      /* spec doesn't say so, but I think this should be queryable */
+      if (ctx->Extensions.ATI_envmap_bumpmap) {
+         return texUnit->BumpTarget;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+
+   default:
+      ;
+   }
+
+   return -1; /* error */
+}
+
+
+
 void GLAPIENTRY
 _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
 {
@@ -548,114 +794,17 @@ _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    if (target == GL_TEXTURE_ENV) {
-      switch (pname) {
-         case GL_TEXTURE_ENV_MODE:
-            *params = ENUM_TO_FLOAT(texUnit->EnvMode);
-            break;
-         case GL_TEXTURE_ENV_COLOR:
-            COPY_4FV( params, texUnit->EnvColor );
-            break;
-         case GL_COMBINE_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               *params = (GLfloat) texUnit->Combine.ModeRGB;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_COMBINE_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               *params = (GLfloat) texUnit->Combine.ModeA;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_SOURCE0_RGB:
-         case GL_SOURCE1_RGB:
-         case GL_SOURCE2_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned rgb_idx = pname - GL_SOURCE0_RGB;
-               *params = (GLfloat) texUnit->Combine.SourceRGB[rgb_idx];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_SOURCE0_ALPHA:
-         case GL_SOURCE1_ALPHA:
-         case GL_SOURCE2_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;
-               *params = (GLfloat) texUnit->Combine.SourceA[alpha_idx];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_OPERAND0_RGB:
-         case GL_OPERAND1_RGB:
-         case GL_OPERAND2_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned op_rgb = pname - GL_OPERAND0_RGB;
-               *params = (GLfloat) texUnit->Combine.OperandRGB[op_rgb];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_OPERAND0_ALPHA:
-         case GL_OPERAND1_ALPHA:
-         case GL_OPERAND2_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;
-               *params = (GLfloat) texUnit->Combine.OperandA[op_alpha];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-            }
-            break;
-         case GL_RGB_SCALE:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               if (texUnit->Combine.ScaleShiftRGB == 0)
-                  *params = 1.0;
-               else if (texUnit->Combine.ScaleShiftRGB == 1)
-                  *params = 2.0;
-               else
-                  *params = 4.0;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-               return;
-            }
-            break;
-         case GL_ALPHA_SCALE:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               if (texUnit->Combine.ScaleShiftA == 0)
-                  *params = 1.0;
-               else if (texUnit->Combine.ScaleShiftA == 1)
-                  *params = 2.0;
-               else
-                  *params = 4.0;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
-               return;
-            }
-            break;
-         default:
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname=0x%x)", pname);
+      if (pname == GL_TEXTURE_ENV_COLOR) {
+         COPY_4FV( params, texUnit->EnvColor );
+      }
+      else {
+         GLint val = get_texenvi(ctx, texUnit, pname);
+         if (val >= 0) {
+            *params = (GLfloat) val;
+         }
       }
    }
    else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
@@ -709,118 +858,20 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    if (target == GL_TEXTURE_ENV) {
-      switch (pname) {
-         case GL_TEXTURE_ENV_MODE:
-            *params = (GLint) texUnit->EnvMode;
-            break;
-         case GL_TEXTURE_ENV_COLOR:
-            params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
-            params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
-            params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
-            params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
-            break;
-         case GL_COMBINE_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               *params = (GLint) texUnit->Combine.ModeRGB;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_COMBINE_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               *params = (GLint) texUnit->Combine.ModeA;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_SOURCE0_RGB:
-         case GL_SOURCE1_RGB:
-         case GL_SOURCE2_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned rgb_idx = pname - GL_SOURCE0_RGB;
-               *params = (GLint) texUnit->Combine.SourceRGB[rgb_idx];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_SOURCE0_ALPHA:
-         case GL_SOURCE1_ALPHA:
-         case GL_SOURCE2_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;
-               *params = (GLint) texUnit->Combine.SourceA[alpha_idx];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_OPERAND0_RGB:
-         case GL_OPERAND1_RGB:
-         case GL_OPERAND2_RGB:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned op_rgb = pname - GL_OPERAND0_RGB;
-               *params = (GLint) texUnit->Combine.OperandRGB[op_rgb];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_OPERAND0_ALPHA:
-         case GL_OPERAND1_ALPHA:
-         case GL_OPERAND2_ALPHA:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-	       const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;
-               *params = (GLint) texUnit->Combine.OperandA[op_alpha];
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-            }
-            break;
-         case GL_RGB_SCALE:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               if (texUnit->Combine.ScaleShiftRGB == 0)
-                  *params = 1;
-               else if (texUnit->Combine.ScaleShiftRGB == 1)
-                  *params = 2;
-               else
-                  *params = 4;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-               return;
-            }
-            break;
-         case GL_ALPHA_SCALE:
-            if (ctx->Extensions.EXT_texture_env_combine ||
-                ctx->Extensions.ARB_texture_env_combine) {
-               if (texUnit->Combine.ScaleShiftA == 0)
-                  *params = 1;
-               else if (texUnit->Combine.ScaleShiftA == 1)
-                  *params = 2;
-               else
-                  *params = 4;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
-               return;
-            }
-            break;
-         default:
-            _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname=0x%x)",
-                        pname);
+      if (pname == GL_TEXTURE_ENV_COLOR) {
+         params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
+         params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
+         params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
+         params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
+      }
+      else {
+         GLint val = get_texenvi(ctx, texUnit, pname);
+         if (val >= 0) {
+            *params = val;
+         }
       }
    }
    else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
@@ -859,3 +910,169 @@ _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
 }
 
 
+/**
+ * Why does ATI_envmap_bumpmap require new entrypoints? Should just
+ * reuse TexEnv ones...
+ */
+void GLAPIENTRY
+_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param )
+{
+   GLfloat p[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      /* This isn't an "official" error case, but let's tell the user
+       * that something's wrong.
+       */
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI");
+      return;
+   }
+
+   if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      /* hope that conversion is correct here */
+      p[0] = INT_TO_FLOAT( param[0] );
+      p[1] = INT_TO_FLOAT( param[1] );
+      p[2] = INT_TO_FLOAT( param[2] );
+      p[3] = INT_TO_FLOAT( param[3] );
+   }
+   else {
+      p[0] = (GLfloat) param[0];
+      p[1] = p[2] = p[3] = 0.0F;  /* init to zero, just to be safe */
+   }
+   _mesa_TexBumpParameterfvATI( pname, p );
+}
+
+
+void GLAPIENTRY
+_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param )
+{
+   struct gl_texture_unit *texUnit;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      if (TEST_EQ_4V(param, texUnit->RotMatrix))
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      COPY_4FV(texUnit->RotMatrix, param);
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" );
+      return;
+   }
+   /* Drivers might want to know about this, instead of dedicated function
+      just shove it into TexEnv where it really belongs anyway */
+   if (ctx->Driver.TexEnv) {
+      (*ctx->Driver.TexEnv)( ctx, 0, pname, param );
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param )
+{
+   const struct gl_texture_unit *texUnit;
+   GLuint i;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {
+      /* spec leaves open to support larger matrices.
+         Don't think anyone would ever want to use it
+         (and apps almost certainly would not understand it and
+         thus fail to submit matrices correctly) so hardcode this. */
+      *param = 4;
+   }
+   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      /* hope that conversion is correct here */
+      param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]);
+      param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]);
+      param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]);
+      param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]);
+   }
+   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {
+      GLint count = 0;
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            count++;
+         }
+      }
+      *param = count;
+   }
+   else if (pname == GL_BUMP_TEX_UNITS_ATI) {
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            *param++ = i + GL_TEXTURE0;
+         }
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );
+      return;
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param )
+{
+   const struct gl_texture_unit *texUnit;
+   GLuint i;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {
+      /* spec leaves open to support larger matrices.
+         Don't think anyone would ever want to use it
+         (and apps might not understand it) so hardcode this. */
+      *param = 4.0F;
+   }
+   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      param[0] = texUnit->RotMatrix[0];
+      param[1] = texUnit->RotMatrix[1];
+      param[2] = texUnit->RotMatrix[2];
+      param[3] = texUnit->RotMatrix[3];
+   }
+   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {
+      GLint count = 0;
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            count++;
+         }
+      }
+      *param = (GLfloat) count;
+   }
+   else if (pname == GL_BUMP_TEX_UNITS_ATI) {
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            *param++ = (GLfloat) (i + GL_TEXTURE0);
+         }
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );
+      return;
+   }
+}
diff --git a/src/mesa/main/texenv.h b/src/mesa/main/texenv.h
index bdff7fdb82..1e9c5faed7 100644
--- a/src/mesa/main/texenv.h
+++ b/src/mesa/main/texenv.h
@@ -48,5 +48,16 @@ _mesa_TexEnvi( GLenum target, GLenum pname, GLint param );
 extern void GLAPIENTRY
 _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param );
 
+extern void GLAPIENTRY
+_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param );
+
+extern void GLAPIENTRY
+_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param );
+
+extern void GLAPIENTRY
+_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param );
+
+extern void GLAPIENTRY
+_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param );
 
 #endif /* TEXENV_H */
diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c
index 6a57d50193..2f3e47e69e 100644
--- a/src/mesa/main/texenvprogram.c
+++ b/src/mesa/main/texenvprogram.c
@@ -2,6 +2,7 @@
  * 
  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
+ * Copyright 2009 VMware, Inc.  All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
@@ -26,8 +27,7 @@
  **************************************************************************/
 
 #include "glheader.h"
-#include "macros.h"
-#include "enums.h"
+#include "imports.h"
 #include "shader/program.h"
 #include "shader/prog_parameter.h"
 #include "shader/prog_cache.h"
@@ -61,42 +61,61 @@ struct texenvprog_cache_item
    struct texenvprog_cache_item *next;
 };
 
+static GLboolean
+texenv_doing_secondary_color(GLcontext *ctx)
+{
+   if (ctx->Light.Enabled &&
+       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR))
+      return GL_TRUE;
+
+   if (ctx->Fog.ColorSumEnabled)
+      return GL_TRUE;
+
+   return GL_FALSE;
+}
 
 /**
- * This MAX is probably a bit generous, but that's OK.  There can be
- * up to four instructions per texture unit (TEX + 3 for combine),
- * then there's fog and specular add.
+ * Up to nine instructions per tex unit, plus fog, specular color.
  */
-#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 4) + 12)
+#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 9) + 12)
 
 #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
 
 struct mode_opt {
-   GLuint Source:4;
-   GLuint Operand:3;
+#ifdef __GNUC__
+   __extension__ GLubyte Source:4;  /**< SRC_x */
+   __extension__ GLubyte Operand:3; /**< OPR_x */
+#else
+   GLubyte Source;  /**< SRC_x */
+   GLubyte Operand; /**< OPR_x */
+#endif
 };
 
 struct state_key {
-   GLbitfield enabled_units;
+   GLuint nr_enabled_units:8;
+   GLuint enabled_units:8;
    GLuint separate_specular:1;
    GLuint fog_enabled:1;
-   GLuint fog_mode:2;
+   GLuint fog_mode:2;          /**< FOG_x */
+   GLuint inputs_available:12;
 
+   /* NOTE: This array of structs must be last! (see "keySize" below) */
    struct {
       GLuint enabled:1;
-      GLuint source_index:3;   /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */
+      GLuint source_index:3;   /**< TEXTURE_x_INDEX */
       GLuint shadow:1;
       GLuint ScaleShiftRGB:2;
       GLuint ScaleShiftA:2;
 
-      GLuint NumArgsRGB:2;
-      GLuint ModeRGB:4;
-      struct mode_opt OptRGB[3];
+      GLuint NumArgsRGB:3;  /**< up to MAX_COMBINER_TERMS */
+      GLuint ModeRGB:5;     /**< MODE_x */
+
+      GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */
+      GLuint ModeA:5;     /**< MODE_x */
 
-      GLuint NumArgsA:2;
-      GLuint ModeA:4;
-      struct mode_opt OptA[3];
-   } unit[8];
+      struct mode_opt OptRGB[MAX_COMBINER_TERMS];
+      struct mode_opt OptA[MAX_COMBINER_TERMS];
+   } unit[MAX_TEXTURE_UNITS];
 };
 
 #define FOG_LINEAR  0
@@ -131,7 +150,9 @@ static GLuint translate_operand( GLenum operand )
    case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;
    case GL_ZERO: return OPR_ZERO;
    case GL_ONE: return OPR_ONE;
-   default:	return OPR_UNKNOWN;
+   default:
+      assert(0);
+      return OPR_UNKNOWN;
    }
 }
 
@@ -147,6 +168,7 @@ static GLuint translate_operand( GLenum operand )
 #define SRC_CONSTANT 9
 #define SRC_PRIMARY_COLOR 10
 #define SRC_PREVIOUS 11
+#define SRC_ZERO     12
 #define SRC_UNKNOWN  15
 
 static GLuint translate_source( GLenum src )
@@ -164,32 +186,50 @@ static GLuint translate_source( GLenum src )
    case GL_CONSTANT: return SRC_CONSTANT;
    case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;
    case GL_PREVIOUS: return SRC_PREVIOUS;
-   default: return SRC_UNKNOWN;
+   case GL_ZERO:
+      return SRC_ZERO;
+   default:
+      assert(0);
+      return SRC_UNKNOWN;
    }
 }
 
-#define MODE_REPLACE       0
-#define MODE_MODULATE      1
-#define MODE_ADD           2
-#define MODE_ADD_SIGNED    3
-#define MODE_INTERPOLATE   4
-#define MODE_SUBTRACT      5
-#define MODE_DOT3_RGB      6
-#define MODE_DOT3_RGB_EXT  7
-#define MODE_DOT3_RGBA     8
-#define MODE_DOT3_RGBA_EXT 9
-#define MODE_MODULATE_ADD_ATI           10
-#define MODE_MODULATE_SIGNED_ADD_ATI    11
-#define MODE_MODULATE_SUBTRACT_ATI      12
-#define MODE_UNKNOWN       15
-
-static GLuint translate_mode( GLenum mode )
+#define MODE_REPLACE                     0  /* r = a0 */
+#define MODE_MODULATE                    1  /* r = a0 * a1 */
+#define MODE_ADD                         2  /* r = a0 + a1 */
+#define MODE_ADD_SIGNED                  3  /* r = a0 + a1 - 0.5 */
+#define MODE_INTERPOLATE                 4  /* r = a0 * a2 + a1 * (1 - a2) */
+#define MODE_SUBTRACT                    5  /* r = a0 - a1 */
+#define MODE_DOT3_RGB                    6  /* r = a0 . a1 */
+#define MODE_DOT3_RGB_EXT                7  /* r = a0 . a1 */
+#define MODE_DOT3_RGBA                   8  /* r = a0 . a1 */
+#define MODE_DOT3_RGBA_EXT               9  /* r = a0 . a1 */
+#define MODE_MODULATE_ADD_ATI           10  /* r = a0 * a2 + a1 */
+#define MODE_MODULATE_SIGNED_ADD_ATI    11  /* r = a0 * a2 + a1 - 0.5 */
+#define MODE_MODULATE_SUBTRACT_ATI      12  /* r = a0 * a2 - a1 */
+#define MODE_ADD_PRODUCTS               13  /* r = a0 * a1 + a2 * a3 */
+#define MODE_ADD_PRODUCTS_SIGNED        14  /* r = a0 * a1 + a2 * a3 - 0.5 */
+#define MODE_BUMP_ENVMAP_ATI            15  /* special */
+#define MODE_UNKNOWN                    16
+
+/**
+ * Translate GL combiner state into a MODE_x value
+ */
+static GLuint translate_mode( GLenum envMode, GLenum mode )
 {
    switch (mode) {
    case GL_REPLACE: return MODE_REPLACE;
    case GL_MODULATE: return MODE_MODULATE;
-   case GL_ADD: return MODE_ADD;
-   case GL_ADD_SIGNED: return MODE_ADD_SIGNED;
+   case GL_ADD:
+      if (envMode == GL_COMBINE4_NV)
+         return MODE_ADD_PRODUCTS;
+      else
+         return MODE_ADD;
+   case GL_ADD_SIGNED:
+      if (envMode == GL_COMBINE4_NV)
+         return MODE_ADD_PRODUCTS_SIGNED;
+      else
+         return MODE_ADD_SIGNED;
    case GL_INTERPOLATE: return MODE_INTERPOLATE;
    case GL_SUBTRACT: return MODE_SUBTRACT;
    case GL_DOT3_RGB: return MODE_DOT3_RGB;
@@ -199,84 +239,257 @@ static GLuint translate_mode( GLenum mode )
    case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;
    case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;
    case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;
-   default: return MODE_UNKNOWN;
+   case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI;
+   default:
+      assert(0);
+      return MODE_UNKNOWN;
+   }
+}
+
+
+/**
+ * Do we need to clamp the results of the given texture env/combine mode?
+ * If the inputs to the mode are in [0,1] we don't always have to clamp
+ * the results.
+ */
+static GLboolean
+need_saturate( GLuint mode )
+{
+   switch (mode) {
+   case MODE_REPLACE:
+   case MODE_MODULATE:
+   case MODE_INTERPOLATE:
+      return GL_FALSE;
+   case MODE_ADD:
+   case MODE_ADD_SIGNED:
+   case MODE_SUBTRACT:
+   case MODE_DOT3_RGB:
+   case MODE_DOT3_RGB_EXT:
+   case MODE_DOT3_RGBA:
+   case MODE_DOT3_RGBA_EXT:
+   case MODE_MODULATE_ADD_ATI:
+   case MODE_MODULATE_SIGNED_ADD_ATI:
+   case MODE_MODULATE_SUBTRACT_ATI:
+   case MODE_ADD_PRODUCTS:
+   case MODE_ADD_PRODUCTS_SIGNED:
+   case MODE_BUMP_ENVMAP_ATI:
+      return GL_TRUE;
+   default:
+      assert(0);
    }
 }
 
-#define TEXTURE_UNKNOWN_INDEX 7
+
+
+/**
+ * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.
+ */
 static GLuint translate_tex_src_bit( GLbitfield bit )
 {
-   switch (bit) {
-   case TEXTURE_1D_BIT:   return TEXTURE_1D_INDEX;
-   case TEXTURE_2D_BIT:   return TEXTURE_2D_INDEX;
-   case TEXTURE_RECT_BIT: return TEXTURE_RECT_INDEX;
-   case TEXTURE_3D_BIT:   return TEXTURE_3D_INDEX;
-   case TEXTURE_CUBE_BIT: return TEXTURE_CUBE_INDEX;
-   default: return TEXTURE_UNKNOWN_INDEX;
+   ASSERT(bit);
+   return _mesa_ffs(bit) - 1;
+}
+
+
+#define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)
+#define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)
+
+/**
+ * Identify all possible varying inputs.  The fragment program will
+ * never reference non-varying inputs, but will track them via state
+ * constants instead.
+ *
+ * This function figures out all the inputs that the fragment program
+ * has access to.  The bitmask is later reduced to just those which
+ * are actually referenced.
+ */
+static GLbitfield get_fp_input_mask( GLcontext *ctx )
+{
+   /* _NEW_PROGRAM */
+   const GLboolean vertexShader = (ctx->Shader.CurrentProgram &&
+				   ctx->Shader.CurrentProgram->LinkStatus &&
+                                   ctx->Shader.CurrentProgram->VertexProgram);
+   const GLboolean vertexProgram = ctx->VertexProgram._Enabled;
+   GLbitfield fp_inputs = 0x0;
+
+   if (ctx->VertexProgram._Overriden) {
+      /* Somebody's messing with the vertex program and we don't have
+       * a clue what's happening.  Assume that it could be producing
+       * all possible outputs.
+       */
+      fp_inputs = ~0;
+   }
+   else if (ctx->RenderMode == GL_FEEDBACK) {
+      /* _NEW_RENDERMODE */
+      fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);
    }
+   else if (!(vertexProgram || vertexShader) ||
+            !ctx->VertexProgram._Current) {
+      /* Fixed function vertex logic */
+      /* _NEW_ARRAY */
+      GLbitfield varying_inputs = ctx->varying_vp_inputs;
+
+      /* These get generated in the setup routine regardless of the
+       * vertex program:
+       */
+      /* _NEW_POINT */
+      if (ctx->Point.PointSprite)
+         varying_inputs |= FRAG_BITS_TEX_ANY;
+
+      /* First look at what values may be computed by the generated
+       * vertex program:
+       */
+      /* _NEW_LIGHT */
+      if (ctx->Light.Enabled) {
+         fp_inputs |= FRAG_BIT_COL0;
+
+         if (texenv_doing_secondary_color(ctx))
+            fp_inputs |= FRAG_BIT_COL1;
+      }
+
+      /* _NEW_TEXTURE */
+      fp_inputs |= (ctx->Texture._TexGenEnabled |
+                    ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;
+
+      /* Then look at what might be varying as a result of enabled
+       * arrays, etc:
+       */
+      if (varying_inputs & VERT_BIT_COLOR0)
+         fp_inputs |= FRAG_BIT_COL0;
+      if (varying_inputs & VERT_BIT_COLOR1)
+         fp_inputs |= FRAG_BIT_COL1;
+
+      fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) 
+                    << FRAG_ATTRIB_TEX0);
+
+   }
+   else {
+      /* calculate from vp->outputs */
+      struct gl_vertex_program *vprog;
+      GLbitfield vp_outputs;
+
+      /* Choose GLSL vertex shader over ARB vertex program.  Need this
+       * since vertex shader state validation comes after fragment state
+       * validation (see additional comments in state.c).
+       */
+      if (vertexShader)
+         vprog = ctx->Shader.CurrentProgram->VertexProgram;
+      else
+         vprog = ctx->VertexProgram.Current;
+
+      vp_outputs = vprog->Base.OutputsWritten;
+
+      /* These get generated in the setup routine regardless of the
+       * vertex program:
+       */
+      /* _NEW_POINT */
+      if (ctx->Point.PointSprite)
+         vp_outputs |= FRAG_BITS_TEX_ANY;
+
+      if (vp_outputs & (1 << VERT_RESULT_COL0))
+         fp_inputs |= FRAG_BIT_COL0;
+      if (vp_outputs & (1 << VERT_RESULT_COL1))
+         fp_inputs |= FRAG_BIT_COL1;
+
+      fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) 
+                    << FRAG_ATTRIB_TEX0);
+   }
+   
+   return fp_inputs;
 }
 
+
 /**
  * Examine current texture environment state and generate a unique
  * key to identify it.
  */
-static void make_state_key( GLcontext *ctx,  struct state_key *key )
+static GLuint make_state_key( GLcontext *ctx,  struct state_key *key )
 {
    GLuint i, j;
-	
+   GLbitfield inputs_referenced = FRAG_BIT_COL0;
+   const GLbitfield inputs_available = get_fp_input_mask( ctx );
+   GLuint keySize;
+
    memset(key, 0, sizeof(*key));
 
+   /* _NEW_TEXTURE */
    for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
       const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
+      const struct gl_texture_object *texObj = texUnit->_Current;
+      const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;
       GLenum format;
 
       if (!texUnit->_ReallyEnabled || !texUnit->Enabled)
          continue;
 
-      format = texUnit->_Current->Image[0][texUnit->_Current->BaseLevel]->_BaseFormat;
+      format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
 
       key->unit[i].enabled = 1;
       key->enabled_units |= (1<<i);
+      key->nr_enabled_units = i + 1;
+      inputs_referenced |= FRAG_BIT_TEX(i);
+
+      key->unit[i].source_index =
+         translate_tex_src_bit(texUnit->_ReallyEnabled);
 
-      key->unit[i].source_index = 
-	 translate_tex_src_bit(texUnit->_ReallyEnabled);		
-      key->unit[i].shadow = ((texUnit->_Current->CompareMode == GL_COMPARE_R_TO_TEXTURE) && 
+      key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
                              ((format == GL_DEPTH_COMPONENT) || 
                               (format == GL_DEPTH_STENCIL_EXT)));
 
-      key->unit[i].NumArgsRGB = texUnit->_CurrentCombine->_NumArgsRGB;
-      key->unit[i].NumArgsA = texUnit->_CurrentCombine->_NumArgsA;
+      key->unit[i].NumArgsRGB = comb->_NumArgsRGB;
+      key->unit[i].NumArgsA = comb->_NumArgsA;
 
       key->unit[i].ModeRGB =
-	 translate_mode(texUnit->_CurrentCombine->ModeRGB);
+	 translate_mode(texUnit->EnvMode, comb->ModeRGB);
       key->unit[i].ModeA =
-	 translate_mode(texUnit->_CurrentCombine->ModeA);
-		
-      key->unit[i].ScaleShiftRGB = texUnit->_CurrentCombine->ScaleShiftRGB;
-      key->unit[i].ScaleShiftA = texUnit->_CurrentCombine->ScaleShiftA;
-
-      for (j=0;j<3;j++) {
-         key->unit[i].OptRGB[j].Operand =
-	    translate_operand(texUnit->_CurrentCombine->OperandRGB[j]);
-         key->unit[i].OptA[j].Operand =
-	    translate_operand(texUnit->_CurrentCombine->OperandA[j]);
-         key->unit[i].OptRGB[j].Source =
-	    translate_source(texUnit->_CurrentCombine->SourceRGB[j]);
-         key->unit[i].OptA[j].Source =
-	    translate_source(texUnit->_CurrentCombine->SourceA[j]);
+	 translate_mode(texUnit->EnvMode, comb->ModeA);
+
+      key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB;
+      key->unit[i].ScaleShiftA = comb->ScaleShiftA;
+
+      for (j = 0; j < MAX_COMBINER_TERMS; j++) {
+         key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]);
+         key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]);
+         key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]);
+         key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]);
       }
+
+      if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+         /* requires some special translation */
+         key->unit[i].NumArgsRGB = 2;
+         key->unit[i].ScaleShiftRGB = 0;
+         key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR;
+         key->unit[i].OptRGB[0].Source = SRC_TEXTURE;
+         key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;
+         key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;
+       }
    }
-	
-   if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
+
+   /* _NEW_LIGHT | _NEW_FOG */
+   if (texenv_doing_secondary_color(ctx)) {
       key->separate_specular = 1;
+      inputs_referenced |= FRAG_BIT_COL1;
+   }
 
+   /* _NEW_FOG */
    if (ctx->Fog.Enabled) {
       key->fog_enabled = 1;
       key->fog_mode = translate_fog_mode(ctx->Fog.Mode);
+      inputs_referenced |= FRAG_BIT_FOGC; /* maybe */
    }
+
+   key->inputs_available = (inputs_available & inputs_referenced);
+
+   /* compute size of state key, ignoring unused texture units */
+   keySize = sizeof(*key) - sizeof(key->unit)
+      + key->nr_enabled_units * sizeof(key->unit[0]);
+
+   return keySize;
 }
 
-/* Use uregs to represent registers internally, translate to Mesa's
+
+/**
+ * Use uregs to represent registers internally, translate to Mesa's
  * expected formats on emit.  
  *
  * NOTE: These are passed by value extensively in this file rather
@@ -292,10 +505,8 @@ struct ureg {
    GLuint file:4;
    GLuint idx:8;
    GLuint negatebase:1;
-   GLuint abs:1;
-   GLuint negateabs:1;
    GLuint swz:12;
-   GLuint pad:5;
+   GLuint pad:7;
 };
 
 static const struct ureg undef = { 
@@ -303,22 +514,19 @@ static const struct ureg undef = {
    ~0,
    0,
    0,
-   0,
-   0,
    0
 };
 
 
-/* State used to build the fragment program:
+/** State used to build the fragment program:
  */
 struct texenv_fragment_program {
    struct gl_fragment_program *program;
-   GLcontext *ctx;
    struct state_key *state;
 
-   GLbitfield alu_temps;	/* Track texture indirections, see spec. */
-   GLbitfield temps_output;	/* Track texture indirections, see spec. */
-   GLbitfield temp_in_use;	/* Tracks temporary regs which are in use. */
+   GLbitfield alu_temps;	/**< Track texture indirections, see spec. */
+   GLbitfield temps_output;	/**< Track texture indirections, see spec. */
+   GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */
    GLboolean error;
 
    struct ureg src_texture[MAX_TEXTURE_COORD_UNITS];   
@@ -326,11 +534,16 @@ struct texenv_fragment_program {
     * else undef.
     */
 
-   struct ureg src_previous;	/* Reg containing color from previous 
+   struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS];
+   /* Reg containing texcoord for a texture unit,
+    * needed for bump mapping, else undef.
+    */
+
+   struct ureg src_previous;	/**< Reg containing color from previous 
 				 * stage.  May need to be decl'd.
 				 */
 
-   GLuint last_tex_stage;	/* Number of last enabled texture unit */
+   GLuint last_tex_stage;	/**< Number of last enabled texture unit */
 
    struct ureg half;
    struct ureg one;
@@ -345,8 +558,6 @@ static struct ureg make_ureg(GLuint file, GLuint idx)
    reg.file = file;
    reg.idx = idx;
    reg.negatebase = 0;
-   reg.abs = 0;
-   reg.negateabs = 0;
    reg.swz = SWIZZLE_NOOP;
    reg.pad = 0;
    return reg;
@@ -408,7 +619,7 @@ static struct ureg get_tex_temp( struct texenv_fragment_program *p )
 {
    int bit;
    
-   /* First try to find availble temp not previously used (to avoid
+   /* First try to find available temp not previously used (to avoid
     * starting a new texture indirection).  According to the spec, the
     * ~p->temps_output isn't necessary, but will keep it there for
     * now:
@@ -433,6 +644,14 @@ static struct ureg get_tex_temp( struct texenv_fragment_program *p )
 }
 
 
+/** Mark a temp reg as being no longer allocatable. */
+static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )
+{
+   if (r.file == PROGRAM_TEMPORARY)
+      p->temps_output |= (1 << r.idx);
+}
+
+
 static void release_temps(GLcontext *ctx, struct texenv_fragment_program *p )
 {
    GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;
@@ -471,11 +690,29 @@ static struct ureg register_param5( struct texenv_fragment_program *p,
 #define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
 #define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
 
+static GLuint frag_to_vert_attrib( GLuint attrib )
+{
+   switch (attrib) {
+   case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;
+   case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;
+   default:
+      assert(attrib >= FRAG_ATTRIB_TEX0);
+      assert(attrib <= FRAG_ATTRIB_TEX7);
+      return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;
+   }
+}
+
 
 static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )
 {
-   p->program->Base.InputsRead |= (1 << input);
-   return make_ureg(PROGRAM_INPUT, input);
+   if (p->state->inputs_available & (1<<input)) {
+      p->program->Base.InputsRead |= (1 << input);
+      return make_ureg(PROGRAM_INPUT, input);
+   }
+   else {
+      GLuint idx = frag_to_vert_attrib( input );
+      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, idx );
+   }
 }
 
 
@@ -485,9 +722,8 @@ static void emit_arg( struct prog_src_register *reg,
    reg->File = ureg.file;
    reg->Index = ureg.idx;
    reg->Swizzle = ureg.swz;
-   reg->NegateBase = ureg.negatebase ? 0xf : 0x0;
-   reg->Abs = ureg.abs;
-   reg->NegateAbs = ureg.negateabs;
+   reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE;
+   reg->Abs = GL_FALSE;
 }
 
 static void emit_dst( struct prog_dst_register *dst,
@@ -510,7 +746,7 @@ emit_op(struct texenv_fragment_program *p,
 	struct ureg src1,
 	struct ureg src2 )
 {
-   GLuint nr = p->program->Base.NumInstructions++;
+   const GLuint nr = p->program->Base.NumInstructions++;
    struct prog_instruction *inst = &p->program->Base.Instructions[nr];
 
    assert(nr < MAX_INSTRUCTIONS);
@@ -526,10 +762,12 @@ emit_op(struct texenv_fragment_program *p,
 
    emit_dst( &inst->DstReg, dest, mask );
 
+#if 0
    /* Accounting for indirection tracking:
     */
    if (dest.file == PROGRAM_TEMPORARY)
       p->temps_output |= 1 << dest.idx;
+#endif
 
    return inst;
 }
@@ -570,6 +808,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p,
 			       GLuint destmask,
 			       GLuint tex_unit,
 			       GLuint tex_idx,
+                               GLuint tex_shadow,
 			       struct ureg coord )
 {
    struct prog_instruction *inst = emit_op( p, op, 
@@ -581,9 +820,15 @@ static struct ureg emit_texld( struct texenv_fragment_program *p,
    
    inst->TexSrcTarget = tex_idx;
    inst->TexSrcUnit = tex_unit;
+   inst->TexShadow = tex_shadow;
 
    p->program->Base.NumTexInstructions++;
 
+   /* Accounting for indirection tracking:
+    */
+   reserve_temp(p, dest);
+
+#if 0
    /* Is this a texture indirection?
     */
    if ((coord.file == PROGRAM_TEMPORARY &&
@@ -595,6 +840,7 @@ static struct ureg emit_texld( struct texenv_fragment_program *p,
       p->alu_temps = 0;
       assert(0);		/* KW: texture env crossbar */
    }
+#endif
 
    return dest;
 }
@@ -608,14 +854,16 @@ static struct ureg register_const4f( struct texenv_fragment_program *p,
 {
    GLfloat values[4];
    GLuint idx, swizzle;
+   struct ureg r;
    values[0] = s0;
    values[1] = s1;
    values[2] = s2;
    values[3] = s3;
    idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
                                      &swizzle );
-   ASSERT(swizzle == SWIZZLE_NOOP);
-   return make_ureg(PROGRAM_CONSTANT, idx);
+   r = make_ureg(PROGRAM_CONSTANT, idx);
+   r.swz = swizzle;
+   return r;
 }
 
 #define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
@@ -677,12 +925,18 @@ static struct ureg get_source( struct texenv_fragment_program *p,
    case SRC_PRIMARY_COLOR:
       return register_input(p, FRAG_ATTRIB_COL0);
 
+   case SRC_ZERO:
+      return get_zero(p);
+
    case SRC_PREVIOUS:
-   default:
       if (is_undef(p->src_previous))
 	 return register_input(p, FRAG_ATTRIB_COL0);
       else
 	 return p->src_previous;
+
+   default:
+      assert(0);
+      return undef;
    }
 }
 
@@ -723,22 +977,29 @@ static struct ureg emit_combine_source( struct texenv_fragment_program *p,
    case OPR_ONE:
       return get_one(p);
    case OPR_SRC_COLOR: 
+      return src;
    default:
+      assert(0);
       return src;
    }
 }
 
-static GLboolean args_match( struct state_key *key, GLuint unit )
+/**
+ * Check if the RGB and Alpha sources and operands match for the given
+ * texture unit's combinder state.  When the RGB and A sources and
+ * operands match, we can emit fewer instructions.
+ */
+static GLboolean args_match( const struct state_key *key, GLuint unit )
 {
-   GLuint i, nr = key->unit[unit].NumArgsRGB;
+   GLuint i, numArgs = key->unit[unit].NumArgsRGB;
 
-   for (i = 0 ; i < nr ; i++) {
+   for (i = 0; i < numArgs; i++) {
       if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) 
 	 return GL_FALSE;
 
-      switch(key->unit[unit].OptA[i].Operand) {
+      switch (key->unit[unit].OptA[i].Operand) {
       case OPR_SRC_ALPHA: 
-	 switch(key->unit[unit].OptRGB[i].Operand) {
+	 switch (key->unit[unit].OptRGB[i].Operand) {
 	 case OPR_SRC_COLOR: 
 	 case OPR_SRC_ALPHA: 
 	    break;
@@ -747,7 +1008,7 @@ static GLboolean args_match( struct state_key *key, GLuint unit )
 	 }
 	 break;
       case OPR_ONE_MINUS_SRC_ALPHA: 
-	 switch(key->unit[unit].OptRGB[i].Operand) {
+	 switch (key->unit[unit].OptRGB[i].Operand) {
 	 case OPR_ONE_MINUS_SRC_COLOR: 
 	 case OPR_ONE_MINUS_SRC_ALPHA: 
 	    break;
@@ -772,10 +1033,12 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
 				 GLuint mode,
 				 const struct mode_opt *opt)
 {
-   struct ureg src[3];
+   struct ureg src[MAX_COMBINER_TERMS];
    struct ureg tmp, half;
    GLuint i;
 
+   assert(nr <= MAX_COMBINER_TERMS);
+
    tmp = undef; /* silence warning (bug 5318) */
 
    for (i = 0; i < nr; i++)
@@ -851,7 +1114,30 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
       /* Arg0 * Arg2 - Arg1 */
       emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
       return dest;
+   case MODE_ADD_PRODUCTS:
+      /* Arg0 * Arg1 + Arg2 * Arg3 */
+      {
+         struct ureg tmp0 = get_temp(p);
+         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
+         emit_arith( p, OPCODE_MAD, dest, mask, saturate, src[2], src[3], tmp0 );
+      }
+      return dest;
+   case MODE_ADD_PRODUCTS_SIGNED:
+      /* Arg0 * Arg1 + Arg2 * Arg3 - 0.5 */
+      {
+         struct ureg tmp0 = get_temp(p);
+         half = get_half(p);
+         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
+         emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[2], src[3], tmp0 );
+         emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
+      }
+      return dest;
+   case MODE_BUMP_ENVMAP_ATI:
+      /* special - not handled here */
+      assert(0);
+      return src[0];
    default: 
+      assert(0);
       return src[0];
    }
 }
@@ -863,15 +1149,18 @@ static struct ureg emit_combine( struct texenv_fragment_program *p,
 static struct ureg
 emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 {
-   struct state_key *key = p->state;
-   GLboolean saturate = (unit < p->last_tex_stage);
+   const struct state_key *key = p->state;
+   GLboolean rgb_saturate, alpha_saturate;
    GLuint rgb_shift, alpha_shift;
-   struct ureg out, shift;
-   struct ureg dest;
+   struct ureg out, dest;
 
    if (!key->unit[unit].enabled) {
       return get_source(p, SRC_PREVIOUS, 0);
    }
+   if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+      /* this isn't really a env stage delivering a color and handled elsewhere */
+      return get_source(p, SRC_PREVIOUS, 0);
+   }
    
    switch (key->unit[unit].ModeRGB) {
    case MODE_DOT3_RGB_EXT:
@@ -888,6 +1177,23 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
       break;
    }
    
+   /* If we'll do rgb/alpha shifting don't saturate in emit_combine().
+    * We don't want to clamp twice.
+    */
+   if (rgb_shift)
+      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */
+   else if (need_saturate(key->unit[unit].ModeRGB))
+      rgb_saturate = GL_TRUE;
+   else
+      rgb_saturate = GL_FALSE;
+
+   if (alpha_shift)
+      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */
+   else if (need_saturate(key->unit[unit].ModeA))
+      alpha_saturate = GL_TRUE;
+   else
+      alpha_saturate = GL_FALSE;
+
    /* If this is the very last calculation, emit direct to output reg:
     */
    if (key->separate_specular ||
@@ -896,13 +1202,13 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
        rgb_shift)
       dest = get_temp( p );
    else
-      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLR);
+      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
 
    /* Emit the RGB and A combine ops
     */
    if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
        args_match(key, unit)) {
-      out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
@@ -910,8 +1216,7 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
    }
    else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
 	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
-
-      out = emit_combine( p, dest, WRITEMASK_XYZW, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
@@ -921,12 +1226,12 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
       /* Need to do something to stop from re-emitting identical
        * argument calculations here:
        */
-      out = emit_combine( p, dest, WRITEMASK_XYZ, saturate,
+      out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,
 			  unit,
 			  key->unit[unit].NumArgsRGB,
 			  key->unit[unit].ModeRGB,
 			  key->unit[unit].OptRGB);
-      out = emit_combine( p, dest, WRITEMASK_W, saturate,
+      out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,
 			  unit,
 			  key->unit[unit].NumArgsA,
 			  key->unit[unit].ModeA,
@@ -936,6 +1241,9 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
    /* Deal with the final shift:
     */
    if (alpha_shift || rgb_shift) {
+      struct ureg shift;
+      GLboolean saturate = GL_TRUE;  /* always saturate at this point */
+
       if (rgb_shift == alpha_shift) {
 	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
       }
@@ -960,21 +1268,32 @@ emit_texenv(struct texenv_fragment_program *p, GLuint unit)
 static void load_texture( struct texenv_fragment_program *p, GLuint unit )
 {
    if (is_undef(p->src_texture[unit])) {
-      GLuint dim = p->state->unit[unit].source_index;
-      struct ureg texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
+      const GLuint texTarget = p->state->unit[unit].source_index;
+      struct ureg texcoord;
       struct ureg tmp = get_tex_temp( p );
 
-      if (dim == TEXTURE_UNKNOWN_INDEX)
-         program_error(p, "TexSrcBit");
-			  
+      if (is_undef(p->texcoord_tex[unit])) {
+         texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
+      }
+      else {
+         /* might want to reuse this reg for tex output actually */
+         texcoord = p->texcoord_tex[unit];
+      }
+
       /* TODO: Use D0_MASK_XY where possible.
        */
       if (p->state->unit[unit].enabled) {
+         GLboolean shadow = GL_FALSE;
+
+	 if (p->state->unit[unit].shadow) {
+	    p->program->Base.ShadowSamplers |= 1 << unit;
+            shadow = GL_TRUE;
+         }
+
 	 p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
 					    tmp, WRITEMASK_XYZW, 
-					    unit, dim, texcoord );
-	 if (p->state->unit[unit].shadow)
-	    p->program->Base.ShadowSamplers |= 1 << unit;
+					    unit, texTarget, shadow,
+                                            texcoord );
 
          p->program->Base.SamplersUsed |= (1 << unit);
          /* This identity mapping should already be in place
@@ -1007,6 +1326,7 @@ static GLboolean load_texenv_source( struct texenv_fragment_program *p,
       break;
       
    default:
+      /* not a texture src - do nothing */
       break;
    }
  
@@ -1018,13 +1338,13 @@ static GLboolean load_texenv_source( struct texenv_fragment_program *p,
  * Generate instructions for loading all texture source terms.
  */
 static GLboolean
-load_texunit_sources( struct texenv_fragment_program *p, int unit )
+load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )
 {
-   struct state_key *key = p->state;
+   const struct state_key *key = p->state;
    GLuint i;
 
    for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {
-      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit);
+      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit );
    }
 
    for (i = 0; i < key->unit[unit].NumArgsA; i++) {
@@ -1034,6 +1354,43 @@ load_texunit_sources( struct texenv_fragment_program *p, int unit )
    return GL_TRUE;
 }
 
+/**
+ * Generate instructions for loading bump map textures.
+ */
+static GLboolean
+load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )
+{
+   const struct state_key *key = p->state;
+   GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;
+   struct ureg texcDst, bumpMapRes;
+   struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0);
+   struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr);
+   struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit );
+   struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit );
+
+   load_texenv_source( p, unit + SRC_TEXTURE0, unit );
+
+   bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit);
+   texcDst = get_tex_temp( p );
+   p->texcoord_tex[bumpedUnitNr] = texcDst;
+
+   /* Apply rot matrix and add coords to be available in next phase.
+    * dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1)
+    * note only 2 coords are affected the rest are left unchanged (mul by 0)
+    */
+   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
+               swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc );
+   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
+               swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst );
+
+   /* Move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish
+    * enough to access this later, should optimize away.
+    */
+   emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0,
+               constdudvcolor, undef, undef );
+
+   return GL_TRUE;
+}
 
 /**
  * Generate a new fragment program which implements the context's
@@ -1049,7 +1406,6 @@ create_new_program(GLcontext *ctx, struct state_key *key,
    struct ureg cf, out;
 
    _mesa_memset(&p, 0, sizeof(p));
-   p.ctx = ctx;
    p.state = key;
    p.program = program;
 
@@ -1058,21 +1414,23 @@ create_new_program(GLcontext *ctx, struct state_key *key,
     */
    p.program->Base.Instructions = instBuffer;
    p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
-   p.program->Base.NumTexIndirections = 1;	/* correct? */
+   p.program->Base.String = NULL;
+   p.program->Base.NumTexIndirections = 1; /* is this right? */
    p.program->Base.NumTexInstructions = 0;
    p.program->Base.NumAluInstructions = 0;
-   p.program->Base.String = NULL;
-   p.program->Base.NumInstructions =
-   p.program->Base.NumTemporaries =
-   p.program->Base.NumParameters =
-   p.program->Base.NumAttributes = p.program->Base.NumAddressRegs = 0;
+   p.program->Base.NumInstructions = 0;
+   p.program->Base.NumTemporaries = 0;
+   p.program->Base.NumParameters = 0;
+   p.program->Base.NumAttributes = 0;
+   p.program->Base.NumAddressRegs = 0;
    p.program->Base.Parameters = _mesa_new_parameter_list();
+   p.program->Base.InputsRead = 0x0;
+   p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;
 
-   p.program->Base.InputsRead = 0;
-   p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLR;
-
-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++)
+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
       p.src_texture[unit] = undef;
+      p.texcoord_tex[unit] = undef;
+   }
 
    p.src_previous = undef;
    p.half = undef;
@@ -1083,11 +1441,23 @@ create_new_program(GLcontext *ctx, struct state_key *key,
    release_temps(ctx, &p);
 
    if (key->enabled_units) {
+      GLboolean needbumpstage = GL_FALSE;
+
+      /* Zeroth pass - bump map textures first */
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
+	 if (key->unit[unit].enabled &&
+             key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+	    needbumpstage = GL_TRUE;
+	    load_texunit_bumpmap( &p, unit );
+	 }
+      if (needbumpstage)
+	 p.program->Base.NumTexIndirections++;
+
       /* First pass - to support texture_env_crossbar, first identify
        * all referenced texture sources and emit texld instructions
        * for each:
        */
-      for (unit = 0 ; unit < ctx->Const.MaxTextureUnits ; unit++)
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
 	 if (key->unit[unit].enabled) {
 	    load_texunit_sources( &p, unit );
 	    p.last_tex_stage = unit;
@@ -1095,15 +1465,16 @@ create_new_program(GLcontext *ctx, struct state_key *key,
 
       /* Second pass - emit combine instructions to build final color:
        */
-      for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++)
-	 if (key->enabled_units & (1<<unit)) {
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
+	 if (key->unit[unit].enabled) {
 	    p.src_previous = emit_texenv( &p, unit );
+            reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */
 	    release_temps(ctx, &p);	/* release all temps */
 	 }
    }
 
    cf = get_source( &p, SRC_PREVIOUS, 0 );
-   out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLR );
+   out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );
 
    if (key->separate_specular) {
       /* Emit specular add.
@@ -1128,9 +1499,11 @@ create_new_program(GLcontext *ctx, struct state_key *key,
        * a reduced value and not what is expected in FogOption
        */
       p.program->FogOption = ctx->Fog.Mode;
-      p.program->Base.InputsRead |= FRAG_BIT_FOGC; /* XXX new */
-   } else
+      p.program->Base.InputsRead |= FRAG_BIT_FOGC;
+   }
+   else {
       p.program->FogOption = GL_NONE;
+   }
 
    if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) 
       program_error(&p, "Exceeded max nr indirect texture lookups");
@@ -1183,12 +1556,13 @@ _mesa_get_fixed_func_fragment_program(GLcontext *ctx)
 {
    struct gl_fragment_program *prog;
    struct state_key key;
+   GLuint keySize;
 	
-   make_state_key(ctx, &key);
+   keySize = make_state_key(ctx, &key);
       
    prog = (struct gl_fragment_program *)
       _mesa_search_program_cache(ctx->FragmentProgram.Cache,
-                                 &key, sizeof(key));
+                                 &key, keySize);
 
    if (!prog) {
       prog = (struct gl_fragment_program *) 
@@ -1197,44 +1571,8 @@ _mesa_get_fixed_func_fragment_program(GLcontext *ctx)
       create_new_program(ctx, &key, prog);
 
       _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,
-                                 &key, sizeof(key), &prog->Base);
+                                 &key, keySize, &prog->Base);
    }
 
    return prog;
 }
-
-
-
-/**
- * If _MaintainTexEnvProgram is set we'll generate a fragment program that
- * implements the current texture env/combine mode.
- * This function generates that program and puts it into effect.
- */
-void
-_mesa_UpdateTexEnvProgram( GLcontext *ctx )
-{
-   const struct gl_fragment_program *prev = ctx->FragmentProgram._Current;
-	
-   ASSERT(ctx->FragmentProgram._MaintainTexEnvProgram);
-
-   /* If a conventional fragment program/shader isn't in effect... */
-   if (!ctx->FragmentProgram._Enabled &&
-       (!ctx->Shader.CurrentProgram ||
-        !ctx->Shader.CurrentProgram->FragmentProgram) ) 
-   {
-      struct gl_fragment_program *newProg;
-
-      newProg = _mesa_get_fixed_func_fragment_program(ctx);
-
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, newProg);
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, newProg);
-   } 
-
-   /* Tell the driver about the change.  Could define a new target for
-    * this?
-    */
-   if (ctx->FragmentProgram._Current != prev && ctx->Driver.BindProgram) {
-      ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
-                         (struct gl_program *) ctx->FragmentProgram._Current);
-   }
-}
diff --git a/src/mesa/main/texenvprogram.h b/src/mesa/main/texenvprogram.h
index a7aa60cf37..0a162d2e7a 100644
--- a/src/mesa/main/texenvprogram.h
+++ b/src/mesa/main/texenvprogram.h
@@ -32,6 +32,4 @@
 extern struct gl_fragment_program *
 _mesa_get_fixed_func_fragment_program(GLcontext *ctx);
 
-extern void _mesa_UpdateTexEnvProgram( GLcontext *ctx );
-
 #endif
diff --git a/src/mesa/main/texformat.c b/src/mesa/main/texformat.c
index 08725846c6..19c92838e0 100644
--- a/src/mesa/main/texformat.c
+++ b/src/mesa/main/texformat.c
@@ -3,6 +3,7 @@
  * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -86,30 +87,33 @@ nonlinear_to_linear(GLubyte cs8)
  *
  * Have to have this so the FetchTexel function pointer is never NULL.
  */
-static void fetch_null_texel( const struct gl_texture_image *texImage,
-			      GLint i, GLint j, GLint k, GLchan *texel )
+void
+_mesa_texformat_fetch_texel_null(const struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, GLchan *texel)
 {
    (void) texImage; (void) i; (void) j; (void) k;
    texel[RCOMP] = 0;
    texel[GCOMP] = 0;
    texel[BCOMP] = 0;
    texel[ACOMP] = 0;
-   _mesa_warning(NULL, "fetch_null_texel() called!");
+   _mesa_warning(NULL, "_mesa_texformat_fetch_texel_null() called!");
 }
 
-static void fetch_null_texelf( const struct gl_texture_image *texImage,
-                               GLint i, GLint j, GLint k, GLfloat *texel )
+void
+_mesa_texformat_fetch_texel_f_null(const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel)
 {
    (void) texImage; (void) i; (void) j; (void) k;
    texel[RCOMP] = 0.0;
    texel[GCOMP] = 0.0;
    texel[BCOMP] = 0.0;
    texel[ACOMP] = 0.0;
-   _mesa_warning(NULL, "fetch_null_texelf() called!");
+   _mesa_warning(NULL, "_mesa_texformat_fetch_texel_f_null() called!");
 }
 
-static void store_null_texel(struct gl_texture_image *texImage,
-                             GLint i, GLint j, GLint k, const void *texel)
+void
+_mesa_texformat_store_texel_null(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
 {
    (void) texImage;
    (void) i;
@@ -153,9 +157,9 @@ const struct gl_texture_format _mesa_texformat_rgba = {
    0,					/* StencilBits */
    4 * sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,			/* StoreTexImageFunc */
-   fetch_texel_1d_rgba,			/* FetchTexel1D */
-   fetch_texel_2d_rgba,			/* FetchTexel2D */
-   fetch_texel_3d_rgba,			/* FetchTexel3D */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
    fetch_texel_1d_f_rgba,		/* FetchTexel1Df */
    fetch_texel_2d_f_rgba,		/* FetchTexel2Df */
    fetch_texel_3d_f_rgba,		/* FetchTexel3Df */
@@ -177,9 +181,9 @@ const struct gl_texture_format _mesa_texformat_rgb = {
    0,					/* StencilBits */
    3 * sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_rgb,			/* FetchTexel1D */
-   fetch_texel_2d_rgb,			/* FetchTexel2D */
-   fetch_texel_3d_rgb,			/* FetchTexel3D */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
    fetch_texel_1d_f_rgb,		/* FetchTexel1Df */
    fetch_texel_2d_f_rgb,		/* FetchTexel2Df */
    fetch_texel_3d_f_rgb,		/* FetchTexel3Df */
@@ -201,12 +205,12 @@ const struct gl_texture_format _mesa_texformat_alpha = {
    0,					/* StencilBits */
    sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_alpha,		/* FetchTexel1D */
-   fetch_texel_2d_alpha,		/* FetchTexel2D */
-   fetch_texel_3d_alpha,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_alpha,		/* FetchTexel1Df */
+   fetch_texel_2d_f_alpha,		/* FetchTexel2Df */
+   fetch_texel_3d_f_alpha,		/* FetchTexel3Df */
    store_texel_alpha			/* StoreTexel */
 };
 
@@ -225,12 +229,12 @@ const struct gl_texture_format _mesa_texformat_luminance = {
    0,					/* StencilBits */
    sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_luminance,		/* FetchTexel1D */
-   fetch_texel_2d_luminance,		/* FetchTexel2D */
-   fetch_texel_3d_luminance,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_luminance,		/* FetchTexel1Df */
+   fetch_texel_2d_f_luminance,		/* FetchTexel2Df */
+   fetch_texel_3d_f_luminance,		/* FetchTexel3Df */
    store_texel_luminance		/* StoreTexel */
 };
 
@@ -249,12 +253,12 @@ const struct gl_texture_format _mesa_texformat_luminance_alpha = {
    0,					/* StencilBits */
    2 * sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_luminance_alpha,	/* FetchTexel1D */
-   fetch_texel_2d_luminance_alpha,	/* FetchTexel2D */
-   fetch_texel_3d_luminance_alpha,	/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_luminance_alpha,	/* FetchTexel1Df */
+   fetch_texel_2d_f_luminance_alpha,	/* FetchTexel2Df */
+   fetch_texel_3d_f_luminance_alpha,	/* FetchTexel3Df */
    store_texel_luminance_alpha		/* StoreTexel */
 };
 
@@ -273,12 +277,12 @@ const struct gl_texture_format _mesa_texformat_intensity = {
    0,					/* StencilBits */
    sizeof(GLchan),			/* TexelBytes */
    _mesa_texstore_rgba,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_intensity,		/* FetchTexel1D */
-   fetch_texel_2d_intensity,		/* FetchTexel2D */
-   fetch_texel_3d_intensity,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_intensity,		/* FetchTexel1Df */
+   fetch_texel_2d_f_intensity,		/* FetchTexel2Df */
+   fetch_texel_3d_f_intensity,		/* FetchTexel3Df */
    store_texel_intensity		/* StoreTexel */
 };
 
@@ -333,6 +337,30 @@ const struct gl_texture_format _mesa_texformat_srgba8 = {
    store_texel_srgba8			/* StoreTexel */
 };
 
+const struct gl_texture_format _mesa_texformat_sargb8 = {
+   MESA_FORMAT_SARGB8,			/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_UNSIGNED_NORMALIZED_ARB,		/* DataType */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   4,					/* TexelBytes */
+   _mesa_texstore_sargb8,		/* StoreTexImageFunc */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_sargb8,		/* FetchTexel1Df */
+   fetch_texel_2d_sargb8,		/* FetchTexel2Df */
+   fetch_texel_3d_sargb8,		/* FetchTexel3Df */
+   store_texel_sargb8			/* StoreTexel */
+};
+
 const struct gl_texture_format _mesa_texformat_sl8 = {
    MESA_FORMAT_SL8,			/* MesaFormat */
    GL_LUMINANCE,			/* BaseFormat */
@@ -357,6 +385,7 @@ const struct gl_texture_format _mesa_texformat_sl8 = {
    store_texel_sl8			/* StoreTexel */
 };
 
+/* Note: this format name looks like a misnomer, make it sal8? */
 const struct gl_texture_format _mesa_texformat_sla8 = {
    MESA_FORMAT_SLA8,			/* MesaFormat */
    GL_LUMINANCE_ALPHA,			/* BaseFormat */
@@ -671,6 +700,79 @@ const struct gl_texture_format _mesa_texformat_intensity_float16 = {
    store_texel_intensity_f16		/* StoreTexel */
 };
 
+const struct gl_texture_format _mesa_texformat_dudv8 = {
+   MESA_FORMAT_DUDV8,			/* MesaFormat */
+   GL_DUDV_ATI,				/* BaseFormat */
+   GL_SIGNED_NORMALIZED,		/* DataType */
+   /* maybe should add dudvBits field, but spec seems to be
+      lacking the ability to query with GetTexLevelParameter anyway */
+   0,					/* RedBits */
+   0,					/* GreenBits */
+   0,					/* BlueBits */
+   0,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   2,					/* TexelBytes */
+   _mesa_texstore_dudv8,		/* StoreTexImageFunc */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_dudv8,		/* FetchTexel1Df */
+   fetch_texel_2d_dudv8,		/* FetchTexel2Df */
+   fetch_texel_3d_dudv8,		/* FetchTexel3Df */
+   NULL					/* StoreTexel */
+};
+
+const struct gl_texture_format _mesa_texformat_signed_rgba8888 = {
+   MESA_FORMAT_SIGNED_RGBA8888,		/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_SIGNED_NORMALIZED,		/* DataType */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   4,					/* TexelBytes */
+   _mesa_texstore_signed_rgba8888,	/* StoreTexImageFunc */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_signed_rgba8888,	/* FetchTexel1Df */
+   fetch_texel_2d_signed_rgba8888,	/* FetchTexel2Df */
+   fetch_texel_3d_signed_rgba8888,	/* FetchTexel3Df */
+   store_texel_signed_rgba8888		/* StoreTexel */
+};
+
+const struct gl_texture_format _mesa_texformat_signed_rgba8888_rev = {
+   MESA_FORMAT_SIGNED_RGBA8888_REV,	/* MesaFormat */
+   GL_RGBA,				/* BaseFormat */
+   GL_SIGNED_NORMALIZED,		/* DataType */
+   8,					/* RedBits */
+   8,					/* GreenBits */
+   8,					/* BlueBits */
+   8,					/* AlphaBits */
+   0,					/* LuminanceBits */
+   0,					/* IntensityBits */
+   0,					/* IndexBits */
+   0,					/* DepthBits */
+   0,					/* StencilBits */
+   4,					/* TexelBytes */
+   _mesa_texstore_signed_rgba8888,	/* StoreTexImageFunc */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_signed_rgba8888_rev,	/* FetchTexel1Df */
+   fetch_texel_2d_signed_rgba8888_rev,	/* FetchTexel2Df */
+   fetch_texel_3d_signed_rgba8888_rev,	/* FetchTexel3Df */
+   store_texel_signed_rgba8888_rev		/* StoreTexel */
+};
 
 /*@}*/
 
@@ -694,12 +796,12 @@ const struct gl_texture_format _mesa_texformat_rgba8888 = {
    0,					/* StencilBits */
    4,					/* TexelBytes */
    _mesa_texstore_rgba8888,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgba8888,		/* FetchTexel1D */
-   fetch_texel_2d_rgba8888,		/* FetchTexel2D */
-   fetch_texel_3d_rgba8888,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgba8888,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba8888,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgba8888,		/* FetchTexel3Df */
    store_texel_rgba8888			/* StoreTexel */
 };
 
@@ -718,12 +820,12 @@ const struct gl_texture_format _mesa_texformat_rgba8888_rev = {
    0,					/* StencilBits */
    4,					/* TexelBytes */
    _mesa_texstore_rgba8888,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgba8888_rev,		/* FetchTexel1D */
-   fetch_texel_2d_rgba8888_rev,		/* FetchTexel2D */
-   fetch_texel_3d_rgba8888_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgba8888_rev,	/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba8888_rev,	/* FetchTexel2Df */
+   fetch_texel_3d_f_rgba8888_rev,	/* FetchTexel3Df */
    store_texel_rgba8888_rev		/* StoreTexel */
 };
 
@@ -742,12 +844,12 @@ const struct gl_texture_format _mesa_texformat_argb8888 = {
    0,					/* StencilBits */
    4,					/* TexelBytes */
    _mesa_texstore_argb8888,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb8888,		/* FetchTexel1D */
-   fetch_texel_2d_argb8888,		/* FetchTexel2D */
-   fetch_texel_3d_argb8888,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb8888,		/* FetchTexel1Df */
+   fetch_texel_2d_f_argb8888,		/* FetchTexel2Df */
+   fetch_texel_3d_f_argb8888,		/* FetchTexel3Df */
    store_texel_argb8888			/* StoreTexel */
 };
 
@@ -766,12 +868,12 @@ const struct gl_texture_format _mesa_texformat_argb8888_rev = {
    0,					/* StencilBits */
    4,					/* TexelBytes */
    _mesa_texstore_argb8888,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb8888_rev,		/* FetchTexel1D */
-   fetch_texel_2d_argb8888_rev,		/* FetchTexel2D */
-   fetch_texel_3d_argb8888_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb8888_rev,	/* FetchTexel1Df */
+   fetch_texel_2d_f_argb8888_rev,	/* FetchTexel2Df */
+   fetch_texel_3d_f_argb8888_rev,	/* FetchTexel3Df */
    store_texel_argb8888_rev		/* StoreTexel */
 };
 
@@ -790,12 +892,12 @@ const struct gl_texture_format _mesa_texformat_rgb888 = {
    0,					/* StencilBits */
    3,					/* TexelBytes */
    _mesa_texstore_rgb888,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgb888,		/* FetchTexel1D */
-   fetch_texel_2d_rgb888,		/* FetchTexel2D */
-   fetch_texel_3d_rgb888,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgb888,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgb888,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgb888,		/* FetchTexel3Df */
    store_texel_rgb888			/* StoreTexel */
 };
 
@@ -814,12 +916,12 @@ const struct gl_texture_format _mesa_texformat_bgr888 = {
    0,					/* StencilBits */
    3,					/* TexelBytes */
    _mesa_texstore_bgr888,		/* StoreTexImageFunc */
-   fetch_texel_1d_bgr888,		/* FetchTexel1D */
-   fetch_texel_2d_bgr888,		/* FetchTexel2D */
-   fetch_texel_3d_bgr888,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_bgr888,		/* FetchTexel1Df */
+   fetch_texel_2d_f_bgr888,		/* FetchTexel2Df */
+   fetch_texel_3d_f_bgr888,		/* FetchTexel3Df */
    store_texel_bgr888			/* StoreTexel */
 };
 
@@ -838,12 +940,12 @@ const struct gl_texture_format _mesa_texformat_rgb565 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_rgb565,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgb565,		/* FetchTexel1D */
-   fetch_texel_2d_rgb565,		/* FetchTexel2D */
-   fetch_texel_3d_rgb565,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgb565,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgb565,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgb565,		/* FetchTexel3Df */
    store_texel_rgb565			/* StoreTexel */
 };
 
@@ -862,12 +964,12 @@ const struct gl_texture_format _mesa_texformat_rgb565_rev = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_rgb565,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgb565_rev,		/* FetchTexel1D */
-   fetch_texel_2d_rgb565_rev,		/* FetchTexel2D */
-   fetch_texel_3d_rgb565_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgb565_rev,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgb565_rev,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgb565_rev,		/* FetchTexel3Df */
    store_texel_rgb565_rev		/* StoreTexel */
 };
 
@@ -886,12 +988,12 @@ const struct gl_texture_format _mesa_texformat_rgba4444 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_rgba4444,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgba4444,		/* FetchTexel1D */
-   fetch_texel_2d_rgba4444,		/* FetchTexel2D */
-   fetch_texel_3d_rgba4444,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgba4444,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba4444,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgba4444,		/* FetchTexel3Df */
    store_texel_rgba4444			/* StoreTexel */
 };
 
@@ -910,12 +1012,12 @@ const struct gl_texture_format _mesa_texformat_argb4444 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_argb4444,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb4444,		/* FetchTexel1D */
-   fetch_texel_2d_argb4444,		/* FetchTexel2D */
-   fetch_texel_3d_argb4444,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb4444,		/* FetchTexel1Df */
+   fetch_texel_2d_f_argb4444,		/* FetchTexel2Df */
+   fetch_texel_3d_f_argb4444,		/* FetchTexel3Df */
    store_texel_argb4444			/* StoreTexel */
 };
 
@@ -934,12 +1036,12 @@ const struct gl_texture_format _mesa_texformat_argb4444_rev = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_argb4444,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb4444_rev,		/* FetchTexel1D */
-   fetch_texel_2d_argb4444_rev,		/* FetchTexel2D */
-   fetch_texel_3d_argb4444_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb4444_rev,	/* FetchTexel1Df */
+   fetch_texel_2d_f_argb4444_rev,	/* FetchTexel2Df */
+   fetch_texel_3d_f_argb4444_rev,	/* FetchTexel3Df */
    store_texel_argb4444_rev		/* StoreTexel */
 };
 
@@ -958,12 +1060,12 @@ const struct gl_texture_format _mesa_texformat_rgba5551 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_rgba5551,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgba5551,		/* FetchTexel1D */
-   fetch_texel_2d_rgba5551,		/* FetchTexel2D */
-   fetch_texel_3d_rgba5551,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgba5551,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgba5551,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgba5551,		/* FetchTexel3Df */
    store_texel_rgba5551			/* StoreTexel */
 };
 
@@ -982,12 +1084,12 @@ const struct gl_texture_format _mesa_texformat_argb1555 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_argb1555,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb1555,		/* FetchTexel1D */
-   fetch_texel_2d_argb1555,		/* FetchTexel2D */
-   fetch_texel_3d_argb1555,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb1555,		/* FetchTexel1Df */
+   fetch_texel_2d_f_argb1555,		/* FetchTexel2Df */
+   fetch_texel_3d_f_argb1555,		/* FetchTexel3Df */
    store_texel_argb1555			/* StoreTexel */
 };
 
@@ -1006,12 +1108,12 @@ const struct gl_texture_format _mesa_texformat_argb1555_rev = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_argb1555,		/* StoreTexImageFunc */
-   fetch_texel_1d_argb1555_rev,		/* FetchTexel1D */
-   fetch_texel_2d_argb1555_rev,		/* FetchTexel2D */
-   fetch_texel_3d_argb1555_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_argb1555_rev,	/* FetchTexel1Df */
+   fetch_texel_2d_f_argb1555_rev,	/* FetchTexel2Df */
+   fetch_texel_3d_f_argb1555_rev,	/* FetchTexel3Df */
    store_texel_argb1555_rev		/* StoreTexel */
 };
 
@@ -1030,12 +1132,12 @@ const struct gl_texture_format _mesa_texformat_al88 = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_al88,			/* StoreTexImageFunc */
-   fetch_texel_1d_al88,			/* FetchTexel1D */
-   fetch_texel_2d_al88,			/* FetchTexel2D */
-   fetch_texel_3d_al88,			/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_al88,		/* FetchTexel1Df */
+   fetch_texel_2d_f_al88,		/* FetchTexel2Df */
+   fetch_texel_3d_f_al88,		/* FetchTexel3Df */
    store_texel_al88			/* StoreTexel */
 };
 
@@ -1054,12 +1156,12 @@ const struct gl_texture_format _mesa_texformat_al88_rev = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_al88,			/* StoreTexImageFunc */
-   fetch_texel_1d_al88_rev,		/* FetchTexel1D */
-   fetch_texel_2d_al88_rev,		/* FetchTexel2D */
-   fetch_texel_3d_al88_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_al88_rev,		/* FetchTexel1Df */
+   fetch_texel_2d_f_al88_rev,		/* FetchTexel2Df */
+   fetch_texel_3d_f_al88_rev,		/* FetchTexel3Df */
    store_texel_al88_rev			/* StoreTexel */
 };
 
@@ -1078,12 +1180,12 @@ const struct gl_texture_format _mesa_texformat_rgb332 = {
    0,					/* StencilBits */
    1,					/* TexelBytes */
    _mesa_texstore_rgb332,		/* StoreTexImageFunc */
-   fetch_texel_1d_rgb332,		/* FetchTexel1D */
-   fetch_texel_2d_rgb332,		/* FetchTexel2D */
-   fetch_texel_3d_rgb332,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_rgb332,		/* FetchTexel1Df */
+   fetch_texel_2d_f_rgb332,		/* FetchTexel2Df */
+   fetch_texel_3d_f_rgb332,		/* FetchTexel3Df */
    store_texel_rgb332			/* StoreTexel */
 };
 
@@ -1102,12 +1204,12 @@ const struct gl_texture_format _mesa_texformat_a8 = {
    0,					/* StencilBits */
    1,					/* TexelBytes */
    _mesa_texstore_a8,			/* StoreTexImageFunc */
-   fetch_texel_1d_a8,			/* FetchTexel1D */
-   fetch_texel_2d_a8,			/* FetchTexel2D */
-   fetch_texel_3d_a8,			/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_a8,			/* FetchTexel1Df */
+   fetch_texel_2d_f_a8,			/* FetchTexel2Df */
+   fetch_texel_3d_f_a8,			/* FetchTexel3Df */
    store_texel_a8			/* StoreTexel */
 };
 
@@ -1126,12 +1228,12 @@ const struct gl_texture_format _mesa_texformat_l8 = {
    0,					/* StencilBits */
    1,					/* TexelBytes */
    _mesa_texstore_a8,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_l8,			/* FetchTexel1D */
-   fetch_texel_2d_l8,			/* FetchTexel2D */
-   fetch_texel_3d_l8,			/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_l8,			/* FetchTexel1Df */
+   fetch_texel_2d_f_l8,			/* FetchTexel2Df */
+   fetch_texel_3d_f_l8,			/* FetchTexel3Df */
    store_texel_l8			/* StoreTexel */
 };
 
@@ -1150,12 +1252,12 @@ const struct gl_texture_format _mesa_texformat_i8 = {
    0,					/* StencilBits */
    1,					/* TexelBytes */
    _mesa_texstore_a8,/*yes*/		/* StoreTexImageFunc */
-   fetch_texel_1d_i8,			/* FetchTexel1D */
-   fetch_texel_2d_i8,			/* FetchTexel2D */
-   fetch_texel_3d_i8,			/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_i8,			/* FetchTexel1Df */
+   fetch_texel_2d_f_i8,			/* FetchTexel2Df */
+   fetch_texel_3d_f_i8,			/* FetchTexel3Df */
    store_texel_i8			/* StoreTexel */
 };
 
@@ -1174,12 +1276,12 @@ const struct gl_texture_format _mesa_texformat_ci8 = {
    0,					/* StencilBits */
    1,					/* TexelBytes */
    _mesa_texstore_ci8,			/* StoreTexImageFunc */
-   fetch_texel_1d_ci8,			/* FetchTexel1D */
-   fetch_texel_2d_ci8,			/* FetchTexel2D */
-   fetch_texel_3d_ci8,			/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_ci8,		/* FetchTexel1Df */
+   fetch_texel_2d_f_ci8,		/* FetchTexel2Df */
+   fetch_texel_3d_f_ci8,		/* FetchTexel3Df */
    store_texel_ci8			/* StoreTexel */
 };
 
@@ -1198,12 +1300,12 @@ const struct gl_texture_format _mesa_texformat_ycbcr = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_ycbcr,		/* StoreTexImageFunc */
-   fetch_texel_1d_ycbcr,		/* FetchTexel1D */
-   fetch_texel_2d_ycbcr,		/* FetchTexel2D */
-   fetch_texel_3d_ycbcr,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_ycbcr,		/* FetchTexel1Df */
+   fetch_texel_2d_f_ycbcr,		/* FetchTexel2Df */
+   fetch_texel_3d_f_ycbcr,		/* FetchTexel3Df */
    store_texel_ycbcr			/* StoreTexel */
 };
 
@@ -1222,12 +1324,12 @@ const struct gl_texture_format _mesa_texformat_ycbcr_rev = {
    0,					/* StencilBits */
    2,					/* TexelBytes */
    _mesa_texstore_ycbcr,		/* StoreTexImageFunc */
-   fetch_texel_1d_ycbcr_rev,		/* FetchTexel1D */
-   fetch_texel_2d_ycbcr_rev,		/* FetchTexel2D */
-   fetch_texel_3d_ycbcr_rev,		/* FetchTexel3D */
-   NULL,				/* FetchTexel1Df */
-   NULL,				/* FetchTexel2Df */
-   NULL,				/* FetchTexel3Df */
+   NULL,				/* FetchTexel1D */
+   NULL,				/* FetchTexel2D */
+   NULL,				/* FetchTexel3D */
+   fetch_texel_1d_f_ycbcr_rev,		/* FetchTexel1Df */
+   fetch_texel_2d_f_ycbcr_rev,		/* FetchTexel2Df */
+   fetch_texel_3d_f_ycbcr_rev,		/* FetchTexel3Df */
    store_texel_ycbcr_rev		/* StoreTexel */
 };
 
@@ -1349,13 +1451,7 @@ const struct gl_texture_format _mesa_null_texformat = {
    0,					/* StencilBits */
    0,					/* TexelBytes */
    NULL,				/* StoreTexImageFunc */
-   fetch_null_texel,			/* FetchTexel1D */
-   fetch_null_texel,			/* FetchTexel2D */
-   fetch_null_texel,			/* FetchTexel3D */
-   fetch_null_texelf,			/* FetchTexel1Df */
-   fetch_null_texelf,			/* FetchTexel2Df */
-   fetch_null_texelf,			/* FetchTexel3Df */
-   store_null_texel			/* StoreTexel */
+   _MESA_TEXFORMAT_NULL_OPS
 };
 
 /*@}*/
@@ -1481,41 +1577,39 @@ _mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat,
       }
    }
 
-   if (ctx->Extensions.ARB_texture_compression) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_ALPHA_ARB:
-            return &_mesa_texformat_alpha;
-         case GL_COMPRESSED_LUMINANCE_ARB:
-            return &_mesa_texformat_luminance;
-         case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
-            return &_mesa_texformat_luminance_alpha;
-         case GL_COMPRESSED_INTENSITY_ARB:
-            return &_mesa_texformat_intensity;
-         case GL_COMPRESSED_RGB_ARB:
+   switch (internalFormat) {
+      case GL_COMPRESSED_ALPHA_ARB:
+         return &_mesa_texformat_alpha;
+      case GL_COMPRESSED_LUMINANCE_ARB:
+         return &_mesa_texformat_luminance;
+      case GL_COMPRESSED_LUMINANCE_ALPHA_ARB:
+         return &_mesa_texformat_luminance_alpha;
+      case GL_COMPRESSED_INTENSITY_ARB:
+         return &_mesa_texformat_intensity;
+      case GL_COMPRESSED_RGB_ARB:
 #if FEATURE_texture_fxt1
-            if (ctx->Extensions.TDFX_texture_compression_FXT1)
-               return &_mesa_texformat_rgb_fxt1;
+         if (ctx->Extensions.TDFX_texture_compression_FXT1)
+            return &_mesa_texformat_rgb_fxt1;
 #endif
 #if FEATURE_texture_s3tc
-            if (ctx->Extensions.EXT_texture_compression_s3tc ||
-                ctx->Extensions.S3_s3tc)
-               return &_mesa_texformat_rgb_dxt1;
+         if (ctx->Extensions.EXT_texture_compression_s3tc ||
+             ctx->Extensions.S3_s3tc)
+            return &_mesa_texformat_rgb_dxt1;
 #endif
-            return &_mesa_texformat_rgb;
-         case GL_COMPRESSED_RGBA_ARB:
+         return &_mesa_texformat_rgb;
+      case GL_COMPRESSED_RGBA_ARB:
 #if FEATURE_texture_fxt1
-            if (ctx->Extensions.TDFX_texture_compression_FXT1)
-               return &_mesa_texformat_rgba_fxt1;
+         if (ctx->Extensions.TDFX_texture_compression_FXT1)
+            return &_mesa_texformat_rgba_fxt1;
 #endif
 #if FEATURE_texture_s3tc
-            if (ctx->Extensions.EXT_texture_compression_s3tc ||
-                ctx->Extensions.S3_s3tc)
-               return &_mesa_texformat_rgba_dxt3; /* Not rgba_dxt1, see spec */
+         if (ctx->Extensions.EXT_texture_compression_s3tc ||
+             ctx->Extensions.S3_s3tc)
+            return &_mesa_texformat_rgba_dxt3; /* Not rgba_dxt1, see spec */
 #endif
-            return &_mesa_texformat_rgba;
-         default:
-            ; /* fallthrough */
-      }
+         return &_mesa_texformat_rgba;
+      default:
+         ; /* fallthrough */
    }
 
    if (ctx->Extensions.MESA_ycbcr_texture) {
@@ -1611,6 +1705,27 @@ _mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat,
       }
    }
 
+   if (ctx->Extensions.ATI_envmap_bumpmap) {
+      switch (internalFormat) {
+         case GL_DUDV_ATI:
+         case GL_DU8DV8_ATI:
+            return &_mesa_texformat_dudv8;
+         default:
+            ; /* fallthrough */
+      }
+   }
+
+   if (ctx->Extensions.MESA_texture_signed_rgba) {
+      switch (internalFormat) {
+         case GL_RGBA_SNORM:
+         case GL_RGBA8_SNORM:
+            return &_mesa_texformat_signed_rgba8888;
+         default:
+            ; /* fallthrough */
+      }
+   }
+
+
 #if FEATURE_EXT_texture_sRGB
    if (ctx->Extensions.EXT_texture_sRGB) {
       switch (internalFormat) {
@@ -1626,21 +1741,40 @@ _mesa_choose_tex_format( GLcontext *ctx, GLint internalFormat,
          case GL_SLUMINANCE_ALPHA_EXT:
          case GL_SLUMINANCE8_ALPHA8_EXT:
             return &_mesa_texformat_sla8;
-         /* NOTE: not supporting any compression of sRGB at this time */
-         case GL_COMPRESSED_SRGB_EXT:
-            return &_mesa_texformat_srgb8;
-         case GL_COMPRESSED_SRGB_ALPHA_EXT:
-            return &_mesa_texformat_srgba8;
          case GL_COMPRESSED_SLUMINANCE_EXT:
             return &_mesa_texformat_sl8;
          case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
             return &_mesa_texformat_sla8;
-         case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+         case GL_COMPRESSED_SRGB_EXT:
+#if FEATURE_texture_s3tc
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgb_dxt1;
+#endif
             return &_mesa_texformat_srgb8;
+         case GL_COMPRESSED_SRGB_ALPHA_EXT:
+#if FEATURE_texture_s3tc
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgba_dxt3; /* Not srgba_dxt1, see spec */
+#endif
+            return &_mesa_texformat_srgba8;
+#if FEATURE_texture_s3tc
+         case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgb_dxt1;
+            break;
          case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgba_dxt1;
+            break;
          case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgba_dxt3;
+            break;
          case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-            return &_mesa_texformat_srgba8;
+            if (ctx->Extensions.EXT_texture_compression_s3tc)
+               return &_mesa_texformat_srgba_dxt5;
+            break;
+#endif
          default:
             ; /* fallthrough */
       }
@@ -1721,6 +1855,11 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format,
       *comps = 1; /* XXX OK? */
       return;
 
+   case MESA_FORMAT_S8_Z24:
+      *datatype = GL_UNSIGNED_INT;
+      *comps = 1; /* XXX OK? */
+      return;
+
    case MESA_FORMAT_Z16:
       *datatype = GL_UNSIGNED_SHORT;
       *comps = 1;
@@ -1731,11 +1870,24 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format,
       *comps = 1;
       return;
 
+   case MESA_FORMAT_DUDV8:
+      *datatype = GL_BYTE;
+      *comps = 2;
+      return;
+
+   case MESA_FORMAT_SIGNED_RGBA8888:
+   case MESA_FORMAT_SIGNED_RGBA8888_REV:
+      *datatype = GL_BYTE;
+      *comps = 4;
+      return;
+
+#if FEATURE_EXT_texture_sRGB
    case MESA_FORMAT_SRGB8:
       *datatype = GL_UNSIGNED_BYTE;
       *comps = 3;
       return;
    case MESA_FORMAT_SRGBA8:
+   case MESA_FORMAT_SARGB8:
       *datatype = GL_UNSIGNED_BYTE;
       *comps = 4;
       return;
@@ -1747,17 +1899,28 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format,
       *datatype = GL_UNSIGNED_BYTE;
       *comps = 2;
       return;
+#endif
 
+#if FEATURE_texture_fxt1
    case MESA_FORMAT_RGB_FXT1:
    case MESA_FORMAT_RGBA_FXT1:
+#endif
+#if FEATURE_texture_s3tc
    case MESA_FORMAT_RGB_DXT1:
    case MESA_FORMAT_RGBA_DXT1:
    case MESA_FORMAT_RGBA_DXT3:
    case MESA_FORMAT_RGBA_DXT5:
+#if FEATURE_EXT_texture_sRGB
+   case MESA_FORMAT_SRGB_DXT1:
+   case MESA_FORMAT_SRGBA_DXT1:
+   case MESA_FORMAT_SRGBA_DXT3:
+   case MESA_FORMAT_SRGBA_DXT5:
+#endif
       /* XXX generate error instead? */
       *datatype = GL_UNSIGNED_BYTE;
       *comps = 0;
       return;
+#endif
 
    case MESA_FORMAT_RGBA:
       *datatype = CHAN_TYPE;
diff --git a/src/mesa/main/texformat.h b/src/mesa/main/texformat.h
index b1604d4a49..a4d8bbf831 100644
--- a/src/mesa/main/texformat.h
+++ b/src/mesa/main/texformat.h
@@ -3,6 +3,7 @@
  * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -38,6 +39,16 @@
 #include "mtypes.h"
 
 
+#define _MESA_TEXFORMAT_NULL_OPS \
+   _mesa_texformat_fetch_texel_null,	/* FetchTexel1D */  \
+   _mesa_texformat_fetch_texel_null,	/* FetchTexel2D */  \
+   _mesa_texformat_fetch_texel_null,	/* FetchTexel3D */  \
+   _mesa_texformat_fetch_texel_f_null,	/* FetchTexel1Df */ \
+   _mesa_texformat_fetch_texel_f_null,	/* FetchTexel2Df */ \
+   _mesa_texformat_fetch_texel_f_null,	/* FetchTexel3Df */ \
+   _mesa_texformat_store_texel_null	/* StoreTexel */
+
+
 /**
  * Mesa internal texture image formats.
  * All texture images are stored in one of these formats.
@@ -98,9 +109,13 @@ enum _format {
    /*@{*/
    MESA_FORMAT_SRGB8,
    MESA_FORMAT_SRGBA8,
+   MESA_FORMAT_SARGB8,
    MESA_FORMAT_SL8,
    MESA_FORMAT_SLA8,
    MESA_FORMAT_SRGB_DXT1,
+   MESA_FORMAT_SRGBA_DXT1,
+   MESA_FORMAT_SRGBA_DXT3,
+   MESA_FORMAT_SRGBA_DXT5,
    /*@}*/
 #endif
 
@@ -150,7 +165,16 @@ enum _format {
    MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32,
    MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16,
    MESA_FORMAT_INTENSITY_FLOAT32,
-   MESA_FORMAT_INTENSITY_FLOAT16
+   MESA_FORMAT_INTENSITY_FLOAT16,
+   /*@}*/
+
+   /**
+    * \name Signed fixed point texture formats.
+    */
+   /*@{*/
+   MESA_FORMAT_DUDV8,
+   MESA_FORMAT_SIGNED_RGBA8888,
+   MESA_FORMAT_SIGNED_RGBA8888_REV
    /*@}*/
 };
 
@@ -170,9 +194,13 @@ extern const struct gl_texture_format _mesa_texformat_intensity;
 /*@{*/
 extern const struct gl_texture_format _mesa_texformat_srgb8;
 extern const struct gl_texture_format _mesa_texformat_srgba8;
+extern const struct gl_texture_format _mesa_texformat_sargb8;
 extern const struct gl_texture_format _mesa_texformat_sl8;
 extern const struct gl_texture_format _mesa_texformat_sla8;
 extern const struct gl_texture_format _mesa_texformat_srgb_dxt1;
+extern const struct gl_texture_format _mesa_texformat_srgba_dxt1;
+extern const struct gl_texture_format _mesa_texformat_srgba_dxt3;
+extern const struct gl_texture_format _mesa_texformat_srgba_dxt5;
 /*@}*/
 #endif
 
@@ -192,6 +220,13 @@ extern const struct gl_texture_format _mesa_texformat_intensity_float32;
 extern const struct gl_texture_format _mesa_texformat_intensity_float16;
 /*@}*/
 
+/** Signed fixed point texture formats */
+/*@{*/
+extern const struct gl_texture_format _mesa_texformat_dudv8;
+extern const struct gl_texture_format _mesa_texformat_signed_rgba8888;
+extern const struct gl_texture_format _mesa_texformat_signed_rgba8888_rev;
+/*@}*/
+
 /** \name Assorted hardware-friendly formats */
 /*@{*/
 extern const struct gl_texture_format _mesa_texformat_rgba8888;
@@ -253,4 +288,19 @@ _mesa_format_to_type_and_comps(const struct gl_texture_format *format,
                                GLenum *datatype, GLuint *comps);
 
 
+extern void
+_mesa_texformat_fetch_texel_null(const struct gl_texture_image *texImage,
+			         GLint i, GLint j, GLint k, GLchan *texel);
+
+
+extern void
+_mesa_texformat_fetch_texel_f_null(const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel);
+
+
+extern void
+_mesa_texformat_store_texel_null(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel);
+
+
 #endif
diff --git a/src/mesa/main/texformat_tmp.h b/src/mesa/main/texformat_tmp.h
index 5f0c674d4f..eb160deff9 100644
--- a/src/mesa/main/texformat_tmp.h
+++ b/src/mesa/main/texformat_tmp.h
@@ -3,6 +3,7 @@
  * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -71,14 +72,6 @@
 
 /* MESA_FORMAT_RGBA **********************************************************/
 
-/* Fetch texel from 1D, 2D or 3D RGBA texture, returning 4 GLchans */
-static void FETCH(rgba)( const struct gl_texture_image *texImage,
-			 GLint i, GLint j, GLint k, GLchan *texel )
-{
-   const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 4);
-   COPY_CHAN4( texel, src );
-}
-
 /* Fetch texel from 1D, 2D or 3D RGBA texture, returning 4 GLfloats */
 static void FETCH(f_rgba)( const struct gl_texture_image *texImage,
                            GLint i, GLint j, GLint k, GLfloat *texel )
@@ -106,17 +99,6 @@ static void store_texel_rgba(struct gl_texture_image *texImage,
 
 /* MESA_FORMAT_RGB ***********************************************************/
 
-/* Fetch texel from 1D, 2D or 3D RGB texture, returning 4 GLchans */
-static void FETCH(rgb)( const struct gl_texture_image *texImage,
-			GLint i, GLint j, GLint k, GLchan *texel )
-{
-   const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 3);
-   texel[RCOMP] = src[0];
-   texel[GCOMP] = src[1];
-   texel[BCOMP] = src[2];
-   texel[ACOMP] = CHAN_MAX;
-}
-
 /* Fetch texel from 1D, 2D or 3D RGB texture, returning 4 GLfloats */
 static void FETCH(f_rgb)( const struct gl_texture_image *texImage,
                           GLint i, GLint j, GLint k, GLfloat *texel )
@@ -143,14 +125,14 @@ static void store_texel_rgb(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ALPHA *********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D ALPHA texture, returning 4 GLchans */
-static void FETCH(alpha)( const struct gl_texture_image *texImage,
-			  GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_alpha)( const struct gl_texture_image *texImage,
+			  GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 1);
    texel[RCOMP] =
    texel[GCOMP] =
-   texel[BCOMP] = 0;
-   texel[ACOMP] = src[0];
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = CHAN_TO_FLOAT(src[0]);
 }
 
 #if DIM == 3
@@ -166,14 +148,14 @@ static void store_texel_alpha(struct gl_texture_image *texImage,
 /* MESA_FORMAT_LUMINANCE *****************************************************/
 
 /* Fetch texel from 1D, 2D or 3D LUMIN texture, returning 4 GLchans */
-static void FETCH(luminance)( const struct gl_texture_image *texImage,
-			      GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_luminance)( const struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 1);
    texel[RCOMP] =
    texel[GCOMP] =
-   texel[BCOMP] = src[0];
-   texel[ACOMP] = CHAN_MAX;
+   texel[BCOMP] = CHAN_TO_FLOAT(src[0]);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -189,14 +171,14 @@ static void store_texel_luminance(struct gl_texture_image *texImage,
 /* MESA_FORMAT_LUMINANCE_ALPHA ***********************************************/
 
 /* Fetch texel from 1D, 2D or 3D L_A texture, returning 4 GLchans */
-static void FETCH(luminance_alpha)( const struct gl_texture_image *texImage,
-				    GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_luminance_alpha)(const struct gl_texture_image *texImage,
+                                     GLint i, GLint j, GLint k, GLfloat *texel)
 {
    const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 2);
-   texel[RCOMP] = src[0];
-   texel[GCOMP] = src[0];
-   texel[BCOMP] = src[0];
-   texel[ACOMP] = src[1];
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = CHAN_TO_FLOAT(src[0]);
+   texel[ACOMP] = CHAN_TO_FLOAT(src[1]);
 }
 
 #if DIM == 3
@@ -213,14 +195,14 @@ static void store_texel_luminance_alpha(struct gl_texture_image *texImage,
 /* MESA_FORMAT_INTENSITY *****************************************************/
 
 /* Fetch texel from 1D, 2D or 3D INT. texture, returning 4 GLchans */
-static void FETCH(intensity)( const struct gl_texture_image *texImage,
-			      GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_intensity)( const struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLchan *src = TEXEL_ADDR(GLchan, texImage, i, j, k, 1);
-   texel[RCOMP] = src[0];
-   texel[GCOMP] = src[0];
-   texel[BCOMP] = src[0];
-   texel[ACOMP] = src[0];
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = CHAN_TO_FLOAT(src[0]);
 }
 
 #if DIM == 3
@@ -605,17 +587,19 @@ static void store_texel_intensity_f16(struct gl_texture_image *texImage,
 
 /* MESA_FORMAT_RGBA8888 ******************************************************/
 
-/* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLchans */
-static void FETCH(rgba8888)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+/* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */
+static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
-   texel[RCOMP] = UBYTE_TO_CHAN( (s >> 24)        );
-   texel[GCOMP] = UBYTE_TO_CHAN( (s >> 16) & 0xff );
-   texel[BCOMP] = UBYTE_TO_CHAN( (s >>  8) & 0xff );
-   texel[ACOMP] = UBYTE_TO_CHAN( (s      ) & 0xff );
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 }
 
+
+
 #if DIM == 3
 static void store_texel_rgba8888(struct gl_texture_image *texImage,
                                  GLint i, GLint j, GLint k, const void *texel)
@@ -630,14 +614,14 @@ static void store_texel_rgba8888(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGBA888_REV ***************************************************/
 
 /* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */
-static void FETCH(rgba8888_rev)( const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
-   texel[RCOMP] = UBYTE_TO_CHAN( (s      ) & 0xff );
-   texel[GCOMP] = UBYTE_TO_CHAN( (s >>  8) & 0xff );
-   texel[BCOMP] = UBYTE_TO_CHAN( (s >> 16) & 0xff );
-   texel[ACOMP] = UBYTE_TO_CHAN( (s >> 24)        );
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 }
 
 #if DIM == 3
@@ -654,14 +638,14 @@ static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ARGB8888 ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */
-static void FETCH(argb8888)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
-   texel[RCOMP] = UBYTE_TO_CHAN( (s >> 16) & 0xff );
-   texel[GCOMP] = UBYTE_TO_CHAN( (s >>  8) & 0xff );
-   texel[BCOMP] = UBYTE_TO_CHAN( (s      ) & 0xff );
-   texel[ACOMP] = UBYTE_TO_CHAN( (s >> 24)        );
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
 }
 
 #if DIM == 3
@@ -677,15 +661,15 @@ static void store_texel_argb8888(struct gl_texture_image *texImage,
 
 /* MESA_FORMAT_ARGB8888_REV **************************************************/
 
-/* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLchans */
-static void FETCH(argb8888_rev)( const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLchan *texel )
+/* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */
+static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
-   texel[RCOMP] = UBYTE_TO_CHAN( (s >>  8) & 0xff );
-   texel[GCOMP] = UBYTE_TO_CHAN( (s >> 16) & 0xff );
-   texel[BCOMP] = UBYTE_TO_CHAN( (s >> 24)        );
-   texel[ACOMP] = UBYTE_TO_CHAN( (s      ) & 0xff );
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
 }
 
 #if DIM == 3
@@ -702,14 +686,14 @@ static void store_texel_argb8888_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGB888 ********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */
-static void FETCH(rgb888)( const struct gl_texture_image *texImage,
-			   GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   texel[RCOMP] = UBYTE_TO_CHAN( src[2] );
-   texel[GCOMP] = UBYTE_TO_CHAN( src[1] );
-   texel[BCOMP] = UBYTE_TO_CHAN( src[0] );
-   texel[ACOMP] = CHAN_MAX;
+   texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );
+   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -718,9 +702,9 @@ static void store_texel_rgb888(struct gl_texture_image *texImage,
 {
    const GLubyte *rgba = (const GLubyte *) texel;
    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   dst[0] = rgba[RCOMP];
+   dst[0] = rgba[BCOMP];
    dst[1] = rgba[GCOMP];
-   dst[2] = rgba[BCOMP];
+   dst[2] = rgba[RCOMP];
 }
 #endif
 
@@ -728,14 +712,14 @@ static void store_texel_rgb888(struct gl_texture_image *texImage,
 /* MESA_FORMAT_BGR888 ********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */
-static void FETCH(bgr888)( const struct gl_texture_image *texImage,
-			   GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   texel[RCOMP] = UBYTE_TO_CHAN( src[0] );
-   texel[GCOMP] = UBYTE_TO_CHAN( src[1] );
-   texel[BCOMP] = UBYTE_TO_CHAN( src[2] );
-   texel[ACOMP] = CHAN_MAX;
+   texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -744,9 +728,9 @@ static void store_texel_bgr888(struct gl_texture_image *texImage,
 {
    const GLubyte *rgba = (const GLubyte *) texel;
    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   dst[0] = rgba[BCOMP];
+   dst[0] = rgba[RCOMP];
    dst[1] = rgba[GCOMP];
-   dst[2] = rgba[RCOMP];
+   dst[2] = rgba[BCOMP];
 }
 #endif
 
@@ -757,15 +741,15 @@ static void store_texel_bgr888(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGB565 ********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */
-static void FETCH(rgb565)( const struct gl_texture_image *texImage,
-			   GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
-   texel[ACOMP] = CHAN_MAX;
+   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);
+   texel[BCOMP] = ((s      ) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -782,15 +766,15 @@ static void store_texel_rgb565(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGB565_REV ****************************************************/
 
 /* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */
-static void FETCH(rgb565_rev)( const struct gl_texture_image *texImage,
-                               GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
-   texel[ACOMP] = CHAN_MAX;
+   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
+   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
+   texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -806,15 +790,15 @@ static void store_texel_rgb565_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGBA4444 ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
-static void FETCH(rgba4444)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgba4444)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >> 12) & 0xf) | ((s >> 8) & 0xf0) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >>  8) & 0xf) | ((s >> 4) & 0xf0) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s >>  4) & 0xf) | ((s     ) & 0xf0) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s      ) & 0xf) | ((s << 4) & 0xf0) );
+   texel[RCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
+   texel[GCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
+   texel[BCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
 }
 
 #if DIM == 3
@@ -831,15 +815,15 @@ static void store_texel_rgba4444(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ARGB4444 ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
-static void FETCH(argb4444)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >>  8) & 0xf) | ((s >> 4) & 0xf0) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >>  4) & 0xf) | ((s     ) & 0xf0) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s      ) & 0xf) | ((s << 4) & 0xf0) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s >> 12) & 0xf) | ((s >> 8) & 0xf0) );
+   texel[RCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
+   texel[GCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
+   texel[BCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
 }
 
 #if DIM == 3
@@ -856,14 +840,14 @@ static void store_texel_argb4444(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ARGB4444_REV **************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */
-static void FETCH(argb4444_rev)( const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s      ) & 0xf) | ((s << 4) & 0xf0) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >> 12) & 0xf) | ((s >> 8) & 0xf0) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s >>  8) & 0xf) | ((s >> 4) & 0xf0) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s >>  4) & 0xf) | ((s     ) & 0xf0) );
+   texel[RCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
+   texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
+   texel[BCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
 }
 
 #if DIM == 3
@@ -879,15 +863,15 @@ static void store_texel_argb4444_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGBA5551 ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
-static void FETCH(rgba5551)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >>  8) & 0xf8) | ((s >> 13) & 0x7) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >>  3) & 0xf8) | ((s >>  8) & 0x7) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s <<  2) & 0xf8) | ((s >>  3) & 0x7) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s) & 0x01) ? 255 : 0);
+   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >>  6) & 0x1f) * (1.0F / 31.0F);
+   texel[BCOMP] = ((s >>  1) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = ((s      ) & 0x01) * 1.0F;
 }
 
 #if DIM == 3
@@ -903,15 +887,15 @@ static void store_texel_rgba5551(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ARGB1555 ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
-static void FETCH(argb1555)( const struct gl_texture_image *texImage,
-			     GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s >> 15) & 0x01) * 255 );
+   texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >>  5) & 0x1f) * (1.0F / 31.0F);
+   texel[BCOMP] = ((s >>  0) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;
 }
 
 #if DIM == 3
@@ -928,15 +912,15 @@ static void store_texel_argb1555(struct gl_texture_image *texImage,
 /* MESA_FORMAT_ARGB1555_REV **************************************************/
 
 /* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */
-static void FETCH(argb1555_rev)( const struct gl_texture_image *texImage,
-                                 GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */
-   texel[RCOMP] = UBYTE_TO_CHAN( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
-   texel[GCOMP] = UBYTE_TO_CHAN( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
-   texel[BCOMP] = UBYTE_TO_CHAN( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
-   texel[ACOMP] = UBYTE_TO_CHAN( ((s >> 15) & 0x01) * 255 );
+   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
+   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
+   texel[BCOMP] = UBYTE_TO_FLOAT( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
+   texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );
 }
 
 #if DIM == 3
@@ -953,14 +937,14 @@ static void store_texel_argb1555_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_AL88 **********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */
-static void FETCH(al88)( const struct gl_texture_image *texImage,
-			 GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_al88)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    texel[RCOMP] = 
    texel[GCOMP] = 
-   texel[BCOMP] = UBYTE_TO_CHAN( s & 0xff );
-   texel[ACOMP] = UBYTE_TO_CHAN( s >> 8 );
+   texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );
 }
 
 #if DIM == 3
@@ -977,14 +961,14 @@ static void store_texel_al88(struct gl_texture_image *texImage,
 /* MESA_FORMAT_AL88_REV ******************************************************/
 
 /* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */
-static void FETCH(al88_rev)( const struct gl_texture_image *texImage,
-                             GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
    texel[RCOMP] = 
    texel[GCOMP] = 
-   texel[BCOMP] = UBYTE_TO_CHAN( s >> 8 );
-   texel[ACOMP] = UBYTE_TO_CHAN( s & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );
+   texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );
 }
 
 #if DIM == 3
@@ -1001,17 +985,15 @@ static void store_texel_al88_rev(struct gl_texture_image *texImage,
 /* MESA_FORMAT_RGB332 ********************************************************/
 
 /* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */
-static void FETCH(rgb332)( const struct gl_texture_image *texImage,
-			   GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
 {
-   static const GLubyte lut2to8[4] = {0, 85, 170, 255};
-   static const GLubyte lut3to8[8] = {0, 36, 73, 109, 146, 182, 219, 255};
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
    const GLubyte s = *src;
-   texel[RCOMP] = UBYTE_TO_CHAN( lut3to8[(s >> 5) & 0x7] );
-   texel[GCOMP] = UBYTE_TO_CHAN( lut3to8[(s >> 2) & 0x7] );
-   texel[BCOMP] = UBYTE_TO_CHAN( lut2to8[(s     ) & 0x3] );
-   texel[ACOMP] = CHAN_MAX;
+   texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);
+   texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);
+   texel[BCOMP] = ((s     ) & 0x3) * (1.0F / 3.0F);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -1028,14 +1010,14 @@ static void store_texel_rgb332(struct gl_texture_image *texImage,
 /* MESA_FORMAT_A8 ************************************************************/
 
 /* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
-static void FETCH(a8)( const struct gl_texture_image *texImage,
-		       GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_a8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
    texel[RCOMP] =
    texel[GCOMP] =
-   texel[BCOMP] = 0;
-   texel[ACOMP] = UBYTE_TO_CHAN( src[0] );
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
 }
 
 #if DIM == 3
@@ -1052,14 +1034,14 @@ static void store_texel_a8(struct gl_texture_image *texImage,
 /* MESA_FORMAT_L8 ************************************************************/
 
 /* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */
-static void FETCH(l8)( const struct gl_texture_image *texImage,
-		       GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_l8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
    texel[RCOMP] =
    texel[GCOMP] =
-   texel[BCOMP] = UBYTE_TO_CHAN( src[0] );
-   texel[ACOMP] = CHAN_MAX;
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -1076,14 +1058,14 @@ static void store_texel_l8(struct gl_texture_image *texImage,
 /* MESA_FORMAT_I8 ************************************************************/
 
 /* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */
-static void FETCH(i8)( const struct gl_texture_image *texImage,
-		       GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_i8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
    texel[RCOMP] =
    texel[GCOMP] =
    texel[BCOMP] =
-   texel[ACOMP] = UBYTE_TO_CHAN( src[0] );
+   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
 }
 
 #if DIM == 3
@@ -1102,12 +1084,11 @@ static void store_texel_i8(struct gl_texture_image *texImage,
 /* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a
  * color table, and return 4 GLchans.
  */
-static void FETCH(ci8)( const struct gl_texture_image *texImage,
-			GLint i, GLint j, GLint k, GLchan *texel )
+static void FETCH(f_ci8)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
    const struct gl_color_table *palette;
-   GLubyte texelUB[4];
    GLuint index;
    GET_CURRENT_CONTEXT(ctx);
 
@@ -1124,61 +1105,48 @@ static void FETCH(ci8)( const struct gl_texture_image *texImage,
    index = (*src) & (palette->Size - 1);
 
    {
-      const GLubyte *table = palette->TableUB;
+      const GLfloat *table = palette->TableF;
       switch (palette->_BaseFormat) {
       case GL_ALPHA:
-         texelUB[RCOMP] =
-         texelUB[GCOMP] =
-         texelUB[BCOMP] = 0;
-         texelUB[ACOMP] = table[index];
-         break;;
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = 0.0F;
+         texel[ACOMP] = table[index];
+         break;
       case GL_LUMINANCE:
-         texelUB[RCOMP] =
-         texelUB[GCOMP] =
-         texelUB[BCOMP] = table[index];
-         texelUB[ACOMP] = 255;
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = table[index];
+         texel[ACOMP] = 1.0F;
          break;
       case GL_INTENSITY:
-         texelUB[RCOMP] =
-         texelUB[GCOMP] =
-         texelUB[BCOMP] =
-         texelUB[ACOMP] = table[index];
-         break;;
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] =
+         texel[ACOMP] = table[index];
+         break;
       case GL_LUMINANCE_ALPHA:
-         texelUB[RCOMP] =
-         texelUB[GCOMP] =
-         texelUB[BCOMP] = table[index * 2 + 0];
-         texelUB[ACOMP] = table[index * 2 + 1];
-         break;;
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = table[index * 2 + 0];
+         texel[ACOMP] = table[index * 2 + 1];
+         break;
       case GL_RGB:
-         texelUB[RCOMP] = table[index * 3 + 0];
-         texelUB[GCOMP] = table[index * 3 + 1];
-         texelUB[BCOMP] = table[index * 3 + 2];
-         texelUB[ACOMP] = 255;
-         break;;
+         texel[RCOMP] = table[index * 3 + 0];
+         texel[GCOMP] = table[index * 3 + 1];
+         texel[BCOMP] = table[index * 3 + 2];
+         texel[ACOMP] = 1.0F;
+         break;
       case GL_RGBA:
-         texelUB[RCOMP] = table[index * 4 + 0];
-         texelUB[GCOMP] = table[index * 4 + 1];
-         texelUB[BCOMP] = table[index * 4 + 2];
-         texelUB[ACOMP] = table[index * 4 + 3];
-         break;;
+         texel[RCOMP] = table[index * 4 + 0];
+         texel[GCOMP] = table[index * 4 + 1];
+         texel[BCOMP] = table[index * 4 + 2];
+         texel[ACOMP] = table[index * 4 + 3];
+         break;
       default:
          _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");
          return;
       }
-#if CHAN_TYPE == GL_UNSIGNED_BYTE
-      COPY_4UBV(texel, texelUB);
-#elif CHAN_TYPE == GL_UNSIGNED_SHORT
-      texel[0] = UBYTE_TO_USHORT(texelUB[0]);
-      texel[1] = UBYTE_TO_USHORT(texelUB[1]);
-      texel[2] = UBYTE_TO_USHORT(texelUB[2]);
-      texel[3] = UBYTE_TO_USHORT(texelUB[3]);
-#else
-      texel[0] = UBYTE_TO_FLOAT(texelUB[0]);
-      texel[1] = UBYTE_TO_FLOAT(texelUB[1]);
-      texel[2] = UBYTE_TO_FLOAT(texelUB[2]);
-      texel[3] = UBYTE_TO_FLOAT(texelUB[3]);
-#endif
    }
 }
 
@@ -1196,14 +1164,15 @@ static void store_texel_ci8(struct gl_texture_image *texImage,
 #if FEATURE_EXT_texture_sRGB
 
 /* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */
+/* Note: component order is same as for MESA_FORMAT_RGB888 */
 static void FETCH(srgb8)(const struct gl_texture_image *texImage,
                          GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   texel[RCOMP] = nonlinear_to_linear(src[0]);
+   texel[RCOMP] = nonlinear_to_linear(src[2]);
    texel[GCOMP] = nonlinear_to_linear(src[1]);
-   texel[BCOMP] = nonlinear_to_linear(src[2]);
-   texel[ACOMP] = CHAN_MAX;
+   texel[BCOMP] = nonlinear_to_linear(src[0]);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -1212,9 +1181,9 @@ static void store_texel_srgb8(struct gl_texture_image *texImage,
 {
    const GLubyte *rgba = (const GLubyte *) texel;
    GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
-   dst[0] = rgba[RCOMP]; /* no conversion */
+   dst[0] = rgba[BCOMP]; /* no conversion */
    dst[1] = rgba[GCOMP];
-   dst[2] = rgba[BCOMP];
+   dst[2] = rgba[RCOMP];
 }
 #endif
 
@@ -1222,11 +1191,11 @@ static void store_texel_srgb8(struct gl_texture_image *texImage,
 static void FETCH(srgba8)(const struct gl_texture_image *texImage,
                           GLint i, GLint j, GLint k, GLfloat *texel )
 {
-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
-   texel[RCOMP] = nonlinear_to_linear(src[0]);
-   texel[GCOMP] = nonlinear_to_linear(src[1]);
-   texel[BCOMP] = nonlinear_to_linear(src[2]);
-   texel[ACOMP] = UBYTE_TO_FLOAT(src[3]); /* linear! */
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = nonlinear_to_linear( (s >> 24) );
+   texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
+   texel[BCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff ); /* linear! */
 }
 
 #if DIM == 3
@@ -1234,10 +1203,29 @@ static void store_texel_srgba8(struct gl_texture_image *texImage,
                                GLint i, GLint j, GLint k, const void *texel)
 {
    const GLubyte *rgba = (const GLubyte *) texel;
-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
-   dst[0] = rgba[RCOMP];
-   dst[1] = rgba[GCOMP];
-   dst[2] = rgba[BCOMP];
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+/* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */
+static void FETCH(sargb8)(const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
+   texel[GCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
+   texel[BCOMP] = nonlinear_to_linear( (s      ) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */
+}
+
+#if DIM == 3
+static void store_texel_sargb8(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
 }
 #endif
 
@@ -1249,7 +1237,7 @@ static void FETCH(sl8)(const struct gl_texture_image *texImage,
    texel[RCOMP] = 
    texel[GCOMP] = 
    texel[BCOMP] = nonlinear_to_linear(src[0]);
-   texel[ACOMP] = CHAN_MAX;
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -1284,19 +1272,74 @@ static void store_texel_sla8(struct gl_texture_image *texImage,
 }
 #endif
 
+#endif /* FEATURE_EXT_texture_sRGB */
 
 
-#endif /* FEATURE_EXT_texture_sRGB */
+/* MESA_FORMAT_DUDV8 ********************************************************/
+
+/* this format by definition produces 0,0,0,1 as rgba values,
+   however we'll return the dudv values as rg and fix up elsewhere */
+static void FETCH(dudv8)(const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);
+   texel[RCOMP] = BYTE_TO_FLOAT(src[0]);
+   texel[GCOMP] = BYTE_TO_FLOAT(src[1]);
+   texel[BCOMP] = 0;
+   texel[ACOMP] = 0;
+}
+
+/* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/
+
+static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,
+			            GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (s >> 24)        );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (s >> 16) & 0xff );
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (s >>  8) & 0xff );
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (s      ) & 0xff );
+}
+
+#if DIM == 3
+static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (s      ) & 0xff );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (s >>  8) & 0xff );
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (s >> 16) & 0xff );
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (s >> 24)        );
+}
+
+#if DIM == 3
+static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,
+                                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
 
 
 
 /* MESA_FORMAT_YCBCR *********************************************************/
 
-/* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLchans */
-/* We convert YCbCr to RGB here */
-/* XXX this may break if GLchan != GLubyte */
-static void FETCH(ycbcr)( const struct gl_texture_image *texImage,
-                          GLint i, GLint j, GLint k, GLchan *texel )
+/* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.
+ * We convert YCbCr to RGB here.
+ */
+static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
    const GLushort *src1 = src0 + 1;                               /* odd */
@@ -1304,23 +1347,17 @@ static void FETCH(ycbcr)( const struct gl_texture_image *texImage,
    const GLubyte cb = *src0 & 0xff;         /* chroma U */
    const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
    const GLubyte cr = *src1 & 0xff;         /* chroma V */
-   GLint r, g, b;
-   if (i & 1) {
-      /* odd pixel: use y1,cr,cb */
-      r = (GLint) (1.164 * (y1-16) + 1.596 * (cr-128));
-      g = (GLint) (1.164 * (y1-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
-      b = (GLint) (1.164 * (y1-16) + 2.018 * (cb-128));
-   }
-   else {
-      /* even pixel: use y0,cr,cb */
-      r = (GLint) (1.164 * (y0-16) + 1.596 * (cr-128));
-      g = (GLint) (1.164 * (y0-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
-      b = (GLint) (1.164 * (y0-16) + 2.018 * (cb-128));
-   }
-   texel[RCOMP] = CLAMP(r, 0, CHAN_MAX);
-   texel[GCOMP] = CLAMP(g, 0, CHAN_MAX);
-   texel[BCOMP] = CLAMP(b, 0, CHAN_MAX);
-   texel[ACOMP] = CHAN_MAX;
+   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+   r *= (1.0F / 255.0F);
+   g *= (1.0F / 255.0F);
+   b *= (1.0F / 255.0F);
+   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
+   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
+   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
@@ -1339,11 +1376,11 @@ static void store_texel_ycbcr(struct gl_texture_image *texImage,
 
 /* MESA_FORMAT_YCBCR_REV *****************************************************/
 
-/* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLchans */
-/* We convert YCbCr to RGB here */
-/* XXX this may break if GLchan != GLubyte */
-static void FETCH(ycbcr_rev)( const struct gl_texture_image *texImage,
-                              GLint i, GLint j, GLint k, GLchan *texel )
+/* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.
+ * We convert YCbCr to RGB here.
+ */
+static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, GLfloat *texel )
 {
    const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
    const GLushort *src1 = src0 + 1;                               /* odd */
@@ -1351,23 +1388,17 @@ static void FETCH(ycbcr_rev)( const struct gl_texture_image *texImage,
    const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
    const GLubyte y1 = *src1 & 0xff;         /* luminance */
    const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
-   GLint r, g, b;
-   if (i & 1) {
-      /* odd pixel: use y1,cr,cb */
-      r = (GLint) (1.164 * (y1-16) + 1.596 * (cr-128));
-      g = (GLint) (1.164 * (y1-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
-      b = (GLint) (1.164 * (y1-16) + 2.018 * (cb-128));
-   }
-   else {
-      /* even pixel: use y0,cr,cb */
-      r = (GLint) (1.164 * (y0-16) + 1.596 * (cr-128));
-      g = (GLint) (1.164 * (y0-16) - 0.813 * (cr-128) - 0.391 * (cb-128));
-      b = (GLint) (1.164 * (y0-16) + 2.018 * (cb-128));
-   }
-   texel[RCOMP] = CLAMP(r, 0, CHAN_MAX);
-   texel[GCOMP] = CLAMP(g, 0, CHAN_MAX);
-   texel[BCOMP] = CLAMP(b, 0, CHAN_MAX);
-   texel[ACOMP] = CHAN_MAX;
+   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+   r *= (1.0F / 255.0F);
+   g *= (1.0F / 255.0F);
+   b *= (1.0F / 255.0F);
+   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
+   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
+   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
+   texel[ACOMP] = 1.0F;
 }
 
 #if DIM == 3
diff --git a/src/mesa/main/texgen.c b/src/mesa/main/texgen.c
index 244c7aaafc..8c98ee3602 100644
--- a/src/mesa/main/texgen.c
+++ b/src/mesa/main/texgen.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -34,15 +35,40 @@
 #include "main/enums.h"
 #include "main/macros.h"
 #include "main/texgen.h"
-#include "math/m_xform.h"
+#include "math/m_matrix.h"
+#include "glapi/dispatch.h"
 
 
+#if FEATURE_texgen
+
+
+/**
+ * Return texgen state for given coordinate
+ */
+static struct gl_texgen *
+get_texgen(struct gl_texture_unit *texUnit, GLenum coord)
+{
+   switch (coord) {
+   case GL_S:
+      return &texUnit->GenS;
+   case GL_T:
+      return &texUnit->GenT;
+   case GL_R:
+      return &texUnit->GenR;
+   case GL_Q:
+      return &texUnit->GenQ;
+   default:
+      return NULL;
+   }
+}
+
 
 void GLAPIENTRY
 _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
 {
-   GET_CURRENT_CONTEXT(ctx);
    struct gl_texture_unit *texUnit;
+   struct gl_texgen *texgen;
+   GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
@@ -59,210 +85,79 @@ _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 
-   switch (coord) {
-      case GL_S:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-	    GLenum mode = (GLenum) (GLint) *params;
-	    GLbitfield bits;
-	    switch (mode) {
-	    case GL_OBJECT_LINEAR:
-	       bits = TEXGEN_OBJ_LINEAR;
-	       break;
-	    case GL_EYE_LINEAR:
-	       bits = TEXGEN_EYE_LINEAR;
-	       break;
-	    case GL_REFLECTION_MAP_NV:
-	       bits = TEXGEN_REFLECTION_MAP_NV;
-	       break;
-	    case GL_NORMAL_MAP_NV:
-	       bits = TEXGEN_NORMAL_MAP_NV;
-	       break;
-	    case GL_SPHERE_MAP:
-	       bits = TEXGEN_SPHERE_MAP;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
-	       return;
-	    }
-	    if (texUnit->GenModeS == mode)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->GenModeS = mode;
-	    texUnit->_GenBitS = bits;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-	    if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
-		return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            COPY_4FV(texUnit->ObjectPlaneS, params);
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-	    GLfloat tmp[4];
-            /* Transform plane equation by the inverse modelview matrix */
-            if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
-               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
-            }
-            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
-	    if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    COPY_4FV(texUnit->EyePlaneS, tmp);
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_T:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-	    GLenum mode = (GLenum) (GLint) *params;
-	    GLbitfield bitt;
-	    switch (mode) {
-               case GL_OBJECT_LINEAR:
-                  bitt = TEXGEN_OBJ_LINEAR;
-                  break;
-               case GL_EYE_LINEAR:
-                  bitt = TEXGEN_EYE_LINEAR;
-                  break;
-               case GL_REFLECTION_MAP_NV:
-                  bitt = TEXGEN_REFLECTION_MAP_NV;
-                  break;
-               case GL_NORMAL_MAP_NV:
-                  bitt = TEXGEN_NORMAL_MAP_NV;
-                  break;
-               case GL_SPHERE_MAP:
-                  bitt = TEXGEN_SPHERE_MAP;
-                  break;
-               default:
-                  _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
-                  return;
-	    }
-	    if (texUnit->GenModeT == mode)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->GenModeT = mode;
-	    texUnit->_GenBitT = bitt;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-	    if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
-		return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            COPY_4FV(texUnit->ObjectPlaneT, params);
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-	    GLfloat tmp[4];
-            /* Transform plane equation by the inverse modelview matrix */
-	    if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
-               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
-            }
-            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
-	    if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
-		return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    COPY_4FV(texUnit->EyePlaneT, tmp);
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_R:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-	    GLenum mode = (GLenum) (GLint) *params;
-	    GLbitfield bitr;
-	    switch (mode) {
-	    case GL_OBJECT_LINEAR:
-	       bitr = TEXGEN_OBJ_LINEAR;
-	       break;
-	    case GL_REFLECTION_MAP_NV:
-	       bitr = TEXGEN_REFLECTION_MAP_NV;
-	       break;
-	    case GL_NORMAL_MAP_NV:
-	       bitr = TEXGEN_NORMAL_MAP_NV;
-	       break;
-	    case GL_EYE_LINEAR:
-	       bitr = TEXGEN_EYE_LINEAR;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
-	       return;
-	    }
-	    if (texUnit->GenModeR == mode)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->GenModeR = mode;
-	    texUnit->_GenBitR = bitr;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-	    if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
-		return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    COPY_4FV(texUnit->ObjectPlaneR, params);
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-	    GLfloat tmp[4];
-            /* Transform plane equation by the inverse modelview matrix */
-            if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
-               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
-            }
-            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
-	    if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    COPY_4FV(texUnit->EyePlaneR, tmp);
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_Q:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-	    GLenum mode = (GLenum) (GLint) *params;
-	    GLbitfield bitq;
-	    switch (mode) {
-	    case GL_OBJECT_LINEAR:
-	       bitq = TEXGEN_OBJ_LINEAR;
-	       break;
-	    case GL_EYE_LINEAR:
-	       bitq = TEXGEN_EYE_LINEAR;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
-	       return;
-	    }
-	    if (texUnit->GenModeQ == mode)
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    texUnit->GenModeQ = mode;
-	    texUnit->_GenBitQ = bitq;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-	    if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
-		return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            COPY_4FV(texUnit->ObjectPlaneQ, params);
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-	    GLfloat tmp[4];
-            /* Transform plane equation by the inverse modelview matrix */
-            if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
-               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
-            }
-            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
-	    if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
-	       return;
-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-	    COPY_4FV(texUnit->EyePlaneQ, tmp);
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
-	 return;
+   texgen = get_texgen(texUnit, coord);
+   if (!texgen) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexGen(coord)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_TEXTURE_GEN_MODE:
+      {
+         GLenum mode = (GLenum) (GLint) params[0];
+         GLbitfield bit = 0x0;
+         if (texgen->Mode == mode)
+            return;
+         switch (mode) {
+         case GL_OBJECT_LINEAR:
+            bit = TEXGEN_OBJ_LINEAR;
+            break;
+         case GL_EYE_LINEAR:
+            bit = TEXGEN_EYE_LINEAR;
+            break;
+         case GL_SPHERE_MAP:
+            if (coord == GL_S || coord == GL_T)
+               bit = TEXGEN_SPHERE_MAP;
+            break;
+         case GL_REFLECTION_MAP_NV:
+            if (coord != GL_Q)
+               bit = TEXGEN_REFLECTION_MAP_NV;
+            break;
+         case GL_NORMAL_MAP_NV:
+            if (coord != GL_Q)
+               bit = TEXGEN_NORMAL_MAP_NV;
+            break;
+         default:
+            ; /* nop */
+         }
+         if (!bit) {
+            _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
+            return;
+         }
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texgen->Mode = mode;
+         texgen->_ModeBit = bit;
+      }
+      break;
+
+   case GL_OBJECT_PLANE:
+      {
+         if (TEST_EQ_4V(texgen->ObjectPlane, params))
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         COPY_4FV(texgen->ObjectPlane, params);
+      }
+      break;
+
+   case GL_EYE_PLANE:
+      {
+         GLfloat tmp[4];
+         /* Transform plane equation by the inverse modelview matrix */
+         if (_math_matrix_is_dirty(ctx->ModelviewMatrixStack.Top)) {
+            _math_matrix_analyse(ctx->ModelviewMatrixStack.Top);
+         }
+         _mesa_transform_vector(tmp, params,
+                                ctx->ModelviewMatrixStack.Top->inv);
+         if (TEST_EQ_4V(texgen->EyePlane, tmp))
+            return;
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         COPY_4FV(texgen->EyePlane, tmp);
+      }
+      break;
+
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
+      return;
    }
 
    if (ctx->Driver.TexGen)
@@ -330,7 +225,8 @@ _mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
 void GLAPIENTRY
 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
 {
-   const struct gl_texture_unit *texUnit;
+   struct gl_texture_unit *texUnit;
+   struct gl_texgen *texgen;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -341,70 +237,24 @@ _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 
-   switch (coord) {
-      case GL_S:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneS );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneS );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_T:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneT );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneT );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_R:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneR );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneR );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_Q:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneQ );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneQ );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
-	    return;
-	 }
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
-	 return;
+   texgen = get_texgen(texUnit, coord);
+   if (!texgen) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_TEXTURE_GEN_MODE:
+      params[0] = ENUM_TO_DOUBLE(texgen->Mode);
+      break;
+   case GL_OBJECT_PLANE:
+      COPY_4V(params, texgen->ObjectPlane);
+      break;
+   case GL_EYE_PLANE:
+      COPY_4V(params, texgen->EyePlane);
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
    }
 }
 
@@ -413,7 +263,8 @@ _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
 void GLAPIENTRY
 _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
 {
-   const struct gl_texture_unit *texUnit;
+   struct gl_texture_unit *texUnit;
+   struct gl_texgen *texgen;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -424,70 +275,24 @@ _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 
-   switch (coord) {
-      case GL_S:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneS );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneS );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_T:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneT );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneT );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_R:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneR );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneR );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_Q:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            COPY_4V( params, texUnit->ObjectPlaneQ );
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            COPY_4V( params, texUnit->EyePlaneQ );
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
-	    return;
-	 }
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
-	 return;
+   texgen = get_texgen(texUnit, coord);
+   if (!texgen) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_TEXTURE_GEN_MODE:
+      params[0] = ENUM_TO_FLOAT(texgen->Mode);
+      break;
+   case GL_OBJECT_PLANE:
+      COPY_4V(params, texgen->ObjectPlane);
+      break;
+   case GL_EYE_PLANE:
+      COPY_4V(params, texgen->EyePlane);
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
    }
 }
 
@@ -496,7 +301,8 @@ _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
 void GLAPIENTRY
 _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
 {
-   const struct gl_texture_unit *texUnit;
+   struct gl_texture_unit *texUnit;
+   struct gl_texgen *texgen;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -507,95 +313,47 @@ _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
 
    texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 
-   switch (coord) {
-      case GL_S:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = texUnit->GenModeS;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            params[0] = (GLint) texUnit->ObjectPlaneS[0];
-            params[1] = (GLint) texUnit->ObjectPlaneS[1];
-            params[2] = (GLint) texUnit->ObjectPlaneS[2];
-            params[3] = (GLint) texUnit->ObjectPlaneS[3];
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            params[0] = (GLint) texUnit->EyePlaneS[0];
-            params[1] = (GLint) texUnit->EyePlaneS[1];
-            params[2] = (GLint) texUnit->EyePlaneS[2];
-            params[3] = (GLint) texUnit->EyePlaneS[3];
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_T:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = texUnit->GenModeT;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            params[0] = (GLint) texUnit->ObjectPlaneT[0];
-            params[1] = (GLint) texUnit->ObjectPlaneT[1];
-            params[2] = (GLint) texUnit->ObjectPlaneT[2];
-            params[3] = (GLint) texUnit->ObjectPlaneT[3];
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            params[0] = (GLint) texUnit->EyePlaneT[0];
-            params[1] = (GLint) texUnit->EyePlaneT[1];
-            params[2] = (GLint) texUnit->EyePlaneT[2];
-            params[3] = (GLint) texUnit->EyePlaneT[3];
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_R:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = texUnit->GenModeR;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            params[0] = (GLint) texUnit->ObjectPlaneR[0];
-            params[1] = (GLint) texUnit->ObjectPlaneR[1];
-            params[2] = (GLint) texUnit->ObjectPlaneR[2];
-            params[3] = (GLint) texUnit->ObjectPlaneR[3];
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            params[0] = (GLint) texUnit->EyePlaneR[0];
-            params[1] = (GLint) texUnit->EyePlaneR[1];
-            params[2] = (GLint) texUnit->EyePlaneR[2];
-            params[3] = (GLint) texUnit->EyePlaneR[3];
-	 }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
-	    return;
-	 }
-	 break;
-      case GL_Q:
-         if (pname==GL_TEXTURE_GEN_MODE) {
-            params[0] = texUnit->GenModeQ;
-	 }
-	 else if (pname==GL_OBJECT_PLANE) {
-            params[0] = (GLint) texUnit->ObjectPlaneQ[0];
-            params[1] = (GLint) texUnit->ObjectPlaneQ[1];
-            params[2] = (GLint) texUnit->ObjectPlaneQ[2];
-            params[3] = (GLint) texUnit->ObjectPlaneQ[3];
-	 }
-	 else if (pname==GL_EYE_PLANE) {
-            params[0] = (GLint) texUnit->EyePlaneQ[0];
-            params[1] = (GLint) texUnit->EyePlaneQ[1];
-            params[2] = (GLint) texUnit->EyePlaneQ[2];
-            params[3] = (GLint) texUnit->EyePlaneQ[3];
-         }
-	 else {
-	    _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
-	    return;
-	 }
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
-	 return;
+   texgen = get_texgen(texUnit, coord);
+   if (!texgen) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)");
+      return;
+   }
+
+   switch (pname) {
+   case GL_TEXTURE_GEN_MODE:
+      params[0] = texgen->Mode;
+      break;
+   case GL_OBJECT_PLANE:
+      params[0] = (GLint) texgen->ObjectPlane[0];
+      params[1] = (GLint) texgen->ObjectPlane[1];
+      params[2] = (GLint) texgen->ObjectPlane[2];
+      params[3] = (GLint) texgen->ObjectPlane[3];
+      break;
+   case GL_EYE_PLANE:
+      params[0] = (GLint) texgen->EyePlane[0];
+      params[1] = (GLint) texgen->EyePlane[1];
+      params[2] = (GLint) texgen->EyePlane[2];
+      params[3] = (GLint) texgen->EyePlane[3];
+      break;
+   default:
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
    }
 }
 
 
+void 
+_mesa_init_texgen_dispatch(struct _glapi_table *disp)
+{
+   SET_GetTexGendv(disp, _mesa_GetTexGendv);
+   SET_GetTexGenfv(disp, _mesa_GetTexGenfv);
+   SET_GetTexGeniv(disp, _mesa_GetTexGeniv);
+   SET_TexGend(disp, _mesa_TexGend);
+   SET_TexGendv(disp, _mesa_TexGendv);
+   SET_TexGenf(disp, _mesa_TexGenf);
+   SET_TexGenfv(disp, _mesa_TexGenfv);
+   SET_TexGeni(disp, _mesa_TexGeni);
+   SET_TexGeniv(disp, _mesa_TexGeniv);
+}
+
+
+#endif /* FEATURE_texgen */
diff --git a/src/mesa/main/texgen.h b/src/mesa/main/texgen.h
index 073588efcd..2ca026de3d 100644
--- a/src/mesa/main/texgen.h
+++ b/src/mesa/main/texgen.h
@@ -27,9 +27,16 @@
 #define TEXGEN_H
 
 
-#include "main/glheader.h"
+#include "main/mtypes.h"
 
 
+#if FEATURE_texgen
+
+#define _MESA_INIT_TEXGEN_FUNCTIONS(driver, impl) \
+   do {                                           \
+      (driver)->TexGen = impl ## TexGen;          \
+   } while (0)
+
 extern void GLAPIENTRY
 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
 
@@ -57,6 +64,19 @@ _mesa_TexGeni( GLenum coord, GLenum pname, GLint param );
 extern void GLAPIENTRY
 _mesa_TexGeniv( GLenum coord, GLenum pname, const GLint *params );
 
+extern void 
+_mesa_init_texgen_dispatch(struct _glapi_table *disp);
+
+#else /* FEATURE_texgen */
+
+#define _MESA_INIT_TEXGEN_FUNCTIONS(driver, impl) do { } while (0)
+
+static INLINE void 
+_mesa_init_texgen_dispatch(struct _glapi_table *disp)
+{
+}
+
+#endif /* FEATURE_texgen */
 
 
 #endif /* TEXGEN_H */
diff --git a/src/mesa/main/texgetimage.c b/src/mesa/main/texgetimage.c
new file mode 100644
index 0000000000..14d6fc7659
--- /dev/null
+++ b/src/mesa/main/texgetimage.c
@@ -0,0 +1,581 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2009 VMware, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/**
+ * Code for glGetTexImage() and glGetCompressedTexImage().
+ */
+
+
+#include "glheader.h"
+#include "bufferobj.h"
+#include "context.h"
+#include "image.h"
+#include "texcompress.h"
+#include "texformat.h"
+#include "texgetimage.h"
+#include "teximage.h"
+#include "texstate.h"
+
+
+
+#if FEATURE_EXT_texture_sRGB
+
+/**
+ * Test if given texture image is an sRGB format.
+ */
+static GLboolean
+is_srgb_teximage(const struct gl_texture_image *texImage)
+{
+   switch (texImage->TexFormat->MesaFormat) {
+   case MESA_FORMAT_SRGB8:
+   case MESA_FORMAT_SRGBA8:
+   case MESA_FORMAT_SARGB8:
+   case MESA_FORMAT_SL8:
+   case MESA_FORMAT_SLA8:
+   case MESA_FORMAT_SRGB_DXT1:
+   case MESA_FORMAT_SRGBA_DXT1:
+   case MESA_FORMAT_SRGBA_DXT3:
+   case MESA_FORMAT_SRGBA_DXT5:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+/**
+ * Convert a float value from linear space to a
+ * non-linear sRGB value in [0, 255].
+ * Not terribly efficient.
+ */
+static INLINE GLfloat
+linear_to_nonlinear(GLfloat cl)
+{
+   /* can't have values outside [0, 1] */
+   GLfloat cs;
+   if (cl < 0.0031308f) {
+      cs = 12.92f * cl;
+   }
+   else {
+      cs = (GLfloat)(1.055 * _mesa_pow(cl, 0.41666) - 0.055);
+   }
+   return cs;
+}
+
+#endif /* FEATURE_EXT_texture_sRGB */
+
+
+/**
+ * Can the given type represent negative values?
+ */
+static INLINE GLboolean
+type_with_negative_values(GLenum type)
+{
+   switch (type) {
+   case GL_BYTE:
+   case GL_SHORT:
+   case GL_INT:
+   case GL_FLOAT:
+   case GL_HALF_FLOAT_ARB:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+/**
+ * This is the software fallback for Driver.GetTexImage().
+ * All error checking will have been done before this routine is called.
+ */
+void
+_mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level,
+                   GLenum format, GLenum type, GLvoid *pixels,
+                   struct gl_texture_object *texObj,
+                   struct gl_texture_image *texImage)
+{
+   const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
+      /* Packing texture image into a PBO.
+       * Map the (potentially) VRAM-based buffer into our process space so
+       * we can write into it with the code below.
+       * A hardware driver might use a sophisticated blit to move the
+       * texture data to the PBO if the PBO is in VRAM along with the texture.
+       */
+      GLubyte *buf = (GLubyte *)
+         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
+                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);
+      if (!buf) {
+         /* buffer is already mapped - that's an error */
+         _mesa_error(ctx, GL_INVALID_OPERATION,"glGetTexImage(PBO is mapped)");
+         return;
+      }
+      /* <pixels> was an offset into the PBO.
+       * Now make it a real, client-side pointer inside the mapped region.
+       */
+      pixels = ADD_POINTERS(buf, pixels);
+   }
+   else if (!pixels) {
+      /* not an error */
+      return;
+   }
+
+   {
+      const GLint width = texImage->Width;
+      const GLint height = texImage->Height;
+      const GLint depth = texImage->Depth;
+      GLint img, row;
+      for (img = 0; img < depth; img++) {
+         for (row = 0; row < height; row++) {
+            /* compute destination address in client memory */
+            GLvoid *dest = _mesa_image_address( dimensions, &ctx->Pack, pixels,
+                                                width, height, format, type,
+                                                img, row, 0);
+            assert(dest);
+
+            if (format == GL_COLOR_INDEX) {
+               GLuint indexRow[MAX_WIDTH];
+               GLint col;
+               /* Can't use FetchTexel here because that returns RGBA */
+               if (texImage->TexFormat->IndexBits == 8) {
+                  const GLubyte *src = (const GLubyte *) texImage->Data;
+                  src += width * (img * texImage->Height + row);
+                  for (col = 0; col < width; col++) {
+                     indexRow[col] = src[col];
+                  }
+               }
+               else if (texImage->TexFormat->IndexBits == 16) {
+                  const GLushort *src = (const GLushort *) texImage->Data;
+                  src += width * (img * texImage->Height + row);
+                  for (col = 0; col < width; col++) {
+                     indexRow[col] = src[col];
+                  }
+               }
+               else {
+                  _mesa_problem(ctx,
+                                "Color index problem in _mesa_GetTexImage");
+               }
+               _mesa_pack_index_span(ctx, width, type, dest,
+                                     indexRow, &ctx->Pack,
+                                     0 /* no image transfer */);
+            }
+            else if (format == GL_DEPTH_COMPONENT) {
+               GLfloat depthRow[MAX_WIDTH];
+               GLint col;
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexelf)(texImage, col, row, img,
+                                           depthRow + col);
+               }
+               _mesa_pack_depth_span(ctx, width, dest, type,
+                                     depthRow, &ctx->Pack);
+            }
+            else if (format == GL_DEPTH_STENCIL_EXT) {
+               /* XXX Note: we're bypassing texImage->FetchTexel()! */
+               const GLuint *src = (const GLuint *) texImage->Data;
+               src += width * row + width * height * img;
+               _mesa_memcpy(dest, src, width * sizeof(GLuint));
+               if (ctx->Pack.SwapBytes) {
+                  _mesa_swap4((GLuint *) dest, width);
+               }
+            }
+            else if (format == GL_YCBCR_MESA) {
+               /* No pixel transfer */
+               const GLint rowstride = texImage->RowStride;
+               MEMCPY(dest,
+                      (const GLushort *) texImage->Data + row * rowstride,
+                      width * sizeof(GLushort));
+               /* check for byte swapping */
+               if ((texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR
+                    && type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||
+                   (texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR_REV
+                    && type == GL_UNSIGNED_SHORT_8_8_MESA)) {
+                  if (!ctx->Pack.SwapBytes)
+                     _mesa_swap2((GLushort *) dest, width);
+               }
+               else if (ctx->Pack.SwapBytes) {
+                  _mesa_swap2((GLushort *) dest, width);
+               }
+            }
+#if FEATURE_EXT_texture_sRGB
+            else if (is_srgb_teximage(texImage)) {
+               /* special case this since need to backconvert values */
+               /* convert row to RGBA format */
+               GLfloat rgba[MAX_WIDTH][4];
+               GLint col;
+               GLbitfield transferOps = 0x0;
+
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexelf)(texImage, col, row, img, rgba[col]);
+                  if (texImage->_BaseFormat == GL_LUMINANCE) {
+                     rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                  }
+                  else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
+                     rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                  }
+                  else if (texImage->_BaseFormat == GL_RGB ||
+                     texImage->_BaseFormat == GL_RGBA) {
+                     rgba[col][RCOMP] = linear_to_nonlinear(rgba[col][RCOMP]);
+                     rgba[col][GCOMP] = linear_to_nonlinear(rgba[col][GCOMP]);
+                     rgba[col][BCOMP] = linear_to_nonlinear(rgba[col][BCOMP]);
+                  }
+               }
+               _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
+                                          format, type, dest,
+                                          &ctx->Pack, transferOps);
+            }
+#endif /* FEATURE_EXT_texture_sRGB */
+            else {
+               /* general case:  convert row to RGBA format */
+               GLfloat rgba[MAX_WIDTH][4];
+               GLint col;
+               GLbitfield transferOps = 0x0;
+
+               /* clamp does not apply to GetTexImage (final conversion)?
+                * Looks like we need clamp though when going from format
+                * containing negative values to unsigned format.
+                */
+               if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA)
+                  transferOps |= IMAGE_CLAMP_BIT;
+               else if (!type_with_negative_values(type) &&
+                        (texImage->TexFormat->DataType == GL_FLOAT ||
+                         texImage->TexFormat->DataType == GL_SIGNED_NORMALIZED))
+                  transferOps |= IMAGE_CLAMP_BIT;
+
+               for (col = 0; col < width; col++) {
+                  (*texImage->FetchTexelf)(texImage, col, row, img, rgba[col]);
+                  if (texImage->_BaseFormat == GL_ALPHA) {
+                     rgba[col][RCOMP] = 0.0;
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                  }
+                  else if (texImage->_BaseFormat == GL_LUMINANCE) {
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                     rgba[col][ACOMP] = 1.0;
+                  }
+                  else if (texImage->_BaseFormat == GL_LUMINANCE_ALPHA) {
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                  }
+                  else if (texImage->_BaseFormat == GL_INTENSITY) {
+                     rgba[col][GCOMP] = 0.0;
+                     rgba[col][BCOMP] = 0.0;
+                     rgba[col][ACOMP] = 1.0;
+                  }
+               }
+               _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
+                                          format, type, dest,
+                                          &ctx->Pack, transferOps);
+            } /* format */
+         } /* row */
+      } /* img */
+   }
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
+                              ctx->Pack.BufferObj);
+   }
+}
+
+
+
+/**
+ * This is the software fallback for Driver.GetCompressedTexImage().
+ * All error checking will have been done before this routine is called.
+ */
+void
+_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level,
+                              GLvoid *img,
+                              struct gl_texture_object *texObj,
+                              struct gl_texture_image *texImage)
+{
+   GLuint size;
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
+      /* pack texture image into a PBO */
+      GLubyte *buf;
+      if ((const GLubyte *) img + texImage->CompressedSize >
+          (const GLubyte *) ctx->Pack.BufferObj->Size) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glGetCompressedTexImage(invalid PBO access)");
+         return;
+      }
+      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
+                                              GL_WRITE_ONLY_ARB,
+                                              ctx->Pack.BufferObj);
+      if (!buf) {
+         /* buffer is already mapped - that's an error */
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glGetCompressedTexImage(PBO is mapped)");
+         return;
+      }
+      img = ADD_POINTERS(buf, img);
+   }
+   else if (!img) {
+      /* not an error */
+      return;
+   }
+
+   /* don't use texImage->CompressedSize since that may be padded out */
+   size = _mesa_compressed_texture_size(ctx, texImage->Width, texImage->Height,
+                                        texImage->Depth,
+                                        texImage->TexFormat->MesaFormat);
+
+   /* just memcpy, no pixelstore or pixel transfer */
+   _mesa_memcpy(img, texImage->Data, size);
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
+      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
+                              ctx->Pack.BufferObj);
+   }
+}
+
+
+
+/**
+ * Do error checking for a glGetTexImage() call.
+ * \return GL_TRUE if any error, GL_FALSE if no errors.
+ */
+static GLboolean
+getteximage_error_check(GLcontext *ctx, GLenum target, GLint level,
+                        GLenum format, GLenum type, GLvoid *pixels )
+{
+   const struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   const GLuint maxLevels = _mesa_max_texture_levels(ctx, target);
+
+   if (maxLevels == 0) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target=0x%x)", target);
+      return GL_TRUE;
+   }
+
+   if (level < 0 || level >= maxLevels) {
+      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
+      return GL_TRUE;
+   }
+
+   if (_mesa_sizeof_packed_type(type) <= 0) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
+      return GL_TRUE;
+   }
+
+   if (_mesa_components_in_format(format) <= 0 ||
+       format == GL_STENCIL_INDEX) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
+      return GL_TRUE;
+   }
+
+   if (!ctx->Extensions.EXT_paletted_texture && _mesa_is_index_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+      return GL_TRUE;
+   }
+
+   if (!ctx->Extensions.ARB_depth_texture && _mesa_is_depth_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+      return GL_TRUE;
+   }
+
+   if (!ctx->Extensions.MESA_ycbcr_texture && _mesa_is_ycbcr_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+      return GL_TRUE;
+   }
+
+   if (!ctx->Extensions.EXT_packed_depth_stencil
+       && _mesa_is_depthstencil_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+      return GL_TRUE;
+   }
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap
+       && _mesa_is_dudv_format(format)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
+      return GL_TRUE;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+   if (!texObj || _mesa_is_proxy_texture(target)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
+      return GL_TRUE;
+   }
+
+   texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+   if (!texImage) {
+      /* out of memory */
+      return GL_TRUE;
+   }
+      
+   /* Make sure the requested image format is compatible with the
+    * texture's format.  Note that a color index texture can be converted
+    * to RGBA so that combo is allowed.
+    */
+   if (_mesa_is_color_format(format)
+       && !_mesa_is_color_format(texImage->TexFormat->BaseFormat)
+       && !_mesa_is_index_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+   else if (_mesa_is_index_format(format)
+            && !_mesa_is_index_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+   else if (_mesa_is_depth_format(format)
+            && !_mesa_is_depth_format(texImage->TexFormat->BaseFormat)
+            && !_mesa_is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+   else if (_mesa_is_ycbcr_format(format)
+            && !_mesa_is_ycbcr_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+   else if (_mesa_is_depthstencil_format(format)
+            && !_mesa_is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+   else if (_mesa_is_dudv_format(format)
+            && !_mesa_is_dudv_format(texImage->TexFormat->BaseFormat)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
+      return GL_TRUE;
+   }
+
+   if (_mesa_is_bufferobj(ctx->Pack.BufferObj)) {
+      /* packing texture image into a PBO */
+      const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
+      if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,
+                                     texImage->Height, texImage->Depth,
+                                     format, type, pixels)) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glGetTexImage(invalid PBO access)");
+         return GL_TRUE;
+      }
+   }
+
+   return GL_FALSE;
+}
+
+
+
+/**
+ * Get texture image.  Called by glGetTexImage.
+ *
+ * \param target texture target.
+ * \param level image level.
+ * \param format pixel data format for returned image.
+ * \param type pixel data type for returned image.
+ * \param pixels returned pixel data.
+ */
+void GLAPIENTRY
+_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
+                   GLenum type, GLvoid *pixels )
+{
+   const struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (getteximage_error_check(ctx, target, level, format, type, pixels)) {
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+
+   _mesa_lock_texture(ctx, texObj);
+   {
+      struct gl_texture_image *texImage =
+         _mesa_select_tex_image(ctx, texObj, target, level);
+
+      /* typically, this will call _mesa_get_teximage() */
+      ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,
+                              texObj, texImage);
+   }
+   _mesa_unlock_texture(ctx, texObj);
+}
+
+
+void GLAPIENTRY
+_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
+{
+   const struct gl_texture_unit *texUnit;
+   struct gl_texture_object *texObj;
+   struct gl_texture_image *texImage;
+   GLint maxLevels;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+   texObj = _mesa_select_tex_object(ctx, texUnit, target);
+   if (!texObj) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB");
+      return;
+   }
+
+   maxLevels = _mesa_max_texture_levels(ctx, target);
+   ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */
+
+   if (level < 0 || level >= maxLevels) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
+      return;
+   }
+
+   if (_mesa_is_proxy_texture(target)) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
+      return;
+   }
+
+   _mesa_lock_texture(ctx, texObj);
+   {
+      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
+      if (texImage) {
+         if (texImage->IsCompressed) {
+            /* this typically calls _mesa_get_compressed_teximage() */
+            ctx->Driver.GetCompressedTexImage(ctx, target, level, img,
+                                              texObj, texImage);
+         }
+         else {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                        "glGetCompressedTexImageARB");
+         }
+      }
+      else {
+         /* probably invalid mipmap level */
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glGetCompressedTexImageARB(level)");
+      }
+   }
+   _mesa_unlock_texture(ctx, texObj);
+}
diff --git a/src/mesa/main/texgetimage.h b/src/mesa/main/texgetimage.h
new file mode 100644
index 0000000000..088d27c7e1
--- /dev/null
+++ b/src/mesa/main/texgetimage.h
@@ -0,0 +1,55 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2009 VMware, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef TEXGETIMAGE_H
+#define TEXGETIMAGE_H
+
+
+extern void
+_mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level,
+                   GLenum format, GLenum type, GLvoid *pixels,
+                   struct gl_texture_object *texObj,
+                   struct gl_texture_image *texImage);
+
+
+extern void
+_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level,
+                              GLvoid *img,
+                              struct gl_texture_object *texObj,
+                              struct gl_texture_image *texImage);
+
+
+
+extern void GLAPIENTRY
+_mesa_GetTexImage( GLenum target, GLint level,
+                   GLenum format, GLenum type, GLvoid *pixels );
+
+
+extern void GLAPIENTRY
+_mesa_GetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img);
+
+
+#endif /* TEXGETIMAGE_H */
diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c
index 9e968ba743..a0304c02d4 100644
--- a/src/mesa/main/teximage.c
+++ b/src/mesa/main/teximage.c
@@ -1,8 +1,9 @@
 /*
  * mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -32,11 +33,10 @@
 #include "glheader.h"
 #include "bufferobj.h"
 #include "context.h"
-#if FEATURE_convolve
 #include "convolve.h"
-#endif
 #include "fbobject.h"
 #include "framebuffer.h"
+#include "hash.h"
 #include "image.h"
 #include "imports.h"
 #include "macros.h"
@@ -50,6 +50,17 @@
 
 
 /**
+ * State changes which we care about for glCopyTex[Sub]Image() calls.
+ * In particular, we care about pixel transfer state and buffer state
+ * (such as glReadBuffer to make sure we read from the right renderbuffer).
+ */
+#define NEW_COPY_TEX_STATE (_MESA_NEW_TRANSFER_STATE | \
+                            _NEW_BUFFERS | \
+                            _NEW_PIXEL)
+
+
+
+/**
  * We allocate texture memory on 512-byte boundaries so we can use MMX/SSE
  * elsewhere.
  */
@@ -169,6 +180,8 @@ logbase2( int n )
  *
  * This is the format which is used during texture application (i.e. the
  * texture format and env mode determine the arithmetic used.
+ *
+ * XXX this could be static
  */
 GLint
 _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat )
@@ -253,23 +266,21 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat )
       }
    }
 
-   if (ctx->Extensions.ARB_texture_compression) {
-      switch (internalFormat) {
-         case GL_COMPRESSED_ALPHA:
-            return GL_ALPHA;
-         case GL_COMPRESSED_LUMINANCE:
-            return GL_LUMINANCE;
-         case GL_COMPRESSED_LUMINANCE_ALPHA:
-            return GL_LUMINANCE_ALPHA;
-         case GL_COMPRESSED_INTENSITY:
-            return GL_INTENSITY;
-         case GL_COMPRESSED_RGB:
-            return GL_RGB;
-         case GL_COMPRESSED_RGBA:
-            return GL_RGBA;
-         default:
-            ; /* fallthrough */
-      }
+   switch (internalFormat) {
+   case GL_COMPRESSED_ALPHA:
+      return GL_ALPHA;
+   case GL_COMPRESSED_LUMINANCE:
+      return GL_LUMINANCE;
+   case GL_COMPRESSED_LUMINANCE_ALPHA:
+      return GL_LUMINANCE_ALPHA;
+   case GL_COMPRESSED_INTENSITY:
+      return GL_INTENSITY;
+   case GL_COMPRESSED_RGB:
+      return GL_RGB;
+   case GL_COMPRESSED_RGBA:
+      return GL_RGBA;
+   default:
+      ; /* fallthrough */
    }
          
    if (ctx->Extensions.TDFX_texture_compression_FXT1) {
@@ -339,6 +350,26 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat )
       }
    }
 
+   if (ctx->Extensions.ATI_envmap_bumpmap) {
+      switch (internalFormat) {
+         case GL_DUDV_ATI:
+         case GL_DU8DV8_ATI:
+            return GL_DUDV_ATI;
+         default:
+            ; /* fallthrough */
+      }
+   }
+
+   if (ctx->Extensions.MESA_texture_signed_rgba) {
+      switch (internalFormat) {
+         case GL_RGBA_SNORM:
+         case GL_RGBA8_SNORM:
+            return GL_RGBA;
+         default:
+            ; /* fallthrough */
+      }
+   }
+
    if (ctx->Extensions.EXT_packed_depth_stencil) {
       switch (internalFormat) {
          case GL_DEPTH_STENCIL_EXT:
@@ -384,193 +415,6 @@ _mesa_base_tex_format( GLcontext *ctx, GLint internalFormat )
 
 
 /**
- * Test if the given image format is a color/RGBA format (i.e., not color
- * index, depth, stencil, etc).
- * \param format  the image format value (may by an internal texture format)
- * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise.
- * XXX maybe move this func to image.c
- */
-GLboolean
-_mesa_is_color_format(GLenum format)
-{
-   switch (format) {
-      case GL_RED:
-      case GL_GREEN:
-      case GL_BLUE:
-      case GL_ALPHA:
-      case GL_ALPHA4:
-      case GL_ALPHA8:
-      case GL_ALPHA12:
-      case GL_ALPHA16:
-      case 1:
-      case GL_LUMINANCE:
-      case GL_LUMINANCE4:
-      case GL_LUMINANCE8:
-      case GL_LUMINANCE12:
-      case GL_LUMINANCE16:
-      case 2:
-      case GL_LUMINANCE_ALPHA:
-      case GL_LUMINANCE4_ALPHA4:
-      case GL_LUMINANCE6_ALPHA2:
-      case GL_LUMINANCE8_ALPHA8:
-      case GL_LUMINANCE12_ALPHA4:
-      case GL_LUMINANCE12_ALPHA12:
-      case GL_LUMINANCE16_ALPHA16:
-      case GL_INTENSITY:
-      case GL_INTENSITY4:
-      case GL_INTENSITY8:
-      case GL_INTENSITY12:
-      case GL_INTENSITY16:
-      case 3:
-      case GL_RGB:
-      case GL_BGR:
-      case GL_R3_G3_B2:
-      case GL_RGB4:
-      case GL_RGB5:
-      case GL_RGB8:
-      case GL_RGB10:
-      case GL_RGB12:
-      case GL_RGB16:
-      case 4:
-      case GL_ABGR_EXT:
-      case GL_RGBA:
-      case GL_BGRA:
-      case GL_RGBA2:
-      case GL_RGBA4:
-      case GL_RGB5_A1:
-      case GL_RGBA8:
-      case GL_RGB10_A2:
-      case GL_RGBA12:
-      case GL_RGBA16:
-      /* float texture formats */
-      case GL_ALPHA16F_ARB:
-      case GL_ALPHA32F_ARB:
-      case GL_LUMINANCE16F_ARB:
-      case GL_LUMINANCE32F_ARB:
-      case GL_LUMINANCE_ALPHA16F_ARB:
-      case GL_LUMINANCE_ALPHA32F_ARB:
-      case GL_INTENSITY16F_ARB:
-      case GL_INTENSITY32F_ARB:
-      case GL_RGB16F_ARB:
-      case GL_RGB32F_ARB:
-      case GL_RGBA16F_ARB:
-      case GL_RGBA32F_ARB:
-      /* compressed formats */
-      case GL_COMPRESSED_ALPHA:
-      case GL_COMPRESSED_LUMINANCE:
-      case GL_COMPRESSED_LUMINANCE_ALPHA:
-      case GL_COMPRESSED_INTENSITY:
-      case GL_COMPRESSED_RGB:
-      case GL_COMPRESSED_RGBA:
-      case GL_RGB_S3TC:
-      case GL_RGB4_S3TC:
-      case GL_RGBA_S3TC:
-      case GL_RGBA4_S3TC:
-      case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-      case GL_COMPRESSED_RGB_FXT1_3DFX:
-      case GL_COMPRESSED_RGBA_FXT1_3DFX:
-#if FEATURE_EXT_texture_sRGB
-      case GL_SRGB_EXT:
-      case GL_SRGB8_EXT:
-      case GL_SRGB_ALPHA_EXT:
-      case GL_SRGB8_ALPHA8_EXT:
-      case GL_SLUMINANCE_ALPHA_EXT:
-      case GL_SLUMINANCE8_ALPHA8_EXT:
-      case GL_SLUMINANCE_EXT:
-      case GL_SLUMINANCE8_EXT:
-      case GL_COMPRESSED_SRGB_EXT:
-      case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      case GL_COMPRESSED_SLUMINANCE_EXT:
-      case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-#endif /* FEATURE_EXT_texture_sRGB */
-         return GL_TRUE;
-      case GL_YCBCR_MESA:  /* not considered to be RGB */
-         /* fall-through */
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a color index format.
- */
-static GLboolean
-is_index_format(GLenum format)
-{
-   switch (format) {
-      case GL_COLOR_INDEX:
-      case GL_COLOR_INDEX1_EXT:
-      case GL_COLOR_INDEX2_EXT:
-      case GL_COLOR_INDEX4_EXT:
-      case GL_COLOR_INDEX8_EXT:
-      case GL_COLOR_INDEX12_EXT:
-      case GL_COLOR_INDEX16_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a depth component format.
- */
-static GLboolean
-is_depth_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH_COMPONENT16:
-      case GL_DEPTH_COMPONENT24:
-      case GL_DEPTH_COMPONENT32:
-      case GL_DEPTH_COMPONENT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a YCbCr format.
- */
-static GLboolean
-is_ycbcr_format(GLenum format)
-{
-   switch (format) {
-      case GL_YCBCR_MESA:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-/**
- * Test if the given image format is a Depth/Stencil format.
- */
-static GLboolean
-is_depthstencil_format(GLenum format)
-{
-   switch (format) {
-      case GL_DEPTH24_STENCIL8_EXT:
-      case GL_DEPTH_STENCIL_EXT:
-         return GL_TRUE;
-      default:
-         return GL_FALSE;
-   }
-}
-
-
-
-/**
  * Test if it is a supported compressed format.
  * 
  * \param internalFormat the internal format token provided by the user.
@@ -630,37 +474,14 @@ _mesa_set_tex_image(struct gl_texture_object *tObj,
                     GLenum target, GLint level,
                     struct gl_texture_image *texImage)
 {
+   const GLuint face = _mesa_tex_target_to_face(target);
+
    ASSERT(tObj);
    ASSERT(texImage);
-   /* XXX simplify this with _mesa_tex_target_to_face() */
-   switch (target) {
-      case GL_TEXTURE_1D:
-      case GL_TEXTURE_2D:
-      case GL_TEXTURE_3D:
-      case GL_TEXTURE_1D_ARRAY_EXT:
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         tObj->Image[0][level] = texImage;
-         break;
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
-         {
-            GLuint face = ((GLuint) target - 
-                           (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X);
-            tObj->Image[face][level] = texImage;
-         }
-         break;
-      case GL_TEXTURE_RECTANGLE_NV:
-         ASSERT(level == 0);
-         tObj->Image[0][level] = texImage;
-         break;
-      default:
-         _mesa_problem(NULL, "bad target in _mesa_set_tex_image()");
-         return;
-   }
+   ASSERT(target != GL_TEXTURE_RECTANGLE_NV || level == 0);
+
+   tObj->Image[face][level] = texImage;
+
    /* Set the 'back' pointer */
    texImage->TexObject = tObj;
 }
@@ -687,7 +508,7 @@ _mesa_new_texture_image( GLcontext *ctx )
  * Free texture image data.
  * This function is a fallback called via ctx->Driver.FreeTexImageData().
  *
- * \param teximage texture image.
+ * \param texImage texture image.
  *
  * Free the texture image data if it's not marked as client data.
  */
@@ -709,7 +530,7 @@ _mesa_free_texture_image_data(GLcontext *ctx,
 /**
  * Free texture image.
  *
- * \param teximage texture image.
+ * \param texImage texture image.
  *
  * Free the texture image structure and the associated image data.
  */
@@ -739,6 +560,9 @@ _mesa_delete_texture_image( GLcontext *ctx, struct gl_texture_image *texImage )
 GLboolean
 _mesa_is_proxy_texture(GLenum target)
 {
+   /* NUM_TEXTURE_TARGETS should match number of terms below */
+   assert(NUM_TEXTURE_TARGETS == 7);
+
    return (target == GL_PROXY_TEXTURE_1D ||
            target == GL_PROXY_TEXTURE_2D ||
            target == GL_PROXY_TEXTURE_3D ||
@@ -766,15 +590,15 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
 {
    switch (target) {
       case GL_TEXTURE_1D:
-         return texUnit->Current1D;
+         return texUnit->CurrentTex[TEXTURE_1D_INDEX];
       case GL_PROXY_TEXTURE_1D:
          return ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];
       case GL_TEXTURE_2D:
-         return texUnit->Current2D;
+         return texUnit->CurrentTex[TEXTURE_2D_INDEX];
       case GL_PROXY_TEXTURE_2D:
          return ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];
       case GL_TEXTURE_3D:
-         return texUnit->Current3D;
+         return texUnit->CurrentTex[TEXTURE_3D_INDEX];
       case GL_PROXY_TEXTURE_3D:
          return ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
@@ -785,25 +609,25 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
       case GL_TEXTURE_CUBE_MAP_ARB:
          return ctx->Extensions.ARB_texture_cube_map
-                ? texUnit->CurrentCubeMap : NULL;
+                ? texUnit->CurrentTex[TEXTURE_CUBE_INDEX] : NULL;
       case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
          return ctx->Extensions.ARB_texture_cube_map
                 ? ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX] : NULL;
       case GL_TEXTURE_RECTANGLE_NV:
          return ctx->Extensions.NV_texture_rectangle
-                ? texUnit->CurrentRect : NULL;
+                ? texUnit->CurrentTex[TEXTURE_RECT_INDEX] : NULL;
       case GL_PROXY_TEXTURE_RECTANGLE_NV:
          return ctx->Extensions.NV_texture_rectangle
                 ? ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX] : NULL;
       case GL_TEXTURE_1D_ARRAY_EXT:
          return ctx->Extensions.MESA_texture_array
-                ? texUnit->Current1DArray : NULL;
+                ? texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
       case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
          return ctx->Extensions.MESA_texture_array
                 ? ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX] : NULL;
       case GL_TEXTURE_2D_ARRAY_EXT:
          return ctx->Extensions.MESA_texture_array
-                ? texUnit->Current2DArray : NULL;
+                ? texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
       case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
          return ctx->Extensions.MESA_texture_array
                 ? ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX] : NULL;
@@ -815,74 +639,28 @@ _mesa_select_tex_object(GLcontext *ctx, const struct gl_texture_unit *texUnit,
 
 
 /**
- * Get the texture image struct which corresponds to target and level
- * of the given texture unit.
+ * Get a texture image pointer from a texture object, given a texture
+ * target and mipmap level.  The target and level parameters should
+ * have already been error-checked.
  *
  * \param ctx GL context.
- * \param texUnit texture unit.
+ * \param texObj texture unit.
  * \param target texture target.
  * \param level image level.
  *
- * \return pointer to the texture image structure on success, or NULL on failure.
- *
- * \sa gl_texture_unit.
+ * \return pointer to the texture image structure, or NULL on failure.
  */
 struct gl_texture_image *
 _mesa_select_tex_image(GLcontext *ctx, const struct gl_texture_object *texObj,
 		       GLenum target, GLint level)
 {
-   ASSERT(texObj);
-
-   if (level < 0 || level >= MAX_TEXTURE_LEVELS) 
-      return NULL;
-
-   /* XXX simplify this with _mesa_tex_target_to_face() */
-   switch (target) {
-      case GL_TEXTURE_1D:
-      case GL_PROXY_TEXTURE_1D:
-      case GL_TEXTURE_2D:
-      case GL_PROXY_TEXTURE_2D:
-      case GL_TEXTURE_3D:
-      case GL_PROXY_TEXTURE_3D:
-         return texObj->Image[0][level];
-
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB: 
-         if (ctx->Extensions.ARB_texture_cube_map) {
-	    GLuint face = ((GLuint) target - 
-			   (GLuint) GL_TEXTURE_CUBE_MAP_POSITIVE_X);
-            return texObj->Image[face][level];
-	 }
-         else
-            return NULL;
-
-      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-         if (ctx->Extensions.ARB_texture_cube_map)
-            return texObj->Image[0][level];
-         else
-            return NULL;
-
-      case GL_TEXTURE_RECTANGLE_NV:
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         if (ctx->Extensions.NV_texture_rectangle && level == 0) 
-            return texObj->Image[0][level];
-         else 
-            return NULL;
+   const GLuint face = _mesa_tex_target_to_face(target);
 
-      case GL_TEXTURE_1D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-      case GL_TEXTURE_2D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return (ctx->Extensions.MESA_texture_array)
-            ? texObj->Image[0][level] : NULL;
+   ASSERT(texObj);
+   ASSERT(level >= 0);
+   ASSERT(level < MAX_TEXTURE_LEVELS);
 
-      default:
-         return NULL;
-   }
+   return texObj->Image[face][level];
 }
 
 
@@ -925,6 +703,7 @@ struct gl_texture_image *
 _mesa_get_proxy_tex_image(GLcontext *ctx, GLenum target, GLint level)
 {
    struct gl_texture_image *texImage;
+   GLuint texIndex;
 
    if (level < 0 )
       return NULL;
@@ -933,111 +712,54 @@ _mesa_get_proxy_tex_image(GLcontext *ctx, GLenum target, GLint level)
    case GL_PROXY_TEXTURE_1D:
       if (level >= ctx->Const.MaxTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_1D_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_1D_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_1D_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_1D_INDEX;
+      break;
    case GL_PROXY_TEXTURE_2D:
       if (level >= ctx->Const.MaxTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_2D_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_2D_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_2D_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_2D_INDEX;
+      break;
    case GL_PROXY_TEXTURE_3D:
       if (level >= ctx->Const.Max3DTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_3D_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_3D_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_3D_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_3D_INDEX;
+      break;
    case GL_PROXY_TEXTURE_CUBE_MAP:
       if (level >= ctx->Const.MaxCubeTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_CUBE_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_CUBE_INDEX;
+      break;
    case GL_PROXY_TEXTURE_RECTANGLE_NV:
       if (level > 0)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_RECT_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_RECT_INDEX;
+      break;
    case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
       if (level >= ctx->Const.MaxTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_1D_ARRAY_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_1D_ARRAY_INDEX;
+      break;
    case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
       if (level >= ctx->Const.MaxTextureLevels)
          return NULL;
-      texImage = ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX]->Image[0][level];
-      if (!texImage) {
-         texImage = ctx->Driver.NewTextureImage(ctx);
-         if (!texImage) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
-            return NULL;
-         }
-         ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX]->Image[0][level] = texImage;
-         /* Set the 'back' pointer */
-         texImage->TexObject = ctx->Texture.ProxyTex[TEXTURE_2D_ARRAY_INDEX];
-      }
-      return texImage;
+      texIndex = TEXTURE_2D_ARRAY_INDEX;
+      break;
    default:
       return NULL;
    }
+
+   texImage = ctx->Texture.ProxyTex[texIndex]->Image[0][level];
+   if (!texImage) {
+      texImage = ctx->Driver.NewTextureImage(ctx);
+      if (!texImage) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "proxy texture allocation");
+         return NULL;
+      }
+      ctx->Texture.ProxyTex[texIndex]->Image[0][level] = texImage;
+      /* Set the 'back' pointer */
+      texImage->TexObject = ctx->Texture.ProxyTex[texIndex];
+   }
+   return texImage;
 }
 
 
@@ -1060,10 +782,6 @@ _mesa_max_texture_levels(GLcontext *ctx, GLenum target)
    case GL_PROXY_TEXTURE_1D:
    case GL_TEXTURE_2D:
    case GL_PROXY_TEXTURE_2D:
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
       return ctx->Const.MaxTextureLevels;
    case GL_TEXTURE_3D:
    case GL_PROXY_TEXTURE_3D:
@@ -1076,10 +794,17 @@ _mesa_max_texture_levels(GLcontext *ctx, GLenum target)
    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
    case GL_TEXTURE_CUBE_MAP_ARB:
    case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
-      return ctx->Const.MaxCubeTextureLevels;
+      return ctx->Extensions.ARB_texture_cube_map
+         ? ctx->Const.MaxCubeTextureLevels : 0;
    case GL_TEXTURE_RECTANGLE_NV:
    case GL_PROXY_TEXTURE_RECTANGLE_NV:
-      return 1;
+      return ctx->Extensions.NV_texture_rectangle ? 1 : 0;
+   case GL_TEXTURE_1D_ARRAY_EXT:
+   case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
+   case GL_TEXTURE_2D_ARRAY_EXT:
+   case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
+      return ctx->Extensions.MESA_texture_array
+         ? ctx->Const.MaxTextureLevels : 0;
    default:
       return 0; /* bad target */
    }
@@ -1217,19 +942,30 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
    img->Width = width;
    img->Height = height;
    img->Depth = depth;
+
    img->Width2 = width - 2 * border;   /* == 1 << img->WidthLog2; */
-   img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */
-   img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */
    img->WidthLog2 = logbase2(img->Width2);
-   if (height == 1)  /* 1-D texture */
+
+   if (height == 1) { /* 1-D texture */
+      img->Height2 = 1;
       img->HeightLog2 = 0;
-   else
+   }
+   else {
+      img->Height2 = height - 2 * border; /* == 1 << img->HeightLog2; */
       img->HeightLog2 = logbase2(img->Height2);
-   if (depth == 1)   /* 2-D texture */
+   }
+
+   if (depth == 1) {  /* 2-D texture */
+      img->Depth2 = 1;
       img->DepthLog2 = 0;
-   else
+   }
+   else {
+      img->Depth2 = depth - 2 * border;   /* == 1 << img->DepthLog2; */
       img->DepthLog2 = logbase2(img->Depth2);
+   }
+
    img->MaxLog2 = MAX2(img->WidthLog2, img->HeightLog2);
+
    img->IsCompressed = GL_FALSE;
    img->CompressedSize = 0;
 
@@ -1246,6 +982,8 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
     * We allocate the array for 1D/2D textures too in order to avoid special-
     * case code in the texstore routines.
     */
+   if (img->ImageOffsets)
+      _mesa_free(img->ImageOffsets);
    img->ImageOffsets = (GLuint *) _mesa_malloc(depth * sizeof(GLuint));
    for (i = 0; i < depth; i++) {
       img->ImageOffsets[i] = i * width * height;
@@ -1267,6 +1005,23 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
 
 
 /**
+ * Free and clear fields of the gl_texture_image struct.
+ *
+ * \param ctx GL context.
+ * \param texImage texture image structure to be cleared.
+ *
+ * After the call, \p texImage will have no data associated with it.  Its
+ * fields are cleared so that its parent object will test incomplete.
+ */
+void
+_mesa_clear_texture_image(GLcontext *ctx, struct gl_texture_image *texImage)
+{
+   ctx->Driver.FreeTexImageData(ctx, texImage);
+   clear_teximage_fields(texImage);
+}
+
+
+/**
  * This is the fallback for Driver.TestProxyTexImage().  Test the texture
  * level, width, height and depth against the ctx->Const limits for textures.
  *
@@ -1572,22 +1327,25 @@ texture_error_check( GLcontext *ctx, GLenum target,
        */
       if (!isProxy) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage%dD(format or type)", dimensions);
+                     "glTexImage%dD(incompatible format 0x%x, type 0x%x)",
+                     dimensions, format, type);
       }
       return GL_TRUE;
    }
 
    /* make sure internal format and format basically agree */
    colorFormat = _mesa_is_color_format(format);
-   indexFormat = is_index_format(format);
+   indexFormat = _mesa_is_index_format(format);
    if ((_mesa_is_color_format(internalFormat) && !colorFormat && !indexFormat) ||
-       (is_index_format(internalFormat) && !indexFormat) ||
-       (is_depth_format(internalFormat) != is_depth_format(format)) ||
-       (is_ycbcr_format(internalFormat) != is_ycbcr_format(format)) ||
-       (is_depthstencil_format(internalFormat) != is_depthstencil_format(format))) {
+       (_mesa_is_index_format(internalFormat) && !indexFormat) ||
+       (_mesa_is_depth_format(internalFormat) != _mesa_is_depth_format(format)) ||
+       (_mesa_is_ycbcr_format(internalFormat) != _mesa_is_ycbcr_format(format)) ||
+       (_mesa_is_depthstencil_format(internalFormat) != _mesa_is_depthstencil_format(format)) ||
+       (_mesa_is_dudv_format(internalFormat) != _mesa_is_dudv_format(format))) {
       if (!isProxy)
          _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glTexImage(internalFormat/format)");
+                     "glTexImage%dD(incompatible internalFormat 0x%x, format 0x%x)",
+                     dimensions, internalFormat, format);
       return GL_TRUE;
    }
 
@@ -1761,7 +1519,8 @@ subtexture_error_check( GLcontext *ctx, GLuint dimensions,
 
    if (!_mesa_is_legal_format_and_type(ctx, format, type)) {
       _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glTexSubImage%dD(format or type)", dimensions);
+                  "glTexSubImage%dD(incompatible format 0x%x, type 0x%x)",
+                  dimensions, format, type);
       return GL_TRUE;
    }
 
@@ -1868,7 +1627,6 @@ subtexture_error_check2( GLcontext *ctx, GLuint dimensions,
  * \param internalFormat internal format given by the user.
  * \param width image width given by the user.
  * \param height image height given by the user.
- * \param depth image depth given by the user.
  * \param border texture border.
  * 
  * \return GL_TRUE if an error was detected, or GL_FALSE if no errors.
@@ -1917,14 +1675,14 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions,
       return GL_TRUE;
    }
 
-   /* NOTE: the format and type aren't really significant for
-    * TestProxyTexImage().  Only the internalformat really matters.
    if (!_mesa_source_buffer_exists(ctx, format)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glCopyTexImage%dD(missing readbuffer)", dimensions);
       return GL_TRUE;
    }
 
+   /* NOTE: the format and type aren't really significant for
+    * TestProxyTexImage().  Only the internalformat really matters.
     */
    type = GL_FLOAT;
 
@@ -2018,7 +1776,7 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions,
          return GL_TRUE;
       }
    }
-   else if (is_depth_format(internalFormat)) {
+   else if (_mesa_is_depth_format(internalFormat)) {
       /* make sure we have depth/stencil buffers */
       if (!ctx->ReadBuffer->_DepthBuffer) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
@@ -2026,7 +1784,7 @@ copytexture_error_check( GLcontext *ctx, GLuint dimensions,
          return GL_TRUE;
       }
    }
-   else if (is_depthstencil_format(internalFormat)) {
+   else if (_mesa_is_depthstencil_format(internalFormat)) {
       /* make sure we have depth/stencil buffers */
       if (!ctx->ReadBuffer->_DepthBuffer || !ctx->ReadBuffer->_StencilBuffer) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
@@ -2224,7 +1982,8 @@ copytexsubimage_error_check2( GLcontext *ctx, GLuint dimensions,
 
    if (!_mesa_source_buffer_exists(ctx, teximage->_BaseFormat)) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
-               "glCopyTexSubImage%dD(missing readbuffer)", dimensions);
+                  "glCopyTexSubImage%dD(missing readbuffer, format=0x%x)",
+                  dimensions, teximage->_BaseFormat);
       return GL_TRUE;
    }
 
@@ -2250,153 +2009,33 @@ copytexsubimage_error_check2( GLcontext *ctx, GLuint dimensions,
 }
 
 
-/**
- * Get texture image.  Called by glGetTexImage.
- *
- * \param target texture target.
- * \param level image level.
- * \param format pixel data format for returned image.
- * \param type pixel data type for returned image.
- * \param pixels returned pixel data.
- */
-void GLAPIENTRY
-_mesa_GetTexImage( GLenum target, GLint level, GLenum format,
-                   GLenum type, GLvoid *pixels )
+/** Callback info for walking over FBO hash table */
+struct cb_info
 {
-   const struct gl_texture_unit *texUnit;
+   GLcontext *ctx;
    struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLint maxLevels = 0;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   texUnit = &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   if (!texObj || _mesa_is_proxy_texture(target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(target)");
-      return;
-   }
-
-   maxLevels = _mesa_max_texture_levels(ctx, target);
-   ASSERT(maxLevels > 0);  /* 0 indicates bad target, caught above */
-
-   if (level < 0 || level >= maxLevels) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexImage(level)" );
-      return;
-   }
-
-   if (_mesa_sizeof_packed_type(type) <= 0) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(type)" );
-      return;
-   }
-
-   if (_mesa_components_in_format(format) <= 0 ||
-       format == GL_STENCIL_INDEX) {
-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexImage(format)" );
-      return;
-   }
-
-   if (!ctx->Extensions.EXT_paletted_texture && is_index_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return;
-   }
-
-   if (!ctx->Extensions.ARB_depth_texture && is_depth_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return;
-   }
-
-   if (!ctx->Extensions.MESA_ycbcr_texture && is_ycbcr_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return;
-   }
-
-   if (!ctx->Extensions.EXT_packed_depth_stencil
-       && is_depthstencil_format(format)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexImage(format)");
-      return;
-   }
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-      if (!texImage) {
-	 /* invalid mipmap level, not an error */
-	 goto out;
-      }
-
-
-      /* Make sure the requested image format is compatible with the
-       * texture's format.  Note that a color index texture can be converted
-       * to RGBA so that combo is allowed.
-       */
-      if (_mesa_is_color_format(format)
-	  && !_mesa_is_color_format(texImage->TexFormat->BaseFormat)
-	  && !is_index_format(texImage->TexFormat->BaseFormat)) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-	 goto out;
-      }
-      else if (is_index_format(format)
-	       && !is_index_format(texImage->TexFormat->BaseFormat)) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-	 goto out;
-      }
-      else if (is_depth_format(format)
-	       && !is_depth_format(texImage->TexFormat->BaseFormat)
-	       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-	 goto out;
-      }
-      else if (is_ycbcr_format(format)
-	       && !is_ycbcr_format(texImage->TexFormat->BaseFormat)) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-	 goto out;
-      }
-      else if (is_depthstencil_format(format)
-	       && !is_depthstencil_format(texImage->TexFormat->BaseFormat)) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexImage(format mismatch)");
-	 goto out;
-      }
-
-      if (ctx->Pack.BufferObj->Name) {
-	 /* packing texture image into a PBO */
-	 const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
-	 if (!_mesa_validate_pbo_access(dimensions, &ctx->Pack, texImage->Width,
-					texImage->Height, texImage->Depth,
-					format, type, pixels)) {
-	    _mesa_error(ctx, GL_INVALID_OPERATION,
-			"glGetTexImage(invalid PBO access)");
-	    goto out;
-	 }
-      }
-
-      /* typically, this will call _mesa_get_teximage() */
-      ctx->Driver.GetTexImage(ctx, target, level, format, type, pixels,
-			      texObj, texImage);
-
-   }
- out:
-   _mesa_unlock_texture(ctx, texObj);
-}
-
+   GLuint level, face;
+};
 
 
 /**
- * Check if the given texture image is bound to any framebuffer objects
- * and update/invalidate them.
- * XXX We're only checking the currently bound framebuffer object for now.
- * In the future, perhaps struct gl_texture_image should have a pointer (or
- * list of pointers (yikes)) to the gl_framebuffer(s) which it's bound to.
+ * Check render to texture callback.  Called from _mesa_HashWalk().
  */
 static void
-update_fbo_texture(GLcontext *ctx, struct gl_texture_object *texObj,
-                   GLuint face, GLuint level)
+check_rtt_cb(GLuint key, void *data, void *userData)
 {
-   if (ctx->DrawBuffer->Name) {
+   struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
+   const struct cb_info *info = (struct cb_info *) userData;
+   GLcontext *ctx = info->ctx;
+   const struct gl_texture_object *texObj = info->texObj;
+   const GLuint level = info->level, face = info->face;
+
+   /* If this is a user-created FBO */
+   if (fb->Name) {
       GLuint i;
+      /* check if any of the FBO's attachments point to 'texObj' */
       for (i = 0; i < BUFFER_COUNT; i++) {
-         struct gl_renderbuffer_attachment *att = 
-            ctx->DrawBuffer->Attachment + i;
+         struct gl_renderbuffer_attachment *att = fb->Attachment + i;
          if (att->Type == GL_TEXTURE &&
              att->Texture == texObj &&
              att->TextureLevel == level &&
@@ -2404,12 +2043,79 @@ update_fbo_texture(GLcontext *ctx, struct gl_texture_object *texObj,
             ASSERT(att->Texture->Image[att->CubeMapFace][att->TextureLevel]);
             /* Tell driver about the new renderbuffer texture */
             ctx->Driver.RenderTexture(ctx, ctx->DrawBuffer, att);
+            /* Mark fb status as indeterminate to force re-validation */
+            fb->_Status = 0;
          }
       }
    }
 }
 
 
+/**
+ * When a texture image is specified we have to check if it's bound to
+ * any framebuffer objects (render to texture) in order to detect changes
+ * in size or format since that effects FBO completeness.
+ * Any FBOs rendering into the texture must be re-validated.
+ */
+static void
+update_fbo_texture(GLcontext *ctx, struct gl_texture_object *texObj,
+                   GLuint face, GLuint level)
+{
+   /* Only check this texture if it's been marked as RenderToTexture */
+   if (texObj->_RenderToTexture) {
+      struct cb_info info;
+      info.ctx = ctx;
+      info.texObj = texObj;
+      info.level = level;
+      info.face = face;
+      _mesa_HashWalk(ctx->Shared->FrameBuffers, check_rtt_cb, &info);
+   }
+}
+
+
+/** Debug helper: override the user-requested internal format */
+static GLenum
+override_internal_format(GLenum internalFormat, GLint width, GLint height)
+{
+#if 0
+   if (internalFormat == GL_RGBA16F_ARB ||
+       internalFormat == GL_RGBA32F_ARB) {
+      printf("Convert rgba float tex to int %d x %d\n", width, height);
+      return GL_RGBA;
+   }
+   else if (internalFormat == GL_RGB16F_ARB ||
+            internalFormat == GL_RGB32F_ARB) {
+      printf("Convert rgb float tex to int %d x %d\n", width, height);
+      return GL_RGB;
+   }
+   else if (internalFormat == GL_LUMINANCE_ALPHA16F_ARB ||
+            internalFormat == GL_LUMINANCE_ALPHA32F_ARB) {
+      printf("Convert luminance float tex to int %d x %d\n", width, height);
+      return GL_LUMINANCE_ALPHA;
+   }
+   else if (internalFormat == GL_LUMINANCE16F_ARB ||
+            internalFormat == GL_LUMINANCE32F_ARB) {
+      printf("Convert luminance float tex to int %d x %d\n", width, height);
+      return GL_LUMINANCE;
+   }
+   else if (internalFormat == GL_ALPHA16F_ARB ||
+            internalFormat == GL_ALPHA32F_ARB) {
+      printf("Convert luminance float tex to int %d x %d\n", width, height);
+      return GL_ALPHA;
+   }
+   /*
+   else if (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {
+      internalFormat = GL_RGBA;
+   }
+   */
+   else {
+      return internalFormat;
+   }
+#else
+   return internalFormat;
+#endif
+}
+
 
 /*
  * Called from the API.  Note that width includes the border.
@@ -2423,11 +2129,11 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-#if FEATURE_convolve
+   internalFormat = override_internal_format(internalFormat, width, 1);
+
    if (_mesa_is_color_format(internalFormat)) {
       _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
    }
-#endif
 
    if (target == GL_TEXTURE_1D) {
       /* non-proxy target */
@@ -2441,10 +2147,10 @@ _mesa_TexImage1D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
-      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
 	 _mesa_update_state(ctx);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
       _mesa_lock_texture(ctx, texObj);
       {
@@ -2520,12 +2226,12 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-#if FEATURE_convolve
+   internalFormat = override_internal_format(internalFormat, width, height);
+
    if (_mesa_is_color_format(internalFormat)) {
       _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
 					 &postConvHeight);
    }
-#endif
 
    if (target == GL_TEXTURE_2D ||
        (ctx->Extensions.ARB_texture_cube_map &&
@@ -2547,10 +2253,10 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
-      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
 	 _mesa_update_state(ctx);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
       _mesa_lock_texture(ctx, texObj);
       {
@@ -2603,7 +2309,7 @@ _mesa_TexImage2D( GLenum target, GLint level, GLint internalFormat,
                               1, border)) {
          /* when error, clear all proxy texture image parameters */
          if (texImage)
-            clear_teximage_fields(ctx->Texture.ProxyTex[TEXTURE_2D_INDEX]->Image[0][level]);
+            clear_teximage_fields(texImage);
       }
       else {
          /* no error, set the tex image parameters */
@@ -2634,6 +2340,8 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   internalFormat = override_internal_format(internalFormat, width, height);
+
    if (target == GL_TEXTURE_3D ||
        (ctx->Extensions.MESA_texture_array &&
         target == GL_TEXTURE_2D_ARRAY_EXT)) {
@@ -2648,10 +2356,10 @@ _mesa_TexImage3D( GLenum target, GLint level, GLint internalFormat,
          return;   /* error was recorded */
       }
 
-      if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+      if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
 	 _mesa_update_state(ctx);
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
       _mesa_lock_texture(ctx, texObj);
       {
@@ -2741,15 +2449,13 @@ _mesa_TexSubImage1D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
       _mesa_update_state(ctx);
 
-#if FEATURE_convolve
    /* XXX should test internal format */
    if (_mesa_is_color_format(format)) {
       _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
    }
-#endif
 
    if (subtexture_error_check(ctx, 1, target, level, xoffset, 0, 0,
 			       postConvWidth, 1, 1, format, type)) {
@@ -2757,7 +2463,7 @@ _mesa_TexSubImage1D( GLenum target, GLint level,
    }
 
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    assert(texObj);
 
@@ -2801,23 +2507,21 @@ _mesa_TexSubImage2D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
       _mesa_update_state(ctx);
 
-#if FEATURE_convolve
    /* XXX should test internal format */
    if (_mesa_is_color_format(format)) {
       _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
                                          &postConvHeight);
    }
-#endif
 
    if (subtexture_error_check(ctx, 2, target, level, xoffset, yoffset, 0,
 			      postConvWidth, postConvHeight, 1, format, type)) {
       return;   /* error was detected */
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    _mesa_lock_texture(ctx, texObj);
    {
@@ -2861,7 +2565,7 @@ _mesa_TexSubImage3D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & _MESA_NEW_TRANSFER_STATE)
       _mesa_update_state(ctx);
 
    if (subtexture_error_check(ctx, 3, target, level, xoffset, yoffset, zoffset,
@@ -2869,7 +2573,7 @@ _mesa_TexSubImage3D( GLenum target, GLint level,
       return;   /* error was detected */
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
    _mesa_lock_texture(ctx, texObj);
@@ -2917,20 +2621,18 @@ _mesa_CopyTexImage1D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & NEW_COPY_TEX_STATE)
       _mesa_update_state(ctx);
 
-#if FEATURE_convolve
    if (_mesa_is_color_format(internalFormat)) {
       _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
    }
-#endif
 
    if (copytexture_error_check(ctx, 1, target, level, internalFormat,
                                postConvWidth, 1, border))
       return;
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    _mesa_lock_texture(ctx, texObj);
    {
@@ -2982,21 +2684,19 @@ _mesa_CopyTexImage2D( GLenum target, GLint level, GLenum internalFormat,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & NEW_COPY_TEX_STATE)
       _mesa_update_state(ctx);
 
-#if FEATURE_convolve
    if (_mesa_is_color_format(internalFormat)) {
       _mesa_adjust_image_for_convolution(ctx, 2, &postConvWidth,
                                          &postConvHeight);
    }
-#endif
 
    if (copytexture_error_check(ctx, 2, target, level, internalFormat,
                                postConvWidth, postConvHeight, border))
       return;
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
    _mesa_lock_texture(ctx, texObj);
@@ -3050,24 +2750,22 @@ _mesa_CopyTexSubImage1D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & NEW_COPY_TEX_STATE)
       _mesa_update_state(ctx);
 
    if (copytexsubimage_error_check1(ctx, 1, target, level))
       return;
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-#if FEATURE_convolve
       if (texImage && _mesa_is_color_format(texImage->InternalFormat)) {
          _mesa_adjust_image_for_convolution(ctx, 1, &postConvWidth, NULL);
       }
-#endif
 
       if (copytexsubimage_error_check2(ctx, 1, target, level,
 				       xoffset, 0, 0, postConvWidth, 1,
@@ -3105,25 +2803,23 @@ _mesa_CopyTexSubImage2D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & NEW_COPY_TEX_STATE)
       _mesa_update_state(ctx);
 
    if (copytexsubimage_error_check1(ctx, 2, target, level))
       return;
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-#if FEATURE_convolve
       if (texImage && _mesa_is_color_format(texImage->InternalFormat)) {
          _mesa_adjust_image_for_convolution(ctx, 2,
                                             &postConvWidth, &postConvHeight);
       }
-#endif
 
       if (copytexsubimage_error_check2(ctx, 2, target, level, xoffset, yoffset, 0,
 				       postConvWidth, postConvHeight, texImage))
@@ -3160,25 +2856,23 @@ _mesa_CopyTexSubImage3D( GLenum target, GLint level,
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
-   if (ctx->NewState & _IMAGE_NEW_TRANSFER_STATE)
+   if (ctx->NewState & NEW_COPY_TEX_STATE)
       _mesa_update_state(ctx);
 
    if (copytexsubimage_error_check1(ctx, 3, target, level))
       return;
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
    _mesa_lock_texture(ctx, texObj);
    {
       texImage = _mesa_select_tex_image(ctx, texObj, target, level);
 
-#if FEATURE_convolve
       if (texImage && _mesa_is_color_format(texImage->InternalFormat)) {
          _mesa_adjust_image_for_convolution(ctx, 2,
                                             &postConvWidth, &postConvHeight);
       }
-#endif
 
       if (copytexsubimage_error_check2(ctx, 3, target, level, xoffset, yoffset,
 				       zoffset, postConvWidth, postConvHeight,
@@ -3420,7 +3114,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level,
          return;
       }
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
       _mesa_lock_texture(ctx, texObj);
@@ -3474,7 +3168,7 @@ _mesa_CompressedTexImage1DARB(GLenum target, GLint level,
          struct gl_texture_unit *texUnit;
          struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
-         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texUnit = _mesa_get_current_tex_unit(ctx);
 	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
 	 _mesa_lock_texture(ctx, texObj);
@@ -3517,7 +3211,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level,
          return;
       }
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
       _mesa_lock_texture(ctx, texObj);
@@ -3573,7 +3267,7 @@ _mesa_CompressedTexImage2DARB(GLenum target, GLint level,
          struct gl_texture_unit *texUnit;
          struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
-         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texUnit = _mesa_get_current_tex_unit(ctx);
 	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
 
 	 _mesa_lock_texture(ctx, texObj);
@@ -3613,7 +3307,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level,
          return;
       }
 
-      texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+      texUnit = _mesa_get_current_tex_unit(ctx);
       texObj = _mesa_select_tex_object(ctx, texUnit, target);
       _mesa_lock_texture(ctx, texObj);
       {
@@ -3667,7 +3361,7 @@ _mesa_CompressedTexImage3DARB(GLenum target, GLint level,
          struct gl_texture_unit *texUnit;
          struct gl_texture_object *texObj;
          struct gl_texture_image *texImage;
-         texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+         texUnit = _mesa_get_current_tex_unit(ctx);
 	 texObj = _mesa_select_tex_object(ctx, texUnit, target);
 	 _mesa_lock_texture(ctx, texObj);
 	 {
@@ -3706,7 +3400,7 @@ _mesa_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    _mesa_lock_texture(ctx, texObj);
    {
@@ -3763,7 +3457,7 @@ _mesa_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    _mesa_lock_texture(ctx, texObj);
    {
@@ -3820,7 +3514,7 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
    texObj = _mesa_select_tex_object(ctx, texUnit, target);
    _mesa_lock_texture(ctx, texObj);
    {
@@ -3857,55 +3551,3 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
 }
 
 
-void GLAPIENTRY
-_mesa_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid *img)
-{
-   const struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   GLint maxLevels;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   if (!texObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB");
-      return;
-   }
-
-   maxLevels = _mesa_max_texture_levels(ctx, target);
-   ASSERT(maxLevels > 0); /* 0 indicates bad target, caught above */
-
-   if (level < 0 || level >= maxLevels) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetCompressedTexImageARB(level)");
-      return;
-   }
-
-   if (_mesa_is_proxy_texture(target)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetCompressedTexImageARB(target)");
-      return;
-   }
-
-   _mesa_lock_texture(ctx, texObj);
-   {
-      texImage = _mesa_select_tex_image(ctx, texObj, target, level);
-      if (texImage) {
-         if (texImage->IsCompressed) {
-            /* this typically calls _mesa_get_compressed_teximage() */
-            ctx->Driver.GetCompressedTexImage(ctx, target, level, img,
-                                              texObj, texImage);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glGetCompressedTexImageARB");
-         }
-      }
-      else {
-         /* probably invalid mipmap level */
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glGetCompressedTexImageARB(level)");
-      }
-   }
-   _mesa_unlock_texture(ctx, texObj);
-}
diff --git a/src/mesa/main/teximage.h b/src/mesa/main/teximage.h
index eb60a1fa8f..094177da79 100644
--- a/src/mesa/main/teximage.h
+++ b/src/mesa/main/teximage.h
@@ -73,6 +73,10 @@ _mesa_init_teximage_fields(GLcontext *ctx, GLenum target,
 
 
 extern void
+_mesa_clear_texture_image(GLcontext *ctx, struct gl_texture_image *texImage);
+
+
+extern void
 _mesa_set_tex_image(struct gl_texture_object *tObj,
                     GLenum target, GLint level,
                     struct gl_texture_image *texImage);
@@ -111,10 +115,6 @@ extern GLuint
 _mesa_tex_target_to_face(GLenum target);
 
 
-extern GLboolean
-_mesa_is_color_format(GLenum format);
-
-
 /**
  * Lock a texture for updating.  See also _mesa_lock_context_textures().
  */
@@ -164,11 +164,6 @@ _mesa_TexImage3DEXT( GLenum target, GLint level, GLenum internalformat,
 
 
 extern void GLAPIENTRY
-_mesa_GetTexImage( GLenum target, GLint level,
-                   GLenum format, GLenum type, GLvoid *pixels );
-
-
-extern void GLAPIENTRY
 _mesa_TexSubImage1D( GLenum target, GLint level, GLint xoffset,
                      GLsizei width,
                      GLenum format, GLenum type,
@@ -260,9 +255,6 @@ _mesa_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
                                  GLsizei height, GLsizei depth, GLenum format,
                                  GLsizei imageSize, const GLvoid *data);
 
-extern void GLAPIENTRY
-_mesa_GetCompressedTexImageARB(GLenum target, GLint lod, GLvoid *img);
-
 /*@}*/
 
 #endif
diff --git a/src/mesa/main/texobj.c b/src/mesa/main/texobj.c
index 7848f0be35..678845ece0 100644
--- a/src/mesa/main/texobj.c
+++ b/src/mesa/main/texobj.c
@@ -28,10 +28,8 @@
  */
 
 
-#include "glheader.h"
-#if FEATURE_colortable
+#include "mfeatures.h"
 #include "colortab.h"
-#endif
 #include "context.h"
 #include "enums.h"
 #include "fbobject.h"
@@ -42,6 +40,8 @@
 #include "texstate.h"
 #include "texobj.h"
 #include "mtypes.h"
+#include "shader/prog_instruction.h"
+
 
 
 /**********************************************************************/
@@ -132,12 +132,15 @@ _mesa_initialize_texture_object( struct gl_texture_object *obj,
    obj->BaseLevel = 0;
    obj->MaxLevel = 1000;
    obj->MaxAnisotropy = 1.0;
-   obj->CompareFlag = GL_FALSE;                      /* SGIX_shadow */
-   obj->CompareOperator = GL_TEXTURE_LEQUAL_R_SGIX;  /* SGIX_shadow */
    obj->CompareMode = GL_NONE;         /* ARB_shadow */
    obj->CompareFunc = GL_LEQUAL;       /* ARB_shadow */
+   obj->CompareFailValue = 0.0F;       /* ARB_shadow_ambient */
    obj->DepthMode = GL_LUMINANCE;      /* ARB_depth_texture */
-   obj->ShadowAmbient = 0.0F;          /* ARB/SGIX_shadow_ambient */
+   obj->Swizzle[0] = GL_RED;
+   obj->Swizzle[1] = GL_GREEN;
+   obj->Swizzle[2] = GL_BLUE;
+   obj->Swizzle[3] = GL_ALPHA;
+   obj->_Swizzle = SWIZZLE_NOOP;
 }
 
 
@@ -175,7 +178,7 @@ finish_texture_init(GLcontext *ctx, GLenum target,
  * Called via ctx->Driver.DeleteTexture() if not overriden by a driver.
  *
  * \param shared the shared GL state to which the object belongs.
- * \param texOjb the texture object to delete.
+ * \param texObj the texture object to delete.
  */
 void
 _mesa_delete_texture_object( GLcontext *ctx, struct gl_texture_object *texObj )
@@ -189,9 +192,7 @@ _mesa_delete_texture_object( GLcontext *ctx, struct gl_texture_object *texObj )
     */
    texObj->Target = 0x99;
 
-#if FEATURE_colortable
    _mesa_free_colortable_data(&texObj->Palette);
-#endif
 
    /* free the texture images */
    for (face = 0; face < 6; face++) {
@@ -241,17 +242,43 @@ _mesa_copy_texture_object( struct gl_texture_object *dest,
    dest->BaseLevel = src->BaseLevel;
    dest->MaxLevel = src->MaxLevel;
    dest->MaxAnisotropy = src->MaxAnisotropy;
-   dest->CompareFlag = src->CompareFlag;
-   dest->CompareOperator = src->CompareOperator;
-   dest->ShadowAmbient = src->ShadowAmbient;
    dest->CompareMode = src->CompareMode;
    dest->CompareFunc = src->CompareFunc;
+   dest->CompareFailValue = src->CompareFailValue;
    dest->DepthMode = src->DepthMode;
    dest->_MaxLevel = src->_MaxLevel;
    dest->_MaxLambda = src->_MaxLambda;
    dest->GenerateMipmap = src->GenerateMipmap;
    dest->Palette = src->Palette;
    dest->_Complete = src->_Complete;
+   COPY_4V(dest->Swizzle, src->Swizzle);
+   dest->_Swizzle = src->_Swizzle;
+}
+
+
+/**
+ * Clear all texture images of the given texture object.
+ *
+ * \param ctx GL context.
+ * \param t texture object.
+ *
+ * \sa _mesa_clear_texture_image().
+ */
+void
+_mesa_clear_texture_object(GLcontext *ctx, struct gl_texture_object *texObj)
+{
+   GLuint i, j;
+
+   if (texObj->Target == 0)
+      return;
+
+   for (i = 0; i < MAX_FACES; i++) {
+      for (j = 0; j < MAX_TEXTURE_LEVELS; j++) {
+         struct gl_texture_image *texImage = texObj->Image[i][j];
+         if (texImage)
+            _mesa_clear_texture_image(ctx, texImage);
+      }
+   }
 }
 
 
@@ -276,7 +303,8 @@ valid_texture_object(const struct gl_texture_object *tex)
       _mesa_problem(NULL, "invalid reference to a deleted texture object");
       return GL_FALSE;
    default:
-      _mesa_problem(NULL, "invalid texture object Target value");
+      _mesa_problem(NULL, "invalid texture object Target 0x%x, Id = %u",
+                    tex->Target, tex->Name);
       return GL_FALSE;
    }
 }
@@ -302,7 +330,7 @@ _mesa_reference_texobj(struct gl_texture_object **ptr,
       GLboolean deleteFlag = GL_FALSE;
       struct gl_texture_object *oldTex = *ptr;
 
-      assert(valid_texture_object(oldTex));
+      ASSERT(valid_texture_object(oldTex));
 
       _glthread_LOCK_MUTEX(oldTex->Mutex);
       ASSERT(oldTex->RefCount > 0);
@@ -325,7 +353,7 @@ _mesa_reference_texobj(struct gl_texture_object **ptr,
 
    if (tex) {
       /* reference new texture */
-      assert(valid_texture_object(tex));
+      ASSERT(valid_texture_object(tex));
       _glthread_LOCK_MUTEX(tex->Mutex);
       if (tex->RefCount == 0) {
          /* this texture's being deleted (look just above) */
@@ -388,8 +416,7 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
     */
    if ((baseLevel < 0) || (baseLevel > MAX_TEXTURE_LEVELS)) {
       char s[100];
-      _mesa_sprintf(s, "obj %p (%d) base level = %d is invalid",
-              (void *) t, t->Name, baseLevel);
+      _mesa_sprintf(s, "base level = %d is invalid", baseLevel);
       incomplete(t, s);
       t->_Complete = GL_FALSE;
       return;
@@ -398,8 +425,7 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
    /* Always need the base level image */
    if (!t->Image[0][baseLevel]) {
       char s[100];
-      _mesa_sprintf(s, "obj %p (%d) Image[baseLevel=%d] == NULL",
-              (void *) t, t->Name, baseLevel);
+      _mesa_sprintf(s, "Image[baseLevel=%d] == NULL", baseLevel);
       incomplete(t, s);
       t->_Complete = GL_FALSE;
       return;
@@ -659,6 +685,76 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
    }
 }
 
+
+/**
+ * Mark a texture object dirty.  It forces the object to be incomplete
+ * and optionally forces the context to re-validate its state.
+ *
+ * \param ctx GL context.
+ * \param texObj texture object.
+ * \param invalidate_state also invalidate context state.
+ */
+void
+_mesa_dirty_texobj(GLcontext *ctx, struct gl_texture_object *texObj,
+                   GLboolean invalidate_state)
+{
+   texObj->_Complete = GL_FALSE;
+   if (invalidate_state)
+      ctx->NewState |= _NEW_TEXTURE;
+}
+
+
+/**
+ * Return pointer to a default/fallback texture.
+ * The texture is a 2D 8x8 RGBA texture with all texels = (0,0,0,1).
+ * That's the value a sampler should get when sampling from an
+ * incomplete texture.
+ */
+struct gl_texture_object *
+_mesa_get_fallback_texture(GLcontext *ctx)
+{
+   if (!ctx->Shared->FallbackTex) {
+      /* create fallback texture now */
+      static GLubyte texels[8 * 8][4];
+      struct gl_texture_object *texObj;
+      struct gl_texture_image *texImage;
+      GLuint i;
+
+      for (i = 0; i < 8 * 8; i++) {
+         texels[i][0] =
+         texels[i][1] =
+         texels[i][2] = 0x0;
+         texels[i][3] = 0xff;
+      }
+
+      /* create texture object */
+      texObj = ctx->Driver.NewTextureObject(ctx, 0, GL_TEXTURE_2D);
+      assert(texObj->RefCount == 1);
+      texObj->MinFilter = GL_NEAREST;
+      texObj->MagFilter = GL_NEAREST;
+
+      /* create level[0] texture image */
+      texImage = _mesa_get_tex_image(ctx, texObj, GL_TEXTURE_2D, 0);
+
+      /* init the image fields */
+      _mesa_init_teximage_fields(ctx, GL_TEXTURE_2D, texImage,
+                                    8, 8, 1, 0, GL_RGBA); 
+
+      /* set image data */
+      ctx->Driver.TexImage2D(ctx, GL_TEXTURE_2D, 0, GL_RGBA,
+                             8, 8, 0,
+                             GL_RGBA, GL_UNSIGNED_BYTE, texels,
+                             &ctx->DefaultPacking, texObj, texImage);
+
+      _mesa_test_texobj_completeness(ctx, texObj);
+      assert(texObj->_Complete);
+
+      ctx->Shared->FallbackTex = texObj;
+   }
+   return ctx->Shared->FallbackTex;
+}
+
+
 /*@}*/
 
 
@@ -756,37 +852,17 @@ unbind_texobj_from_fbo(GLcontext *ctx, struct gl_texture_object *texObj)
 static void
 unbind_texobj_from_texunits(GLcontext *ctx, struct gl_texture_object *texObj)
 {
-   GLuint u;
+   GLuint u, tex;
 
    for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) {
       struct gl_texture_unit *unit = &ctx->Texture.Unit[u];
-      if (texObj == unit->Current1D) {
-         _mesa_reference_texobj(&unit->Current1D, ctx->Shared->Default1D);
-         ASSERT(unit->Current1D);
-      }
-      else if (texObj == unit->Current2D) {
-         _mesa_reference_texobj(&unit->Current2D, ctx->Shared->Default2D);
-         ASSERT(unit->Current2D);
-      }
-      else if (texObj == unit->Current3D) {
-         _mesa_reference_texobj(&unit->Current3D, ctx->Shared->Default3D);
-         ASSERT(unit->Current3D);
-      }
-      else if (texObj == unit->CurrentCubeMap) {
-         _mesa_reference_texobj(&unit->CurrentCubeMap, ctx->Shared->DefaultCubeMap);
-         ASSERT(unit->CurrentCubeMap);
-      }
-      else if (texObj == unit->CurrentRect) {
-         _mesa_reference_texobj(&unit->CurrentRect, ctx->Shared->DefaultRect);
-         ASSERT(unit->CurrentRect);
-      }
-      else if (texObj == unit->Current1DArray) {
-         _mesa_reference_texobj(&unit->Current1DArray, ctx->Shared->Default1DArray);
-         ASSERT(unit->Current1DArray);
-      }
-      else if (texObj == unit->Current2DArray) {
-         _mesa_reference_texobj(&unit->Current2DArray, ctx->Shared->Default2DArray);
-         ASSERT(unit->Current2DArray);
+      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+         if (texObj == unit->CurrentTex[tex]) {
+            _mesa_reference_texobj(&unit->CurrentTex[tex],
+                                   ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]);
+            ASSERT(unit->CurrentTex[tex]);
+            break;
+         }
       }
    }
 }
@@ -857,6 +933,35 @@ _mesa_DeleteTextures( GLsizei n, const GLuint *textures)
 
 
 /**
+ * Convert a GL texture target enum such as GL_TEXTURE_2D or GL_TEXTURE_3D
+ * into the corresponding Mesa texture target index.
+ * Return -1 if target is invalid.
+ */
+static GLint
+target_enum_to_index(GLenum target)
+{
+   switch (target) {
+   case GL_TEXTURE_1D:
+      return TEXTURE_1D_INDEX;
+   case GL_TEXTURE_2D:
+      return TEXTURE_2D_INDEX;
+   case GL_TEXTURE_3D:
+      return TEXTURE_3D_INDEX;
+   case GL_TEXTURE_CUBE_MAP_ARB:
+      return TEXTURE_CUBE_INDEX;
+   case GL_TEXTURE_RECTANGLE_NV:
+      return TEXTURE_RECT_INDEX;
+   case GL_TEXTURE_1D_ARRAY_EXT:
+      return TEXTURE_1D_ARRAY_INDEX;
+   case GL_TEXTURE_2D_ARRAY_EXT:
+      return TEXTURE_2D_ARRAY_INDEX;
+   default:
+      return -1;
+   }
+}
+
+
+/**
  * Bind a named texture to a texturing target.
  * 
  * \param target texture target.
@@ -878,38 +983,21 @@ _mesa_BindTexture( GLenum target, GLuint texName )
    const GLuint unit = ctx->Texture.CurrentUnit;
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
    struct gl_texture_object *newTexObj = NULL, *defaultTexObj = NULL;
+   GLint targetIndex;
+   GLboolean early_out = GL_FALSE;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
       _mesa_debug(ctx, "glBindTexture %s %d\n",
                   _mesa_lookup_enum_by_nr(target), (GLint) texName);
 
-   switch (target) {
-   case GL_TEXTURE_1D:
-      defaultTexObj = ctx->Shared->Default1D;
-      break;
-   case GL_TEXTURE_2D:
-      defaultTexObj = ctx->Shared->Default2D;
-      break;
-   case GL_TEXTURE_3D:
-      defaultTexObj = ctx->Shared->Default3D;
-      break;
-   case GL_TEXTURE_CUBE_MAP_ARB:
-      defaultTexObj = ctx->Shared->DefaultCubeMap;
-      break;
-   case GL_TEXTURE_RECTANGLE_NV:
-      defaultTexObj = ctx->Shared->DefaultRect;
-      break;
-   case GL_TEXTURE_1D_ARRAY_EXT:
-      defaultTexObj = ctx->Shared->Default1DArray;
-      break;
-   case GL_TEXTURE_2D_ARRAY_EXT:
-      defaultTexObj = ctx->Shared->Default2DArray;
-      break;
-   default:
+   targetIndex = target_enum_to_index(target);
+   if (targetIndex < 0) {
       _mesa_error(ctx, GL_INVALID_ENUM, "glBindTexture(target)");
       return;
    }
+   assert(targetIndex < NUM_TEXTURE_TARGETS);
+   defaultTexObj = ctx->Shared->DefaultTex[targetIndex];
 
    /*
     * Get pointer to new texture object (newTexObj)
@@ -950,6 +1038,17 @@ _mesa_BindTexture( GLenum target, GLuint texName )
 
    assert(valid_texture_object(newTexObj));
 
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+   if ((ctx->Shared->RefCount == 1)
+       && (newTexObj == texUnit->CurrentTex[targetIndex])) {
+      early_out = GL_TRUE;
+   }
+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+   if (early_out) {
+      return;
+   }
+
    /* flush before changing binding */
    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
 
@@ -957,40 +1056,8 @@ _mesa_BindTexture( GLenum target, GLuint texName )
     * texture object will be decremented.  It'll be deleted if the
     * count hits zero.
     */
-   switch (target) {
-      case GL_TEXTURE_1D:
-         _mesa_reference_texobj(&texUnit->Current1D, newTexObj);
-         ASSERT(texUnit->Current1D);
-         break;
-      case GL_TEXTURE_2D:
-         _mesa_reference_texobj(&texUnit->Current2D, newTexObj);
-         ASSERT(texUnit->Current2D);
-         break;
-      case GL_TEXTURE_3D:
-         _mesa_reference_texobj(&texUnit->Current3D, newTexObj);
-         ASSERT(texUnit->Current3D);
-         break;
-      case GL_TEXTURE_CUBE_MAP_ARB:
-         _mesa_reference_texobj(&texUnit->CurrentCubeMap, newTexObj);
-         ASSERT(texUnit->CurrentCubeMap);
-         break;
-      case GL_TEXTURE_RECTANGLE_NV:
-         _mesa_reference_texobj(&texUnit->CurrentRect, newTexObj);
-         ASSERT(texUnit->CurrentRect);
-         break;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         texUnit->Current1DArray = newTexObj;
-         ASSERT(texUnit->Current1DArray);
-         break;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         texUnit->Current2DArray = newTexObj;
-         ASSERT(texUnit->Current2DArray);
-         break;
-      default:
-         /* Bad target should be caught above */
-         _mesa_problem(ctx, "bad target in BindTexture");
-         return;
-   }
+   _mesa_reference_texobj(&texUnit->CurrentTex[targetIndex], newTexObj);
+   ASSERT(texUnit->CurrentTex[targetIndex]);
 
    /* Pass BindTexture call to device driver */
    if (ctx->Driver.BindTexture)
@@ -1132,10 +1199,9 @@ _mesa_IsTexture( GLuint texture )
 
 
 /**
- * Simplest implementation of texture locking: Grab the a new mutex in
- * the shared context.  Examine the shared context state timestamp and
- * if there has been a change, set the appropriate bits in
- * ctx->NewState.
+ * Simplest implementation of texture locking: grab the shared tex
+ * mutex.  Examine the shared context state timestamp and if there has
+ * been a change, set the appropriate bits in ctx->NewState.
  *
  * This is used to deal with synchronizing things when a texture object
  * is used/modified by different contexts (or threads) which are sharing
diff --git a/src/mesa/main/texobj.h b/src/mesa/main/texobj.h
index d5374c5d6c..9bfebd45c8 100644
--- a/src/mesa/main/texobj.h
+++ b/src/mesa/main/texobj.h
@@ -58,6 +58,9 @@ _mesa_copy_texture_object( struct gl_texture_object *dest,
                            const struct gl_texture_object *src );
 
 extern void
+_mesa_clear_texture_object(GLcontext *ctx, struct gl_texture_object *obj);
+
+extern void
 _mesa_reference_texobj(struct gl_texture_object **ptr,
                        struct gl_texture_object *tex);
 
@@ -66,6 +69,13 @@ _mesa_test_texobj_completeness( const GLcontext *ctx,
                                 struct gl_texture_object *obj );
 
 extern void
+_mesa_dirty_texobj(GLcontext *ctx, struct gl_texture_object *texObj,
+                   GLboolean invalidate_state);
+
+extern struct gl_texture_object *
+_mesa_get_fallback_texture(GLcontext *ctx);
+
+extern void
 _mesa_unlock_context_textures( GLcontext *ctx );
 
 extern void
@@ -73,7 +83,6 @@ _mesa_lock_context_textures( GLcontext *ctx );
 
 /*@}*/
 
-
 /**
  * \name API functions
  */
diff --git a/src/mesa/main/texparam.c b/src/mesa/main/texparam.c
index a9e752a637..6cbb9999b1 100644
--- a/src/mesa/main/texparam.c
+++ b/src/mesa/main/texparam.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -37,6 +38,8 @@
 #include "main/texcompress.h"
 #include "main/texparam.h"
 #include "main/teximage.h"
+#include "main/texstate.h"
+#include "shader/prog_instruction.h"
 
 
 /**
@@ -67,409 +70,640 @@ validate_texture_wrap_mode(GLcontext * ctx, GLenum target, GLenum wrap)
       return GL_TRUE;
    }
 
-   _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+   _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)", wrap );
    return GL_FALSE;
 }
 
 
-void GLAPIENTRY
-_mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
+/**
+ * Get current texture object for given target.
+ * Return NULL if any error.
+ */
+static struct gl_texture_object *
+get_texobj(GLcontext *ctx, GLenum target)
 {
-   _mesa_TexParameterfv(target, pname, &param);
+   struct gl_texture_unit *texUnit;
+
+   if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexParameter(current unit)");
+      return NULL;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   switch (target) {
+   case GL_TEXTURE_1D:
+      return texUnit->CurrentTex[TEXTURE_1D_INDEX];
+   case GL_TEXTURE_2D:
+      return texUnit->CurrentTex[TEXTURE_2D_INDEX];
+   case GL_TEXTURE_3D:
+      return texUnit->CurrentTex[TEXTURE_3D_INDEX];
+   case GL_TEXTURE_CUBE_MAP:
+      if (ctx->Extensions.ARB_texture_cube_map) {
+         return texUnit->CurrentTex[TEXTURE_CUBE_INDEX];
+      }
+      break;
+   case GL_TEXTURE_RECTANGLE_NV:
+      if (ctx->Extensions.NV_texture_rectangle) {
+         return texUnit->CurrentTex[TEXTURE_RECT_INDEX];
+      }
+      break;
+   case GL_TEXTURE_1D_ARRAY_EXT:
+      if (ctx->Extensions.MESA_texture_array) {
+         return texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX];
+      }
+      break;
+   case GL_TEXTURE_2D_ARRAY_EXT:
+      if (ctx->Extensions.MESA_texture_array) {
+         return texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX];
+      }
+      break;
+   default:
+      ;
+   }
+
+   _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(target)");
+   return NULL;
 }
 
 
-void GLAPIENTRY
-_mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
+/**
+ * Convert GL_RED/GREEN/BLUE/ALPHA/ZERO/ONE to SWIZZLE_X/Y/Z/W/ZERO/ONE.
+ * \return -1 if error.
+ */
+static GLint
+comp_to_swizzle(GLenum comp)
 {
-   const GLenum eparam = (GLenum) (GLint) params[0];
-   struct gl_texture_unit *texUnit;
-   struct gl_texture_object *texObj;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   switch (comp) {
+   case GL_RED:
+      return SWIZZLE_X;
+   case GL_GREEN:
+      return SWIZZLE_Y;
+   case GL_BLUE:
+      return SWIZZLE_Z;
+   case GL_ALPHA:
+      return SWIZZLE_W;
+   case GL_ZERO:
+      return SWIZZLE_ZERO;
+   case GL_ONE:
+      return SWIZZLE_ONE;
+   default:
+      return -1;
+   }
+}
 
-   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
-      _mesa_debug(ctx, "glTexParameter %s %s %.1f(%s)...\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  _mesa_lookup_enum_by_nr(pname),
-                  *params,
-		  _mesa_lookup_enum_by_nr(eparam));
 
-   if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexParameterfv(current unit)");
-      return;
+static void
+set_swizzle_component(GLuint *swizzle, GLuint comp, GLuint swz)
+{
+   ASSERT(comp < 4);
+   ASSERT(swz <= SWIZZLE_NIL);
+   {
+      GLuint mask = 0x7 << (3 * comp);
+      GLuint s = (*swizzle & ~mask) | (swz << (3 * comp));
+      *swizzle = s;
    }
+}
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
 
-   switch (target) {
-      case GL_TEXTURE_1D:
-         texObj = texUnit->Current1D;
-         break;
-      case GL_TEXTURE_2D:
-         texObj = texUnit->Current2D;
-         break;
-      case GL_TEXTURE_3D:
-         texObj = texUnit->Current3D;
-         break;
-      case GL_TEXTURE_CUBE_MAP:
-         if (!ctx->Extensions.ARB_texture_cube_map) {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
-            return;
-         }
-         texObj = texUnit->CurrentCubeMap;
-         break;
-      case GL_TEXTURE_RECTANGLE_NV:
-         if (!ctx->Extensions.NV_texture_rectangle) {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
-            return;
-         }
-         texObj = texUnit->CurrentRect;
-         break;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-         if (!ctx->Extensions.MESA_texture_array) {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
-            return;
-         }
-         texObj = texUnit->Current1DArray;
-         break;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-         if (!ctx->Extensions.MESA_texture_array) {
-            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
-            return;
-         }
-         texObj = texUnit->Current2DArray;
-         break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
-         return;
-   }
+/**
+ * This is called just prior to changing any texture object state.
+ * Any pending rendering will be flushed out, we'll set the _NEW_TEXTURE
+ * state flag and then mark the texture object as 'incomplete' so that any
+ * per-texture derived state gets recomputed.
+ */
+static INLINE void
+flush(GLcontext *ctx, struct gl_texture_object *texObj)
+{
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+   texObj->_Complete = GL_FALSE;
+}
 
+
+/**
+ * Set an integer-valued texture parameter
+ * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
+ */
+static GLboolean
+set_tex_parameteri(GLcontext *ctx,
+                   struct gl_texture_object *texObj,
+                   GLenum pname, const GLint *params)
+{
    switch (pname) {
-      case GL_TEXTURE_MIN_FILTER:
-         /* A small optimization */
-         if (texObj->MinFilter == eparam)
-            return;
-         if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->MinFilter = eparam;
-         }
-         else if ((eparam==GL_NEAREST_MIPMAP_NEAREST ||
-                   eparam==GL_LINEAR_MIPMAP_NEAREST ||
-                   eparam==GL_NEAREST_MIPMAP_LINEAR ||
-                   eparam==GL_LINEAR_MIPMAP_LINEAR) &&
-                  texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->MinFilter = eparam;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
-            return;
-         }
-         break;
-      case GL_TEXTURE_MAG_FILTER:
-         /* A small optimization */
-         if (texObj->MagFilter == eparam)
-            return;
+   case GL_TEXTURE_MIN_FILTER:
+      if (texObj->MinFilter == params[0])
+         return GL_FALSE;
+      switch (params[0]) {
+      case GL_NEAREST:
+      case GL_LINEAR:
+         flush(ctx, texObj);
+         texObj->MinFilter = params[0];
+         return GL_TRUE;
+      case GL_NEAREST_MIPMAP_NEAREST:
+      case GL_LINEAR_MIPMAP_NEAREST:
+      case GL_NEAREST_MIPMAP_LINEAR:
+      case GL_LINEAR_MIPMAP_LINEAR:
+         if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
+            flush(ctx, texObj);
+            texObj->MinFilter = params[0];
+            return GL_TRUE;
+         }
+         /* fall-through */
+      default:
+         _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)",
+                      params[0] );
+      }
+      return GL_FALSE;
 
-         if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->MagFilter = eparam;
-         }
-         else {
-            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
-            return;
-         }
-         break;
-      case GL_TEXTURE_WRAP_S:
-         if (texObj->WrapS == eparam)
-            return;
-         if (validate_texture_wrap_mode(ctx, texObj->Target, eparam)) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->WrapS = eparam;
-         }
-         else {
-            return;
-         }
-         break;
-      case GL_TEXTURE_WRAP_T:
-         if (texObj->WrapT == eparam)
-            return;
-         if (validate_texture_wrap_mode(ctx, texObj->Target, eparam)) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->WrapT = eparam;
-         }
-         else {
-            return;
-         }
-         break;
-      case GL_TEXTURE_WRAP_R:
-         if (texObj->WrapR == eparam)
-            return;
-         if (validate_texture_wrap_mode(ctx, texObj->Target, eparam)) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->WrapR = eparam;
-         }
-         else {
-	    return;
-         }
-         break;
-      case GL_TEXTURE_BORDER_COLOR:
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->BorderColor[RCOMP] = params[0];
-         texObj->BorderColor[GCOMP] = params[1];
-         texObj->BorderColor[BCOMP] = params[2];
-         texObj->BorderColor[ACOMP] = params[3];
-         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[RCOMP], params[0]);
-         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[GCOMP], params[1]);
-         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[BCOMP], params[2]);
-         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[ACOMP], params[3]);
-         break;
-      case GL_TEXTURE_MIN_LOD:
-         if (texObj->MinLod == params[0])
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->MinLod = params[0];
-         break;
-      case GL_TEXTURE_MAX_LOD:
-         if (texObj->MaxLod == params[0])
-            return;
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->MaxLod = params[0];
-         break;
-      case GL_TEXTURE_BASE_LEVEL:
-         if (params[0] < 0.0) {
-            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)");
-            return;
-         }
-         if (target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0.0) {
-            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)");
-            return;
-         }
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->BaseLevel = (GLint) params[0];
-         break;
-      case GL_TEXTURE_MAX_LEVEL:
-         if (params[0] < 0.0) {
-            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)");
-            return;
-         }
-         if (target == GL_TEXTURE_RECTANGLE_ARB) {
-            _mesa_error(ctx, GL_INVALID_OPERATION, "glTexParameter(param)");
-            return;
-         }
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->MaxLevel = (GLint) params[0];
-         break;
-      case GL_TEXTURE_PRIORITY:
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-         texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
-         break;
-      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
-         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
-	    if (params[0] < 1.0) {
-	       _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
-	       return;
-	    }
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            /* clamp to max, that's what NVIDIA does */
-            texObj->MaxAnisotropy = MIN2(params[0],
-                                         ctx->Const.MaxTextureMaxAnisotropy);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
-            return;
-         }
-         break;
-      case GL_TEXTURE_COMPARE_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_TEXTURE_COMPARE_SGIX)");
-            return;
-         }
-         break;
-      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            GLenum op = (GLenum) params[0];
-            if (op == GL_TEXTURE_LEQUAL_R_SGIX ||
-                op == GL_TEXTURE_GEQUAL_R_SGIX) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->CompareOperator = op;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
-            }
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                    "glTexParameter(pname=GL_TEXTURE_COMPARE_OPERATOR_SGIX)");
-            return;
-         }
-         break;
-      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-         if (ctx->Extensions.SGIX_shadow_ambient) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-            texObj->ShadowAmbient = CLAMP(params[0], 0.0F, 1.0F);
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_SHADOW_AMBIENT_SGIX)");
-            return;
-         }
-         break;
-      case GL_GENERATE_MIPMAP_SGIS:
-         if (ctx->Extensions.SGIS_generate_mipmap) {
-            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+   case GL_TEXTURE_MAG_FILTER:
+      if (texObj->MagFilter == params[0])
+         return GL_FALSE;
+      switch (params[0]) {
+      case GL_NEAREST:
+      case GL_LINEAR:
+         flush(ctx, texObj);
+         texObj->MagFilter = params[0];
+         return GL_TRUE;
+      default:
+         _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param=0x%x)",
+                      params[0]);
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_WRAP_S:
+      if (texObj->WrapS == params[0])
+         return GL_FALSE;
+      if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
+         flush(ctx, texObj);
+         texObj->WrapS = params[0];
+         return GL_TRUE;
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_WRAP_T:
+      if (texObj->WrapT == params[0])
+         return GL_FALSE;
+      if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
+         flush(ctx, texObj);
+         texObj->WrapT = params[0];
+         return GL_TRUE;
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_WRAP_R:
+      if (texObj->WrapR == params[0])
+         return GL_FALSE;
+      if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
+         flush(ctx, texObj);
+         texObj->WrapR = params[0];
+         return GL_TRUE;
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_BASE_LEVEL:
+      if (texObj->BaseLevel == params[0])
+         return GL_FALSE;
+      if (params[0] < 0 ||
+          (texObj->Target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0)) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glTexParameter(param=%d)", params[0]);
+         return GL_FALSE;
+      }
+      flush(ctx, texObj);
+      texObj->BaseLevel = params[0];
+      return GL_TRUE;
+
+   case GL_TEXTURE_MAX_LEVEL:
+      if (texObj->MaxLevel == params[0])
+         return GL_FALSE;
+      if (params[0] < 0 || texObj->Target == GL_TEXTURE_RECTANGLE_ARB) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glTexParameter(param=%d)", params[0]);
+         return GL_FALSE;
+      }
+      flush(ctx, texObj);
+      texObj->MaxLevel = params[0];
+      return GL_TRUE;
+
+   case GL_GENERATE_MIPMAP_SGIS:
+      if (ctx->Extensions.SGIS_generate_mipmap) {
+         if (texObj->GenerateMipmap != params[0]) {
+            flush(ctx, texObj);
             texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
+            return GL_TRUE;
          }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
-            return;
-         }
-         break;
-      case GL_TEXTURE_COMPARE_MODE_ARB:
-         if (ctx->Extensions.ARB_shadow) {
-            const GLenum mode = (GLenum) params[0];
-            if (mode == GL_NONE || mode == GL_COMPARE_R_TO_TEXTURE_ARB) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->CompareMode = mode;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM,
-                           "glTexParameter(bad GL_TEXTURE_COMPARE_MODE_ARB: 0x%x)", mode);
-               return;
-            }
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_TEXTURE_COMPARE_MODE_ARB)");
-            return;
-         }
-         break;
-      case GL_TEXTURE_COMPARE_FUNC_ARB:
-         if (ctx->Extensions.ARB_shadow) {
-            const GLenum func = (GLenum) params[0];
-            if (func == GL_LEQUAL || func == GL_GEQUAL) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->CompareFunc = func;
-            }
-            else if (ctx->Extensions.EXT_shadow_funcs &&
-                     (func == GL_EQUAL ||
-                      func == GL_NOTEQUAL ||
-                      func == GL_LESS ||
-                      func == GL_GREATER ||
-                      func == GL_ALWAYS ||
-                      func == GL_NEVER)) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->CompareFunc = func;
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_ENUM,
-                           "glTexParameter(bad GL_TEXTURE_COMPARE_FUNC_ARB)");
-               return;
+         return GL_FALSE;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_COMPARE_MODE_ARB:
+      if (ctx->Extensions.ARB_shadow &&
+          (params[0] == GL_NONE ||
+           params[0] == GL_COMPARE_R_TO_TEXTURE_ARB)) {
+         if (texObj->CompareMode != params[0]) {
+            flush(ctx, texObj);
+            texObj->CompareMode = params[0];
+            return GL_TRUE;
+         }
+         return GL_FALSE;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glTexParameter(GL_TEXTURE_COMPARE_MODE_ARB)");
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_COMPARE_FUNC_ARB:
+      if (ctx->Extensions.ARB_shadow) {
+         if (texObj->CompareFunc == params[0])
+            return GL_FALSE;
+         switch (params[0]) {
+         case GL_LEQUAL:
+         case GL_GEQUAL:
+            flush(ctx, texObj);
+            texObj->CompareFunc = params[0];
+            return GL_TRUE;
+         case GL_EQUAL:
+         case GL_NOTEQUAL:
+         case GL_LESS:
+         case GL_GREATER:
+         case GL_ALWAYS:
+         case GL_NEVER:
+            if (ctx->Extensions.EXT_shadow_funcs) {
+               flush(ctx, texObj);
+               texObj->CompareFunc = params[0];
+               return GL_TRUE;
             }
-         }
-         else {
+            /* fall-through */
+         default:
             _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_TEXTURE_COMPARE_FUNC_ARB)");
-            return;
+                        "glTexParameter(GL_TEXTURE_COMPARE_FUNC_ARB)");
          }
-         break;
-      case GL_DEPTH_TEXTURE_MODE_ARB:
-         if (ctx->Extensions.ARB_depth_texture) {
-            const GLenum result = (GLenum) params[0];
-            if (result == GL_LUMINANCE || result == GL_INTENSITY
-                || result == GL_ALPHA) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->DepthMode = result;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
+      }
+      return GL_FALSE;
+
+   case GL_DEPTH_TEXTURE_MODE_ARB:
+      if (ctx->Extensions.ARB_depth_texture &&
+          (params[0] == GL_LUMINANCE ||
+           params[0] == GL_INTENSITY ||
+           params[0] == GL_ALPHA)) {
+         if (texObj->DepthMode != params[0]) {
+            flush(ctx, texObj);
+            texObj->DepthMode = params[0];
+            return GL_TRUE;
+         }
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM,
+                     "glTexParameter(GL_DEPTH_TEXTURE_MODE_ARB)");
+      }
+      return GL_FALSE;
+
+#ifdef FEATURE_OES_draw_texture
+   case GL_TEXTURE_CROP_RECT_OES:
+      texObj->CropRect[0] = params[0];
+      texObj->CropRect[1] = params[1];
+      texObj->CropRect[2] = params[2];
+      texObj->CropRect[3] = params[3];
+      return GL_TRUE;
+#endif
+
+   case GL_TEXTURE_SWIZZLE_R_EXT:
+   case GL_TEXTURE_SWIZZLE_G_EXT:
+   case GL_TEXTURE_SWIZZLE_B_EXT:
+   case GL_TEXTURE_SWIZZLE_A_EXT:
+      if (ctx->Extensions.EXT_texture_swizzle) {
+         const GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
+         const GLint swz = comp_to_swizzle(params[0]);
+         if (swz < 0) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                        "glTexParameter(swizzle 0x%x)", params[0]);
+            return GL_FALSE;
+         }
+         ASSERT(comp < 4);
+         if (swz >= 0) {
+            flush(ctx, texObj);
+            texObj->Swizzle[comp] = params[0];
+            set_swizzle_component(&texObj->_Swizzle, comp, swz);
+            return GL_TRUE;
+         }
+      }
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
+      return GL_FALSE;
+
+   case GL_TEXTURE_SWIZZLE_RGBA_EXT:
+      if (ctx->Extensions.EXT_texture_swizzle) {
+         GLuint comp;
+         flush(ctx, texObj);
+         for (comp = 0; comp < 4; comp++) {
+            const GLint swz = comp_to_swizzle(params[comp]);
+            if (swz >= 0) {
+               texObj->Swizzle[comp] = params[comp];
+               set_swizzle_component(&texObj->_Swizzle, comp, swz);
             }
             else {
-               _mesa_error(ctx, GL_INVALID_ENUM,
-                          "glTexParameter(bad GL_DEPTH_TEXTURE_MODE_ARB)");
-               return;
+               _mesa_error(ctx, GL_INVALID_OPERATION,
+                           "glTexParameter(swizzle 0x%x)", params[comp]);
+               return GL_FALSE;
             }
          }
-         else {
+         return GL_TRUE;
+      }
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
+      return GL_FALSE;
+
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
+   }
+   return GL_FALSE;
+}
+
+
+/**
+ * Set a float-valued texture parameter
+ * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
+ */
+static GLboolean
+set_tex_parameterf(GLcontext *ctx,
+                   struct gl_texture_object *texObj,
+                   GLenum pname, const GLfloat *params)
+{
+   switch (pname) {
+   case GL_TEXTURE_MIN_LOD:
+      if (texObj->MinLod == params[0])
+         return GL_FALSE;
+      flush(ctx, texObj);
+      texObj->MinLod = params[0];
+      return GL_TRUE;
+
+   case GL_TEXTURE_MAX_LOD:
+      if (texObj->MaxLod == params[0])
+         return GL_FALSE;
+      flush(ctx, texObj);
+      texObj->MaxLod = params[0];
+      return GL_TRUE;
+
+   case GL_TEXTURE_PRIORITY:
+      flush(ctx, texObj);
+      texObj->Priority = CLAMP(params[0], 0.0F, 1.0F);
+      return GL_TRUE;
+
+   case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+      if (ctx->Extensions.EXT_texture_filter_anisotropic) {
+         if (texObj->MaxAnisotropy == params[0])
+            return GL_FALSE;
+         if (params[0] < 1.0) {
+            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
+            return GL_FALSE;
+         }
+         flush(ctx, texObj);
+         /* clamp to max, that's what NVIDIA does */
+         texObj->MaxAnisotropy = MIN2(params[0],
+                                      ctx->Const.MaxTextureMaxAnisotropy);
+         return GL_TRUE;
+      }
+      else {
+         static GLuint count = 0;
+         if (count++ < 10)
             _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glTexParameter(pname=GL_DEPTH_TEXTURE_MODE_ARB)");
-            return;
-         }
-         break;
-      case GL_TEXTURE_LOD_BIAS:
-         /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias*/
-         if (ctx->Extensions.EXT_texture_lod_bias) {
-            if (texObj->LodBias != params[0]) {
-               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
-               texObj->LodBias = params[0];
-            }
-         }
-         break;
-#ifdef FEATURE_OES_draw_texture
-      case GL_TEXTURE_CROP_RECT_OES:
-         texObj->CropRect[0] = (GLint) params[0];
-         texObj->CropRect[1] = (GLint) params[1];
-         texObj->CropRect[2] = (GLint) params[2];
-         texObj->CropRect[3] = (GLint) params[3];
-         break;
-#endif
+                        "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
+      }
+      return GL_FALSE;
 
-      default:
+   case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+      if (ctx->Extensions.ARB_shadow_ambient) {
+         if (texObj->CompareFailValue != params[0]) {
+            flush(ctx, texObj);
+            texObj->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
+            return GL_TRUE;
+         }
+      }
+      else {
          _mesa_error(ctx, GL_INVALID_ENUM,
-                     "glTexParameter(pname=0x%x)", pname);
-         return;
+                    "glTexParameter(pname=GL_TEXTURE_COMPARE_FAIL_VALUE_ARB)");
+      }
+      return GL_FALSE;
+
+   case GL_TEXTURE_LOD_BIAS:
+      /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
+      if (ctx->Extensions.EXT_texture_lod_bias) {
+         if (texObj->LodBias != params[0]) {
+            flush(ctx, texObj);
+            texObj->LodBias = params[0];
+            return GL_TRUE;
+         }
+         return GL_FALSE;
+      }
+      break;
+
+   case GL_TEXTURE_BORDER_COLOR:
+      flush(ctx, texObj);
+      texObj->BorderColor[RCOMP] = params[0];
+      texObj->BorderColor[GCOMP] = params[1];
+      texObj->BorderColor[BCOMP] = params[2];
+      texObj->BorderColor[ACOMP] = params[3];
+      return GL_TRUE;
+
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
    }
+   return GL_FALSE;
+}
 
-   texObj->_Complete = GL_FALSE;
 
-   if (ctx->Driver.TexParameter) {
-      (*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
+void GLAPIENTRY
+_mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+   GLboolean need_update;
+   struct gl_texture_object *texObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   texObj = get_texobj(ctx, target);
+   if (!texObj)
+      return;
+
+   switch (pname) {
+   case GL_TEXTURE_MIN_FILTER:
+   case GL_TEXTURE_MAG_FILTER:
+   case GL_TEXTURE_WRAP_S:
+   case GL_TEXTURE_WRAP_T:
+   case GL_TEXTURE_WRAP_R:
+   case GL_TEXTURE_BASE_LEVEL:
+   case GL_TEXTURE_MAX_LEVEL:
+   case GL_GENERATE_MIPMAP_SGIS:
+   case GL_TEXTURE_COMPARE_MODE_ARB:
+   case GL_TEXTURE_COMPARE_FUNC_ARB:
+   case GL_DEPTH_TEXTURE_MODE_ARB:
+      {
+         /* convert float param to int */
+         GLint p = (GLint) param;
+         need_update = set_tex_parameteri(ctx, texObj, pname, &p);
+      }
+      break;
+   default:
+      /* this will generate an error if pname is illegal */
+      need_update = set_tex_parameterf(ctx, texObj, pname, &param);
+   }
+
+   if (ctx->Driver.TexParameter && need_update) {
+      ctx->Driver.TexParameter(ctx, target, texObj, pname, &param);
    }
 }
 
 
 void GLAPIENTRY
-_mesa_TexParameteri( GLenum target, GLenum pname, GLint param )
+_mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-   GLfloat fparam[4];
-   if (pname == GL_TEXTURE_PRIORITY)
-      fparam[0] = INT_TO_FLOAT(param);
-   else
-      fparam[0] = (GLfloat) param;
-   fparam[1] = fparam[2] = fparam[3] = 0.0;
-   _mesa_TexParameterfv(target, pname, fparam);
+   GLboolean need_update;
+   struct gl_texture_object *texObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   texObj = get_texobj(ctx, target);
+   if (!texObj)
+      return;
+
+   switch (pname) {
+   case GL_TEXTURE_MIN_FILTER:
+   case GL_TEXTURE_MAG_FILTER:
+   case GL_TEXTURE_WRAP_S:
+   case GL_TEXTURE_WRAP_T:
+   case GL_TEXTURE_WRAP_R:
+   case GL_TEXTURE_BASE_LEVEL:
+   case GL_TEXTURE_MAX_LEVEL:
+   case GL_GENERATE_MIPMAP_SGIS:
+   case GL_TEXTURE_COMPARE_MODE_ARB:
+   case GL_TEXTURE_COMPARE_FUNC_ARB:
+   case GL_DEPTH_TEXTURE_MODE_ARB:
+      {
+         /* convert float param to int */
+         GLint p = (GLint) params[0];
+         need_update = set_tex_parameteri(ctx, texObj, pname, &p);
+      }
+      break;
+
+#ifdef FEATURE_OES_draw_texture
+   case GL_TEXTURE_CROP_RECT_OES:
+      {
+         /* convert float params to int */
+         GLint iparams[4];
+         iparams[0] = (GLint) params[0];
+         iparams[1] = (GLint) params[1];
+         iparams[2] = (GLint) params[2];
+         iparams[3] = (GLint) params[3];
+         need_update = set_tex_parameteri(ctx, texObj, pname, iparams);
+      }
+      break;
+#endif
+
+   default:
+      /* this will generate an error if pname is illegal */
+      need_update = set_tex_parameterf(ctx, texObj, pname, params);
+   }
+
+   if (ctx->Driver.TexParameter && need_update) {
+      ctx->Driver.TexParameter(ctx, target, texObj, pname, params);
+   }
 }
 
 
 void GLAPIENTRY
-_mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
+_mesa_TexParameteri(GLenum target, GLenum pname, GLint param)
 {
-   GLfloat fparam[4];
-   if (pname == GL_TEXTURE_BORDER_COLOR) {
-      fparam[0] = INT_TO_FLOAT(params[0]);
-      fparam[1] = INT_TO_FLOAT(params[1]);
-      fparam[2] = INT_TO_FLOAT(params[2]);
-      fparam[3] = INT_TO_FLOAT(params[3]);
+   GLboolean need_update;
+   struct gl_texture_object *texObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   texObj = get_texobj(ctx, target);
+   if (!texObj)
+      return;
+
+   switch (pname) {
+   case GL_TEXTURE_MIN_LOD:
+   case GL_TEXTURE_MAX_LOD:
+   case GL_TEXTURE_PRIORITY:
+   case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+   case GL_TEXTURE_LOD_BIAS:
+   case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+      {
+         GLfloat fparam = (GLfloat) param;
+         /* convert int param to float */
+         need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
+      }
+      break;
+   default:
+      /* this will generate an error if pname is illegal */
+      need_update = set_tex_parameteri(ctx, texObj, pname, &param);
    }
-   else if (pname == GL_TEXTURE_CROP_RECT_OES) {
-      fparam[0] = (GLfloat) params[0];
-      fparam[1] = (GLfloat) params[1];
-      fparam[2] = (GLfloat) params[2];
-      fparam[3] = (GLfloat) params[3];
+
+   if (ctx->Driver.TexParameter && need_update) {
+      GLfloat fparam = (GLfloat) param;
+      ctx->Driver.TexParameter(ctx, target, texObj, pname, &fparam);
    }
-   else {
-      if (pname == GL_TEXTURE_PRIORITY)
-         fparam[0] = INT_TO_FLOAT(params[0]);
-      else
-         fparam[0] = (GLfloat) params[0];
-      fparam[1] = fparam[2] = fparam[3] = 0.0F;
+}
+
+
+void GLAPIENTRY
+_mesa_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+   GLboolean need_update;
+   struct gl_texture_object *texObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   texObj = get_texobj(ctx, target);
+   if (!texObj)
+      return;
+
+   switch (pname) {
+   case GL_TEXTURE_BORDER_COLOR:
+      {
+         /* convert int params to float */
+         GLfloat fparams[4];
+         fparams[0] = INT_TO_FLOAT(params[0]);
+         fparams[1] = INT_TO_FLOAT(params[1]);
+         fparams[2] = INT_TO_FLOAT(params[2]);
+         fparams[3] = INT_TO_FLOAT(params[3]);
+         need_update = set_tex_parameterf(ctx, texObj, pname, fparams);
+      }
+      break;
+   case GL_TEXTURE_MIN_LOD:
+   case GL_TEXTURE_MAX_LOD:
+   case GL_TEXTURE_PRIORITY:
+   case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+   case GL_TEXTURE_LOD_BIAS:
+   case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+      {
+         /* convert int param to float */
+         GLfloat fparam = (GLfloat) params[0];
+         need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
+      }
+      break;
+   default:
+      /* this will generate an error if pname is illegal */
+      need_update = set_tex_parameteri(ctx, texObj, pname, params);
+   }
+
+   if (ctx->Driver.TexParameter && need_update) {
+      GLfloat fparams[4];
+      fparams[0] = INT_TO_FLOAT(params[0]);
+      if (pname == GL_TEXTURE_BORDER_COLOR ||
+          pname == GL_TEXTURE_CROP_RECT_OES) {
+         fparams[1] = INT_TO_FLOAT(params[1]);
+         fparams[2] = INT_TO_FLOAT(params[2]);
+         fparams[3] = INT_TO_FLOAT(params[3]);
+      }
+      ctx->Driver.TexParameter(ctx, target, texObj, pname, fparams);
    }
-   _mesa_TexParameterfv(target, pname, fparam);
 }
 
 
@@ -483,44 +717,6 @@ _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
 }
 
 
-static GLuint
-tex_image_dimensions(GLcontext *ctx, GLenum target)
-{
-   switch (target) {
-      case GL_TEXTURE_1D:
-      case GL_PROXY_TEXTURE_1D:
-         return 1;
-      case GL_TEXTURE_2D:
-      case GL_PROXY_TEXTURE_2D:
-         return 2;
-      case GL_TEXTURE_3D:
-      case GL_PROXY_TEXTURE_3D:
-         return 3;
-      case GL_TEXTURE_CUBE_MAP:
-      case GL_PROXY_TEXTURE_CUBE_MAP:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-         return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
-      case GL_TEXTURE_RECTANGLE_NV:
-      case GL_PROXY_TEXTURE_RECTANGLE_NV:
-         return ctx->Extensions.NV_texture_rectangle ? 2 : 0;
-      case GL_TEXTURE_1D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_1D_ARRAY_EXT:
-         return ctx->Extensions.MESA_texture_array ? 2 : 0;
-      case GL_TEXTURE_2D_ARRAY_EXT:
-      case GL_PROXY_TEXTURE_2D_ARRAY_EXT:
-         return ctx->Extensions.MESA_texture_array ? 3 : 0;
-      default:
-         _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
-         return 0;
-   }
-}
-
-
 void GLAPIENTRY
 _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
                               GLenum pname, GLint *params )
@@ -528,7 +724,6 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
    const struct gl_texture_unit *texUnit;
    struct gl_texture_object *texObj;
    const struct gl_texture_image *img = NULL;
-   GLuint dimensions;
    GLboolean isProxy;
    GLint maxLevels;
    GET_CURRENT_CONTEXT(ctx);
@@ -540,19 +735,13 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    /* this will catch bad target values */
-   dimensions = tex_image_dimensions(ctx, target);  /* 1, 2 or 3 */
-   if (dimensions == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
-      return;
-   }
-
    maxLevels = _mesa_max_texture_levels(ctx, target);
    if (maxLevels == 0) {
-      /* should not happen since <target> was just checked above */
-      _mesa_problem(ctx, "maxLevels=0 in _mesa_GetTexLevelParameter");
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glGetTexLevelParameter[if]v(target=0x%x)", target);
       return;
    }
 
@@ -649,7 +838,8 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
                         "glGetTexLevelParameter[if]v(pname)");
          break;
       case GL_TEXTURE_STENCIL_SIZE_EXT:
-         if (ctx->Extensions.EXT_packed_depth_stencil) {
+         if (ctx->Extensions.EXT_packed_depth_stencil ||
+             ctx->Extensions.ARB_framebuffer_object) {
             *params = img->TexFormat->StencilBits;
          }
          else {
@@ -660,33 +850,21 @@ _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
 
       /* GL_ARB_texture_compression */
       case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
-         if (ctx->Extensions.ARB_texture_compression) {
-            if (img->IsCompressed && !isProxy) {
-               /* Don't use ctx->Driver.CompressedTextureSize() since that
-                * may returned a padded hardware size.
-                */
-               *params = _mesa_compressed_texture_size(ctx, img->Width,
-                                                   img->Height, img->Depth,
-                                                   img->TexFormat->MesaFormat);
-            }
-            else {
-               _mesa_error(ctx, GL_INVALID_OPERATION,
-                           "glGetTexLevelParameter[if]v(pname)");
-            }
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glGetTexLevelParameter[if]v(pname)");
-         }
+	 if (img->IsCompressed && !isProxy) {
+	    /* Don't use ctx->Driver.CompressedTextureSize() since that
+	     * may returned a padded hardware size.
+	     */
+	    *params = _mesa_compressed_texture_size(ctx, img->Width,
+						    img->Height, img->Depth,
+						    img->TexFormat->MesaFormat);
+	 }
+	 else {
+	    _mesa_error(ctx, GL_INVALID_OPERATION,
+			"glGetTexLevelParameter[if]v(pname)");
+	 }
          break;
       case GL_TEXTURE_COMPRESSED:
-         if (ctx->Extensions.ARB_texture_compression) {
-            *params = (GLint) img->IsCompressed;
-         }
-         else {
-            _mesa_error(ctx, GL_INVALID_ENUM,
-                        "glGetTexLevelParameter[if]v(pname)");
-         }
+         *params = (GLint) img->IsCompressed;
          break;
 
       /* GL_ARB_texture_float */
@@ -780,7 +958,7 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    obj = _mesa_select_tex_object(ctx, texUnit, target);
    if (!obj) {
@@ -841,63 +1019,49 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
             *params = obj->MaxAnisotropy;
          }
 	 else
-	    error = 1;
-         break;
-      case GL_TEXTURE_COMPARE_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            *params = (GLfloat) obj->CompareFlag;
-         }
-	 else 
-	    error = 1;
-         break;
-      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            *params = (GLfloat) obj->CompareOperator;
-         }
-	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
-      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-         if (ctx->Extensions.SGIX_shadow_ambient) {
-            *params = obj->ShadowAmbient;
+      case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+         if (ctx->Extensions.ARB_shadow_ambient) {
+            *params = obj->CompareFailValue;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
       case GL_GENERATE_MIPMAP_SGIS:
          if (ctx->Extensions.SGIS_generate_mipmap) {
             *params = (GLfloat) obj->GenerateMipmap;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
       case GL_TEXTURE_COMPARE_MODE_ARB:
          if (ctx->Extensions.ARB_shadow) {
             *params = (GLfloat) obj->CompareMode;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
       case GL_TEXTURE_COMPARE_FUNC_ARB:
          if (ctx->Extensions.ARB_shadow) {
             *params = (GLfloat) obj->CompareFunc;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
       case GL_DEPTH_TEXTURE_MODE_ARB:
          if (ctx->Extensions.ARB_depth_texture) {
             *params = (GLfloat) obj->DepthMode;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
       case GL_TEXTURE_LOD_BIAS:
          if (ctx->Extensions.EXT_texture_lod_bias) {
             *params = obj->LodBias;
          }
 	 else 
-	    error = 1;
+	    error = GL_TRUE;
          break;
 #ifdef FEATURE_OES_draw_texture
       case GL_TEXTURE_CROP_RECT_OES:
@@ -907,10 +1071,37 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
          params[3] = obj->CropRect[3];
          break;
 #endif
+
+      case GL_TEXTURE_SWIZZLE_R_EXT:
+      case GL_TEXTURE_SWIZZLE_G_EXT:
+      case GL_TEXTURE_SWIZZLE_B_EXT:
+      case GL_TEXTURE_SWIZZLE_A_EXT:
+         if (ctx->Extensions.EXT_texture_swizzle) {
+            GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
+            *params = (GLfloat) obj->Swizzle[comp];
+         }
+         else {
+            error = GL_TRUE;
+         }
+         break;
+
+      case GL_TEXTURE_SWIZZLE_RGBA_EXT:
+         if (ctx->Extensions.EXT_texture_swizzle) {
+            GLuint comp;
+            for (comp = 0; comp < 4; comp++) {
+               params[comp] = (GLfloat) obj->Swizzle[comp];
+            }
+         }
+         else {
+            error = GL_TRUE;
+         }
+         break;
+
       default:
-	 error = 1;
+	 error = GL_TRUE;
 	 break;
    }
+
    if (error)
       _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)",
 		  pname);
@@ -924,6 +1115,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
 {
    struct gl_texture_unit *texUnit;
    struct gl_texture_object *obj;
+   GLboolean error = GL_FALSE;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -933,7 +1125,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
       return;
    }
 
-   texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
+   texUnit = _mesa_get_current_tex_unit(ctx);
 
    obj = _mesa_select_tex_object(ctx, texUnit, target);
    if (!obj) {
@@ -944,19 +1136,19 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
    switch (pname) {
       case GL_TEXTURE_MAG_FILTER:
          *params = (GLint) obj->MagFilter;
-         return;
+         break;;
       case GL_TEXTURE_MIN_FILTER:
          *params = (GLint) obj->MinFilter;
-         return;
+         break;;
       case GL_TEXTURE_WRAP_S:
          *params = (GLint) obj->WrapS;
-         return;
+         break;;
       case GL_TEXTURE_WRAP_T:
          *params = (GLint) obj->WrapT;
-         return;
+         break;;
       case GL_TEXTURE_WRAP_R:
          *params = (GLint) obj->WrapR;
-         return;
+         break;;
       case GL_TEXTURE_BORDER_COLOR:
          {
             GLfloat b[4];
@@ -969,7 +1161,7 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
             params[2] = FLOAT_TO_INT(b[2]);
             params[3] = FLOAT_TO_INT(b[3]);
          }
-         return;
+         break;;
       case GL_TEXTURE_RESIDENT:
          {
             GLboolean resident;
@@ -979,74 +1171,76 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
                resident = GL_TRUE;
             *params = (GLint) resident;
          }
-         return;
+         break;;
       case GL_TEXTURE_PRIORITY:
          *params = FLOAT_TO_INT(obj->Priority);
-         return;
+         break;;
       case GL_TEXTURE_MIN_LOD:
          *params = (GLint) obj->MinLod;
-         return;
+         break;;
       case GL_TEXTURE_MAX_LOD:
          *params = (GLint) obj->MaxLod;
-         return;
+         break;;
       case GL_TEXTURE_BASE_LEVEL:
          *params = obj->BaseLevel;
-         return;
+         break;;
       case GL_TEXTURE_MAX_LEVEL:
          *params = obj->MaxLevel;
-         return;
+         break;;
       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
          if (ctx->Extensions.EXT_texture_filter_anisotropic) {
             *params = (GLint) obj->MaxAnisotropy;
-            return;
          }
-         break;
-      case GL_TEXTURE_COMPARE_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            *params = (GLint) obj->CompareFlag;
-            return;
+         else {
+            error = GL_TRUE;
          }
          break;
-      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
-         if (ctx->Extensions.SGIX_shadow) {
-            *params = (GLint) obj->CompareOperator;
-            return;
+      case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+         if (ctx->Extensions.ARB_shadow_ambient) {
+            *params = (GLint) FLOAT_TO_INT(obj->CompareFailValue);
          }
-         break;
-      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-         if (ctx->Extensions.SGIX_shadow_ambient) {
-            *params = (GLint) FLOAT_TO_INT(obj->ShadowAmbient);
-            return;
+         else {
+            error = GL_TRUE;
          }
          break;
       case GL_GENERATE_MIPMAP_SGIS:
          if (ctx->Extensions.SGIS_generate_mipmap) {
             *params = (GLint) obj->GenerateMipmap;
-            return;
+         }
+         else {
+            error = GL_TRUE;
          }
          break;
       case GL_TEXTURE_COMPARE_MODE_ARB:
          if (ctx->Extensions.ARB_shadow) {
             *params = (GLint) obj->CompareMode;
-            return;
+         }
+         else {
+            error = GL_TRUE;
          }
          break;
       case GL_TEXTURE_COMPARE_FUNC_ARB:
          if (ctx->Extensions.ARB_shadow) {
             *params = (GLint) obj->CompareFunc;
-            return;
+         }
+         else {
+            error = GL_TRUE;
          }
          break;
       case GL_DEPTH_TEXTURE_MODE_ARB:
          if (ctx->Extensions.ARB_depth_texture) {
             *params = (GLint) obj->DepthMode;
-            return;
+         }
+         else {
+            error = GL_TRUE;
          }
          break;
       case GL_TEXTURE_LOD_BIAS:
          if (ctx->Extensions.EXT_texture_lod_bias) {
             *params = (GLint) obj->LodBias;
-            return;
+         }
+         else {
+            error = GL_TRUE;
          }
          break;
 #ifdef FEATURE_OES_draw_texture
@@ -1057,9 +1251,35 @@ _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
          params[3] = obj->CropRect[3];
          break;
 #endif
+      case GL_TEXTURE_SWIZZLE_R_EXT:
+      case GL_TEXTURE_SWIZZLE_G_EXT:
+      case GL_TEXTURE_SWIZZLE_B_EXT:
+      case GL_TEXTURE_SWIZZLE_A_EXT:
+         if (ctx->Extensions.EXT_texture_swizzle) {
+            GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
+            *params = obj->Swizzle[comp];
+         }
+         else {
+            error = GL_TRUE;
+         }
+         break;
+
+      case GL_TEXTURE_SWIZZLE_RGBA_EXT:
+         if (ctx->Extensions.EXT_texture_swizzle) {
+            COPY_4V(params, obj->Swizzle);
+         }
+         else {
+            error = GL_TRUE;
+         }
+         break;
+
       default:
          ; /* silence warnings */
    }
-   /* If we get here, pname was an unrecognized enum */
-   _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname);
+
+   if (error)
+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)",
+		  pname);
+
+   _mesa_unlock_texture(ctx, obj);
 }
diff --git a/src/mesa/main/texrender.c b/src/mesa/main/texrender.c
index 4ae13a7b9b..cc74d58fbd 100644
--- a/src/mesa/main/texrender.c
+++ b/src/mesa/main/texrender.c
@@ -194,6 +194,59 @@ texture_put_row(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
    }
 }
 
+/**
+ * Put row of RGB values into a renderbuffer that wraps a texture image.
+ */
+static void
+texture_put_row_rgb(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
+                GLint x, GLint y, const void *values, const GLubyte *mask)
+{
+   const struct texture_renderbuffer *trb
+      = (const struct texture_renderbuffer *) rb;
+   const GLint z = trb->Zoffset;
+   GLuint i;
+
+   y += trb->Yoffset;
+
+   if (rb->DataType == CHAN_TYPE) {
+      const GLchan *rgb = (const GLchan *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, rgb);
+         }
+         rgb += 3;
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_SHORT) {
+      const GLushort *zValues = (const GLushort *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            trb->Store(trb->TexImage, x + i, y, z, zValues + i);
+         }
+      }
+   }
+   else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
+      const GLuint *zValues = (const GLuint *) values;
+      for (i = 0; i < count; i++) {
+         if (!mask || mask[i]) {
+            GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
+            trb->Store(trb->TexImage, x + i, y, z, &flt);
+         }
+      }
+   }
+   else {
+      _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");
+   }
+}
+
 
 static void
 texture_put_mono_row(GLcontext *ctx, struct gl_renderbuffer *rb, GLuint count,
@@ -380,6 +433,7 @@ wrap_texture(GLcontext *ctx, struct gl_renderbuffer_attachment *att)
    trb->Base.GetRow = texture_get_row;
    trb->Base.GetValues = texture_get_values;
    trb->Base.PutRow = texture_put_row;
+   trb->Base.PutRowRGB = texture_put_row_rgb;
    trb->Base.PutMonoRow = texture_put_mono_row;
    trb->Base.PutValues = texture_put_values;
    trb->Base.PutMonoValues = texture_put_mono_values;
@@ -453,6 +507,7 @@ update_wrapper(GLcontext *ctx, const struct gl_renderbuffer_attachment *att)
    trb->Base.BlueBits = trb->TexImage->TexFormat->BlueBits;
    trb->Base.AlphaBits = trb->TexImage->TexFormat->AlphaBits;
    trb->Base.DepthBits = trb->TexImage->TexFormat->DepthBits;
+   trb->Base.StencilBits = trb->TexImage->TexFormat->StencilBits;
 }
 
 
diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c
index 9bfb7e0ec2..b9311d0ffc 100644
--- a/src/mesa/main/texstate.c
+++ b/src/mesa/main/texstate.c
@@ -1,6 +1,6 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.1
+ * Version:  7.5
  *
  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
@@ -29,10 +29,9 @@
  */
 
 #include "glheader.h"
+#include "mfeatures.h"
 #include "colormac.h"
-#if FEATURE_colortable
 #include "colortab.h"
-#endif
 #include "context.h"
 #include "enums.h"
 #include "macros.h"
@@ -42,7 +41,6 @@
 #include "texstate.h"
 #include "texenvprogram.h"
 #include "mtypes.h"
-#include "math/m_xform.h"
 
 
 
@@ -53,10 +51,10 @@
  */
 static const struct gl_tex_env_combine_state default_combine_state = {
    GL_MODULATE, GL_MODULATE,
-   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT },
-   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT },
-   { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA },
-   { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },
+   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
+   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
+   { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA },
+   { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },
    0, 0,
    2, 2
 };
@@ -69,7 +67,7 @@ static const struct gl_tex_env_combine_state default_combine_state = {
 void
 _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst )
 {
-   GLuint i;
+   GLuint u, tex;
 
    ASSERT(src);
    ASSERT(dst);
@@ -81,57 +79,32 @@ _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst )
    dst->Texture.SharedPalette = src->Texture.SharedPalette;
 
    /* per-unit state */
-   for (i = 0; i < src->Const.MaxTextureImageUnits; i++) {
-      dst->Texture.Unit[i].Enabled = src->Texture.Unit[i].Enabled;
-      dst->Texture.Unit[i].EnvMode = src->Texture.Unit[i].EnvMode;
-      COPY_4V(dst->Texture.Unit[i].EnvColor, src->Texture.Unit[i].EnvColor);
-      dst->Texture.Unit[i].TexGenEnabled = src->Texture.Unit[i].TexGenEnabled;
-      dst->Texture.Unit[i].GenModeS = src->Texture.Unit[i].GenModeS;
-      dst->Texture.Unit[i].GenModeT = src->Texture.Unit[i].GenModeT;
-      dst->Texture.Unit[i].GenModeR = src->Texture.Unit[i].GenModeR;
-      dst->Texture.Unit[i].GenModeQ = src->Texture.Unit[i].GenModeQ;
-      dst->Texture.Unit[i]._GenBitS = src->Texture.Unit[i]._GenBitS;
-      dst->Texture.Unit[i]._GenBitT = src->Texture.Unit[i]._GenBitT;
-      dst->Texture.Unit[i]._GenBitR = src->Texture.Unit[i]._GenBitR;
-      dst->Texture.Unit[i]._GenBitQ = src->Texture.Unit[i]._GenBitQ;
-      dst->Texture.Unit[i]._GenFlags = src->Texture.Unit[i]._GenFlags;
-      COPY_4V(dst->Texture.Unit[i].ObjectPlaneS, src->Texture.Unit[i].ObjectPlaneS);
-      COPY_4V(dst->Texture.Unit[i].ObjectPlaneT, src->Texture.Unit[i].ObjectPlaneT);
-      COPY_4V(dst->Texture.Unit[i].ObjectPlaneR, src->Texture.Unit[i].ObjectPlaneR);
-      COPY_4V(dst->Texture.Unit[i].ObjectPlaneQ, src->Texture.Unit[i].ObjectPlaneQ);
-      COPY_4V(dst->Texture.Unit[i].EyePlaneS, src->Texture.Unit[i].EyePlaneS);
-      COPY_4V(dst->Texture.Unit[i].EyePlaneT, src->Texture.Unit[i].EyePlaneT);
-      COPY_4V(dst->Texture.Unit[i].EyePlaneR, src->Texture.Unit[i].EyePlaneR);
-      COPY_4V(dst->Texture.Unit[i].EyePlaneQ, src->Texture.Unit[i].EyePlaneQ);
-      dst->Texture.Unit[i].LodBias = src->Texture.Unit[i].LodBias;
+   for (u = 0; u < src->Const.MaxTextureImageUnits; u++) {
+      dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled;
+      dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode;
+      COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor);
+      dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled;
+      dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS;
+      dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT;
+      dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR;
+      dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ;
+      dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias;
 
       /* GL_EXT_texture_env_combine */
-      dst->Texture.Unit[i].Combine.ModeRGB = src->Texture.Unit[i].Combine.ModeRGB;
-      dst->Texture.Unit[i].Combine.ModeA = src->Texture.Unit[i].Combine.ModeA;
-      COPY_3V(dst->Texture.Unit[i].Combine.SourceRGB, src->Texture.Unit[i].Combine.SourceRGB);
-      COPY_3V(dst->Texture.Unit[i].Combine.SourceA, src->Texture.Unit[i].Combine.SourceA);
-      COPY_3V(dst->Texture.Unit[i].Combine.OperandRGB, src->Texture.Unit[i].Combine.OperandRGB);
-      COPY_3V(dst->Texture.Unit[i].Combine.OperandA, src->Texture.Unit[i].Combine.OperandA);
-      dst->Texture.Unit[i].Combine.ScaleShiftRGB = src->Texture.Unit[i].Combine.ScaleShiftRGB;
-      dst->Texture.Unit[i].Combine.ScaleShiftA = src->Texture.Unit[i].Combine.ScaleShiftA;
+      dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine;
+
+      /* GL_ATI_envmap_bumpmap - need this? */
+      dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget;
+      COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix);
+
 
       /* copy texture object bindings, not contents of texture objects */
       _mesa_lock_context_textures(dst);
 
-      _mesa_reference_texobj(&dst->Texture.Unit[i].Current1D,
-                             src->Texture.Unit[i].Current1D);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].Current2D,
-                             src->Texture.Unit[i].Current2D);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].Current3D,
-                             src->Texture.Unit[i].Current3D);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].CurrentCubeMap,
-                             src->Texture.Unit[i].CurrentCubeMap);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].CurrentRect,
-                             src->Texture.Unit[i].CurrentRect);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].Current1DArray,
-                             src->Texture.Unit[i].Current1DArray);
-      _mesa_reference_texobj(&dst->Texture.Unit[i].Current2DArray,
-                             src->Texture.Unit[i].Current2DArray);
+      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+         _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],
+                                src->Texture.Unit[u].CurrentTex[tex]);
+      }
 
       _mesa_unlock_context_textures(dst);
    }
@@ -204,11 +177,14 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state,
    case GL_LUMINANCE:
    case GL_RGB:
    case GL_YCBCR_MESA:
+   case GL_DUDV_ATI:
       state->SourceA[0] = GL_PREVIOUS;
       break;
       
    default:
-      _mesa_problem(NULL, "Invalid texBaseFormat in calculate_derived_texenv");
+      _mesa_problem(NULL,
+                    "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
+                    texBaseFormat);
       return;
    }
 
@@ -241,6 +217,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state,
 	 break;
       case GL_RGB:
       case GL_YCBCR_MESA:
+      case GL_DUDV_ATI:
 	 mode_rgb = GL_REPLACE;
 	 break;
       case GL_RGBA:
@@ -267,6 +244,7 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state,
       case GL_LUMINANCE_ALPHA:
       case GL_RGBA:
       case GL_YCBCR_MESA:
+      case GL_DUDV_ATI:
 	 state->SourceRGB[2] = GL_TEXTURE;
 	 state->SourceA[2]   = GL_TEXTURE;
 	 state->SourceRGB[0] = GL_CONSTANT;
@@ -282,7 +260,8 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state,
 
    default:
       _mesa_problem(NULL,
-                    "Invalid texture env mode in calculate_derived_texenv");
+                    "Invalid texture env mode 0x%x in calculate_derived_texenv",
+                    mode);
       return;
    }
    
@@ -364,84 +343,119 @@ _mesa_ClientActiveTextureARB(GLenum texture)
 static void
 update_texture_matrices( GLcontext *ctx )
 {
-   GLuint i;
+   GLuint u;
 
-   ctx->Texture._TexMatEnabled = 0;
+   ctx->Texture._TexMatEnabled = 0x0;
 
-   for (i=0; i < ctx->Const.MaxTextureCoordUnits; i++) {
-      if (_math_matrix_is_dirty(ctx->TextureMatrixStack[i].Top)) {
-	 _math_matrix_analyse( ctx->TextureMatrixStack[i].Top );
+   for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {
+      if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {
+	 _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );
 
-	 if (ctx->Texture.Unit[i]._ReallyEnabled &&
-	     ctx->TextureMatrixStack[i].Top->type != MATRIX_IDENTITY)
-	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(i);
+	 if (ctx->Texture.Unit[u]._ReallyEnabled &&
+	     ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)
+	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);
 
 	 if (ctx->Driver.TextureMatrix)
-	    ctx->Driver.TextureMatrix( ctx, i, ctx->TextureMatrixStack[i].Top);
+	    ctx->Driver.TextureMatrix( ctx, u, ctx->TextureMatrixStack[u].Top);
       }
    }
 }
 
 
 /**
- * Update texture object's _Function field.  We need to do this
- * whenever any of the texture object's shadow-related fields change
- * or when we start/stop using a fragment program.
- *
- * This function could be expanded someday to update additional per-object
- * fields that depend on assorted state changes.
+ * Examine texture unit's combine/env state to update derived state.
  */
 static void
-update_texture_compare_function(GLcontext *ctx,
-                                struct gl_texture_object *tObj)
+update_tex_combine(GLcontext *ctx, struct gl_texture_unit *texUnit)
 {
-   /* XXX temporarily disable this test since it breaks the GLSL
-    * shadow2D(), etc. functions.
+   struct gl_tex_env_combine_state *combine;
+
+   /* Set the texUnit->_CurrentCombine field to point to the user's combiner
+    * state, or the combiner state which is derived from traditional texenv
+    * mode.
     */
-   if (0 /*ctx->FragmentProgram._Current*/) {
-      /* Texel/coordinate comparison is ignored for programs.
-       * See GL_ARB_fragment_program/shader spec for details.
-       */
-      tObj->_Function = GL_NONE;
+   if (texUnit->EnvMode == GL_COMBINE ||
+       texUnit->EnvMode == GL_COMBINE4_NV) {
+      texUnit->_CurrentCombine = & texUnit->Combine;
    }
-   else if (tObj->CompareFlag) {
-      /* GL_SGIX_shadow */
-      if (tObj->CompareOperator == GL_TEXTURE_LEQUAL_R_SGIX) {
-         tObj->_Function = GL_LEQUAL;
+   else {
+      const struct gl_texture_object *texObj = texUnit->_Current;
+      GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
+      if (format == GL_COLOR_INDEX) {
+         format = GL_RGBA;  /* a bit of a hack */
       }
-      else {
-         ASSERT(tObj->CompareOperator == GL_TEXTURE_GEQUAL_R_SGIX);
-         tObj->_Function = GL_GEQUAL;
+      else if (format == GL_DEPTH_COMPONENT ||
+               format == GL_DEPTH_STENCIL_EXT) {
+         format = texObj->DepthMode;
       }
+      calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
+      texUnit->_CurrentCombine = & texUnit->_EnvMode;
    }
-   else if (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) {
-      /* GL_ARB_shadow */
-      tObj->_Function = tObj->CompareFunc;
-   }
-   else {
-      tObj->_Function = GL_NONE;  /* pass depth through as grayscale */
-   }
-}
 
+   combine = texUnit->_CurrentCombine;
 
-/**
- * Helper function for determining which texture object (1D, 2D, cube, etc)
- * should actually be used.
- */
-static void
-texture_override(GLcontext *ctx,
-                 struct gl_texture_unit *texUnit, GLbitfield enableBits,
-                 struct gl_texture_object *texObj, GLuint textureBit)
-{
-   if (!texUnit->_ReallyEnabled && (enableBits & textureBit)) {
-      if (!texObj->_Complete) {
-         _mesa_test_texobj_completeness(ctx, texObj);
-      }
-      if (texObj->_Complete) {
-         texUnit->_ReallyEnabled = textureBit;
-         texUnit->_Current = texObj;
-         update_texture_compare_function(ctx, texObj);
-      }
+   /* Determine number of source RGB terms in the combiner function */
+   switch (combine->ModeRGB) {
+   case GL_REPLACE:
+      combine->_NumArgsRGB = 1;
+      break;
+   case GL_ADD:
+   case GL_ADD_SIGNED:
+      if (texUnit->EnvMode == GL_COMBINE4_NV)
+         combine->_NumArgsRGB = 4;
+      else
+         combine->_NumArgsRGB = 2;
+      break;
+   case GL_MODULATE:
+   case GL_SUBTRACT:
+   case GL_DOT3_RGB:
+   case GL_DOT3_RGBA:
+   case GL_DOT3_RGB_EXT:
+   case GL_DOT3_RGBA_EXT:
+      combine->_NumArgsRGB = 2;
+      break;
+   case GL_INTERPOLATE:
+   case GL_MODULATE_ADD_ATI:
+   case GL_MODULATE_SIGNED_ADD_ATI:
+   case GL_MODULATE_SUBTRACT_ATI:
+      combine->_NumArgsRGB = 3;
+      break;
+   case GL_BUMP_ENVMAP_ATI:
+      /* no real arguments for this case */
+      combine->_NumArgsRGB = 0;
+      break;
+   default:
+      combine->_NumArgsRGB = 0;
+      _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
+      return;
+   }
+
+   /* Determine number of source Alpha terms in the combiner function */
+   switch (combine->ModeA) {
+   case GL_REPLACE:
+      combine->_NumArgsA = 1;
+      break;
+   case GL_ADD:
+   case GL_ADD_SIGNED:
+      if (texUnit->EnvMode == GL_COMBINE4_NV)
+         combine->_NumArgsA = 4;
+      else
+         combine->_NumArgsA = 2;
+      break;
+   case GL_MODULATE:
+   case GL_SUBTRACT:
+      combine->_NumArgsA = 2;
+      break;
+   case GL_INTERPOLATE:
+   case GL_MODULATE_ADD_ATI:
+   case GL_MODULATE_SIGNED_ADD_ATI:
+   case GL_MODULATE_SUBTRACT_ATI:
+      combine->_NumArgsA = 3;
+      break;
+   default:
+      combine->_NumArgsA = 0;
+      _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
+      break;
    }
 }
 
@@ -460,6 +474,7 @@ update_texture_state( GLcontext *ctx )
    GLuint unit;
    struct gl_fragment_program *fprog = NULL;
    struct gl_vertex_program *vprog = NULL;
+   GLbitfield enabledFragUnits = 0x0;
 
    if (ctx->Shader.CurrentProgram &&
        ctx->Shader.CurrentProgram->LinkStatus) {
@@ -478,145 +493,98 @@ update_texture_state( GLcontext *ctx )
       }
    }
 
-   ctx->NewState |= _NEW_TEXTURE; /* TODO: only set this if there are 
-				   * actual changes. 
-				   */
+   /* TODO: only set this if there are actual changes */
+   ctx->NewState |= _NEW_TEXTURE;
 
-   ctx->Texture._EnabledUnits = 0;
-   ctx->Texture._GenFlags = 0;
-   ctx->Texture._TexMatEnabled = 0;
-   ctx->Texture._TexGenEnabled = 0;
+   ctx->Texture._EnabledUnits = 0x0;
+   ctx->Texture._GenFlags = 0x0;
+   ctx->Texture._TexMatEnabled = 0x0;
+   ctx->Texture._TexGenEnabled = 0x0;
 
    /*
     * Update texture unit state.
     */
    for (unit = 0; unit < ctx->Const.MaxTextureImageUnits; unit++) {
       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-      GLbitfield enableBits;
+      GLbitfield enabledVertTargets = 0x0;
+      GLbitfield enabledFragTargets = 0x0;
+      GLbitfield enabledTargets = 0x0;
+      GLuint texIndex;
 
-      texUnit->_Current = NULL;
-      texUnit->_ReallyEnabled = 0;
-      texUnit->_GenFlags = 0;
-
-      /* Get the bitmask of texture enables.
+      /* Get the bitmask of texture target enables.
        * enableBits will be a mask of the TEXTURE_*_BIT flags indicating
        * which texture targets are enabled (fixed function) or referenced
        * by a fragment shader/program.  When multiple flags are set, we'll
-       * settle on the one with highest priority (see texture_override below).
+       * settle on the one with highest priority (see below).
        */
-      if (fprog || vprog) {
-         enableBits = 0x0;
-         if (fprog)
-            enableBits |= fprog->Base.TexturesUsed[unit];
-         if (vprog)
-            enableBits |= vprog->Base.TexturesUsed[unit];
+      if (vprog) {
+         enabledVertTargets |= vprog->Base.TexturesUsed[unit];
+      }
+
+      if (fprog) {
+         enabledFragTargets |= fprog->Base.TexturesUsed[unit];
       }
       else {
-         if (!texUnit->Enabled)
-            continue;
-         enableBits = texUnit->Enabled;
+         /* fixed-function fragment program */
+         enabledFragTargets |= texUnit->Enabled;
       }
 
-      ASSERT(texUnit->Current1D);
-      ASSERT(texUnit->Current2D);
-      ASSERT(texUnit->Current3D);
-      ASSERT(texUnit->CurrentCubeMap);
-      ASSERT(texUnit->CurrentRect);
-      ASSERT(texUnit->Current1DArray);
-      ASSERT(texUnit->Current2DArray);
-
-      /* Look for the highest-priority texture target that's enabled and
-       * complete.  That's the one we'll use for texturing.  If we're using
-       * a fragment program we're guaranteed that bitcount(enabledBits) <= 1.
-       */
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->Current2DArray, TEXTURE_2D_ARRAY_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->Current1DArray, TEXTURE_1D_ARRAY_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->CurrentCubeMap, TEXTURE_CUBE_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->Current3D, TEXTURE_3D_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->CurrentRect, TEXTURE_RECT_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->Current2D, TEXTURE_2D_BIT);
-      texture_override(ctx, texUnit, enableBits,
-                       texUnit->Current1D, TEXTURE_1D_BIT);
+      enabledTargets = enabledVertTargets | enabledFragTargets;
 
-      if (!texUnit->_ReallyEnabled) {
+      texUnit->_ReallyEnabled = 0x0;
+
+      if (enabledTargets == 0x0) {
+         /* neither vertex nor fragment processing uses this unit */
          continue;
       }
 
-      if (texUnit->_ReallyEnabled)
-         ctx->Texture._EnabledUnits |= (1 << unit);
-
-      if (texUnit->EnvMode == GL_COMBINE) {
-	 texUnit->_CurrentCombine = & texUnit->Combine;
+      /* Look for the highest priority texture target that's enabled (or used
+       * by the vert/frag shaders) and "complete".  That's the one we'll use
+       * for texturing.  If we're using vert/frag program we're guaranteed
+       * that bitcount(enabledBits) <= 1.
+       * Note that the TEXTURE_x_INDEX values are in high to low priority.
+       */
+      for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) {
+         if (enabledTargets & (1 << texIndex)) {
+            struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
+            if (!texObj->_Complete) {
+               _mesa_test_texobj_completeness(ctx, texObj);
+            }
+            if (texObj->_Complete) {
+               texUnit->_ReallyEnabled = 1 << texIndex;
+               _mesa_reference_texobj(&texUnit->_Current, texObj);
+               break;
+            }
+         }
       }
-      else {
-         const struct gl_texture_object *texObj = texUnit->_Current;
-         GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
-         if (format == GL_COLOR_INDEX) {
-            format = GL_RGBA;  /* a bit of a hack */
+
+      if (!texUnit->_ReallyEnabled) {
+         if (fprog) {
+            /* If we get here it means the shader is expecting a texture
+             * object, but there isn't one (or it's incomplete).  Use the
+             * fallback texture.
+             */
+            struct gl_texture_object *texObj = _mesa_get_fallback_texture(ctx);
+            texUnit->_ReallyEnabled = 1 << TEXTURE_2D_INDEX;
+            _mesa_reference_texobj(&texUnit->_Current, texObj);
          }
-         else if (format == GL_DEPTH_COMPONENT
-                  || format == GL_DEPTH_STENCIL_EXT) {
-            format = texObj->DepthMode;
+         else {
+            /* fixed-function: texture unit is really disabled */
+            continue;
          }
-	 calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
-	 texUnit->_CurrentCombine = & texUnit->_EnvMode;
       }
 
-      switch (texUnit->_CurrentCombine->ModeRGB) {
-      case GL_REPLACE:
-	 texUnit->_CurrentCombine->_NumArgsRGB = 1;
-	 break;
-      case GL_MODULATE:
-      case GL_ADD:
-      case GL_ADD_SIGNED:
-      case GL_SUBTRACT:
-      case GL_DOT3_RGB:
-      case GL_DOT3_RGBA:
-      case GL_DOT3_RGB_EXT:
-      case GL_DOT3_RGBA_EXT:
-	 texUnit->_CurrentCombine->_NumArgsRGB = 2;
-	 break;
-      case GL_INTERPOLATE:
-      case GL_MODULATE_ADD_ATI:
-      case GL_MODULATE_SIGNED_ADD_ATI:
-      case GL_MODULATE_SUBTRACT_ATI:
-	 texUnit->_CurrentCombine->_NumArgsRGB = 3;
-	 break;
-      default:
-	 texUnit->_CurrentCombine->_NumArgsRGB = 0;
-         _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
-         return;
-      }
+      /* if we get here, we know this texture unit is enabled */
 
-      switch (texUnit->_CurrentCombine->ModeA) {
-      case GL_REPLACE:
-	 texUnit->_CurrentCombine->_NumArgsA = 1;
-	 break;
-      case GL_MODULATE:
-      case GL_ADD:
-      case GL_ADD_SIGNED:
-      case GL_SUBTRACT:
-	 texUnit->_CurrentCombine->_NumArgsA = 2;
-	 break;
-      case GL_INTERPOLATE:
-      case GL_MODULATE_ADD_ATI:
-      case GL_MODULATE_SIGNED_ADD_ATI:
-      case GL_MODULATE_SUBTRACT_ATI:
-	 texUnit->_CurrentCombine->_NumArgsA = 3;
-	 break;
-      default:
-	 texUnit->_CurrentCombine->_NumArgsA = 0;
-         _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
-	 break;
-      }
+      ctx->Texture._EnabledUnits |= (1 << unit);
+
+      if (enabledFragTargets)
+         enabledFragUnits |= (1 << unit);
+
+      update_tex_combine(ctx, texUnit);
    }
 
+
    /* Determine which texture coordinate sets are actually needed */
    if (fprog) {
       const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
@@ -624,28 +592,30 @@ update_texture_state( GLcontext *ctx )
          = (fprog->Base.InputsRead >> FRAG_ATTRIB_TEX0) & coordMask;
    }
    else {
-      ctx->Texture._EnabledCoordUnits = ctx->Texture._EnabledUnits;
+      ctx->Texture._EnabledCoordUnits = enabledFragUnits;
    }
 
    /* Setup texgen for those texture coordinate sets that are in use */
    for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {
       struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
 
+      texUnit->_GenFlags = 0x0;
+
       if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))
 	 continue;
 
       if (texUnit->TexGenEnabled) {
 	 if (texUnit->TexGenEnabled & S_BIT) {
-	    texUnit->_GenFlags |= texUnit->_GenBitS;
+	    texUnit->_GenFlags |= texUnit->GenS._ModeBit;
 	 }
 	 if (texUnit->TexGenEnabled & T_BIT) {
-	    texUnit->_GenFlags |= texUnit->_GenBitT;
-	 }
-	 if (texUnit->TexGenEnabled & Q_BIT) {
-	    texUnit->_GenFlags |= texUnit->_GenBitQ;
+	    texUnit->_GenFlags |= texUnit->GenT._ModeBit;
 	 }
 	 if (texUnit->TexGenEnabled & R_BIT) {
-	    texUnit->_GenFlags |= texUnit->_GenBitR;
+	    texUnit->_GenFlags |= texUnit->GenR._ModeBit;
+	 }
+	 if (texUnit->TexGenEnabled & Q_BIT) {
+	    texUnit->_GenFlags |= texUnit->GenQ._ModeBit;
 	 }
 
 	 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);
@@ -728,6 +698,7 @@ static void
 init_texture_unit( GLcontext *ctx, GLuint unit )
 {
    struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
+   GLuint tex;
 
    texUnit->EnvMode = GL_MODULATE;
    ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
@@ -735,35 +706,36 @@ init_texture_unit( GLcontext *ctx, GLuint unit )
    texUnit->Combine = default_combine_state;
    texUnit->_EnvMode = default_combine_state;
    texUnit->_CurrentCombine = & texUnit->_EnvMode;
-
-   texUnit->TexGenEnabled = 0;
-   texUnit->GenModeS = GL_EYE_LINEAR;
-   texUnit->GenModeT = GL_EYE_LINEAR;
-   texUnit->GenModeR = GL_EYE_LINEAR;
-   texUnit->GenModeQ = GL_EYE_LINEAR;
-   texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
-   texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
-   texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
-   texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
+   texUnit->BumpTarget = GL_TEXTURE0;
+
+   texUnit->TexGenEnabled = 0x0;
+   texUnit->GenS.Mode = GL_EYE_LINEAR;
+   texUnit->GenT.Mode = GL_EYE_LINEAR;
+   texUnit->GenR.Mode = GL_EYE_LINEAR;
+   texUnit->GenQ.Mode = GL_EYE_LINEAR;
+   texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;
+   texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;
+   texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;
+   texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;
 
    /* Yes, these plane coefficients are correct! */
-   ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );
+
+   /* no mention of this in spec, but maybe id matrix expected? */
+   ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 );
 
    /* initialize current texture object ptrs to the shared default objects */
-   _mesa_reference_texobj(&texUnit->Current1D, ctx->Shared->Default1D);
-   _mesa_reference_texobj(&texUnit->Current2D, ctx->Shared->Default2D);
-   _mesa_reference_texobj(&texUnit->Current3D, ctx->Shared->Default3D);
-   _mesa_reference_texobj(&texUnit->CurrentCubeMap, ctx->Shared->DefaultCubeMap);
-   _mesa_reference_texobj(&texUnit->CurrentRect, ctx->Shared->DefaultRect);
-   _mesa_reference_texobj(&texUnit->Current1DArray, ctx->Shared->Default1DArray);
-   _mesa_reference_texobj(&texUnit->Current2DArray, ctx->Shared->Default2DArray);
+   for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+      _mesa_reference_texobj(&texUnit->CurrentTex[tex],
+                             ctx->Shared->DefaultTex[tex]);
+   }
 }
 
 
@@ -773,26 +745,22 @@ init_texture_unit( GLcontext *ctx, GLuint unit )
 GLboolean
 _mesa_init_texture(GLcontext *ctx)
 {
-   GLuint i;
-
-   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
-   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
+   GLuint u;
 
    /* Texture group */
    ctx->Texture.CurrentUnit = 0;      /* multitexture */
-   ctx->Texture._EnabledUnits = 0;
+   ctx->Texture._EnabledUnits = 0x0;
    ctx->Texture.SharedPalette = GL_FALSE;
-#if FEATURE_colortable
    _mesa_init_colortable(&ctx->Texture.Palette);
-#endif
 
-   for (i = 0; i < MAX_TEXTURE_UNITS; i++)
-      init_texture_unit( ctx, i );
+   for (u = 0; u < MAX_TEXTURE_UNITS; u++)
+      init_texture_unit(ctx, u);
 
    /* After we're done initializing the context's texture state the default
     * texture objects' refcounts should be at least MAX_TEXTURE_UNITS + 1.
     */
-   assert(ctx->Shared->Default1D->RefCount >= MAX_TEXTURE_UNITS + 1);
+   assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount
+          >= MAX_TEXTURE_UNITS + 1);
 
    /* Allocate proxy textures */
    if (!alloc_proxy_textures( ctx ))
@@ -812,27 +780,20 @@ _mesa_free_texture_data(GLcontext *ctx)
 
    /* unreference current textures */
    for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++) {
-      struct gl_texture_unit *unit = ctx->Texture.Unit + u;
-      _mesa_reference_texobj(&unit->Current1D, NULL);
-      _mesa_reference_texobj(&unit->Current2D, NULL);
-      _mesa_reference_texobj(&unit->Current3D, NULL);
-      _mesa_reference_texobj(&unit->CurrentCubeMap, NULL);
-      _mesa_reference_texobj(&unit->CurrentRect, NULL);
-      _mesa_reference_texobj(&unit->Current1DArray, NULL);
-      _mesa_reference_texobj(&unit->Current2DArray, NULL);
+      /* The _Current texture could account for another reference */
+      _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);
+
+      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
+         _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);
+      }
    }
 
    /* Free proxy texture objects */
    for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)
       ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
 
-#if FEATURE_colortable
-   {
-      GLuint i;
-      for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++)
-         _mesa_free_colortable_data( &ctx->Texture.Unit[i].ColorTable );
-   }
-#endif
+   for (u = 0; u < MAX_TEXTURE_IMAGE_UNITS; u++)
+      _mesa_free_colortable_data(&ctx->Texture.Unit[u].ColorTable);
 }
 
 
@@ -844,17 +805,13 @@ _mesa_free_texture_data(GLcontext *ctx)
 void
 _mesa_update_default_objects_texture(GLcontext *ctx)
 {
-   GLuint i;
-
-   for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-
-      _mesa_reference_texobj(&texUnit->Current1D, ctx->Shared->Default1D);
-      _mesa_reference_texobj(&texUnit->Current2D, ctx->Shared->Default2D);
-      _mesa_reference_texobj(&texUnit->Current3D, ctx->Shared->Default3D);
-      _mesa_reference_texobj(&texUnit->CurrentCubeMap, ctx->Shared->DefaultCubeMap);
-      _mesa_reference_texobj(&texUnit->CurrentRect, ctx->Shared->DefaultRect);
-      _mesa_reference_texobj(&texUnit->Current1DArray, ctx->Shared->Default1DArray);
-      _mesa_reference_texobj(&texUnit->Current2DArray, ctx->Shared->Default2DArray);
+   GLuint u, tex;
+
+   for (u = 0; u < MAX_TEXTURE_UNITS; u++) {
+      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
+      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
+         _mesa_reference_texobj(&texUnit->CurrentTex[tex],
+                                ctx->Shared->DefaultTex[tex]);
+      }
    }
 }
diff --git a/src/mesa/main/texstate.h b/src/mesa/main/texstate.h
index a7d7088c62..17ac68000c 100644
--- a/src/mesa/main/texstate.h
+++ b/src/mesa/main/texstate.h
@@ -35,6 +35,18 @@
 #include "mtypes.h"
 
 
+/**
+ * Return pointer to current texture unit.
+ * This the texture unit set by glActiveTexture(), not glClientActiveTexture().
+ */
+static INLINE struct gl_texture_unit *
+_mesa_get_current_tex_unit(GLcontext *ctx)
+{
+   ASSERT(ctx->Texture.CurrentUnit < Elements(ctx->Texture.Unit));
+   return &(ctx->Texture.Unit[ctx->Texture.CurrentUnit]);
+}
+
+
 extern void
 _mesa_copy_texture_state( const GLcontext *src, GLcontext *dst );
 
@@ -48,16 +60,14 @@ _mesa_print_texunit_state( GLcontext *ctx, GLuint unit );
  */
 /*@{*/
 
-
-/*
- * GL_ARB_multitexture
- */
 extern void GLAPIENTRY
 _mesa_ActiveTextureARB( GLenum target );
 
 extern void GLAPIENTRY
 _mesa_ClientActiveTextureARB( GLenum target );
 
+/*@}*/
+
 
 /**
  * \name Initialization, state maintenance
diff --git a/src/mesa/main/texstore.c b/src/mesa/main/texstore.c
index 67cfca2565..352c88e673 100644
--- a/src/mesa/main/texstore.c
+++ b/src/mesa/main/texstore.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.5
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008-2009  VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -55,9 +56,7 @@
 #include "bufferobj.h"
 #include "colormac.h"
 #include "context.h"
-#if FEATURE_convolve
 #include "convolve.h"
-#endif
 #include "image.h"
 #include "macros.h"
 #include "mipmap.h"
@@ -271,16 +270,6 @@ compute_component_mapping(GLenum inFormat, GLenum outFormat,
 }
 
 
-#if !FEATURE_convolve
-static void
-_mesa_adjust_image_for_convolution(GLcontext *ctx, GLuint dims,
-                                   GLsizei *srcWidth, GLsizei *srcHeight)
-{
-   /* no-op */
-}
-#endif
-
-
 /**
  * Make a temporary (color) texture image with GLfloat components.
  * Apply all needed pixel unpacking and pixel transfer operations.
@@ -384,7 +373,6 @@ make_temp_float_image(GLcontext *ctx, GLuint dims,
          convWidth = srcWidth;
          convHeight = srcHeight;
 
-#if FEATURE_convolve
          /* do convolution */
          {
             GLfloat *src = tempImage + img * (srcWidth * srcHeight * 4);
@@ -404,7 +392,7 @@ make_temp_float_image(GLcontext *ctx, GLuint dims,
                }
             }
          }
-#endif
+
          /* do post-convolution transfer and pack into tempImage */
          {
             const GLint logComponents
@@ -561,7 +549,6 @@ _mesa_make_temp_chan_image(GLcontext *ctx, GLuint dims,
           textureBaseFormat == GL_ALPHA ||
           textureBaseFormat == GL_INTENSITY);
 
-#if FEATURE_convolve
    if ((dims == 1 && ctx->Pixel.Convolution1DEnabled) ||
        (dims >= 2 && ctx->Pixel.Convolution2DEnabled) ||
        (dims >= 2 && ctx->Pixel.Separable2DEnabled)) {
@@ -583,7 +570,6 @@ _mesa_make_temp_chan_image(GLcontext *ctx, GLuint dims,
       transferOps = 0;
       freeSrcImage = GL_TRUE;
    }
-#endif
 
    /* unpack and transfer the source image */
    tempImage = (GLchan *) _mesa_malloc(srcWidth * srcHeight * srcDepth
@@ -797,6 +783,7 @@ static const GLubyte *
 type_mapping( GLenum srcType )
 {
    switch (srcType) {
+   case GL_BYTE:
    case GL_UNSIGNED_BYTE:
       return map_identity;
    case GL_UNSIGNED_INT_8_8_8_8:
@@ -818,6 +805,7 @@ byteswap_mapping( GLboolean swapBytes,
       return map_identity;
 
    switch (srcType) {
+   case GL_BYTE:
    case GL_UNSIGNED_BYTE:
       return map_identity;
    case GL_UNSIGNED_INT_8_8_8_8:
@@ -885,8 +873,8 @@ _mesa_swizzle_ubyte_image(GLcontext *ctx,
 
 /*    _mesa_printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */
 
-   if (srcRowStride == dstRowStride &&
-       srcComponents == dstComponents &&
+   if (srcComponents == dstComponents &&
+       srcRowStride == dstRowStride &&
        srcRowStride == srcWidth * srcComponents &&
        dimensions < 3) {
       /* 1 and 2D images only */
@@ -992,6 +980,32 @@ memcpy_texture(GLcontext *ctx,
 }
 
 
+/**
+ * no-op store
+ */
+GLboolean
+_mesa_texstore_null(TEXSTORE_PARAMS)
+{
+   (void) ctx;
+   (void) dims; 
+   (void) baseInternalFormat; 
+   (void) dstFormat; 
+   (void) dstAddr; 
+   (void) dstXoffset;
+   (void) dstYoffset;
+   (void) dstZoffset; 
+   (void) dstRowStride;
+   (void) dstImageOffsets; 
+   (void) srcWidth;
+   (void) srcHeight;
+   (void) srcDepth; 
+   (void) srcFormat;
+   (void) srcType; 
+   (void) srcAddr; 
+   (void) srcPacking;
+   return GL_TRUE;
+}
+
 
 /**
  * Store an image in any of the formats:
@@ -2470,7 +2484,214 @@ _mesa_texstore_ycbcr(TEXSTORE_PARAMS)
    return GL_TRUE;
 }
 
+GLboolean
+_mesa_texstore_dudv8(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+
+   ASSERT(dstFormat == &_mesa_texformat_dudv8);
+   ASSERT(dstFormat->TexelBytes == 2);
+   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);
+   ASSERT((srcFormat == GL_DU8DV8_ATI) ||
+	  (srcFormat == GL_DUDV_ATI));
+   ASSERT(baseInternalFormat == GL_DUDV_ATI);
 
+   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (srcType == GL_BYTE) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (littleEndian) {
+	 dstmap[0] = 0;
+	 dstmap[1] = 3;
+      }
+      else {
+	 dstmap[0] = 3;
+	 dstmap[1] = 0;
+      }
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				GL_LUMINANCE_ALPHA, /* hack */
+				GL_UNSIGNED_BYTE, /* hack */
+				GL_LUMINANCE_ALPHA, /* hack */
+				dstmap, 2,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path - note this is defined for 2d textures only */
+      const GLint components = _mesa_components_in_format(baseInternalFormat);
+      const GLint srcStride = _mesa_image_row_stride(srcPacking,
+                                                 srcWidth, srcFormat, srcType);
+      GLbyte *tempImage, *dst, *src;
+      GLint row;
+
+      tempImage = (GLbyte *) _mesa_malloc(srcWidth * srcHeight * srcDepth
+                                          * components * sizeof(GLbyte));
+      if (!tempImage)
+         return GL_FALSE;
+
+      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                           srcWidth, srcHeight,
+                                           srcFormat, srcType,
+                                           0, 0, 0);
+
+      dst = tempImage;
+      for (row = 0; row < srcHeight; row++) {
+         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,
+                                     dst, srcFormat, srcType, src,
+                                     srcPacking, 0);
+         dst += srcWidth * components;
+         src += srcStride;
+      }
+ 
+      src = tempImage;
+      dst = (GLbyte *) dstAddr
+            + dstYoffset * dstRowStride
+            + dstXoffset * dstFormat->TexelBytes;
+      for (row = 0; row < srcHeight; row++) {
+         memcpy(dst, src, srcWidth * dstFormat->TexelBytes);
+         dst += dstRowStride;
+         src += srcWidth * dstFormat->TexelBytes;
+      }
+      _mesa_free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/**
+ * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or MESA_FORMAT_SIGNED_RGBA8888_REV
+ */
+GLboolean
+_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+
+   ASSERT(dstFormat == &_mesa_texformat_signed_rgba8888 ||
+          dstFormat == &_mesa_texformat_signed_rgba8888_rev);
+   ASSERT(dstFormat->TexelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == &_mesa_texformat_signed_rgba8888 &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {
+       /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == &_mesa_texformat_signed_rgba8888_rev &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    (srcType == GL_BYTE) &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if ((littleEndian && dstFormat == &_mesa_texformat_signed_rgba8888) ||
+	  (!littleEndian && dstFormat == &_mesa_texformat_signed_rgba8888_rev)) {
+	 dstmap[3] = 0;
+	 dstmap[2] = 1;
+	 dstmap[1] = 2;
+	 dstmap[0] = 3;
+      }
+      else {
+	 dstmap[3] = 3;
+	 dstmap[2] = 2;
+	 dstmap[1] = 1;
+	 dstmap[0] = 0;
+      }
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 4,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 dstFormat->BaseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      _mesa_adjust_image_for_convolution(ctx, dims, &srcWidth, &srcHeight);
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * dstFormat->TexelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * dstFormat->TexelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == &_mesa_texformat_signed_rgba8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
+                                                FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),
+                                                FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),
+                                                FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );
+                  srcRow += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888_REV( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),
+                                                    FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),
+                                                    FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),
+                                                    FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );
+                  srcRow += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      _mesa_free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
 
 /**
  * Store a combined depth/stencil texture image.
@@ -2479,12 +2700,45 @@ GLboolean
 _mesa_texstore_z24_s8(TEXSTORE_PARAMS)
 {
    const GLfloat depthScale = (GLfloat) 0xffffff;
+   const GLint srcRowStride
+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+      / sizeof(GLuint);
+   GLint img, row;
 
    ASSERT(dstFormat == &_mesa_texformat_z24_s8);
-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT);
-   ASSERT(srcType == GL_UNSIGNED_INT_24_8_EXT);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
 
-   if (ctx->Pixel.DepthScale == 1.0f &&
+   /* In case we only upload depth we need to preserve the stencil */
+   if (srcFormat == GL_DEPTH_COMPONENT) {
+      for (img = 0; img < srcDepth; img++) {
+         GLuint *dstRow = (GLuint *) dstAddr
+            + dstImageOffsets[dstZoffset + img]
+            + dstYoffset * dstRowStride / sizeof(GLuint)
+            + dstXoffset;
+         const GLuint *src
+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+                  srcWidth, srcHeight,
+                  srcFormat, srcType,
+                  img, 0, 0);
+         for (row = 0; row < srcHeight; row++) {
+            GLuint depth[MAX_WIDTH];
+            GLint i;
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, /* dst type */
+                                    depth, /* dst addr */
+                                    depthScale,
+                                    srcType, src, srcPacking);
+
+            for (i = 0; i < srcWidth; i++)
+               dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
+
+            src += srcRowStride;
+            dstRow += dstRowStride / sizeof(GLuint);
+         }
+      }
+   }
+   else if (ctx->Pixel.DepthScale == 1.0f &&
        ctx->Pixel.DepthBias == 0.0f &&
        !srcPacking->SwapBytes) {
       /* simple path */
@@ -2769,7 +3023,6 @@ _mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
 GLboolean
 _mesa_texstore_srgb8(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const struct gl_texture_format *newDstFormat;
    StoreTexImageFunc store;
    GLboolean k;
@@ -2777,14 +3030,8 @@ _mesa_texstore_srgb8(TEXSTORE_PARAMS)
    ASSERT(dstFormat == &_mesa_texformat_srgb8);
 
    /* reuse normal rgb texstore code */
-   if (littleEndian) {
-      newDstFormat = &_mesa_texformat_bgr888;
-      store = _mesa_texstore_bgr888;
-   }
-   else {
-      newDstFormat = &_mesa_texformat_rgb888;
-      store = _mesa_texstore_rgb888;
-   }
+   newDstFormat = &_mesa_texformat_rgb888;
+   store = _mesa_texstore_rgb888;
 
    k = store(ctx, dims, baseInternalFormat,
              newDstFormat, dstAddr,
@@ -2800,17 +3047,13 @@ _mesa_texstore_srgb8(TEXSTORE_PARAMS)
 GLboolean
 _mesa_texstore_srgba8(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const struct gl_texture_format *newDstFormat;
    GLboolean k;
 
    ASSERT(dstFormat == &_mesa_texformat_srgba8);
 
    /* reuse normal rgba texstore code */
-   if (littleEndian)
-      newDstFormat = &_mesa_texformat_rgba8888_rev;
-   else
-      newDstFormat = &_mesa_texformat_rgba8888;
+   newDstFormat = &_mesa_texformat_rgba8888;
 
    k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,
                                newDstFormat, dstAddr,
@@ -2824,6 +3067,28 @@ _mesa_texstore_srgba8(TEXSTORE_PARAMS)
 
 
 GLboolean
+_mesa_texstore_sargb8(TEXSTORE_PARAMS)
+{
+   const struct gl_texture_format *newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == &_mesa_texformat_sargb8);
+
+   /* reuse normal rgba texstore code */
+   newDstFormat = &_mesa_texformat_argb8888;
+
+   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,
+                               newDstFormat, dstAddr,
+                               dstXoffset, dstYoffset, dstZoffset,
+                               dstRowStride, dstImageOffsets,
+                               srcWidth, srcHeight, srcDepth,
+                               srcFormat, srcType,
+                               srcAddr, srcPacking);
+   return k;
+}
+
+
+GLboolean
 _mesa_texstore_sl8(TEXSTORE_PARAMS)
 {
    const struct gl_texture_format *newDstFormat;
@@ -2848,17 +3113,13 @@ _mesa_texstore_sl8(TEXSTORE_PARAMS)
 GLboolean
 _mesa_texstore_sla8(TEXSTORE_PARAMS)
 {
-   const GLboolean littleEndian = _mesa_little_endian();
    const struct gl_texture_format *newDstFormat;
    GLboolean k;
 
    ASSERT(dstFormat == &_mesa_texformat_sla8);
 
    /* reuse normal luminance/alpha texstore code */
-   if (littleEndian)
-      newDstFormat = &_mesa_texformat_al88;
-   else
-      newDstFormat = &_mesa_texformat_al88_rev;
+   newDstFormat = &_mesa_texformat_al88;
 
    k = _mesa_texstore_al88(ctx, dims, baseInternalFormat,
                            newDstFormat, dstAddr,
@@ -2888,7 +3149,7 @@ _mesa_validate_pbo_teximage(GLcontext *ctx, GLuint dimensions,
 {
    GLubyte *buf;
 
-   if (unpack->BufferObj->Name == 0) {
+   if (!_mesa_is_bufferobj(unpack->BufferObj)) {
       /* no PBO */
       return pixels;
    }
@@ -2924,7 +3185,7 @@ _mesa_validate_pbo_compressed_teximage(GLcontext *ctx,
 {
    GLubyte *buf;
 
-   if (packing->BufferObj->Name == 0) {
+   if (!_mesa_is_bufferobj(packing->BufferObj)) {
       /* not using a PBO - return pointer unchanged */
       return pixels;
    }
@@ -2954,7 +3215,7 @@ void
 _mesa_unmap_teximage_pbo(GLcontext *ctx,
                          const struct gl_pixelstore_attrib *unpack)
 {
-   if (unpack->BufferObj->Name) {
+   if (_mesa_is_bufferobj(unpack->BufferObj)) {
       ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_UNPACK_BUFFER_EXT,
                               unpack->BufferObj);
    }
@@ -3673,252 +3934,3 @@ _mesa_store_compressed_texsubimage3d(GLcontext *ctx, GLenum target,
    (void) texObj;
    (void) texImage;
 }
-
-
-
-
-#if FEATURE_EXT_texture_sRGB
-
-/**
- * Test if given texture image is an sRGB format.
- */
-static GLboolean
-is_srgb_teximage(const struct gl_texture_image *texImage)
-{
-   switch (texImage->TexFormat->MesaFormat) {
-   case MESA_FORMAT_SRGB8:
-   case MESA_FORMAT_SRGBA8:
-   case MESA_FORMAT_SL8:
-   case MESA_FORMAT_SLA8:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-#endif /* FEATURE_EXT_texture_sRGB */
-
-
-/**
- * This is the software fallback for Driver.GetTexImage().
- * All error checking will have been done before this routine is called.
- */
-void
-_mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level,
-                   GLenum format, GLenum type, GLvoid *pixels,
-                   struct gl_texture_object *texObj,
-                   struct gl_texture_image *texImage)
-{
-   const GLuint dimensions = (target == GL_TEXTURE_3D) ? 3 : 2;
-
-   if (ctx->Pack.BufferObj->Name) {
-      /* Packing texture image into a PBO.
-       * Map the (potentially) VRAM-based buffer into our process space so
-       * we can write into it with the code below.
-       * A hardware driver might use a sophisticated blit to move the
-       * texture data to the PBO if the PBO is in VRAM along with the texture.
-       */
-      GLubyte *buf = (GLubyte *)
-         ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                               GL_WRITE_ONLY_ARB, ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,"glGetTexImage(PBO is mapped)");
-         return;
-      }
-      /* <pixels> was an offset into the PBO.
-       * Now make it a real, client-side pointer inside the mapped region.
-       */
-      pixels = ADD_POINTERS(buf, pixels);
-   }
-   else if (!pixels) {
-      /* not an error */
-      return;
-   }
-
-   {
-      const GLint width = texImage->Width;
-      const GLint height = texImage->Height;
-      const GLint depth = texImage->Depth;
-      GLint img, row;
-      for (img = 0; img < depth; img++) {
-         for (row = 0; row < height; row++) {
-            /* compute destination address in client memory */
-            GLvoid *dest = _mesa_image_address( dimensions, &ctx->Pack, pixels,
-                                                width, height, format, type,
-                                                img, row, 0);
-            assert(dest);
-
-            if (format == GL_COLOR_INDEX) {
-               GLuint indexRow[MAX_WIDTH];
-               GLint col;
-               /* Can't use FetchTexel here because that returns RGBA */
-               if (texImage->TexFormat->IndexBits == 8) {
-                  const GLubyte *src = (const GLubyte *) texImage->Data;
-                  src += width * (img * texImage->Height + row);
-                  for (col = 0; col < width; col++) {
-                     indexRow[col] = src[col];
-                  }
-               }
-               else if (texImage->TexFormat->IndexBits == 16) {
-                  const GLushort *src = (const GLushort *) texImage->Data;
-                  src += width * (img * texImage->Height + row);
-                  for (col = 0; col < width; col++) {
-                     indexRow[col] = src[col];
-                  }
-               }
-               else {
-                  _mesa_problem(ctx,
-                                "Color index problem in _mesa_GetTexImage");
-               }
-               _mesa_pack_index_span(ctx, width, type, dest,
-                                     indexRow, &ctx->Pack,
-                                     0 /* no image transfer */);
-            }
-            else if (format == GL_DEPTH_COMPONENT) {
-               GLfloat depthRow[MAX_WIDTH];
-               GLint col;
-               for (col = 0; col < width; col++) {
-                  (*texImage->FetchTexelf)(texImage, col, row, img,
-                                           depthRow + col);
-               }
-               _mesa_pack_depth_span(ctx, width, dest, type,
-                                     depthRow, &ctx->Pack);
-            }
-            else if (format == GL_DEPTH_STENCIL_EXT) {
-               /* XXX Note: we're bypassing texImage->FetchTexel()! */
-               const GLuint *src = (const GLuint *) texImage->Data;
-               src += width * row + width * height * img;
-               _mesa_memcpy(dest, src, width * sizeof(GLuint));
-               if (ctx->Pack.SwapBytes) {
-                  _mesa_swap4((GLuint *) dest, width);
-               }
-            }
-            else if (format == GL_YCBCR_MESA) {
-               /* No pixel transfer */
-               const GLint rowstride = texImage->RowStride;
-               MEMCPY(dest,
-                      (const GLushort *) texImage->Data + row * rowstride,
-                      width * sizeof(GLushort));
-               /* check for byte swapping */
-               if ((texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR
-                    && type == GL_UNSIGNED_SHORT_8_8_REV_MESA) ||
-                   (texImage->TexFormat->MesaFormat == MESA_FORMAT_YCBCR_REV
-                    && type == GL_UNSIGNED_SHORT_8_8_MESA)) {
-                  if (!ctx->Pack.SwapBytes)
-                     _mesa_swap2((GLushort *) dest, width);
-               }
-               else if (ctx->Pack.SwapBytes) {
-                  _mesa_swap2((GLushort *) dest, width);
-               }
-            }
-#if FEATURE_EXT_texture_sRGB
-            else if (is_srgb_teximage(texImage)) {
-               /* no pixel transfer and no non-linear to linear conversion */
-               const GLint comps = texImage->TexFormat->TexelBytes;
-               const GLint rowstride = comps * texImage->RowStride;
-               MEMCPY(dest,
-                      (const GLubyte *) texImage->Data + row * rowstride,
-                      comps * width * sizeof(GLubyte));
-            }
-#endif /* FEATURE_EXT_texture_sRGB */
-            else {
-               /* general case:  convert row to RGBA format */
-               GLfloat rgba[MAX_WIDTH][4];
-               GLint col;
-               GLbitfield transferOps = 0x0;
-
-               if (type == GL_FLOAT && 
-                   ((ctx->Color.ClampReadColor == GL_TRUE) ||
-                    (ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB &&
-                     texImage->TexFormat->DataType != GL_FLOAT)))
-                  transferOps |= IMAGE_CLAMP_BIT;
-
-               for (col = 0; col < width; col++) {
-                  (*texImage->FetchTexelf)(texImage, col, row, img, rgba[col]);
-                  if (texImage->TexFormat->BaseFormat == GL_ALPHA) {
-                     rgba[col][RCOMP] = 0.0;
-                     rgba[col][GCOMP] = 0.0;
-                     rgba[col][BCOMP] = 0.0;
-                  }
-                  else if (texImage->TexFormat->BaseFormat == GL_LUMINANCE) {
-                     rgba[col][GCOMP] = 0.0;
-                     rgba[col][BCOMP] = 0.0;
-                     rgba[col][ACOMP] = 1.0;
-                  }
-                  else if (texImage->TexFormat->BaseFormat == GL_LUMINANCE_ALPHA) {
-                     rgba[col][GCOMP] = 0.0;
-                     rgba[col][BCOMP] = 0.0;
-                  }
-                  else if (texImage->TexFormat->BaseFormat == GL_INTENSITY) {
-                     rgba[col][GCOMP] = 0.0;
-                     rgba[col][BCOMP] = 0.0;
-                     rgba[col][ACOMP] = 1.0;
-                  }
-               }
-               _mesa_pack_rgba_span_float(ctx, width, (GLfloat (*)[4]) rgba,
-                                          format, type, dest,
-                                          &ctx->Pack, transferOps /*image xfer ops*/);
-            } /* format */
-         } /* row */
-      } /* img */
-   }
-
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
-}
-
-
-
-/**
- * This is the software fallback for Driver.GetCompressedTexImage().
- * All error checking will have been done before this routine is called.
- */
-void
-_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level,
-                              GLvoid *img,
-                              struct gl_texture_object *texObj,
-                              struct gl_texture_image *texImage)
-{
-   GLuint size;
-
-   if (ctx->Pack.BufferObj->Name) {
-      /* pack texture image into a PBO */
-      GLubyte *buf;
-      if ((const GLubyte *) img + texImage->CompressedSize >
-          (const GLubyte *) ctx->Pack.BufferObj->Size) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetCompressedTexImage(invalid PBO access)");
-         return;
-      }
-      buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                                              GL_WRITE_ONLY_ARB,
-                                              ctx->Pack.BufferObj);
-      if (!buf) {
-         /* buffer is already mapped - that's an error */
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glGetCompressedTexImage(PBO is mapped)");
-         return;
-      }
-      img = ADD_POINTERS(buf, img);
-   }
-   else if (!img) {
-      /* not an error */
-      return;
-   }
-
-   /* don't use texImage->CompressedSize since that may be padded out */
-   size = _mesa_compressed_texture_size(ctx, texImage->Width, texImage->Height,
-                                        texImage->Depth,
-                                        texImage->TexFormat->MesaFormat);
-
-   /* just memcpy, no pixelstore or pixel transfer */
-   _mesa_memcpy(img, texImage->Data, size);
-
-   if (ctx->Pack.BufferObj->Name) {
-      ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT,
-                              ctx->Pack.BufferObj);
-   }
-}
diff --git a/src/mesa/main/texstore.h b/src/mesa/main/texstore.h
index 951d0a112b..e1b12dfa95 100644
--- a/src/mesa/main/texstore.h
+++ b/src/mesa/main/texstore.h
@@ -3,6 +3,7 @@
  * Version:  6.5.1
  *
  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008 VMware, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -38,6 +39,7 @@
 #include "mtypes.h"
 
 
+extern GLboolean _mesa_texstore_null(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_rgba(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_color_index(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_rgba8888(TEXSTORE_PARAMS);
@@ -73,10 +75,12 @@ extern GLboolean _mesa_texstore_rgba_dxt5(TEXSTORE_PARAMS);
 #if FEATURE_EXT_texture_sRGB
 extern GLboolean _mesa_texstore_srgb8(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_srgba8(TEXSTORE_PARAMS);
+extern GLboolean _mesa_texstore_sargb8(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_sl8(TEXSTORE_PARAMS);
 extern GLboolean _mesa_texstore_sla8(TEXSTORE_PARAMS);
 #endif
-
+extern GLboolean _mesa_texstore_dudv8(TEXSTORE_PARAMS);
+extern GLboolean _mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS);
 
 extern GLchan *
 _mesa_make_temp_chan_image(GLcontext *ctx, GLuint dims,
@@ -207,19 +211,6 @@ _mesa_store_compressed_texsubimage3d(GLcontext *ctx, GLenum target,
                                 struct gl_texture_image *texImage);
 
 
-extern void
-_mesa_get_teximage(GLcontext *ctx, GLenum target, GLint level,
-                   GLenum format, GLenum type, GLvoid *pixels,
-                   struct gl_texture_object *texObj,
-                   struct gl_texture_image *texImage);
-
-
-extern void
-_mesa_get_compressed_teximage(GLcontext *ctx, GLenum target, GLint level,
-                              GLvoid *img,
-                              struct gl_texture_object *texObj,
-                              struct gl_texture_image *texImage);
-
 extern const GLvoid *
 _mesa_validate_pbo_teximage(GLcontext *ctx, GLuint dimensions,
 			    GLsizei width, GLsizei height, GLsizei depth,
diff --git a/src/mesa/main/varray.c b/src/mesa/main/varray.c
index 9d9b28b518..6cd2a2f4f6 100644
--- a/src/mesa/main/varray.c
+++ b/src/mesa/main/varray.c
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.2
+ * Version:  7.6
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -29,6 +30,7 @@
 #include "context.h"
 #include "enable.h"
 #include "enums.h"
+#include "hash.h"
 #include "mtypes.h"
 #include "varray.h"
 #include "arrayobj.h"
@@ -36,49 +38,55 @@
 
 
 /**
- * Update the fields of a vertex array object.
- * We need to do a few special things for arrays that live in
- * vertex buffer objects.
+ * Set the fields of a vertex array.
+ * Also do an error check for GL_ARB_vertex_array_object: check that
+ * all arrays reside in VBOs when using a vertex array object.
  *
  * \param array  the array to update
  * \param dirtyBit  which bit to set in ctx->Array.NewState for this array
  * \param elementSize  size of each array element, in bytes
  * \param size  components per element (1, 2, 3 or 4)
  * \param type  datatype of each component (GL_FLOAT, GL_INT, etc)
+ * \param format  either GL_RGBA or GL_BGRA
  * \param stride  stride between elements, in elements
  * \param normalized  are integer types converted to floats in [-1, 1]?
  * \param ptr  the address (or offset inside VBO) of the array data
+ * \return GL_TRUE if no error, GL_FALSE if error
  */
-static void
+static GLboolean
 update_array(GLcontext *ctx, struct gl_client_array *array,
              GLbitfield dirtyBit, GLsizei elementSize,
-             GLint size, GLenum type,
+             GLint size, GLenum type, GLenum format,
              GLsizei stride, GLboolean normalized, const GLvoid *ptr)
 {
+   ASSERT(format == GL_RGBA || format == GL_BGRA);
+
+   if (ctx->Array.ArrayObj->VBOonly &&
+       ctx->Array.ArrayBufferObj->Name == 0) {
+      /* GL_ARB_vertex_array_object requires that all arrays reside in VBOs.
+       * Generate GL_INVALID_OPERATION if that's not true.
+       */
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glVertex/Normal/EtcPointer(non-VBO array)");
+      return GL_FALSE;
+   }
+
    array->Size = size;
    array->Type = type;
+   array->Format = format;
    array->Stride = stride;
    array->StrideB = stride ? stride : elementSize;
    array->Normalized = normalized;
    array->Ptr = (const GLubyte *) ptr;
-#if FEATURE_ARB_vertex_buffer_object
+   array->_ElementSize = elementSize;
+
    _mesa_reference_buffer_object(ctx, &array->BufferObj,
                                  ctx->Array.ArrayBufferObj);
 
-   /* Compute the index of the last array element that's inside the buffer.
-    * Later in glDrawArrays we'll check if start + count > _MaxElement to
-    * be sure we won't go out of bounds.
-    */
-   if (ctx->Array.ArrayBufferObj->Name)
-      array->_MaxElement = ((GLsizeiptrARB) ctx->Array.ArrayBufferObj->Size
-                            - (GLsizeiptrARB) array->Ptr + array->StrideB
-                            - elementSize) / array->StrideB;
-   else
-#endif
-      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
-
    ctx->NewState |= _NEW_ARRAY;
    ctx->Array.NewState |= dirtyBit;
+
+   return GL_TRUE;
 }
 
 
@@ -127,12 +135,14 @@ _mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
          break;
 #endif
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glVertexPointer(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->Vertex, _NEW_ARRAY_VERTEX,
-                elementSize, size, type, stride, GL_FALSE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->Vertex, _NEW_ARRAY_VERTEX,
+                     elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr))
+      return;
 
    if (ctx->Driver.VertexPointer)
       ctx->Driver.VertexPointer( ctx, size, type, stride, ptr );
@@ -177,12 +187,14 @@ _mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
          break;
 #endif
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glNormalPointer(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->Normal, _NEW_ARRAY_NORMAL,
-                elementSize, 3, type, stride, GL_TRUE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->Normal, _NEW_ARRAY_NORMAL,
+                     elementSize, 3, type, GL_RGBA, stride, GL_TRUE, ptr))
+      return;
 
    if (ctx->Driver.NormalPointer)
       ctx->Driver.NormalPointer( ctx, type, stride, ptr );
@@ -193,12 +205,15 @@ void GLAPIENTRY
 _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
 {
    GLsizei elementSize;
+   GLenum format;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (size < 3 || size > 4) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(size)" );
-      return;
+      if (!ctx->Extensions.EXT_vertex_array_bgra || size != GL_BGRA) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glColorPointer(size)");
+         return;
+      }
    }
    if (stride < 0) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glColorPointer(stride)" );
@@ -209,6 +224,18 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
       _mesa_debug(ctx, "glColorPointer( sz %d type %s stride %d )\n", size,
                   _mesa_lookup_enum_by_nr( type ), stride);
 
+   if (size == GL_BGRA) {
+      if (type != GL_UNSIGNED_BYTE) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glColorPointer(GL_BGRA/GLubyte)");
+         return;
+      }
+      format = GL_BGRA;
+      size = 4;
+   }
+   else {
+      format = GL_RGBA;
+   }
+
    switch (type) {
       case GL_BYTE:
          elementSize = size * sizeof(GLbyte);
@@ -240,12 +267,14 @@ _mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
          break;
 #endif
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glColorPointer(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->Color, _NEW_ARRAY_COLOR0,
-                elementSize, size, type, stride, GL_TRUE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->Color, _NEW_ARRAY_COLOR0,
+                     elementSize, size, type, format, stride, GL_TRUE, ptr))
+      return;
 
    if (ctx->Driver.ColorPointer)
       ctx->Driver.ColorPointer( ctx, size, type, stride, ptr );
@@ -276,8 +305,9 @@ _mesa_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->FogCoord, _NEW_ARRAY_FOGCOORD,
-                elementSize, 1, type, stride, GL_FALSE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->FogCoord, _NEW_ARRAY_FOGCOORD,
+                     elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr))
+      return;
 
    if (ctx->Driver.FogCoordPointer)
       ctx->Driver.FogCoordPointer( ctx, type, stride, ptr );
@@ -317,8 +347,9 @@ _mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->Index, _NEW_ARRAY_INDEX,
-                elementSize, 1, type, stride, GL_FALSE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->Index, _NEW_ARRAY_INDEX,
+                     elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr))
+      return;
 
    if (ctx->Driver.IndexPointer)
       ctx->Driver.IndexPointer( ctx, type, stride, ptr );
@@ -330,12 +361,15 @@ _mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
 			       GLsizei stride, const GLvoid *ptr)
 {
    GLsizei elementSize;
+   GLenum format;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (size != 3 && size != 4) {
-      _mesa_error( ctx, GL_INVALID_VALUE, "glSecondaryColorPointer(size)" );
-      return;
+      if (!ctx->Extensions.EXT_vertex_array_bgra || size != GL_BGRA) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glSecondaryColorPointer(size)");
+         return;
+      }
    }
    if (stride < 0) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glSecondaryColorPointer(stride)" );
@@ -346,6 +380,18 @@ _mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
       _mesa_debug(ctx, "glSecondaryColorPointer( sz %d type %s stride %d )\n",
                   size, _mesa_lookup_enum_by_nr( type ), stride);
 
+   if (size == GL_BGRA) {
+      if (type != GL_UNSIGNED_BYTE) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glColorPointer(GL_BGRA/GLubyte)");
+         return;
+      }
+      format = GL_BGRA;
+      size = 4;
+   }
+   else {
+      format = GL_RGBA;
+   }
+
    switch (type) {
       case GL_BYTE:
          elementSize = size * sizeof(GLbyte);
@@ -372,12 +418,15 @@ _mesa_SecondaryColorPointerEXT(GLint size, GLenum type,
          elementSize = size * sizeof(GLdouble);
          break;
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glSecondaryColorPointer(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->SecondaryColor, _NEW_ARRAY_COLOR1,
-                elementSize, size, type, stride, GL_TRUE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->SecondaryColor,
+                     _NEW_ARRAY_COLOR1, elementSize, size, type,
+                     format, stride, GL_TRUE, ptr))
+      return;
 
    if (ctx->Driver.SecondaryColorPointer)
       ctx->Driver.SecondaryColorPointer( ctx, size, type, stride, ptr );
@@ -431,13 +480,15 @@ _mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
          break;
 #endif
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexCoordPointer(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->TexCoord[unit],
-                _NEW_ARRAY_TEXCOORD(unit),
-                elementSize, size, type, stride, GL_FALSE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->TexCoord[unit],
+                     _NEW_ARRAY_TEXCOORD(unit),
+                     elementSize, size, type, GL_RGBA, stride, GL_FALSE, ptr))
+      return;
 
    if (ctx->Driver.TexCoordPointer)
       ctx->Driver.TexCoordPointer( ctx, size, type, stride, ptr );
@@ -455,8 +506,10 @@ _mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
       return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->EdgeFlag, _NEW_ARRAY_EDGEFLAG,
-                sizeof(GLboolean), 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->EdgeFlag, _NEW_ARRAY_EDGEFLAG,
+                     sizeof(GLboolean), 1, GL_UNSIGNED_BYTE, GL_RGBA,
+                     stride, GL_FALSE, ptr))
+      return;
 
    if (ctx->Driver.EdgeFlagPointer)
       ctx->Driver.EdgeFlagPointer( ctx, stride, ptr );
@@ -490,21 +543,28 @@ _mesa_PointSizePointer(GLenum type, GLsizei stride, const GLvoid *ptr)
    }
 
    update_array(ctx, &ctx->Array.ArrayObj->PointSize, _NEW_ARRAY_POINT_SIZE,
-                elementSize, 1, type, stride, GL_FALSE, ptr);
+                elementSize, 1, type, GL_RGBA, stride, GL_FALSE, ptr);
 }
 
 
 #if FEATURE_NV_vertex_program
+/**
+ * Set a vertex attribute array.
+ * Note that these arrays DO alias the conventional GL vertex arrays
+ * (position, normal, color, fog, texcoord, etc).
+ * The generic attribute slots at #16 and above are not touched.
+ */
 void GLAPIENTRY
 _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
                             GLsizei stride, const GLvoid *ptr)
 {
    GLboolean normalized = GL_FALSE;
    GLsizei elementSize;
+   GLenum format;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (index >= MAX_VERTEX_PROGRAM_ATTRIBS) {
+   if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) {
       _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerNV(index)");
       return;
    }
@@ -524,6 +584,21 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
       return;
    }
 
+   if (size == GL_BGRA) {
+      if (type != GL_UNSIGNED_BYTE) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glVertexAttribPointerNV(GL_BGRA/type)");
+         return;
+      }
+
+      format = GL_BGRA;
+      size = 4;
+      normalized = GL_TRUE;
+   }
+   else {
+      format = GL_RGBA;
+   }
+
    /* check for valid 'type' and compute StrideB right away */
    switch (type) {
       case GL_UNSIGNED_BYTE:
@@ -540,13 +615,15 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
          elementSize = size * sizeof(GLdouble);
          break;
       default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerNV(type)" );
+         _mesa_error( ctx, GL_INVALID_ENUM, "glVertexAttribPointerNV(type=%s)",
+                      _mesa_lookup_enum_by_nr(type));
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
-                _NEW_ARRAY_ATTRIB(index),
-                elementSize, size, type, stride, normalized, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
+                     _NEW_ARRAY_ATTRIB(index),
+                     elementSize, size, type, format, stride, normalized, ptr))
+      return;
 
    if (ctx->Driver.VertexAttribPointer)
       ctx->Driver.VertexAttribPointer( ctx, index, size, type, stride, ptr );
@@ -555,12 +632,18 @@ _mesa_VertexAttribPointerNV(GLuint index, GLint size, GLenum type,
 
 
 #if FEATURE_ARB_vertex_program
+/**
+ * Set a generic vertex attribute array.
+ * Note that these arrays DO NOT alias the conventional GL vertex arrays
+ * (position, normal, color, fog, texcoord, etc).
+ */
 void GLAPIENTRY
 _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
                              GLboolean normalized,
                              GLsizei stride, const GLvoid *ptr)
 {
    GLsizei elementSize;
+   GLenum format;
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
@@ -570,8 +653,10 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
    }
 
    if (size < 1 || size > 4) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(size)");
-      return;
+      if (!ctx->Extensions.EXT_vertex_array_bgra || size != GL_BGRA) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(size)");
+         return;
+      }
    }
 
    if (stride < 0) {
@@ -579,6 +664,25 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
       return;
    }
 
+   if (size == GL_BGRA) {
+      if (type != GL_UNSIGNED_BYTE) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glVertexAttribPointerARB(GL_BGRA/type)");
+         return;
+      }
+      if (normalized != GL_TRUE) {
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glVertexAttribPointerARB(GL_BGRA/normalized)");
+         return;
+      }
+
+      format = GL_BGRA;
+      size = 4;
+   }
+   else {
+      format = GL_RGBA;
+   }
+
    /* check for valid 'type' and compute StrideB right away */
    /* NOTE: more types are supported here than in the NV extension */
    switch (type) {
@@ -616,9 +720,10 @@ _mesa_VertexAttribPointerARB(GLuint index, GLint size, GLenum type,
          return;
    }
 
-   update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
-                _NEW_ARRAY_ATTRIB(index),
-                elementSize, size, type, stride, normalized, ptr);
+   if (!update_array(ctx, &ctx->Array.ArrayObj->VertexAttrib[index],
+                     _NEW_ARRAY_ATTRIB(index),
+                     elementSize, size, type, format, stride, normalized, ptr))
+      return;
 
    if (ctx->Driver.VertexAttribPointer)
       ctx->Driver.VertexAttribPointer(ctx, index, size, type, stride, ptr);
@@ -933,24 +1038,6 @@ _mesa_MultiDrawArraysEXT( GLenum mode, GLint *first,
 }
 
 
-/* GL_EXT_multi_draw_arrays */
-void GLAPIENTRY
-_mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type,
-                            const GLvoid **indices, GLsizei primcount )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-
-   for (i = 0; i < primcount; i++) {
-      if (count[i] > 0) {
-         CALL_DrawElements(ctx->Exec, (mode, count[i], type, indices[i]));
-      }
-   }
-}
-
-
 /* GL_IBM_multimode_draw_arrays */
 void GLAPIENTRY
 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
@@ -994,13 +1081,107 @@ _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count,
 
 
 /**
+ * Copy one client vertex array to another.
+ */
+void
+_mesa_copy_client_array(GLcontext *ctx,
+                        struct gl_client_array *dst,
+                        struct gl_client_array *src)
+{
+   dst->Size = src->Size;
+   dst->Type = src->Type;
+   dst->Format = src->Format;
+   dst->Stride = src->Stride;
+   dst->StrideB = src->StrideB;
+   dst->Ptr = src->Ptr;
+   dst->Enabled = src->Enabled;
+   dst->Normalized = src->Normalized;
+   dst->_ElementSize = src->_ElementSize;
+   _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
+   dst->_MaxElement = src->_MaxElement;
+}
+
+
+
+/**
+ * Print vertex array's fields.
+ */
+static void
+print_array(const char *name, GLint index, const struct gl_client_array *array)
+{
+   if (index >= 0)
+      _mesa_printf("  %s[%d]: ", name, index);
+   else
+      _mesa_printf("  %s: ", name);
+   _mesa_printf("Ptr=%p, Type=0x%x, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %u), MaxElem=%u\n",
+                array->Ptr, array->Type, array->Size,
+                array->_ElementSize, array->StrideB,
+                array->BufferObj->Name, array->BufferObj->Size,
+                array->_MaxElement);
+}
+
+
+/**
+ * Print current vertex object/array info.  For debug.
+ */
+void
+_mesa_print_arrays(GLcontext *ctx)
+{
+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
+   GLuint i;
+
+   _mesa_update_array_object_max_element(ctx, arrayObj);
+
+   _mesa_printf("Array Object %u\n", arrayObj->Name);
+   if (arrayObj->Vertex.Enabled)
+      print_array("Vertex", -1, &arrayObj->Vertex);
+   if (arrayObj->Normal.Enabled)
+      print_array("Normal", -1, &arrayObj->Normal);
+   if (arrayObj->Color.Enabled)
+      print_array("Color", -1, &arrayObj->Color);
+   for (i = 0; i < Elements(arrayObj->TexCoord); i++)
+      if (arrayObj->TexCoord[i].Enabled)
+         print_array("TexCoord", i, &arrayObj->TexCoord[i]);
+   for (i = 0; i < Elements(arrayObj->VertexAttrib); i++)
+      if (arrayObj->VertexAttrib[i].Enabled)
+         print_array("Attrib", i, &arrayObj->VertexAttrib[i]);
+   _mesa_printf("  _MaxElement = %u\n", arrayObj->_MaxElement);
+}
+
+
+/**
  * Initialize vertex array state for given context.
  */
 void 
 _mesa_init_varray(GLcontext *ctx)
 {
    ctx->Array.DefaultArrayObj = _mesa_new_array_object(ctx, 0);
-   ctx->Array.ArrayObj = ctx->Array.DefaultArrayObj;
-
+   _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj,
+                                ctx->Array.DefaultArrayObj);
    ctx->Array.ActiveTexture = 0;   /* GL_ARB_multitexture */
+
+   ctx->Array.Objects = _mesa_NewHashTable();
+}
+
+
+/**
+ * Callback for deleting an array object.  Called by _mesa_HashDeleteAll().
+ */
+static void
+delete_arrayobj_cb(GLuint id, void *data, void *userData)
+{
+   struct gl_array_object *arrayObj = (struct gl_array_object *) data;
+   GLcontext *ctx = (GLcontext *) userData;
+   _mesa_delete_array_object(ctx, arrayObj);
+}
+
+
+/**
+ * Free vertex array state for given context.
+ */
+void 
+_mesa_free_varray_data(GLcontext *ctx)
+{
+   _mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx);
+   _mesa_DeleteHashTable(ctx->Array.Objects);
 }
diff --git a/src/mesa/main/varray.h b/src/mesa/main/varray.h
index 6385689fcc..ef790c504e 100644
--- a/src/mesa/main/varray.h
+++ b/src/mesa/main/varray.h
@@ -1,18 +1,9 @@
-/**
- * \file varray.h
- * Vertex arrays.
- *
- * \if subset
- * (No-op)
- *
- * \endif
- */
-
 /*
  * Mesa 3-D graphics library
- * Version:  4.1
+ * Version:  7.6
  *
- * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -138,6 +129,11 @@ extern void GLAPIENTRY
 _mesa_MultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type,
                             const GLvoid **indices, GLsizei primcount );
 
+extern void GLAPIENTRY
+_mesa_MultiDrawElementsBaseVertex( GLenum mode,
+				   const GLsizei *count, GLenum type,
+				   const GLvoid **indices, GLsizei primcount,
+				   const GLint *basevertex);
 
 extern void GLAPIENTRY
 _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
@@ -156,13 +152,49 @@ _mesa_LockArraysEXT(GLint first, GLsizei count);
 extern void GLAPIENTRY
 _mesa_UnlockArraysEXT( void );
 
+
+extern void GLAPIENTRY
+_mesa_DrawArrays(GLenum mode, GLint first, GLsizei count);
+
+extern void GLAPIENTRY
+_mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,
+                   const GLvoid *indices);
+
+extern void GLAPIENTRY
+_mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
+                        GLenum type, const GLvoid *indices);
+
+extern void GLAPIENTRY
+_mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+			     const GLvoid *indices, GLint basevertex);
+
+extern void GLAPIENTRY
+_mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
+				  GLsizei count, GLenum type,
+				  const GLvoid *indices,
+				  GLint basevertex);
+
+
+extern void
+_mesa_copy_client_array(GLcontext *ctx,
+                        struct gl_client_array *dst,
+                        struct gl_client_array *src);
+
+
+extern void
+_mesa_print_arrays(GLcontext *ctx);
+
 extern void
 _mesa_init_varray( GLcontext * ctx );
 
+extern void 
+_mesa_free_varray_data(GLcontext *ctx);
+
 #else
 
 /** No-op */
 #define _mesa_init_varray( c )  ((void)0)
+#define _mesa_free_varray_data( c )  ((void)0)
 
 #endif
 
diff --git a/src/mesa/main/version.h b/src/mesa/main/version.h
index 3d874c8ba8..0cae1860a3 100644
--- a/src/mesa/main/version.h
+++ b/src/mesa/main/version.h
@@ -1,8 +1,9 @@
 /*
  * Mesa 3-D graphics library
- * Version:  7.3
+ * Version:  7.7
  *
  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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"),
@@ -29,9 +30,9 @@
 
 /* Mesa version */
 #define MESA_MAJOR 7
-#define MESA_MINOR 3
+#define MESA_MINOR 7
 #define MESA_PATCH 0
-#define MESA_VERSION_STRING "7.3-rc3"
+#define MESA_VERSION_STRING "7.7-devel"
 
 /* To make version comparison easy */
 #define MESA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
diff --git a/src/mesa/main/viewport.c b/src/mesa/main/viewport.c
new file mode 100644
index 0000000000..309308c983
--- /dev/null
+++ b/src/mesa/main/viewport.c
@@ -0,0 +1,180 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/**
+ * \file viewport.c
+ * glViewport and glDepthRange functions.
+ */
+
+
+#include "context.h"
+#include "macros.h"
+#include "viewport.h"
+
+
+/**
+ * Set the viewport.
+ * \sa Called via glViewport() or display list execution.
+ *
+ * Flushes the vertices and calls _mesa_set_viewport() with the given
+ * parameters.
+ */
+void GLAPIENTRY
+_mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+   _mesa_set_viewport(ctx, x, y, width, height);
+}
+
+
+/**
+ * Set new viewport parameters and update derived state (the _WindowMap
+ * matrix).  Usually called from _mesa_Viewport().
+ * 
+ * \param ctx GL context.
+ * \param x, y coordinates of the lower left corner of the viewport rectangle.
+ * \param width width of the viewport rectangle.
+ * \param height height of the viewport rectangle.
+ */
+void
+_mesa_set_viewport(GLcontext *ctx, GLint x, GLint y,
+                    GLsizei width, GLsizei height)
+{
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glViewport %d %d %d %d\n", x, y, width, height);
+
+   if (width < 0 || height < 0) {
+      _mesa_error(ctx,  GL_INVALID_VALUE,
+                   "glViewport(%d, %d, %d, %d)", x, y, width, height);
+      return;
+   }
+
+   /* clamp width and height to the implementation dependent range */
+   width  = MIN2(width, (GLsizei) ctx->Const.MaxViewportWidth);
+   height = MIN2(height, (GLsizei) ctx->Const.MaxViewportHeight);
+
+   ctx->Viewport.X = x;
+   ctx->Viewport.Width = width;
+   ctx->Viewport.Y = y;
+   ctx->Viewport.Height = height;
+   ctx->NewState |= _NEW_VIEWPORT;
+
+#if 1
+   /* XXX remove this someday.  Currently the DRI drivers rely on
+    * the WindowMap matrix being up to date in the driver's Viewport
+    * and DepthRange functions.
+    */
+   _math_matrix_viewport(&ctx->Viewport._WindowMap,
+                         ctx->Viewport.X, ctx->Viewport.Y,
+                         ctx->Viewport.Width, ctx->Viewport.Height,
+                         ctx->Viewport.Near, ctx->Viewport.Far,
+                         ctx->DrawBuffer->_DepthMaxF);
+#endif
+
+   if (ctx->Driver.Viewport) {
+      /* Many drivers will use this call to check for window size changes
+       * and reallocate the z/stencil/accum/etc buffers if needed.
+       */
+      ctx->Driver.Viewport(ctx, x, y, width, height);
+   }
+}
+
+
+/**
+ * Called by glDepthRange
+ *
+ * \param nearval  specifies the Z buffer value which should correspond to
+ *                 the near clip plane
+ * \param farval  specifies the Z buffer value which should correspond to
+ *                the far clip plane
+ */
+void GLAPIENTRY
+_mesa_DepthRange(GLclampd nearval, GLclampd farval)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   if (MESA_VERBOSE&VERBOSE_API)
+      _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval);
+
+   if (ctx->Viewport.Near == nearval &&
+       ctx->Viewport.Far == farval)
+      return;
+
+   ctx->Viewport.Near = (GLfloat) CLAMP(nearval, 0.0, 1.0);
+   ctx->Viewport.Far = (GLfloat) CLAMP(farval, 0.0, 1.0);
+   ctx->NewState |= _NEW_VIEWPORT;
+
+#if 1
+   /* XXX remove this someday.  Currently the DRI drivers rely on
+    * the WindowMap matrix being up to date in the driver's Viewport
+    * and DepthRange functions.
+    */
+   _math_matrix_viewport(&ctx->Viewport._WindowMap,
+                         ctx->Viewport.X, ctx->Viewport.Y,
+                         ctx->Viewport.Width, ctx->Viewport.Height,
+                         ctx->Viewport.Near, ctx->Viewport.Far,
+                         ctx->DrawBuffer->_DepthMaxF);
+#endif
+
+   if (ctx->Driver.DepthRange) {
+      ctx->Driver.DepthRange(ctx, nearval, farval);
+   }
+}
+
+
+
+/** 
+ * Initialize the context viewport attribute group.
+ * \param ctx  the GL context.
+ */
+void _mesa_init_viewport(GLcontext *ctx)
+{
+   GLfloat depthMax = 65535.0F; /* sorf of arbitrary */
+
+   /* Viewport group */
+   ctx->Viewport.X = 0;
+   ctx->Viewport.Y = 0;
+   ctx->Viewport.Width = 0;
+   ctx->Viewport.Height = 0;
+   ctx->Viewport.Near = 0.0;
+   ctx->Viewport.Far = 1.0;
+   _math_matrix_ctr(&ctx->Viewport._WindowMap);
+
+   _math_matrix_viewport(&ctx->Viewport._WindowMap, 0, 0, 0, 0,
+                         0.0F, 1.0F, depthMax);
+}
+
+
+/** 
+ * Free the context viewport attribute group data.
+ * \param ctx  the GL context.
+ */
+void _mesa_free_viewport_data(GLcontext *ctx)
+{
+   _math_matrix_dtr(&ctx->Viewport._WindowMap);
+}
+
diff --git a/src/mesa/main/viewport.h b/src/mesa/main/viewport.h
new file mode 100644
index 0000000000..f08fef2797
--- /dev/null
+++ b/src/mesa/main/viewport.h
@@ -0,0 +1,52 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#ifndef VIEWPORT_H
+#define VIEWPORT_H
+
+
+extern void GLAPIENTRY
+_mesa_Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+
+
+extern void 
+_mesa_set_viewport(GLcontext *ctx, GLint x, GLint y,
+                   GLsizei width, GLsizei height);
+
+
+extern void GLAPIENTRY
+_mesa_DepthRange(GLclampd nearval, GLclampd farval);
+
+
+extern void 
+_mesa_init_viewport(GLcontext *ctx);
+
+
+extern void 
+_mesa_free_viewport_data(GLcontext *ctx);
+
+
+#endif
diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c
index 0204979003..6e0581f62d 100644
--- a/src/mesa/main/vtxfmt.c
+++ b/src/mesa/main/vtxfmt.c
@@ -27,12 +27,18 @@
  */
 
 #include "glheader.h"
+#include "api_arrayelt.h"
 #include "api_loopback.h"
 #include "context.h"
 #include "imports.h"
 #include "mtypes.h"
 #include "state.h"
 #include "vtxfmt.h"
+#include "eval.h"
+#include "dlist.h"
+
+
+#if FEATURE_beginend
 
 
 /* The neutral vertex format.  This wraps all tnl module functions,
@@ -54,9 +60,12 @@
    ASSERT( tnl->Current );						\
    ASSERT( tnl->SwapCount < NUM_VERTEX_FORMAT_ENTRIES );		\
    ASSERT( tmp_offset >= 0 );						\
-									\
-   /* Save the swapped function's dispatch entry so it can be */	\
-   /* restored later. */						\
+                                                                        \
+   if (tnl->SwapCount == 0)                                             \
+      ctx->Driver.BeginVertices( ctx );                                 \
+                                                                        \
+   /* Save the swapped function's dispatch entry so it can be */        \
+   /* restored later. */                                                \
    tnl->Swapped[tnl->SwapCount].location = & (((_glapi_proc *)ctx->Exec)[tmp_offset]); \
    tnl->Swapped[tnl->SwapCount].function = (_glapi_proc)TAG(FUNC);	\
    tnl->SwapCount++;							\
@@ -79,18 +88,16 @@
 static void
 install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt )
 {
-   SET_ArrayElement(tab, vfmt->ArrayElement);
+   _mesa_install_arrayelt_vtxfmt(tab, vfmt);
+
    SET_Color3f(tab, vfmt->Color3f);
    SET_Color3fv(tab, vfmt->Color3fv);
    SET_Color4f(tab, vfmt->Color4f);
    SET_Color4fv(tab, vfmt->Color4fv);
    SET_EdgeFlag(tab, vfmt->EdgeFlag);
-   SET_EvalCoord1f(tab, vfmt->EvalCoord1f);
-   SET_EvalCoord1fv(tab, vfmt->EvalCoord1fv);
-   SET_EvalCoord2f(tab, vfmt->EvalCoord2f);
-   SET_EvalCoord2fv(tab, vfmt->EvalCoord2fv);
-   SET_EvalPoint1(tab, vfmt->EvalPoint1);
-   SET_EvalPoint2(tab, vfmt->EvalPoint2);
+
+   _mesa_install_eval_vtxfmt(tab, vfmt);
+
    SET_FogCoordfEXT(tab, vfmt->FogCoordfEXT);
    SET_FogCoordfvEXT(tab, vfmt->FogCoordfvEXT);
    SET_Indexf(tab, vfmt->Indexf);
@@ -122,17 +129,19 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt )
    SET_Vertex3fv(tab, vfmt->Vertex3fv);
    SET_Vertex4f(tab, vfmt->Vertex4f);
    SET_Vertex4fv(tab, vfmt->Vertex4fv);
-   SET_CallList(tab, vfmt->CallList);
-   SET_CallLists(tab, vfmt->CallLists);
+
+   _mesa_install_dlist_vtxfmt(tab, vfmt);
+
    SET_Begin(tab, vfmt->Begin);
    SET_End(tab, vfmt->End);
    SET_Rectf(tab, vfmt->Rectf);
    SET_DrawArrays(tab, vfmt->DrawArrays);
    SET_DrawElements(tab, vfmt->DrawElements);
    SET_DrawRangeElements(tab, vfmt->DrawRangeElements);
-   SET_EvalMesh1(tab, vfmt->EvalMesh1);
-   SET_EvalMesh2(tab, vfmt->EvalMesh2);
-   ASSERT(tab->EvalMesh2);
+   SET_MultiDrawElementsEXT(tab, vfmt->MultiDrawElementsEXT);
+   SET_DrawElementsBaseVertex(tab, vfmt->DrawElementsBaseVertex);
+   SET_DrawRangeElementsBaseVertex(tab, vfmt->DrawRangeElementsBaseVertex);
+   SET_MultiDrawElementsBaseVertex(tab, vfmt->MultiDrawElementsBaseVertex);
 
    /* GL_NV_vertex_program */
    SET_VertexAttrib1fNV(tab, vfmt->VertexAttrib1fNV);
@@ -172,7 +181,10 @@ void _mesa_install_exec_vtxfmt( GLcontext *ctx, const GLvertexformat *vfmt )
 
 void _mesa_install_save_vtxfmt( GLcontext *ctx, const GLvertexformat *vfmt )
 {
+   /* vfmt is empty when dlist is disabled */
+#if FEATURE_dlist
    install_vtxfmt( ctx->Save, vfmt );
+#endif
 }
 
 
@@ -189,3 +201,6 @@ void _mesa_restore_exec_vtxfmt( GLcontext *ctx )
 
    tnl->SwapCount = 0;
 }
+
+
+#endif /* FEATURE_beginend */
diff --git a/src/mesa/main/vtxfmt.h b/src/mesa/main/vtxfmt.h
index 76f108e023..819a6ec218 100644
--- a/src/mesa/main/vtxfmt.h
+++ b/src/mesa/main/vtxfmt.h
@@ -33,6 +33,8 @@
 #ifndef _VTXFMT_H_
 #define _VTXFMT_H_
 
+#if FEATURE_beginend
+
 extern void _mesa_init_exec_vtxfmt( GLcontext *ctx );
 
 extern void _mesa_install_exec_vtxfmt( GLcontext *ctx, const GLvertexformat *vfmt );
@@ -40,4 +42,29 @@ extern void _mesa_install_save_vtxfmt( GLcontext *ctx, const GLvertexformat *vfm
 
 extern void _mesa_restore_exec_vtxfmt( GLcontext *ctx );
 
-#endif
+#else /* FEATURE_beginend */
+
+static INLINE void
+_mesa_init_exec_vtxfmt( GLcontext *ctx )
+{
+}
+
+static INLINE void
+_mesa_install_exec_vtxfmt( GLcontext *ctx, const GLvertexformat *vfmt )
+{
+}
+
+static INLINE void
+_mesa_install_save_vtxfmt( GLcontext *ctx, const GLvertexformat *vfmt )
+{
+}
+
+
+static INLINE void
+_mesa_restore_exec_vtxfmt( GLcontext *ctx )
+{
+}
+
+#endif /* FEATURE_beginend */
+
+#endif /* _VTXFMT_H_ */
diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h
index 6f5d01e40f..d56a2bb95e 100644
--- a/src/mesa/main/vtxfmt_tmp.h
+++ b/src/mesa/main/vtxfmt_tmp.h
@@ -335,6 +335,17 @@ static void GLAPIENTRY TAG(DrawElements)( GLenum mode, GLsizei count, GLenum typ
    CALL_DrawElements(GET_DISPATCH(), ( mode, count, type, indices ));
 }
 
+static void GLAPIENTRY TAG(MultiDrawElementsEXT)( GLenum mode,
+						  const GLsizei *count,
+						  GLenum type,
+						  const GLvoid **indices,
+						  GLsizei primcount)
+{
+   PRE_LOOPBACK( MultiDrawElementsEXT );
+   CALL_MultiDrawElementsEXT(GET_DISPATCH(), ( mode, count, type, indices,
+					       primcount ));
+}
+
 static void GLAPIENTRY TAG(DrawRangeElements)( GLenum mode, GLuint start,
 				    GLuint end, GLsizei count,
 				    GLenum type, const GLvoid *indices )
@@ -343,6 +354,44 @@ static void GLAPIENTRY TAG(DrawRangeElements)( GLenum mode, GLuint start,
    CALL_DrawRangeElements(GET_DISPATCH(), ( mode, start, end, count, type, indices ));
 }
 
+static void GLAPIENTRY TAG(DrawElementsBaseVertex)( GLenum mode,
+						    GLsizei count,
+						    GLenum type,
+						    const GLvoid *indices,
+						    GLint basevertex)
+{
+   PRE_LOOPBACK( DrawElementsBaseVertex );
+   CALL_DrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+						 indices, basevertex ));
+}
+
+static void GLAPIENTRY TAG(DrawRangeElementsBaseVertex)( GLenum mode,
+							 GLuint start,
+							 GLuint end,
+							 GLsizei count,
+							 GLenum type,
+							 const GLvoid *indices,
+							 GLint basevertex)
+{
+   PRE_LOOPBACK( DrawRangeElementsBaseVertex );
+   CALL_DrawRangeElementsBaseVertex(GET_DISPATCH(), ( mode, start, end,
+						      count, type, indices,
+						      basevertex ));
+}
+
+static void GLAPIENTRY TAG(MultiDrawElementsBaseVertex)( GLenum mode,
+							 const GLsizei *count,
+							 GLenum type,
+							 const GLvoid **indices,
+							 GLsizei primcount,
+							 const GLint *basevertex)
+{
+   PRE_LOOPBACK( MultiDrawElementsBaseVertex );
+   CALL_MultiDrawElementsBaseVertex(GET_DISPATCH(), ( mode, count, type,
+						      indices,
+						      primcount, basevertex ));
+}
+
 static void GLAPIENTRY TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
 {
    PRE_LOOPBACK( EvalMesh1 );
@@ -522,6 +571,10 @@ static GLvertexformat TAG(vtxfmt) = {
    TAG(DrawArrays),
    TAG(DrawElements),
    TAG(DrawRangeElements),
+   TAG(MultiDrawElementsEXT),
+   TAG(DrawElementsBaseVertex),
+   TAG(DrawRangeElementsBaseVertex),
+   TAG(MultiDrawElementsBaseVertex),
    TAG(EvalMesh1),
    TAG(EvalMesh2)
 };
author	Chia-I Wu <olvaffe@gmail.com>	2009-09-15 14:16:22 +0800
committer	Chia-I Wu <olvaffe@gmail.com>	2009-09-15 14:16:22 +0800
commit	e2ba90a9cc762cf00a168f0a59d31e7dc52fc42e (patch)
tree	fe3206d7602ad935296884742980f3c4d30bd867 /src/mesa/main
parent	11a4292d4eb515813b82b8d688a318adef66b3e6 (diff)
parent	b4b8800315637d9218a81c76f09df7d601710d29 (diff)