X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglx%2Fx11%2Fsingle2.c;h=d535757a9ed997b9735f61f38c0aec1f6a8cc28e;hb=4eb95ce807222bc31019b69156fab44aac72cfe7;hp=693c28df8fee2d35a115d850efa3958abb9f7682;hpb=cb3610e37c4c0a40520441b8515d044dabcc8854;p=mesa.git

diff --git a/src/glx/x11/single2.c b/src/glx/x11/single2.c
index 693c28df8fe..d535757a9ed 100644
--- a/src/glx/x11/single2.c
+++ b/src/glx/x11/single2.c
@@ -34,11 +34,13 @@
 **
 */
 
-#define NEED_GL_FUNCS_WRAPPED
 #include <stdio.h>
+#include <assert.h>
 #include "glxclient.h"
 #include "packsingle.h"
 #include "glxextensions.h"
+#include "indirect.h"
+#include "indirect_vertex_array.h"
 
 /* Used for GL_ARB_transpose_matrix */
 static void TransposeMatrixf(GLfloat m[16])
@@ -92,7 +94,28 @@ static void TransposeMatrixi(GLint m[16])
     }
 }
 
-GLenum glGetError(void)
+
+/**
+ * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
+ * that are not transpose-matrix enums are unaffected.
+ */
+static GLenum
+RemapTransposeEnum( GLenum e )
+{
+    switch( e ) {
+    case GL_TRANSPOSE_MODELVIEW_MATRIX:
+    case GL_TRANSPOSE_PROJECTION_MATRIX:
+    case GL_TRANSPOSE_TEXTURE_MATRIX:
+	return e - (GL_TRANSPOSE_MODELVIEW_MATRIX - GL_MODELVIEW_MATRIX);
+    case GL_TRANSPOSE_COLOR_MATRIX:
+	return GL_COLOR_MATRIX;
+    default:
+	return e;
+    };
+}
+
+
+GLenum __indirect_glGetError(void)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
     GLuint retval = GL_NO_ERROR;
@@ -114,58 +137,178 @@ GLenum glGetError(void)
     return retval;
 }
 
-void glGetClipPlane(GLenum plane, GLdouble *equation)
+
+/**
+ * Get the selected attribute from the client state.
+ * 
+ * \returns
+ * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
+ */
+static GLboolean
+get_client_data( __GLXcontext * gc, GLenum cap, GLintptr * data )
 {
-    __GLX_SINGLE_DECLARE_VARIABLES();
-    xGLXSingleReply reply;
-    __GLX_SINGLE_LOAD_VARIABLES();
-    __GLX_SINGLE_BEGIN(X_GLsop_GetClipPlane,4);
-    __GLX_SINGLE_PUT_LONG(0,plane);
-    __GLX_SINGLE_READ_XREPLY();
-    if (reply.length == 8) {
-	__GLX_SINGLE_GET_DOUBLE_ARRAY(equation,4);
+    GLboolean retval = GL_TRUE;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    const GLint tex_unit = __glXGetActiveTextureUnit( state );
+
+
+    switch( cap ) {
+    case GL_VERTEX_ARRAY:
+    case GL_NORMAL_ARRAY:
+    case GL_COLOR_ARRAY:
+    case GL_INDEX_ARRAY:
+    case GL_EDGE_FLAG_ARRAY:
+    case GL_SECONDARY_COLOR_ARRAY:
+    case GL_FOG_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, cap, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_NORMAL_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_NORMAL_ARRAY, 0, data );
+	break;
+    case GL_INDEX_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_INDEX_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+    case GL_FOG_COORD_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_FOG_COORD_ARRAY, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_NORMAL_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_NORMAL_ARRAY, 0, data );
+	break;
+    case GL_INDEX_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_INDEX_ARRAY, 0, data );
+	break;
+    case GL_EDGE_FLAG_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_EDGE_FLAG_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+    case GL_FOG_COORD_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_FOG_COORD_ARRAY, 0, data );
+	break;
+
+    case GL_TEXTURE_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+
+    case GL_MAX_ELEMENTS_VERTICES:
+    case GL_MAX_ELEMENTS_INDICES:
+	retval = GL_TRUE;
+	*data = ~0UL;
+	break;
+
+    
+    case GL_PACK_ROW_LENGTH:
+	*data = (GLintptr)state->storePack.rowLength;
+	break;
+    case GL_PACK_IMAGE_HEIGHT:
+	*data = (GLintptr)state->storePack.imageHeight;
+	break;
+    case GL_PACK_SKIP_ROWS:
+	*data = (GLintptr)state->storePack.skipRows;
+	break;
+    case GL_PACK_SKIP_PIXELS:
+	*data = (GLintptr)state->storePack.skipPixels;
+	break;
+    case GL_PACK_SKIP_IMAGES:
+	*data = (GLintptr)state->storePack.skipImages;
+	break;
+    case GL_PACK_ALIGNMENT:
+	*data = (GLintptr)state->storePack.alignment;
+	break;
+    case GL_PACK_SWAP_BYTES:
+	*data = (GLintptr)state->storePack.swapEndian;
+	break;
+    case GL_PACK_LSB_FIRST:
+	*data = (GLintptr)state->storePack.lsbFirst;
+	break;
+    case GL_UNPACK_ROW_LENGTH:
+	*data = (GLintptr)state->storeUnpack.rowLength;
+	break;
+    case GL_UNPACK_IMAGE_HEIGHT:
+	*data = (GLintptr)state->storeUnpack.imageHeight;
+	break;
+    case GL_UNPACK_SKIP_ROWS:
+	*data = (GLintptr)state->storeUnpack.skipRows;
+	break;
+    case GL_UNPACK_SKIP_PIXELS:
+	*data = (GLintptr)state->storeUnpack.skipPixels;
+	break;
+    case GL_UNPACK_SKIP_IMAGES:
+	*data = (GLintptr)state->storeUnpack.skipImages;
+	break;
+    case GL_UNPACK_ALIGNMENT:
+	*data = (GLintptr)state->storeUnpack.alignment;
+	break;
+    case GL_UNPACK_SWAP_BYTES:
+	*data = (GLintptr)state->storeUnpack.swapEndian;
+	break;
+    case GL_UNPACK_LSB_FIRST:
+	*data = (GLintptr)state->storeUnpack.lsbFirst;
+	break;
+    case GL_CLIENT_ATTRIB_STACK_DEPTH:
+        *data = (GLintptr)(gc->attributes.stackPointer - gc->attributes.stack);
+	break;
+    case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+	*data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
+	break;
+    case GL_CLIENT_ACTIVE_TEXTURE:
+	*data = (GLintptr)(tex_unit + GL_TEXTURE0);
+	break;
+
+    default:
+	retval = GL_FALSE;
+	break;
     }
