svn merge ^/branches/released .

16 files changed, 3785 insertions, 3898 deletions

diff --git a/xorg-server/hw/dmx/dmxinput.c b/xorg-server/hw/dmx/dmxinput.c
index 0f7f24040..517a5ee8c 100644
--- a/xorg-server/hw/dmx/dmxinput.c
+++ b/xorg-server/hw/dmx/dmxinput.c
@@ -114,6 +114,6 @@ NewInputDeviceRequest (InputOption *options, InputAttributes *attrs,
 }

 

 void

-DeleteInputDeviceRequest(DeviceIntPtr pDev, int flags)

+DeleteInputDeviceRequest(DeviceIntPtr pDev)

 {

 }

diff --git a/xorg-server/hw/dmx/glxProxy/g_renderswap.c b/xorg-server/hw/dmx/glxProxy/g_renderswap.c
index b92821d0a..8aab433e8 100644
--- a/xorg-server/hw/dmx/glxProxy/g_renderswap.c
+++ b/xorg-server/hw/dmx/glxProxy/g_renderswap.c
@@ -1,2360 +1,2321 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. 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.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxserver.h"
-#include "glxext.h"
-#include "g_disptab.h"
-#include "unpack.h"
-
-void __glXDispSwap_CallList(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ListBase(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Begin(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Color3bv(GLbyte *pc)
-{
-}
-
-void __glXDispSwap_Color3dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Color3fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
-}
-
-void __glXDispSwap_Color3iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Color3sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Color3ubv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-}
-
-void __glXDispSwap_Color3uiv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-}
-
-void __glXDispSwap_Color3usv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-}
-
-void __glXDispSwap_Color4bv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-}
-
-void __glXDispSwap_Color4dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-}
-
-void __glXDispSwap_Color4fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Color4iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Color4sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Color4ubv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-}
-
-void __glXDispSwap_Color4uiv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Color4usv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_EdgeFlagv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_End(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_Indexdv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 8);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_Indexfv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_Indexiv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_Indexsv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_Normal3bv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_Normal3dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Normal3fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Normal3iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Normal3sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_RasterPos2dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_RasterPos2fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_RasterPos2iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_RasterPos2sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_RasterPos3dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_RasterPos3fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_RasterPos3iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_RasterPos3sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_RasterPos4dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_RasterPos4fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_RasterPos4iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_RasterPos4sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Rectdv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);
-
-}
-
-void __glXDispSwap_Rectfv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);
-
-}
-
-void __glXDispSwap_Rectiv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
-	__GLX_SWAP_INT_ARRAY(pc + 8, 2);
-
-}
-
-void __glXDispSwap_Rectsv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
-
-}
-
-void __glXDispSwap_TexCoord1dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 8);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_TexCoord1fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_TexCoord1iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_TexCoord1sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_TexCoord2dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_TexCoord2fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_TexCoord2iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_TexCoord2sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_TexCoord3dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_TexCoord3fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_TexCoord3iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_TexCoord3sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_TexCoord4dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_TexCoord4fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_TexCoord4iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_TexCoord4sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Vertex2dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_Vertex2fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_Vertex2iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_Vertex2sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_Vertex3dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Vertex3fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Vertex3iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Vertex3sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_Vertex4dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Vertex4fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Vertex4iv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_Vertex4sv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_ClipPlane(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 36);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 32);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_ColorMaterial(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_CullFace(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Fogf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_Fogfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	pname = *(GLenum *)(pc + 0);
-	compsize = __glFogfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
-
-}
-
-void __glXDispSwap_Fogi(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_Fogiv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	pname = *(GLenum *)(pc + 0);
-	compsize = __glFogiv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
-
-}
-
-void __glXDispSwap_FrontFace(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Hint(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_Lightf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_Lightfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glLightfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_Lighti(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_Lightiv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glLightiv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_LightModelf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_LightModelfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	pname = *(GLenum *)(pc + 0);
-	compsize = __glLightModelfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
-
-}
-
-void __glXDispSwap_LightModeli(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_LightModeliv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	pname = *(GLenum *)(pc + 0);
-	compsize = __glLightModeliv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
-
-}
-
-void __glXDispSwap_LineStipple(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT(pc + 4);
-
-}
-
-void __glXDispSwap_LineWidth(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-
-}
-
-void __glXDispSwap_Materialf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_Materialfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glMaterialfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_Materiali(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_Materialiv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glMaterialiv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_PointSize(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-
-}
-
-void __glXDispSwap_PolygonMode(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_Scissor(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-
-}
-
-void __glXDispSwap_ShadeModel(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_TexParameterf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_TexParameterfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexParameterfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexParameteri(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_TexParameteriv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexParameteriv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexEnvf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_TexEnvfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexEnvfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexEnvi(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_TexEnviv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexEnviv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexGend(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_DOUBLE(pc + 0);
-
-}
-
-void __glXDispSwap_TexGendv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint cmdlen;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexGendv_size(pname);
-	if (compsize < 0) compsize = 0;
-	cmdlen = __GLX_PAD(8+compsize*8);
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, cmdlen);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexGenf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_TexGenfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexGenfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_TexGeni(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_TexGeniv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glTexGeniv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_InitNames(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_LoadName(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_PassThrough(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-
-}
-
-void __glXDispSwap_PopName(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_PushName(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_DrawBuffer(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Clear(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ClearAccum(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-	__GLX_SWAP_FLOAT(pc + 12);
-
-}
-
-void __glXDispSwap_ClearIndex(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-
-}
-
-void __glXDispSwap_ClearColor(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-	__GLX_SWAP_FLOAT(pc + 12);
-
-}
-
-void __glXDispSwap_ClearStencil(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ClearDepth(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 8);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-
-}
-
-void __glXDispSwap_StencilMask(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ColorMask(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_DepthMask(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_IndexMask(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Accum(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_Disable(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_Enable(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_PopAttrib(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_PushAttrib(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_MapGrid1d(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 20);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-
-}
-
-void __glXDispSwap_MapGrid1f(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_MapGrid2d(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 40);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 32);
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_INT(pc + 36);
-	__GLX_SWAP_DOUBLE(pc + 16);
-	__GLX_SWAP_DOUBLE(pc + 24);
-
-}
-
-void __glXDispSwap_MapGrid2f(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_FLOAT(pc + 16);
-	__GLX_SWAP_FLOAT(pc + 20);
-
-}
-
-void __glXDispSwap_EvalCoord1dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 8);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_EvalCoord1fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_EvalCoord2dv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_EvalCoord2fv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_EvalMesh1(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_EvalPoint1(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_EvalMesh2(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-
-}
-
-void __glXDispSwap_EvalPoint2(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_AlphaFunc(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_BlendFunc(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_LogicOp(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_StencilFunc(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_StencilOp(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_DepthFunc(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_PixelZoom(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_PixelTransferf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_PixelTransferi(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_PixelMapfv(GLbyte *pc)
-{
-	GLint mapsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	mapsize = *(GLint *)(pc + 4);
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);
-
-}
-
-void __glXDispSwap_PixelMapuiv(GLbyte *pc)
-{
-	GLint mapsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	mapsize = *(GLint *)(pc + 4);
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, mapsize);
-
-}
-
-void __glXDispSwap_PixelMapusv(GLbyte *pc)
-{
-	GLint mapsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	mapsize = *(GLint *)(pc + 4);
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);
-
-}
-
-void __glXDispSwap_ReadBuffer(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_CopyPixels(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-
-}
-
-void __glXDispSwap_DepthRange(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 16);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-
-}
-
-void __glXDispSwap_Frustum(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 48);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_DOUBLE(pc + 16);
-	__GLX_SWAP_DOUBLE(pc + 24);
-	__GLX_SWAP_DOUBLE(pc + 32);
-	__GLX_SWAP_DOUBLE(pc + 40);
-
-}
-
-void __glXDispSwap_LoadIdentity(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_LoadMatrixf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
-
-}
-
-void __glXDispSwap_LoadMatrixd(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 128);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
-
-}
-
-void __glXDispSwap_MatrixMode(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_MultMatrixf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
-
-}
-
-void __glXDispSwap_MultMatrixd(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 128);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
-
-}
-
-void __glXDispSwap_Ortho(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 48);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_DOUBLE(pc + 16);
-	__GLX_SWAP_DOUBLE(pc + 24);
-	__GLX_SWAP_DOUBLE(pc + 32);
-	__GLX_SWAP_DOUBLE(pc + 40);
-
-}
-
-void __glXDispSwap_PopMatrix(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_PushMatrix(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_Rotated(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 32);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_DOUBLE(pc + 16);
-	__GLX_SWAP_DOUBLE(pc + 24);
-
-}
-
-void __glXDispSwap_Rotatef(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-	__GLX_SWAP_FLOAT(pc + 12);
-
-}
-
-void __glXDispSwap_Scaled(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_DOUBLE(pc + 16);
-
-}
-
-void __glXDispSwap_Scalef(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_Translated(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 24);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_DOUBLE(pc + 0);
-	__GLX_SWAP_DOUBLE(pc + 8);
-	__GLX_SWAP_DOUBLE(pc + 16);
-
-}
-
-void __glXDispSwap_Translatef(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_Viewport(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-
-}
-
-void __glXDispSwap_PolygonOffset(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-
-}
-
-void __glXDispSwap_CopyTexImage1D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-	__GLX_SWAP_INT(pc + 24);
-
-}
-
-void __glXDispSwap_CopyTexImage2D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-	__GLX_SWAP_INT(pc + 24);
-	__GLX_SWAP_INT(pc + 28);
-
-}
-
-void __glXDispSwap_CopyTexSubImage1D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-
-}
-
-void __glXDispSwap_CopyTexSubImage2D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-	__GLX_SWAP_INT(pc + 24);
-	__GLX_SWAP_INT(pc + 28);
-
-}
-
-void __glXDispSwap_BindTexture(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_PrioritizeTextures(GLbyte *pc)
-{
-	GLsizei n;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	n = *(GLsizei *)(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n);
-
-}
-
-void __glXDispSwap_Indexubv(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-}
-
-void __glXDispSwap_BlendColor(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_FLOAT(pc + 0);
-	__GLX_SWAP_FLOAT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-	__GLX_SWAP_FLOAT(pc + 12);
-
-}
-
-void __glXDispSwap_BlendEquation(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ColorTableParameterfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glColorTableParameterfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_ColorTableParameteriv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glColorTableParameteriv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_CopyColorTable(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-
-}
-
-void __glXDispSwap_CopyColorSubTable(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-
-}
-
-void __glXDispSwap_ConvolutionParameterf(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_FLOAT(pc + 8);
-
-}
-
-void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glConvolutionParameterfv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_ConvolutionParameteri(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc)
-{
-	GLenum pname;
-	GLint compsize;
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 4);
-	pname = *(GLenum *)(pc + 4);
-	compsize = __glConvolutionParameteriv_size(pname);
-	if (compsize < 0) compsize = 0;
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
-
-}
-
-void __glXDispSwap_CopyConvolutionFilter1D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-
-}
-
-void __glXDispSwap_CopyConvolutionFilter2D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-
-}
-
-void __glXDispSwap_Histogram(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-
-}
-
-void __glXDispSwap_Minmax(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-
-}
-
-void __glXDispSwap_ResetHistogram(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_ResetMinmax(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_CopyTexSubImage3D(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT(pc + 4);
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_INT(pc + 12);
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_INT(pc + 20);
-	__GLX_SWAP_INT(pc + 24);
-	__GLX_SWAP_INT(pc + 28);
-	__GLX_SWAP_INT(pc + 32);
-
-}
-
-void __glXDispSwap_ActiveTextureARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-
-}
-
-void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 12);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 8);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
-
-}
-
-void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);
-
-}
-
-void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 4, 1);
-
-}
-
-void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 1);
-
-}
-
-void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 20);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 16);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
-
-}
-
-void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);
-
-}
-
-void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 4, 2);
-
-}
-
-void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
-
-}
-
-void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 28);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 24);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
-
-}
-
-void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);
-
-}
-
-void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 4, 3);
-
-}
-
-void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 3);
-
-}
-
-void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-
-#ifdef __GLX_ALIGN64
-	if ((unsigned long)(pc) & 7) {
-	    __GLX_MEM_COPY(pc-4, pc, 36);
-	    pc -= 4;
-	}
-#endif
-	__GLX_SWAP_INT(pc + 32);
-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
-
-}
-
-void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);
-
-}
-
-void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_INT_ARRAY(pc + 4, 4);
-
-}
-
-void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc)
-{
-	__GLX_DECLARE_SWAP_VARIABLES;
-
-	__GLX_SWAP_INT(pc + 0);
-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 4);
-
-}
-
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. 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.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "glxserver.h"

