libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 512 insertions, 415 deletions

diff --git a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
index f28a79df6..ec0e83d09 100644
--- a/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
+++ b/xorg-server/hw/dmx/glxProxy/glxcmdsswap.c
@@ -39,9 +39,9 @@
 #include "glxext.h"
 #include "glxvendor.h"
 
-extern int glxIsExtensionSupported( char *ext );
+extern int glxIsExtensionSupported(char *ext);
 
-int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
+int __glXSwapGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc);
 
 /************************************************************************/
 
@@ -52,9 +52,11 @@ int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
 ** it is called at the end of the unswapped routine.
 */
 
-int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreateContext(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -66,9 +68,11 @@ int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
     return __glXCreateContext(cl, pc);
 }
 
-int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreateNewContext(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -80,9 +84,11 @@ int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
     return __glXCreateNewContext(cl, pc);
 }
 
-int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreateContextWithConfigSGIX(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXCreateContextWithConfigSGIXReq *req = (xGLXCreateContextWithConfigSGIXReq *) pc;
+    xGLXCreateContextWithConfigSGIXReq *req =
+        (xGLXCreateContextWithConfigSGIXReq *) pc;
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -94,10 +100,11 @@ int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
     return __glXCreateContextWithConfigSGIX(cl, pc);
 }
 
-int __glXSwapQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapQueryMaxSwapBarriersSGIX(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXQueryMaxSwapBarriersSGIXReq *req =
-	(xGLXQueryMaxSwapBarriersSGIXReq *)pc;
+        (xGLXQueryMaxSwapBarriersSGIXReq *) pc;
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -106,9 +113,11 @@ int __glXSwapQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
     return __glXQueryMaxSwapBarriersSGIX(cl, pc);
 }
 
-int __glXSwapBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapBindSwapBarrierSGIX(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *)pc;
+    xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -118,9 +127,11 @@ int __glXSwapBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
     return __glXBindSwapBarrierSGIX(cl, pc);
 }
 
-int __glXSwapJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapJoinSwapGroupSGIX(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *)pc;
+    xGLXJoinSwapGroupSGIXReq *req = (xGLXJoinSwapGroupSGIXReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -130,9 +141,11 @@ int __glXSwapJoinSwapGroupSGIX(__GLXclientState *cl, GLbyte *pc)
     return __glXJoinSwapGroupSGIX(cl, pc);
 }
 
-int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapDestroyContext(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -141,9 +154,11 @@ int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
     return __glXDestroyContext(cl, pc);
 }
 
-int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapMakeCurrent(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -154,9 +169,11 @@ int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
     return __glXMakeCurrent(cl, pc);
 }
 
-int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapMakeContextCurrent(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -168,9 +185,11 @@ int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
     return __glXMakeContextCurrent(cl, pc);
 }
 
-int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapMakeCurrentReadSGI(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -182,9 +201,11 @@ int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
     return __glXMakeCurrentReadSGI(cl, pc);
 }
 
-int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapIsDirect(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -193,9 +214,11 @@ int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
     return __glXIsDirect(cl, pc);
 }
 
-int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapQueryVersion(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -205,9 +228,11 @@ int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
     return __glXQueryVersion(cl, pc);
 }
 
-int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapWaitGL(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -216,9 +241,11 @@ int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
     return __glXWaitGL(cl, pc);
 }
 
-int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapWaitX(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -227,9 +254,11 @@ int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
     return __glXWaitX(cl, pc);
 }
 
-int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCopyContext(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -240,9 +269,10 @@ int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
     return __glXCopyContext(cl, pc);
 }
 