-    __GLX_SINGLE_END();
+
+
+    return retval;
 }
 
-#define CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type) \
-    case GL_ ## enum_name ## _ARRAY: \
-      *dest = (gl_type) (IS_ARRAY_ENABLED(state, array)); break
-#define CASE_ARRAY_SIZE(enum_name,array,dest,gl_type) \
-    case GL_ ## enum_name ## _ARRAY_SIZE: \
-      *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].size ; break
-#define CASE_ARRAY_TYPE(enum_name,array,dest,gl_type) \
-    case GL_ ## enum_name ## _ARRAY_TYPE: \
-      *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].type ; break
-#define CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type) \
-    case GL_ ## enum_name ## _ARRAY_STRIDE: \
-      *dest = (gl_type) state->vertArray.arrays[array ## _ARRAY].stride ; break
-
-#define CASE_ARRAY_ALL(enum_name,array,dest,gl_type) \
-	CASE_ARRAY_ENABLE(enum_name,array,dest,gl_type); \
-	CASE_ARRAY_STRIDE(enum_name,array,dest,gl_type); \
-	CASE_ARRAY_TYPE(enum_name,array,dest,gl_type); \
-	CASE_ARRAY_SIZE(enum_name,array,dest,gl_type)
-
-void glGetBooleanv(GLenum val, GLboolean *b)
+
+void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
 {
     const GLenum origVal = val;
     __GLX_SINGLE_DECLARE_VARIABLES();
-    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
     xGLXSingleReply reply;
 
-    if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
-       val = GL_MODELVIEW_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
-       val = GL_PROJECTION_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
-       val = GL_TEXTURE_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
-       val = GL_COLOR_MATRIX;
-    }
+    val = RemapTransposeEnum( val );
 
     __GLX_SINGLE_LOAD_VARIABLES();
     __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
@@ -178,120 +321,28 @@ void glGetBooleanv(GLenum val, GLboolean *b)
 	** Error occured; don't modify user's buffer.
 	*/
     } else {
+	GLintptr data;
+
 	/*
-	** For all the queries listed here, we use the locally stored
-	** values rather than the one returned by the server.  Note that
-	** we still needed to send the request to the server in order to
+	** We still needed to send the request to the server in order to
 	** find out whether it was legal to make a query (it's illegal,
 	** for example, to call a query between glBegin() and glEnd()).
 	*/
-	switch (val) {
-	  case GL_PACK_ROW_LENGTH:
-	    *b = (GLboolean)state->storePack.rowLength;
-	    break;
-	  case GL_PACK_IMAGE_HEIGHT:
-	    *b = (GLboolean)state->storePack.imageHeight;
-	    break;
-	  case GL_PACK_SKIP_ROWS:
-	    *b = (GLboolean)state->storePack.skipRows;
-	    break;
-	  case GL_PACK_SKIP_PIXELS:
-	    *b = (GLboolean)state->storePack.skipPixels;
-	    break;
-	  case GL_PACK_SKIP_IMAGES:
-	    *b = (GLboolean)state->storePack.skipImages;
-	    break;
-	  case GL_PACK_ALIGNMENT:
-	    *b = (GLboolean)state->storePack.alignment;
-	    break;
-	  case GL_PACK_SWAP_BYTES:
-	    *b = (GLboolean)state->storePack.swapEndian;
-	    break;
-	  case GL_PACK_LSB_FIRST:
-	    *b = (GLboolean)state->storePack.lsbFirst;
-	    break;
-	  case GL_UNPACK_ROW_LENGTH:
-	    *b = (GLboolean)state->storeUnpack.rowLength;
-	    break;
-	  case GL_UNPACK_IMAGE_HEIGHT:
-	    *b = (GLboolean)state->storeUnpack.imageHeight;
-	    break;
-	  case GL_UNPACK_SKIP_ROWS:
-	    *b = (GLboolean)state->storeUnpack.skipRows;
-	    break;
-	  case GL_UNPACK_SKIP_PIXELS:
-	    *b = (GLboolean)state->storeUnpack.skipPixels;
-	    break;
-	  case GL_UNPACK_SKIP_IMAGES:
-	    *b = (GLboolean)state->storeUnpack.skipImages;
-	    break;
-	  case GL_UNPACK_ALIGNMENT:
-	    *b = (GLboolean)state->storeUnpack.alignment;
-	    break;
-	  case GL_UNPACK_SWAP_BYTES:
-	    *b = (GLboolean)state->storeUnpack.swapEndian;
-	    break;
-	  case GL_UNPACK_LSB_FIRST:
-	    *b = (GLboolean)state->storeUnpack.lsbFirst;
-	    break;
-
-	  CASE_ARRAY_ALL(VERTEX, vertex, b, GLboolean);
-
-	  CASE_ARRAY_ENABLE(NORMAL, normal, b, GLboolean);
-	  CASE_ARRAY_TYPE(NORMAL, normal, b, GLboolean);
-	  CASE_ARRAY_STRIDE(NORMAL, normal, b, GLboolean);
 
-	  CASE_ARRAY_ALL(COLOR, color, b, GLboolean);
-
-	  CASE_ARRAY_ENABLE(INDEX, index, b, GLboolean);
-	  CASE_ARRAY_TYPE(INDEX, index, b, GLboolean);
-	  CASE_ARRAY_STRIDE(INDEX, index, b, GLboolean);
-
-	  case GL_TEXTURE_COORD_ARRAY:
-	    *b = (GLboolean)IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_SIZE:
-	    *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].size;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_TYPE:
-	    *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].type;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_STRIDE:
-	    *b = (GLboolean)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
-	    break;
-
-	  CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, b, GLboolean);
-	  CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, b, GLboolean);
-
-	  CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, b, GLboolean);
-
-	  CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, b, GLboolean);
-	  CASE_ARRAY_TYPE(FOG_COORD, fogCoord, b, GLboolean);
-	  CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, b, GLboolean);
-
-	  case GL_MAX_ELEMENTS_VERTICES:
-	    *b = (GLboolean)state->vertArray.maxElementsVertices;
-	    break;
-	  case GL_MAX_ELEMENTS_INDICES:
-	    *b = (GLboolean)state->vertArray.maxElementsIndices;
-	    break;
-	  case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-	    *b = (GLboolean)__GL_CLIENT_ATTRIB_STACK_DEPTH;
-	    break;
-	  case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-	    *b = (GLboolean)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
-	    break;
-	  default:
+	if ( get_client_data( gc, val, & data ) ) {
+	    *b = (GLboolean) data;
+	}
+	else {
 	    /*
-	    ** Not a local value, so use what we got from the server.
-	    */
+	     ** Not a local value, so use what we got from the server.
+	     */
 	    if (compsize == 1) {
 		__GLX_SINGLE_GET_CHAR(b);
 	    } else {
 		__GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
-                if (val != origVal) {
-                   /* matrix transpose */
-                   TransposeMatrixb(b);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixb(b);
                 }
 	    }
 	}