+#include "glxext.h"

+#include "g_disptab.h"

+#include "unpack.h"

+

+void __glXDispSwap_CallList(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ListBase(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Begin(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Color3bv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Color3dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Color3fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

+}

+

+void __glXDispSwap_Color3iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Color3sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Color3ubv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Color3uiv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+}

+

+void __glXDispSwap_Color3usv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+}

+

+void __glXDispSwap_Color4bv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Color4dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+}

+

+void __glXDispSwap_Color4fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Color4iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Color4sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Color4ubv(GLbyte *pc)

+{

+

+}

+

+void __glXDispSwap_Color4uiv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Color4usv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_EdgeFlagv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_End(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Indexdv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 8);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_Indexfv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_Indexiv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_Indexsv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_Normal3bv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Normal3dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Normal3fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Normal3iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Normal3sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_RasterPos2dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_RasterPos2fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_RasterPos2iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_RasterPos2sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_RasterPos3dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_RasterPos3fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_RasterPos3iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_RasterPos3sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_RasterPos4dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_RasterPos4fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_RasterPos4iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_RasterPos4sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Rectdv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);

+

+}

+

+void __glXDispSwap_Rectfv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);

+

+}

+

+void __glXDispSwap_Rectiv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

+	__GLX_SWAP_INT_ARRAY(pc + 8, 2);

+

+}

+

+void __glXDispSwap_Rectsv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);

+

+}

+

+void __glXDispSwap_TexCoord1dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 8);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_TexCoord1fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_TexCoord1iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_TexCoord1sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_TexCoord2dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_TexCoord2fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_TexCoord2iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_TexCoord2sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_TexCoord3dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_TexCoord3fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_TexCoord3iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_TexCoord3sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_TexCoord4dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_TexCoord4fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_TexCoord4iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_TexCoord4sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Vertex2dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_Vertex2fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_Vertex2iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_Vertex2sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_Vertex3dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Vertex3fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Vertex3iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Vertex3sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_Vertex4dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Vertex4fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Vertex4iv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_Vertex4sv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_ClipPlane(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 36);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 32);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_ColorMaterial(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_CullFace(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Fogf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_Fogfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	pname = *(GLenum *)(pc + 0);

+	compsize = __glFogfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);

+

+}

+

+void __glXDispSwap_Fogi(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_Fogiv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	pname = *(GLenum *)(pc + 0);

+	compsize = __glFogiv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);

+

+}

+

+void __glXDispSwap_FrontFace(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Hint(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_Lightf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_Lightfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glLightfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_Lighti(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_Lightiv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glLightiv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_LightModelf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_LightModelfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	pname = *(GLenum *)(pc + 0);

+	compsize = __glLightModelfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);

+

+}

+

+void __glXDispSwap_LightModeli(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_LightModeliv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	pname = *(GLenum *)(pc + 0);

+	compsize = __glLightModeliv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);

+

+}

+

+void __glXDispSwap_LineStipple(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT(pc + 4);

+

+}

+

+void __glXDispSwap_LineWidth(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+

+}

+

+void __glXDispSwap_Materialf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_Materialfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glMaterialfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_Materiali(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_Materialiv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glMaterialiv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_PointSize(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+

+}

+

+void __glXDispSwap_PolygonMode(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_Scissor(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+

+}

+

+void __glXDispSwap_ShadeModel(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_TexParameterf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_TexParameterfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexParameterfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexParameteri(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_TexParameteriv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexParameteriv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexEnvf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_TexEnvfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexEnvfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexEnvi(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_TexEnviv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexEnviv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexGend(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_DOUBLE(pc + 0);

+

+}

+

+void __glXDispSwap_TexGendv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint cmdlen;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexGendv_size(pname);

+	if (compsize < 0) compsize = 0;

+	cmdlen = __GLX_PAD(8+compsize*8);

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, cmdlen);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexGenf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_TexGenfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexGenfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_TexGeni(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_TexGeniv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glTexGeniv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_InitNames(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_LoadName(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_PassThrough(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+

+}

+

+void __glXDispSwap_PopName(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_PushName(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_DrawBuffer(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Clear(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ClearAccum(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+	__GLX_SWAP_FLOAT(pc + 12);

+

+}

+

+void __glXDispSwap_ClearIndex(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+

+}

+

+void __glXDispSwap_ClearColor(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+	__GLX_SWAP_FLOAT(pc + 12);

+

+}

+

+void __glXDispSwap_ClearStencil(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ClearDepth(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 8);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+

+}

+

+void __glXDispSwap_StencilMask(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ColorMask(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_DepthMask(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_IndexMask(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Accum(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_Disable(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_Enable(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_PopAttrib(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_PushAttrib(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_MapGrid1d(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 20);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+

+}

+

+void __glXDispSwap_MapGrid1f(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_MapGrid2d(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 40);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 32);

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_INT(pc + 36);

+	__GLX_SWAP_DOUBLE(pc + 16);

+	__GLX_SWAP_DOUBLE(pc + 24);

+

+}

+

+void __glXDispSwap_MapGrid2f(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_FLOAT(pc + 16);

+	__GLX_SWAP_FLOAT(pc + 20);

+

+}

+

+void __glXDispSwap_EvalCoord1dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 8);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_EvalCoord1fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_EvalCoord2dv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_EvalCoord2fv(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_EvalMesh1(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_EvalPoint1(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_EvalMesh2(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+

+}

+

+void __glXDispSwap_EvalPoint2(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_AlphaFunc(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_BlendFunc(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_LogicOp(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_StencilFunc(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_StencilOp(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_DepthFunc(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_PixelZoom(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_PixelTransferf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_PixelTransferi(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_PixelMapfv(GLbyte *pc)

+{

+	GLint mapsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	mapsize = *(GLint *)(pc + 4);

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);

+

+}

+

+void __glXDispSwap_PixelMapuiv(GLbyte *pc)

+{

+	GLint mapsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	mapsize = *(GLint *)(pc + 4);

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, mapsize);

+

+}

+

+void __glXDispSwap_PixelMapusv(GLbyte *pc)

+{

+	GLint mapsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	mapsize = *(GLint *)(pc + 4);

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);

+

+}

+

+void __glXDispSwap_ReadBuffer(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_CopyPixels(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+

+}

+

+void __glXDispSwap_DepthRange(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 16);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+

+}

+

+void __glXDispSwap_Frustum(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 48);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_DOUBLE(pc + 16);

+	__GLX_SWAP_DOUBLE(pc + 24);

+	__GLX_SWAP_DOUBLE(pc + 32);

+	__GLX_SWAP_DOUBLE(pc + 40);

+

+}

+

+void __glXDispSwap_LoadIdentity(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_LoadMatrixf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);

+

+}

+

+void __glXDispSwap_LoadMatrixd(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 128);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);

+

+}

+

+void __glXDispSwap_MatrixMode(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_MultMatrixf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);

+

+}

+

+void __glXDispSwap_MultMatrixd(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 128);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);

+

+}

+

+void __glXDispSwap_Ortho(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 48);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_DOUBLE(pc + 16);

+	__GLX_SWAP_DOUBLE(pc + 24);

+	__GLX_SWAP_DOUBLE(pc + 32);

+	__GLX_SWAP_DOUBLE(pc + 40);

+

+}

+

+void __glXDispSwap_PopMatrix(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_PushMatrix(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_Rotated(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 32);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_DOUBLE(pc + 16);

+	__GLX_SWAP_DOUBLE(pc + 24);

+

+}

+

+void __glXDispSwap_Rotatef(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+	__GLX_SWAP_FLOAT(pc + 12);

+

+}

+

+void __glXDispSwap_Scaled(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_DOUBLE(pc + 16);

+

+}

+

+void __glXDispSwap_Scalef(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_Translated(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 24);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_DOUBLE(pc + 0);

+	__GLX_SWAP_DOUBLE(pc + 8);

+	__GLX_SWAP_DOUBLE(pc + 16);

+

+}

+

+void __glXDispSwap_Translatef(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_Viewport(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+

+}

+

+void __glXDispSwap_PolygonOffset(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+

+}

+

+void __glXDispSwap_CopyTexImage1D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+	__GLX_SWAP_INT(pc + 24);

+

+}

+

+void __glXDispSwap_CopyTexImage2D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+	__GLX_SWAP_INT(pc + 24);

+	__GLX_SWAP_INT(pc + 28);

+

+}

+

+void __glXDispSwap_CopyTexSubImage1D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+

+}

+

+void __glXDispSwap_CopyTexSubImage2D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+	__GLX_SWAP_INT(pc + 24);

+	__GLX_SWAP_INT(pc + 28);

+

+}

+

+void __glXDispSwap_BindTexture(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_PrioritizeTextures(GLbyte *pc)

+{

+	GLsizei n;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	n = *(GLsizei *)(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 4, n);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n);

+

+}

+

+void __glXDispSwap_Indexubv(GLbyte *pc)

+{

+}

+

+void __glXDispSwap_BlendColor(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_FLOAT(pc + 0);

+	__GLX_SWAP_FLOAT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+	__GLX_SWAP_FLOAT(pc + 12);

+

+}

+

+void __glXDispSwap_BlendEquation(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ColorTableParameterfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glColorTableParameterfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_ColorTableParameteriv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glColorTableParameteriv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_CopyColorTable(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+

+}

+

+void __glXDispSwap_CopyColorSubTable(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+

+}

+

+void __glXDispSwap_ConvolutionParameterf(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_FLOAT(pc + 8);

+

+}

+

+void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glConvolutionParameterfv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_ConvolutionParameteri(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc)

+{

+	GLenum pname;

+	GLint compsize;

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 4);

+	pname = *(GLenum *)(pc + 4);

+	compsize = __glConvolutionParameteriv_size(pname);

+	if (compsize < 0) compsize = 0;

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);

+

+}

+

+void __glXDispSwap_CopyConvolutionFilter1D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+

+}

+

+void __glXDispSwap_CopyConvolutionFilter2D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+

+}

+

+void __glXDispSwap_Histogram(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+

+}

+

+void __glXDispSwap_Minmax(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+

+}

+

+void __glXDispSwap_ResetHistogram(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_ResetMinmax(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_CopyTexSubImage3D(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT(pc + 4);

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_INT(pc + 12);

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_INT(pc + 20);

+	__GLX_SWAP_INT(pc + 24);

+	__GLX_SWAP_INT(pc + 28);

+	__GLX_SWAP_INT(pc + 32);

+

+}

+

+void __glXDispSwap_ActiveTextureARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+

+}

+

+void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 12);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 8);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);

+

+}

+

+void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);

+

+}

+

+void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 4, 1);

+

+}

+

+void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 1);

+

+}

+

+void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 20);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 16);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);

+

+}

