Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

1 files changed, 218 insertions, 230 deletions

diff --git a/glx/glxdri2.c b/glx/glxdri2.c
index 5e524db99..aa38295fa 100644
--- a/glx/glxdri2.c
+++ b/glx/glxdri2.c
@@ -54,18 +54,18 @@
 #include "dispatch.h"
 #include "extension_string.h"
 
-typedef struct __GLXDRIscreen   __GLXDRIscreen;
-typedef struct __GLXDRIcontext  __GLXDRIcontext;
+typedef struct __GLXDRIscreen __GLXDRIscreen;
+typedef struct __GLXDRIcontext __GLXDRIcontext;
 typedef struct __GLXDRIdrawable __GLXDRIdrawable;
 
 struct __GLXDRIscreen {
-    __GLXscreen		 base;
-    __DRIscreen		*driScreen;
-    void		*driver;
-    int			 fd;
+    __GLXscreen base;
+    __DRIscreen *driScreen;
+    void *driver;
+    int fd;
 
-    xf86EnterVTProc	*enterVT;
-    xf86LeaveVTProc	*leaveVT;
+    xf86EnterVTProc *enterVT;
+    xf86LeaveVTProc *leaveVT;
 
     const __DRIcoreExtension *core;
     const __DRIdri2Extension *dri2;
@@ -79,16 +79,16 @@ struct __GLXDRIscreen {
 };
 
 struct __GLXDRIcontext {
-    __GLXcontext	 base;
-    __DRIcontext	*driContext;
+    __GLXcontext base;
+    __DRIcontext *driContext;
 };
 
 #define MAX_DRAWABLE_BUFFERS 5
 
 struct __GLXDRIdrawable {
-    __GLXdrawable	 base;
-    __DRIdrawable	*driDrawable;
-    __GLXDRIscreen	*screen;
+    __GLXdrawable base;
+    __DRIdrawable *driDrawable;
+    __GLXDRIscreen *screen;
 
     /* Dimensions as last reported by DRI2GetBuffers. */
     int width;
@@ -98,12 +98,12 @@ struct __GLXDRIdrawable {
 };
 
 static void
-__glXDRIdrawableDestroy(__GLXdrawable *drawable)
+__glXDRIdrawableDestroy(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     const __DRIcoreExtension *core = private->screen->core;
-    
-    (*core->destroyDrawable)(private->driDrawable);
+
+    (*core->destroyDrawable) (private->driDrawable);
 
     __glXDrawableRelease(drawable);
 
@@ -111,8 +111,8 @@ __glXDRIdrawableDestroy(__GLXdrawable *drawable)
 }
 
 static void
-__glXDRIdrawableCopySubBuffer(__GLXdrawable *drawable,
-			       int x, int y, int w, int h)
+__glXDRIdrawableCopySubBuffer(__GLXdrawable * drawable,
+                              int x, int y, int w, int h)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -125,11 +125,11 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *drawable,
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFrontLeft, DRI2BufferBackLeft);
+                   DRI2BufferFrontLeft, DRI2BufferBackLeft);
 }
 
 static void
-__glXDRIdrawableWaitX(__GLXdrawable *drawable)
+__glXDRIdrawableWaitX(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -142,11 +142,11 @@ __glXDRIdrawableWaitX(__GLXdrawable *drawable)
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
+                   DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
 }
 
 static void
-__glXDRIdrawableWaitGL(__GLXdrawable *drawable)
+__glXDRIdrawableWaitGL(__GLXdrawable * drawable)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
     BoxRec box;
@@ -159,34 +159,34 @@ __glXDRIdrawableWaitGL(__GLXdrawable *drawable)
     RegionInit(&region, &box, 0);
 
     DRI2CopyRegion(drawable->pDraw, &region,
-		   DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
+                   DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
 }
 
 static void
 __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