@@ -299,25 +350,13 @@ void glGetBooleanv(GLenum val, GLboolean *b)
     __GLX_SINGLE_END();
 }
 
-void glGetDoublev(GLenum val, GLdouble *d)
+void __indirect_glGetDoublev(GLenum val, GLdouble *d)
 {
     const GLenum origVal = val;
     __GLX_SINGLE_DECLARE_VARIABLES();
-    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
     xGLXSingleReply reply;
 
-    if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
-       val = GL_MODELVIEW_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
-       val = GL_PROJECTION_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
-       val = GL_TEXTURE_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
-       val = GL_COLOR_MATRIX;
-    }
+    val = RemapTransposeEnum( val );
 
     __GLX_SINGLE_LOAD_VARIABLES();
     __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
@@ -330,110 +369,18 @@ void glGetDoublev(GLenum val, GLdouble *d)
 	** Error occured; don't modify user's buffer.
 	*/
     } else {
+	GLintptr data;
+
 	/*
-	** For all the queries listed here, we use the locally stored
-	** values rather than the one returned by the server.  Note that
-	** we still needed to send the request to the server in order to
+	** We still needed to send the request to the server in order to
 	** find out whether it was legal to make a query (it's illegal,
 	** for example, to call a query between glBegin() and glEnd()).
 	*/
-	switch (val) {
-	  case GL_PACK_ROW_LENGTH:
-	    *d = (GLdouble)state->storePack.rowLength;
-	    break;
-	  case GL_PACK_IMAGE_HEIGHT:
-	    *d = (GLdouble)state->storePack.imageHeight;
-	    break;
-	  case GL_PACK_SKIP_ROWS:
-	    *d = (GLdouble)state->storePack.skipRows;
-	    break;
-	  case GL_PACK_SKIP_PIXELS:
-	    *d = (GLdouble)state->storePack.skipPixels;
-	    break;
-	  case GL_PACK_SKIP_IMAGES:
-	    *d = (GLdouble)state->storePack.skipImages;
-	    break;
-	  case GL_PACK_ALIGNMENT:
-	    *d = (GLdouble)state->storePack.alignment;
-	    break;
-	  case GL_PACK_SWAP_BYTES:
-	    *d = (GLdouble)state->storePack.swapEndian;
-	    break;
-	  case GL_PACK_LSB_FIRST:
-	    *d = (GLdouble)state->storePack.lsbFirst;
-	    break;
-	  case GL_UNPACK_ROW_LENGTH:
-	    *d = (GLdouble)state->storeUnpack.rowLength;
-	    break;
-	  case GL_UNPACK_IMAGE_HEIGHT:
-	    *d = (GLdouble)state->storeUnpack.imageHeight;
-	    break;
-	  case GL_UNPACK_SKIP_ROWS:
-	    *d = (GLdouble)state->storeUnpack.skipRows;
-	    break;
-	  case GL_UNPACK_SKIP_PIXELS:
-	    *d = (GLdouble)state->storeUnpack.skipPixels;
-	    break;
-	  case GL_UNPACK_SKIP_IMAGES:
-	    *d = (GLdouble)state->storeUnpack.skipImages;
-	    break;
-	  case GL_UNPACK_ALIGNMENT:
-	    *d = (GLdouble)state->storeUnpack.alignment;
-	    break;
-	  case GL_UNPACK_SWAP_BYTES:
-	    *d = (GLdouble)state->storeUnpack.swapEndian;
-	    break;
-	  case GL_UNPACK_LSB_FIRST:
-	    *d = (GLdouble)state->storeUnpack.lsbFirst;
-	    break;
-
-	  CASE_ARRAY_ALL(VERTEX, vertex, d, GLdouble);
 
-	  CASE_ARRAY_ENABLE(NORMAL, normal, d, GLdouble);
-	  CASE_ARRAY_TYPE(NORMAL, normal, d, GLdouble);
-	  CASE_ARRAY_STRIDE(NORMAL, normal, d, GLdouble);
-
-	  CASE_ARRAY_ALL(COLOR, color, d, GLdouble);
-
-	  CASE_ARRAY_ENABLE(INDEX, index, d, GLdouble);
-	  CASE_ARRAY_TYPE(INDEX, index, d, GLdouble);
-	  CASE_ARRAY_STRIDE(INDEX, index, d, GLdouble);
-
-	  case GL_TEXTURE_COORD_ARRAY:
-	    *d = (GLdouble) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_SIZE:
-	    *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].size;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_TYPE:
-	    *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].type;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_STRIDE:
-	    *d = (GLdouble)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
-	    break;
-
-	  CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, d, GLdouble);
-	  CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, d, GLdouble);
-
-	  CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, d, GLdouble);
-
-	  CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, d, GLdouble);
-	  CASE_ARRAY_TYPE(FOG_COORD, fogCoord, d, GLdouble);
-	  CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, d, GLdouble);
-
-	  case GL_MAX_ELEMENTS_VERTICES:
-	    *d = (GLdouble)state->vertArray.maxElementsVertices;
-	    break;
-	  case GL_MAX_ELEMENTS_INDICES:
-	    *d = (GLdouble)state->vertArray.maxElementsIndices;
-	    break;
-	  case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-	    *d = (GLdouble)__GL_CLIENT_ATTRIB_STACK_DEPTH;
-	    break;
-	  case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-	    *d = (GLdouble)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
-	    break;
-	  default:
+	if ( get_client_data( gc, val, & data ) ) {
+	    *d = (GLdouble) data;
+	}
+	else {
 	    /*
 	     ** Not a local value, so use what we got from the server.
 	     */
@@ -441,35 +388,23 @@ void glGetDoublev(GLenum val, GLdouble *d)
 		__GLX_SINGLE_GET_DOUBLE(d);
 	    } else {
 		__GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
-                if (val != origVal) {
-                   /* matrix transpose */
-                   TransposeMatrixd(d);
-                }
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixd(d);
+		}
 	    }
 	}
     }
     __GLX_SINGLE_END();
 }
 