+

+void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);

+

+}

+

+void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 4, 2);

+

+}

+

+void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);

+

+}

+

+void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 28);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 24);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);

+

+}

+

+void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);

+

+}

+

+void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 4, 3);

+

+}

+

+void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 3);

+

+}

+

+void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+

+#ifdef __GLX_ALIGN64

+	if ((unsigned long)(pc) & 7) {

+	    __GLX_MEM_COPY(pc-4, pc, 36);

+	    pc -= 4;

+	}

+#endif

+	__GLX_SWAP_INT(pc + 32);

+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);

+

+}

+

+void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);

+

+}

+

+void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_INT_ARRAY(pc + 4, 4);

+

+}

+

+void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc)

+{

+	__GLX_DECLARE_SWAP_VARIABLES;

+

+	__GLX_SWAP_INT(pc + 0);

+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 4);

+

+}

+

diff --git a/xorg-server/hw/dmx/glxProxy/glxcmds.c b/xorg-server/hw/dmx/glxProxy/glxcmds.c
index a2fe0b27b..bac4478da 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmds.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmds.c
@@ -3404,7 +3404,7 @@ int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
       WriteToClient(client, attribs_size, (char *)attribs);

    }

 

-   Xfree(attribs);

+   free(attribs);

 

    return Success;

 }

@@ -3420,11 +3420,6 @@ int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
    Display *dpy;

    int screen, rc;

    DMXScreenInfo *dmxScreen;

-   char *attrbuf;

-#ifdef PANORAMIX

-    PanoramiXRes *pXinDraw = NULL;

-    PanoramiXRes *pXinReadDraw = NULL;

-#endif

 

    if (drawId != None) {

       rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixSetAttrAccess);

@@ -3491,7 +3486,7 @@ int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
 

 #ifdef PANORAMIX

        if (!noPanoramiXExtension) {

-	  pXinDraw = (PanoramiXRes *)

+	  PanoramiXRes *pXinDraw = (PanoramiXRes *)

 	     SecurityLookupIDByClass(client, pDraw->id, XRC_DRAWABLE, DixReadAccess);

 	  if (!pXinDraw) {

 	     client->errorValue = drawId;

diff --git a/xorg-server/hw/dmx/glxProxy/glxscreens.c b/xorg-server/hw/dmx/glxProxy/glxscreens.c
index 4c40d2315..8cf7b281c 100644
--- a/xorg-server/hw/dmx/glxProxy/glxscreens.c
+++ b/xorg-server/hw/dmx/glxProxy/glxscreens.c
@@ -204,9 +204,9 @@ static void CalcServerVersionAndExtensions( void )
     * release temporary storage

     */

    for (s=0; s<__glXNumActiveScreens; s++) {

-      if (be_extensions[s]) Xfree(be_extensions[s]); 

+      free(be_extensions[s]);

    }

-   Xfree( be_extensions );

+   free( be_extensions );

 

    if (dmxGLXSwapGroupSupport) {

        if (!denied_extensions ||

@@ -254,7 +254,6 @@ void __glXScreenInit(GLint numscreens)
 	 if (numscreens > 1) {

 	    for (s=1; s<numscreens; s++) {

 	       DMXScreenInfo *dmxScreen = &dmxScreens[s];

-	       __GLXscreenInfo *glxScreen = &__glXActiveScreens[s];

 	  

 	       cfg = FindMatchingFBConfig( &dmxScreen0->fbconfigs[c],

 		                           dmxScreen->fbconfigs, 

diff --git a/xorg-server/hw/dmx/glxProxy/glxsingle.c b/xorg-server/hw/dmx/glxProxy/glxsingle.c
index 19f12ad58..8325b4afc 100644
--- a/xorg-server/hw/dmx/glxProxy/glxsingle.c
+++ b/xorg-server/hw/dmx/glxProxy/glxsingle.c
@@ -288,7 +288,7 @@ int __glXForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
 	  WriteToClient(client, be_buf_size, (char *)be_buf);

     }

 

-    if (be_buf_size > 0) Xfree(be_buf);

+    if (be_buf_size > 0) free(be_buf);

 

     return Success;

 }

@@ -364,7 +364,7 @@ int __glXForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
        SyncHandle();

 

        if (s > from_screen && be_buf_size > 0) {

-	  Xfree(be_buf);

+	  free(be_buf);

        }

     }

 

@@ -388,7 +388,7 @@ int __glXForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
 	  WriteToClient(client, be_buf_size, (char *)be_buf);

     }

 

-    if (be_buf_size > 0) Xfree(be_buf);

+    if (be_buf_size > 0) free(be_buf);

 

     return Success;

 }

@@ -750,7 +750,6 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
     GLboolean swapBytes, lsbFirst;

     ClientPtr client = cl->client;

     DrawablePtr pDraw;

-    int error;

     __GLXcontext *glxc;

     int from_screen = 0;

     int to_screen = 0;

@@ -939,12 +938,12 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
 

 		   }

 

-		   Xfree( be_buf );

+		   free( be_buf );

 		}

 		else {

 		   /* Throw data on the floor */

 		   _XEatData(dpy, be_buf_size);

-		   Xfree( buf );

+		   free( buf );

 		   return BadAlloc;

 		}

 	     }

@@ -970,7 +969,7 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
     WriteToClient(client, sizeof(xGLXReadPixelsReply),(char *)&reply);

     if (buf_size > 0) {

        WriteToClient(client, buf_size, (char *)buf);

-       Xfree( buf );

+       free( buf );

     }

 

     return Success;

diff --git a/xorg-server/hw/dmx/glxProxy/glxvendor.c b/xorg-server/hw/dmx/glxProxy/glxvendor.c
index e8460fad8..f2cea706f 100644
--- a/xorg-server/hw/dmx/glxProxy/glxvendor.c
+++ b/xorg-server/hw/dmx/glxProxy/glxvendor.c
@@ -272,7 +272,7 @@ int __glXVForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
 	  WriteToClient(client, be_buf_size, (char *)be_buf);

     }

 

-    if (be_buf_size > 0) Xfree(be_buf);

+    if (be_buf_size > 0) free(be_buf);

 

     return Success;

 }

@@ -349,7 +349,7 @@ int __glXVForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
        SyncHandle();

 

        if (s > from_screen && be_buf_size > 0) {

-	  Xfree(be_buf);

+	  free(be_buf);

        }

     }

 

@@ -369,7 +369,7 @@ int __glXVForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
 	  WriteToClient(client, be_buf_size, (char *)be_buf);

     }

 

-    if (be_buf_size > 0) Xfree(be_buf);

+    if (be_buf_size > 0) free(be_buf);

 

     return Success;

 }

diff --git a/xorg-server/hw/dmx/glxProxy/render2swap.c b/xorg-server/hw/dmx/glxProxy/render2swap.c
index 37e43d8fa..34122fb36 100644
--- a/xorg-server/hw/dmx/glxProxy/render2swap.c
+++ b/xorg-server/hw/dmx/glxProxy/render2swap.c
@@ -1,341 +1,335 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. 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.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxserver.h"
-#include "unpack.h"
-#include "g_disptab.h"
-
-GLint __glEvalComputeK(GLenum target)
-{
-    switch (target) {
-    case GL_MAP1_VERTEX_4:
-    case GL_MAP1_COLOR_4:
-    case GL_MAP1_TEXTURE_COORD_4:
-    case GL_MAP2_VERTEX_4:
-    case GL_MAP2_COLOR_4:
-    case GL_MAP2_TEXTURE_COORD_4:
-	return 4;
-    case GL_MAP1_VERTEX_3:
-    case GL_MAP1_TEXTURE_COORD_3:
-    case GL_MAP1_NORMAL:
-    case GL_MAP2_VERTEX_3:
-    case GL_MAP2_TEXTURE_COORD_3:
-    case GL_MAP2_NORMAL:
-	return 3;
-    case GL_MAP1_TEXTURE_COORD_2:
-    case GL_MAP2_TEXTURE_COORD_2:
-	return 2;
-    case GL_MAP1_TEXTURE_COORD_1:
-    case GL_MAP2_TEXTURE_COORD_1:
-    case GL_MAP1_INDEX:
-    case GL_MAP2_INDEX:
-	return 1;
-    default:
-	return 0;
-    }
-}
-
-void __glXDispSwap_Map1f(GLbyte *pc)
-{
-    GLint order, k;
-    GLfloat u1, u2, *points;
-    GLenum target;
-    GLint compsize;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_INT(pc + 0);
-    __GLX_SWAP_INT(pc + 12);
-    __GLX_SWAP_FLOAT(pc + 4);
-    __GLX_SWAP_FLOAT(pc + 8);
-    
-    target = *(GLenum *)(pc + 0); 
-    order = *(GLint *)(pc + 12);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    points = (GLfloat *)(pc + 16);
-    k = __glEvalComputeK(target);
-
-    if (order <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = order * k;
-    }
-    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
-
-}
-
-void __glXDispSwap_Map2f(GLbyte *pc)
-{
-    GLint uorder, vorder, ustride, vstride, k;
-    GLfloat u1, u2, v1, v2, *points;
-    GLenum target;
-    GLint compsize;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_INT(pc + 0);
-    __GLX_SWAP_INT(pc + 12);
-    __GLX_SWAP_INT(pc + 24);
-    __GLX_SWAP_FLOAT(pc + 4);
-    __GLX_SWAP_FLOAT(pc + 8);
-    __GLX_SWAP_FLOAT(pc + 16);
-    __GLX_SWAP_FLOAT(pc + 20);
-    
-    target = *(GLenum *)(pc + 0); 
-    uorder = *(GLint *)(pc + 12);
-    vorder = *(GLint *)(pc + 24);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    v1 = *(GLfloat *)(pc + 16);
-    v2 = *(GLfloat *)(pc + 20);
-    points = (GLfloat *)(pc + 28);
-
-    k = __glEvalComputeK(target);
-    ustride = vorder * k;
-    vstride = k;
-
-    if (vorder <= 0 || uorder <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = uorder * vorder * k;
-    }
-    __GLX_SWAP_FLOAT_ARRAY(points, compsize);
-
-}
-
-void __glXDispSwap_Map1d(GLbyte *pc)
-{
-    GLint order, k, compsize;
-    GLenum target;
-    GLdouble u1, u2, *points;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_DOUBLE(pc + 0);
-    __GLX_SWAP_DOUBLE(pc + 8);
-    __GLX_SWAP_INT(pc + 16);
-    __GLX_SWAP_INT(pc + 20);
-
-    target = *(GLenum*) (pc + 16);
-    order = *(GLint*) (pc + 20);
-    k = __glEvalComputeK(target);
-    if (order <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = order * k;
-    }
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
-    __GLX_SWAP_DOUBLE_ARRAY(pc+24, compsize);
-    pc += 24;
-
-#ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
-    }
-#else
-    points = (GLdouble*) pc;
-#endif
-}
-
-void __glXDispSwap_Map2d(GLbyte *pc)
-{
-    GLdouble u1, u2, v1, v2, *points;
-    GLint uorder, vorder, ustride, vstride, k, compsize;
-    GLenum target;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_DOUBLE(pc + 0);
-    __GLX_SWAP_DOUBLE(pc + 8);
-    __GLX_SWAP_DOUBLE(pc + 16);
-    __GLX_SWAP_DOUBLE(pc + 24);
-    __GLX_SWAP_INT(pc + 32);
-    __GLX_SWAP_INT(pc + 36);
-    __GLX_SWAP_INT(pc + 40);
-
-    target = *(GLenum *)(pc + 32);
-    uorder = *(GLint *)(pc + 36);
-    vorder = *(GLint *)(pc + 40);
-    k = __glEvalComputeK(target);
-    if (vorder <= 0 || uorder <= 0 || k < 0) {
-	/* Erroneous command. */
-	compsize = 0;
-    } else {
-	compsize = uorder * vorder * k;
-    }
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
-    __GLX_GET_DOUBLE(v1,pc+16);
-    __GLX_GET_DOUBLE(v2,pc+24);
-    __GLX_SWAP_DOUBLE_ARRAY(pc+44, compsize);
-    pc += 44;
-    ustride = vorder * k;
-    vstride = k;
-
-#ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
-    }
-#else
-    points = (GLdouble*) pc;
-#endif
-}
-
-void __glXDispSwap_CallLists(GLbyte *pc)
-{
-    GLenum type;
-    GLsizei n;
-    __GLX_DECLARE_SWAP_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;
-    }
-
-}
-
-static void swapArray(GLint numVals, GLenum datatype,
-                      GLint stride, GLint numVertexes, GLbyte *pc)
-{
-    int i,j;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    switch (datatype) {
-      case GL_BYTE:
-      case GL_UNSIGNED_BYTE:
-	/* don't need to swap */
-	return;
-      case GL_SHORT:
-      case GL_UNSIGNED_SHORT:
-	for (i=0; i<numVertexes; i++) {
-	    GLshort *pVal = (GLshort *) pc;
-	    for (j=0; j<numVals; j++) {
-		__GLX_SWAP_SHORT(&pVal[j]);
-	    }
-	    pc += stride;
-	}
-	break;
-      case GL_INT:
-      case GL_UNSIGNED_INT:
-	for (i=0; i<numVertexes; i++) {
-	    GLint *pVal = (GLint *) pc;
-	    for (j=0; j<numVals; j++) {
-		__GLX_SWAP_INT(&pVal[j]);
-	    }
-	    pc += stride;
-	}
-	break;
-      case GL_FLOAT:
-	for (i=0; i<numVertexes; i++) {
-	    GLfloat *pVal = (GLfloat *) pc;
-	    for (j=0; j<numVals; j++) {
-		__GLX_SWAP_FLOAT(&pVal[j]);
-	    }
-	    pc += stride;
-	}
-	break;
-      case GL_DOUBLE:
-	for (i=0; i<numVertexes; i++) {
-	    GLdouble *pVal = (GLdouble *) pc;
-	    for (j=0; j<numVals; j++) {
-		__GLX_SWAP_DOUBLE(&pVal[j]);
-	    }
-	    pc += stride;
-	}
-	break;
-      default:
-	return;
-    }
-}
-
-void __glXDispSwap_DrawArrays(GLbyte *pc)
-{
-    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *)pc;
-    __GLXdispatchDrawArraysComponentHeader *compHeader;
-    int i;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    __GLX_SWAP_INT(&hdr->numVertexes);
-    __GLX_SWAP_INT(&hdr->numComponents);
-    __GLX_SWAP_INT(&hdr->primType);
-
-    pc += sizeof(__GLXdispatchDrawArraysHeader);
-    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
-
-    /* compute stride (same for all component arrays) */
-    for (i=0; i<hdr->numComponents; i++) {
-	__GLX_SWAP_INT(&compHeader[i].datatype);
-	__GLX_SWAP_INT(&compHeader[i].numVals);
-	__GLX_SWAP_INT(&compHeader[i].component);
-
-    }
-
-}
-
-void __glXDispSwap_DrawArraysEXT(GLbyte *pc)
-{
-#ifdef XXX_STUB
-#endif /*XXX_STUB*/
-}
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. 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.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "glxserver.h"