-		  CARD64 msc, CARD32 sbc)
+                  CARD64 msc, CARD32 sbc)
 {
     __GLXdrawable *drawable = data;
     xGLXBufferSwapComplete2 wire;
 
     if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
-	return;
+        return;
 
     wire.type = __glXEventBase + GLX_BufferSwapComplete;
     switch (type) {
     case DRI2_EXCHANGE_COMPLETE:
-	wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
+        break;
     case DRI2_BLIT_COMPLETE:
-	wire.event_type = GLX_BLIT_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_BLIT_COMPLETE_INTEL;
+        break;
     case DRI2_FLIP_COMPLETE:
-	wire.event_type = GLX_FLIP_COMPLETE_INTEL;
-	break;
+        wire.event_type = GLX_FLIP_COMPLETE_INTEL;
+        break;
     default:
-	/* unknown swap completion type */
-	wire.event_type = 0;
-	break;
+        /* unknown swap completion type */
+        wire.event_type = 0;
+        break;
     }
     wire.drawable = drawable->drawId;
     wire.ust_hi = ust >> 32;
@@ -205,7 +205,7 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
  * swap should happen, then perform the copy when we receive it.
  */
 static GLboolean
-__glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable *drawable)
+__glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable * drawable)
 {
     __GLXDRIdrawable *priv = (__GLXDRIdrawable *) drawable;
     __GLXDRIscreen *screen = priv->screen;
@@ -213,26 +213,26 @@ __glXDRIdrawableSwapBuffers(ClientPtr client, __GLXdrawable *drawable)
 
 #if __DRI2_FLUSH_VERSION >= 3
     if (screen->flush) {
-	(*screen->flush->flush)(priv->driDrawable);
-	(*screen->flush->invalidate)(priv->driDrawable);
+        (*screen->flush->flush) (priv->driDrawable);
+        (*screen->flush->invalidate) (priv->driDrawable);
     }
 #else
     if (screen->flush)
-	(*screen->flush->flushInvalidate)(priv->driDrawable);
+        (*screen->flush->flushInvalidate) (priv->driDrawable);
 #endif
 
     if (DRI2SwapBuffers(client, drawable->pDraw, 0, 0, 0, &unused,
-			__glXdriSwapEvent, drawable) != Success)
-	return FALSE;
+                        __glXdriSwapEvent, drawable) != Success)
+        return FALSE;
 
     return TRUE;
 }
 
 static int
-__glXDRIdrawableSwapInterval(__GLXdrawable *drawable, int interval)
+__glXDRIdrawableSwapInterval(__GLXdrawable * drawable, int interval)
 {
-    if (interval <= 0) /* || interval > BIGNUM? */
-	return GLX_BAD_VALUE;
+    if (interval <= 0)          /* || interval > BIGNUM? */
+        return GLX_BAD_VALUE;
 
     DRI2SwapInterval(drawable->pDraw, interval);
 
@@ -240,57 +240,56 @@ __glXDRIdrawableSwapInterval(__GLXdrawable *drawable, int interval)
 }
 
 static void
-__glXDRIcontextDestroy(__GLXcontext *baseContext)
+__glXDRIcontextDestroy(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    (*screen->core->destroyContext)(context->driContext);
+    (*screen->core->destroyContext) (context->driContext);
     __glXContextDestroy(&context->base);
     free(context);
 }
 
 static int
-__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
+__glXDRIcontextMakeCurrent(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
     __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    return (*screen->core->bindContext)(context->driContext,
-					draw->driDrawable,
-					read->driDrawable);
-}					      
+    return (*screen->core->bindContext) (context->driContext,
+                                         draw->driDrawable, read->driDrawable);
+}
 
 static int
-__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
+__glXDRIcontextLoseCurrent(__GLXcontext * baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) context->base.pGlxScreen;
 
-    return (*screen->core->unbindContext)(context->driContext);
+    return (*screen->core->unbindContext) (context->driContext);
 }
 
 static int
-__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc,
-		    unsigned long mask)
+__glXDRIcontextCopy(__GLXcontext * baseDst, __GLXcontext * baseSrc,
+                    unsigned long mask)
 {
     __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst;
     __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc;
     __GLXDRIscreen *screen = (__GLXDRIscreen *) dst->base.pGlxScreen;
 
-    return (*screen->core->copyContext)(dst->driContext,
-					src->driContext, mask);
+    return (*screen->core->copyContext) (dst->driContext,
+                                         src->driContext, mask);
 }
 
 static Bool