-void glGetFloatv(GLenum val, GLfloat *f)
+void __indirect_glGetFloatv(GLenum val, GLfloat *f)
 {
     const GLenum origVal = val;
     __GLX_SINGLE_DECLARE_VARIABLES();
-    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
     xGLXSingleReply reply;
 
-    if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
-       val = GL_MODELVIEW_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
-       val = GL_PROJECTION_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
-       val = GL_TEXTURE_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
-       val = GL_COLOR_MATRIX;
-    }
+    val = RemapTransposeEnum( val );
 
     __GLX_SINGLE_LOAD_VARIABLES();
     __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
@@ -482,120 +417,28 @@ void glGetFloatv(GLenum val, GLfloat *f)
 	** Error occured; don't modify user's buffer.
 	*/
     } else {
+	GLintptr data;
+
 	/*
-	** For all the queries listed here, we use the locally stored
-	** values rather than the one returned by the server.  Note that
-	** we still needed to send the request to the server in order to
+	** We still needed to send the request to the server in order to
 	** find out whether it was legal to make a query (it's illegal,
 	** for example, to call a query between glBegin() and glEnd()).
 	*/
-	switch (val) {
-	  case GL_PACK_ROW_LENGTH:
-	    *f = (GLfloat)state->storePack.rowLength;
-	    break;
-	  case GL_PACK_IMAGE_HEIGHT:
-	    *f = (GLfloat)state->storePack.imageHeight;
-	    break;
-	  case GL_PACK_SKIP_ROWS:
-	    *f = (GLfloat)state->storePack.skipRows;
-	    break;
-	  case GL_PACK_SKIP_PIXELS:
-	    *f = (GLfloat)state->storePack.skipPixels;
-	    break;
-	  case GL_PACK_SKIP_IMAGES:
-	    *f = (GLfloat)state->storePack.skipImages;
-	    break;
-	  case GL_PACK_ALIGNMENT:
-	    *f = (GLfloat)state->storePack.alignment;
-	    break;
-	  case GL_PACK_SWAP_BYTES:
-	    *f = (GLfloat)state->storePack.swapEndian;
-	    break;
-	  case GL_PACK_LSB_FIRST:
-	    *f = (GLfloat)state->storePack.lsbFirst;
-	    break;
-	  case GL_UNPACK_ROW_LENGTH:
-	    *f = (GLfloat)state->storeUnpack.rowLength;
-	    break;
-	  case GL_UNPACK_IMAGE_HEIGHT:
-	    *f = (GLfloat)state->storeUnpack.imageHeight;
-	    break;
-	  case GL_UNPACK_SKIP_ROWS:
-	    *f = (GLfloat)state->storeUnpack.skipRows;
-	    break;
-	  case GL_UNPACK_SKIP_PIXELS:
-	    *f = (GLfloat)state->storeUnpack.skipPixels;
-	    break;
-	  case GL_UNPACK_SKIP_IMAGES:
-	    *f = (GLfloat)state->storeUnpack.skipImages;
-	    break;
-	  case GL_UNPACK_ALIGNMENT:
-	    *f = (GLfloat)state->storeUnpack.alignment;
-	    break;
-	  case GL_UNPACK_SWAP_BYTES:
-	    *f = (GLfloat)state->storeUnpack.swapEndian;
-	    break;
-	  case GL_UNPACK_LSB_FIRST:
-	    *f = (GLfloat)state->storeUnpack.lsbFirst;
-	    break;
-
-	  CASE_ARRAY_ALL(VERTEX, vertex, f, GLfloat);
-
-	  CASE_ARRAY_ENABLE(NORMAL, normal, f, GLfloat);
-	  CASE_ARRAY_TYPE(NORMAL, normal, f, GLfloat);
-	  CASE_ARRAY_STRIDE(NORMAL, normal, f, GLfloat);
-
-	  CASE_ARRAY_ALL(COLOR, color, f, GLfloat);
-
-	  CASE_ARRAY_ENABLE(INDEX, index, f, GLfloat);
-	  CASE_ARRAY_TYPE(INDEX, index, f, GLfloat);
-	  CASE_ARRAY_STRIDE(INDEX, index, f, GLfloat);
 
-	  case GL_TEXTURE_COORD_ARRAY:
-	    *f = (GLfloat) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_SIZE:
-	    *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].size;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_TYPE:
-	    *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].type;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_STRIDE:
-	    *f = (GLfloat)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
-	    break;
-
-	  CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, f, GLfloat);
-	  CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, f, GLfloat);
-
-	  CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, f, GLfloat);
-
-	  CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, f, GLfloat);
-	  CASE_ARRAY_TYPE(FOG_COORD, fogCoord, f, GLfloat);
-	  CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, f, GLfloat);
-
-	  case GL_MAX_ELEMENTS_VERTICES:
-	    *f = (GLfloat)state->vertArray.maxElementsVertices;
-	    break;
-	  case GL_MAX_ELEMENTS_INDICES:
-	    *f = (GLfloat)state->vertArray.maxElementsIndices;
-	    break;
-	  case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-	    *f = (GLfloat)__GL_CLIENT_ATTRIB_STACK_DEPTH;
-	    break;
-	  case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-	    *f = (GLfloat)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
-	    break;
-	  default:
+	if ( get_client_data( gc, val, & data ) ) {
+	    *f = (GLfloat) data;
+	}
+	else {
 	    /*
-	    ** Not a local value, so use what we got from the server.
-	    */
+	     ** Not a local value, so use what we got from the server.
+	     */
 	    if (compsize == 1) {
 		__GLX_SINGLE_GET_FLOAT(f);
 	    } else {
 		__GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
-                if (val != origVal) {
-                   /* matrix transpose */
-                   TransposeMatrixf(f);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixf(f);
                 }
 	    }
 	}