+#include "unpack.h"

+#include "g_disptab.h"

+

+GLint __glEvalComputeK(GLenum target)

+{

+    switch (target) {

+    case GL_MAP1_VERTEX_4:

+    case GL_MAP1_COLOR_4:

+    case GL_MAP1_TEXTURE_COORD_4:

+    case GL_MAP2_VERTEX_4:

+    case GL_MAP2_COLOR_4:

+    case GL_MAP2_TEXTURE_COORD_4:

+	return 4;

+    case GL_MAP1_VERTEX_3:

+    case GL_MAP1_TEXTURE_COORD_3:

+    case GL_MAP1_NORMAL:

+    case GL_MAP2_VERTEX_3:

+    case GL_MAP2_TEXTURE_COORD_3:

+    case GL_MAP2_NORMAL:

+	return 3;

+    case GL_MAP1_TEXTURE_COORD_2:

+    case GL_MAP2_TEXTURE_COORD_2:

+	return 2;

+    case GL_MAP1_TEXTURE_COORD_1:

+    case GL_MAP2_TEXTURE_COORD_1:

+    case GL_MAP1_INDEX:

+    case GL_MAP2_INDEX:

+	return 1;

+    default:

+	return 0;

+    }

+}

+

+void __glXDispSwap_Map1f(GLbyte *pc)

+{

+    GLint order, k;

+    GLfloat u1, u2, *points;

+    GLenum target;

+    GLint compsize;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_INT(pc + 0);

+    __GLX_SWAP_INT(pc + 12);

+    __GLX_SWAP_FLOAT(pc + 4);

+    __GLX_SWAP_FLOAT(pc + 8);

+    

+    target = *(GLenum *)(pc + 0); 

+    order = *(GLint *)(pc + 12);

+    u1 = *(GLfloat *)(pc + 4);

+    u2 = *(GLfloat *)(pc + 8);

+    points = (GLfloat *)(pc + 16);

+    k = __glEvalComputeK(target);

+

+    if (order <= 0 || k < 0) {

+	/* Erroneous command. */

+	compsize = 0;

+    } else {

+	compsize = order * k;

+    }

+    __GLX_SWAP_FLOAT_ARRAY(points, compsize);

+

+}

+

+void __glXDispSwap_Map2f(GLbyte *pc)

+{

+    GLint uorder, vorder, ustride, vstride, k;

+    GLfloat u1, u2, v1, v2, *points;

+    GLenum target;

+    GLint compsize;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_INT(pc + 0);

+    __GLX_SWAP_INT(pc + 12);

+    __GLX_SWAP_INT(pc + 24);

+    __GLX_SWAP_FLOAT(pc + 4);

+    __GLX_SWAP_FLOAT(pc + 8);

+    __GLX_SWAP_FLOAT(pc + 16);

+    __GLX_SWAP_FLOAT(pc + 20);

+    

+    target = *(GLenum *)(pc + 0); 

+    uorder = *(GLint *)(pc + 12);

+    vorder = *(GLint *)(pc + 24);

+    u1 = *(GLfloat *)(pc + 4);

+    u2 = *(GLfloat *)(pc + 8);

+    v1 = *(GLfloat *)(pc + 16);

+    v2 = *(GLfloat *)(pc + 20);

+    points = (GLfloat *)(pc + 28);

+

+    k = __glEvalComputeK(target);

+    ustride = vorder * k;

+    vstride = k;

+

+    if (vorder <= 0 || uorder <= 0 || k < 0) {

+	/* Erroneous command. */

+	compsize = 0;

+    } else {

+	compsize = uorder * vorder * k;

+    }

+    __GLX_SWAP_FLOAT_ARRAY(points, compsize);

+

+}

+

+void __glXDispSwap_Map1d(GLbyte *pc)

+{

+    GLint order, k, compsize;

+    GLenum target;

+    GLdouble u1, u2, *points;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_DOUBLE(pc + 0);

+    __GLX_SWAP_DOUBLE(pc + 8);

+    __GLX_SWAP_INT(pc + 16);

+    __GLX_SWAP_INT(pc + 20);

+

+    target = *(GLenum*) (pc + 16);

+    order = *(GLint*) (pc + 20);

+    k = __glEvalComputeK(target);

+    if (order <= 0 || k < 0) {

+	/* Erroneous command. */

+	compsize = 0;

+    } else {

+	compsize = order * k;

+    }

+    __GLX_GET_DOUBLE(u1,pc);

+    __GLX_GET_DOUBLE(u2,pc+8);

+    __GLX_SWAP_DOUBLE_ARRAY(pc+24, compsize);

+    pc += 24;

+

+#ifdef __GLX_ALIGN64

+    if (((unsigned long)pc) & 7) {

+	/*

+	** Copy the doubles up 4 bytes, trashing the command but aligning

+	** the data in the process

+	*/

+	__GLX_MEM_COPY(pc-4, pc, compsize*8);

+	points = (GLdouble*) (pc - 4);

+    } else {

+	points = (GLdouble*) pc;

+    }

+#else

+    points = (GLdouble*) pc;

+#endif

+}

+

+void __glXDispSwap_Map2d(GLbyte *pc)

+{

+    GLdouble u1, u2, v1, v2, *points;

+    GLint uorder, vorder, ustride, vstride, k, compsize;

+    GLenum target;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_DOUBLE(pc + 0);

+    __GLX_SWAP_DOUBLE(pc + 8);

+    __GLX_SWAP_DOUBLE(pc + 16);

+    __GLX_SWAP_DOUBLE(pc + 24);

+    __GLX_SWAP_INT(pc + 32);

+    __GLX_SWAP_INT(pc + 36);

+    __GLX_SWAP_INT(pc + 40);

+

+    target = *(GLenum *)(pc + 32);

+    uorder = *(GLint *)(pc + 36);

+    vorder = *(GLint *)(pc + 40);

+    k = __glEvalComputeK(target);

+    if (vorder <= 0 || uorder <= 0 || k < 0) {

+	/* Erroneous command. */

+	compsize = 0;

+    } else {

+	compsize = uorder * vorder * k;

+    }

+    __GLX_GET_DOUBLE(u1,pc);

+    __GLX_GET_DOUBLE(u2,pc+8);

+    __GLX_GET_DOUBLE(v1,pc+16);

+    __GLX_GET_DOUBLE(v2,pc+24);

+    __GLX_SWAP_DOUBLE_ARRAY(pc+44, compsize);

+    pc += 44;

+    ustride = vorder * k;

+    vstride = k;

+

+#ifdef __GLX_ALIGN64

+    if (((unsigned long)pc) & 7) {

+	/*

+	** Copy the doubles up 4 bytes, trashing the command but aligning

+	** the data in the process

+	*/

+	__GLX_MEM_COPY(pc-4, pc, compsize*8);

+	points = (GLdouble*) (pc - 4);

+    } else {

+	points = (GLdouble*) pc;

+    }

+#else

+    points = (GLdouble*) pc;

+#endif

+}

+

+void __glXDispSwap_CallLists(GLbyte *pc)

+{

+    GLenum type;

+    GLsizei n;

+    __GLX_DECLARE_SWAP_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;

+    }

+

+}

+

+static void swapArray(GLint numVals, GLenum datatype,

+                      GLint stride, GLint numVertexes, GLbyte *pc)

+{

+    int i,j;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    switch (datatype) {

+      case GL_BYTE:

+      case GL_UNSIGNED_BYTE:

+	/* don't need to swap */

+	return;

+      case GL_SHORT:

+      case GL_UNSIGNED_SHORT:

+	for (i=0; i<numVertexes; i++) {

+	    GLshort *pVal = (GLshort *) pc;

+	    for (j=0; j<numVals; j++) {

+		__GLX_SWAP_SHORT(&pVal[j]);

+	    }

+	    pc += stride;

+	}

+	break;

+      case GL_INT:

+      case GL_UNSIGNED_INT:

+	for (i=0; i<numVertexes; i++) {

+	    GLint *pVal = (GLint *) pc;

+	    for (j=0; j<numVals; j++) {

+		__GLX_SWAP_INT(&pVal[j]);

+	    }

+	    pc += stride;

+	}

+	break;

+      case GL_FLOAT:

+	for (i=0; i<numVertexes; i++) {

+	    GLfloat *pVal = (GLfloat *) pc;

+	    for (j=0; j<numVals; j++) {

+		__GLX_SWAP_FLOAT(&pVal[j]);

+	    }

+	    pc += stride;

+	}

+	break;

+      case GL_DOUBLE:

+	for (i=0; i<numVertexes; i++) {

+	    GLdouble *pVal = (GLdouble *) pc;

+	    for (j=0; j<numVals; j++) {

+		__GLX_SWAP_DOUBLE(&pVal[j]);

+	    }

+	    pc += stride;

+	}

+	break;

+      default:

+	return;

+    }

+}