-__glXDRIcontextWait(__GLXcontext *baseContext,
-		    __GLXclientState *cl, int *error)
+__glXDRIcontextWait(__GLXcontext * baseContext,
+                    __GLXclientState * cl, int *error)
 {
     if (DRI2WaitSwap(cl->client, baseContext->drawPriv->pDraw)) {
-	*error = cl->client->noClientException;
-	return TRUE;
+        *error = cl->client->noClientException;
+        return TRUE;
     }
 
     return FALSE;
@@ -299,9 +298,8 @@ __glXDRIcontextWait(__GLXcontext *baseContext,
 #ifdef __DRI_TEX_BUFFER
 
 static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
+__glXDRIbindTexImage(__GLXcontext * baseContext,
+                     int buffer, __GLXdrawable * glxPixmap)
 {
     __GLXDRIdrawable *drawable = (__GLXDRIdrawable *) glxPixmap;
     const __DRItexBufferExtension *texBuffer = drawable->screen->texBuffer;
@@ -312,25 +310,23 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
 
 #if __DRI_TEX_BUFFER_VERSION >= 2
     if (texBuffer->base.version >= 2 && texBuffer->setTexBuffer2 != NULL) {
-	(*texBuffer->setTexBuffer2)(context->driContext,
-				    glxPixmap->target,
-				    glxPixmap->format,
-				    drawable->driDrawable);
-    } else
+        (*texBuffer->setTexBuffer2) (context->driContext,
+                                     glxPixmap->target,
+                                     glxPixmap->format, drawable->driDrawable);
+    }
+    else
 #endif
     {
-	texBuffer->setTexBuffer(context->driContext,
-				glxPixmap->target,
-				drawable->driDrawable);
+        texBuffer->setTexBuffer(context->driContext,
+                                glxPixmap->target, drawable->driDrawable);
     }
 
     return Success;
 }
 
 static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
+__glXDRIreleaseTexImage(__GLXcontext * baseContext,
+                        int buffer, __GLXdrawable * pixmap)
 {
     /* FIXME: Just unbind the texture? */
     return Success;
@@ -339,17 +335,15 @@ __glXDRIreleaseTexImage(__GLXcontext *baseContext,
 #else
 
 static int
-__glXDRIbindTexImage(__GLXcontext *baseContext,
-		     int buffer,
-		     __GLXdrawable *glxPixmap)
+__glXDRIbindTexImage(__GLXcontext * baseContext,
+                     int buffer, __GLXdrawable * glxPixmap)
 {
     return Success;
 }
 
 static int
-__glXDRIreleaseTexImage(__GLXcontext *baseContext,
-			int buffer,
-			__GLXdrawable *pixmap)
+__glXDRIreleaseTexImage(__GLXcontext * baseContext,
+                        int buffer, __GLXdrawable * pixmap)
 {
     return Success;
 }
@@ -362,31 +356,31 @@ static __GLXtextureFromPixmap __glXDRItextureFromPixmap = {
 };
 
 static void
-__glXDRIscreenDestroy(__GLXscreen *baseScreen)
+__glXDRIscreenDestroy(__GLXscreen * baseScreen)
 {
     int i;
 
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
 
-    (*screen->core->destroyScreen)(screen->driScreen);
+    (*screen->core->destroyScreen) (screen->driScreen);
 
     dlclose(screen->driver);
 
     __glXScreenDestroy(baseScreen);
 
     if (screen->driConfigs) {
-	for (i = 0; screen->driConfigs[i] != NULL; i++)
-	    free((__DRIconfig **)screen->driConfigs[i]);
-	free(screen->driConfigs);
+        for (i = 0; screen->driConfigs[i] != NULL; i++)
+            free((__DRIconfig **) screen->driConfigs[i]);
+        free(screen->driConfigs);
     }
 
     free(screen);
 }
 
 static __GLXcontext *
-__glXDRIscreenCreateContext(__GLXscreen *baseScreen,
-			    __GLXconfig *glxConfig,
-			    __GLXcontext *baseShareContext)
+__glXDRIscreenCreateContext(__GLXscreen * baseScreen,
+                            __GLXconfig * glxConfig,
+                            __GLXcontext * baseShareContext)
 {
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
     __GLXDRIcontext *context, *shareContext;
@@ -395,27 +389,27 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
 
     shareContext = (__GLXDRIcontext *) baseShareContext;
     if (shareContext)
-	driShare = shareContext->driContext;
+        driShare = shareContext->driContext;
     else
-	driShare = NULL;
+        driShare = NULL;
 
     context = calloc(1, sizeof *context);
     if (context == NULL)
-	return NULL;
+        return NULL;
 
-    context->base.destroy           = __glXDRIcontextDestroy;
-    context->base.makeCurrent       = __glXDRIcontextMakeCurrent;
-    context->base.loseCurrent       = __glXDRIcontextLoseCurrent;
-    context->base.copy              = __glXDRIcontextCopy;
+    context->base.destroy = __glXDRIcontextDestroy;
+    context->base.makeCurrent = __glXDRIcontextMakeCurrent;
+    context->base.loseCurrent = __glXDRIcontextLoseCurrent;
+    context->base.copy = __glXDRIcontextCopy;
     context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
-    context->base.wait              = __glXDRIcontextWait;
+    context->base.wait = __glXDRIcontextWait;
 
     context->driContext =
-	(*screen->dri2->createNewContext)(screen->driScreen,
-					  config->driConfig,
-					  driShare, context);
+        (*screen->dri2->createNewContext) (screen->driScreen,
+                                           config->driConfig,
+                                           driShare, context);
     if (context->driContext == NULL) {
-	    free(context);
+        free(context);
         return NULL;
     }
 
@@ -430,18 +424,16 @@ __glXDRIinvalidateBuffers(DrawablePtr pDraw, void *priv, XID id)
     __GLXDRIscreen *screen = private->screen;
 
     if (screen->flush)
-	(*screen->flush->invalidate)(private->driDrawable);
+        (*screen->flush->invalidate) (private->driDrawable);
 #endif
 }
 
 static __GLXdrawable *
 __glXDRIscreenCreateDrawable(ClientPtr client,
-			     __GLXscreen *screen,
-			     DrawablePtr pDraw,
-			     XID drawId,
-			     int type,
-			     XID glxDrawId,
-			     __GLXconfig *glxConfig)
+                             __GLXscreen * screen,
+                             DrawablePtr pDraw,
+                             XID drawId,
+                             int type, XID glxDrawId, __GLXconfig * glxConfig)
 {
     __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
     __GLXDRIconfig *config = (__GLXDRIconfig *) glxConfig;
@@ -449,39 +441,39 @@ __glXDRIscreenCreateDrawable(ClientPtr client,
 
     private = calloc(1, sizeof *private);
     if (private == NULL)
-	return NULL;
+        return NULL;
 
     private->screen = driScreen;
     if (!__glXDrawableInit(&private->base, screen,
-			   pDraw, type, glxDrawId, glxConfig)) {
+                           pDraw, type, glxDrawId, glxConfig)) {
         free(private);
-	return NULL;
+        return NULL;
     }
 
-    private->base.destroy       = __glXDRIdrawableDestroy;
-    private->base.swapBuffers   = __glXDRIdrawableSwapBuffers;
+    private->base.destroy = __glXDRIdrawableDestroy;
+    private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
     private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
-    private->base.waitGL	= __glXDRIdrawableWaitGL;
-    private->base.waitX		= __glXDRIdrawableWaitX;
+    private->base.waitGL = __glXDRIdrawableWaitGL;
+    private->base.waitX = __glXDRIdrawableWaitX;
 
     if (DRI2CreateDrawable(client, pDraw, drawId,
-			   __glXDRIinvalidateBuffers, private)) {
-	    free(private);
-	    return NULL;
+                           __glXDRIinvalidateBuffers, private)) {
+        free(private);
+        return NULL;
     }
 
     private->driDrawable =
-	(*driScreen->dri2->createNewDrawable)(driScreen->driScreen,
-					      config->driConfig, private);
+        (*driScreen->dri2->createNewDrawable) (driScreen->driScreen,
+                                               config->driConfig, private);
 
     return &private->base;
 }
 
 static __DRIbuffer *
-dri2GetBuffers(__DRIdrawable *driDrawable,
-	       int *width, int *height,
-	       unsigned int *attachments, int count,
-	       int *out_count, void *loaderPrivate)
+dri2GetBuffers(__DRIdrawable * driDrawable,
+               int *width, int *height,
+               unsigned int *attachments, int count,
+               int *out_count, void *loaderPrivate)
 {
     __GLXDRIdrawable *private = loaderPrivate;
     DRI2BufferPtr *buffers;
@@ -489,12 +481,12 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
     int j;
 
     buffers = DRI2GetBuffers(private->base.pDraw,
-			     width, height, attachments, count, out_count);
+                             width, height, attachments, count, out_count);
     if (*out_count > MAX_DRAWABLE_BUFFERS) {
-	*out_count = 0;
-	return NULL;
+        *out_count = 0;
+        return NULL;
     }
-	
+
     private->width = *width;
     private->height = *height;
 
@@ -502,19 +494,19 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
      * __DRIbuffer tokens. */
     j = 0;
     for (i = 0; i < *out_count; i++) {
-	/* Do not send the real front buffer of a window to the client.
-	 */
-	if ((private->base.pDraw->type == DRAWABLE_WINDOW)
-	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
-	    continue;
-	}
-
-	private->buffers[j].attachment = buffers[i]->attachment;
-	private->buffers[j].name = buffers[i]->name;
-	private->buffers[j].pitch = buffers[i]->pitch;
-	private->buffers[j].cpp = buffers[i]->cpp;
-	private->buffers[j].flags = buffers[i]->flags;
-	j++;
+        /* Do not send the real front buffer of a window to the client.
+         */
+        if ((private->base.pDraw->type == DRAWABLE_WINDOW)
+            && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
+            continue;
+        }
+
+        private->buffers[j].attachment = buffers[i]->attachment;
+        private->buffers[j].name = buffers[i]->name;
+        private->buffers[j].pitch = buffers[i]->pitch;
+        private->buffers[j].cpp = buffers[i]->cpp;
+        private->buffers[j].flags = buffers[i]->flags;
+        j++;
     }
 
     *out_count = j;
@@ -522,10 +514,10 @@ dri2GetBuffers(__DRIdrawable *driDrawable,
 }
 
 static __DRIbuffer *
-dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
-			 int *width, int *height,
-			 unsigned int *attachments, int count,
-			 int *out_count, void *loaderPrivate)
+dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,
+                         int *width, int *height,
+                         unsigned int *attachments, int count,
+                         int *out_count, void *loaderPrivate)
 {
     __GLXDRIdrawable *private = loaderPrivate;
     DRI2BufferPtr *buffers;
@@ -533,11 +525,11 @@ dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
     int j = 0;
 
     buffers = DRI2GetBuffersWithFormat(private->base.pDraw,
-				       width, height, attachments, count,
-				       out_count);
+                                       width, height, attachments, count,
+                                       out_count);
     if (*out_count > MAX_DRAWABLE_BUFFERS) {
-	*out_count = 0;
-	return NULL;
+        *out_count = 0;
+        return NULL;
     }
 
     private->width = *width;