@@ -603,25 +446,13 @@ void glGetFloatv(GLenum val, GLfloat *f)
     __GLX_SINGLE_END();
 }
 
-void glGetIntegerv(GLenum val, GLint *i)
+void __indirect_glGetIntegerv(GLenum val, GLint *i)
 {
     const GLenum origVal = val;
     __GLX_SINGLE_DECLARE_VARIABLES();
-    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
     xGLXSingleReply reply;
 
-    if (val == GL_TRANSPOSE_MODELVIEW_MATRIX_ARB) {
-       val = GL_MODELVIEW_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_PROJECTION_MATRIX_ARB) {
-       val = GL_PROJECTION_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_TEXTURE_MATRIX_ARB) {
-       val = GL_TEXTURE_MATRIX;
-    }
-    else if (val == GL_TRANSPOSE_COLOR_MATRIX_ARB) {
-       val = GL_COLOR_MATRIX;
-    }
+    val = RemapTransposeEnum( val );
 
     __GLX_SINGLE_LOAD_VARIABLES();
     __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
@@ -634,120 +465,28 @@ void glGetIntegerv(GLenum val, GLint *i)
 	** Error occured; don't modify user's buffer.
 	*/
     } else {
+	GLintptr data;
+
 	/*
-	** For all the queries listed here, we use the locally stored
-	** values rather than the one returned by the server.  Note that
-	** we still needed to send the request to the server in order to
+	** We still needed to send the request to the server in order to
 	** find out whether it was legal to make a query (it's illegal,
 	** for example, to call a query between glBegin() and glEnd()).
 	*/
-	switch (val) {
-	  case GL_PACK_ROW_LENGTH:
-	    *i = (GLint)state->storePack.rowLength;
-	    break;
-	  case GL_PACK_IMAGE_HEIGHT:
-	    *i = (GLint)state->storePack.imageHeight;
-	    break;
-	  case GL_PACK_SKIP_ROWS:
-	    *i = (GLint)state->storePack.skipRows;
-	    break;
-	  case GL_PACK_SKIP_PIXELS:
-	    *i = (GLint)state->storePack.skipPixels;
-	    break;
-	  case GL_PACK_SKIP_IMAGES:
-	    *i = (GLint)state->storePack.skipImages;
-	    break;
-	  case GL_PACK_ALIGNMENT:
-	    *i = (GLint)state->storePack.alignment;
-	    break;
-	  case GL_PACK_SWAP_BYTES:
-	    *i = (GLint)state->storePack.swapEndian;
-	    break;
-	  case GL_PACK_LSB_FIRST:
-	    *i = (GLint)state->storePack.lsbFirst;
-	    break;
-	  case GL_UNPACK_ROW_LENGTH:
-	    *i = (GLint)state->storeUnpack.rowLength;
-	    break;
-	  case GL_UNPACK_IMAGE_HEIGHT:
-	    *i = (GLint)state->storeUnpack.imageHeight;
-	    break;
-	  case GL_UNPACK_SKIP_ROWS:
-	    *i = (GLint)state->storeUnpack.skipRows;
-	    break;
-	  case GL_UNPACK_SKIP_PIXELS:
-	    *i = (GLint)state->storeUnpack.skipPixels;
-	    break;
-	  case GL_UNPACK_SKIP_IMAGES:
-	    *i = (GLint)state->storeUnpack.skipImages;
-	    break;
-	  case GL_UNPACK_ALIGNMENT:
-	    *i = (GLint)state->storeUnpack.alignment;
-	    break;
-	  case GL_UNPACK_SWAP_BYTES:
-	    *i = (GLint)state->storeUnpack.swapEndian;
-	    break;
-	  case GL_UNPACK_LSB_FIRST:
-	    *i = (GLint)state->storeUnpack.lsbFirst;
-	    break;
-
-	  CASE_ARRAY_ALL(VERTEX, vertex, i, GLint);
 
-	  CASE_ARRAY_ENABLE(NORMAL, normal, i, GLint);
-	  CASE_ARRAY_TYPE(NORMAL, normal, i, GLint);
-	  CASE_ARRAY_STRIDE(NORMAL, normal, i, GLint);
-
-	  CASE_ARRAY_ALL(COLOR, color, i, GLint);
-
-	  CASE_ARRAY_ENABLE(INDEX, index, i, GLint);
-	  CASE_ARRAY_TYPE(INDEX, index, i, GLint);
-	  CASE_ARRAY_STRIDE(INDEX, index, i, GLint);
-
-	  case GL_TEXTURE_COORD_ARRAY:
-	    *i = (GLint) IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_SIZE:
-	    *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].size;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_TYPE:
-	    *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].type;
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY_STRIDE:
-	    *i = (GLint)state->vertArray.texCoord[state->vertArray.activeTexture].stride;
-	    break;
-
-	  CASE_ARRAY_ENABLE(EDGE_FLAG, edgeFlag, i, GLint);
-	  CASE_ARRAY_STRIDE(EDGE_FLAG, edgeFlag, i, GLint);
-
-	  CASE_ARRAY_ALL(SECONDARY_COLOR, secondaryColor, i, GLint);
-
-	  CASE_ARRAY_ENABLE(FOG_COORD, fogCoord, i, GLint);
-	  CASE_ARRAY_TYPE(FOG_COORD, fogCoord, i, GLint);
-	  CASE_ARRAY_STRIDE(FOG_COORD, fogCoord, i, GLint);
-
-	  case GL_MAX_ELEMENTS_VERTICES:
-	    *i = (GLint)state->vertArray.maxElementsVertices;
-	    break;
-	  case GL_MAX_ELEMENTS_INDICES:
-	    *i = (GLint)state->vertArray.maxElementsIndices;
-	    break;
-	  case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-	    *i = (GLint)__GL_CLIENT_ATTRIB_STACK_DEPTH;
-	    break;
-	  case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-	    *i = (GLint)(state->vertArray.activeTexture + GL_TEXTURE0_ARB);
-	    break;
-	  default:
+	if ( get_client_data( gc, val, & data ) ) {
+	    *i = (GLint) data;
+	}
+	else {
 	    /*
-	    ** Not a local value, so use what we got from the server.
-	    */
+	     ** Not a local value, so use what we got from the server.
+	     */
 	    if (compsize == 1) {
 		__GLX_SINGLE_GET_LONG(i);
 	    } else {
 		__GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
-                if (val != origVal) {
-                   /* matrix transpose */
-                   TransposeMatrixi(i);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixi(i);
                 }
 	    }
 	}