+

+void __glXDispSwap_DrawArrays(GLbyte *pc)

+{

+    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *)pc;

+    __GLXdispatchDrawArraysComponentHeader *compHeader;

+    int i;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    __GLX_SWAP_INT(&hdr->numVertexes);

+    __GLX_SWAP_INT(&hdr->numComponents);

+    __GLX_SWAP_INT(&hdr->primType);

+

+    pc += sizeof(__GLXdispatchDrawArraysHeader);

+    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;

+

+    /* compute stride (same for all component arrays) */

+    for (i=0; i<hdr->numComponents; i++) {

+	__GLX_SWAP_INT(&compHeader[i].datatype);

+	__GLX_SWAP_INT(&compHeader[i].numVals);

+	__GLX_SWAP_INT(&compHeader[i].component);

+

+    }

+

+}

diff --git a/xorg-server/hw/dmx/glxProxy/renderpixswap.c b/xorg-server/hw/dmx/glxProxy/renderpixswap.c
index 462feeeb1..e0ed7e77d 100644
--- a/xorg-server/hw/dmx/glxProxy/renderpixswap.c
+++ b/xorg-server/hw/dmx/glxProxy/renderpixswap.c
@@ -1,383 +1,383 @@
-/*
- * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
- * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice including the dates of first publication and
- * either this permission notice or a reference to
- * http://oss.sgi.com/projects/FreeB/
- * shall be included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * SILICON GRAPHICS, INC. 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.
- *
- * Except as contained in this notice, the name of Silicon Graphics, Inc.
- * shall not be used in advertising or otherwise to promote the sale, use or
- * other dealings in this Software without prior written authorization from
- * Silicon Graphics, Inc.
- */
-
-#include "glxserver.h"
-#include "unpack.h"
-#include "g_disptab.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);
-
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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);
-
-    hdr->swapBytes = !hdr->swapBytes;
-
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
-
-void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
-{
-    __GLXdispatchConvolutionFilterHeader *hdr =
-				(__GLXdispatchConvolutionFilterHeader *) pc;
-    GLint hdrlen, image1len;
-    __GLX_DECLARE_SWAP_VARIABLES;
-
-    hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
-
-    __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.
-    */
-    hdr->swapBytes = !hdr->swapBytes;
-}
+/*

+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)

+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, including without limitation

+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,

+ * and/or sell copies of the Software, and to permit persons to whom the

+ * Software is furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice including the dates of first publication and

+ * either this permission notice or a reference to

+ * http://oss.sgi.com/projects/FreeB/

+ * shall be included in all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * SILICON GRAPHICS, INC. 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.

+ *

+ * Except as contained in this notice, the name of Silicon Graphics, Inc.

+ * shall not be used in advertising or otherwise to promote the sale, use or

+ * other dealings in this Software without prior written authorization from

+ * Silicon Graphics, Inc.

+ */

+

+#include "glxserver.h"

+#include "unpack.h"

+#include "g_disptab.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);

+

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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);

+

+    hdr->swapBytes = !hdr->swapBytes;

+

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

+

+void __glXDispSwap_SeparableFilter2D(GLbyte *pc)

+{

+    __GLXdispatchConvolutionFilterHeader *hdr =

+				(__GLXdispatchConvolutionFilterHeader *) pc;

+    GLint hdrlen;

+    __GLX_DECLARE_SWAP_VARIABLES;

+

+    hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);

+

+    __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.

+    */

+    hdr->swapBytes = !hdr->swapBytes;

+}

diff --git a/xorg-server/hw/dmx/input/dmxinputinit.c b/xorg-server/hw/dmx/input/dmxinputinit.c
index f9acaa039..c700a1246 100644
--- a/xorg-server/hw/dmx/input/dmxinputinit.c
+++ b/xorg-server/hw/dmx/input/dmxinputinit.c
@@ -839,7 +839,6 @@ static void dmxInputScanForExtensions(DMXInputInfo *dmxInput, int doXI)
     Display              *display;

     int                  num;

     int                  i, j;

-    DMXLocalInputInfoPtr dmxLocal;

     int                  (*handler)(Display *, char *, char *);

 

     if (!(display = XOpenDisplay(dmxInput->name))) return;

diff --git a/xorg-server/hw/dmx/input/dmxxinput.c b/xorg-server/hw/dmx/input/dmxxinput.c
index a2a4156ab..3d5f32775 100644
--- a/xorg-server/hw/dmx/input/dmxxinput.c
+++ b/xorg-server/hw/dmx/input/dmxxinput.c
@@ -1,150 +1,93 @@
-/*
- * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.
- *
- * 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 on the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial
- * portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT 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.
- */
-
-/*
- * Authors:
- *   Rickard E. (Rik) Faith <faith@redhat.com>
- *
- */
-
-/** \file
- *
- * This file implements support required by the XINPUT extension.
- */
-
-#ifdef HAVE_DMX_CONFIG_H
-#include <dmx-config.h>
-#endif
-
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "inputstr.h"
-#include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>
-#include "XIstubs.h"
-
-#include "mipointer.h"
-#include "dmxinputinit.h"
-#include "exevents.h"
-
-/** Change the core keyboard from \a old_dev to \a new_dev.  Currently
- * this is not implemented. */
-int ChangeKeyboardDevice(DeviceIntPtr old_dev, DeviceIntPtr new_dev)
-{
-#if 0
-    DMXLocalInputInfoPtr dmxLocalOld = old_dev->public.devicePrivate;
-    DMXLocalInputInfoPtr dmxLocalNew = new_dev->public.devicePrivate;
-    
-                                /* Switch our notion of core keyboard */
-    dmxLocalOld->isCore         = 0;
-    dmxLocalOld->sendsCore      = dmxLocalOld->savedSendsCore;
-
-    dmxLocalNew->isCore         = 1;
-    dmxLocalNew->savedSendsCore = dmxLocalNew->sendsCore;
-    dmxLocalNew->sendsCore      = 1;
-    dmxLocalCorePointer         = dmxLocalNew;
-
-    RegisterKeyboardDevice(new_dev);
-    RegisterOtherDevice(old_dev);
-    
-    return Success;
-#endif
-    return BadMatch;
-}
-
-/** Change the core pointer from \a old_dev to \a new_dev. */
-int ChangePointerDevice(DeviceIntPtr old_dev,
-                        DeviceIntPtr new_dev,
-                        unsigned char x,
-                        unsigned char y)
-{
-    DMXLocalInputInfoPtr dmxLocalOld = old_dev->public.devicePrivate;
-    DMXLocalInputInfoPtr dmxLocalNew = new_dev->public.devicePrivate;
-    
-    if (x != 0 || y != 1) return BadMatch;
-
-                                /* Make sure the new device can focus */
-    InitFocusClassDeviceStruct(old_dev);
-
-                                /* Switch the motion history buffers */
-    if (dmxLocalOld->savedMotionProc) {
-        old_dev->valuator->numMotionEvents = dmxLocalOld->savedMotionEvents;
-    }
-    dmxLocalNew->savedMotionEvents     = new_dev->valuator->numMotionEvents;
-    new_dev->valuator->numMotionEvents = GetMaximumEventsNum();
-                                /* Switch our notion of core pointer */
-    dmxLocalOld->isCore         = 0;
-    dmxLocalOld->sendsCore      = dmxLocalOld->savedSendsCore;
-
-    dmxLocalNew->isCore         = 1;
-    dmxLocalNew->savedSendsCore = dmxLocalNew->sendsCore;
-    dmxLocalNew->sendsCore      = 1;
-    dmxLocalCorePointer         = dmxLocalNew;
-    
-    return Success;
-}
-
-/** Close the input device.  This is not required by the XINPUT model
- * that DMX uses. */
-void CloseInputDevice (DeviceIntPtr d, ClientPtr client)
-{
-}
-
-/** This is not required by the XINPUT model that DMX uses. */
-void AddOtherInputDevices(void)
-{
-}
-
-/** Open an input device.  This is not required by the XINPUT model that
- * DMX uses. */
-void OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)
-{
-}
-
-/** Set device mode to \a mode.  This is not implemented. */
-int SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)
-{
-    return BadMatch;
-}
-
-/** Set device valuators.  This is not implemented. */
-int SetDeviceValuators (ClientPtr client,
-                        DeviceIntPtr dev,
-                        int *valuators,
-                        int first_valuator,
-                        int num_valuators)
-{
-    return BadMatch;
-}
-
-/** Change device control.  This is not implemented. */
-int ChangeDeviceControl(ClientPtr client,
-                        DeviceIntPtr dev,
-                        xDeviceCtl *control)
-{
-    return BadMatch;
-}
+/*

+ * Copyright 2002-2003 Red Hat Inc., Durham, North Carolina.

+ *

+ * 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 on the rights to use, copy, modify, merge,

+ * publish, distribute, sublicense, and/or sell copies of the Software,

+ * and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the

+ * next paragraph) shall be included in all copies or substantial

+ * portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT 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.

+ */

+

+/*

+ * Authors:

+ *   Rickard E. (Rik) Faith <faith@redhat.com>

+ *

+ */

+

+/** \file

+ *

+ * This file implements support required by the XINPUT extension.

+ */

+

+#ifdef HAVE_DMX_CONFIG_H

+#include <dmx-config.h>

+#endif

+

+#include <X11/X.h>

+#include <X11/Xproto.h>

+#include "inputstr.h"

+#include <X11/extensions/XI.h>

+#include <X11/extensions/XIproto.h>

+#include "XIstubs.h"

+

+#include "mipointer.h"

+#include "dmxinputinit.h"

+#include "exevents.h"

+

+/** Close the input device.  This is not required by the XINPUT model

+ * that DMX uses. */

+void CloseInputDevice (DeviceIntPtr d, ClientPtr client)

+{

+}

+

+/** This is not required by the XINPUT model that DMX uses. */

+void AddOtherInputDevices(void)

+{

+}

+

+/** Open an input device.  This is not required by the XINPUT model that

+ * DMX uses. */

+void OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)

+{

+}

+

+/** Set device mode to \a mode.  This is not implemented. */

+int SetDeviceMode(ClientPtr client, DeviceIntPtr dev, int mode)

+{

+    return BadMatch;

+}

+

+/** Set device valuators.  This is not implemented. */

+int SetDeviceValuators (ClientPtr client,

+                        DeviceIntPtr dev,

+                        int *valuators,

+                        int first_valuator,

+                        int num_valuators)

+{

+    return BadMatch;

+}

+

+/** Change device control.  This is not implemented. */

+int ChangeDeviceControl(ClientPtr client,

+                        DeviceIntPtr dev,

+                        xDeviceCtl *control)

+{

+    return BadMatch;

+}