@@ -546,34 +538,34 @@ dri2GetBuffersWithFormat(__DRIdrawable *driDrawable,
     /* This assumes the DRI2 buffer attachment tokens matches the
      * __DRIbuffer tokens. */
     for (i = 0; i < *out_count; i++) {
-	/* Do not send the real front buffer of a window to the client.
-	 */
-	if ((private->base.pDraw->type == DRAWABLE_WINDOW)
-	    && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
-	    continue;
-	}
-
-	private->buffers[j].attachment = buffers[i]->attachment;
-	private->buffers[j].name = buffers[i]->name;
-	private->buffers[j].pitch = buffers[i]->pitch;
-	private->buffers[j].cpp = buffers[i]->cpp;
-	private->buffers[j].flags = buffers[i]->flags;
-	j++;
+        /* Do not send the real front buffer of a window to the client.
+         */
+        if ((private->base.pDraw->type == DRAWABLE_WINDOW)
+            && (buffers[i]->attachment == DRI2BufferFrontLeft)) {
+            continue;
+        }
+
+        private->buffers[j].attachment = buffers[i]->attachment;
+        private->buffers[j].name = buffers[i]->name;
+        private->buffers[j].pitch = buffers[i]->pitch;
+        private->buffers[j].cpp = buffers[i]->cpp;
+        private->buffers[j].flags = buffers[i]->flags;
+        j++;
     }
 
     *out_count = j;
     return private->buffers;
 }
 