@@ -758,7 +497,7 @@ void glGetIntegerv(GLenum val, GLint *i)
 /*
 ** Send all pending commands to server.
 */
-void glFlush(void)
+void __indirect_glFlush(void)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
 
@@ -772,7 +511,7 @@ void glFlush(void)
     XFlush(dpy);
 }
 
-void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
 
@@ -787,7 +526,7 @@ void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
     gc->feedbackBuf = buffer;
 }
 
-void glSelectBuffer(GLsizei numnames, GLuint *buffer)
+void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
 
@@ -801,7 +540,7 @@ void glSelectBuffer(GLsizei numnames, GLuint *buffer)
     gc->selectBuf = buffer;
 }
 
-GLint glRenderMode(GLenum mode)
+GLint __indirect_glRenderMode(GLenum mode)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
     GLint retval = 0;
@@ -838,7 +577,7 @@ GLint glRenderMode(GLenum mode)
     return retval;
 }
 
-void glFinish(void)
+void __indirect_glFinish(void)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
     xGLXSingleReply reply;
@@ -868,7 +607,7 @@ version_from_string( const char * ver,
 }
 
 
-const GLubyte *glGetString(GLenum name)
+const GLubyte *__indirect_glGetString(GLenum name)
 {
     __GLXcontext *gc = __glXGetCurrentContext();
     Display *dpy = gc->currentDpy;
@@ -1013,32 +752,34 @@ const GLubyte *glGetString(GLenum name)
     return s;
 }
 