-int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapGetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
 {
-   ClientPtr client = cl->client;
+    ClientPtr client = cl->client;
     xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
     xGLXGetVisualConfigsReply reply;
     __GLXscreenInfo *pGlxScreen;
@@ -250,62 +280,63 @@ int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
     CARD32 buf[__GLX_TOTAL_CONFIG];
     unsigned int screen;
     int i, p;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
     screen = req->screen;
     if (screen >= screenInfo.numScreens) {
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
+        /* The client library must send a valid screen number. */
+        client->errorValue = screen;
+        return BadValue;
     }
     pGlxScreen = &__glXActiveScreens[screen];
 
     reply.numVisuals = pGlxScreen->numGLXVisuals;
     reply.numProps = __GLX_TOTAL_CONFIG;
     reply.length = (pGlxScreen->numGLXVisuals * __GLX_SIZE_CARD32 *
-		    __GLX_TOTAL_CONFIG) >> 2;
+                    __GLX_TOTAL_CONFIG) >> 2;
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
-    
+
     __GLX_SWAP_SHORT(&reply.sequenceNumber);
     __GLX_SWAP_INT(&reply.length);
     __GLX_SWAP_INT(&reply.numVisuals);
     __GLX_SWAP_INT(&reply.numProps);
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
-
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
-	if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
-	    /* not a usable visual */
-	    continue;
-	}
-	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
-
-	buf[p++] = pGlxVisual->redSize;
-	buf[p++] = pGlxVisual->greenSize;
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
+    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *) &reply);
+
+    for (i = 0; i < pGlxScreen->numVisuals; i++) {
+        pGlxVisual = &pGlxScreen->pGlxVisual[i];
+        if (!pGlxScreen->isGLXvis[i] || pGlxVisual->vid == 0) {
+            /* not a usable visual */
+            continue;
+        }
+        p = 0;
+        buf[p++] = pGlxVisual->vid;
+        buf[p++] = pGlxVisual->class;
+        buf[p++] = pGlxVisual->rgba;
+
+        buf[p++] = pGlxVisual->redSize;
+        buf[p++] = pGlxVisual->greenSize;
+        buf[p++] = pGlxVisual->blueSize;
+        buf[p++] = pGlxVisual->alphaSize;
+        buf[p++] = pGlxVisual->accumRedSize;
+        buf[p++] = pGlxVisual->accumGreenSize;
+        buf[p++] = pGlxVisual->accumBlueSize;
+        buf[p++] = pGlxVisual->accumAlphaSize;
+
+        buf[p++] = pGlxVisual->doubleBuffer;
+        buf[p++] = pGlxVisual->stereo;
+
+        buf[p++] = pGlxVisual->bufferSize;
+        buf[p++] = pGlxVisual->depthSize;
+        buf[p++] = pGlxVisual->stencilSize;
+        buf[p++] = pGlxVisual->auxBuffers;
+        buf[p++] = pGlxVisual->level;
         /*
-        ** Add token/value pairs for extensions.
-        */
+         ** Add token/value pairs for extensions.
+         */
         buf[p++] = GLX_VISUAL_CAVEAT_EXT;
         buf[p++] = pGlxVisual->visualRating;
         buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
@@ -321,16 +352,18 @@ int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
         buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
         buf[p++] = pGlxVisual->transparentIndex;
 
-	__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
-	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
-			(char *)buf);
+        __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
+        WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG,
+                      (char *) buf);
     }
     return Success;
 }
 
-int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreateGLXPixmap(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -342,9 +375,11 @@ int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     return __glXCreateGLXPixmap(cl, pc);
 }
 
-int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreatePixmap(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -357,9 +392,11 @@ int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
     return __glXCreatePixmap(cl, pc);
 }
 
-int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapDestroyGLXPixmap(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -368,9 +405,11 @@ int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     return __glXDestroyGLXPixmap(cl, pc);
 }
 
-int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapSwapBuffers(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -380,9 +419,11 @@ int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
     return __glXSwapBuffers(cl, pc);
 }
 
-int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapUseXFont(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -395,10 +436,11 @@ int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
     return __glXUseXFont(cl, pc);
 }
 
-
-int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapQueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXQueryExtensionsStringReq *req = NULL;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -407,9 +449,11 @@ int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
     return __glXQueryExtensionsString(cl, pc);
 }
 
-int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapQueryServerString(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
+    xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -419,9 +463,11 @@ int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
     return __glXQueryServerString(cl, pc);
 }
 
-int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapClientInfo(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
+    xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -432,15 +478,17 @@ int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
     return __glXClientInfo(cl, pc);
 }
 
-int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc)
+int
+__glXSwapQueryContextInfoEXT(__GLXclientState * cl, char *pc)
 {
     xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->context);
 
-    return __glXQueryContextInfoEXT(cl, (GLbyte *)pc);
+    return __glXQueryContextInfoEXT(cl, (GLbyte *) pc);
 }
 
 /************************************************************************/
@@ -449,7 +497,8 @@ int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc)
 ** Swap replies.
 */
 
-void __glXSwapMakeCurrentReply(ClientPtr client,  xGLXMakeCurrentReadSGIReply *reply)
+void
+__glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReadSGIReply * reply)
 {
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
@@ -459,103 +508,120 @@ void __glXSwapMakeCurrentReply(ClientPtr client,  xGLXMakeCurrentReadSGIReply *r
     __GLX_SWAP_INT(&reply->writeType);
     __GLX_SWAP_INT(&reply->readVid);
     __GLX_SWAP_INT(&reply->readType);
-    WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, (char *)reply);
+    WriteToClient(client, sz_xGLXMakeCurrentReadSGIReply, (char *) reply);
 }
 
-void __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply *reply)
+void
+__glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply)
 {
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
-    WriteToClient(client, sz_xGLXIsDirectReply, (char *)reply);
+    WriteToClient(client, sz_xGLXIsDirectReply, (char *) reply);
 }
 
-void __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply *reply)
+void
+__glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply * reply)
 {
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->majorVersion);
     __GLX_SWAP_INT(&reply->minorVersion);
-    WriteToClient(client, sz_xGLXQueryVersionReply, (char *)reply);
+    WriteToClient(client, sz_xGLXQueryVersionReply, (char *) reply);
 }
 
-void glxSwapQueryExtensionsStringReply(ClientPtr client,
-				       xGLXQueryExtensionsStringReply *reply, char *buf)
+void
+glxSwapQueryExtensionsStringReply(ClientPtr client,
+                                  xGLXQueryExtensionsStringReply * reply,
+                                  char *buf)
 {
     int length = reply->length;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
+    WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *) reply);
+    __GLX_SWAP_INT_ARRAY((int *) buf, length);
     WriteToClient(client, length << 2, buf);
 }
 