-static void 
-dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
+static void
+dri2FlushFrontBuffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 {
     (void) driDrawable;
     __glXDRIdrawableWaitGL((__GLXdrawable *) loaderPrivate);
 }
 
 static const __DRIdri2LoaderExtension loaderExtension = {
-    { __DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION },
+    {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
     dri2GetBuffers,
     dri2FlushFrontBuffer,
     dri2GetBuffersWithFormat,
@@ -581,7 +573,7 @@ static const __DRIdri2LoaderExtension loaderExtension = {
 
 #ifdef __DRI_USE_INVALIDATE
 static const __DRIuseInvalidateExtension dri2UseInvalidate = {
-   { __DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION }
+    {__DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION}
 };
 #endif
 
@@ -595,36 +587,36 @@ static const __DRIextension *loader_extensions[] = {
 };
 
 static Bool
-glxDRIEnterVT (int index, int flags)
+glxDRIEnterVT(int index, int flags)
 {
     ScrnInfoPtr scrn = xf86Screens[index];
-    Bool	ret;
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) 
-	glxGetScreen(screenInfo.screens[index]);
+    Bool ret;
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+        glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
 
     scrn->EnterVT = screen->enterVT;
 
-    ret = scrn->EnterVT (index, flags);
+    ret = scrn->EnterVT(index, flags);
 
     screen->enterVT = scrn->EnterVT;
     scrn->EnterVT = glxDRIEnterVT;
 
     if (!ret)
-	return FALSE;
-    
+        return FALSE;
+
     glxResumeClients();
 
     return TRUE;
 }
 
 static void
-glxDRILeaveVT (int index, int flags)
+glxDRILeaveVT(int index, int flags)
 {
     ScrnInfoPtr scrn = xf86Screens[index];
     __GLXDRIscreen *screen = (__GLXDRIscreen *)
-	glxGetScreen(screenInfo.screens[index]);
+        glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
 
@@ -637,7 +629,7 @@ glxDRILeaveVT (int index, int flags)
 }
 
 static void
-initializeExtensions(__GLXDRIscreen *screen)
+initializeExtensions(__GLXDRIscreen * screen)
 {
     ScreenPtr pScreen = screen->base.pScreen;
     const __DRIextension **extensions;
@@ -645,48 +637,46 @@ initializeExtensions(__GLXDRIscreen *screen)
 
     extensions = screen->core->getExtensions(screen->driScreen);
 
-    __glXEnableExtension(screen->glx_enable_bits,
-			 "GLX_MESA_copy_sub_buffer");
+    __glXEnableExtension(screen->glx_enable_bits, "GLX_MESA_copy_sub_buffer");
     LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
 
     __glXEnableExtension(screen->glx_enable_bits, "GLX_INTEL_swap_event");
     LogMessage(X_INFO, "AIGLX: enabled GLX_INTEL_swap_event\n");
 
     if (DRI2HasSwapControl(pScreen)) {
-	__glXEnableExtension(screen->glx_enable_bits,
-			     "GLX_SGI_swap_control");
-	__glXEnableExtension(screen->glx_enable_bits,
-			     "GLX_MESA_swap_control");
-	LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
+        __glXEnableExtension(screen->glx_enable_bits, "GLX_SGI_swap_control");
+        __glXEnableExtension(screen->glx_enable_bits, "GLX_MESA_swap_control");
+        LogMessage(X_INFO,
+                   "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
     }
 
     for (i = 0; extensions[i]; i++) {
 #ifdef __DRI_READ_DRAWABLE
-	if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
-	    __glXEnableExtension(screen->glx_enable_bits,
-				 "GLX_SGI_make_current_read");
+        if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
+            __glXEnableExtension(screen->glx_enable_bits,
+                                 "GLX_SGI_make_current_read");
 
-	    LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_make_current_read\n");
-	}
+            LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_make_current_read\n");
+        }
 #endif
 
 #ifdef __DRI_TEX_BUFFER
-	if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {
-	    screen->texBuffer =
-		(const __DRItexBufferExtension *) extensions[i];
-	    /* GLX_EXT_texture_from_pixmap is always enabled. */
-	    LogMessage(X_INFO, "AIGLX: GLX_EXT_texture_from_pixmap backed by buffer objects\n");
-	}
+        if (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) {
+            screen->texBuffer = (const __DRItexBufferExtension *) extensions[i];
+            /* GLX_EXT_texture_from_pixmap is always enabled. */
+            LogMessage(X_INFO,
+                       "AIGLX: GLX_EXT_texture_from_pixmap backed by buffer objects\n");
+        }
 #endif
 
 #ifdef __DRI2_FLUSH
-	if (strcmp(extensions[i]->name, __DRI2_FLUSH) == 0 &&
-	    extensions[i]->version >= 3) {
-		screen->flush = (__DRI2flushExtension *) extensions[i];
-	}
+        if (strcmp(extensions[i]->name, __DRI2_FLUSH) == 0 &&
+            extensions[i]->version >= 3) {
+            screen->flush = (__DRI2flushExtension *) extensions[i];
+        }
 #endif
 
-	/* Ignore unknown extensions */
+        /* Ignore unknown extensions */
     }
 }
 
@@ -700,49 +690,48 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 
     screen = calloc(1, sizeof *screen);
     if (screen == NULL)
-	return NULL;
+        return NULL;
 
     if (!xf86LoaderCheckSymbol("DRI2Connect") ||
-	!DRI2Connect(pScreen, DRI2DriverDRI,
-		     &screen->fd, &driverName, &deviceName)) {
-	LogMessage(X_INFO,
-		   "AIGLX: Screen %d is not DRI2 capable\n", pScreen->myNum);
-	return NULL;
+        !DRI2Connect(pScreen, DRI2DriverDRI,
+                     &screen->fd, &driverName, &deviceName)) {
+        LogMessage(X_INFO,
+                   "AIGLX: Screen %d is not DRI2 capable\n", pScreen->myNum);
+        return NULL;
     }
 
-    screen->base.destroy        = __glXDRIscreenDestroy;
-    screen->base.createContext  = __glXDRIscreenCreateContext;
+    screen->base.destroy = __glXDRIscreenDestroy;
+    screen->base.createContext = __glXDRIscreenCreateContext;
     screen->base.createDrawable = __glXDRIscreenCreateDrawable;
-    screen->base.swapInterval   = __glXDRIdrawableSwapInterval;
-    screen->base.pScreen       = pScreen;
+    screen->base.swapInterval = __glXDRIdrawableSwapInterval;
+    screen->base.pScreen = pScreen;
 
     __glXInitExtensionEnableBits(screen->glx_enable_bits);
 
-    screen->driver = glxProbeDriver(driverName, (void **)&screen->core, __DRI_CORE, 1,
-				    (void **)&screen->dri2, __DRI_DRI2, 1);
+    screen->driver =
+        glxProbeDriver(driverName, (void **) &screen->core, __DRI_CORE, 1,
+                       (void **) &screen->dri2, __DRI_DRI2, 1);
     if (screen->driver == NULL) {
         goto handle_error;
     }
-    
+
     screen->driScreen =
-	(*screen->dri2->createNewScreen)(pScreen->myNum,
-					 screen->fd,
-					 loader_extensions,
-					 &screen->driConfigs,
-					 screen);
+        (*screen->dri2->createNewScreen) (pScreen->myNum,
+                                          screen->fd,
+                                          loader_extensions,
+                                          &screen->driConfigs, screen);
 
     if (screen->driScreen == NULL) {
-	LogMessage(X_ERROR,
-		   "AIGLX error: Calling driver entry point failed\n");
-	goto handle_error;
+        LogMessage(X_ERROR, "AIGLX error: Calling driver entry point failed\n");
+        goto handle_error;
     }
 
     initializeExtensions(screen);
 
     screen->base.fbconfigs = glxConvertConfigs(screen->core, screen->driConfigs,
-					       GLX_WINDOW_BIT |
-					       GLX_PIXMAP_BIT |
-					       GLX_PBUFFER_BIT);
+                                               GLX_WINDOW_BIT |
+                                               GLX_PIXMAP_BIT |
+                                               GLX_PBUFFER_BIT);
 
     __glXScreenInit(&screen->base, pScreen);
 
@@ -752,11 +741,11 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
      */
     buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
     if (buffer_size > 0) {
-	free(screen->base.GLXextensions);
+        free(screen->base.GLXextensions);
 
-	screen->base.GLXextensions = xnfalloc(buffer_size);
-	(void) __glXGetExtensionString(screen->glx_enable_bits, 
-				       screen->base.GLXextensions);
+        screen->base.GLXextensions = xnfalloc(buffer_size);
+        (void) __glXGetExtensionString(screen->glx_enable_bits,
+                                       screen->base.GLXextensions);
     }
 
     /* We're going to assume (perhaps incorrectly?) that all DRI2-enabled
@@ -770,14 +759,13 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
      */
     screen->base.GLXmajor = 1;
     screen->base.GLXminor = 4;
-    
+
     screen->enterVT = pScrn->EnterVT;
-    pScrn->EnterVT = glxDRIEnterVT; 
+    pScrn->EnterVT = glxDRIEnterVT;
     screen->leaveVT = pScrn->LeaveVT;
     pScrn->LeaveVT = glxDRILeaveVT;
 
-    LogMessage(X_INFO,
-	       "AIGLX: Loaded and initialized %s\n", driverName);
+    LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;