-GLboolean glIsEnabled(GLenum cap)
+GLboolean __indirect_glIsEnabled(GLenum cap)
 {
     __GLX_SINGLE_DECLARE_VARIABLES();
     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
     xGLXSingleReply reply;
     GLboolean retval = 0;
+    GLintptr enable;
 
     if (!dpy) return 0;
 
     switch(cap) {
-      case GL_VERTEX_ARRAY:
-	  return IS_ARRAY_ENABLED(state, vertex);
-      case GL_NORMAL_ARRAY:
-	  return IS_ARRAY_ENABLED(state, normal);
-      case GL_COLOR_ARRAY:
-	  return IS_ARRAY_ENABLED(state, color);
-      case GL_INDEX_ARRAY:
-	  return IS_ARRAY_ENABLED(state, index);
-      case GL_TEXTURE_COORD_ARRAY:
-	  return IS_TEXARRAY_ENABLED(state, state->vertArray.activeTexture);
-      case GL_EDGE_FLAG_ARRAY:
-	  return IS_ARRAY_ENABLED(state, edgeFlag);
-      case GL_SECONDARY_COLOR_ARRAY:
-	  return IS_ARRAY_ENABLED(state, secondaryColor);
-      case GL_FOG_COORD_ARRAY:
-	  return IS_ARRAY_ENABLED(state, fogCoord);
+    case GL_VERTEX_ARRAY:
+    case GL_NORMAL_ARRAY:
+    case GL_COLOR_ARRAY:
+    case GL_INDEX_ARRAY:
+    case GL_EDGE_FLAG_ARRAY:
+    case GL_SECONDARY_COLOR_ARRAY:
+    case GL_FOG_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, cap, 0, & enable );
+	assert( retval );
+	return (GLboolean) enable;
+	break;
+    case GL_TEXTURE_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY,
+				      __glXGetActiveTextureUnit( state ), & enable );
+	assert( retval );
+	return (GLboolean) enable;
+	break;
     }
 
     __GLX_SINGLE_LOAD_VARIABLES();