-void glxSwapQueryServerStringReply(ClientPtr client,
-				   xGLXQueryServerStringReply *reply, char *buf)
+void
+glxSwapQueryServerStringReply(ClientPtr client,
+                              xGLXQueryServerStringReply * reply, char *buf)
 {
     int length = reply->length;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *)reply);
+    WriteToClient(client, sz_xGLXQueryServerStringReply, (char *) reply);
     /** no swap is needed for an array of chars **/
     /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
     WriteToClient(client, length << 2, buf);
 }
 
-void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf)
+void
+__glXSwapQueryContextInfoEXTReply(ClientPtr client,
+                                  xGLXQueryContextInfoEXTReply * reply,
+                                  int *buf)
 {
     int length = reply->length;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
-    WriteToClient(client, length << 2, (char *)buf);
+    WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *) reply);
+    __GLX_SWAP_INT_ARRAY((int *) buf, length);
+    WriteToClient(client, length << 2, (char *) buf);
 }
 
-
-void __glXSwapQueryContextReply(ClientPtr client,
-                                xGLXQueryContextReply *reply, int *buf)
+void
+__glXSwapQueryContextReply(ClientPtr client,
+                           xGLXQueryContextReply * reply, int *buf)
 {
     int length = reply->length;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->n);
-    WriteToClient(client, sz_xGLXQueryContextReply, (char *)reply);
-    __GLX_SWAP_INT_ARRAY((int *)buf, length);
-    WriteToClient(client, length << 2, (char *)buf);
+    WriteToClient(client, sz_xGLXQueryContextReply, (char *) reply);
+    __GLX_SWAP_INT_ARRAY((int *) buf, length);
+    WriteToClient(client, length << 2, (char *) buf);
 }
 
-void __glXSwapGetDrawableAttributesReply(ClientPtr client,
-                                 xGLXGetDrawableAttributesReply *reply, int *buf) 
+void
+__glXSwapGetDrawableAttributesReply(ClientPtr client,
+                                    xGLXGetDrawableAttributesReply * reply,
+                                    int *buf)
 {
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->numAttribs);
-    __GLX_SWAP_INT_ARRAY( buf, reply->length );
-    WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)reply);
-    WriteToClient(client, reply->length << 2, (char *)buf);
+    __GLX_SWAP_INT_ARRAY(buf, reply->length);
+    WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *) reply);
+    WriteToClient(client, reply->length << 2, (char *) buf);
 }
 
-void __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client, xGLXQueryMaxSwapBarriersSGIXReply *reply)
+void
+__glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client,
+                                       xGLXQueryMaxSwapBarriersSGIXReply *
+                                       reply)
 {
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_SWAP_SHORT(&reply->sequenceNumber);
     __GLX_SWAP_INT(&reply->length);
     __GLX_SWAP_INT(&reply->max);
-    WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, (char *)reply);
+    WriteToClient(client, sz_xGLXQueryMaxSwapBarriersSGIXReply, (char *) reply);
 }
 
 /************************************************************************/