diff --git a/xorg-server/hw/kdrive/ephyr/XF86dri.c b/xorg-server/hw/kdrive/ephyr/XF86dri.c
index 08123d35c..247580e0a 100644
--- a/xorg-server/hw/kdrive/ephyr/XF86dri.c
+++ b/xorg-server/hw/kdrive/ephyr/XF86dri.c
@@ -1,628 +1,628 @@
-/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
-/**************************************************************************
-
-Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
-Copyright 2000 VA Linux Systems, Inc.
-All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, 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 PRECISION INSIGHT AND/OR ITS 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.
-
-**************************************************************************/
-
-/*
- * Authors:
- *   Kevin E. Martin <martin@valinux.com>
- *   Jens Owen <jens@tungstengraphics.com>
- *   Rickard E. (Rik) Faith <faith@valinux.com>
- *
- */
-
-/*
- * This file has been copied from the mesa source tree and a little bit
- * modified by:
- *
- * Dodji Seketeli <dodji@openedhand.com>
- */
-
-#ifdef HAVE_CONFIG_H
-#include <kdrive-config.h>
-#endif
-/*
- * including some server headers (like kdrive-config.h)
- * might define the macro _XSERVER64
- * on 64 bits machines. That macro must _NOT_ be defined for Xlib
- * client code, otherwise bad things happen.
- * So let's undef that macro if necessary.
- */
-#ifdef _XSERVER64
-#undef _XSERVER64
-#endif
-
-/* THIS IS NOT AN X CONSORTIUM STANDARD */
-
-#include <X11/Xlibint.h>
-#include <X11/extensions/Xext.h>
-#include <X11/extensions/extutil.h>
-#include <GL/glx.h>
-#include "xf86dri.h"
-#include <X11/dri/xf86driproto.h>
-
-static XExtensionInfo _xf86dri_info_data;
-static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
-static char xf86dri_extension_name[] = XF86DRINAME;
-
-#define XF86DRICheckExtension(dpy,i,val) \
-  XextCheckExtension (dpy, i, xf86dri_extension_name, val)
-
-/*****************************************************************************
- *                                                                           *
- *			   private utility routines                          *
- *                                                                           *
- *****************************************************************************/
-
-static int close_display(Display *dpy, XExtCodes *extCodes);
-static /* const */ XExtensionHooks xf86dri_extension_hooks = {
-    NULL,				/* create_gc */
-    NULL,				/* copy_gc */
-    NULL,				/* flush_gc */
-    NULL,				/* free_gc */
-    NULL,				/* create_font */
-    NULL,				/* free_font */
-    close_display,			/* close_display */
-    NULL,				/* wire_to_event */
-    NULL,				/* event_to_wire */
-    NULL,				/* error */
-    NULL,				/* error_string */
-};
-
-static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
-				   xf86dri_extension_name, 
-				   &xf86dri_extension_hooks, 
-				   0, NULL)
-
-static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
-
-
-/*****************************************************************************
- *                                                                           *
- *		    public XFree86-DRI Extension routines                    *
- *                                                                           *
- *****************************************************************************/
-
-#if 0
-#include <stdio.h>
-#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
-#else
-#define TRACE(msg)
-#endif
-
-Bool XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable);
-Bool XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable);
-
-Bool XF86DRIQueryExtension (Display *dpy, int *event_basep, int *error_basep)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-
-    TRACE("QueryExtension...");
-    if (XextHasExtension(info)) {
-	*event_basep = info->codes->first_event;
-	*error_basep = info->codes->first_error;
-        TRACE("QueryExtension... return True");
-	return True;
-    } else {
-        TRACE("QueryExtension... return False");
-	return False;
-    }
-}
-
-Bool XF86DRIQueryVersion(Display *dpy, int *majorVersion, int *minorVersion,
-                         int *patchVersion)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIQueryVersionReply rep;
-    xXF86DRIQueryVersionReq *req;
-
-    TRACE("QueryVersion...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIQueryVersion, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIQueryVersion;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("QueryVersion... return False");
-	return False;
-    }
-    *majorVersion = rep.majorVersion;
-    *minorVersion = rep.minorVersion;
-    *patchVersion = rep.patchVersion;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("QueryVersion... return True");
-    return True;
-}
-
-Bool
-XF86DRIQueryDirectRenderingCapable (Display *dpy, int screen, Bool *isCapable)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIQueryDirectRenderingCapableReply rep;
-    xXF86DRIQueryDirectRenderingCapableReq *req;
-
-    TRACE("QueryDirectRenderingCapable...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIQueryDirectRenderingCapable, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-        UnlockDisplay(dpy);
-        SyncHandle();
-        TRACE("QueryDirectRenderingCapable... return False");
-        return False;
-    }
-    *isCapable = rep.isCapable;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("QueryDirectRenderingCapable... return True");
-    return True;
-}
-
-Bool
-XF86DRIOpenConnection (Display *dpy, int screen,
-                       drm_handle_t *hSAREA,
-                       char **busIdString)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIOpenConnectionReply rep;
-    xXF86DRIOpenConnectionReq *req;
-
-    TRACE("OpenConnection...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIOpenConnection, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIOpenConnection;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-        UnlockDisplay(dpy);
-        SyncHandle();
-        TRACE("OpenConnection... return False");
-        return False;
-    }
-
-    *hSAREA = rep.hSAREALow;
-    if (sizeof(drm_handle_t) == 8) {
-        int shift = 32; /* var to prevent warning on next line */
-        *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
-    }
-
-    if (rep.length) {
-        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
-            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
-            UnlockDisplay(dpy);
-            SyncHandle();
-            TRACE("OpenConnection... return False");
-            return False;
-        }
-        _XReadPad(dpy, *busIdString, rep.busIdStringLength);
-    } else {
-        *busIdString = NULL;
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("OpenConnection... return True");
-    return True;
-}
-
-Bool XF86DRIAuthConnection(Display *dpy, int screen, drm_magic_t magic)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIAuthConnectionReq *req;
-    xXF86DRIAuthConnectionReply rep;
-
-    TRACE("AuthConnection...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIAuthConnection, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIAuthConnection;
-    req->screen = screen;
-    req->magic = magic;
-    rep.authenticated = 0;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("AuthConnection... return False");
-	return False;
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("AuthConnection... return True");
-    return True;
-}
-
-Bool XF86DRICloseConnection(Display *dpy, int screen)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRICloseConnectionReq *req;
-
-    TRACE("CloseConnection...");
-
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRICloseConnection, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRICloseConnection;
-    req->screen = screen;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("CloseConnection... return True");
-    return True;
-}
-
-Bool XF86DRIGetClientDriverName(Display *dpy, int screen,
-                                int *ddxDriverMajorVersion,
-	                        int *ddxDriverMinorVersion,
-                                int *ddxDriverPatchVersion,
-                                char **clientDriverName)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIGetClientDriverNameReply rep;
-    xXF86DRIGetClientDriverNameReq *req;
-
-    TRACE("GetClientDriverName...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIGetClientDriverName, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIGetClientDriverName;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("GetClientDriverName... return False");
-	return False;
-    }
-
-    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
-    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
-    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
-
-    if (rep.length) {
-        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
-            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
-            UnlockDisplay(dpy);
-            SyncHandle();
-            TRACE("GetClientDriverName... return False");
-            return False;
-        }
-	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
-    } else {
-        *clientDriverName = NULL;
-    }
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("GetClientDriverName... return True");
-    return True;
-}
-
-Bool XF86DRICreateContextWithConfig(Display *dpy, int screen, int configID,
-                                    XID *context, drm_context_t *hHWContext)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRICreateContextReply rep;
-    xXF86DRICreateContextReq *req;
-
-    TRACE("CreateContext...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRICreateContext, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRICreateContext;
-    req->visual = configID;
-    req->screen = screen;
-    *context = XAllocID(dpy);
-    req->context = *context;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("CreateContext... return False");
-	return False;
-    }
-    *hHWContext = rep.hHWContext;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("CreateContext... return True");
-    return True;
-}
-
-Bool XF86DRICreateContext(Display *dpy, int screen, Visual *visual,
-                          XID *context, drm_context_t *hHWContext)
-{
-    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
-					   context, hHWContext );
-}
-
-GLboolean XF86DRIDestroyContext( Display *dpy, int screen, XID context)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIDestroyContextReq *req;
-
-    TRACE("DestroyContext...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIDestroyContext, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIDestroyContext;
-    req->screen = screen;
-    req->context = context;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("DestroyContext... return True");
-    return True;
-}
-
-GLboolean
-XF86DRICreateDrawable (Display *dpy, int screen,
-                       XID drawable, drm_drawable_t * hHWDrawable)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRICreateDrawableReply rep;
-    xXF86DRICreateDrawableReq *req;
-
-    TRACE("CreateDrawable...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRICreateDrawable, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRICreateDrawable;
-    req->screen = screen;
-    req->drawable = drawable;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("CreateDrawable... return False");
-	return False;
-    }
-    *hHWDrawable = rep.hHWDrawable;
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("CreateDrawable... return True");
-    return True;
-}
-
-static int noopErrorHandler(Display *dpy, XErrorEvent *xerr)
-{
-    return 0;
-}
-
-GLboolean XF86DRIDestroyDrawable( Display *dpy, int screen,
-    XID drawable )
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIDestroyDrawableReq *req;
-    int (*oldXErrorHandler)(Display *, XErrorEvent *);
-
-    TRACE("DestroyDrawable...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    /* This is called from the DRI driver, which used call it like this
-     *
-     *   if (windowExists(drawable))
-     *     destroyDrawable(drawable);
-     *
-     * which is a textbook race condition - the window may disappear
-     * from the server between checking for its existance and
-     * destroying it.  Instead we change the semantics of
-     * __DRIinterfaceMethodsRec::destroyDrawable() to succeed even if
-     * the windows is gone, by wrapping the destroy call in an error
-     * handler. */
-
-    XSync(dpy, GL_FALSE);
-    oldXErrorHandler = XSetErrorHandler(noopErrorHandler);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIDestroyDrawable, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIDestroyDrawable;
-    req->screen = screen;
-    req->drawable = drawable;
-    UnlockDisplay(dpy);
-    SyncHandle();
-
-    XSetErrorHandler(oldXErrorHandler);
-
-    TRACE("DestroyDrawable... return True");
-    return True;
-}
-
-Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
-    unsigned int* index, unsigned int* stamp,
-    int* X, int* Y, int* W, int* H,
-    int* numClipRects, drm_clip_rect_t ** pClipRects,
-    int* backX, int* backY,
-    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIGetDrawableInfoReply rep;
-    xXF86DRIGetDrawableInfoReq *req=NULL;
-    int total_rects;
-
-    TRACE("GetDrawableInfo...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIGetDrawableInfo, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIGetDrawableInfo;
-    req->screen = screen;
-    req->drawable = drawable;
-
-    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
-    {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("GetDrawableInfo... return False");
-	return False;
-    }
-    *index = rep.drawableTableIndex;
-    *stamp = rep.drawableTableStamp;
-    *X = (int)rep.drawableX;
-    *Y = (int)rep.drawableY;
-    *W = (int)rep.drawableWidth;
-    *H = (int)rep.drawableHeight;
-    *numClipRects = rep.numClipRects;
-    total_rects = *numClipRects;
-
-    *backX = rep.backX;
-    *backY = rep.backY;
-    *numBackClipRects = rep.numBackClipRects;
-    total_rects += *numBackClipRects;
-
-#if 0
-    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
-     * backwards compatibility (Because of the >> 2 shift) but the fix
-     * enables multi-threaded apps to work.
-     */
-    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
-		       SIZEOF(xGenericReply) + 
-		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
-        _XEatData(dpy, rep.length);
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("GetDrawableInfo... return False");
-        return False;
-    }
-#endif
-
-    if (*numClipRects) {
-       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
-
-       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
-       if (*pClipRects)
-	  _XRead(dpy, (char*)*pClipRects, len);
-    } else {
-        *pClipRects = NULL;
-    }
-
-    if (*numBackClipRects) {
-       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
-
-       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
-       if (*pBackClipRects) 
-	  _XRead(dpy, (char*)*pBackClipRects, len);
-    } else {
-        *pBackClipRects = NULL;
-    }
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("GetDrawableInfo... return True");
-    return True;
-}
-
-Bool
-XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,
-                      int *fbOrigin, int *fbSize, int *fbStride,
-                      int *devPrivateSize, void **pDevPrivate)
-{
-    XExtDisplayInfo *info = find_display (dpy);
-    xXF86DRIGetDeviceInfoReply rep;
-    xXF86DRIGetDeviceInfoReq *req;
-
-    TRACE("GetDeviceInfo...");
-    XF86DRICheckExtension (dpy, info, False);
-
-    LockDisplay(dpy);
-    GetReq(XF86DRIGetDeviceInfo, req);
-    req->reqType = info->codes->major_opcode;
-    req->driReqType = X_XF86DRIGetDeviceInfo;
-    req->screen = screen;
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
-	UnlockDisplay(dpy);
-	SyncHandle();
-        TRACE("GetDeviceInfo... return False");
-	return False;
-    }
-
-    *hFrameBuffer = rep.hFrameBufferLow;
-    if (sizeof(drm_handle_t) == 8) {
-       int shift = 32; /* var to prevent warning on next line */
-       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
-    }
-
-    *fbOrigin = rep.framebufferOrigin;
-    *fbSize = rep.framebufferSize;
-    *fbStride = rep.framebufferStride;
-    *devPrivateSize = rep.devPrivateSize;
-
-    if (rep.length) {
-        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
-            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
-            UnlockDisplay(dpy);
-            SyncHandle();
-            TRACE("GetDeviceInfo... return False");
-            return False;
-        }
-	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
-    } else {
-        *pDevPrivate = NULL;
-    }
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-    TRACE("GetDeviceInfo... return True");
-    return True;
-}
-
-Bool
-XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable)
-{
-    /* This function and the underlying X protocol are deprecated.
-     */
-    (void) dpy;
-    (void) screen;
-    (void) drawable;
-    return False;
-}
-
-Bool
-XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable)
-{
-    /* This function and the underlying X protocol are deprecated.
-     */
-    (void) dpy;
-    (void) screen;
-    (void) drawable;
-    return True;
-}
+/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */

+/**************************************************************************

+

+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.

+Copyright 2000 VA Linux Systems, Inc.

+All Rights Reserved.

+

+Permission is hereby granted, free of charge, to any person obtaining a

+copy of this software and associated documentation files (the

+"Software"), to deal in the Software without restriction, including

+without limitation the rights to use, copy, modify, merge, publish,

+distribute, 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 PRECISION INSIGHT AND/OR ITS 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.

+

+**************************************************************************/

+

+/*

+ * Authors:

+ *   Kevin E. Martin <martin@valinux.com>

+ *   Jens Owen <jens@tungstengraphics.com>

+ *   Rickard E. (Rik) Faith <faith@valinux.com>

+ *

+ */

+

+/*

+ * This file has been copied from the mesa source tree and a little bit

+ * modified by:

+ *

+ * Dodji Seketeli <dodji@openedhand.com>

+ */

+

+#ifdef HAVE_CONFIG_H

+#include <kdrive-config.h>

+#endif

+/*

+ * including some server headers (like kdrive-config.h)

+ * might define the macro _XSERVER64

+ * on 64 bits machines. That macro must _NOT_ be defined for Xlib

+ * client code, otherwise bad things happen.

+ * So let's undef that macro if necessary.

+ */

+#ifdef _XSERVER64

+#undef _XSERVER64

+#endif

+

+/* THIS IS NOT AN X CONSORTIUM STANDARD */

+

+#include <X11/Xlibint.h>

+#include <X11/extensions/Xext.h>

+#include <X11/extensions/extutil.h>

+#include <GL/glx.h>

+#include "xf86dri.h"

+#include <X11/dri/xf86driproto.h>

+

+static XExtensionInfo _xf86dri_info_data;

+static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;

+static char xf86dri_extension_name[] = XF86DRINAME;

+

+#define XF86DRICheckExtension(dpy,i,val) \

+  XextCheckExtension (dpy, i, xf86dri_extension_name, val)

+

+/*****************************************************************************

+ *                                                                           *

+ *			   private utility routines                          *

+ *                                                                           *

+ *****************************************************************************/

+

+static int close_display(Display *dpy, XExtCodes *extCodes);

+static /* const */ XExtensionHooks xf86dri_extension_hooks = {

+    NULL,				/* create_gc */

+    NULL,				/* copy_gc */

+    NULL,				/* flush_gc */

+    NULL,				/* free_gc */

+    NULL,				/* create_font */

+    NULL,				/* free_font */

+    close_display,			/* close_display */

+    NULL,				/* wire_to_event */

+    NULL,				/* event_to_wire */

+    NULL,				/* error */

+    NULL,				/* error_string */

+};

+

+static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 

+				   xf86dri_extension_name, 

+				   &xf86dri_extension_hooks, 

+				   0, NULL)

+

+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)

+

+

+/*****************************************************************************

+ *                                                                           *

+ *		    public XFree86-DRI Extension routines                    *

+ *                                                                           *

+ *****************************************************************************/

+

+#if 0

+#include <stdio.h>

+#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);

+#else

+#define TRACE(msg)

+#endif

+

+Bool XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable);

+Bool XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable);

+

+Bool XF86DRIQueryExtension (Display *dpy, int *event_basep, int *error_basep)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+

+    TRACE("QueryExtension...");

+    if (XextHasExtension(info)) {

+	*event_basep = info->codes->first_event;

+	*error_basep = info->codes->first_error;

+        TRACE("QueryExtension... return True");

+	return True;

+    } else {

+        TRACE("QueryExtension... return False");

+	return False;

+    }

+}

+

+Bool XF86DRIQueryVersion(Display *dpy, int *majorVersion, int *minorVersion,

+                         int *patchVersion)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIQueryVersionReply rep;

+    xXF86DRIQueryVersionReq *req;

+

+    TRACE("QueryVersion...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIQueryVersion, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIQueryVersion;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("QueryVersion... return False");

+	return False;

+    }

+    *majorVersion = rep.majorVersion;

+    *minorVersion = rep.minorVersion;

+    *patchVersion = rep.patchVersion;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("QueryVersion... return True");

+    return True;

+}

+

+Bool

+XF86DRIQueryDirectRenderingCapable (Display *dpy, int screen, Bool *isCapable)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIQueryDirectRenderingCapableReply rep;

+    xXF86DRIQueryDirectRenderingCapableReq *req;

+

+    TRACE("QueryDirectRenderingCapable...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIQueryDirectRenderingCapable, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;

+    req->screen = screen;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+        UnlockDisplay(dpy);

+        SyncHandle();

+        TRACE("QueryDirectRenderingCapable... return False");

+        return False;

+    }

+    *isCapable = rep.isCapable;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("QueryDirectRenderingCapable... return True");

+    return True;

+}

+

+Bool

+XF86DRIOpenConnection (Display *dpy, int screen,

+                       drm_handle_t *hSAREA,

+                       char **busIdString)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIOpenConnectionReply rep;

+    xXF86DRIOpenConnectionReq *req;

+

+    TRACE("OpenConnection...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIOpenConnection, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIOpenConnection;

+    req->screen = screen;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+        UnlockDisplay(dpy);

+        SyncHandle();

+        TRACE("OpenConnection... return False");

+        return False;

+    }

+

+    *hSAREA = rep.hSAREALow;

+    if (sizeof(drm_handle_t) == 8) {

+        int shift = 32; /* var to prevent warning on next line */

+        *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;

+    }

+

+    if (rep.length) {

+        if (!(*busIdString = (char *)calloc(rep.busIdStringLength + 1, 1))) {

+            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));

+            UnlockDisplay(dpy);

+            SyncHandle();

+            TRACE("OpenConnection... return False");

+            return False;

+        }

+        _XReadPad(dpy, *busIdString, rep.busIdStringLength);

+    } else {

+        *busIdString = NULL;

+    }

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("OpenConnection... return True");

+    return True;

+}

+

+Bool XF86DRIAuthConnection(Display *dpy, int screen, drm_magic_t magic)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIAuthConnectionReq *req;

+    xXF86DRIAuthConnectionReply rep;

+

+    TRACE("AuthConnection...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIAuthConnection, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIAuthConnection;

+    req->screen = screen;

+    req->magic = magic;

+    rep.authenticated = 0;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("AuthConnection... return False");

+	return False;

+    }

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("AuthConnection... return True");

+    return True;

+}

+

+Bool XF86DRICloseConnection(Display *dpy, int screen)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRICloseConnectionReq *req;

+

+    TRACE("CloseConnection...");

+

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRICloseConnection, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRICloseConnection;

+    req->screen = screen;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("CloseConnection... return True");

+    return True;

+}

+

+Bool XF86DRIGetClientDriverName(Display *dpy, int screen,

+                                int *ddxDriverMajorVersion,

+	                        int *ddxDriverMinorVersion,

+                                int *ddxDriverPatchVersion,

+                                char **clientDriverName)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIGetClientDriverNameReply rep;

+    xXF86DRIGetClientDriverNameReq *req;

+

+    TRACE("GetClientDriverName...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIGetClientDriverName, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIGetClientDriverName;

+    req->screen = screen;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("GetClientDriverName... return False");

+	return False;

+    }

+

+    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;

+    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;

+    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;

+

+    if (rep.length) {

+        if (!(*clientDriverName = (char *)calloc(rep.clientDriverNameLength + 1, 1))) {

+            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));

+            UnlockDisplay(dpy);

+            SyncHandle();

+            TRACE("GetClientDriverName... return False");

+            return False;

+        }

+	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);

+    } else {

+        *clientDriverName = NULL;

+    }

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("GetClientDriverName... return True");

+    return True;

+}

+

+Bool XF86DRICreateContextWithConfig(Display *dpy, int screen, int configID,

+                                    XID *context, drm_context_t *hHWContext)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRICreateContextReply rep;

+    xXF86DRICreateContextReq *req;

+

+    TRACE("CreateContext...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRICreateContext, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRICreateContext;

+    req->visual = configID;

+    req->screen = screen;

+    *context = XAllocID(dpy);

+    req->context = *context;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("CreateContext... return False");

+	return False;

+    }

+    *hHWContext = rep.hHWContext;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("CreateContext... return True");

+    return True;

+}

+

+Bool XF86DRICreateContext(Display *dpy, int screen, Visual *visual,

+                          XID *context, drm_context_t *hHWContext)

+{

+    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,

+					   context, hHWContext );

+}

+

+GLboolean XF86DRIDestroyContext( Display *dpy, int screen, XID context)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIDestroyContextReq *req;

+

+    TRACE("DestroyContext...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIDestroyContext, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIDestroyContext;

+    req->screen = screen;

+    req->context = context;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("DestroyContext... return True");

+    return True;

+}

+

+GLboolean

+XF86DRICreateDrawable (Display *dpy, int screen,

+                       XID drawable, drm_drawable_t * hHWDrawable)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRICreateDrawableReply rep;

+    xXF86DRICreateDrawableReq *req;

+

+    TRACE("CreateDrawable...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRICreateDrawable, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRICreateDrawable;

+    req->screen = screen;

+    req->drawable = drawable;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("CreateDrawable... return False");

+	return False;

+    }

+    *hHWDrawable = rep.hHWDrawable;

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("CreateDrawable... return True");

+    return True;

+}

+