@@ -1050,7 +791,7 @@ GLboolean glIsEnabled(GLenum cap)
     return retval;
 }
 
-void glGetPointerv(GLenum pname, void **params)
+void __indirect_glGetPointerv(GLenum pname, void **params)
 {
     __GLXcontext *gc = __glXGetCurrentContext();
     __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
@@ -1059,37 +800,32 @@ void glGetPointerv(GLenum pname, void **params)
     if (!dpy) return;
 
     switch(pname) {
-      case GL_VERTEX_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ vertex_ARRAY ].ptr;
-	  return;
-      case GL_NORMAL_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ normal_ARRAY ].ptr;
-	  return;
-      case GL_COLOR_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ color_ARRAY ].ptr;
-	  return;
-      case GL_INDEX_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ index_ARRAY ].ptr;
-	  return;
-      case GL_TEXTURE_COORD_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.texCoord[state->vertArray.activeTexture].ptr;
-	  return;
-      case GL_EDGE_FLAG_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ edgeFlag_ARRAY ].ptr;
+    case GL_VERTEX_ARRAY_POINTER:
+    case GL_NORMAL_ARRAY_POINTER:
+    case GL_COLOR_ARRAY_POINTER:
+    case GL_INDEX_ARRAY_POINTER:
+    case GL_EDGE_FLAG_ARRAY_POINTER:
+	__glXGetArrayPointer( state, pname - GL_VERTEX_ARRAY_POINTER 
+			      + GL_VERTEX_ARRAY,
+			      0, params );
 	return;
-      case GL_SECONDARY_COLOR_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ secondaryColor_ARRAY ].ptr;
+    case GL_TEXTURE_COORD_ARRAY_POINTER:
+	__glXGetArrayPointer( state, GL_TEXTURE_COORD_ARRAY, 
+			      __glXGetActiveTextureUnit( state ), params );
 	return;
-      case GL_FOG_COORD_ARRAY_POINTER:
-	  *params = (void *)state->vertArray.arrays[ fogCoord_ARRAY ].ptr;
+    case GL_SECONDARY_COLOR_ARRAY_POINTER:
+    case GL_FOG_COORD_ARRAY_POINTER:
+	__glXGetArrayPointer( state, pname - GL_FOG_COORD_ARRAY_POINTER
+			      + GL_FOG_COORD_ARRAY, 
+			      0, params );
 	return;
-      case GL_FEEDBACK_BUFFER_POINTER:
+    case GL_FEEDBACK_BUFFER_POINTER:
 	*params = (void *)gc->feedbackBuf;
 	return;
-      case GL_SELECTION_BUFFER_POINTER:
+    case GL_SELECTION_BUFFER_POINTER:
 	*params = (void *)gc->selectBuf;
 	return;
-      default:
+    default:
 	__glXSetError(gc, GL_INVALID_ENUM);
 	return;
     }