@@ -565,21 +631,23 @@ void __glXSwapQueryMaxSwapBarriersSGIXReply(ClientPtr client, xGLXQueryMaxSwapBa
 ** client library to send batches of GL rendering commands.
 */
 
-int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapRender(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXRenderReq *req;
     int left;
     __GLXrenderHeader *hdr;
     ClientPtr client = cl->client;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     /*
-    ** NOTE: much of this code also appears in the nonswapping version of this
-    ** routine, __glXRender().  Any changes made here should also be
-    ** duplicated there.
-    */
-    
+     ** NOTE: much of this code also appears in the nonswapping version of this
+     ** routine, __glXRender().  Any changes made here should also be
+     ** duplicated there.
+     */
+
     req = (xGLXRenderReq *) pc;
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->contextTag);
@@ -587,74 +655,81 @@ int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)
     pc += sz_xGLXRenderReq;
     left = (req->length << 2) - sz_xGLXRenderReq;
     while (left > 0) {
-	void (* proc)(GLbyte *);
-	CARD16 opcode;
-
-	/*
-	** Verify that the header length and the overall length agree.
-	** Also, each command must be word aligned.
-	*/
-	hdr = (__GLXrenderHeader *) pc;
-	__GLX_SWAP_SHORT(&hdr->length);
-	__GLX_SWAP_SHORT(&hdr->opcode);
-
-	/*
+        void (*proc) (GLbyte *);
+        CARD16 opcode;
+
+        /*
+         ** Verify that the header length and the overall length agree.
+         ** Also, each command must be word aligned.
+         */
+        hdr = (__GLXrenderHeader *) pc;
+        __GLX_SWAP_SHORT(&hdr->length);
+        __GLX_SWAP_SHORT(&hdr->opcode);
+
+        /*
          * call the command procedure to swap any arguments
-	 */
-	opcode = hdr->opcode;
-	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {
-	    proc = __glXSwapRenderTable[opcode];
+         */
+        opcode = hdr->opcode;
+        if ((opcode >= __GLX_MIN_RENDER_OPCODE) &&
+            (opcode <= __GLX_MAX_RENDER_OPCODE)) {
+            proc = __glXSwapRenderTable[opcode];
 #if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
-	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
-	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
-	    __GLXRenderSwapInfo *info = &__glXSwapRenderTable_EXT[index];
-	    if (info->swapfunc) {
-	       proc = info->swapfunc;
-	    }
-	    else {
-	       proc = NULL;
-	       if (info->elem_size == 4 && info->nelems > 0) {
-		  __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	       else if (info->elem_size == 2 && info->nelems > 0) {
-		  __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	       else if (info->elem_size == 8 && info->nelems > 0) {
-		  __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_HDR_SIZE), 
-			                info->nelems );
-	       }
-	    }
-#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
-	} else {
-	    client->errorValue = 0;
-	    return __glXBadRenderRequest;
-	}
-
-	if (proc != NULL) 
-	   (*proc)(pc + __GLX_RENDER_HDR_SIZE);
-
-	/*
-	 * proceed to the next command
-	 */ 
-	pc += hdr->length;
-	left -= hdr->length;
+        }
+        else if ((opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
+                 (opcode <= __GLX_MAX_RENDER_OPCODE_EXT)) {
+            int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
+            __GLXRenderSwapInfo *info = &__glXSwapRenderTable_EXT[index];
+
+            if (info->swapfunc) {
+                proc = info->swapfunc;
+            }
+            else {
+                proc = NULL;
+                if (info->elem_size == 4 && info->nelems > 0) {
+                    __GLX_SWAP_INT_ARRAY((int *) (pc + __GLX_RENDER_HDR_SIZE),
+                                         info->nelems);
+                }
+                else if (info->elem_size == 2 && info->nelems > 0) {
+                    __GLX_SWAP_SHORT_ARRAY((short *) (pc +
+                                                      __GLX_RENDER_HDR_SIZE),
+                                           info->nelems);
+                }
+                else if (info->elem_size == 8 && info->nelems > 0) {
+                    __GLX_SWAP_DOUBLE_ARRAY((double *) (pc +
+                                                        __GLX_RENDER_HDR_SIZE),
+                                            info->nelems);
+                }
+            }
+#endif                          /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
+        }
+        else {
+            client->errorValue = 0;
+            return __glXBadRenderRequest;
+        }
+
+        if (proc != NULL)
+            (*proc) (pc + __GLX_RENDER_HDR_SIZE);
+
+        /*
+         * proceed to the next command
+         */
+        pc += hdr->length;
+        left -= hdr->length;
     }
 
-    return __glXRender( cl, (GLbyte *)req );
+    return __glXRender(cl, (GLbyte *) req);
 }
 
 /*
 ** Execute a large rendering request (one that spans multiple X requests).
 */