+static int noopErrorHandler(Display *dpy, XErrorEvent *xerr)

+{

+    return 0;

+}

+

+GLboolean XF86DRIDestroyDrawable( Display *dpy, int screen,

+    XID drawable )

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIDestroyDrawableReq *req;

+    int (*oldXErrorHandler)(Display *, XErrorEvent *);

+

+    TRACE("DestroyDrawable...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    /* This is called from the DRI driver, which used call it like this

+     *

+     *   if (windowExists(drawable))

+     *     destroyDrawable(drawable);

+     *

+     * which is a textbook race condition - the window may disappear

+     * from the server between checking for its existance and

+     * destroying it.  Instead we change the semantics of

+     * __DRIinterfaceMethodsRec::destroyDrawable() to succeed even if

+     * the windows is gone, by wrapping the destroy call in an error

+     * handler. */

+

+    XSync(dpy, GL_FALSE);

+    oldXErrorHandler = XSetErrorHandler(noopErrorHandler);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIDestroyDrawable, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIDestroyDrawable;

+    req->screen = screen;

+    req->drawable = drawable;

+    UnlockDisplay(dpy);

+    SyncHandle();

+

+    XSetErrorHandler(oldXErrorHandler);

+

+    TRACE("DestroyDrawable... return True");

+    return True;

+}

+

+Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,

+    unsigned int* index, unsigned int* stamp,

+    int* X, int* Y, int* W, int* H,

+    int* numClipRects, drm_clip_rect_t ** pClipRects,

+    int* backX, int* backY,

+    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIGetDrawableInfoReply rep;

+    xXF86DRIGetDrawableInfoReq *req=NULL;

+    int total_rects;

+

+    TRACE("GetDrawableInfo...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIGetDrawableInfo, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIGetDrawableInfo;

+    req->screen = screen;

+    req->drawable = drawable;

+

+    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 

+    {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("GetDrawableInfo... return False");

+	return False;

+    }

+    *index = rep.drawableTableIndex;

+    *stamp = rep.drawableTableStamp;

+    *X = (int)rep.drawableX;

+    *Y = (int)rep.drawableY;

+    *W = (int)rep.drawableWidth;

+    *H = (int)rep.drawableHeight;

+    *numClipRects = rep.numClipRects;

+    total_rects = *numClipRects;

+

+    *backX = rep.backX;

+    *backY = rep.backY;

+    *numBackClipRects = rep.numBackClipRects;

+    total_rects += *numBackClipRects;

+

+#if 0

+    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks

+     * backwards compatibility (Because of the >> 2 shift) but the fix

+     * enables multi-threaded apps to work.

+     */

+    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 

+		       SIZEOF(xGenericReply) + 

+		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {

+        _XEatData(dpy, rep.length);

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("GetDrawableInfo... return False");

+        return False;

+    }

+#endif

+

+    if (*numClipRects) {

+       int len = sizeof(drm_clip_rect_t) * (*numClipRects);

+

+       *pClipRects = (drm_clip_rect_t *)calloc(len, 1);

+       if (*pClipRects)

+	  _XRead(dpy, (char*)*pClipRects, len);

+    } else {

+        *pClipRects = NULL;

+    }

+

+    if (*numBackClipRects) {

+       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);

+

+       *pBackClipRects = (drm_clip_rect_t *)calloc(len, 1);

+       if (*pBackClipRects) 

+	  _XRead(dpy, (char*)*pBackClipRects, len);

+    } else {

+        *pBackClipRects = NULL;

+    }

+

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("GetDrawableInfo... return True");

+    return True;

+}

+

+Bool

+XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,

+                      int *fbOrigin, int *fbSize, int *fbStride,

+                      int *devPrivateSize, void **pDevPrivate)

+{

+    XExtDisplayInfo *info = find_display (dpy);

+    xXF86DRIGetDeviceInfoReply rep;

+    xXF86DRIGetDeviceInfoReq *req;

+

+    TRACE("GetDeviceInfo...");

+    XF86DRICheckExtension (dpy, info, False);

+

+    LockDisplay(dpy);

+    GetReq(XF86DRIGetDeviceInfo, req);

+    req->reqType = info->codes->major_opcode;

+    req->driReqType = X_XF86DRIGetDeviceInfo;

+    req->screen = screen;

+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

+	UnlockDisplay(dpy);

+	SyncHandle();

+        TRACE("GetDeviceInfo... return False");

+	return False;

+    }

+

+    *hFrameBuffer = rep.hFrameBufferLow;

+    if (sizeof(drm_handle_t) == 8) {

+       int shift = 32; /* var to prevent warning on next line */

+       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;

+    }

+

+    *fbOrigin = rep.framebufferOrigin;

+    *fbSize = rep.framebufferSize;

+    *fbStride = rep.framebufferStride;

+    *devPrivateSize = rep.devPrivateSize;

+

+    if (rep.length) {

+        if (!(*pDevPrivate = (void *)calloc(rep.devPrivateSize, 1))) {

+            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));

+            UnlockDisplay(dpy);

+            SyncHandle();

+            TRACE("GetDeviceInfo... return False");

+            return False;

+        }

+	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);

+    } else {

+        *pDevPrivate = NULL;

+    }

+

+    UnlockDisplay(dpy);

+    SyncHandle();

+    TRACE("GetDeviceInfo... return True");

+    return True;

+}

+

+Bool

+XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable)

+{

+    /* This function and the underlying X protocol are deprecated.

+     */

+    (void) dpy;

+    (void) screen;

+    (void) drawable;

+    return False;

+}

+

+Bool

+XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable)

+{

+    /* This function and the underlying X protocol are deprecated.

+     */

+    (void) dpy;

+    (void) screen;

+    (void) drawable;

+    return True;

+}

diff --git a/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c b/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c
index 60f200629..da573dacb 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyrhostvideo.c
@@ -262,7 +262,7 @@ ephyrHostXVQueryAdaptors (EphyrHostXVAdaptorArray **a_adaptors)
 

     EPHYR_LOG ("enter\n") ;

 

-    result = Xcalloc (1, sizeof (EphyrHostXVAdaptorArray)) ;

+    result = calloc (1, sizeof (EphyrHostXVAdaptorArray)) ;

     if (!result)

         goto out ;

 

@@ -340,7 +340,7 @@ ephyrHostXVAdaptorGetVideoFormats (const EphyrHostXVAdaptor *a_this,
     EPHYR_RETURN_VAL_IF_FAIL (a_this, NULL) ;

 

     nb_formats = ((XvAdaptorInfo*)a_this)->num_formats ;

-    formats = Xcalloc (nb_formats, sizeof (EphyrHostVideoFormat)) ;

+    formats = calloc (nb_formats, sizeof (EphyrHostVideoFormat)) ;

     for (i=0; i < nb_formats; i++) {

         memset (&visual_info_template, 0, sizeof (visual_info_template)) ;

         visual_info_template.visualid =

@@ -454,7 +454,7 @@ ephyrHostXVQueryEncodings (int a_port_id,
                             &num_encodings,

                             &encoding_info) ;

     if (num_encodings && encoding_info) {

-        encodings = Xcalloc (num_encodings, sizeof (EphyrHostEncoding)) ;

+        encodings = calloc (num_encodings, sizeof (EphyrHostEncoding)) ;

         for (i=0; i<num_encodings; i++) {

             encodings[i].id = encoding_info[i].encoding_id ;

             encodings[i].name = strdup (encoding_info[i].name) ;

diff --git a/xorg-server/hw/kdrive/linux/evdev.c b/xorg-server/hw/kdrive/linux/evdev.c
index 71b93931b..20df77b99 100644
--- a/xorg-server/hw/kdrive/linux/evdev.c
+++ b/xorg-server/hw/kdrive/linux/evdev.c
@@ -165,7 +165,7 @@ EvdevPtrRead (int evdevPort, void *closure)
     n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));

     if (n <= 0) {

         if (errno == ENODEV)

-            DeleteInputDeviceRequest(pi->dixdev, 0);

+            DeleteInputDeviceRequest(pi->dixdev);

         return;

     }

 

@@ -375,7 +375,7 @@ EvdevKbdRead (int evdevPort, void *closure)
     n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));

     if (n <= 0) {

         if (errno == ENODEV)

-            DeleteInputDeviceRequest(ki->dixdev, 0);

+            DeleteInputDeviceRequest(ki->dixdev);

         return;

     }

 

diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c
index 21921b2c3..2d82ccdbc 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.c
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.c
@@ -854,7 +854,7 @@ unwind:
 }

 

 void

-DeleteInputDeviceRequest(DeviceIntPtr pDev, int flags)

+DeleteInputDeviceRequest(DeviceIntPtr pDev)

 {

     LocalDevicePtr pInfo = (LocalDevicePtr) pDev->public.devicePrivate;

     InputDriverPtr drv = NULL;

@@ -874,9 +874,9 @@ DeleteInputDeviceRequest(DeviceIntPtr pDev, int flags)
     if (!isMaster && pInfo != NULL)

     {

         if(drv->UnInit)

-            drv->UnInit(drv, pInfo, flags);

+            drv->UnInit(drv, pInfo, 0);

         else

-            xf86DeleteInput(pInfo, flags);

+            xf86DeleteInput(pInfo, 0);

 

         /* devices added through HAL aren't in the config layout */

         it = xf86ConfigLayout.inputs;

@@ -1267,7 +1267,7 @@ xf86DisableDevice(DeviceIntPtr dev, Bool panic)
     } else

     {

         SendDevicePresenceEvent(dev->id, DeviceUnrecoverable);

-        DeleteInputDeviceRequest(dev, 0);

+        DeleteInputDeviceRequest(dev);

     }

 }

 

diff --git a/xorg-server/hw/xfree86/int10/helper_mem.c b/xorg-server/hw/xfree86/int10/helper_mem.c
index b95b56a93..610cd42ac 100644
--- a/xorg-server/hw/xfree86/int10/helper_mem.c
+++ b/xorg-server/hw/xfree86/int10/helper_mem.c
@@ -296,15 +296,12 @@ xf86int10GetBiosSegment(xf86Int10InfoPtr pInt, void *base)
     unsigned i;

     int cs = ~0;

     int segments[4];

-    const char * format;

 

     segments[0] = MEM_RW(pInt, (0x10 << 2) + 2);

     segments[1] = MEM_RW(pInt, (0x42 << 2) + 2);

     segments[2] = V_BIOS >> 4;

     segments[3] = ~0;

 

-    format = "No V_BIOS found\n";

-

     for (i = 0; segments[i] != ~0; i++) {

 	unsigned char * vbiosMem;

 

@@ -318,7 +315,7 @@ xf86int10GetBiosSegment(xf86Int10InfoPtr pInt, void *base)
     }

 

     if (segments[i] == ~0) {

-	xf86DrvMsg(pInt->scrnIndex, X_ERROR, format, (unsigned long)cs << 4);

+	xf86DrvMsg(pInt->scrnIndex, X_ERROR, "No V_BIOS found\n");

 	return FALSE;

     }

 

diff --git a/xorg-server/hw/xquartz/darwinXinput.c b/xorg-server/hw/xquartz/darwinXinput.c
index cba2853a3..54ba2032a 100644
--- a/xorg-server/hw/xquartz/darwinXinput.c
+++ b/xorg-server/hw/xquartz/darwinXinput.c
@@ -245,7 +245,7 @@ NewInputDeviceRequest(InputOption *options, InputAttributes *attrs,
  *

  */

 void

-DeleteInputDeviceRequest(DeviceIntPtr dev, int flags)

+DeleteInputDeviceRequest(DeviceIntPtr dev)

 {

   DEBUG_LOG("DeleteInputDeviceRequest(%p)\n", dev);

 }