Attachment 2416 Details for Bug 2996 – Make server-side GLX use autogenerated dispatch code, version 02

[patch] Make server-side GLX use autogenerated dispatch code, version 02

Xorg-dispatch-02.patch (text/plain), 462.32 KB, created by Ian Romanick on 2005-04-13 15:28:35 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ian Romanick

Created: 2005-04-13 15:28:35 UTC

Size: 462.32 KB

patch

obsolete

>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab.c Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab.c	2005-04-12 20:56:34.000000000 -0700
>@@ -32,6 +32,8 @@
> #include "glxserver.h"
> #include "glxext.h"
> #include "g_disptab.h"
>+#include "indirect_dispatch.h"
>+
> __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
> 	__glXNoSuchSingleOpcode,
> 	__glXRender,
>@@ -427,7 +429,7 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXDisp_SampleCoverageARB,
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_WindowPos3fARB /* 230 */
>+	__glXDisp_WindowPos3fvMESA /* 230 */
> #else
> 	__glXNoSuchRenderOpcode
> #endif
>@@ -828,7 +830,7 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXDispSwap_SampleCoverageARB,
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_WindowPos3fARB /* 230 */
>+	__glXDispSwap_WindowPos3fvMESA /* 230 */
> #else
> 	__glXNoSuchRenderOpcode
> #endif
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab_EXT.c Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab_EXT.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab_EXT.c	2005-04-12 19:57:51.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab_EXT.c	2005-04-12 20:59:31.000000000 -0700
>@@ -32,6 +32,8 @@
> #include "glxserver.h"
> #include "glxext.h"
> #include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+
> __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
> 	__glXDisp_ColorTable, /* 2053 */
> 	__glXDisp_ColorTableParameterfv, /* 2054 */
>@@ -46,8 +48,8 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_PointParameterfARB, /* 2065 */
>-	__glXDisp_PointParameterfvARB, /* 2066 */
>+	__glXDisp_PointParameterfEXT, /* 2065 */
>+	__glXDisp_PointParameterfvEXT, /* 2066 */
> #else
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
>@@ -2101,7 +2103,7 @@
> 	__glXDisp_ResetMinmax,
> 	__glXDisp_TexImage3D,
> 	__glXDisp_TexSubImage3D,
>-	__glXDisp_DrawArraysEXT,
>+	__glXDisp_DrawArrays,
> 	__glXDisp_BindTexture,
> 	__glXDisp_PrioritizeTextures,
> 	__glXDisp_CopyTexImage1D,
>@@ -2110,17 +2112,17 @@
> 	__glXDisp_CopyTexSubImage2D,  /* 4122 */
> 	__glXDisp_CopyTexSubImage3D,  /* 4123 */
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_FogCoordfv,         /* 4124 */
>-	__glXDisp_FogCoorddv,         /* 4125 */
>-	__glXDisp_SecondaryColor3bv,  /* 4126 */
>-	__glXDisp_SecondaryColor3sv,  /* 4127 */
>-	__glXDisp_SecondaryColor3iv,  /* 4128 */
>-	__glXDisp_SecondaryColor3fv,  /* 4129 */
>-	__glXDisp_SecondaryColor3dv,  /* 4130 */
>-	__glXDisp_SecondaryColor3ubv, /* 4131 */
>-	__glXDisp_SecondaryColor3usv, /* 4132 */
>-	__glXDisp_SecondaryColor3uiv, /* 4133 */
>-	__glXDisp_BlendFuncSeparate,  /* 4134 */
>+	__glXDisp_FogCoordfvEXT,      /* 4124 */
>+	__glXDisp_FogCoorddvEXT,      /* 4125 */
>+	__glXDisp_SecondaryColor3bvEXT, /* 4126 */
>+	__glXDisp_SecondaryColor3svEXT, /* 4127 */
>+	__glXDisp_SecondaryColor3ivEXT, /* 4128 */
>+	__glXDisp_SecondaryColor3fvEXT, /* 4129 */
>+	__glXDisp_SecondaryColor3dvEXT, /* 4130 */
>+	__glXDisp_SecondaryColor3ubvEXT,/* 4131 */
>+	__glXDisp_SecondaryColor3usvEXT,/* 4132 */
>+	__glXDisp_SecondaryColor3uivEXT,/* 4133 */
>+	__glXDisp_BlendFuncSeparateEXT, /* 4134 */
> #else
> 	__glXNoSuchRenderOpcode,      /* 4124 */
> 	__glXNoSuchRenderOpcode,      /* 4125 */
>@@ -2231,7 +2233,7 @@
> };
> __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
> 	__glXDisp_AreTexturesResidentEXT, /* 11 */
>-	__glXDisp_DeleteTexturesEXT, /* 12 */
>+	__glXDisp_DeleteTextures, /* 12 */
> 	__glXDisp_GenTexturesEXT, /* 13 */
> 	__glXDisp_IsTextureEXT, /* 14 */
> };
>@@ -2251,8 +2253,8 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_PointParameterfARB, /* 2065 */
>-	__glXDispSwap_PointParameterfvARB, /* 2066 */
>+	__glXDispSwap_PointParameterfEXT, /* 2065 */
>+	__glXDispSwap_PointParameterfvEXT, /* 2066 */
> #else
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
>@@ -4306,7 +4308,7 @@
> 	__glXDispSwap_ResetMinmax,
> 	__glXDispSwap_TexImage3D,
> 	__glXDispSwap_TexSubImage3D,
>-	__glXDispSwap_DrawArraysEXT,
>+	__glXDispSwap_DrawArrays,
> 	__glXDispSwap_BindTexture,
> 	__glXDispSwap_PrioritizeTextures,
> 	__glXDispSwap_CopyTexImage1D,
>@@ -4315,17 +4317,17 @@
> 	__glXDispSwap_CopyTexSubImage2D,  /* 4122 */
> 	__glXDispSwap_CopyTexSubImage3D,  /* 4123 */
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_FogCoordfv,         /* 4124 */
>-	__glXDispSwap_FogCoorddv,         /* 4125 */
>-	__glXDispSwap_SecondaryColor3bv,  /* 4126 */
>-	__glXDispSwap_SecondaryColor3sv,  /* 4127 */
>-	__glXDispSwap_SecondaryColor3iv,  /* 4128 */
>-	__glXDispSwap_SecondaryColor3fv,  /* 4129 */
>-	__glXDispSwap_SecondaryColor3dv,  /* 4130 */
>-	__glXDispSwap_SecondaryColor3ubv, /* 4131 */
>-	__glXDispSwap_SecondaryColor3usv, /* 4132 */
>-	__glXDispSwap_SecondaryColor3uiv, /* 4133 */
>-	__glXDisp_BlendFuncSeparate,      /* 4134 */
>+	__glXDispSwap_FogCoordfvEXT,        /* 4124 */
>+	__glXDispSwap_FogCoorddvEXT,        /* 4125 */
>+	__glXDispSwap_SecondaryColor3bvEXT, /* 4126 */
>+	__glXDispSwap_SecondaryColor3svEXT, /* 4127 */
>+	__glXDispSwap_SecondaryColor3ivEXT, /* 4128 */
>+	__glXDispSwap_SecondaryColor3fvEXT, /* 4129 */
>+	__glXDispSwap_SecondaryColor3dvEXT, /* 4130 */
>+	__glXDispSwap_SecondaryColor3ubvEXT,/* 4131 */
>+	__glXDispSwap_SecondaryColor3usvEXT,/* 4132 */
>+	__glXDispSwap_SecondaryColor3uivEXT,/* 4133 */
>+	__glXDisp_BlendFuncSeparateEXT,     /* 4134 */
> #else
> 	__glXNoSuchRenderOpcode,          /* 4124 */
> 	__glXNoSuchRenderOpcode,          /* 4125 */
>@@ -4436,7 +4438,7 @@
> };
> __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
> 	__glXDispSwap_AreTexturesResidentEXT, /* 11 */
>-	__glXDispSwap_DeleteTexturesEXT, /* 12 */
>+	__glXDispSwap_DeleteTextures, /* 12 */
> 	__glXDispSwap_GenTexturesEXT, /* 13 */
> 	__glXDispSwap_IsTextureEXT, /* 14 */
> };
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab_EXT.h Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab_EXT.h
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab_EXT.h	2005-04-12 19:57:43.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab_EXT.h	2005-04-12 20:52:24.000000000 -0700
>@@ -31,117 +31,6 @@
> ** version 1.2.1 Specification.
> */
> 
>-extern int __glXDisp_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsTextureEXT(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDisp_ColorTable(GLbyte*);
>-extern void __glXDisp_ColorTableParameterfv(GLbyte*);
>-extern void __glXDisp_ColorTableParameteriv(GLbyte*);
>-extern void __glXDisp_CopyColorTable(GLbyte*);
>-extern void __glXDisp_BlendColor(GLbyte*);
>-extern void __glXDisp_BlendEquation(GLbyte*);
>-extern void __glXDisp_TexSubImage1D(GLbyte*);
>-extern void __glXDisp_TexSubImage2D(GLbyte*);
>-extern void __glXDisp_ConvolutionFilter1D(GLbyte*);
>-extern void __glXDisp_ConvolutionFilter2D(GLbyte*);
>-extern void __glXDisp_ConvolutionParameterf(GLbyte*);
>-extern void __glXDisp_ConvolutionParameterfv(GLbyte*);
>-extern void __glXDisp_ConvolutionParameteri(GLbyte*);
>-extern void __glXDisp_ConvolutionParameteriv(GLbyte*);
>-extern void __glXDisp_CopyConvolutionFilter1D(GLbyte*);
>-extern void __glXDisp_CopyConvolutionFilter2D(GLbyte*);
>-extern void __glXDisp_SeparableFilter2D(GLbyte*);
>-extern void __glXDisp_Histogram(GLbyte*);
>-extern void __glXDisp_Minmax(GLbyte*);
>-extern void __glXDisp_ResetHistogram(GLbyte*);
>-extern void __glXDisp_ResetMinmax(GLbyte*);
>-extern void __glXDisp_TexImage3D(GLbyte*);
>-extern void __glXDisp_TexSubImage3D(GLbyte*);
>-extern void __glXDisp_DrawArraysEXT(GLbyte*);
>-extern void __glXDisp_BindTexture(GLbyte*);
>-extern void __glXDisp_PrioritizeTextures(GLbyte*);
>-extern void __glXDisp_CopyTexImage1D(GLbyte*);
>-extern void __glXDisp_CopyTexImage2D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage1D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage2D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage3D(GLbyte*);
>-extern void __glXDisp_PointParameterfARB(GLbyte*);
>-extern void __glXDisp_PointParameterfvARB(GLbyte*);
>-
>-extern void __glXDisp_FogCoordfv(GLbyte *);
>-extern void __glXDisp_FogCoorddv(GLbyte *);
>-extern void __glXDispSwap_FogCoordfv(GLbyte *);
>-extern void __glXDispSwap_FogCoorddv(GLbyte *);
>-
>-extern void __glXDisp_SecondaryColor3bv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3sv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3iv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3ubv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3usv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3uiv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3fv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3dv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3bv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3sv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3iv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3ubv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3usv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3uiv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3fv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3dv(GLbyte *);
>-
>-extern void __glXDisp_BlendFuncSeparate(GLbyte *);
>-extern void __glXDispSwap_BlendFuncSeparate(GLbyte *);
>-
>-extern void __glXDisp_PointParameteriNV(GLbyte *);
>-extern void __glXDisp_PointParameterivNV(GLbyte *);
>-extern void __glXDispSwap_PointParameteriNV(GLbyte *);
>-extern void __glXDispSwap_PointParameterivNV(GLbyte *);
>-
>-extern void __glXDisp_ActiveStencilFaceEXT(GLbyte*);
>-
>-extern int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsTextureEXT(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDispSwap_ColorTable(GLbyte*);
>-extern void __glXDispSwap_ColorTableParameterfv(GLbyte*);
>-extern void __glXDispSwap_ColorTableParameteriv(GLbyte*);
>-extern void __glXDispSwap_CopyColorTable(GLbyte*);
>-extern void __glXDispSwap_BlendColor(GLbyte*);
>-extern void __glXDispSwap_BlendEquation(GLbyte*);
>-extern void __glXDispSwap_TexSubImage1D(GLbyte*);
>-extern void __glXDispSwap_TexSubImage2D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionFilter1D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionFilter2D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameterf(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameterfv(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameteri(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameteriv(GLbyte*);
>-extern void __glXDispSwap_CopyConvolutionFilter1D(GLbyte*);
>-extern void __glXDispSwap_CopyConvolutionFilter2D(GLbyte*);
>-extern void __glXDispSwap_SeparableFilter2D(GLbyte*);
>-extern void __glXDispSwap_Histogram(GLbyte*);
>-extern void __glXDispSwap_Minmax(GLbyte*);
>-extern void __glXDispSwap_ResetHistogram(GLbyte*);
>-extern void __glXDispSwap_ResetMinmax(GLbyte*);
>-extern void __glXDispSwap_TexImage3D(GLbyte*);
>-extern void __glXDispSwap_TexSubImage3D(GLbyte*);
>-extern void __glXDispSwap_DrawArraysEXT(GLbyte*);
>-extern void __glXDispSwap_BindTexture(GLbyte*);
>-extern void __glXDispSwap_PrioritizeTextures(GLbyte*);
>-extern void __glXDispSwap_CopyTexImage1D(GLbyte*);
>-extern void __glXDispSwap_CopyTexImage2D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage1D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage2D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage3D(GLbyte*);
>-extern void __glXDispSwap_PointParameterfARB(GLbyte*);
>-extern void __glXDispSwap_PointParameterfvARB(GLbyte*);
>-extern void __glXDispSwap_ActiveStencilFaceEXT(GLbyte*);
>-
> #define __GLX_MIN_RENDER_OPCODE_EXT 2053
> #define __GLX_MAX_RENDER_OPCODE_EXT 4222
> #define __GLX_MIN_VENDPRIV_OPCODE_EXT 11
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab.h Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab.h
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_disptab.h	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_disptab.h	2005-04-12 20:53:16.000000000 -0700
>@@ -56,281 +56,6 @@
> extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
> extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
> 
>-extern int __glXDisp_NewList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_EndList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteLists(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenLists(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_FeedbackBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_SelectBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_RenderMode(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_Finish(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_PixelStoref(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_PixelStorei(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_ReadPixels(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetBooleanv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetClipPlane(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetDoublev(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetError(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetFloatv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetIntegerv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetLightfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetLightiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapdv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMaterialfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMaterialiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapuiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapusv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPolygonStipple(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetString(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexEnvfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexEnviv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGendv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGenfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGeniv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexImage(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsEnabled(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_Flush(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_AreTexturesResident(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsTexture(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTable(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetSeparableFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogram(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmax(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDisp_CallList(GLbyte*);
>-extern void __glXDisp_CallLists(GLbyte*);
>-extern void __glXDisp_ListBase(GLbyte*);
>-extern void __glXDisp_Begin(GLbyte*);
>-extern void __glXDisp_Bitmap(GLbyte*);
>-extern void __glXDisp_Color3bv(GLbyte*);
>-extern void __glXDisp_Color3dv(GLbyte*);
>-extern void __glXDisp_Color3fv(GLbyte*);
>-extern void __glXDisp_Color3iv(GLbyte*);
>-extern void __glXDisp_Color3sv(GLbyte*);
>-extern void __glXDisp_Color3ubv(GLbyte*);
>-extern void __glXDisp_Color3uiv(GLbyte*);
>-extern void __glXDisp_Color3usv(GLbyte*);
>-extern void __glXDisp_Color4bv(GLbyte*);
>-extern void __glXDisp_Color4dv(GLbyte*);
>-extern void __glXDisp_Color4fv(GLbyte*);
>-extern void __glXDisp_Color4iv(GLbyte*);
>-extern void __glXDisp_Color4sv(GLbyte*);
>-extern void __glXDisp_Color4ubv(GLbyte*);
>-extern void __glXDisp_Color4uiv(GLbyte*);
>-extern void __glXDisp_Color4usv(GLbyte*);
>-extern void __glXDisp_EdgeFlagv(GLbyte*);
>-extern void __glXDisp_End(GLbyte*);
>-extern void __glXDisp_Indexdv(GLbyte*);
>-extern void __glXDisp_Indexfv(GLbyte*);
>-extern void __glXDisp_Indexiv(GLbyte*);
>-extern void __glXDisp_Indexsv(GLbyte*);
>-extern void __glXDisp_Normal3bv(GLbyte*);
>-extern void __glXDisp_Normal3dv(GLbyte*);
>-extern void __glXDisp_Normal3fv(GLbyte*);
>-extern void __glXDisp_Normal3iv(GLbyte*);
>-extern void __glXDisp_Normal3sv(GLbyte*);
>-extern void __glXDisp_RasterPos2dv(GLbyte*);
>-extern void __glXDisp_RasterPos2fv(GLbyte*);
>-extern void __glXDisp_RasterPos2iv(GLbyte*);
>-extern void __glXDisp_RasterPos2sv(GLbyte*);
>-extern void __glXDisp_RasterPos3dv(GLbyte*);
>-extern void __glXDisp_RasterPos3fv(GLbyte*);
>-extern void __glXDisp_RasterPos3iv(GLbyte*);
>-extern void __glXDisp_RasterPos3sv(GLbyte*);
>-extern void __glXDisp_RasterPos4dv(GLbyte*);
>-extern void __glXDisp_RasterPos4fv(GLbyte*);
>-extern void __glXDisp_RasterPos4iv(GLbyte*);
>-extern void __glXDisp_RasterPos4sv(GLbyte*);
>-extern void __glXDisp_Rectdv(GLbyte*);
>-extern void __glXDisp_Rectfv(GLbyte*);
>-extern void __glXDisp_Rectiv(GLbyte*);
>-extern void __glXDisp_Rectsv(GLbyte*);
>-extern void __glXDisp_TexCoord1dv(GLbyte*);
>-extern void __glXDisp_TexCoord1fv(GLbyte*);
>-extern void __glXDisp_TexCoord1iv(GLbyte*);
>-extern void __glXDisp_TexCoord1sv(GLbyte*);
>-extern void __glXDisp_TexCoord2dv(GLbyte*);
>-extern void __glXDisp_TexCoord2fv(GLbyte*);
>-extern void __glXDisp_TexCoord2iv(GLbyte*);
>-extern void __glXDisp_TexCoord2sv(GLbyte*);
>-extern void __glXDisp_TexCoord3dv(GLbyte*);
>-extern void __glXDisp_TexCoord3fv(GLbyte*);
>-extern void __glXDisp_TexCoord3iv(GLbyte*);
>-extern void __glXDisp_TexCoord3sv(GLbyte*);
>-extern void __glXDisp_TexCoord4dv(GLbyte*);
>-extern void __glXDisp_TexCoord4fv(GLbyte*);
>-extern void __glXDisp_TexCoord4iv(GLbyte*);
>-extern void __glXDisp_TexCoord4sv(GLbyte*);
>-extern void __glXDisp_Vertex2dv(GLbyte*);
>-extern void __glXDisp_Vertex2fv(GLbyte*);
>-extern void __glXDisp_Vertex2iv(GLbyte*);
>-extern void __glXDisp_Vertex2sv(GLbyte*);
>-extern void __glXDisp_Vertex3dv(GLbyte*);
>-extern void __glXDisp_Vertex3fv(GLbyte*);
>-extern void __glXDisp_Vertex3iv(GLbyte*);
>-extern void __glXDisp_Vertex3sv(GLbyte*);
>-extern void __glXDisp_Vertex4dv(GLbyte*);
>-extern void __glXDisp_Vertex4fv(GLbyte*);
>-extern void __glXDisp_Vertex4iv(GLbyte*);
>-extern void __glXDisp_Vertex4sv(GLbyte*);
>-extern void __glXDisp_ClipPlane(GLbyte*);
>-extern void __glXDisp_ColorMaterial(GLbyte*);
>-extern void __glXDisp_CullFace(GLbyte*);
>-extern void __glXDisp_Fogf(GLbyte*);
>-extern void __glXDisp_Fogfv(GLbyte*);
>-extern void __glXDisp_Fogi(GLbyte*);
>-extern void __glXDisp_Fogiv(GLbyte*);
>-extern void __glXDisp_FrontFace(GLbyte*);
>-extern void __glXDisp_Hint(GLbyte*);
>-extern void __glXDisp_Lightf(GLbyte*);
>-extern void __glXDisp_Lightfv(GLbyte*);
>-extern void __glXDisp_Lighti(GLbyte*);
>-extern void __glXDisp_Lightiv(GLbyte*);
>-extern void __glXDisp_LightModelf(GLbyte*);
>-extern void __glXDisp_LightModelfv(GLbyte*);
>-extern void __glXDisp_LightModeli(GLbyte*);
>-extern void __glXDisp_LightModeliv(GLbyte*);
>-extern void __glXDisp_LineStipple(GLbyte*);
>-extern void __glXDisp_LineWidth(GLbyte*);
>-extern void __glXDisp_Materialf(GLbyte*);
>-extern void __glXDisp_Materialfv(GLbyte*);
>-extern void __glXDisp_Materiali(GLbyte*);
>-extern void __glXDisp_Materialiv(GLbyte*);
>-extern void __glXDisp_PointSize(GLbyte*);
>-extern void __glXDisp_PolygonMode(GLbyte*);
>-extern void __glXDisp_PolygonStipple(GLbyte*);
>-extern void __glXDisp_Scissor(GLbyte*);
>-extern void __glXDisp_ShadeModel(GLbyte*);
>-extern void __glXDisp_TexParameterf(GLbyte*);
>-extern void __glXDisp_TexParameterfv(GLbyte*);
>-extern void __glXDisp_TexParameteri(GLbyte*);
>-extern void __glXDisp_TexParameteriv(GLbyte*);
>-extern void __glXDisp_TexImage1D(GLbyte*);
>-extern void __glXDisp_TexImage2D(GLbyte*);
>-extern void __glXDisp_TexEnvf(GLbyte*);
>-extern void __glXDisp_TexEnvfv(GLbyte*);
>-extern void __glXDisp_TexEnvi(GLbyte*);
>-extern void __glXDisp_TexEnviv(GLbyte*);
>-extern void __glXDisp_TexGend(GLbyte*);
>-extern void __glXDisp_TexGendv(GLbyte*);
>-extern void __glXDisp_TexGenf(GLbyte*);
>-extern void __glXDisp_TexGenfv(GLbyte*);
>-extern void __glXDisp_TexGeni(GLbyte*);
>-extern void __glXDisp_TexGeniv(GLbyte*);
>-extern void __glXDisp_InitNames(GLbyte*);
>-extern void __glXDisp_LoadName(GLbyte*);
>-extern void __glXDisp_PassThrough(GLbyte*);
>-extern void __glXDisp_PopName(GLbyte*);
>-extern void __glXDisp_PushName(GLbyte*);
>-extern void __glXDisp_DrawBuffer(GLbyte*);
>-extern void __glXDisp_Clear(GLbyte*);
>-extern void __glXDisp_ClearAccum(GLbyte*);
>-extern void __glXDisp_ClearIndex(GLbyte*);
>-extern void __glXDisp_ClearColor(GLbyte*);
>-extern void __glXDisp_ClearStencil(GLbyte*);
>-extern void __glXDisp_ClearDepth(GLbyte*);
>-extern void __glXDisp_StencilMask(GLbyte*);
>-extern void __glXDisp_ColorMask(GLbyte*);
>-extern void __glXDisp_DepthMask(GLbyte*);
>-extern void __glXDisp_IndexMask(GLbyte*);
>-extern void __glXDisp_Accum(GLbyte*);
>-extern void __glXDisp_Disable(GLbyte*);
>-extern void __glXDisp_Enable(GLbyte*);
>-extern void __glXDisp_PopAttrib(GLbyte*);
>-extern void __glXDisp_PushAttrib(GLbyte*);
>-extern void __glXDisp_Map1d(GLbyte*);
>-extern void __glXDisp_Map1f(GLbyte*);
>-extern void __glXDisp_Map2d(GLbyte*);
>-extern void __glXDisp_Map2f(GLbyte*);
>-extern void __glXDisp_MapGrid1d(GLbyte*);
>-extern void __glXDisp_MapGrid1f(GLbyte*);
>-extern void __glXDisp_MapGrid2d(GLbyte*);
>-extern void __glXDisp_MapGrid2f(GLbyte*);
>-extern void __glXDisp_EvalCoord1dv(GLbyte*);
>-extern void __glXDisp_EvalCoord1fv(GLbyte*);
>-extern void __glXDisp_EvalCoord2dv(GLbyte*);
>-extern void __glXDisp_EvalCoord2fv(GLbyte*);
>-extern void __glXDisp_EvalMesh1(GLbyte*);
>-extern void __glXDisp_EvalPoint1(GLbyte*);
>-extern void __glXDisp_EvalMesh2(GLbyte*);
>-extern void __glXDisp_EvalPoint2(GLbyte*);
>-extern void __glXDisp_AlphaFunc(GLbyte*);
>-extern void __glXDisp_BlendFunc(GLbyte*);
>-extern void __glXDisp_LogicOp(GLbyte*);
>-extern void __glXDisp_StencilFunc(GLbyte*);
>-extern void __glXDisp_StencilOp(GLbyte*);
>-extern void __glXDisp_DepthFunc(GLbyte*);
>-extern void __glXDisp_PixelZoom(GLbyte*);
>-extern void __glXDisp_PixelTransferf(GLbyte*);
>-extern void __glXDisp_PixelTransferi(GLbyte*);
>-extern void __glXDisp_PixelMapfv(GLbyte*);
>-extern void __glXDisp_PixelMapuiv(GLbyte*);
>-extern void __glXDisp_PixelMapusv(GLbyte*);
>-extern void __glXDisp_ReadBuffer(GLbyte*);
>-extern void __glXDisp_CopyPixels(GLbyte*);
>-extern void __glXDisp_DrawPixels(GLbyte*);
>-extern void __glXDisp_DepthRange(GLbyte*);
>-extern void __glXDisp_Frustum(GLbyte*);
>-extern void __glXDisp_LoadIdentity(GLbyte*);
>-extern void __glXDisp_LoadMatrixf(GLbyte*);
>-extern void __glXDisp_LoadMatrixd(GLbyte*);
>-extern void __glXDisp_MatrixMode(GLbyte*);
>-extern void __glXDisp_MultMatrixf(GLbyte*);
>-extern void __glXDisp_MultMatrixd(GLbyte*);
>-extern void __glXDisp_Ortho(GLbyte*);
>-extern void __glXDisp_PopMatrix(GLbyte*);
>-extern void __glXDisp_PushMatrix(GLbyte*);
>-extern void __glXDisp_Rotated(GLbyte*);
>-extern void __glXDisp_Rotatef(GLbyte*);
>-extern void __glXDisp_Scaled(GLbyte*);
>-extern void __glXDisp_Scalef(GLbyte*);
>-extern void __glXDisp_Translated(GLbyte*);
>-extern void __glXDisp_Translatef(GLbyte*);
>-extern void __glXDisp_Viewport(GLbyte*);
>-extern void __glXDisp_PolygonOffset(GLbyte*);
>-extern void __glXDisp_DrawArrays(GLbyte*);
>-extern void __glXDisp_Indexubv(GLbyte*);
>-extern void __glXDisp_ColorSubTable(GLbyte*);
>-extern void __glXDisp_CopyColorSubTable(GLbyte*);
>-extern void __glXDisp_ActiveTextureARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4svARB(GLbyte*);
>-extern void __glXDisp_SampleCoverageARB(GLbyte *);
>-extern void __glXDisp_WindowPos3fARB(GLbyte *);
>-
> extern int __glXSwapRender(__GLXclientState*, GLbyte*);
> extern int __glXSwapRenderLarge(__GLXclientState*, GLbyte*);
> extern int __glXSwapCreateContext(__GLXclientState*, GLbyte*);
>@@ -356,281 +81,6 @@
> extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
> extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
> 
>-extern int __glXDispSwap_NewList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_EndList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteLists(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenLists(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_FeedbackBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_SelectBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_RenderMode(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_Finish(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_PixelStoref(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_PixelStorei(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_ReadPixels(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetBooleanv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetClipPlane(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetDoublev(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetError(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetFloatv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetIntegerv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetLightfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetLightiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapdv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMaterialfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMaterialiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapuiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapusv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPolygonStipple(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetString(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexEnvfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexEnviv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGendv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGenfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGeniv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexImage(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsEnabled(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_Flush(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_AreTexturesResident(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsTexture(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTable(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetSeparableFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogram(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmax(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDispSwap_CallList(GLbyte*);
>-extern void __glXDispSwap_CallLists(GLbyte*);
>-extern void __glXDispSwap_ListBase(GLbyte*);
>-extern void __glXDispSwap_Begin(GLbyte*);
>-extern void __glXDispSwap_Bitmap(GLbyte*);
>-extern void __glXDispSwap_Color3bv(GLbyte*);
>-extern void __glXDispSwap_Color3dv(GLbyte*);
>-extern void __glXDispSwap_Color3fv(GLbyte*);
>-extern void __glXDispSwap_Color3iv(GLbyte*);
>-extern void __glXDispSwap_Color3sv(GLbyte*);
>-extern void __glXDispSwap_Color3ubv(GLbyte*);
>-extern void __glXDispSwap_Color3uiv(GLbyte*);
>-extern void __glXDispSwap_Color3usv(GLbyte*);
>-extern void __glXDispSwap_Color4bv(GLbyte*);
>-extern void __glXDispSwap_Color4dv(GLbyte*);
>-extern void __glXDispSwap_Color4fv(GLbyte*);
>-extern void __glXDispSwap_Color4iv(GLbyte*);
>-extern void __glXDispSwap_Color4sv(GLbyte*);
>-extern void __glXDispSwap_Color4ubv(GLbyte*);
>-extern void __glXDispSwap_Color4uiv(GLbyte*);
>-extern void __glXDispSwap_Color4usv(GLbyte*);
>-extern void __glXDispSwap_EdgeFlagv(GLbyte*);
>-extern void __glXDispSwap_End(GLbyte*);
>-extern void __glXDispSwap_Indexdv(GLbyte*);
>-extern void __glXDispSwap_Indexfv(GLbyte*);
>-extern void __glXDispSwap_Indexiv(GLbyte*);
>-extern void __glXDispSwap_Indexsv(GLbyte*);
>-extern void __glXDispSwap_Normal3bv(GLbyte*);
>-extern void __glXDispSwap_Normal3dv(GLbyte*);
>-extern void __glXDispSwap_Normal3fv(GLbyte*);
>-extern void __glXDispSwap_Normal3iv(GLbyte*);
>-extern void __glXDispSwap_Normal3sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4sv(GLbyte*);
>-extern void __glXDispSwap_Rectdv(GLbyte*);
>-extern void __glXDispSwap_Rectfv(GLbyte*);
>-extern void __glXDispSwap_Rectiv(GLbyte*);
>-extern void __glXDispSwap_Rectsv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4sv(GLbyte*);
>-extern void __glXDispSwap_Vertex2dv(GLbyte*);
>-extern void __glXDispSwap_Vertex2fv(GLbyte*);
>-extern void __glXDispSwap_Vertex2iv(GLbyte*);
>-extern void __glXDispSwap_Vertex2sv(GLbyte*);
>-extern void __glXDispSwap_Vertex3dv(GLbyte*);
>-extern void __glXDispSwap_Vertex3fv(GLbyte*);
>-extern void __glXDispSwap_Vertex3iv(GLbyte*);
>-extern void __glXDispSwap_Vertex3sv(GLbyte*);
>-extern void __glXDispSwap_Vertex4dv(GLbyte*);
>-extern void __glXDispSwap_Vertex4fv(GLbyte*);
>-extern void __glXDispSwap_Vertex4iv(GLbyte*);
>-extern void __glXDispSwap_Vertex4sv(GLbyte*);
>-extern void __glXDispSwap_ClipPlane(GLbyte*);
>-extern void __glXDispSwap_ColorMaterial(GLbyte*);
>-extern void __glXDispSwap_CullFace(GLbyte*);
>-extern void __glXDispSwap_Fogf(GLbyte*);
>-extern void __glXDispSwap_Fogfv(GLbyte*);
>-extern void __glXDispSwap_Fogi(GLbyte*);
>-extern void __glXDispSwap_Fogiv(GLbyte*);
>-extern void __glXDispSwap_FrontFace(GLbyte*);
>-extern void __glXDispSwap_Hint(GLbyte*);
>-extern void __glXDispSwap_Lightf(GLbyte*);
>-extern void __glXDispSwap_Lightfv(GLbyte*);
>-extern void __glXDispSwap_Lighti(GLbyte*);
>-extern void __glXDispSwap_Lightiv(GLbyte*);
>-extern void __glXDispSwap_LightModelf(GLbyte*);
>-extern void __glXDispSwap_LightModelfv(GLbyte*);
>-extern void __glXDispSwap_LightModeli(GLbyte*);
>-extern void __glXDispSwap_LightModeliv(GLbyte*);
>-extern void __glXDispSwap_LineStipple(GLbyte*);
>-extern void __glXDispSwap_LineWidth(GLbyte*);
>-extern void __glXDispSwap_Materialf(GLbyte*);
>-extern void __glXDispSwap_Materialfv(GLbyte*);
>-extern void __glXDispSwap_Materiali(GLbyte*);
>-extern void __glXDispSwap_Materialiv(GLbyte*);
>-extern void __glXDispSwap_PointSize(GLbyte*);
>-extern void __glXDispSwap_PolygonMode(GLbyte*);
>-extern void __glXDispSwap_PolygonStipple(GLbyte*);
>-extern void __glXDispSwap_Scissor(GLbyte*);
>-extern void __glXDispSwap_ShadeModel(GLbyte*);
>-extern void __glXDispSwap_TexParameterf(GLbyte*);
>-extern void __glXDispSwap_TexParameterfv(GLbyte*);
>-extern void __glXDispSwap_TexParameteri(GLbyte*);
>-extern void __glXDispSwap_TexParameteriv(GLbyte*);
>-extern void __glXDispSwap_TexImage1D(GLbyte*);
>-extern void __glXDispSwap_TexImage2D(GLbyte*);
>-extern void __glXDispSwap_TexEnvf(GLbyte*);
>-extern void __glXDispSwap_TexEnvfv(GLbyte*);
>-extern void __glXDispSwap_TexEnvi(GLbyte*);
>-extern void __glXDispSwap_TexEnviv(GLbyte*);
>-extern void __glXDispSwap_TexGend(GLbyte*);
>-extern void __glXDispSwap_TexGendv(GLbyte*);
>-extern void __glXDispSwap_TexGenf(GLbyte*);
>-extern void __glXDispSwap_TexGenfv(GLbyte*);
>-extern void __glXDispSwap_TexGeni(GLbyte*);
>-extern void __glXDispSwap_TexGeniv(GLbyte*);
>-extern void __glXDispSwap_InitNames(GLbyte*);
>-extern void __glXDispSwap_LoadName(GLbyte*);
>-extern void __glXDispSwap_PassThrough(GLbyte*);
>-extern void __glXDispSwap_PopName(GLbyte*);
>-extern void __glXDispSwap_PushName(GLbyte*);
>-extern void __glXDispSwap_DrawBuffer(GLbyte*);
>-extern void __glXDispSwap_Clear(GLbyte*);
>-extern void __glXDispSwap_ClearAccum(GLbyte*);
>-extern void __glXDispSwap_ClearIndex(GLbyte*);
>-extern void __glXDispSwap_ClearColor(GLbyte*);
>-extern void __glXDispSwap_ClearStencil(GLbyte*);
>-extern void __glXDispSwap_ClearDepth(GLbyte*);
>-extern void __glXDispSwap_StencilMask(GLbyte*);
>-extern void __glXDispSwap_ColorMask(GLbyte*);
>-extern void __glXDispSwap_DepthMask(GLbyte*);
>-extern void __glXDispSwap_IndexMask(GLbyte*);
>-extern void __glXDispSwap_Accum(GLbyte*);
>-extern void __glXDispSwap_Disable(GLbyte*);
>-extern void __glXDispSwap_Enable(GLbyte*);
>-extern void __glXDispSwap_PopAttrib(GLbyte*);
>-extern void __glXDispSwap_PushAttrib(GLbyte*);
>-extern void __glXDispSwap_Map1d(GLbyte*);
>-extern void __glXDispSwap_Map1f(GLbyte*);
>-extern void __glXDispSwap_Map2d(GLbyte*);
>-extern void __glXDispSwap_Map2f(GLbyte*);
>-extern void __glXDispSwap_MapGrid1d(GLbyte*);
>-extern void __glXDispSwap_MapGrid1f(GLbyte*);
>-extern void __glXDispSwap_MapGrid2d(GLbyte*);
>-extern void __glXDispSwap_MapGrid2f(GLbyte*);
>-extern void __glXDispSwap_EvalCoord1dv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord1fv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord2dv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord2fv(GLbyte*);
>-extern void __glXDispSwap_EvalMesh1(GLbyte*);
>-extern void __glXDispSwap_EvalPoint1(GLbyte*);
>-extern void __glXDispSwap_EvalMesh2(GLbyte*);
>-extern void __glXDispSwap_EvalPoint2(GLbyte*);
>-extern void __glXDispSwap_AlphaFunc(GLbyte*);
>-extern void __glXDispSwap_BlendFunc(GLbyte*);
>-extern void __glXDispSwap_LogicOp(GLbyte*);
>-extern void __glXDispSwap_StencilFunc(GLbyte*);
>-extern void __glXDispSwap_StencilOp(GLbyte*);
>-extern void __glXDispSwap_DepthFunc(GLbyte*);
>-extern void __glXDispSwap_PixelZoom(GLbyte*);
>-extern void __glXDispSwap_PixelTransferf(GLbyte*);
>-extern void __glXDispSwap_PixelTransferi(GLbyte*);
>-extern void __glXDispSwap_PixelMapfv(GLbyte*);
>-extern void __glXDispSwap_PixelMapuiv(GLbyte*);
>-extern void __glXDispSwap_PixelMapusv(GLbyte*);
>-extern void __glXDispSwap_ReadBuffer(GLbyte*);
>-extern void __glXDispSwap_CopyPixels(GLbyte*);
>-extern void __glXDispSwap_DrawPixels(GLbyte*);
>-extern void __glXDispSwap_DepthRange(GLbyte*);
>-extern void __glXDispSwap_Frustum(GLbyte*);
>-extern void __glXDispSwap_LoadIdentity(GLbyte*);
>-extern void __glXDispSwap_LoadMatrixf(GLbyte*);
>-extern void __glXDispSwap_LoadMatrixd(GLbyte*);
>-extern void __glXDispSwap_MatrixMode(GLbyte*);
>-extern void __glXDispSwap_MultMatrixf(GLbyte*);
>-extern void __glXDispSwap_MultMatrixd(GLbyte*);
>-extern void __glXDispSwap_Ortho(GLbyte*);
>-extern void __glXDispSwap_PopMatrix(GLbyte*);
>-extern void __glXDispSwap_PushMatrix(GLbyte*);
>-extern void __glXDispSwap_Rotated(GLbyte*);
>-extern void __glXDispSwap_Rotatef(GLbyte*);
>-extern void __glXDispSwap_Scaled(GLbyte*);
>-extern void __glXDispSwap_Scalef(GLbyte*);
>-extern void __glXDispSwap_Translated(GLbyte*);
>-extern void __glXDispSwap_Translatef(GLbyte*);
>-extern void __glXDispSwap_Viewport(GLbyte*);
>-extern void __glXDispSwap_PolygonOffset(GLbyte*);
>-extern void __glXDispSwap_DrawArrays(GLbyte*);
>-extern void __glXDispSwap_Indexubv(GLbyte*);
>-extern void __glXDispSwap_ColorSubTable(GLbyte*);
>-extern void __glXDispSwap_CopyColorSubTable(GLbyte*);
>-extern void __glXDispSwap_ActiveTextureARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4svARB(GLbyte*);
>-extern void __glXDispSwap_SampleCoverageARB(GLbyte *);
>-extern void __glXDispSwap_WindowPos3fARB(GLbyte *);
>-
> #define __GLX_MIN_GLXCMD_OPCODE 1
> #define __GLX_MAX_GLXCMD_OPCODE 20
> #define __GLX_MIN_RENDER_OPCODE 1
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/glxcmds.c Xorg-dispatch/xc/programs/Xserver/GL/glx/glxcmds.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/glxcmds.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/glxcmds.c	2005-04-12 21:29:13.000000000 -0700
>@@ -48,6 +48,9 @@
> #include "glxext.h"
> #include "GL/glx_ansic.h"
> #include "glcontextmodes.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> /************************************************************************/
> 
>@@ -612,7 +615,7 @@
> 	*/
> 	if (__GLX_HAS_UNFLUSHED_CMDS(prevglxc)) {
> 	    if (__glXForceCurrent(cl, tag, (int *)&error)) {
>-		glFlush();
>+		GL_CALL(Flush)();
> 		__GLX_NOTE_FLUSHED_CMDS(prevglxc);
> 	    } else {
> 		return error;
>@@ -798,7 +801,7 @@
>     if (!__glXForceCurrent(cl, req->contextTag, &error)) {
> 	return error;
>     }
>-    glFinish();
>+    GL_CALL(Finish)();
>     return Success;
> }
> 
>@@ -884,7 +887,7 @@
> 	    ** Do whatever is needed to make sure that all preceding requests
> 	    ** in both streams are completed before the copy is executed.
> 	    */
>-	    glFinish();
>+	    GL_CALL(Finish)();
> 	    __GLX_NOTE_FLUSHED_CMDS(tagcx);
> 	} else {
> 	    return error;
>@@ -1313,7 +1316,7 @@
> 	    ** Do whatever is needed to make sure that all preceding requests
> 	    ** in both streams are completed before the swap is executed.
> 	    */
>-	    glFinish();
>+	    GL_CALL(Finish)();
> 	    __GLX_NOTE_FLUSHED_CMDS(glxc);
> 	} else {
> 	    return error;
>@@ -1734,11 +1737,11 @@
> #ifndef __DARWIN__
>     switch( vendorcode ) {
>     case X_GLvop_SampleMaskSGIS:
>-	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
>+	GL_CALL(SampleMaskSGIS)(*(GLfloat *)(pc + 4),
> 			 *(GLboolean *)(pc + 8));
> 	return Success;
>     case X_GLvop_SamplePatternSGIS:
>-	glSamplePatternSGIS( *(GLenum *)(pc + 4));
>+	GL_CALL(SamplePatternSGIS)( *(GLenum *)(pc + 4));
> 	return Success;
>     }
> #endif
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/glxcmdsswap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/glxcmdsswap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/glxcmdsswap.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/glxcmdsswap.c	2005-04-12 21:30:12.000000000 -0700
>@@ -46,6 +46,9 @@
> #include <windowstr.h>
> #include "glxext.h"
> #include "GL/glx_ansic.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
> static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
>@@ -809,12 +812,12 @@
>     case X_GLvop_SampleMaskSGIS:
> 	__GLX_SWAP_FLOAT(pc + 4);
> 	__GLX_SWAP_INT(pc + 8);
>-	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
>+	GL_CALL(SampleMaskSGIS)(*(GLfloat *)(pc + 4),
> 			 *(GLboolean *)(pc + 8));
> 	return Success;
>     case X_GLvop_SamplePatternSGIS:
> 	__GLX_SWAP_INT(pc + 4);
>-	glSamplePatternSGIS( *(GLenum *)(pc + 4));
>+	GL_CALL(SamplePatternSGIS)( *(GLenum *)(pc + 4));
> 	return Success;
>     }
> #endif
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/glxserver.h Xorg-dispatch/xc/programs/Xserver/GL/glx/glxserver.h
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/glxserver.h	2005-04-12 16:11:17.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/glxserver.h	2005-04-13 15:18:23.000000000 -0700
>@@ -80,6 +80,13 @@
> #define False 0
> #endif
> 
>+#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
>+#    define HIDDEN  __attribute__((visibility("hidden")))
>+#  else
>+#    define HIDDEN
>+#  endif
>+
>+
> /*
> ** GLX resources.
> */
>@@ -174,7 +181,7 @@
>  */
> typedef struct {
>     int bytes;
>-    int (*varsize)(GLbyte *pc, Bool swap);
>+    int (*varsize)(const GLbyte *pc, Bool swap);
> } __GLXrenderSizeData;
> extern __GLXrenderSizeData __glXRenderSizeTable[];
> extern __GLXrenderSizeData __glXRenderSizeTable_EXT[];
>@@ -220,10 +227,22 @@
>  * Routines for computing the size of variably-sized rendering commands.
>  */
> 
>-extern int __glXTypeSize(GLenum enm);
>-extern int __glXImageSize(GLenum format, GLenum type,
>+HIDDEN extern int __glXTypeSize(GLenum enm);
>+HIDDEN extern int __glXImageSize(GLenum format, GLenum type,
>     GLenum target, GLsizei w, GLsizei h, GLsizei d,
>     GLint imageHeight, GLint rowLength, GLint skipImages, GLint skipRows,
>     GLint alignment);
> 
>+HIDDEN extern void * __glXGetAnswerBuffer(
>+     __GLXclientState * cl, size_t required_size, void * local_buffer,
>+     size_t local_size, unsigned alignment );
>+
>+HIDDEN extern void __glXSendReply(
>+    ClientPtr client, const void * data, size_t elements, size_t element_size,
>+    GLboolean always_array, CARD32 retval );
>+
>+HIDDEN extern void __glXSendReplySwap(
>+    ClientPtr client, const void * data, size_t elements, size_t element_size,
>+    GLboolean always_array, CARD32 retval );
>+
> #endif /* !__GLX_server_h__ */
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_single.c Xorg-dispatch/xc/programs/Xserver/GL/glx/g_single.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_single.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_single.c	2005-04-12 21:27:40.000000000 -0700
>@@ -36,6 +36,9 @@
> #include "unpack.h"
> #include "impsize.h"
> #include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -172,7 +175,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
> 	__glXClearErrorOccured();
>-	glGetBooleanv( 
>+	GL_CALL(GetBooleanv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLboolean *) answer
> 	);
>@@ -215,7 +218,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
> 	__glXClearErrorOccured();
>-	glGetDoublev( 
>+	GL_CALL(GetDoublev)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLdouble *) answer
> 	);
>@@ -279,7 +282,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetFloatv( 
>+	GL_CALL(GetFloatv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLfloat  *) answer
> 	);
>@@ -322,7 +325,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetIntegerv( 
>+	GL_CALL(GetIntegerv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLint    *) answer
> 	);
>@@ -547,7 +550,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetMapiv( 
>+	GL_CALL(GetMapiv)( 
> 		*(GLenum   *)(pc + 0),
> 		*(GLenum   *)(pc + 4),
> 		(GLint    *) answer
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/g_singleswap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/g_singleswap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/g_singleswap.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/g_singleswap.c	2005-04-12 21:27:46.000000000 -0700
>@@ -36,6 +36,9 @@
> #include "unpack.h"
> #include "impsize.h"
> #include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -198,7 +201,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
> 	__glXClearErrorOccured();
>-	glGetBooleanv( 
>+	GL_CALL(GetBooleanv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLboolean *) answer
> 	);
>@@ -250,7 +253,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
> 	__glXClearErrorOccured();
>-	glGetDoublev( 
>+	GL_CALL(GetDoublev)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLdouble *) answer
> 	);
>@@ -328,7 +331,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetFloatv( 
>+	GL_CALL(GetFloatv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLfloat  *) answer
> 	);
>@@ -381,7 +384,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetIntegerv( 
>+	GL_CALL(GetIntegerv)( 
> 		*(GLenum   *)(pc + 0),
> 		(GLint    *) answer
> 	);
>@@ -661,7 +664,7 @@
> 
> 	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
> 	__glXClearErrorOccured();
>-	glGetMapiv( 
>+	GL_CALL(GetMapiv)( 
> 		*(GLenum   *)(pc + 0),
> 		*(GLenum   *)(pc + 4),
> 		(GLint    *) answer
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/glx/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/Imakefile	2005-04-12 20:30:40.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/Imakefile	2005-04-12 20:30:26.000000000 -0700
>@@ -19,6 +19,8 @@
> 
> LinkSourceFile(glcontextmodes.c, $(MESASRCDIR)/src/mesa/drivers/dri/common)
> LinkSourceFile(glcontextmodes.h, $(MESASRCDIR)/src/mesa/drivers/dri/common)
>+LinkSourceFile(glapi.c, $(MESASRCDIR)/src/mesa/glapi)
>+LinkSourceFile(glthread.c, $(MESASRCDIR)/src/mesa/glapi)
> LinkSourceFile(indirect_size.h, $(MESASRCDIR)/src/glx/x11)
> 
>          SRCS = global.c glxbuf.c glxcmds.c glxcmdsswap.c glxext.c \
>@@ -27,8 +29,9 @@
>                 renderpixswap.c rensize.c rensizetab.c single2.c \
>                 single2swap.c singlepix.c singlepixswap.c \
>                 singlesize.c xfont.c g_disptab.c g_disptab_EXT.c \
>-                g_render.c g_renderswap.c g_single.c g_singleswap.c \
>                 indirect_reqsize.c indirect_size_get.c indirect_util.c \
>+                indirect_dispatch.c indirect_dispatch_swap.c \
>+                glapi.c glthread.c \
>                 glcontextmodes.c $(MSRCS)
> 
>          OBJS = $(SRCS:.c=.o)
>@@ -91,6 +94,8 @@
> LinkSourceFile(glxpix.c,LinkDirectory)
> LinkSourceFile(glxscreens.c,LinkDirectory)
> LinkSourceFile(glxutil.c,LinkDirectory)
>+LinkSourceFile(indirect_dispatch.c,LinkDirectory)
>+LinkSourceFile(indirect_dispatch_swap.c,LinkDirectory)
> LinkSourceFile(indirect_reqsize.c,LinkDirectory)
> LinkSourceFile(indirect_size_get.c,LinkDirectory)
> LinkSourceFile(indirect_util.c,LinkDirectory)
>@@ -108,8 +113,8 @@
> LinkSourceFile(xfont.c,LinkDirectory)
> LinkSourceFile(g_disptab.c,LinkDirectory)
> LinkSourceFile(g_disptab_EXT.c,LinkDirectory)
>-LinkSourceFile(g_render.c,LinkDirectory)
>-LinkSourceFile(g_renderswap.c,LinkDirectory)
> LinkSourceFile(g_single.c,LinkDirectory)
> LinkSourceFile(g_singleswap.c,LinkDirectory)
>+LinkSourceFile(glapi.c,LinkDirectory)
>+LinkSourceFile(glthread.c,LinkDirectory)
> #endif
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch.c Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch.c	1969-12-31 16:00:00.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch.c	2005-04-12 21:05:23.000000000 -0700
>@@ -0,0 +1,5389 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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, 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.  IN NO EVENT SHALL
>+ * IBM,
>+ * AND/OR THEIR SUPPLIERS 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 <X11/Xmd.h>
>+#include <GL/gl.h>
>+#include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+
>+typedef struct {
>+    __GLX_PIXEL_3D_HDR;
>+} __GLXpixel3DHeader;
>+
>+extern GLboolean __glXErrorOccured( void );
>+extern void __glXClearErrorOccured( void );
>+
>+static const unsigned dummy_answer[2] = {0, 0};
>+
>+int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(NewList)(
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(EndList)();
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_CallList(GLbyte * pc)
>+{
>+    GL_CALL(CallList)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_CallLists(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+    const GLenum type = *(GLenum   *)(pc +  4);
>+    const GLvoid * lists =  (const GLvoid *)(pc +  8);
>+
>+    lists = (const GLvoid *) (pc + 8);
>+
>+    GL_CALL(CallLists)(
>+        n,
>+        type,
>+        lists
>+    );
>+}
>+
>+int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(DeleteLists)(
>+            *(GLuint   *)(pc +  0),
>+            *(GLsizei  *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLuint retval;
>+        retval = GL_CALL(GenLists)(
>+            *(GLsizei  *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ListBase(GLbyte * pc)
>+{
>+    GL_CALL(ListBase)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Begin(GLbyte * pc)
>+{
>+    GL_CALL(Begin)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Bitmap(GLbyte * pc)
>+{
>+    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(Bitmap)(
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLfloat  *)(pc + 28),
>+        *(GLfloat  *)(pc + 32),
>+        *(GLfloat  *)(pc + 36),
>+        *(GLfloat  *)(pc + 40),
>+        bitmap
>+    );
>+}
>+void __glXDisp_Color3bv(GLbyte * pc)
>+{
>+    GL_CALL(Color3bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Color3dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3fv(GLbyte * pc)
>+{
>+    GL_CALL(Color3fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3iv(GLbyte * pc)
>+{
>+    GL_CALL(Color3iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3sv(GLbyte * pc)
>+{
>+    GL_CALL(Color3sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3ubv(GLbyte * pc)
>+{
>+    GL_CALL(Color3ubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3uiv(GLbyte * pc)
>+{
>+    GL_CALL(Color3uiv)(
>+         (const GLuint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color3usv(GLbyte * pc)
>+{
>+    GL_CALL(Color3usv)(
>+         (const GLushort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4bv(GLbyte * pc)
>+{
>+    GL_CALL(Color4bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Color4dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4fv(GLbyte * pc)
>+{
>+    GL_CALL(Color4fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4iv(GLbyte * pc)
>+{
>+    GL_CALL(Color4iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4sv(GLbyte * pc)
>+{
>+    GL_CALL(Color4sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4ubv(GLbyte * pc)
>+{
>+    GL_CALL(Color4ubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4uiv(GLbyte * pc)
>+{
>+    GL_CALL(Color4uiv)(
>+         (const GLuint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Color4usv(GLbyte * pc)
>+{
>+    GL_CALL(Color4usv)(
>+         (const GLushort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EdgeFlagv(GLbyte * pc)
>+{
>+    GL_CALL(EdgeFlagv)(
>+         (const GLboolean *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_End(GLbyte * pc)
>+{
>+    GL_CALL(End)();
>+}
>+
>+void __glXDisp_Indexdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Indexdv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Indexfv(GLbyte * pc)
>+{
>+    GL_CALL(Indexfv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Indexiv(GLbyte * pc)
>+{
>+    GL_CALL(Indexiv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Indexsv(GLbyte * pc)
>+{
>+    GL_CALL(Indexsv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Normal3bv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Normal3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Normal3dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Normal3fv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Normal3iv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Normal3sv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos2dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos2fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos2iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos2sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos3dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos3fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos3iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos3sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos4dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos4fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos4iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_RasterPos4sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Rectdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Rectdv)(
>+         (const GLdouble *)(pc +  0),
>+         (const GLdouble *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_Rectfv(GLbyte * pc)
>+{
>+    GL_CALL(Rectfv)(
>+         (const GLfloat *)(pc +  0),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Rectiv(GLbyte * pc)
>+{
>+    GL_CALL(Rectiv)(
>+         (const GLint *)(pc +  0),
>+         (const GLint *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Rectsv(GLbyte * pc)
>+{
>+    GL_CALL(Rectsv)(
>+         (const GLshort *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_TexCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord1dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord1fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord1iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord1sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord2dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord2fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord2iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord2sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord3dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord3fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord3iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord3sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord4dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord4fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord4iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexCoord4sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex2dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex2fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex2iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex2sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex3dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex3fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex3iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex3sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex4dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex4fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex4iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4iv)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Vertex4sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4sv)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ClipPlane(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ClipPlane)(
>+        *(GLenum   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ColorMaterial(GLbyte * pc)
>+{
>+    GL_CALL(ColorMaterial)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_CullFace(GLbyte * pc)
>+{
>+    GL_CALL(CullFace)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Fogf(GLbyte * pc)
>+{
>+    GL_CALL(Fogf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_Fogfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    GL_CALL(Fogfv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_Fogi(GLbyte * pc)
>+{
>+    GL_CALL(Fogi)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_Fogiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    GL_CALL(Fogiv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_FrontFace(GLbyte * pc)
>+{
>+    GL_CALL(FrontFace)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Hint(GLbyte * pc)
>+{
>+    GL_CALL(Hint)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_Lightf(GLbyte * pc)
>+{
>+    GL_CALL(Lightf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Lightfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(Lightfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_Lighti(GLbyte * pc)
>+{
>+    GL_CALL(Lighti)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Lightiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(Lightiv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_LightModelf(GLbyte * pc)
>+{
>+    GL_CALL(LightModelf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_LightModelfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    GL_CALL(LightModelfv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_LightModeli(GLbyte * pc)
>+{
>+    GL_CALL(LightModeli)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_LightModeliv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    GL_CALL(LightModeliv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_LineStipple(GLbyte * pc)
>+{
>+    GL_CALL(LineStipple)(
>+        *(GLint    *)(pc +  0),
>+        *(GLushort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_LineWidth(GLbyte * pc)
>+{
>+    GL_CALL(LineWidth)(
>+        *(GLfloat  *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Materialf(GLbyte * pc)
>+{
>+    GL_CALL(Materialf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Materialfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(Materialfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_Materiali(GLbyte * pc)
>+{
>+    GL_CALL(Materiali)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Materialiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(Materialiv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_PointSize(GLbyte * pc)
>+{
>+    GL_CALL(PointSize)(
>+        *(GLfloat  *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PolygonMode(GLbyte * pc)
>+{
>+    GL_CALL(PolygonMode)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_PolygonStipple(GLbyte * pc)
>+{
>+    const GLubyte * const mask = (const GLubyte *) (pc + 20);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(PolygonStipple)(
>+        mask
>+    );
>+}
>+void __glXDisp_Scissor(GLbyte * pc)
>+{
>+    GL_CALL(Scissor)(
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ShadeModel(GLbyte * pc)
>+{
>+    GL_CALL(ShadeModel)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexParameterf(GLbyte * pc)
>+{
>+    GL_CALL(TexParameterf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(TexParameterfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexParameteri(GLbyte * pc)
>+{
>+    GL_CALL(TexParameteri)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(TexParameteriv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexImage1D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexImage1D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLint    *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    );
>+}
>+void __glXDisp_TexImage2D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexImage2D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    );
>+}
>+void __glXDisp_TexEnvf(GLbyte * pc)
>+{
>+    GL_CALL(TexEnvf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexEnvfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(TexEnvfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexEnvi(GLbyte * pc)
>+{
>+    GL_CALL(TexEnvi)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexEnviv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(TexEnviv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexGend(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexGend)(
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12),
>+        *(GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexGendv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLdouble * params;
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint compsize = __glTexGendv_size(pname);
>+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
>+
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    params = (const GLdouble *) (pc + 8);
>+
>+    GL_CALL(TexGendv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexGenf(GLbyte * pc)
>+{
>+    GL_CALL(TexGenf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexGenfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(TexGenfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_TexGeni(GLbyte * pc)
>+{
>+    GL_CALL(TexGeni)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_TexGeniv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(TexGeniv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_InitNames(GLbyte * pc)
>+{
>+    GL_CALL(InitNames)();
>+}
>+
>+void __glXDisp_LoadName(GLbyte * pc)
>+{
>+    GL_CALL(LoadName)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PassThrough(GLbyte * pc)
>+{
>+    GL_CALL(PassThrough)(
>+        *(GLfloat  *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PopName(GLbyte * pc)
>+{
>+    GL_CALL(PopName)();
>+}
>+
>+void __glXDisp_PushName(GLbyte * pc)
>+{
>+    GL_CALL(PushName)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_DrawBuffer(GLbyte * pc)
>+{
>+    GL_CALL(DrawBuffer)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Clear(GLbyte * pc)
>+{
>+    GL_CALL(Clear)(
>+        *(GLbitfield *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ClearAccum(GLbyte * pc)
>+{
>+    GL_CALL(ClearAccum)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLfloat  *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ClearIndex(GLbyte * pc)
>+{
>+    GL_CALL(ClearIndex)(
>+        *(GLfloat  *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ClearColor(GLbyte * pc)
>+{
>+    GL_CALL(ClearColor)(
>+        *(GLclampf *)(pc +  0),
>+        *(GLclampf *)(pc +  4),
>+        *(GLclampf *)(pc +  8),
>+        *(GLclampf *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ClearStencil(GLbyte * pc)
>+{
>+    GL_CALL(ClearStencil)(
>+        *(GLint    *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ClearDepth(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ClearDepth)(
>+        *(GLclampd *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_StencilMask(GLbyte * pc)
>+{
>+    GL_CALL(StencilMask)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ColorMask(GLbyte * pc)
>+{
>+    GL_CALL(ColorMask)(
>+        *(GLboolean *)(pc +  0),
>+        *(GLboolean *)(pc +  1),
>+        *(GLboolean *)(pc +  2),
>+        *(GLboolean *)(pc +  3)
>+    );
>+}
>+
>+void __glXDisp_DepthMask(GLbyte * pc)
>+{
>+    GL_CALL(DepthMask)(
>+        *(GLboolean *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_IndexMask(GLbyte * pc)
>+{
>+    GL_CALL(IndexMask)(
>+        *(GLuint   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Accum(GLbyte * pc)
>+{
>+    GL_CALL(Accum)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_Disable(GLbyte * pc)
>+{
>+    GL_CALL(Disable)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Enable(GLbyte * pc)
>+{
>+    GL_CALL(Enable)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PopAttrib(GLbyte * pc)
>+{
>+    GL_CALL(PopAttrib)();
>+}
>+
>+void __glXDisp_PushAttrib(GLbyte * pc)
>+{
>+    GL_CALL(PushAttrib)(
>+        *(GLbitfield *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MapGrid1d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MapGrid1d)(
>+        *(GLint    *)(pc + 16),
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_MapGrid1f(GLbyte * pc)
>+{
>+    GL_CALL(MapGrid1f)(
>+        *(GLint    *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_MapGrid2d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MapGrid2d)(
>+        *(GLint    *)(pc + 32),
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLint    *)(pc + 36),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24)
>+    );
>+}
>+
>+void __glXDisp_MapGrid2f(GLbyte * pc)
>+{
>+    GL_CALL(MapGrid2f)(
>+        *(GLint    *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLfloat  *)(pc + 16),
>+        *(GLfloat  *)(pc + 20)
>+    );
>+}
>+
>+void __glXDisp_EvalCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(EvalCoord1dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EvalCoord1fv(GLbyte * pc)
>+{
>+    GL_CALL(EvalCoord1fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EvalCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(EvalCoord2dv)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EvalCoord2fv(GLbyte * pc)
>+{
>+    GL_CALL(EvalCoord2fv)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EvalMesh1(GLbyte * pc)
>+{
>+    GL_CALL(EvalMesh1)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_EvalPoint1(GLbyte * pc)
>+{
>+    GL_CALL(EvalPoint1)(
>+        *(GLint    *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_EvalMesh2(GLbyte * pc)
>+{
>+    GL_CALL(EvalMesh2)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_EvalPoint2(GLbyte * pc)
>+{
>+    GL_CALL(EvalPoint2)(
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_AlphaFunc(GLbyte * pc)
>+{
>+    GL_CALL(AlphaFunc)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLclampf *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_BlendFunc(GLbyte * pc)
>+{
>+    GL_CALL(BlendFunc)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_LogicOp(GLbyte * pc)
>+{
>+    GL_CALL(LogicOp)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_StencilFunc(GLbyte * pc)
>+{
>+    GL_CALL(StencilFunc)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLuint   *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_StencilOp(GLbyte * pc)
>+{
>+    GL_CALL(StencilOp)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_DepthFunc(GLbyte * pc)
>+{
>+    GL_CALL(DepthFunc)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PixelZoom(GLbyte * pc)
>+{
>+    GL_CALL(PixelZoom)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_PixelTransferf(GLbyte * pc)
>+{
>+    GL_CALL(PixelTransferf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_PixelTransferi(GLbyte * pc)
>+{
>+    GL_CALL(PixelTransferi)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    );
>+}
>+
>+int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(PixelStoref)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLfloat  *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(PixelStorei)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_PixelMapfv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(PixelMapfv)(
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_PixelMapuiv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(PixelMapuiv)(
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLuint *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_PixelMapusv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(PixelMapusv)(
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLushort *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ReadBuffer(GLbyte * pc)
>+{
>+    GL_CALL(ReadBuffer)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_CopyPixels(GLbyte * pc)
>+{
>+    GL_CALL(CopyPixels)(
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLenum   *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_DrawPixels(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(DrawPixels)(
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLenum   *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        pixels
>+    );
>+}
>+int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetBooleanv_size(pname);
>+        GLboolean answerBuffer[200];
>+        GLboolean * params = __glXGetAnswerBuffer(cl, compsize * 1, answerBuffer, sizeof(answerBuffer), 1);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetBooleanv)(
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble equation[4];
>+        GL_CALL(GetClipPlane)(
>+            *(GLenum   *)(pc +  0),
>+            equation
>+        );
>+        __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetDoublev_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetDoublev)(
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = GL_CALL(GetError)();
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetFloatv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetFloatv)(
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetIntegerv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetIntegerv)(
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetLightfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetLightfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetLightiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetLightiv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapdv_size(target,query);
>+        GLdouble answerBuffer[200];
>+        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapdv)(
>+            target,
>+            query,
>+            v
>+        );
>+        __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapfv_size(target,query);
>+        GLfloat answerBuffer[200];
>+        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapfv)(
>+            target,
>+            query,
>+            v
>+        );
>+        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapiv_size(target,query);
>+        GLint answerBuffer[200];
>+        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapiv)(
>+            target,
>+            query,
>+            v
>+        );
>+        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMaterialfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMaterialfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMaterialiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMaterialiv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapfv_size(map);
>+        GLfloat answerBuffer[200];
>+        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapfv)(
>+            map,
>+            values
>+        );
>+        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapuiv_size(map);
>+        GLuint answerBuffer[200];
>+        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapuiv)(
>+            map,
>+            values
>+        );
>+        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapusv_size(map);
>+        GLushort answerBuffer[200];
>+        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapusv)(
>+            map,
>+            values
>+        );
>+        __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexEnvfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexEnvfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexEnviv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexEnviv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGendv_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGendv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGenfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGenfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGeniv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGeniv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  8);
>+
>+        const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexLevelParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  8);
>+
>+        const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexLevelParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsEnabled)(
>+            *(GLenum   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsList)(
>+            *(GLuint   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_DepthRange(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(DepthRange)(
>+        *(GLclampd *)(pc +  0),
>+        *(GLclampd *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Frustum(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Frustum)(
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24),
>+        *(GLdouble *)(pc + 32),
>+        *(GLdouble *)(pc + 40)
>+    );
>+}
>+
>+void __glXDisp_LoadIdentity(GLbyte * pc)
>+{
>+    GL_CALL(LoadIdentity)();
>+}
>+
>+void __glXDisp_LoadMatrixf(GLbyte * pc)
>+{
>+    GL_CALL(LoadMatrixf)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_LoadMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(LoadMatrixd)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MatrixMode(GLbyte * pc)
>+{
>+    GL_CALL(MatrixMode)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultMatrixf(GLbyte * pc)
>+{
>+    GL_CALL(MultMatrixf)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultMatrixd)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_Ortho(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Ortho)(
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24),
>+        *(GLdouble *)(pc + 32),
>+        *(GLdouble *)(pc + 40)
>+    );
>+}
>+
>+void __glXDisp_PopMatrix(GLbyte * pc)
>+{
>+    GL_CALL(PopMatrix)();
>+}
>+
>+void __glXDisp_PushMatrix(GLbyte * pc)
>+{
>+    GL_CALL(PushMatrix)();
>+}
>+
>+void __glXDisp_Rotated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Rotated)(
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24)
>+    );
>+}
>+
>+void __glXDisp_Rotatef(GLbyte * pc)
>+{
>+    GL_CALL(Rotatef)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLfloat  *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_Scaled(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Scaled)(
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_Scalef(GLbyte * pc)
>+{
>+    GL_CALL(Scalef)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Translated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Translated)(
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_Translatef(GLbyte * pc)
>+{
>+    GL_CALL(Translatef)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_Viewport(GLbyte * pc)
>+{
>+    GL_CALL(Viewport)(
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_BindTexture(GLbyte * pc)
>+{
>+    GL_CALL(BindTexture)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_Indexubv(GLbyte * pc)
>+{
>+    GL_CALL(Indexubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PolygonOffset(GLbyte * pc)
>+{
>+    GL_CALL(PolygonOffset)(
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreTexturesResident)(
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        );
>+        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_CopyTexImage1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexImage1D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLint    *)(pc + 24)
>+    );
>+}
>+
>+void __glXDisp_CopyTexImage2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexImage2D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLint    *)(pc + 28)
>+    );
>+}
>+
>+void __glXDisp_CopyTexSubImage1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage1D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20)
>+    );
>+}
>+
>+void __glXDisp_CopyTexSubImage2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage2D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28)
>+    );
>+}
>+
>+int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GL_CALL(DeleteTextures)(
>+            n,
>+             (const GLuint *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenTextures)(
>+            n,
>+            textures
>+        );
>+        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsTexture)(
>+            *(GLuint   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_PrioritizeTextures(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    GL_CALL(PrioritizeTextures)(
>+        n,
>+         (const GLuint *)(pc +  4),
>+         (const GLclampf *)(pc + 4+n*4)
>+    );
>+}
>+
>+void __glXDisp_TexSubImage1D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexSubImage1D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    );
>+}
>+void __glXDisp_TexSubImage2D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexSubImage2D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLint    *)(pc + 32),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLsizei  *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    );
>+}
>+void __glXDisp_BlendColor(GLbyte * pc)
>+{
>+    GL_CALL(BlendColor)(
>+        *(GLclampf *)(pc +  0),
>+        *(GLclampf *)(pc +  4),
>+        *(GLclampf *)(pc +  8),
>+        *(GLclampf *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_BlendEquation(GLbyte * pc)
>+{
>+    GL_CALL(BlendEquation)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ColorTable(GLbyte * pc)
>+{
>+    const GLvoid * const table = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(ColorTable)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        table
>+    );
>+}
>+void __glXDisp_ColorTableParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(ColorTableParameterfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_ColorTableParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(ColorTableParameteriv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_CopyColorTable(GLbyte * pc)
>+{
>+    GL_CALL(CopyColorTable)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    );
>+}
>+
>+int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetColorTableParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetColorTableParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ColorSubTable(GLbyte * pc)
>+{
>+    const GLvoid * const data = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(ColorSubTable)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        data
>+    );
>+}
>+void __glXDisp_CopyColorSubTable(GLbyte * pc)
>+{
>+    GL_CALL(CopyColorSubTable)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLsizei  *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(ConvolutionFilter1D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 36),
>+        *(GLenum   *)(pc + 40),
>+        image
>+    );
>+}
>+void __glXDisp_ConvolutionFilter2D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(ConvolutionFilter2D)(
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        *(GLenum   *)(pc + 40),
>+        image
>+    );
>+}
>+void __glXDisp_ConvolutionParameterf(GLbyte * pc)
>+{
>+    GL_CALL(ConvolutionParameterf)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ConvolutionParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    GL_CALL(ConvolutionParameterfv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_ConvolutionParameteri(GLbyte * pc)
>+{
>+    GL_CALL(ConvolutionParameteri)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ConvolutionParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    GL_CALL(ConvolutionParameteriv)(
>+        *(GLenum   *)(pc +  0),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyConvolutionFilter1D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    );
>+}
>+
>+void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyConvolutionFilter2D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20)
>+    );
>+}
>+
>+int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetConvolutionParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetConvolutionParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetHistogramParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetHistogramParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMinmaxParameterfv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMinmaxParameteriv)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_Histogram(GLbyte * pc)
>+{
>+    GL_CALL(Histogram)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLsizei  *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLboolean *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_Minmax(GLbyte * pc)
>+{
>+    GL_CALL(Minmax)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLboolean *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ResetHistogram(GLbyte * pc)
>+{
>+    GL_CALL(ResetHistogram)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ResetMinmax(GLbyte * pc)
>+{
>+    GL_CALL(ResetMinmax)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_TexImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 80);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexImage3D)(
>+        *(GLenum   *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLint    *)(pc + 44),
>+        *(GLsizei  *)(pc + 48),
>+        *(GLsizei  *)(pc + 52),
>+        *(GLsizei  *)(pc + 56),
>+        *(GLint    *)(pc + 64),
>+        *(GLenum   *)(pc + 68),
>+        *(GLenum   *)(pc + 72),
>+        pixels
>+    );
>+}
>+void __glXDisp_TexSubImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 84);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 88);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment);
>+
>+    GL_CALL(TexSubImage3D)(
>+        *(GLenum   *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLint    *)(pc + 44),
>+        *(GLint    *)(pc + 48),
>+        *(GLint    *)(pc + 52),
>+        *(GLsizei  *)(pc + 60),
>+        *(GLsizei  *)(pc + 64),
>+        *(GLsizei  *)(pc + 68),
>+        *(GLenum   *)(pc + 76),
>+        *(GLenum   *)(pc + 80),
>+        pixels
>+    );
>+}
>+void __glXDisp_CopyTexSubImage3D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage3D)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLsizei  *)(pc + 32)
>+    );
>+}
>+
>+void __glXDisp_ActiveTextureARB(GLbyte * pc)
>+{
>+    GL_CALL(ActiveTextureARB)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord1dvARB)(
>+        *(GLenum   *)(pc +  8),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1fvARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1ivARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord1svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1svARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord2dvARB)(
>+        *(GLenum   *)(pc + 16),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2fvARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2ivARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord2svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2svARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord3dvARB)(
>+        *(GLenum   *)(pc + 24),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3fvARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3ivARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord3svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3svARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord4dvARB)(
>+        *(GLenum   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4fvARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4ivARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_MultiTexCoord4svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4svARB)(
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_SampleCoverageARB(GLbyte * pc)
>+{
>+    GL_CALL(SampleCoverageARB)(
>+        *(GLclampf *)(pc +  0),
>+        *(GLboolean *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_DrawBuffersARB(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    GL_CALL(DrawBuffersARB)(
>+        n,
>+         (const GLenum *)(pc +  4)
>+    );
>+}
>+
>+int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreTexturesResidentEXT)(
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        );
>+        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenTexturesEXT)(
>+            n,
>+            textures
>+        );
>+        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsTextureEXT)(
>+            *(GLuint   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_SampleMaskSGIS(GLbyte * pc)
>+{
>+    GL_CALL(SampleMaskSGIS)(
>+        *(GLclampf *)(pc +  0),
>+        *(GLboolean *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_SamplePatternSGIS(GLbyte * pc)
>+{
>+    GL_CALL(SamplePatternSGIS)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_PointParameterfEXT(GLbyte * pc)
>+{
>+    GL_CALL(PointParameterfEXT)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_PointParameterfvEXT(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    GL_CALL(PointParameterfvEXT)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_WindowPos3fvMESA(GLbyte * pc)
>+{
>+    GL_CALL(WindowPos3fvMESA)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc)
>+{
>+    GL_CALL(BlendFuncSeparateEXT)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_FogCoordfvEXT(GLbyte * pc)
>+{
>+    GL_CALL(FogCoordfvEXT)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_FogCoorddvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(FogCoorddvEXT)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
>+
>+    GL_CALL(CompressedTexImage3DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 24);
>+
>+    GL_CALL(CompressedTexImage2DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        imageSize,
>+         (const GLvoid *)(pc + 28)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
>+
>+    GL_CALL(CompressedTexImage1DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 36);
>+
>+    GL_CALL(CompressedTexSubImage3DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        imageSize,
>+         (const GLvoid *)(pc + 40)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
>+
>+    GL_CALL(CompressedTexSubImage2DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    );
>+}
>+
>+void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
>+
>+    GL_CALL(CompressedTexSubImage1DARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLenum   *)(pc + 16),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3bvEXT)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(SecondaryColor3dvEXT)(
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3fvEXT)(
>+         (const GLfloat *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3ivEXT)(
>+         (const GLint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3svEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3svEXT)(
>+         (const GLshort *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3ubvEXT)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3uivEXT)(
>+         (const GLuint *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3usvEXT)(
>+         (const GLushort *)(pc +  0)
>+    );
>+}
>+
>+int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreProgramsResidentNV)(
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        );
>+        __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BindProgramNV(GLbyte * pc)
>+{
>+    GL_CALL(BindProgramNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    );
>+}
>+
>+int __glXDisp_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GL_CALL(DeleteProgramsNV)(
>+            n,
>+             (const GLuint *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ExecuteProgramNV(GLbyte * pc)
>+{
>+    GL_CALL(ExecuteProgramNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+int __glXDisp_GenProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenProgramsNV)(
>+            n,
>+            ids
>+        );
>+        __glXSendReply(cl->client, ids, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramParameterdvNV)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramParameterfvNV)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetProgramivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetProgramivNV)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        GL_CALL(GetTrackMatrixivNV)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribdvARB)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribfvARB)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribivARB)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsProgramNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsProgramNV)(
>+            *(GLuint   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_LoadProgramNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  8);
>+
>+    GL_CALL(LoadProgramNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        len,
>+         (const GLubyte *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ProgramParameter4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramParameter4dvNV)(
>+        *(GLenum   *)(pc + 32),
>+        *(GLuint   *)(pc + 36),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ProgramParameter4fvNV(GLbyte * pc)
>+{
>+    GL_CALL(ProgramParameter4fvNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ProgramParameters4dvNV(GLbyte * pc)
>+{
>+    const GLuint num = *(GLuint   *)(pc +  8);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramParameters4dvNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        num,
>+         (const GLdouble *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ProgramParameters4fvNV(GLbyte * pc)
>+{
>+    const GLuint num = *(GLuint   *)(pc +  8);
>+
>+    GL_CALL(ProgramParameters4fvNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        num,
>+         (const GLfloat *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_RequestResidentProgramsNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    GL_CALL(RequestResidentProgramsNV)(
>+        n,
>+         (const GLuint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_TrackMatrixNV(GLbyte * pc)
>+{
>+    GL_CALL(TrackMatrixNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib1dvARB)(
>+        *(GLuint   *)(pc +  8),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1fvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib1svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1svARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib2dvARB)(
>+        *(GLuint   *)(pc + 16),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2fvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2svARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib3dvARB)(
>+        *(GLuint   *)(pc + 24),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3fvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3svARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib4dvARB)(
>+        *(GLuint   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4fvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4svARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NubvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs1dvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs1fvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs1svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs1svNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs2dvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs2fvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs2svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs2svNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs3dvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs3fvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs3svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs3svNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs4dvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs4fvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs4svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs4svNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(VertexAttribs4ubvNV)(
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLubyte *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_PointParameteriNV(GLbyte * pc)
>+{
>+    GL_CALL(PointParameteriNV)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_PointParameterivNV(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    GL_CALL(PointParameterivNV)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
>+{
>+    GL_CALL(ActiveStencilFaceEXT)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4bvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4bvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLbyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4ivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ivARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ubvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4usvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4usvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLushort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4uivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4uivARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLuint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NbvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLbyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NsvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NivARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NusvARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLushort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NuivARB)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLuint *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_ProgramStringARB(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  8);
>+
>+    GL_CALL(ProgramStringARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        len,
>+         (const GLvoid *)(pc + 12)
>+    );
>+}
>+
>+void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramEnvParameter4dvARB)(
>+        *(GLenum   *)(pc + 32),
>+        *(GLuint   *)(pc + 36),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(ProgramEnvParameter4fvARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramLocalParameter4dvARB)(
>+        *(GLenum   *)(pc + 32),
>+        *(GLuint   *)(pc + 36),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(ProgramLocalParameter4fvARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramEnvParameterdvARB)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramEnvParameterfvARB)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramLocalParameterdvARB)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramLocalParameterfvARB)(
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetProgramivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetProgramivARB)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+    GL_CALL(ProgramNamedParameter4fvNV)(
>+        *(GLuint   *)(pc +  0),
>+        len,
>+         (const GLubyte *)(pc + 24),
>+         (const GLfloat *)(pc +  8)
>+    );
>+}
>+
>+void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc + 36);
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramNamedParameter4dvNV)(
>+        *(GLuint   *)(pc + 32),
>+        len,
>+         (const GLubyte *)(pc + 40),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+int __glXDisp_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+        GLfloat params[4];
>+        GL_CALL(GetProgramNamedParameterfvNV)(
>+            *(GLuint   *)(pc +  0),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+        GLdouble params[4];
>+        GL_CALL(GetProgramNamedParameterdvNV)(
>+            *(GLuint   *)(pc +  0),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        );
>+        __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenQueriesARB)(
>+            n,
>+            ids
>+        );
>+        __glXSendReply(cl->client, ids, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GL_CALL(DeleteQueriesARB)(
>+            n,
>+             (const GLuint *)(pc +  4)
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsQueryARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsQueryARB)(
>+            *(GLuint   *)(pc +  0)
>+        );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BeginQueryARB(GLbyte * pc)
>+{
>+    GL_CALL(BeginQueryARB)(
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_EndQueryARB(GLbyte * pc)
>+{
>+    GL_CALL(EndQueryARB)(
>+        *(GLenum   *)(pc +  0)
>+    );
>+}
>+
>+int __glXDisp_GetQueryivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryivARB)(
>+            *(GLenum   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryObjectivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryObjectivARB)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
>+        GLuint answerBuffer[200];
>+        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryObjectuivARB)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribdvNV)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribfvNV)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribivNV)(
>+            *(GLuint   *)(pc +  0),
>+            pname,
>+            params
>+        );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib1dvNV)(
>+        *(GLuint   *)(pc +  8),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1fvNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib1svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1svNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib2dvNV)(
>+        *(GLuint   *)(pc + 16),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2fvNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib2svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2svNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib3dvNV)(
>+        *(GLuint   *)(pc + 24),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3fvNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib3svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3svNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib4dvNV)(
>+        *(GLuint   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4fvNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4svNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    );
>+}
>+
>+void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ubvNV)(
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch.h Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch.h
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch.h	1969-12-31 16:00:00.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch.h	2005-04-12 14:15:42.000000000 -0700
>@@ -0,0 +1,897 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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, 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.  IN NO EVENT SHALL
>+ * IBM,
>+ * AND/OR THEIR SUPPLIERS 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.
>+ */
>+
>+#if !defined( _INDIRECT_DISPATCH_H_ )
>+#  define _INDIRECT_DISPATCH_H_
>+
>+#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
>+#    define HIDDEN  __attribute__((visibility("hidden")))
>+#  else
>+#    define HIDDEN
>+#  endif
>+struct __GLXclientStateRec;
>+
>+extern HIDDEN int __glXDisp_NewList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_NewList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_EndList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_EndList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ListBase(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ListBase(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Begin(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Bitmap(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Bitmap(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3uiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3usv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4ubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4ubv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4uiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4uiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_End(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_End(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexdv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexdv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexsv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexsv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectsv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectsv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClipPlane(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClipPlane(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorMaterial(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorMaterial(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Hint(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Hint(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModelf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModelfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModelfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModeliv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModeliv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materiali(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materiali(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointSize(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointSize(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scissor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scissor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGend(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGend(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGenf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_InitNames(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_InitNames(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PassThrough(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PopName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DrawBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Clear(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearDepth(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearDepth(GLbyte * pc);
>+extern HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_IndexMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Accum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Accum(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Disable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Disable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Enable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
>+extern HIDDEN int __glXDisp_Finish(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_Finish(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_Flush(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_Flush(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PopAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map1d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map1d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map1f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map1f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map2d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map2f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid1d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid1d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid1f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid1f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid2d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid2d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid2f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid2f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalMesh1(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalMesh1(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalPoint1(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalPoint1(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalMesh2(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalMesh2(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalPoint2(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalPoint2(GLbyte * pc);
>+extern HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
>+extern HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilOp(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelZoom(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelZoom(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
>+extern HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelMapuiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapuiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapusv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ReadBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyPixels(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyPixels(GLbyte * pc);
>+extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetError(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Frustum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadIdentity(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadIdentity(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MatrixMode(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MatrixMode(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Ortho(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Ortho(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scaled(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Translated(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Translated(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Translatef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Viewport(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsTexture(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsTexture(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorTableParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTableParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Histogram(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Minmax(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Minmax(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ResetMinmax(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SampleCoverageARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SampleCoverageARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4uivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_BeginQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BeginQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameterfEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterfEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FogCoordfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FogCoordfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FogCoorddvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FogCoorddvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_BindProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindProgramNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LoadProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameters4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RequestResidentProgramsNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TrackMatrixNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TrackMatrixNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameteriNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameteriNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+
>+#  undef HIDDEN
>+
>+#endif /* !defined( _INDIRECT_DISPATCH_H_ ) */
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch_swap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch_swap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_dispatch_swap.c	1969-12-31 16:00:00.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_dispatch_swap.c	2005-04-12 21:05:41.000000000 -0700
>@@ -0,0 +1,5537 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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, 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.  IN NO EVENT SHALL
>+ * IBM,
>+ * AND/OR THEIR SUPPLIERS 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 <X11/Xmd.h>
>+#include <GL/gl.h>
>+#include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+
>+typedef struct {
>+    __GLX_PIXEL_3D_HDR;
>+} __GLXpixel3DHeader;
>+
>+extern GLboolean __glXErrorOccured( void );
>+extern void __glXClearErrorOccured( void );
>+
>+static const unsigned dummy_answer[2] = {0, 0};
>+
>+static GLenum
>+bswap_ENUM( const void * src )
>+{
>+    union { uint32_t dst; GLenum ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLintptr
>+bswap_CARD32( const void * src )
>+{
>+    union { uint32_t dst; GLintptr ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLshort
>+bswap_CARD16( const void * src )
>+{
>+    union { uint16_t dst; GLshort ret; } x;
>+    x.dst = bswap_16( *(uint16_t *) src );
>+    return x.ret;
>+}
>+
>+static GLfloat
>+bswap_FLOAT32( const void * src )
>+{
>+    union { uint32_t dst; GLfloat ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLclampd
>+bswap_FLOAT64( const void * src )
>+{
>+    union { uint64_t dst; GLclampd ret; } x;
>+    x.dst = bswap_64( *(uint64_t *) src );
>+    return x.ret;
>+}
>+
>+static void *
>+bswap_16_array( uint16_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint16_t temp = bswap_16( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+static void *
>+bswap_32_array( uint32_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint32_t temp = bswap_32( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+static void *
>+bswap_64_array( uint64_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint64_t temp = bswap_64( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(NewList)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_EndList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(EndList)();
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_CallList(GLbyte * pc)
>+{
>+    GL_CALL(CallList)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_CallLists(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+    const GLenum type =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLvoid * lists;
>+
>+    switch(type) {
>+    case GL_BYTE:
>+    case GL_UNSIGNED_BYTE:
>+    case GL_2_BYTES:
>+    case GL_3_BYTES:
>+    case GL_4_BYTES:
>+        lists = (const GLvoid *) (pc + 8); break;
>+    case GL_SHORT:
>+    case GL_UNSIGNED_SHORT:
>+        lists = (const GLvoid *) bswap_16_array( (uint16_t *) (pc + 8), n ); break;
>+    case GL_INT:
>+    case GL_UNSIGNED_INT:
>+    case GL_FLOAT:
>+        lists = (const GLvoid *) bswap_32_array( (uint32_t *) (pc + 8), n ); break;
>+    }
>+
>+    GL_CALL(CallLists)(
>+        n,
>+        type,
>+        lists
>+    );
>+}
>+
>+int __glXDispSwap_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(DeleteLists)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLsizei )bswap_CARD32 ( pc +  4 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLuint retval;
>+        retval = GL_CALL(GenLists)(
>+             (GLsizei )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ListBase(GLbyte * pc)
>+{
>+    GL_CALL(ListBase)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Begin(GLbyte * pc)
>+{
>+    GL_CALL(Begin)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Bitmap(GLbyte * pc)
>+{
>+    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(Bitmap)(
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLfloat )bswap_FLOAT32( pc + 28 ),
>+         (GLfloat )bswap_FLOAT32( pc + 32 ),
>+         (GLfloat )bswap_FLOAT32( pc + 36 ),
>+         (GLfloat )bswap_FLOAT32( pc + 40 ),
>+        bitmap
>+    );
>+}
>+void __glXDispSwap_Color3bv(GLbyte * pc)
>+{
>+    GL_CALL(Color3bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_Color3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Color3dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color3fv(GLbyte * pc)
>+{
>+    GL_CALL(Color3fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color3iv(GLbyte * pc)
>+{
>+    GL_CALL(Color3iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color3sv(GLbyte * pc)
>+{
>+    GL_CALL(Color3sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color3ubv(GLbyte * pc)
>+{
>+    GL_CALL(Color3ubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_Color3uiv(GLbyte * pc)
>+{
>+    GL_CALL(Color3uiv)(
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color3usv(GLbyte * pc)
>+{
>+    GL_CALL(Color3usv)(
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4bv(GLbyte * pc)
>+{
>+    GL_CALL(Color4bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_Color4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Color4dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4fv(GLbyte * pc)
>+{
>+    GL_CALL(Color4fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4iv(GLbyte * pc)
>+{
>+    GL_CALL(Color4iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4sv(GLbyte * pc)
>+{
>+    GL_CALL(Color4sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4ubv(GLbyte * pc)
>+{
>+    GL_CALL(Color4ubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_Color4uiv(GLbyte * pc)
>+{
>+    GL_CALL(Color4uiv)(
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Color4usv(GLbyte * pc)
>+{
>+    GL_CALL(Color4usv)(
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_EdgeFlagv(GLbyte * pc)
>+{
>+    GL_CALL(EdgeFlagv)(
>+         (const GLboolean *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_End(GLbyte * pc)
>+{
>+    GL_CALL(End)();
>+}
>+
>+void __glXDispSwap_Indexdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Indexdv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_Indexfv(GLbyte * pc)
>+{
>+    GL_CALL(Indexfv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_Indexiv(GLbyte * pc)
>+{
>+    GL_CALL(Indexiv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_Indexsv(GLbyte * pc)
>+{
>+    GL_CALL(Indexsv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_Normal3bv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3bv)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_Normal3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Normal3dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Normal3fv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Normal3iv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Normal3sv(GLbyte * pc)
>+{
>+    GL_CALL(Normal3sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos2dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos2fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos2iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos2sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos2sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos3dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos3fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos3iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos3sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos3sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(RasterPos4dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos4fv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos4iv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_RasterPos4sv(GLbyte * pc)
>+{
>+    GL_CALL(RasterPos4sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Rectdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Rectdv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 16), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Rectfv(GLbyte * pc)
>+{
>+    GL_CALL(Rectfv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Rectiv(GLbyte * pc)
>+{
>+    GL_CALL(Rectiv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Rectsv(GLbyte * pc)
>+{
>+    GL_CALL(Rectsv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord1dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord1fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord1iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord1sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord1sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord2dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord2fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord2iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord2sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord2sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord3dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord3fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord3iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord3sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord3sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexCoord4dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord4fv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord4iv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_TexCoord4sv(GLbyte * pc)
>+{
>+    GL_CALL(TexCoord4sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex2dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex2fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex2iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex2sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex2sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex3dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex3fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex3iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex3sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex3sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Vertex4dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex4fv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex4iv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4iv)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_Vertex4sv(GLbyte * pc)
>+{
>+    GL_CALL(Vertex4sv)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ClipPlane(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ClipPlane)(
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ColorMaterial(GLbyte * pc)
>+{
>+    GL_CALL(ColorMaterial)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_CullFace(GLbyte * pc)
>+{
>+    GL_CALL(CullFace)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Fogf(GLbyte * pc)
>+{
>+    GL_CALL(Fogf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_Fogfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glFogfv_size(pname) );
>+
>+    GL_CALL(Fogfv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_Fogi(GLbyte * pc)
>+{
>+    GL_CALL(Fogi)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_Fogiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glFogiv_size(pname) );
>+
>+    GL_CALL(Fogiv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_FrontFace(GLbyte * pc)
>+{
>+    GL_CALL(FrontFace)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Hint(GLbyte * pc)
>+{
>+    GL_CALL(Hint)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_Lightf(GLbyte * pc)
>+{
>+    GL_CALL(Lightf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Lightfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glLightfv_size(pname) );
>+
>+    GL_CALL(Lightfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_Lighti(GLbyte * pc)
>+{
>+    GL_CALL(Lighti)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Lightiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glLightiv_size(pname) );
>+
>+    GL_CALL(Lightiv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_LightModelf(GLbyte * pc)
>+{
>+    GL_CALL(LightModelf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_LightModelfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModelfv_size(pname) );
>+
>+    GL_CALL(LightModelfv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_LightModeli(GLbyte * pc)
>+{
>+    GL_CALL(LightModeli)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_LightModeliv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModeliv_size(pname) );
>+
>+    GL_CALL(LightModeliv)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_LineStipple(GLbyte * pc)
>+{
>+    GL_CALL(LineStipple)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLushort)bswap_CARD16 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_LineWidth(GLbyte * pc)
>+{
>+    GL_CALL(LineWidth)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Materialf(GLbyte * pc)
>+{
>+    GL_CALL(Materialf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Materialfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialfv_size(pname) );
>+
>+    GL_CALL(Materialfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_Materiali(GLbyte * pc)
>+{
>+    GL_CALL(Materiali)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Materialiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialiv_size(pname) );
>+
>+    GL_CALL(Materialiv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_PointSize(GLbyte * pc)
>+{
>+    GL_CALL(PointSize)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PolygonMode(GLbyte * pc)
>+{
>+    GL_CALL(PolygonMode)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_PolygonStipple(GLbyte * pc)
>+{
>+    const GLubyte * const mask = (const GLubyte *) (pc + 20);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(PolygonStipple)(
>+        mask
>+    );
>+}
>+void __glXDispSwap_Scissor(GLbyte * pc)
>+{
>+    GL_CALL(Scissor)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_ShadeModel(GLbyte * pc)
>+{
>+    GL_CALL(ShadeModel)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_TexParameterf(GLbyte * pc)
>+{
>+    GL_CALL(TexParameterf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameterfv_size(pname) );
>+
>+    GL_CALL(TexParameterfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexParameteri(GLbyte * pc)
>+{
>+    GL_CALL(TexParameteri)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameteriv_size(pname) );
>+
>+    GL_CALL(TexParameteriv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexImage1D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexImage1D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_TexImage2D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexImage2D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_TexEnvf(GLbyte * pc)
>+{
>+    GL_CALL(TexEnvf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexEnvfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnvfv_size(pname) );
>+
>+    GL_CALL(TexEnvfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexEnvi(GLbyte * pc)
>+{
>+    GL_CALL(TexEnvi)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexEnviv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnviv_size(pname) );
>+
>+    GL_CALL(TexEnviv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexGend(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(TexGend)(
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_TexGendv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLdouble * params;
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint compsize = __glTexGendv_size(pname);
>+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
>+
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    params = (const GLdouble *) bswap_64_array( (uint64_t *) (pc + 8), __glTexGendv_size(pname) );
>+
>+    GL_CALL(TexGendv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexGenf(GLbyte * pc)
>+{
>+    GL_CALL(TexGenf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexGenfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGenfv_size(pname) );
>+
>+    GL_CALL(TexGenfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_TexGeni(GLbyte * pc)
>+{
>+    GL_CALL(TexGeni)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_TexGeniv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGeniv_size(pname) );
>+
>+    GL_CALL(TexGeniv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_InitNames(GLbyte * pc)
>+{
>+    GL_CALL(InitNames)();
>+}
>+
>+void __glXDispSwap_LoadName(GLbyte * pc)
>+{
>+    GL_CALL(LoadName)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PassThrough(GLbyte * pc)
>+{
>+    GL_CALL(PassThrough)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PopName(GLbyte * pc)
>+{
>+    GL_CALL(PopName)();
>+}
>+
>+void __glXDispSwap_PushName(GLbyte * pc)
>+{
>+    GL_CALL(PushName)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_DrawBuffer(GLbyte * pc)
>+{
>+    GL_CALL(DrawBuffer)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Clear(GLbyte * pc)
>+{
>+    GL_CALL(Clear)(
>+         (GLbitfield)bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ClearAccum(GLbyte * pc)
>+{
>+    GL_CALL(ClearAccum)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLfloat )bswap_FLOAT32( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_ClearIndex(GLbyte * pc)
>+{
>+    GL_CALL(ClearIndex)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ClearColor(GLbyte * pc)
>+{
>+    GL_CALL(ClearColor)(
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 ),
>+         (GLclampf)bswap_FLOAT32( pc +  8 ),
>+         (GLclampf)bswap_FLOAT32( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_ClearStencil(GLbyte * pc)
>+{
>+    GL_CALL(ClearStencil)(
>+         (GLint   )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ClearDepth(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ClearDepth)(
>+         (GLclampd)bswap_FLOAT64( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_StencilMask(GLbyte * pc)
>+{
>+    GL_CALL(StencilMask)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ColorMask(GLbyte * pc)
>+{
>+    GL_CALL(ColorMask)(
>+        *(GLboolean *)(pc +  0),
>+        *(GLboolean *)(pc +  1),
>+        *(GLboolean *)(pc +  2),
>+        *(GLboolean *)(pc +  3)
>+    );
>+}
>+
>+void __glXDispSwap_DepthMask(GLbyte * pc)
>+{
>+    GL_CALL(DepthMask)(
>+        *(GLboolean *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_IndexMask(GLbyte * pc)
>+{
>+    GL_CALL(IndexMask)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Accum(GLbyte * pc)
>+{
>+    GL_CALL(Accum)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_Disable(GLbyte * pc)
>+{
>+    GL_CALL(Disable)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_Enable(GLbyte * pc)
>+{
>+    GL_CALL(Enable)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PopAttrib(GLbyte * pc)
>+{
>+    GL_CALL(PopAttrib)();
>+}
>+
>+void __glXDispSwap_PushAttrib(GLbyte * pc)
>+{
>+    GL_CALL(PushAttrib)(
>+         (GLbitfield)bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_MapGrid1d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MapGrid1d)(
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_MapGrid1f(GLbyte * pc)
>+{
>+    GL_CALL(MapGrid1f)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_MapGrid2d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MapGrid2d)(
>+         (GLint   )bswap_CARD32 ( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 36 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 )
>+    );
>+}
>+
>+void __glXDispSwap_MapGrid2f(GLbyte * pc)
>+{
>+    GL_CALL(MapGrid2f)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLfloat )bswap_FLOAT32( pc + 16 ),
>+         (GLfloat )bswap_FLOAT32( pc + 20 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(EvalCoord1dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalCoord1fv(GLbyte * pc)
>+{
>+    GL_CALL(EvalCoord1fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(EvalCoord2dv)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalCoord2fv(GLbyte * pc)
>+{
>+    GL_CALL(EvalCoord2fv)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalMesh1(GLbyte * pc)
>+{
>+    GL_CALL(EvalMesh1)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalPoint1(GLbyte * pc)
>+{
>+    GL_CALL(EvalPoint1)(
>+         (GLint   )bswap_CARD32 ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalMesh2(GLbyte * pc)
>+{
>+    GL_CALL(EvalMesh2)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_EvalPoint2(GLbyte * pc)
>+{
>+    GL_CALL(EvalPoint2)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_AlphaFunc(GLbyte * pc)
>+{
>+    GL_CALL(AlphaFunc)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_BlendFunc(GLbyte * pc)
>+{
>+    GL_CALL(BlendFunc)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_LogicOp(GLbyte * pc)
>+{
>+    GL_CALL(LogicOp)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_StencilFunc(GLbyte * pc)
>+{
>+    GL_CALL(StencilFunc)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLuint  )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_StencilOp(GLbyte * pc)
>+{
>+    GL_CALL(StencilOp)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_DepthFunc(GLbyte * pc)
>+{
>+    GL_CALL(DepthFunc)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PixelZoom(GLbyte * pc)
>+{
>+    GL_CALL(PixelZoom)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_PixelTransferf(GLbyte * pc)
>+{
>+    GL_CALL(PixelTransferf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_PixelTransferi(GLbyte * pc)
>+{
>+    GL_CALL(PixelTransferi)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+int __glXDispSwap_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(PixelStoref)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLfloat )bswap_FLOAT32( pc +  4 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GL_CALL(PixelStorei)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_PixelMapfv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(PixelMapfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_PixelMapuiv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(PixelMapuiv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_PixelMapusv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(PixelMapusv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_ReadBuffer(GLbyte * pc)
>+{
>+    GL_CALL(ReadBuffer)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_CopyPixels(GLbyte * pc)
>+{
>+    GL_CALL(CopyPixels)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLenum  )bswap_ENUM   ( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_DrawPixels(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(DrawPixels)(
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLenum  )bswap_ENUM   ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+        pixels
>+    );
>+}
>+int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetBooleanv_size(pname);
>+        GLboolean answerBuffer[200];
>+        GLboolean * params = __glXGetAnswerBuffer(cl, compsize * 1, answerBuffer, sizeof(answerBuffer), 1);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetBooleanv)(
>+            pname,
>+            params
>+        );
>+        __glXSendReplySwap(cl->client, params, compsize, 1, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble equation[4];
>+        GL_CALL(GetClipPlane)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            equation
>+        );
>+        (void) bswap_64_array( (uint64_t *) equation, 4 );
>+        __glXSendReplySwap(cl->client, equation, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetDoublev_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetDoublev)(
>+            pname,
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = GL_CALL(GetError)();
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetFloatv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetFloatv)(
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetIntegerv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetIntegerv)(
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetLightfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetLightfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetLightiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetLightiv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapdv_size(target,query);
>+        GLdouble answerBuffer[200];
>+        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapdv)(
>+            target,
>+            query,
>+            v
>+        );
>+        (void) bswap_64_array( (uint64_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapfv_size(target,query);
>+        GLfloat answerBuffer[200];
>+        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapfv)(
>+            target,
>+            query,
>+            v
>+        );
>+        (void) bswap_32_array( (uint32_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapiv_size(target,query);
>+        GLint answerBuffer[200];
>+        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMapiv)(
>+            target,
>+            query,
>+            v
>+        );
>+        (void) bswap_32_array( (uint32_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMaterialfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMaterialfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMaterialiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMaterialiv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapfv_size(map);
>+        GLfloat answerBuffer[200];
>+        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapfv)(
>+            map,
>+            values
>+        );
>+        (void) bswap_32_array( (uint32_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapuiv_size(map);
>+        GLuint answerBuffer[200];
>+        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapuiv)(
>+            map,
>+            values
>+        );
>+        (void) bswap_32_array( (uint32_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapusv_size(map);
>+        GLushort answerBuffer[200];
>+        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetPixelMapusv)(
>+            map,
>+            values
>+        );
>+        (void) bswap_16_array( (uint16_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 2, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexEnvfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexEnvfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexEnviv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexEnviv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGendv_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGendv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGenfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGenfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGeniv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexGeniv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
>+
>+        const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexLevelParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
>+
>+        const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetTexLevelParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsEnabled)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsList)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_DepthRange(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(DepthRange)(
>+         (GLclampd)bswap_FLOAT64( pc +  0 ),
>+         (GLclampd)bswap_FLOAT64( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Frustum(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Frustum)(
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 ),
>+         (GLdouble)bswap_FLOAT64( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc + 40 )
>+    );
>+}
>+
>+void __glXDispSwap_LoadIdentity(GLbyte * pc)
>+{
>+    GL_CALL(LoadIdentity)();
>+}
>+
>+void __glXDispSwap_LoadMatrixf(GLbyte * pc)
>+{
>+    GL_CALL(LoadMatrixf)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
>+    );
>+}
>+
>+void __glXDispSwap_LoadMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(LoadMatrixd)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
>+    );
>+}
>+
>+void __glXDispSwap_MatrixMode(GLbyte * pc)
>+{
>+    GL_CALL(MatrixMode)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_MultMatrixf(GLbyte * pc)
>+{
>+    GL_CALL(MultMatrixf)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
>+    );
>+}
>+
>+void __glXDispSwap_MultMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultMatrixd)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
>+    );
>+}
>+
>+void __glXDispSwap_Ortho(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Ortho)(
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 ),
>+         (GLdouble)bswap_FLOAT64( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc + 40 )
>+    );
>+}
>+
>+void __glXDispSwap_PopMatrix(GLbyte * pc)
>+{
>+    GL_CALL(PopMatrix)();
>+}
>+
>+void __glXDispSwap_PushMatrix(GLbyte * pc)
>+{
>+    GL_CALL(PushMatrix)();
>+}
>+
>+void __glXDispSwap_Rotated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Rotated)(
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 )
>+    );
>+}
>+
>+void __glXDispSwap_Rotatef(GLbyte * pc)
>+{
>+    GL_CALL(Rotatef)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLfloat )bswap_FLOAT32( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_Scaled(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Scaled)(
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_Scalef(GLbyte * pc)
>+{
>+    GL_CALL(Scalef)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Translated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(Translated)(
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_Translatef(GLbyte * pc)
>+{
>+    GL_CALL(Translatef)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_Viewport(GLbyte * pc)
>+{
>+    GL_CALL(Viewport)(
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_BindTexture(GLbyte * pc)
>+{
>+    GL_CALL(BindTexture)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_Indexubv(GLbyte * pc)
>+{
>+    GL_CALL(Indexubv)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_PolygonOffset(GLbyte * pc)
>+{
>+    GL_CALL(PolygonOffset)(
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreTexturesResident)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_CopyTexImage1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexImage1D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 )
>+    );
>+}
>+
>+void __glXDispSwap_CopyTexImage2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexImage2D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 )
>+    );
>+}
>+
>+void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage1D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 )
>+    );
>+}
>+
>+void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage2D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 )
>+    );
>+}
>+
>+int __glXDispSwap_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GL_CALL(DeleteTextures)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenTextures)(
>+            n,
>+            textures
>+        );
>+        (void) bswap_32_array( (uint32_t *) textures, n );
>+        __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsTexture)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_PrioritizeTextures(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    GL_CALL(PrioritizeTextures)(
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+         (const GLclampf *)bswap_32_array( (uint32_t *) (pc + 4+n*4), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_TexSubImage1D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexSubImage1D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_TexSubImage2D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexSubImage2D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLint   )bswap_CARD32 ( pc + 32 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLsizei )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_BlendColor(GLbyte * pc)
>+{
>+    GL_CALL(BlendColor)(
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 ),
>+         (GLclampf)bswap_FLOAT32( pc +  8 ),
>+         (GLclampf)bswap_FLOAT32( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_BlendEquation(GLbyte * pc)
>+{
>+    GL_CALL(BlendEquation)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ColorTable(GLbyte * pc)
>+{
>+    const GLvoid * const table = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(ColorTable)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+        table
>+    );
>+}
>+void __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameterfv_size(pname) );
>+
>+    GL_CALL(ColorTableParameterfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameteriv_size(pname) );
>+
>+    GL_CALL(ColorTableParameteriv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_CopyColorTable(GLbyte * pc)
>+{
>+    GL_CALL(CopyColorTable)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    );
>+}
>+
>+int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetColorTableParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetColorTableParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ColorSubTable(GLbyte * pc)
>+{
>+    const GLvoid * const data = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(ColorSubTable)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+        data
>+    );
>+}
>+void __glXDispSwap_CopyColorSubTable(GLbyte * pc)
>+{
>+    GL_CALL(CopyColorSubTable)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLsizei )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(ConvolutionFilter1D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 40 ),
>+        image
>+    );
>+}
>+void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(ConvolutionFilter2D)(
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 40 ),
>+        image
>+    );
>+}
>+void __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
>+{
>+    GL_CALL(ConvolutionParameterf)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameterfv_size(pname) );
>+
>+    GL_CALL(ConvolutionParameterfv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
>+{
>+    GL_CALL(ConvolutionParameteri)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    );
>+}
>+
>+void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameteriv_size(pname) );
>+
>+    GL_CALL(ConvolutionParameteriv)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
>+{
>+    GL_CALL(CopyConvolutionFilter1D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    );
>+}
>+
>+void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
>+{
>+    GL_CALL(CopyConvolutionFilter2D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 )
>+    );
>+}
>+
>+int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetConvolutionParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetConvolutionParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetHistogramParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetHistogramParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMinmaxParameterfv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetMinmaxParameteriv)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_Histogram(GLbyte * pc)
>+{
>+    GL_CALL(Histogram)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLsizei )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+        *(GLboolean *)(pc + 12)
>+    );
>+}
>+
>+void __glXDispSwap_Minmax(GLbyte * pc)
>+{
>+    GL_CALL(Minmax)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        *(GLboolean *)(pc +  8)
>+    );
>+}
>+
>+void __glXDispSwap_ResetHistogram(GLbyte * pc)
>+{
>+    GL_CALL(ResetHistogram)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_ResetMinmax(GLbyte * pc)
>+{
>+    GL_CALL(ResetMinmax)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_TexImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 80);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexImage3D)(
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLint   )bswap_CARD32 ( pc + 44 ),
>+         (GLsizei )bswap_CARD32 ( pc + 48 ),
>+         (GLsizei )bswap_CARD32 ( pc + 52 ),
>+         (GLsizei )bswap_CARD32 ( pc + 56 ),
>+         (GLint   )bswap_CARD32 ( pc + 64 ),
>+         (GLenum  )bswap_ENUM   ( pc + 68 ),
>+         (GLenum  )bswap_ENUM   ( pc + 72 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_TexSubImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 84);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 88);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES,   bswap_CARD32( & hdr->swapBytes ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST,    bswap_CARD32( & hdr->lsbFirst ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels ));
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment ));
>+
>+    GL_CALL(TexSubImage3D)(
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLint   )bswap_CARD32 ( pc + 44 ),
>+         (GLint   )bswap_CARD32 ( pc + 48 ),
>+         (GLint   )bswap_CARD32 ( pc + 52 ),
>+         (GLsizei )bswap_CARD32 ( pc + 60 ),
>+         (GLsizei )bswap_CARD32 ( pc + 64 ),
>+         (GLsizei )bswap_CARD32 ( pc + 68 ),
>+         (GLenum  )bswap_ENUM   ( pc + 76 ),
>+         (GLenum  )bswap_ENUM   ( pc + 80 ),
>+        pixels
>+    );
>+}
>+void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
>+{
>+    GL_CALL(CopyTexSubImage3D)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 )
>+    );
>+}
>+
>+void __glXDispSwap_ActiveTextureARB(GLbyte * pc)
>+{
>+    GL_CALL(ActiveTextureARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord1dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1ivARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord1svARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord2dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc + 16 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2ivARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord2svARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord3dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3ivARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord3svARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(MultiTexCoord4dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4ivARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc)
>+{
>+    GL_CALL(MultiTexCoord4svARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_SampleCoverageARB(GLbyte * pc)
>+{
>+    GL_CALL(SampleCoverageARB)(
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+        *(GLboolean *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_DrawBuffersARB(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    GL_CALL(DrawBuffersARB)(
>+        n,
>+         (const GLenum *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    );
>+}
>+
>+int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreTexturesResidentEXT)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenTexturesEXT)(
>+            n,
>+            textures
>+        );
>+        (void) bswap_32_array( (uint32_t *) textures, n );
>+        __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsTextureEXT)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_SampleMaskSGIS(GLbyte * pc)
>+{
>+    GL_CALL(SampleMaskSGIS)(
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+        *(GLboolean *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_SamplePatternSGIS(GLbyte * pc)
>+{
>+    GL_CALL(SamplePatternSGIS)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_PointParameterfEXT(GLbyte * pc)
>+{
>+    GL_CALL(PointParameterfEXT)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_PointParameterfvEXT(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameterfvEXT_size(pname) );
>+
>+    GL_CALL(PointParameterfvEXT)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc)
>+{
>+    GL_CALL(WindowPos3fvMESA)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc)
>+{
>+    GL_CALL(BlendFuncSeparateEXT)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_FogCoordfvEXT(GLbyte * pc)
>+{
>+    GL_CALL(FogCoordfvEXT)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_FogCoorddvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(FogCoorddvEXT)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
>+
>+    GL_CALL(CompressedTexImage3DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 24 );
>+
>+    GL_CALL(CompressedTexImage2DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 28)
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
>+
>+    GL_CALL(CompressedTexImage1DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 36 );
>+
>+    GL_CALL(CompressedTexSubImage3DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 40)
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
>+
>+    GL_CALL(CompressedTexSubImage2DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
>+
>+    GL_CALL(CompressedTexSubImage1DARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLenum  )bswap_ENUM   ( pc + 16 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3bvEXT)(
>+         (const GLbyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(SecondaryColor3dvEXT)(
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3fvEXT)(
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3ivEXT)(
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3svEXT)(
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3ubvEXT)(
>+         (const GLubyte *)(pc +  0)
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3uivEXT)(
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc)
>+{
>+    GL_CALL(SecondaryColor3usvEXT)(
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+int __glXDispSwap_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n * 1, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = GL_CALL(AreProgramsResidentNV)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BindProgramNV(GLbyte * pc)
>+{
>+    GL_CALL(BindProgramNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+int __glXDispSwap_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GL_CALL(DeleteProgramsNV)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ExecuteProgramNV(GLbyte * pc)
>+{
>+    GL_CALL(ExecuteProgramNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    );
>+}
>+
>+int __glXDispSwap_GenProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenProgramsNV)(
>+            n,
>+            ids
>+        );
>+        (void) bswap_32_array( (uint32_t *) ids, n );
>+        __glXSendReplySwap(cl->client, ids, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramParameterdvNV)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramParameterfvNV)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetProgramivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetProgramivNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        GL_CALL(GetTrackMatrixivNV)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, 1 );
>+        __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribdvARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribfvARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribivARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsProgramNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsProgramNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_LoadProgramNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
>+
>+    GL_CALL(LoadProgramNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        len,
>+         (const GLubyte *)(pc + 12)
>+    );
>+}
>+
>+void __glXDispSwap_ProgramParameter4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramParameter4dvNV)(
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLuint  )bswap_CARD32 ( pc + 36 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc)
>+{
>+    GL_CALL(ProgramParameter4fvNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc)
>+{
>+    const GLuint num =  (GLuint  )bswap_CARD32 ( pc +  8 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramParameters4dvNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        num,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 12), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc)
>+{
>+    const GLuint num =  (GLuint  )bswap_CARD32 ( pc +  8 );
>+
>+    GL_CALL(ProgramParameters4fvNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        num,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc + 12), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    GL_CALL(RequestResidentProgramsNV)(
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_TrackMatrixNV(GLbyte * pc)
>+{
>+    GL_CALL(TrackMatrixNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib1dvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  8 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1fvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1svARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib2dvARB)(
>+         (GLuint  )bswap_CARD32 ( pc + 16 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2fvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2svARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib3dvARB)(
>+         (GLuint  )bswap_CARD32 ( pc + 24 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3fvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3svARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib4dvARB)(
>+         (GLuint  )bswap_CARD32 ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4fvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4svARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NubvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs1dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs1fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs1svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs2dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs2fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs2svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs3dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs3fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs3svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttribs4dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs4fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs4svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(VertexAttribs4ubvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLubyte *)(pc +  8)
>+    );
>+}
>+
>+void __glXDispSwap_PointParameteriNV(GLbyte * pc)
>+{
>+    GL_CALL(PointParameteriNV)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_PointParameterivNV(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameterivNV_size(pname) );
>+
>+    GL_CALL(PointParameterivNV)(
>+        pname,
>+        params
>+    );
>+}
>+
>+void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
>+{
>+    GL_CALL(ActiveStencilFaceEXT)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4bvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLbyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ivARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ubvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4usvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4uivARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NbvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLbyte *)(pc +  4)
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NsvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NivARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NusvARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4NuivARB)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramStringARB(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
>+
>+    GL_CALL(ProgramStringARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        len,
>+         (const GLvoid *)(pc + 12)
>+    );
>+}
>+
>+void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramEnvParameter4dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLuint  )bswap_CARD32 ( pc + 36 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(ProgramEnvParameter4fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramLocalParameter4dvARB)(
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLuint  )bswap_CARD32 ( pc + 36 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
>+{
>+    GL_CALL(ProgramLocalParameter4fvARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    );
>+}
>+
>+int __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramEnvParameterdvARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramEnvParameterfvARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        GL_CALL(GetProgramLocalParameterdvARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        GL_CALL(GetProgramLocalParameterfvARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetProgramivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetProgramivARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    GL_CALL(ProgramNamedParameter4fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        len,
>+         (const GLubyte *)(pc + 24),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc + 36 );
>+
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(ProgramNamedParameter4dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc + 32 ),
>+        len,
>+         (const GLubyte *)(pc + 40),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+int __glXDispSwap_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+        GLfloat params[4];
>+        GL_CALL(GetProgramNamedParameterfvNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+        GLdouble params[4];
>+        GL_CALL(GetProgramNamedParameterdvNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        GL_CALL(GenQueriesARB)(
>+            n,
>+            ids
>+        );
>+        (void) bswap_32_array( (uint32_t *) ids, n );
>+        __glXSendReplySwap(cl->client, ids, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GL_CALL(DeleteQueriesARB)(
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsQueryARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = GL_CALL(IsQueryARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BeginQueryARB(GLbyte * pc)
>+{
>+    GL_CALL(BeginQueryARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    );
>+}
>+
>+void __glXDispSwap_EndQueryARB(GLbyte * pc)
>+{
>+    GL_CALL(EndQueryARB)(
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    );
>+}
>+
>+int __glXDispSwap_GetQueryivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryivARB)(
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryObjectivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryObjectivARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
>+        GLuint answerBuffer[200];
>+        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetQueryObjectuivARB)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribdvNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribfvNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        GL_CALL(GetVertexAttribivNV)(
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            pname,
>+            params
>+        );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib1dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  8 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib1svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib2dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc + 16 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib2svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib3dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc + 24 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib3svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    GL_CALL(VertexAttrib4dvNV)(
>+         (GLuint  )bswap_CARD32 ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4fvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4svNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
>+{
>+    GL_CALL(VertexAttrib4ubvNV)(
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    );
>+}
>+
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_util.c Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_util.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/indirect_util.c	2005-04-12 19:47:41.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/indirect_util.c	2005-04-12 15:24:55.000000000 -0700
>@@ -26,6 +26,13 @@
> #include <X11/Xmd.h>
> #include <GL/gl.h>
> #include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "singlesize.h"
> #include "glapitable.h"
> #include "glapi.h"
> #include "glthread.h"
>@@ -37,16 +44,151 @@
> #endif
> 
> 
>+#define __GLX_PAD(a) (((a)+3)&~3)
>+
>+extern xGLXSingleReply __glXReply;
>+
>+
> HIDDEN GLint
> __glGetBooleanv_variable_size( GLenum e )
> {
>     if ( e == GL_COMPRESSED_TEXTURE_FORMATS ) {
> 	GLint temp;
> 
>-	glGetIntegerv( GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp );
>+	GL_CALL(GetIntegerv)( GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp );
> 	return temp;
>     }
>     else {
> 	return 0;
>     }
> }
>+
>+
>+/**
>+ * Get a properly aligned buffer to hold reply data.
>+ *
>+ * \warning
>+ * This function assumes that \c local_buffer is already properly aligned.
>+ * It also assumes that \c alignment is a power of two.
>+ */
>+HIDDEN void *
>+__glXGetAnswerBuffer( __GLXclientState * cl, size_t required_size,
>+    void * local_buffer, size_t local_size, unsigned alignment )
>+{
>+    void * buffer = local_buffer;
>+    const unsigned mask = alignment - 1;
>+
>+    if ( local_size < required_size ) {
>+        const size_t worst_case_size = required_size + alignment;
>+        intptr_t  temp_buf;
>+
>+        if ( cl->returnBufSize < worst_case_size ) {
>+	    void * temp = xrealloc( cl->returnBuf, worst_case_size );
>+	    
>+	    if ( temp == NULL ) {
>+	        return NULL;
>+	    }
>+	    
>+	    cl->returnBuf = temp;
>+	    cl->returnBufSize = worst_case_size;
>+	}
>+	
>+	temp_buf = (intptr_t) cl->returnBuf;
>+	temp_buf = (temp_buf + mask) & ~mask;
>+	buffer = (void *) temp_buf;
>+    }
>+
>+    return buffer;
>+}
>+
>+
>+/**
>+ * Send a GLX reply to the client.
>+ *
>+ * Technically speaking, there are several different ways to encode a GLX
>+ * reply.  The primary difference is whether or not certain fields (e.g.,
>+ * retval, size, and "pad3") are set.  This function gets around that by
>+ * always setting all of the fields to "reasonable" values.  This does no
>+ * harm to clients, but it does make the server-side code much more compact.
>+ */
>+HIDDEN void
>+__glXSendReply( ClientPtr client, const void * data, size_t elements,
>+    size_t element_size, GLboolean always_array, CARD32 retval )
>+{
>+    size_t reply_ints = 0;
>+
>+    if ( __glXErrorOccured() ) {
>+        elements = 0;
>+    }
>+    else if ( (elements > 1) || always_array ) {
>+        reply_ints = ((elements * element_size) + 3) >> 2;
>+    }
>+
>+    __glXReply.length =         reply_ints;
>+    __glXReply.type =           X_Reply;
>+    __glXReply.sequenceNumber = client->sequence;
>+    __glXReply.size =           elements;
>+    __glXReply.retval =         retval;
>+
>+
>+    /* It is faster on almost always every architecture to just copy the 8
>+     * bytes, even when not necessary, than check to see of the value of
>+     * elements requires it.  Copying the data when not needed will do no
>+     * harm.
>+     */
>+
>+    (void) memcpy( & __glXReply.pad3, data, 8 );
>+    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
>+
>+    if ( reply_ints != 0 ) {
>+        WriteToClient( client, reply_ints * 4, (char *) data );
>+    }
>+}
>+
>+
>+/**
>+ * Send a GLX reply to the client.
>+ *
>+ * Technically speaking, there are several different ways to encode a GLX
>+ * reply.  The primary difference is whether or not certain fields (e.g.,
>+ * retval, size, and "pad3") are set.  This function gets around that by
>+ * always setting all of the fields to "reasonable" values.  This does no
>+ * harm to clients, but it does make the server-side code much more compact.
>+ *
>+ * \warning
>+ * This function assumes that values stored in \c data will be byte-swapped
>+ * by the caller if necessary.
>+ */
>+HIDDEN void
>+__glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
>+    size_t element_size, GLboolean always_array, CARD32 retval )
>+{
>+    size_t reply_ints = 0;
>+
>+    if ( __glXErrorOccured() ) {
>+        elements = 0;
>+    }
>+    else if ( (elements > 1) || always_array ) {
>+        reply_ints = ((elements * element_size) + 3) >> 2;
>+    }
>+
>+    __glXReply.length =         bswap_32( reply_ints );
>+    __glXReply.type =           bswap_32( X_Reply );
>+    __glXReply.sequenceNumber = bswap_32( client->sequence );
>+    __glXReply.size =           bswap_32( elements );
>+    __glXReply.retval =         bswap_32( retval );
>+
>+
>+    /* It is faster on almost always every architecture to just copy the 8
>+     * bytes, even when not necessary, than check to see of the value of
>+     * elements requires it.  Copying the data when not needed will do no
>+     * harm.
>+     */
>+
>+    (void) memcpy( & __glXReply.pad3, data, 8 );
>+    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
>+
>+    if ( reply_ints != 0 ) {
>+        WriteToClient( client, reply_ints * 4, (char *) data );
>+    }
>+}
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/render2.c Xorg-dispatch/xc/programs/Xserver/GL/glx/render2.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/render2.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/render2.c	2005-04-12 20:53:48.000000000 -0700
>@@ -37,8 +37,10 @@
> /* #define NEED_REPLIES */
> #include <glxserver.h>
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> extern GLint __glEvalComputeK(GLenum target);
> 
>@@ -55,7 +57,7 @@
>     points = (GLfloat *)(pc + 16);
>     k = __glEvalComputeK(target);
> 
>-    glMap1f(target, u1, u2, k, order, points);
>+    GL_CALL(Map1f)(target, u1, u2, k, order, points);
> }
> 
> void __glXDisp_Map2f(GLbyte *pc)
>@@ -77,7 +79,7 @@
>     ustride = vorder * k;
>     vstride = k;
> 
>-    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>+    GL_CALL(Map2f)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
> }
> 
> void __glXDisp_Map1d(GLbyte *pc)
>@@ -119,7 +121,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap1d(target, u1, u2, k, order, points);
>+    GL_CALL(Map1d)(target, u1, u2, k, order, points);
> }
> 
> void __glXDisp_Map2d(GLbyte *pc)
>@@ -167,17 +169,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>-}
>-
>-void __glXDisp_CallLists(GLbyte *pc)
>-{
>-    GLenum type;
>-    GLsizei n;
>-
>-    type = *(GLenum *)(pc + 4);
>-    n = *(GLsizei *)(pc + 0);
>-    glCallLists(n, type, pc + 8);
>+    GL_CALL(Map2d)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
> }
> 
> void __glXDisp_DrawArrays(GLbyte *pc)
>@@ -211,36 +203,36 @@
> 
> 	switch (component) {
> 	  case GL_VERTEX_ARRAY:
>-	    glEnableClientState(GL_VERTEX_ARRAY);
>-	    glVertexPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_VERTEX_ARRAY);
>+	    GL_CALL(VertexPointer)(numVals, datatype, stride, pc);
> 	    break;
> 	  case GL_NORMAL_ARRAY:
>-	    glEnableClientState(GL_NORMAL_ARRAY);
>-	    glNormalPointer(datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_NORMAL_ARRAY);
>+	    GL_CALL(NormalPointer)(datatype, stride, pc);
> 	    break;
> 	  case GL_COLOR_ARRAY:
>-	    glEnableClientState(GL_COLOR_ARRAY);
>-	    glColorPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_COLOR_ARRAY);
>+	    GL_CALL(ColorPointer)(numVals, datatype, stride, pc);
> 	    break;
> 	  case GL_INDEX_ARRAY:
>-	    glEnableClientState(GL_INDEX_ARRAY);
>-	    glIndexPointer(datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_INDEX_ARRAY);
>+	    GL_CALL(IndexPointer)(datatype, stride, pc);
> 	    break;
> 	  case GL_TEXTURE_COORD_ARRAY:
>-	    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>-	    glTexCoordPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_TEXTURE_COORD_ARRAY);
>+	    GL_CALL(TexCoordPointer)(numVals, datatype, stride, pc);
> 	    break;
> 	  case GL_EDGE_FLAG_ARRAY:
>-	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
>-	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
>+	    GL_CALL(EnableClientState)(GL_EDGE_FLAG_ARRAY);
>+	    GL_CALL(EdgeFlagPointer)(stride, (const GLboolean *)pc);
> 	    break;
> 	  case GL_SECONDARY_COLOR_ARRAY:
>-	    glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
>-	    glSecondaryColorPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_SECONDARY_COLOR_ARRAY);
>+	    GL_CALL(SecondaryColorPointerEXT)(numVals, datatype, stride, pc);
> 	    break;
> 	  case GL_FOG_COORD_ARRAY:
>-	    glEnableClientState(GL_FOG_COORD_ARRAY);
>-	    glFogCoordPointer(datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_FOG_COORD_ARRAY);
>+	    GL_CALL(FogCoordPointerEXT)(datatype, stride, pc);
> 	    break;
> 	  default:
> 	    break;
>@@ -249,17 +241,17 @@
> 	pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
>     }
> 
>-    glDrawArrays(primType, 0, numVertexes);
>+    GL_CALL(DrawArrays)(primType, 0, numVertexes);
> 
>     /* turn off anything we might have turned on */
>-    glDisableClientState(GL_VERTEX_ARRAY);
>-    glDisableClientState(GL_NORMAL_ARRAY);
>-    glDisableClientState(GL_COLOR_ARRAY);
>-    glDisableClientState(GL_INDEX_ARRAY);
>-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>-    glDisableClientState(GL_EDGE_FLAG_ARRAY);
>-    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
>-    glDisableClientState(GL_FOG_COORD_ARRAY);
>+    GL_CALL(DisableClientState)(GL_VERTEX_ARRAY);
>+    GL_CALL(DisableClientState)(GL_NORMAL_ARRAY);
>+    GL_CALL(DisableClientState)(GL_COLOR_ARRAY);
>+    GL_CALL(DisableClientState)(GL_INDEX_ARRAY);
>+    GL_CALL(DisableClientState)(GL_TEXTURE_COORD_ARRAY);
>+    GL_CALL(DisableClientState)(GL_EDGE_FLAG_ARRAY);
>+    GL_CALL(DisableClientState)(GL_SECONDARY_COLOR_ARRAY);
>+    GL_CALL(DisableClientState)(GL_FOG_COORD_ARRAY);
> }
> 
> void __glXDisp_DrawArraysEXT(GLbyte *pc)
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/render2swap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/render2swap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/render2swap.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/render2swap.c	2005-04-12 20:51:39.000000000 -0700
>@@ -39,6 +39,10 @@
> #include "unpack.h"
> #include "g_disptab.h"
> #include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> extern GLint __glEvalComputeK(GLenum target);
> 
>@@ -71,7 +75,7 @@
>     }
>     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
> 
>-    glMap1f(target, u1, u2, k, order, points);
>+    GL_CALL(Map1f)(target, u1, u2, k, order, points);
> }
> 
> void __glXDispSwap_Map2f(GLbyte *pc)
>@@ -112,7 +116,7 @@
>     }
>     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
> 
>-    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>+    GL_CALL(Map2f)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
> }
> 
> void __glXDispSwap_Map1d(GLbyte *pc)
>@@ -156,7 +160,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap1d(target, u1, u2, k, order, points);
>+    GL_CALL(Map1d)(target, u1, u2, k, order, points);
> }
> 
> void __glXDispSwap_Map2d(GLbyte *pc)
>@@ -208,42 +212,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>-}
>-
>-void __glXDispSwap_CallLists(GLbyte *pc)
>-{
>-    GLenum type;
>-    GLsizei n;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-    __GLX_SWAP_INT(pc + 4);
>-    __GLX_SWAP_INT(pc + 0);
>-    type = *(GLenum *)(pc + 4);
>-    n = *(GLsizei *)(pc + 0);
>-
>-    switch (type) {
>-      case GL_BYTE:
>-      case GL_UNSIGNED_BYTE:
>-      case GL_2_BYTES:
>-      case GL_3_BYTES:
>-      case GL_4_BYTES:
>-	break;
>-      case GL_SHORT:
>-      case GL_UNSIGNED_SHORT:
>-	__GLX_SWAP_SHORT_ARRAY(pc+8, n);
>-	break;
>-      case GL_INT:
>-      case GL_UNSIGNED_INT:
>-	__GLX_SWAP_INT_ARRAY(pc+8, n);
>-	break;
>-      case GL_FLOAT:
>-	__GLX_SWAP_FLOAT_ARRAY(pc+8, n);
>-	break;
>-    }
>-
>-    glCallLists(n, type, pc+8);
>+    GL_CALL(Map2d)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
> }
> 
> static void swapArray(GLint numVals, GLenum datatype,
>@@ -343,28 +312,28 @@
> 
>         switch (component) {
>           case GL_VERTEX_ARRAY:
>-	    glEnableClientState(GL_VERTEX_ARRAY);
>-	    glVertexPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_VERTEX_ARRAY);
>+	    GL_CALL(VertexPointer)(numVals, datatype, stride, pc);
>             break;
>           case GL_NORMAL_ARRAY:
>-	    glEnableClientState(GL_NORMAL_ARRAY);
>-	    glNormalPointer(datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_NORMAL_ARRAY);
>+	    GL_CALL(NormalPointer)(datatype, stride, pc);
>             break;
>           case GL_COLOR_ARRAY:
>-	    glEnableClientState(GL_COLOR_ARRAY);
>-	    glColorPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_COLOR_ARRAY);
>+	    GL_CALL(ColorPointer)(numVals, datatype, stride, pc);
>             break;
>           case GL_INDEX_ARRAY:
>-	    glEnableClientState(GL_INDEX_ARRAY);
>-	    glIndexPointer(datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_INDEX_ARRAY);
>+	    GL_CALL(IndexPointer)(datatype, stride, pc);
>             break;
>           case GL_TEXTURE_COORD_ARRAY:
>-	    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>-	    glTexCoordPointer(numVals, datatype, stride, pc);
>+	    GL_CALL(EnableClientState)(GL_TEXTURE_COORD_ARRAY);
>+	    GL_CALL(TexCoordPointer)(numVals, datatype, stride, pc);
>             break;
>           case GL_EDGE_FLAG_ARRAY:
>-	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
>-	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
>+	    GL_CALL(EnableClientState)(GL_EDGE_FLAG_ARRAY);
>+	    GL_CALL(EdgeFlagPointer)(stride, (const GLboolean *)pc);
>             break;
>           default:
>             break;
>@@ -373,15 +342,15 @@
>         pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
>     }
> 
>-    glDrawArrays(primType, 0, numVertexes);
>+    GL_CALL(DrawArrays)(primType, 0, numVertexes);
> 
>     /* turn off anything we might have turned on */
>-    glDisableClientState(GL_VERTEX_ARRAY);
>-    glDisableClientState(GL_NORMAL_ARRAY);
>-    glDisableClientState(GL_COLOR_ARRAY);
>-    glDisableClientState(GL_INDEX_ARRAY);
>-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>-    glDisableClientState(GL_EDGE_FLAG_ARRAY);
>+    GL_CALL(DisableClientState)(GL_VERTEX_ARRAY);
>+    GL_CALL(DisableClientState)(GL_NORMAL_ARRAY);
>+    GL_CALL(DisableClientState)(GL_COLOR_ARRAY);
>+    GL_CALL(DisableClientState)(GL_INDEX_ARRAY);
>+    GL_CALL(DisableClientState)(GL_TEXTURE_COORD_ARRAY);
>+    GL_CALL(DisableClientState)(GL_EDGE_FLAG_ARRAY);
> }
> 
> void __glXDispSwap_DrawArraysEXT(GLbyte *pc)
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/renderpix.c Xorg-dispatch/xc/programs/Xserver/GL/glx/renderpix.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/renderpix.c	2005-04-12 20:00:45.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/renderpix.c	2005-04-12 15:31:22.000000000 -0700
>@@ -37,247 +37,11 @@
> #define NEED_REPLIES
> #include "glxserver.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-
>-void __glXDisp_PolygonStipple(GLbyte *pc)
>-{
>-    __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glPolygonStipple((GLubyte *)(hdr+1));
>-}
>-
>-void __glXDisp_Bitmap(GLbyte *pc)
>-{
>-    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glBitmap((GLsizei) hdr->width,
>-	     (GLsizei) hdr->height,
>-	     (GLfloat) hdr->xorig,
>-	     (GLfloat) hdr->yorig,
>-	     (GLfloat) hdr->xmove,
>-	     (GLfloat) hdr->ymove,
>-	     (GLubyte *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage1D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage2D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
>-		 hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_DrawPixels(GLbyte *pc)
>-{
>-    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glDrawPixels((GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage1D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLsizei) hdr->width,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage2D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLint) hdr->yoffset,
>-		    (GLsizei) hdr->width,
>-		    (GLsizei) hdr->height,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImage3DHeader *hdr =
>-				(__GLXdispatchTexSubImage3DHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
>-		       hdr->zoffset, hdr->width, hdr->height, hdr->depth,
>-		       hdr->format, hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ColorTable(GLbyte *pc)
>-{
>-   __GLXdispatchColorTableHeader *hdr =
>-				(__GLXdispatchColorTableHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorTable(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ColorSubTable(GLbyte *pc)
>-{
>-   __GLXdispatchColorSubTableHeader *hdr =
>-				(__GLXdispatchColorSubTableHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
>-		    hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ConvolutionFilter1D(GLbyte *pc)
>-{
>-   __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter1D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ConvolutionFilter2D(GLbyte *pc)
>-{
>-   __GLXdispatchConvolutionFilterHeader *hdr =
>-				 (__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
> 
> void __glXDisp_SeparableFilter2D(GLbyte *pc)
> {
>@@ -287,23 +51,21 @@
> 
>     hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_DISPATCH_HDR_SIZE);
> 
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT, hdr->alignment);
> 
>     /* XXX check this usage - internal code called
>     ** a version without the packing parameters
>     */
>-    image1len = __glXImageSize(hdr->format, hdr->type, 0,
>-			       hdr->width, 1, 1,
>-			       0, hdr->rowLength,
>-			       0, hdr->skipRows, hdr->alignment);
>+    image1len = __glXImageSize(hdr->format, hdr->type, 0, hdr->width, 1, 1,
>+			       0, hdr->rowLength, 0, hdr->skipRows, hdr->alignment);
>     image1len = __GLX_PAD(image1len);
> 
>-    glSeparableFilter2D(hdr->target, hdr->internalformat,
>+    GL_CALL(SeparableFilter2D)(hdr->target, hdr->internalformat,
> 		 hdr->width, hdr->height, hdr->format, hdr->type,
> 		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
> }
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/renderpixswap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/renderpixswap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/renderpixswap.c	2005-04-13 10:36:08.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/renderpixswap.c	2005-04-12 15:32:31.000000000 -0700
>@@ -37,472 +37,11 @@
> #define NEED_REPLIES
> #include "glxserver.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-
>-void __glXDispSwap_PolygonStipple(GLbyte *pc)
>-{
>-    __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glPolygonStipple((GLubyte *)(hdr+1));
>-}
>-
>-void __glXDispSwap_Bitmap(GLbyte *pc)
>-{
>-    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->xorig);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->yorig);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->xmove);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->ymove);
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glBitmap((GLsizei) hdr->width,
>-	     (GLsizei) hdr->height,
>-	     (GLfloat) hdr->xorig,
>-	     (GLfloat) hdr->yorig,
>-	     (GLfloat) hdr->xmove,
>-	     (GLfloat) hdr->ymove,
>-	     (GLubyte *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->components);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage1D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->components);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage2D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->depth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
>-		 hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_DrawPixels(GLbyte *pc)
>-{
>-    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glDrawPixels((GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage1D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLsizei) hdr->width,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage2D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLint) hdr->yoffset,
>-		    (GLsizei) hdr->width,
>-		    (GLsizei) hdr->height,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImage3DHeader *hdr =
>-				(__GLXdispatchTexSubImage3DHeader *) pc;
>-
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->zoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->depth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
>-		       hdr->zoffset, hdr->width, hdr->height, hdr->depth,
>-		       hdr->format, hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ColorTable(GLbyte *pc)
>-{
>-    __GLXdispatchColorTableHeader *hdr =
>-				(__GLXdispatchColorTableHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorTable(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ColorSubTable(GLbyte *pc)
>-{
>-    __GLXdispatchColorSubTableHeader *hdr =
>-				(__GLXdispatchColorSubTableHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->start);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->count);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
>-		    hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ConvolutionFilter1D(GLbyte *pc)
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, 1, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ConvolutionFilter2D(GLbyte *pc)
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
> 
> void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
> {
>@@ -529,12 +68,12 @@
>     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>     ** the pixel data.
>     */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT, hdr->alignment);
> 
>     /* XXX check this usage - internal code called
>     ** a version without the packing parameters
>@@ -544,7 +83,7 @@
>     image1len = __GLX_PAD(image1len);
> 
> 
>-    glSeparableFilter2D(hdr->target, hdr->internalformat,
>+    GL_CALL(SeparableFilter2D)(hdr->target, hdr->internalformat,
> 		 hdr->width, hdr->height, hdr->format, hdr->type,
> 		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
> }
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/single2.c Xorg-dispatch/xc/programs/Xserver/GL/glx/single2.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/single2.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/single2.c	2005-04-12 21:16:39.000000000 -0700
>@@ -38,9 +38,12 @@
> #include "glxserver.h"
> #include "glxutil.h"
> #include "glxext.h"
>+#include "indirect_dispatch.h"
> #include "unpack.h"
>-#include "g_disptab.h"
> #include "GL/glx_ansic.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -67,7 +70,7 @@
> 	}
> 	cx->feedbackBufSize = size;
>     }
>-    glFeedbackBuffer(size, type, cx->feedbackBuf);
>+    GL_CALL(FeedbackBuffer)(size, type, cx->feedbackBuf);
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -95,7 +98,7 @@
> 	}
> 	cx->selectBufSize = size;
>     }
>-    glSelectBuffer(size, cx->selectBuf);
>+    GL_CALL(SelectBuffer)(size, cx->selectBuf);
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -117,10 +120,10 @@
> 
>     pc += __GLX_SINGLE_HDR_SIZE;
>     newMode = *(GLenum*) pc;
>-    retval = glRenderMode(newMode);
>+    retval = GL_CALL(RenderMode)(newMode);
> 
>     /* Check that render mode worked */
>-    glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
>+    GL_CALL(GetIntegerv)(GL_RENDER_MODE, &newModeCheck);
>     if (newModeCheck != newMode) {
> 	/* Render mode change failed.  Bail */
> 	newMode = newModeCheck;
>@@ -208,7 +211,7 @@
> 		return error;
> 	}
> 
>-	glFlush();
>+	GL_CALL(Flush)();
> 	__GLX_NOTE_FLUSHED_CMDS(cx);
> 	return Success;
> }
>@@ -225,7 +228,7 @@
>     }
> 
>     /* Do a local glFinish */
>-    glFinish();
>+    GL_CALL(Finish)();
>     __GLX_NOTE_FLUSHED_CMDS(cx);
> 
>     /* Send empty reply packet to indicate finish is finished */
>@@ -322,7 +325,7 @@
> 
>     pc += __GLX_SINGLE_HDR_SIZE;
>     name = *(GLenum *)(pc + 0);
>-    string = (const char *)glGetString(name);
>+    string = (const char *) GL_CALL(GetString)(name);
>     client = cl->client;
> 
>     /*
>@@ -378,30 +381,3 @@
> {
>     return DoGetString(cl, pc, GL_FALSE);
> }
>-
>-int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>-{
>-    __GLXcontext *cx;
>-    ClientPtr client = cl->client;
>-    int error;
>-    GLdouble answer[4];
>-
>-    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-    if (!cx) {
>-	return error;
>-    }
>-    pc += __GLX_SINGLE_HDR_SIZE;
>-
>-    __glXClearErrorOccured();
>-    glGetClipPlane(*(GLenum   *)(pc + 0), answer);
>-    if (__glXErrorOccured()) {
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-    } else {
>-	__GLX_BEGIN_REPLY(32);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_DOUBLE_ARRAY(4);
>-    }
>-    return Success;
>-}
>-
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/single2swap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/single2swap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/single2swap.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/single2swap.c	2005-04-13 15:16:20.000000000 -0700
>@@ -39,8 +39,11 @@
> #include "glxutil.h"
> #include "glxext.h"
> #include "unpack.h"
>-#include "g_disptab.h"
> #include "GL/glx_ansic.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -71,7 +74,7 @@
> 	}
> 	cx->feedbackBufSize = size;
>     }
>-    glFeedbackBuffer(size, type, cx->feedbackBuf);
>+    GL_CALL(FeedbackBuffer)(size, type, cx->feedbackBuf);
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -102,7 +105,7 @@
> 	}
> 	cx->selectBufSize = size;
>     }
>-    glSelectBuffer(size, cx->selectBuf);
>+    GL_CALL(SelectBuffer)(size, cx->selectBuf);
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -128,10 +131,10 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     __GLX_SWAP_INT(pc);
>     newMode = *(GLenum*) pc;
>-    retval = glRenderMode(newMode);
>+    retval = GL_CALL(RenderMode)(newMode);
> 
>     /* Check that render mode worked */
>-    glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
>+    GL_CALL(GetIntegerv)(GL_RENDER_MODE, &newModeCheck);
>     if (newModeCheck != newMode) {
> 	/* Render mode change failed.  Bail */
> 	newMode = newModeCheck;
>@@ -228,7 +231,7 @@
> 		return error;
> 	}
> 
>-	glFlush();
>+	GL_CALL(Flush)();
> 	__GLX_NOTE_FLUSHED_CMDS(cx);
> 	return Success;
> }
>@@ -247,7 +250,7 @@
>     }
> 
>     /* Do a local glFinish */
>-    glFinish();
>+    GL_CALL(Finish)();
>     __GLX_NOTE_FLUSHED_CMDS(cx);
> 
>     /* Send empty reply packet to indicate finish is finished */
>@@ -264,36 +267,3 @@
> {
>     return DoGetString(cl, pc, GL_TRUE);
> }
>-
>-int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>-{
>-    __GLXcontext *cx;
>-    ClientPtr client = cl->client;
>-    int error;
>-    GLdouble answer[4];
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-    __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-    if (!cx) {
>-	return error;
>-    }
>-    pc += __GLX_SINGLE_HDR_SIZE;
>-    __GLX_SWAP_INT(pc + 0);
>-
>-    __glXClearErrorOccured();
>-    glGetClipPlane(*(GLenum   *)(pc + 0), answer);
>-    if (__glXErrorOccured()) {
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-    } else {
>-	__GLX_SWAP_DOUBLE_ARRAY((GLbyte *)answer, 4);
>-	__GLX_BEGIN_REPLY(32);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_DOUBLE_ARRAY(4);
>-    }
>-    return Success;
>-}
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/singlepix.c Xorg-dispatch/xc/programs/Xserver/GL/glx/singlepix.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/singlepix.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/singlepix.c	2005-04-13 15:16:53.000000000 -0700
>@@ -39,8 +39,10 @@
> #include "glxext.h"
> #include "singlesize.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -68,11 +70,11 @@
>     compsize = __glReadPixels_size(format,type,width,height);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_LSB_FIRST, lsbFirst);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glReadPixels(
>+    GL_CALL(ReadPixels)(
> 		 *(GLint    *)(pc + 0),
> 		 *(GLint    *)(pc + 4),
> 		 *(GLsizei  *)(pc + 8),
>@@ -116,10 +118,10 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 16);
> 
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
>+    GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_WIDTH, &width);
>+    GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_HEIGHT, &height);
>     if ( target == GL_TEXTURE_3D) {
>-	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
>+	GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_DEPTH, &depth);
>     }
>     /*
>      * The three queries above might fail if we're in a state where queries
>@@ -128,10 +130,10 @@
>     compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetTexImage(
>+    GL_CALL(GetTexImage)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLint    *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -170,11 +172,11 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     lsbFirst = *(GLboolean *)(pc + 0);
> 
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    GL_CALL(PixelStorei)(GL_PACK_LSB_FIRST, lsbFirst);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
> 
>     __glXClearErrorOccured();
>-    glGetPolygonStipple(
>+    GL_CALL(GetPolygonStipple)(
> 			(GLubyte  *) answer
> 			);
> 
>@@ -214,8 +216,8 @@
>     /* target must be SEPARABLE_2D, however I guess we can let the GL
>        barf on this one.... */
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_WIDTH, &width);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_HEIGHT, &height);
>     /*
>      * The two queries above might fail if we're in a state where queries
>      * are illegal, but then width and height would still be zero anyway.
>@@ -228,10 +230,10 @@
>     compsize = __GLX_PAD(compsize);
>     compsize2 = __GLX_PAD(compsize2);
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
>     __glXClearErrorOccured();
>-    glGetSeparableFilter(
>+    GL_CALL(GetSeparableFilter)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -276,11 +278,11 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_WIDTH, &width);
>     if (target == GL_CONVOLUTION_1D) {
>         height = 1;
>     } else {
>-	glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+	GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_HEIGHT, &height);
>     }
>     /*
>      * The two queries above might fail if we're in a state where queries
>@@ -289,10 +291,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetConvolutionFilter(
>+    GL_CALL(GetConvolutionFilter)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -336,7 +338,7 @@
>     swapBytes = *(GLboolean *)(pc + 12);
>     reset = *(GLboolean *)(pc + 13);
> 
>-    glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
>+    GL_CALL(GetHistogramParameteriv)(target, GL_HISTOGRAM_WIDTH, &width);
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -344,10 +346,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetHistogram( target, reset, format, type, answer);
>+    GL_CALL(GetHistogram)( target, reset, format, type, answer);
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -387,10 +389,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetMinmax( target, reset, format, type, answer);
>+    GL_CALL(GetMinmax)( target, reset, format, type, answer);
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -426,7 +428,7 @@
>     type = *(GLenum *)(pc + 8);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
>+    GL_CALL(GetColorTableParameteriv)(target, GL_COLOR_TABLE_WIDTH, &width);
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -434,10 +436,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetColorTable(
>+    GL_CALL(GetColorTable)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/singlepixswap.c Xorg-dispatch/xc/programs/Xserver/GL/glx/singlepixswap.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/singlepixswap.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/singlepixswap.c	2005-04-13 15:16:47.000000000 -0700
>@@ -39,8 +39,10 @@
> #include "glxext.h"
> #include "singlesize.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> int __glXDispSwap_ReadPixels(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -77,11 +79,11 @@
>     compsize = __glReadPixels_size(format,type,width,height);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_LSB_FIRST, lsbFirst);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glReadPixels(
>+    GL_CALL(ReadPixels)(
> 		 *(GLint    *)(pc + 0),
> 		 *(GLint    *)(pc + 4),
> 		 *(GLsizei  *)(pc + 8),
>@@ -134,10 +136,10 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 16);
> 
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
>+    GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_WIDTH, &width);
>+    GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_HEIGHT, &height);
>     if ( target == GL_TEXTURE_3D) {
>-	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
>+	GL_CALL(GetTexLevelParameteriv)(target, level, GL_TEXTURE_DEPTH, &depth);
>     }
>     /*
>      * The three queries above might fail if we're in a state where queries
>@@ -146,10 +148,10 @@
>     compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetTexImage(
>+    GL_CALL(GetTexImage)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLint    *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -194,11 +196,11 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     lsbFirst = *(GLboolean *)(pc + 0);
> 
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    GL_CALL(PixelStorei)(GL_PACK_LSB_FIRST, lsbFirst);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
> 
>     __glXClearErrorOccured();
>-    glGetPolygonStipple(
>+    GL_CALL(GetPolygonStipple)(
> 			(GLubyte  *) answer
> 			);
>     if (__glXErrorOccured()) {
>@@ -244,8 +246,8 @@
>     /* target must be SEPARABLE_2D, however I guess we can let the GL
>        barf on this one.... */
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_WIDTH, &width);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_HEIGHT, &height);
>     /*
>      * The two queries above might fail if we're in a state where queries
>      * are illegal, but then width and height would still be zero anyway.
>@@ -258,10 +260,10 @@
>     compsize = __GLX_PAD(compsize);
>     compsize2 = __GLX_PAD(compsize2);
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
>     __glXClearErrorOccured();
>-    glGetSeparableFilter(
>+    GL_CALL(GetSeparableFilter)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -313,11 +315,11 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>+    GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_WIDTH, &width);
>     if (target == GL_CONVOLUTION_2D) {
>         height = 1;
>     } else {
>-	glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+	GL_CALL(GetConvolutionParameteriv)(target, GL_CONVOLUTION_HEIGHT, &height);
>     }
>     /*
>      * The two queries above might fail if we're in a state where queries
>@@ -326,10 +328,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetConvolutionFilter(
>+    GL_CALL(GetConvolutionFilter)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>@@ -380,7 +382,7 @@
>     swapBytes = *(GLboolean *)(pc + 12);
>     reset = *(GLboolean *)(pc + 13);
> 
>-    glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
>+    GL_CALL(GetHistogramParameteriv)(target, GL_HISTOGRAM_WIDTH, &width);
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -388,10 +390,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetHistogram( target, reset, format, type, answer);
>+    GL_CALL(GetHistogram)( target, reset, format, type, answer);
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -437,10 +439,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetMinmax( target, reset, format, type, answer);
>+    GL_CALL(GetMinmax)( target, reset, format, type, answer);
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -481,7 +483,7 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
>+    GL_CALL(GetColorTableParameteriv)(target, GL_COLOR_TABLE_WIDTH, &width);
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -489,10 +491,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    GL_CALL(PixelStorei)(GL_PACK_SWAP_BYTES, !swapBytes);
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetColorTable(
>+    GL_CALL(GetColorTable)(
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/singlesize.c Xorg-dispatch/xc/programs/Xserver/GL/glx/singlesize.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/singlesize.c	2005-04-13 10:16:22.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/singlesize.c	2005-04-13 10:26:56.000000000 -0700
>@@ -102,7 +102,7 @@
> 	switch (query) {
> 	  case GL_COEFF:
> 	    k = EvalComputeK(target);
>-	    glGetMapiv(target, GL_ORDER, &order);
>+	    GL_CALL(GetMapiv)(target, GL_ORDER, &order);
> 	    /*
> 	    ** The query above might fail, but then order will be zero anyway.
> 	    */
>@@ -126,7 +126,7 @@
> 	  case GL_COEFF:
> 	    k = EvalComputeK(target);
> 	    majorMinor[0] = majorMinor[1] = 0;
>-	    glGetMapiv(target, GL_ORDER, majorMinor);
>+	    GL_CALL(GetMapiv)(target, GL_ORDER, majorMinor);
> 	    /*
> 	    ** The query above might fail, but then majorMinor will be zeroes
> 	    */
>@@ -195,7 +195,7 @@
>       default:
> 	return -1;
>     }
>-    glGetIntegerv(query, &size);
>+    GL_CALL(GetIntegerv)(query, &size);
>     return size;
> }
> 
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/glx/xfont.c Xorg-dispatch/xc/programs/Xserver/GL/glx/xfont.c
>--- Xorg-new-size/xc/programs/Xserver/GL/glx/xfont.c	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/glx/xfont.c	2005-04-12 21:21:52.000000000 -0700
>@@ -43,6 +43,9 @@
> #include <pixmapstr.h>
> #include <windowstr.h>
> #include <dixfontstr.h>
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
> 
> extern XID clientErrorValue;	/* imported kludge from dix layer */
> 
>@@ -92,7 +95,7 @@
> 	pglyph -= widthPadded;
> 	p += widthPadded;
>     }
>-    glBitmap(w, h, -pci->metrics.leftSideBearing, pci->metrics.descent,
>+    GL_CALL(Bitmap)(w, h, -pci->metrics.leftSideBearing, pci->metrics.descent,
> 	     pci->metrics.characterWidth, 0, allocbuf ? allocbuf : buf);
> 
>     if (allocbuf) {
>@@ -116,12 +119,12 @@
>     int rv;				/* return value */
>     int encoding = (FONTLASTROW(pFont) == 0) ? Linear16Bit : TwoD16Bit;
>     
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, FALSE);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, GLYPHPADBYTES);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SWAP_BYTES, FALSE);
>+    GL_CALL(PixelStorei)(GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ROW_LENGTH, 0);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_ROWS, 0);
>+    GL_CALL(PixelStorei)(GL_UNPACK_SKIP_PIXELS, 0);
>+    GL_CALL(PixelStorei)(GL_UNPACK_ALIGNMENT, GLYPHPADBYTES);
>     for (i=0; i < count; i++) {
> 	chs[0] = (first + i) >> 8;	/* high byte is first byte */
> 	chs[1] = first + i;
>@@ -132,14 +135,14 @@
> 	/*
> 	** Define a display list containing just a glBitmap() call.
> 	*/
>-	glNewList(list_base + i, GL_COMPILE);
>+	GL_CALL(NewList)(list_base + i, GL_COMPILE);
> 	if (nglyphs ) {
> 	    rv = __glXMakeBitmapFromGlyph(pFont, pci);
> 	    if (rv) {
> 		return rv;
> 	    }
> 	}
>-	glEndList();
>+	GL_CALL(EndList)();
>     }
>     return Success;
> }
>@@ -162,7 +165,7 @@
> 	return error;
>     }
> 
>-    glGetIntegerv(GL_LIST_INDEX, (GLint*) &currentListIndex);
>+    GL_CALL(GetIntegerv)(GL_LIST_INDEX, (GLint*) &currentListIndex);
>     if (currentListIndex != 0) {
> 	/*
> 	** A display list is currently being made.  It is an error
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/array_cache/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/array_cache/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/array_cache/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/array_cache/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaACBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/GLcore/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/GLcore/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/GLcore/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/GLcore/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define MesaInXServer
> #define MesaBuildDir ../main/
> #define MesaACBuildDir ../array_cache/
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/GLcore/module/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/GLcore/module/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/GLcore/module/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/GLcore/module/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -3,7 +3,7 @@
> #define IHaveModules
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define MesaInXServer
> #define MesaBuildDir ../../main/module/
> #define MesaACBuildDir ../../array_cache/module/
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -16,7 +16,7 @@
> #include <Server.tmpl>
> 
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/main/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/main/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/main/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/main/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -17,7 +17,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/math/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/math/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/math/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/math/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaMathBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/shader/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/shader/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/shader/Imakefile	2005-04-12 09:49:28.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/shader/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaShaderBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/swrast/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/swrast/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/swrast/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/swrast/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -16,7 +16,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaSwrastBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/swrast_setup/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/swrast_setup/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/swrast_setup/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/swrast_setup/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaSwrastSetupBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/tnl/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/tnl/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/tnl/Imakefile	2005-01-18 10:56:32.000000000 -0800
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/tnl/Imakefile	2005-04-12 13:52:40.000000000 -0700
>@@ -18,7 +18,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaTnlBuildDir /**/
> #if !defined(IHaveModules) || !BuildModuleInSubdir
>diff --exclude CVS -Nudr Xorg-new-size/xc/programs/Xserver/GL/mesa/X/Imakefile Xorg-dispatch/xc/programs/Xserver/GL/mesa/X/Imakefile
>--- Xorg-new-size/xc/programs/Xserver/GL/mesa/X/Imakefile	2005-04-13 10:41:28.000000000 -0700
>+++ Xorg-dispatch/xc/programs/Xserver/GL/mesa/X/Imakefile	2005-04-13 10:41:40.000000000 -0700
>@@ -11,7 +11,7 @@
> 
> #include <Server.tmpl>
> 
>-#define NeedAllMesaSrc
>+/*#define NeedAllMesaSrc*/
> #define NeedToLinkMesaSrc
> #define MesaXBuildDir /**/
> #define MesaInXServer

Actions: View | Splinter Review

Attachments on bug 2996: 2408 | 2409 | 2410 | 2411 | 2416 | 3543 | 3544 | 4330

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.