-int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapRenderLarge(__GLXclientState * cl, GLbyte * pc)
 {
-   ClientPtr client = cl->client;
+    ClientPtr client = cl->client;
     xGLXRenderLargeReq *req;
     __GLXrenderLargeHeader *hdr;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
@@ -666,134 +741,139 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_SHORT(&req->requestTotal);
 
     pc += sz_xGLXRenderLargeReq;
-   
+
     if (req->requestNumber == 1) {
-	void (* proc)(GLbyte *) = NULL;
-	__GLXRenderSwapInfo *info = NULL;
-	CARD16 opcode;
+        void (*proc) (GLbyte *) = NULL;
+        __GLXRenderSwapInfo *info = NULL;
+        CARD16 opcode;
 
-	hdr = (__GLXrenderLargeHeader *) pc;
-	__GLX_SWAP_INT(&hdr->length);
-	__GLX_SWAP_INT(&hdr->opcode);
+        hdr = (__GLXrenderLargeHeader *) pc;
+        __GLX_SWAP_INT(&hdr->length);
+        __GLX_SWAP_INT(&hdr->opcode);
 
-	/*
+        /*
          * call the command procedure to swap any arguments
-	 * Note that we are assuming that all arguments that needs to be
-	 * swaped are on the first req only !
-	 */
-	opcode = hdr->opcode;
-	if ( (opcode >= __GLX_MIN_RENDER_OPCODE) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE) ) {
-	    proc = __glXSwapRenderTable[opcode];
+         * Note that we are assuming that all arguments that needs to be
+         * swaped are on the first req only !
+         */
+        opcode = hdr->opcode;
+        if ((opcode >= __GLX_MIN_RENDER_OPCODE) &&
+            (opcode <= __GLX_MAX_RENDER_OPCODE)) {
+            proc = __glXSwapRenderTable[opcode];
 #if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
-	} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) && 
-	     (opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
-	    int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
-	    info = &__glXSwapRenderTable_EXT[index];
-	    if (info->swapfunc) {
-	       proc = info->swapfunc;
-	    }
-#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
-	} else {
-	    client->errorValue = 0;
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-	}
-
-	/*
-	** Make enough space in the buffer, then copy the entire request.
-	*/
-	if (cl->largeCmdBufSize < hdr->length) {
-	    if (!cl->largeCmdBuf) {
-		cl->largeCmdBuf = (GLbyte *) malloc(hdr->length);
-	    } else {
-		cl->largeCmdBuf = (GLbyte *) realloc(cl->largeCmdBuf, hdr->length);
-	    }
-	    if (!cl->largeCmdBuf) {
-	       cl->largeCmdRequestsTotal = 0;
-		return BadAlloc;
-	    }
-	    cl->largeCmdBufSize = hdr->length;
-	}
-	memcpy(cl->largeCmdBuf, pc, req->dataBytes);
-
-	cl->largeCmdBytesSoFar = req->dataBytes;
-	cl->largeCmdBytesTotal = hdr->length;
-	cl->largeCmdRequestsSoFar = 1;
-	cl->largeCmdRequestsTotal = req->requestTotal;
-	cl->largeCmdRequestsSwapProc = proc;
-	cl->largeCmdMaxReqDataSize = req->dataBytes;
-	cl->largeCmdRequestsSwap_info = info;
-
-	return Success;
-	
+        }
+        else if ((opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
+                 (opcode <= __GLX_MAX_RENDER_OPCODE_EXT)) {
+            int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
+
+            info = &__glXSwapRenderTable_EXT[index];
+            if (info->swapfunc) {
+                proc = info->swapfunc;
+            }
+#endif                          /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
+        }
+        else {
+            client->errorValue = 0;
+            cl->largeCmdRequestsTotal = 0;
+            return __glXBadLargeRequest;
+        }
+
+        /*
+         ** Make enough space in the buffer, then copy the entire request.
+         */
+        if (cl->largeCmdBufSize < hdr->length) {
+            if (!cl->largeCmdBuf) {
+                cl->largeCmdBuf = (GLbyte *) malloc(hdr->length);
+            }
+            else {
+                cl->largeCmdBuf =
+                    (GLbyte *) realloc(cl->largeCmdBuf, hdr->length);
+            }
+            if (!cl->largeCmdBuf) {
+                cl->largeCmdRequestsTotal = 0;
+                return BadAlloc;
+            }
+            cl->largeCmdBufSize = hdr->length;
+        }
+        memcpy(cl->largeCmdBuf, pc, req->dataBytes);
+
+        cl->largeCmdBytesSoFar = req->dataBytes;
+        cl->largeCmdBytesTotal = hdr->length;
+        cl->largeCmdRequestsSoFar = 1;
+        cl->largeCmdRequestsTotal = req->requestTotal;
+        cl->largeCmdRequestsSwapProc = proc;
+        cl->largeCmdMaxReqDataSize = req->dataBytes;
+        cl->largeCmdRequestsSwap_info = info;
+
+        return Success;
 
     }
     else if (req->requestNumber < cl->largeCmdRequestsTotal) {
-       /*
-        * This is not the first nor last request - just copy the data
-	*/
-       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-       }
+        /*
+         * This is not the first nor last request - just copy the data
+         */
+        if (cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
+            cl->largeCmdRequestsTotal = 0;
+            return __glXBadLargeRequest;
+        }
 
-       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 
-	           pc, req->dataBytes);
+        memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, req->dataBytes);
 
-       cl->largeCmdBytesSoFar += req->dataBytes;
+        cl->largeCmdBytesSoFar += req->dataBytes;
 
-       if (req->dataBytes > cl->largeCmdMaxReqDataSize)
-	  cl->largeCmdMaxReqDataSize = req->dataBytes;
+        if (req->dataBytes > cl->largeCmdMaxReqDataSize)
+            cl->largeCmdMaxReqDataSize = req->dataBytes;
 
-	return Success;
+        return Success;
     }
     else if (req->requestNumber == cl->largeCmdRequestsTotal) {
-       /*
-        * this is the last request
-        * copy the remainder bytes, call the procedure to swap any
-	* needed data, and then call to transfer the command to all
-	* back-end servers
-	*/
-       if (  cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
-	    cl->largeCmdRequestsTotal = 0;
-	    return __glXBadLargeRequest;
-       }
-
-       memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, 
-	           pc, req->dataBytes);
-
-       cl->largeCmdBytesSoFar += req->dataBytes;
-
-       if (req->dataBytes > cl->largeCmdMaxReqDataSize)
-	  cl->largeCmdMaxReqDataSize = req->dataBytes;
-
-	if (cl->largeCmdRequestsSwapProc != NULL) {
-	   (*cl->largeCmdRequestsSwapProc)(cl->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);
-	}
-	else if (cl->largeCmdRequestsSwap_info &&
-	         cl->largeCmdRequestsSwap_info->nelems > 0) {
-    	   if (cl->largeCmdRequestsSwap_info->elem_size == 4) {
-	      __GLX_SWAP_INT_ARRAY( (int *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	   else if (cl->largeCmdRequestsSwap_info->elem_size == 2) {
-	      __GLX_SWAP_SHORT_ARRAY( (short *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	   else if (cl->largeCmdRequestsSwap_info->elem_size == 8) {
-	      __GLX_SWAP_DOUBLE_ARRAY( (double *)(pc + __GLX_RENDER_LARGE_HDR_SIZE), 
-		       cl->largeCmdRequestsSwap_info->nelems );
-	   }
-	}
-
-	cl->largeCmdRequestsTotal = 0;
-        return( __glXSendLargeCommand(cl, req->contextTag) );
+        /*
+         * this is the last request
+         * copy the remainder bytes, call the procedure to swap any
+         * needed data, and then call to transfer the command to all
+         * back-end servers
+         */
+        if (cl->largeCmdBytesSoFar + req->dataBytes > cl->largeCmdBytesTotal) {
+            cl->largeCmdRequestsTotal = 0;
+            return __glXBadLargeRequest;
+        }
+
+        memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, req->dataBytes);
+
+        cl->largeCmdBytesSoFar += req->dataBytes;
+
+        if (req->dataBytes > cl->largeCmdMaxReqDataSize)
+            cl->largeCmdMaxReqDataSize = req->dataBytes;
+
+        if (cl->largeCmdRequestsSwapProc != NULL) {
+            (*cl->largeCmdRequestsSwapProc) (cl->largeCmdBuf +
+                                             __GLX_RENDER_LARGE_HDR_SIZE);
+        }
+        else if (cl->largeCmdRequestsSwap_info &&
+                 cl->largeCmdRequestsSwap_info->nelems > 0) {
+            if (cl->largeCmdRequestsSwap_info->elem_size == 4) {
+                __GLX_SWAP_INT_ARRAY((int *) (pc + __GLX_RENDER_LARGE_HDR_SIZE),
+                                     cl->largeCmdRequestsSwap_info->nelems);
+            }
+            else if (cl->largeCmdRequestsSwap_info->elem_size == 2) {
+                __GLX_SWAP_SHORT_ARRAY((short *) (pc +
+                                                  __GLX_RENDER_LARGE_HDR_SIZE),
+                                       cl->largeCmdRequestsSwap_info->nelems);
+            }
+            else if (cl->largeCmdRequestsSwap_info->elem_size == 8) {
+                __GLX_SWAP_DOUBLE_ARRAY((double *) (pc +
+                                                    __GLX_RENDER_LARGE_HDR_SIZE),
+                                        cl->largeCmdRequestsSwap_info->nelems);
+            }
+        }
+
+        cl->largeCmdRequestsTotal = 0;
+        return (__glXSendLargeCommand(cl, req->contextTag));
 
     }
     else {
-       cl->largeCmdRequestsTotal = 0;
-       return __glXBadLargeRequest;
+        cl->largeCmdRequestsTotal = 0;
+        return __glXBadLargeRequest;
     }
 
 }
@@ -805,7 +885,8 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
 ** allocating these entry points in the dispatch table.
 */
 
-int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapVendorPrivate(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXVendorPrivateReq *req;
     CARD32 vendorCode;
@@ -816,58 +897,58 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
     vendorCode = req->vendorCode;
     __GLX_SWAP_INT(&vendorCode);
 
-
-    switch( vendorCode ) {
-
-       case X_GLvop_DeleteTexturesEXT:
-	  return __glXVForwardSingleReqSwap( cl, pc );
-	  break;
-
-       case X_GLXvop_SwapIntervalSGI:
-	  if (glxIsExtensionSupported("SGI_swap_control")) {
-	     return __glXVForwardSingleReqSwap( cl, pc );
-	  }
-	  else {
-	     return Success;
-	  }
-	  break;
-
-#if 0 /* glx 1.3 */
-       case X_GLXvop_CreateGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXVideoSourceSGIX:
-	  break;
-       case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
-	  break;
-       case X_GLXvop_DestroyGLXPbufferSGIX:
-	  break;
-       case X_GLXvop_ChangeDrawableAttributesSGIX:
-	  break;
+    switch (vendorCode) {
+
+    case X_GLvop_DeleteTexturesEXT:
+        return __glXVForwardSingleReqSwap(cl, pc);
+        break;
+
+    case X_GLXvop_SwapIntervalSGI:
+        if (glxIsExtensionSupported("SGI_swap_control")) {
+            return __glXVForwardSingleReqSwap(cl, pc);
+        }
+        else {
+            return Success;
+        }
+        break;
+
+#if 0                           /* glx 1.3 */
+    case X_GLXvop_CreateGLXVideoSourceSGIX:
+        break;
+    case X_GLXvop_DestroyGLXVideoSourceSGIX:
+        break;
+    case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+        break;
+    case X_GLXvop_DestroyGLXPbufferSGIX:
+        break;
+    case X_GLXvop_ChangeDrawableAttributesSGIX:
+        break;
 #endif
 
-       case X_GLXvop_JoinSwapGroupSGIX:
-	  return __glXSwapJoinSwapGroupSGIX( cl, pc );
-	  break;
+    case X_GLXvop_JoinSwapGroupSGIX:
+        return __glXSwapJoinSwapGroupSGIX(cl, pc);
+        break;
 
-       case X_GLXvop_BindSwapBarrierSGIX:
-	  return __glXSwapBindSwapBarrierSGIX( cl, pc );
-	  break;
+    case X_GLXvop_BindSwapBarrierSGIX:
+        return __glXSwapBindSwapBarrierSGIX(cl, pc);
+        break;
 
-       case X_GLXvop_CreateContextWithConfigSGIX:
-	  return __glXSwapCreateContextWithConfigSGIX( cl, pc );
-	  break;
+    case X_GLXvop_CreateContextWithConfigSGIX:
+        return __glXSwapCreateContextWithConfigSGIX(cl, pc);
+        break;
 
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
+    default:
+        /*
+         ** unsupported private request
+         */
+        cl->client->errorValue = req->vendorCode;
+        return __glXUnsupportedPrivateRequest;
     }
 
 }
 
-int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapVendorPrivateWithReply(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXVendorPrivateWithReplyReq *req;
     CARD32 vendorCode;
@@ -878,76 +959,78 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
     vendorCode = req->vendorCode;
     __GLX_SWAP_INT(&vendorCode);
 
-    switch( vendorCode ) {
-
-       case X_GLvop_GetConvolutionFilterEXT:
-       case X_GLvop_GetSeparableFilterEXT:
-       case X_GLvop_GetHistogramEXT:
-       case X_GLvop_GetMinmaxEXT:
-	  return( __glXNoSuchSingleOpcode(cl, pc) );
-	  break;
-
-       case X_GLvop_GetConvolutionParameterfvEXT:
-       case X_GLvop_GetConvolutionParameterivEXT:
-       case X_GLvop_GetHistogramParameterivEXT:
-       case X_GLvop_GetMinmaxParameterfvEXT:
-       case X_GLvop_GetMinmaxParameterivEXT:
-       case X_GLvop_GenTexturesEXT:
-	  return( __glXVForwardAllWithReplySwapiv(cl, pc) );
-	  break;
-
-       case X_GLvop_AreTexturesResidentEXT:
-       case X_GLvop_IsTextureEXT:
-	  return( __glXVForwardPipe0WithReplySwap(cl, pc) );
-	  break;
-
-#if 0 /* glx1.3 */
-       case X_GLvop_GetDetailTexFuncSGIS:
-       case X_GLvop_GetSharpenTexFuncSGIS:
-       case X_GLvop_GetColorTableSGI:
-       case X_GLvop_GetColorTableParameterfvSGI:
-       case X_GLvop_GetColorTableParameterivSGI:
-       case X_GLvop_GetTexFilterFuncSGIS:
-       case X_GLvop_GetInstrumentsSGIX:
-       case X_GLvop_InstrumentsBufferSGIX:
-       case X_GLvop_PollInstrumentsSGIX:
-       case X_GLvop_FlushRasterSGIX:
-       case X_GLXvop_CreateGLXPbufferSGIX:
-       case X_GLXvop_GetDrawableAttributesSGIX:
-       case X_GLXvop_QueryHyperpipeNetworkSGIX:
-       case X_GLXvop_QueryHyperpipeConfigSGIX:
-       case X_GLXvop_HyperpipeConfigSGIX:
-       case X_GLXvop_DestroyHyperpipeConfigSGIX:
+    switch (vendorCode) {
+
+    case X_GLvop_GetConvolutionFilterEXT:
+    case X_GLvop_GetSeparableFilterEXT:
+    case X_GLvop_GetHistogramEXT:
+    case X_GLvop_GetMinmaxEXT:
+        return (__glXNoSuchSingleOpcode(cl, pc));
+        break;
+
+    case X_GLvop_GetConvolutionParameterfvEXT:
+    case X_GLvop_GetConvolutionParameterivEXT:
+    case X_GLvop_GetHistogramParameterivEXT:
+    case X_GLvop_GetMinmaxParameterfvEXT:
+    case X_GLvop_GetMinmaxParameterivEXT:
+    case X_GLvop_GenTexturesEXT:
+        return (__glXVForwardAllWithReplySwapiv(cl, pc));
+        break;
+
+    case X_GLvop_AreTexturesResidentEXT:
+    case X_GLvop_IsTextureEXT:
+        return (__glXVForwardPipe0WithReplySwap(cl, pc));
+        break;
+
+#if 0                           /* glx1.3 */
+    case X_GLvop_GetDetailTexFuncSGIS:
+    case X_GLvop_GetSharpenTexFuncSGIS:
+    case X_GLvop_GetColorTableSGI:
+    case X_GLvop_GetColorTableParameterfvSGI:
+    case X_GLvop_GetColorTableParameterivSGI:
+    case X_GLvop_GetTexFilterFuncSGIS:
+    case X_GLvop_GetInstrumentsSGIX:
+    case X_GLvop_InstrumentsBufferSGIX:
+    case X_GLvop_PollInstrumentsSGIX:
+    case X_GLvop_FlushRasterSGIX:
+    case X_GLXvop_CreateGLXPbufferSGIX:
+    case X_GLXvop_GetDrawableAttributesSGIX:
+    case X_GLXvop_QueryHyperpipeNetworkSGIX:
+    case X_GLXvop_QueryHyperpipeConfigSGIX:
+    case X_GLXvop_HyperpipeConfigSGIX:
+    case X_GLXvop_DestroyHyperpipeConfigSGIX:
 #endif
-       case X_GLXvop_QueryMaxSwapBarriersSGIX:
-	  return( __glXSwapQueryMaxSwapBarriersSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_GetFBConfigsSGIX:
-	  return( __glXSwapGetFBConfigsSGIX(cl, pc) );
-	  break;
-
-       case X_GLXvop_MakeCurrentReadSGI:
-	  return( __glXSwapMakeCurrentReadSGI(cl, pc) );
-	  break;
-
-       case X_GLXvop_QueryContextInfoEXT:
-	  return( __glXSwapQueryContextInfoEXT(cl,(char *)pc) );
-	  break;
-
-       default:
-	  /*
-	   ** unsupported private request
-	   */
-	  cl->client->errorValue = req->vendorCode;
-	  return __glXUnsupportedPrivateRequest;
+    case X_GLXvop_QueryMaxSwapBarriersSGIX:
+        return (__glXSwapQueryMaxSwapBarriersSGIX(cl, pc));
+        break;
+
+    case X_GLXvop_GetFBConfigsSGIX:
+        return (__glXSwapGetFBConfigsSGIX(cl, pc));
+        break;
+
+    case X_GLXvop_MakeCurrentReadSGI:
+        return (__glXSwapMakeCurrentReadSGI(cl, pc));
+        break;
+
+    case X_GLXvop_QueryContextInfoEXT:
+        return (__glXSwapQueryContextInfoEXT(cl, (char *) pc));
+        break;
+
+    default:
+        /*
+         ** unsupported private request
+         */
+        cl->client->errorValue = req->vendorCode;
+        return __glXUnsupportedPrivateRequest;
     }
 
 }
 
-int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapGetFBConfigs(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -956,22 +1039,25 @@ int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
     return __glXGetFBConfigs(cl, pc);
 }
 
-int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapGetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
 {
-   xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)pc;
-   xGLXGetFBConfigsReq new_req;
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
+    xGLXGetFBConfigsReq new_req;
 
-   new_req.reqType = req->reqType;
-   new_req.glxCode = req->glxCode;
-   new_req.length = req->length;
-   new_req.screen = req->screen;
+    new_req.reqType = req->reqType;
+    new_req.glxCode = req->glxCode;
+    new_req.length = req->length;
+    new_req.screen = req->screen;
 
-   return( __glXSwapGetFBConfigs( cl, (GLbyte *)&new_req ) );
+    return (__glXSwapGetFBConfigs(cl, (GLbyte *) & new_req));
 }
 
-int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreateWindow(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
@@ -981,37 +1067,42 @@ int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->glxwindow);
     __GLX_SWAP_INT(&req->numAttribs);
 
-    return( __glXCreateWindow( cl, (GLbyte *)pc ) );
+    return (__glXCreateWindow(cl, (GLbyte *) pc));
 }
 
-int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapDestroyWindow(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->glxwindow);
 
-    return( __glXDestroyWindow( cl, (GLbyte *)pc ) );
+    return (__glXDestroyWindow(cl, (GLbyte *) pc));
 }
 
-int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapQueryContext(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXQueryContextReq *req = (xGLXQueryContextReq *)pc;
+    xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
 
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->context);
 
-    return( __glXQueryContext(cl, (GLbyte *)pc) );
- 
+    return (__glXQueryContext(cl, (GLbyte *) pc));
+
 }
 
-int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapCreatePbuffer(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *)pc;
+    xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
     int nattr = req->numAttribs;
+
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
@@ -1020,43 +1111,49 @@ int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->fbconfig);
     __GLX_SWAP_INT(&req->pbuffer);
     __GLX_SWAP_INT(&req->numAttribs);
-    __GLX_SWAP_INT_ARRAY( (int *)(req+1), nattr*2 );
+    __GLX_SWAP_INT_ARRAY((int *) (req + 1), nattr * 2);
 
-    return( __glXCreatePbuffer( cl, pc ) );
+    return (__glXCreatePbuffer(cl, pc));
 }
 
-int __glXSwapDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapDestroyPbuffer(__GLXclientState * cl, GLbyte * pc)
 {
     xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->pbuffer);
 
-    return( __glXDestroyPbuffer( cl, (GLbyte *)pc ) );
+    return (__glXDestroyPbuffer(cl, (GLbyte *) pc));
 }
 
-int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapGetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
 {
-   xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
+    xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *) pc;
+
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->drawable);
 
-    return( __glXGetDrawableAttributes(cl, pc) );
+    return (__glXGetDrawableAttributes(cl, pc));
 }
 
-int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
+int
+__glXSwapChangeDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
 {
-   xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *)pc;
+    xGLXChangeDrawableAttributesReq *req =
+        (xGLXChangeDrawableAttributesReq *) pc;
     __GLX_DECLARE_SWAP_VARIABLES;
     __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->drawable);
     __GLX_SWAP_INT(&req->numAttribs);
-    __GLX_SWAP_INT_ARRAY( (int *)(req+1), req->numAttribs * 2 );
+    __GLX_SWAP_INT_ARRAY((int *) (req + 1), req->numAttribs * 2);
 
-    return( __glXChangeDrawableAttributes(cl, pc) );
+    return (__glXChangeDrawableAttributes(cl, pc));
 }