Revert pointless reindents to avoid merge conflicts.

Why are we reindenting code that's work in progress...

7 files changed, 2893 insertions, 3019 deletions

diff --git a/src/glx/x11/dri2.c b/src/glx/x11/dri2.c
index dbb5b5cddd0..edd80dc58f2 100644
--- a/src/glx/x11/dri2.c
+++ b/src/glx/x11/dri2.c
@@ -42,266 +42,260 @@
 
 static char dri2ExtensionName[] = DRI2_NAME;
 static XExtensionInfo *dri2Info;
-static
-XEXT_GENERATE_CLOSE_DISPLAY(DRI2CloseDisplay, dri2Info)
-     static /* const */ XExtensionHooks dri2ExtensionHooks = {
-        NULL,                   /* create_gc */
-        NULL,                   /* copy_gc */
-        NULL,                   /* flush_gc */
-        NULL,                   /* free_gc */
-        NULL,                   /* create_font */
-        NULL,                   /* free_font */
-        DRI2CloseDisplay,       /* close_display */
-        NULL,                   /* wire_to_event */
-        NULL,                   /* event_to_wire */
-        NULL,                   /* error */
-        NULL,                   /* error_string */
-     };
-
-static
-XEXT_GENERATE_FIND_DISPLAY(DRI2FindDisplay, dri2Info,
-                           dri2ExtensionName, &dri2ExtensionHooks, 0, NULL)
-
-     Bool DRI2QueryExtension(Display * dpy, int *eventBase, int *errorBase)
+static XEXT_GENERATE_CLOSE_DISPLAY (DRI2CloseDisplay, dri2Info)
+static /* const */ XExtensionHooks dri2ExtensionHooks = {
+    NULL,				/* create_gc */
+    NULL,				/* copy_gc */
+    NULL,				/* flush_gc */
+    NULL,				/* free_gc */
+    NULL,				/* create_font */
+    NULL,				/* free_font */
+    DRI2CloseDisplay,			/* close_display */
+    NULL,				/* wire_to_event */
+    NULL,				/* event_to_wire */
+    NULL,				/* error */
+    NULL,				/* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (DRI2FindDisplay, dri2Info, 
+				   dri2ExtensionName, 
+				   &dri2ExtensionHooks, 
+				   0, NULL)
+
+Bool DRI2QueryExtension(Display *dpy, int *eventBase, int *errorBase)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 
-   if (XextHasExtension(info)) {
-      *eventBase = info->codes->first_event;
-      *errorBase = info->codes->first_error;
-      return True;
-   }
+    if (XextHasExtension(info)) {
+	*eventBase = info->codes->first_event;
+	*errorBase = info->codes->first_error;
+	return True;
+    }
 
-   return False;
+    return False;
 }
 
-Bool
-DRI2QueryVersion(Display * dpy, int *major, int *minor)
+Bool DRI2QueryVersion(Display *dpy, int *major, int *minor)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2QueryVersionReply rep;
-   xDRI2QueryVersionReq *req;
-
-   XextCheckExtension(dpy, info, dri2ExtensionName, False);
-
-   LockDisplay(dpy);
-   GetReq(DRI2QueryVersion, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2QueryVersion;
-   req->majorVersion = DRI2_MAJOR;
-   req->minorVersion = DRI2_MINOR;
-   if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-   *major = rep.majorVersion;
-   *minor = rep.minorVersion;
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return True;
+    XExtDisplayInfo *info = DRI2FindDisplay (dpy);
+    xDRI2QueryVersionReply rep;
+    xDRI2QueryVersionReq *req;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2QueryVersion, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2QueryVersion;
+    req->majorVersion = DRI2_MAJOR;
+    req->minorVersion = DRI2_MINOR;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    *major = rep.majorVersion;
+    *minor = rep.minorVersion;
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return True;
 }
 
-Bool
-DRI2Connect(Display * dpy, int screen,
-            char **driverName, char **busId, unsigned int *sareaHandle)
+Bool DRI2Connect(Display *dpy, int screen,
+		 char **driverName, char **busId, unsigned int *sareaHandle)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2ConnectReply rep;
-   xDRI2ConnectReq *req;
-
-   XextCheckExtension(dpy, info, dri2ExtensionName, False);
-
-   LockDisplay(dpy);
-   GetReq(DRI2Connect, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2Connect;
-   req->screen = screen;
-   if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-
-   if (rep.driverNameLength == 0 && rep.busIdLength == 0) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-
-   *driverName = Xmalloc(rep.driverNameLength + 1);
-   if (*driverName == NULL) {
-      _XEatData(dpy,
-                ((rep.driverNameLength + 3) & ~3) +
-                ((rep.busIdLength + 3) & ~3));
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-   _XReadPad(dpy, *driverName, rep.driverNameLength);
-   (*driverName)[rep.driverNameLength] = '\0';
-
-   *busId = Xmalloc(rep.busIdLength + 1);
-   if (*busId == NULL) {
-      Xfree(*driverName);
-      _XEatData(dpy, ((rep.busIdLength + 3) & ~3));
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-   _XReadPad(dpy, *busId, rep.busIdLength);
-   (*busId)[rep.busIdLength] = '\0';
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return True;
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2ConnectReply rep;
+    xDRI2ConnectReq *req;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2Connect, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2Connect;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+
+    if (rep.driverNameLength == 0 && rep.busIdLength == 0) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+
+    *driverName = Xmalloc(rep.driverNameLength + 1);
+    if (*driverName == NULL) {
+	_XEatData(dpy, 
+		  ((rep.driverNameLength + 3) & ~3) +
+		  ((rep.busIdLength + 3) & ~3));
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    _XReadPad(dpy, *driverName, rep.driverNameLength);
+    (*driverName)[rep.driverNameLength] = '\0';
+
+    *busId = Xmalloc(rep.busIdLength + 1);
+    if (*busId == NULL) {
+	Xfree(*driverName);
+	_XEatData(dpy, ((rep.busIdLength + 3) & ~3));
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    _XReadPad(dpy, *busId, rep.busIdLength);
+    (*busId)[rep.busIdLength] = '\0';
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return True;
 }
 
-Bool
-DRI2AuthConnection(Display * dpy, int screen, drm_magic_t magic)
+Bool DRI2AuthConnection(Display *dpy, int screen, drm_magic_t magic)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2AuthConnectionReq *req;
-   xDRI2AuthConnectionReply rep;
-
-   XextCheckExtension(dpy, info, dri2ExtensionName, False);
-
-   LockDisplay(dpy);
-   GetReq(DRI2AuthConnection, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2AuthConnection;
-   req->screen = screen;
-   req->magic = magic;
-   rep.authenticated = 0;
-   if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return False;
-   }
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return rep.authenticated;
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2AuthConnectionReq *req;
+    xDRI2AuthConnectionReply rep;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReq(DRI2AuthConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2AuthConnection;
+    req->screen = screen;
+    req->magic = magic;
+    rep.authenticated = 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return rep.authenticated;
 }
 
-void
-DRI2CreateDrawable(Display * dpy, XID drawable)
+void DRI2CreateDrawable(Display *dpy, XID drawable)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2CreateDrawableReq *req;
-
-   XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
-
-   LockDisplay(dpy);
-   GetReq(DRI2CreateDrawable, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2CreateDrawable;
-   req->drawable = drawable;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2CreateDrawableReq *req;
+
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
+
+    LockDisplay(dpy);
+    GetReq(DRI2CreateDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2CreateDrawable;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
-DRI2Buffer *
-DRI2GetBuffers(Display * dpy, XID drawable,
-               int *width, int *height,
-               unsigned int *attachments, int count, int *outCount)
+DRI2Buffer *DRI2GetBuffers(Display *dpy, XID drawable,
+			   int *width, int *height,
+			   unsigned int *attachments, int count,
+			   int *outCount)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2GetBuffersReply rep;
-   xDRI2GetBuffersReq *req;
-   DRI2Buffer *buffers;
-   xDRI2Buffer repBuffer;
-   CARD32 *p;
-   int i;
-
-   XextCheckExtension(dpy, info, dri2ExtensionName, False);
-
-   LockDisplay(dpy);
-   GetReqExtra(DRI2GetBuffers, count * 4, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2GetBuffers;
-   req->drawable = drawable;
-   req->count = count;
-   p = (CARD32 *) & req[1];
-   for (i = 0; i < count; i++)
-      p[i] = attachments[i];
-
-   if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return NULL;
-   }
-
-   *width = rep.width;
-   *height = rep.height;
-   *outCount = rep.count;
-
-   buffers = Xmalloc(count * sizeof buffers[0]);
-   if (buffers == NULL) {
-      _XEatData(dpy, rep.count * sizeof repBuffer);
-      UnlockDisplay(dpy);
-      SyncHandle();
-      return NULL;
-   }
-
-   for (i = 0; i < rep.count; i++) {
-      _XReadPad(dpy, (char *) &repBuffer, sizeof repBuffer);
-      buffers[i].attachment = repBuffer.attachment;
-      buffers[i].name = repBuffer.name;
-      buffers[i].pitch = repBuffer.pitch;
-      buffers[i].cpp = repBuffer.cpp;
-      buffers[i].flags = repBuffer.flags;
-   }
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return buffers;
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2GetBuffersReply rep;
+    xDRI2GetBuffersReq *req;
+    DRI2Buffer *buffers;
+    xDRI2Buffer repBuffer;
+    CARD32 *p;
+    int i;
+
+    XextCheckExtension (dpy, info, dri2ExtensionName, False);
+
+    LockDisplay(dpy);
+    GetReqExtra(DRI2GetBuffers, count * 4, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2GetBuffers;
+    req->drawable = drawable;
+    req->count = count;
+    p = (CARD32 *) &req[1];
+    for (i = 0; i < count; i++)
+	p[i] = attachments[i];
+
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return NULL;
+    }
+
+    *width = rep.width;
+    *height = rep.height;
+    *outCount = rep.count;
+
+    buffers = Xmalloc(count * sizeof buffers[0]);
+    if (buffers == NULL) {
+	_XEatData(dpy, rep.count * sizeof repBuffer);
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return NULL;
+    }
+
+    for (i = 0; i < rep.count; i++) {
+	_XReadPad(dpy, (char *) &repBuffer, sizeof repBuffer);
+	buffers[i].attachment = repBuffer.attachment;
+	buffers[i].name = repBuffer.name;
+	buffers[i].pitch = repBuffer.pitch;
+	buffers[i].cpp = repBuffer.cpp;
+	buffers[i].flags = repBuffer.flags;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return buffers;
 }
 
-void
-DRI2SwapBuffers(Display * dpy, XID drawable,
-                int x, int y, int width, int height)
+void DRI2SwapBuffers(Display *dpy, XID drawable,
+		     int x, int y, int width, int height)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2SwapBuffersReq *req;
-   xDRI2SwapBuffersReply rep;
-
-   XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
-
-   LockDisplay(dpy);
-   GetReq(DRI2SwapBuffers, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2SwapBuffers;
-   req->drawable = drawable;
-   req->x = x;
-   req->y = y;
-   req->width = width;
-   req->height = height;
-
-   _XReply(dpy, (xReply *) & rep, 0, xFalse);
-
-   UnlockDisplay(dpy);
-   SyncHandle();
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2SwapBuffersReq *req;
+    xDRI2SwapBuffersReply rep;
+
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
+
+    LockDisplay(dpy);
+    GetReq(DRI2SwapBuffers, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2SwapBuffers;
+    req->drawable = drawable;
+    req->x = x;
+    req->y = y;
+    req->width = width;
+    req->height = height;
+
+    _XReply(dpy, (xReply *)&rep, 0, xFalse);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
-void
-DRI2DestroyDrawable(Display * dpy, XID drawable)
+void DRI2DestroyDrawable(Display *dpy, XID drawable)
 {
-   XExtDisplayInfo *info = DRI2FindDisplay(dpy);
-   xDRI2DestroyDrawableReq *req;
+    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
+    xDRI2DestroyDrawableReq *req;
 
-   XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
+    XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
 
-   XSync(dpy, False);
+    XSync(dpy, False);
 
-   LockDisplay(dpy);
-   GetReq(DRI2DestroyDrawable, req);
-   req->reqType = info->codes->major_opcode;
-   req->dri2ReqType = X_DRI2DestroyDrawable;
-   req->drawable = drawable;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    LockDisplay(dpy);
+    GetReq(DRI2DestroyDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->dri2ReqType = X_DRI2DestroyDrawable;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
diff --git a/src/glx/x11/dri2.h b/src/glx/x11/dri2.h
index 620ad7a30b3..25212f99e5c 100644
--- a/src/glx/x11/dri2.h
+++ b/src/glx/x11/dri2.h
@@ -34,31 +34,34 @@
 #ifndef _DRI2_H_
 #define _DRI2_H_
 
-typedef struct
-{
-   unsigned int attachment;
-   unsigned int name;
-   unsigned int pitch;
-   unsigned int cpp;
-   unsigned int flags;
+typedef struct {
+    unsigned int attachment;
+    unsigned int name;
+    unsigned int pitch;
+    unsigned int cpp;
+    unsigned int flags;
 } DRI2Buffer;
 
 extern Bool
-DRI2QueryExtension(Display * display, int *eventBase, int *errorBase);
-extern Bool DRI2QueryVersion(Display * display, int *major, int *minor);
+DRI2QueryExtension(Display *display, int *eventBase, int *errorBase);
 extern Bool
-DRI2Connect(Display * display, int screen,
-            char **driverName, char **busId, unsigned int *sareaHandle);
+DRI2QueryVersion(Display *display, int *major, int *minor);
 extern Bool
-DRI2AuthConnection(Display * display, int screen, drm_magic_t magic);
-extern void DRI2CreateDrawable(Display * display, XID drawable);
-extern void DRI2DestroyDrawable(Display * display, XID handle);
-extern DRI2Buffer *DRI2GetBuffers(Display * dpy, XID drawable,
-                                  int *width, int *height,
-                                  unsigned int *attachments, int count,
-                                  int *outCount);
+DRI2Connect(Display *display, int screen,
+	    char **driverName, char **busId, unsigned int *sareaHandle);
+extern Bool
+DRI2AuthConnection(Display *display, int screen, drm_magic_t magic);
+extern void
+DRI2CreateDrawable(Display *display, XID drawable);
+extern void
+DRI2DestroyDrawable(Display *display, XID handle);
+extern DRI2Buffer *
+DRI2GetBuffers(Display *dpy, XID drawable,
+	       int *width, int *height,
+	       unsigned int *attachments, int count,
+	       int *outCount);
 extern void
-DRI2SwapBuffers(Display * dpy, XID drawable,
-                int x, int y, int width, int height);
+DRI2SwapBuffers(Display *dpy, XID drawable,
+		int x, int y, int width, int height);
 
 #endif
diff --git a/src/glx/x11/dri2_glx.c b/src/glx/x11/dri2_glx.c
index 651d8433564..39b618e718a 100644
--- a/src/glx/x11/dri2_glx.c
+++ b/src/glx/x11/dri2_glx.c
@@ -51,302 +51,292 @@ typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate;
 typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate;
 typedef struct __GLXDRIdrawablePrivateRec __GLXDRIdrawablePrivate;
 
-struct __GLXDRIdisplayPrivateRec
-{
-   __GLXDRIdisplay base;
+struct __GLXDRIdisplayPrivateRec {
+    __GLXDRIdisplay base;
 
-   /*
+    /*
     ** XFree86-DRI version information
     */
-   int driMajor;
-   int driMinor;
-   int driPatch;
+    int driMajor;
+    int driMinor;
+    int driPatch;
 };
 
-struct __GLXDRIcontextPrivateRec
-{
-   __GLXDRIcontext base;
-   __DRIcontext *driContext;
-   __GLXscreenConfigs *psc;
+struct __GLXDRIcontextPrivateRec {
+    __GLXDRIcontext base;
+    __DRIcontext *driContext;
+    __GLXscreenConfigs *psc;
 };
 
-struct __GLXDRIdrawablePrivateRec
-{
-   __GLXDRIdrawable base;
-   __DRIbuffer buffers[5];
-   int bufferCount;
-   int width, height;
+struct __GLXDRIdrawablePrivateRec {
+    __GLXDRIdrawable base;
+    __DRIbuffer buffers[5];
+    int bufferCount;
+    int width, height;
 };
 
-static void
-dri2DestroyContext(__GLXDRIcontext * context,
-                   __GLXscreenConfigs * psc, Display * dpy)
+static void dri2DestroyContext(__GLXDRIcontext *context,
+			      __GLXscreenConfigs *psc, Display *dpy)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
-   const __DRIcoreExtension *core = pcp->psc->core;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    const __DRIcoreExtension *core = pcp->psc->core;
 
-   (*core->destroyContext) (pcp->driContext);
+    (*core->destroyContext)(pcp->driContext);
 
-   Xfree(pcp);
+    Xfree(pcp);
 }
 
-static Bool
-dri2BindContext(__GLXDRIcontext * context,
-                __GLXDRIdrawable * draw, __GLXDRIdrawable * read)
+static Bool dri2BindContext(__GLXDRIcontext *context,
+			   __GLXDRIdrawable *draw, __GLXDRIdrawable *read)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
-   const __DRIcoreExtension *core = pcp->psc->core;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    const __DRIcoreExtension *core = pcp->psc->core;
 
-   return (*core->bindContext) (pcp->driContext,
-                                draw->driDrawable, read->driDrawable);
+    return (*core->bindContext)(pcp->driContext,
+				draw->driDrawable,
+				read->driDrawable);
 }
 
-static void
-dri2UnbindContext(__GLXDRIcontext * context)
+static void dri2UnbindContext(__GLXDRIcontext *context)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
-   const __DRIcoreExtension *core = pcp->psc->core;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    const __DRIcoreExtension *core = pcp->psc->core;
 
-   (*core->unbindContext) (pcp->driContext);
+    (*core->unbindContext)(pcp->driContext);
 }
 
-static __GLXDRIcontext *
-dri2CreateContext(__GLXscreenConfigs * psc,
-                  const __GLcontextModes * mode,
-                  GLXContext gc, GLXContext shareList, int renderType)
+static __GLXDRIcontext *dri2CreateContext(__GLXscreenConfigs *psc,
+					 const __GLcontextModes *mode,
+					 GLXContext gc,
+					 GLXContext shareList, int renderType)
 {
-   __GLXDRIcontextPrivate *pcp, *pcp_shared;
-   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode;
-   __DRIcontext *shared = NULL;
-
-   if (shareList) {
-      pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext;
-      shared = pcp_shared->driContext;
-   }
-
-   pcp = Xmalloc(sizeof *pcp);
-   if (pcp == NULL)
-      return NULL;
-
-   pcp->psc = psc;
-   pcp->driContext =
-      (*psc->dri2->createNewContext) (psc->__driScreen,
-                                      config->driConfig, shared, pcp);
-   gc->__driContext = pcp->driContext;
-
-   if (pcp->driContext == NULL) {
-      Xfree(pcp);
-      return NULL;
-   }
-
-   pcp->base.destroyContext = dri2DestroyContext;
-   pcp->base.bindContext = dri2BindContext;
-   pcp->base.unbindContext = dri2UnbindContext;
-
-   return &pcp->base;
+    __GLXDRIcontextPrivate *pcp, *pcp_shared;
+    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode;
+    __DRIcontext *shared = NULL;
+
+    if (shareList) {
+	pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext;
+	shared = pcp_shared->driContext;
+    }
+
+    pcp = Xmalloc(sizeof *pcp);
+    if (pcp == NULL)
+	return NULL;
+
+    pcp->psc = psc;
+    pcp->driContext = 
+	(*psc->dri2->createNewContext)(psc->__driScreen,
+				       config->driConfig, shared, pcp);
+    gc->__driContext = pcp->driContext;
+
+    if (pcp->driContext == NULL) {
+	Xfree(pcp);
+	return NULL;
+    }
+
+    pcp->base.destroyContext = dri2DestroyContext;
+    pcp->base.bindContext = dri2BindContext;
+    pcp->base.unbindContext = dri2UnbindContext;
+
+    return &pcp->base;
 }
 
-static void
-dri2DestroyDrawable(__GLXDRIdrawable * pdraw)
+static void dri2DestroyDrawable(__GLXDRIdrawable *pdraw)
 {
-   const __DRIcoreExtension *core = pdraw->psc->core;
+    const __DRIcoreExtension *core = pdraw->psc->core;
 
-   (*core->destroyDrawable) (pdraw->driDrawable);
-   DRI2DestroyDrawable(pdraw->psc->dpy, pdraw->drawable);
-   Xfree(pdraw);
+    (*core->destroyDrawable)(pdraw->driDrawable);
+    DRI2DestroyDrawable(pdraw->psc->dpy, pdraw->drawable);
+    Xfree(pdraw);
 }
 
-static __GLXDRIdrawable *
-dri2CreateDrawable(__GLXscreenConfigs * psc,
-                   XID xDrawable,
-                   GLXDrawable drawable, const __GLcontextModes * modes)
+static __GLXDRIdrawable *dri2CreateDrawable(__GLXscreenConfigs *psc,
+					    XID xDrawable,
+					    GLXDrawable drawable,
+					    const __GLcontextModes *modes)
 {
-   __GLXDRIdrawablePrivate *pdraw;
-   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
+    __GLXDRIdrawablePrivate *pdraw;
+    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
 
-   pdraw = Xmalloc(sizeof(*pdraw));
-   if (!pdraw)
-      return NULL;
+    pdraw = Xmalloc(sizeof(*pdraw));
+    if (!pdraw)
+	return NULL;
 
-   pdraw->base.destroyDrawable = dri2DestroyDrawable;
-   pdraw->base.xDrawable = xDrawable;
-   pdraw->base.drawable = drawable;
-   pdraw->base.psc = psc;
+    pdraw->base.destroyDrawable = dri2DestroyDrawable;
+    pdraw->base.xDrawable = xDrawable;
+    pdraw->base.drawable = drawable;
+    pdraw->base.psc = psc;
 
-   DRI2CreateDrawable(psc->dpy, xDrawable);
+    DRI2CreateDrawable(psc->dpy, xDrawable);
 
-   /* Create a new drawable */
-   pdraw->base.driDrawable =
-      (*psc->dri2->createNewDrawable) (psc->__driScreen,
-                                       config->driConfig, pdraw);
+    /* Create a new drawable */
+    pdraw->base.driDrawable =
+	(*psc->dri2->createNewDrawable)(psc->__driScreen,
+					config->driConfig, pdraw);
 
-   if (!pdraw->base.driDrawable) {
-      DRI2DestroyDrawable(psc->dpy, drawable);
-      Xfree(pdraw);
-      return NULL;
-   }
+    if (!pdraw->base.driDrawable) {
+	DRI2DestroyDrawable(psc->dpy, drawable);
+	Xfree(pdraw);
+	return NULL;
+    }
 
-   return &pdraw->base;
+    return &pdraw->base;
 }
 
-static void
-dri2SwapBuffers(__GLXDRIdrawable * pdraw)
+static void dri2SwapBuffers(__GLXDRIdrawable *pdraw)
 {
-   __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw;
+    __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw;
 
-   DRI2SwapBuffers(pdraw->psc->dpy, pdraw->drawable,
-                   0, 0, priv->width, priv->height);
+    DRI2SwapBuffers(pdraw->psc->dpy, pdraw->drawable,
+		    0, 0, priv->width, priv->height);
 }
 
-static void
-dri2DestroyScreen(__GLXscreenConfigs * psc)
+static void dri2DestroyScreen(__GLXscreenConfigs *psc)
 {
-   /* Free the direct rendering per screen data */
-   (*psc->core->destroyScreen) (psc->__driScreen);
-   drmClose(psc->fd);
-   psc->__driScreen = NULL;
+    /* Free the direct rendering per screen data */
+    (*psc->core->destroyScreen)(psc->__driScreen);
+    drmClose(psc->fd);
+    psc->__driScreen = NULL;
 }
 
 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)
 {
-   __GLXDRIdrawablePrivate *pdraw = loaderPrivate;
-   DRI2Buffer *buffers;
-   int i;
-
-   buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
-                            width, height, attachments, count, out_count);
-   if (buffers == NULL)
-      return NULL;
-
-   pdraw->width = *width;
-   pdraw->height = *height;
-
-   /* This assumes the DRI2 buffer attachment tokens matches the
-    * __DRIbuffer tokens. */
-   for (i = 0; i < *out_count; i++) {
-      pdraw->buffers[i].attachment = buffers[i].attachment;
-      pdraw->buffers[i].name = buffers[i].name;
-      pdraw->buffers[i].pitch = buffers[i].pitch;
-      pdraw->buffers[i].cpp = buffers[i].cpp;
-      pdraw->buffers[i].flags = buffers[i].flags;
-   }
-
-   Xfree(buffers);
-
-   return pdraw->buffers;
+    __GLXDRIdrawablePrivate *pdraw = loaderPrivate;
+    DRI2Buffer *buffers;
+    int i;
+
+    buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
+			     width, height, attachments, count, out_count);
+    if (buffers == NULL)
+       return NULL;
+
+    pdraw->width = *width;
+    pdraw->height = *height;
+
+    /* This assumes the DRI2 buffer attachment tokens matches the
+     * __DRIbuffer tokens. */
+    for (i = 0; i < *out_count; i++) {
+	pdraw->buffers[i].attachment = buffers[i].attachment;
+	pdraw->buffers[i].name = buffers[i].name;
+	pdraw->buffers[i].pitch = buffers[i].pitch;
+	pdraw->buffers[i].cpp = buffers[i].cpp;
+	pdraw->buffers[i].flags = buffers[i].flags;
+    }
+
+    Xfree(buffers);
+
+    return pdraw->buffers;
 }
 
 static const __DRIdri2LoaderExtension dri2LoaderExtension = {
-   {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
-   dri2GetBuffers,
+    { __DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION },
+    dri2GetBuffers,
 };
 
 static const __DRIextension *loader_extensions[] = {
-   &dri2LoaderExtension.base,
-   &systemTimeExtension.base,
-   NULL
+    &dri2LoaderExtension.base,
+    &systemTimeExtension.base,
+    NULL
 };
 
-static __GLXDRIscreen *
-dri2CreateScreen(__GLXscreenConfigs * psc, int screen,
-                 __GLXdisplayPrivate * priv)
+static __GLXDRIscreen *dri2CreateScreen(__GLXscreenConfigs *psc, int screen,
+					__GLXdisplayPrivate *priv)
 {
-   const __DRIconfig **driver_configs;
-   const __DRIextension **extensions;
-   __GLXDRIscreen *psp;
-   unsigned int sareaHandle;
-   char *driverName, *busID;
-   drm_magic_t magic;
-   int i;
-
-   psp = Xmalloc(sizeof *psp);
-   if (psp == NULL)
-      return NULL;
-
-   /* Initialize per screen dynamic client GLX extensions */
-   psc->ext_list_first_time = GL_TRUE;
-
-   if (!DRI2Connect(psc->dpy, screen, &driverName, &busID, &sareaHandle))
-      return NULL;
-
-   psc->driver = driOpenDriver(driverName);
-   if (psc->driver == NULL)
-      goto handle_error;
-
-   extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
-   if (extensions == NULL) {
-      ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
-      goto handle_error;
-   }
-
-   for (i = 0; extensions[i]; i++) {
-      if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
-         psc->core = (__DRIcoreExtension *) extensions[i];
-      if (strcmp(extensions[i]->name, __DRI_DRI2) == 0)
-         psc->dri2 = (__DRIdri2Extension *) extensions[i];
-   }
-
-   if (psc->core == NULL || psc->dri2 == NULL) {
-      ErrorMessageF("core dri or dri2 extension not found\n");
-      goto handle_error;
-   }
-
-   psc->fd = drmOpen(NULL, busID);
-   if (psc->fd < 0) {
-      ErrorMessageF("failed to open drm device: %s\n", strerror(errno));
-      return NULL;
-   }
-
-   if (drmGetMagic(psc->fd, &magic))
-      return NULL;
-
-   if (!DRI2AuthConnection(psc->dpy, screen, magic)) {
-      ErrorMessageF("failed to authenticate drm access\n");
-      return NULL;
-   }
-
-   psc->__driScreen =
-      psc->dri2->createNewScreen(screen, psc->fd,
-                                 loader_extensions, &driver_configs, psc);
-   if (psc->__driScreen == NULL) {
-      ErrorMessageF("failed to create dri screen\n");
-      return NULL;
-   }
-
-   driBindExtensions(psc, 1);
-
-   psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs);
-   psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs);
-
-   psp->destroyScreen = dri2DestroyScreen;
-   psp->createContext = dri2CreateContext;
-   psp->createDrawable = dri2CreateDrawable;
-   psp->swapBuffers = dri2SwapBuffers;
-
-   Xfree(driverName);
-   Xfree(busID);
-
-   return psp;
+    const __DRIconfig **driver_configs;
+    const __DRIextension **extensions;
+    __GLXDRIscreen *psp;
+    unsigned int sareaHandle;
+    char *driverName, *busID;
+    drm_magic_t magic;
+    int i;
+
+    psp = Xmalloc(sizeof *psp);
+    if (psp == NULL)
+	return NULL;
+
+    /* Initialize per screen dynamic client GLX extensions */
+    psc->ext_list_first_time = GL_TRUE;
+
+    if (!DRI2Connect(psc->dpy, screen, &driverName, &busID, &sareaHandle))
+	return NULL;
+
+    psc->driver = driOpenDriver(driverName);
+    if (psc->driver == NULL)
+	goto handle_error;
+
+    extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
+    if (extensions == NULL) {
+	ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
+	goto handle_error;
+    }
+    
+    for (i = 0; extensions[i]; i++) {
+	if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
+	    psc->core = (__DRIcoreExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_DRI2) == 0)
+	    psc->dri2 = (__DRIdri2Extension *) extensions[i];
+    }
+
+    if (psc->core == NULL || psc->dri2 == NULL) {
+	ErrorMessageF("core dri or dri2 extension not found\n");
+	goto handle_error;
+    }
+
+    psc->fd = drmOpen(NULL, busID);
+    if (psc->fd < 0) {
+	ErrorMessageF("failed to open drm device: %s\n", strerror(errno));
+	return NULL;
+    }
+
+    if (drmGetMagic(psc->fd, &magic))
+	return NULL;
+
+    if (!DRI2AuthConnection(psc->dpy, screen, magic)) {
+	ErrorMessageF("failed to authenticate drm access\n");
+	return NULL;
+    }
+
+    psc->__driScreen = 
+	psc->dri2->createNewScreen(screen, psc->fd,
+				   loader_extensions, &driver_configs, psc);
+    if (psc->__driScreen == NULL) {
+	ErrorMessageF("failed to create dri screen\n");
+	return NULL;
+    }
+
+    driBindExtensions(psc, 1);
+
+    psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs);
+    psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs);
+
+    psp->destroyScreen = dri2DestroyScreen;
+    psp->createContext = dri2CreateContext;
+    psp->createDrawable = dri2CreateDrawable;
+    psp->swapBuffers = dri2SwapBuffers;
+
+    Xfree(driverName);
+    Xfree(busID);
+
+    return psp;
 
  handle_error:
-   Xfree(driverName);
-   Xfree(busID);
+    Xfree(driverName);
+    Xfree(busID);
 
-   /* FIXME: clean up here */
+    /* FIXME: clean up here */
 
-   return NULL;
+    return NULL;
 }
 
 /* Called from __glXFreeDisplayPrivate.
  */
-static void
-dri2DestroyDisplay(__GLXDRIdisplay * dpy)
+static void dri2DestroyDisplay(__GLXDRIdisplay *dpy)
 {
-   Xfree(dpy);
+    Xfree(dpy);
 }
 
 /*
@@ -354,30 +344,29 @@ dri2DestroyDisplay(__GLXDRIdisplay * dpy)
  * This is called from __glXInitialize() when we are given a new
  * display pointer.
  */
-_X_HIDDEN __GLXDRIdisplay *
-dri2CreateDisplay(Display * dpy)
+_X_HIDDEN __GLXDRIdisplay *dri2CreateDisplay(Display *dpy)
 {
-   __GLXDRIdisplayPrivate *pdp;
-   int eventBase, errorBase;
+    __GLXDRIdisplayPrivate *pdp;
+    int eventBase, errorBase;
 
-   if (!DRI2QueryExtension(dpy, &eventBase, &errorBase))
-      return NULL;
+    if (!DRI2QueryExtension(dpy, &eventBase, &errorBase))
+	return NULL;
 
-   pdp = Xmalloc(sizeof *pdp);
-   if (pdp == NULL)
-      return NULL;
+    pdp = Xmalloc(sizeof *pdp);
+    if (pdp == NULL)
+	return NULL;
 
-   if (!DRI2QueryVersion(dpy, &pdp->driMajor, &pdp->driMinor)) {
-      Xfree(pdp);
-      return NULL;
-   }
+    if (!DRI2QueryVersion(dpy, &pdp->driMajor, &pdp->driMinor)) {
+	Xfree(pdp);
+	return NULL;
+    }
 
-   pdp->driPatch = 0;
+    pdp->driPatch = 0;
 
-   pdp->base.destroyDisplay = dri2DestroyDisplay;
-   pdp->base.createScreen = dri2CreateScreen;
+    pdp->base.destroyDisplay = dri2DestroyDisplay;
+    pdp->base.createScreen = dri2CreateScreen;
 
-   return &pdp->base;
+    return &pdp->base;
 }
 
 #endif /* GLX_DIRECT_RENDERING */
diff --git a/src/glx/x11/dri_common.c b/src/glx/x11/dri_common.c
index 4691ac7bb6d..4e535d5f10b 100644
--- a/src/glx/x11/dri_common.c
+++ b/src/glx/x11/dri_common.c
@@ -50,35 +50,33 @@
 #define RTLD_GLOBAL 0
 #endif
 
-_X_HIDDEN void
-InfoMessageF(const char *f, ...)
+_X_HIDDEN void InfoMessageF(const char *f, ...)
 {
-   va_list args;
-   const char *env;
-
-   if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
-      fprintf(stderr, "libGL: ");
-      va_start(args, f);
-      vfprintf(stderr, f, args);
-      va_end(args);
-   }
+    va_list args;
+    const char *env;
+
+    if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
+	fprintf(stderr, "libGL: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
 }
 
 /**
  * Print error to stderr, unless LIBGL_DEBUG=="quiet".
  */
-_X_HIDDEN void
-ErrorMessageF(const char *f, ...)
+_X_HIDDEN void ErrorMessageF(const char *f, ...)
 {
-   va_list args;
-   const char *env;
-
-   if ((env = getenv("LIBGL_DEBUG")) && !strstr(env, "quiet")) {
-      fprintf(stderr, "libGL error: ");
-      va_start(args, f);
-      vfprintf(stderr, f, args);
-      va_end(args);
-   }
+    va_list args;
+    const char *env;
+
+    if ((env = getenv("LIBGL_DEBUG")) && !strstr(env, "quiet")) {
+	fprintf(stderr, "libGL error: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
 }
 
 #ifndef DEFAULT_DRIVER_DIR
@@ -98,8 +96,7 @@ ErrorMessageF(const char *f, ...)
  * \returns
  * A handle from \c dlopen, or \c NULL if driver file not found.
  */
-_X_HIDDEN void *
-driOpenDriver(const char *driverName)
+_X_HIDDEN void *driOpenDriver(const char *driverName)
 {
    void *glhandle, *handle;
    const char *libPaths, *p, *next;
@@ -114,41 +111,40 @@ driOpenDriver(const char *driverName)
       /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
       libPaths = getenv("LIBGL_DRIVERS_PATH");
       if (!libPaths)
-         libPaths = getenv("LIBGL_DRIVERS_DIR");        /* deprecated */
+         libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
    }
    if (libPaths == NULL)
-      libPaths = DEFAULT_DRIVER_DIR;
+       libPaths = DEFAULT_DRIVER_DIR;
 
    handle = NULL;
    for (p = libPaths; *p; p = next) {
-      next = strchr(p, ':');
-      if (next == NULL) {
-         len = strlen(p);
-         next = p + len;
-      }
-      else {
-         len = next - p;
-         next++;
-      }
+       next = strchr(p, ':');
+       if (next == NULL) {
+	   len = strlen(p);
+	   next = p + len;
+       } else {
+	   len = next - p;
+	   next++;
+       }
 
 #ifdef GLX_USE_TLS
       snprintf(realDriverName, sizeof realDriverName,
-               "%.*s/tls/%s_dri.so", len, p, driverName);
+	       "%.*s/tls/%s_dri.so", len, p, driverName);
       InfoMessageF("OpenDriver: trying %s\n", realDriverName);
       handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
 #endif
 
-      if (handle == NULL) {
-         snprintf(realDriverName, sizeof realDriverName,
-                  "%.*s/%s_dri.so", len, p, driverName);
-         InfoMessageF("OpenDriver: trying %s\n", realDriverName);
-         handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
+      if ( handle == NULL ) {
+	 snprintf(realDriverName, sizeof realDriverName,
+		  "%.*s/%s_dri.so", len, p, driverName);
+	 InfoMessageF("OpenDriver: trying %s\n", realDriverName);
+	 handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
       }
 
-      if (handle != NULL)
-         break;
+      if ( handle != NULL )
+	  break;
       else
-         ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
+	 ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
    }
 
    if (!handle)
@@ -161,248 +157,244 @@ driOpenDriver(const char *driverName)
 }
 
 _X_HIDDEN const __DRIsystemTimeExtension systemTimeExtension = {
-   {__DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION},
-   __glXGetUST,
-   __driGetMscRateOML
+    { __DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION },
+    __glXGetUST,
+    __driGetMscRateOML
 };
 
 #define __ATTRIB(attrib, field) \
     { attrib, offsetof(__GLcontextModes, field) }
 
-static const struct
-{
-   unsigned int attrib, offset;
-} attribMap[] = {
-   __ATTRIB(__DRI_ATTRIB_BUFFER_SIZE, rgbBits),
-      __ATTRIB(__DRI_ATTRIB_LEVEL, level),
-      __ATTRIB(__DRI_ATTRIB_RED_SIZE, redBits),
-      __ATTRIB(__DRI_ATTRIB_GREEN_SIZE, greenBits),
-      __ATTRIB(__DRI_ATTRIB_BLUE_SIZE, blueBits),
-      __ATTRIB(__DRI_ATTRIB_ALPHA_SIZE, alphaBits),
-      __ATTRIB(__DRI_ATTRIB_DEPTH_SIZE, depthBits),
-      __ATTRIB(__DRI_ATTRIB_STENCIL_SIZE, stencilBits),
-      __ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE, accumRedBits),
-      __ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE, accumGreenBits),
-      __ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE, accumBlueBits),
-      __ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE, accumAlphaBits),
-      __ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS, sampleBuffers),
-      __ATTRIB(__DRI_ATTRIB_SAMPLES, samples),
-      __ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER, doubleBufferMode),
-      __ATTRIB(__DRI_ATTRIB_STEREO, stereoMode),
-      __ATTRIB(__DRI_ATTRIB_AUX_BUFFERS, numAuxBuffers),
+static const struct { unsigned int attrib, offset; } attribMap[] = {
+    __ATTRIB(__DRI_ATTRIB_BUFFER_SIZE,			rgbBits),
+    __ATTRIB(__DRI_ATTRIB_LEVEL,			level),
+    __ATTRIB(__DRI_ATTRIB_RED_SIZE,			redBits),
+    __ATTRIB(__DRI_ATTRIB_GREEN_SIZE,			greenBits),
+    __ATTRIB(__DRI_ATTRIB_BLUE_SIZE,			blueBits),
+    __ATTRIB(__DRI_ATTRIB_ALPHA_SIZE,			alphaBits),
+    __ATTRIB(__DRI_ATTRIB_DEPTH_SIZE,			depthBits),
+    __ATTRIB(__DRI_ATTRIB_STENCIL_SIZE,			stencilBits),
+    __ATTRIB(__DRI_ATTRIB_ACCUM_RED_SIZE,		accumRedBits),
+    __ATTRIB(__DRI_ATTRIB_ACCUM_GREEN_SIZE,		accumGreenBits),
+    __ATTRIB(__DRI_ATTRIB_ACCUM_BLUE_SIZE,		accumBlueBits),
+    __ATTRIB(__DRI_ATTRIB_ACCUM_ALPHA_SIZE,		accumAlphaBits),
+    __ATTRIB(__DRI_ATTRIB_SAMPLE_BUFFERS,		sampleBuffers),
+    __ATTRIB(__DRI_ATTRIB_SAMPLES,			samples),
+    __ATTRIB(__DRI_ATTRIB_DOUBLE_BUFFER,		doubleBufferMode),
+    __ATTRIB(__DRI_ATTRIB_STEREO,			stereoMode),
+    __ATTRIB(__DRI_ATTRIB_AUX_BUFFERS,			numAuxBuffers),
 #if 0
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_TYPE, transparentPixel),
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_INDEX_VALUE, transparentIndex),
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_RED_VALUE, transparentRed),
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_GREEN_VALUE, transparentGreen),
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_BLUE_VALUE, transparentBlue),
-      __ATTRIB(__DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE, transparentAlpha),
-      __ATTRIB(__DRI_ATTRIB_RED_MASK, redMask),
-      __ATTRIB(__DRI_ATTRIB_GREEN_MASK, greenMask),
-      __ATTRIB(__DRI_ATTRIB_BLUE_MASK, blueMask),
-      __ATTRIB(__DRI_ATTRIB_ALPHA_MASK, alphaMask),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_TYPE,		transparentPixel),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_INDEX_VALUE,	transparentIndex),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_RED_VALUE,	transparentRed),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_GREEN_VALUE,	transparentGreen),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_BLUE_VALUE,	transparentBlue),
+    __ATTRIB(__DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE,	transparentAlpha),
+    __ATTRIB(__DRI_ATTRIB_RED_MASK,			redMask),
+    __ATTRIB(__DRI_ATTRIB_GREEN_MASK,			greenMask),
+    __ATTRIB(__DRI_ATTRIB_BLUE_MASK,			blueMask),
+    __ATTRIB(__DRI_ATTRIB_ALPHA_MASK,			alphaMask),
 #endif
-      __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH, maxPbufferWidth),
-      __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT, maxPbufferHeight),
-      __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS, maxPbufferPixels),
-      __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH, optimalPbufferWidth),
-      __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT, optimalPbufferHeight),
+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_WIDTH,		maxPbufferWidth),
+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_HEIGHT,		maxPbufferHeight),
+    __ATTRIB(__DRI_ATTRIB_MAX_PBUFFER_PIXELS,		maxPbufferPixels),
+    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH,	optimalPbufferWidth),
+    __ATTRIB(__DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT,	optimalPbufferHeight),
 #if 0
-      __ATTRIB(__DRI_ATTRIB_SWAP_METHOD, swapMethod),
+    __ATTRIB(__DRI_ATTRIB_SWAP_METHOD,			swapMethod),
 #endif
-__ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB, bindToTextureRgb),
-      __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA, bindToTextureRgba),
-      __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,
-                     bindToMipmapTexture),
-      __ATTRIB(__DRI_ATTRIB_YINVERTED, yInverted),};
+    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGB,		bindToTextureRgb),
+    __ATTRIB(__DRI_ATTRIB_BIND_TO_TEXTURE_RGBA,		bindToTextureRgba),
+    __ATTRIB(__DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE,	bindToMipmapTexture),
+    __ATTRIB(__DRI_ATTRIB_YINVERTED,			yInverted),
+};
 
 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
 
 static int
-scalarEqual(__GLcontextModes * mode, unsigned int attrib, unsigned int value)
+scalarEqual(__GLcontextModes *mode, unsigned int attrib, unsigned int value)
 {
-   unsigned int glxValue;
-   int i;
+    unsigned int glxValue;
+    int i;
 
-   for (i = 0; i < ARRAY_SIZE(attribMap); i++)
-      if (attribMap[i].attrib == attrib) {
-         glxValue = *(unsigned int *) ((char *) mode + attribMap[i].offset);
-         return glxValue == GLX_DONT_CARE || glxValue == value;
-      }
+    for (i = 0; i < ARRAY_SIZE(attribMap); i++)
+	if (attribMap[i].attrib == attrib) {
+	    glxValue = *(unsigned int *) ((char *) mode + attribMap[i].offset);
+	    return glxValue == GLX_DONT_CARE || glxValue == value;
+	}
 
-   return GL_TRUE;              /* Is a non-existing attribute equal to value? */
+    return GL_TRUE; /* Is a non-existing attribute equal to value? */
 }
 
 static int
-driConfigEqual(const __DRIcoreExtension * core,
-               __GLcontextModes * modes, const __DRIconfig * driConfig)
+driConfigEqual(const __DRIcoreExtension *core,
+	       __GLcontextModes *modes, const __DRIconfig *driConfig)
 {
-   unsigned int attrib, value, glxValue;
-   int i;
-
-   i = 0;
-   while (core->indexConfigAttrib(driConfig, i++, &attrib, &value)) {
-      switch (attrib) {
-      case __DRI_ATTRIB_RENDER_TYPE:
-         glxValue = 0;
-         if (value & __DRI_ATTRIB_RGBA_BIT) {
-            glxValue |= GLX_RGBA_BIT;
-         }
-         else if (value & __DRI_ATTRIB_COLOR_INDEX_BIT) {
-            glxValue |= GLX_COLOR_INDEX_BIT;
-         }
-         if (glxValue != modes->renderType)
-            return GL_FALSE;
-         break;
-
-      case __DRI_ATTRIB_CONFIG_CAVEAT:
-         if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
-            glxValue = GLX_NON_CONFORMANT_CONFIG;
-         else if (value & __DRI_ATTRIB_SLOW_BIT)
-            glxValue = GLX_SLOW_CONFIG;
-         else
-            glxValue = GLX_NONE;
-         if (glxValue != modes->visualRating)
-            return GL_FALSE;
-         break;
-
-      case __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS:
-         glxValue = 0;
-         if (value & __DRI_ATTRIB_TEXTURE_1D_BIT)
-            glxValue |= GLX_TEXTURE_1D_BIT_EXT;
-         if (value & __DRI_ATTRIB_TEXTURE_2D_BIT)
-            glxValue |= GLX_TEXTURE_2D_BIT_EXT;
-         if (value & __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT)
-            glxValue |= GLX_TEXTURE_RECTANGLE_BIT_EXT;
-         if (modes->bindToTextureTargets != GLX_DONT_CARE &&
-             glxValue != modes->bindToTextureTargets)
-            return GL_FALSE;
-         break;
-
-      default:
-         if (!scalarEqual(modes, attrib, value))
-            return GL_FALSE;
-      }
-   }
-
-   return GL_TRUE;
+    unsigned int attrib, value, glxValue;
+    int i;
+
+    i = 0;
+    while (core->indexConfigAttrib(driConfig, i++, &attrib, &value)) {
+	switch (attrib) {
+	case __DRI_ATTRIB_RENDER_TYPE:
+	    glxValue = 0;
+	    if (value & __DRI_ATTRIB_RGBA_BIT) {
+		glxValue |= GLX_RGBA_BIT;
+	    } else if (value & __DRI_ATTRIB_COLOR_INDEX_BIT) {
+		glxValue |= GLX_COLOR_INDEX_BIT;
+	    }
+	    if (glxValue != modes->renderType)
+		return GL_FALSE;
+	    break;
+
+	case __DRI_ATTRIB_CONFIG_CAVEAT:
+	    if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
+		glxValue = GLX_NON_CONFORMANT_CONFIG;
+	    else if (value & __DRI_ATTRIB_SLOW_BIT)
+		glxValue = GLX_SLOW_CONFIG;
+	    else
+		glxValue = GLX_NONE;
+	    if (glxValue != modes->visualRating)
+		return GL_FALSE;
+	    break;
+
+	case __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS:
+	    glxValue = 0;
+	    if (value & __DRI_ATTRIB_TEXTURE_1D_BIT)
+		glxValue |= GLX_TEXTURE_1D_BIT_EXT;
+	    if (value & __DRI_ATTRIB_TEXTURE_2D_BIT)
+		glxValue |= GLX_TEXTURE_2D_BIT_EXT;
+	    if (value & __DRI_ATTRIB_TEXTURE_RECTANGLE_BIT)
+		glxValue |= GLX_TEXTURE_RECTANGLE_BIT_EXT;
+	    if (modes->bindToTextureTargets != GLX_DONT_CARE &&
+		glxValue != modes->bindToTextureTargets)
+		return GL_FALSE;
+	    break;	
+
+	default:
+	    if (!scalarEqual(modes, attrib, value))
+		return GL_FALSE;
+	}
+    }
+
+    return GL_TRUE;
 }
 
 static __GLcontextModes *
-createDriMode(const __DRIcoreExtension * core,
-              __GLcontextModes * modes, const __DRIconfig ** driConfigs)
+createDriMode(const __DRIcoreExtension *core,
+	      __GLcontextModes *modes, const __DRIconfig **driConfigs)
 {
-   __GLXDRIconfigPrivate *config;
-   int i;
+    __GLXDRIconfigPrivate *config;
+    int i;
 
-   for (i = 0; driConfigs[i]; i++) {
-      if (driConfigEqual(core, modes, driConfigs[i]))
-         break;
-   }
+    for (i = 0; driConfigs[i]; i++) {
+	if (driConfigEqual(core, modes, driConfigs[i]))
+	    break;
+    }
 
-   if (driConfigs[i] == NULL)
-      return NULL;
+    if (driConfigs[i] == NULL)
+	return NULL;
 
-   config = Xmalloc(sizeof *config);
-   if (config == NULL)
-      return NULL;
+    config = Xmalloc(sizeof *config);
+    if (config == NULL)
+	return NULL;
 
-   config->modes = *modes;
-   config->driConfig = driConfigs[i];
+    config->modes = *modes;
+    config->driConfig = driConfigs[i];
 
-   return &config->modes;
+    return &config->modes;
 }
 
 _X_HIDDEN __GLcontextModes *
-driConvertConfigs(const __DRIcoreExtension * core,
-                  __GLcontextModes * modes, const __DRIconfig ** configs)
+driConvertConfigs(const __DRIcoreExtension *core,
+		  __GLcontextModes *modes, const __DRIconfig **configs)
 {
-   __GLcontextModes head, *tail, *m;
-
-   tail = &head;
-   head.next = NULL;
-   for (m = modes; m; m = m->next) {
-      tail->next = createDriMode(core, m, configs);
-      if (tail->next == NULL) {
-         /* no matching dri config for m */
-         continue;
-      }
+    __GLcontextModes head, *tail, *m;
 
+    tail = &head;
+    head.next = NULL;
+    for (m = modes; m; m = m->next) {
+	tail->next = createDriMode(core, m, configs);
+	if (tail->next == NULL) {
+	    /* no matching dri config for m */
+	    continue;
+	}
 
-      tail = tail->next;
-   }
 
-   _gl_context_modes_destroy(modes);
+	tail = tail->next;
+    }
 
-   return head.next;
+    _gl_context_modes_destroy(modes);
+
+    return head.next;
 }
 
 _X_HIDDEN void
-driBindExtensions(__GLXscreenConfigs * psc, int dri2)
+driBindExtensions(__GLXscreenConfigs *psc, int dri2)
 {
-   const __DRIextension **extensions;
-   int i;
+    const __DRIextension **extensions;
+    int i;
 
-   extensions = psc->core->getExtensions(psc->__driScreen);
+    extensions = psc->core->getExtensions(psc->__driScreen);
 
-   for (i = 0; extensions[i]; i++) {
+    for (i = 0; extensions[i]; i++) {
 #ifdef __DRI_COPY_SUB_BUFFER
-      if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
-         psc->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_MESA_copy_sub_buffer_bit");
-      }
+	if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
+	    psc->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_MESA_copy_sub_buffer_bit");
+	}
 #endif
 
 #ifdef __DRI_SWAP_CONTROL
-      if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
-         psc->swapControl = (__DRIswapControlExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_SGI_swap_control");
-         __glXEnableDirectExtension(psc, "GLX_MESA_swap_control");
-      }
+	if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
+	    psc->swapControl = (__DRIswapControlExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_SGI_swap_control");
+	    __glXEnableDirectExtension(psc, "GLX_MESA_swap_control");
+	}
 #endif
 
 #ifdef __DRI_ALLOCATE
-      if (strcmp(extensions[i]->name, __DRI_ALLOCATE) == 0) {
-         psc->allocate = (__DRIallocateExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_MESA_allocate_memory");
-      }
+	if (strcmp(extensions[i]->name, __DRI_ALLOCATE) == 0) {
+	    psc->allocate = (__DRIallocateExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_MESA_allocate_memory");
+	}
 #endif
 
 #ifdef __DRI_FRAME_TRACKING
-      if (strcmp(extensions[i]->name, __DRI_FRAME_TRACKING) == 0) {
-         psc->frameTracking = (__DRIframeTrackingExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_MESA_swap_frame_usage");
-      }
+	if (strcmp(extensions[i]->name, __DRI_FRAME_TRACKING) == 0) {
+	    psc->frameTracking = (__DRIframeTrackingExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_MESA_swap_frame_usage");
+	}
 #endif
 
 #ifdef __DRI_MEDIA_STREAM_COUNTER
-      if (strcmp(extensions[i]->name, __DRI_MEDIA_STREAM_COUNTER) == 0) {
-         psc->msc = (__DRImediaStreamCounterExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_SGI_video_sync");
-      }
+	if (strcmp(extensions[i]->name, __DRI_MEDIA_STREAM_COUNTER) == 0) {
+	    psc->msc = (__DRImediaStreamCounterExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_SGI_video_sync");
+	}
 #endif
 
 #ifdef __DRI_SWAP_BUFFER_COUNTER
-      /* No driver supports this at this time and the extension is
-       * not defined in dri_interface.h.  Will enable
-       * GLX_OML_sync_control if implemented. */
+	/* No driver supports this at this time and the extension is
+	 * not defined in dri_interface.h.  Will enable
+	 * GLX_OML_sync_control if implemented. */
 #endif
 
 #ifdef __DRI_READ_DRAWABLE
-      if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
-         __glXEnableDirectExtension(psc, "GLX_SGI_make_current_read");
-      }
+	if (strcmp(extensions[i]->name, __DRI_READ_DRAWABLE) == 0) {
+	    __glXEnableDirectExtension(psc, "GLX_SGI_make_current_read");
+	}
 #endif
 
 #ifdef __DRI_TEX_BUFFER
-      if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) && dri2) {
-         psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
-         __glXEnableDirectExtension(psc, "GLX_EXT_texture_from_pixmap");
-      }
+	if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0) && dri2) {
+	    psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
+	    __glXEnableDirectExtension(psc, "GLX_EXT_texture_from_pixmap");
+	}
 #endif
 
-      /* Ignore unknown extensions */
-   }
+	/* Ignore unknown extensions */
+    }
 }
 
 #endif /* GLX_DIRECT_RENDERING */
diff --git a/src/glx/x11/dri_glx.c b/src/glx/x11/dri_glx.c
index 5160e28af70..290b87c62ea 100644
--- a/src/glx/x11/dri_glx.c
+++ b/src/glx/x11/dri_glx.c
@@ -51,24 +51,22 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate;
 typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate;
 
-struct __GLXDRIdisplayPrivateRec
-{
-   __GLXDRIdisplay base;
+struct __GLXDRIdisplayPrivateRec {
+    __GLXDRIdisplay base;
 
-   /*
+    /*
     ** XFree86-DRI version information
     */
-   int driMajor;
-   int driMinor;
-   int driPatch;
+    int driMajor;
+    int driMinor;
+    int driPatch;
 };
 
-struct __GLXDRIcontextPrivateRec
-{
-   __GLXDRIcontext base;
-   __DRIcontext *driContext;
-   XID hwContextID;
-   __GLXscreenConfigs *psc;
+struct __GLXDRIcontextPrivateRec {
+    __GLXDRIcontext base;
+    __DRIcontext *driContext;
+    XID hwContextID;
+    __GLXscreenConfigs *psc;
 };
 
 /*
@@ -76,8 +74,7 @@ struct __GLXDRIcontextPrivateRec
  * the DRI driver for the screen. (I.e. "r128", "tdfx", etc).
  * Return True for success, False for failure.
  */
-static Bool
-driGetDriverName(Display * dpy, int scrNum, char **driverName)
+static Bool driGetDriverName(Display *dpy, int scrNum, char **driverName)
 {
    int directCapable;
    Bool b;
@@ -102,7 +99,7 @@ driGetDriverName(Display * dpy, int scrNum, char **driverName)
    }
 
    InfoMessageF("XF86DRIGetClientDriverName: %d.%d.%d %s (screen %d)\n",
-                driverMajor, driverMinor, driverPatch, *driverName, scrNum);
+	     driverMajor, driverMinor, driverPatch, *driverName, scrNum);
 
    return True;
 }
@@ -113,19 +110,17 @@ driGetDriverName(Display * dpy, int scrNum, char **driverName)
  * The returned char pointer points to a static array that will be
  * overwritten by subsequent calls.
  */
-PUBLIC const char *
-glXGetScreenDriver(Display * dpy, int scrNum)
-{
+PUBLIC const char *glXGetScreenDriver (Display *dpy, int scrNum) {
    static char ret[32];
    char *driverName;
    if (driGetDriverName(dpy, scrNum, &driverName)) {
       int len;
       if (!driverName)
-         return NULL;
-      len = strlen(driverName);
+	 return NULL;
+      len = strlen (driverName);
       if (len >= 31)
-         return NULL;
-      memcpy(ret, driverName, len + 1);
+	 return NULL;
+      memcpy (ret, driverName, len+1);
       Xfree(driverName);
       return ret;
    }
@@ -143,125 +138,121 @@ glXGetScreenDriver(Display * dpy, int scrNum)
  *
  * Note: The driver remains opened after this function returns.
  */
-PUBLIC const char *
-glXGetDriverConfig(const char *driverName)
+PUBLIC const char *glXGetDriverConfig (const char *driverName)
 {
-   void *handle = driOpenDriver(driverName);
+   void *handle = driOpenDriver (driverName);
    if (handle)
-      return dlsym(handle, "__driConfigOptions");
+      return dlsym (handle, "__driConfigOptions");
    else
       return NULL;
 }
 
 #ifdef XDAMAGE_1_1_INTERFACE
 
-static GLboolean
-has_damage_post(Display * dpy)
+static GLboolean has_damage_post(Display *dpy)
 {
-   static GLboolean inited = GL_FALSE;
-   static GLboolean has_damage;
-
-   if (!inited) {
-      int major, minor;
-
-      if (XDamageQueryVersion(dpy, &major, &minor) &&
-          major == 1 && minor >= 1) {
-         has_damage = GL_TRUE;
-      }
-      else {
-         has_damage = GL_FALSE;
-      }
-      inited = GL_TRUE;
-   }
-
-   return has_damage;
+    static GLboolean inited = GL_FALSE;
+    static GLboolean has_damage;
+
+    if (!inited) {
+	int major, minor;
+
+	if (XDamageQueryVersion(dpy, &major, &minor) &&
+	    major == 1 && minor >= 1)
+	{
+	    has_damage = GL_TRUE;
+	} else {
+	    has_damage = GL_FALSE;
+	}
+	inited = GL_TRUE;
+    }
+
+    return has_damage;
 }
 
-static void
-__glXReportDamage(__DRIdrawable * driDraw,
-                  int x, int y,
-                  drm_clip_rect_t * rects, int num_rects,
-                  GLboolean front_buffer, void *loaderPrivate)
+static void __glXReportDamage(__DRIdrawable *driDraw,
+			      int x, int y,
+			      drm_clip_rect_t *rects, int num_rects,
+			      GLboolean front_buffer,
+			      void *loaderPrivate)
 {
-   XRectangle *xrects;
-   XserverRegion region;
-   int i;
-   int x_off, y_off;
-   __GLXDRIdrawable *glxDraw = loaderPrivate;
-   __GLXscreenConfigs *psc = glxDraw->psc;
-   Display *dpy = psc->dpy;
-   Drawable drawable;
-
-   if (!has_damage_post(dpy))
-      return;
-
-   if (front_buffer) {
-      x_off = x;
-      y_off = y;
-      drawable = RootWindow(dpy, psc->scr);
-   }
-   else {
-      x_off = 0;
-      y_off = 0;
-      drawable = glxDraw->xDrawable;
-   }
-
-   xrects = malloc(sizeof(XRectangle) * num_rects);
-   if (xrects == NULL)
-      return;
-
-   for (i = 0; i < num_rects; i++) {
-      xrects[i].x = rects[i].x1 + x_off;
-      xrects[i].y = rects[i].y1 + y_off;
-      xrects[i].width = rects[i].x2 - rects[i].x1;
-      xrects[i].height = rects[i].y2 - rects[i].y1;
-   }
-   region = XFixesCreateRegion(dpy, xrects, num_rects);
-   free(xrects);
-   XDamageAdd(dpy, drawable, region);
-   XFixesDestroyRegion(dpy, region);
+    XRectangle *xrects;
+    XserverRegion region;
+    int i;
+    int x_off, y_off;
+    __GLXDRIdrawable *glxDraw = loaderPrivate;
+    __GLXscreenConfigs *psc = glxDraw->psc;
+    Display *dpy = psc->dpy;
+    Drawable drawable;
+
+    if (!has_damage_post(dpy))
+	return;
+
+    if (front_buffer) {
+	x_off = x;
+	y_off = y;
+	drawable = RootWindow(dpy, psc->scr);
+    } else{
+	x_off = 0;
+	y_off = 0;
+	drawable = glxDraw->xDrawable;
+    }
+
+    xrects = malloc(sizeof(XRectangle) * num_rects);
+    if (xrects == NULL)
+	return;
+
+    for (i = 0; i < num_rects; i++) {
+	xrects[i].x = rects[i].x1 + x_off;
+	xrects[i].y = rects[i].y1 + y_off;
+	xrects[i].width = rects[i].x2 - rects[i].x1;
+	xrects[i].height = rects[i].y2 - rects[i].y1;
+    }
+    region = XFixesCreateRegion(dpy, xrects, num_rects);
+    free(xrects);
+    XDamageAdd(dpy, drawable, region);
+    XFixesDestroyRegion(dpy, region);
 }
 
 static const __DRIdamageExtension damageExtension = {
-   {__DRI_DAMAGE, __DRI_DAMAGE_VERSION},
-   __glXReportDamage,
+    { __DRI_DAMAGE, __DRI_DAMAGE_VERSION },
+    __glXReportDamage,
 };
 
 #endif
 
 static GLboolean
-__glXDRIGetDrawableInfo(__DRIdrawable * 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,
-                        void *loaderPrivate)
+__glXDRIGetDrawableInfo(__DRIdrawable *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,
+			void *loaderPrivate)
 {
-   __GLXDRIdrawable *glxDraw = loaderPrivate;
-   __GLXscreenConfigs *psc = glxDraw->psc;
-   Display *dpy = psc->dpy;
-
-   return XF86DRIGetDrawableInfo(dpy, psc->scr, glxDraw->drawable,
-                                 index, stamp, X, Y, W, H,
-                                 numClipRects, pClipRects,
-                                 backX, backY,
-                                 numBackClipRects, pBackClipRects);
+    __GLXDRIdrawable *glxDraw = loaderPrivate;
+    __GLXscreenConfigs *psc = glxDraw->psc;
+    Display *dpy = psc->dpy;
+
+    return XF86DRIGetDrawableInfo(dpy, psc->scr, glxDraw->drawable,
+				  index, stamp, X, Y, W, H,
+				  numClipRects, pClipRects,
+				  backX, backY,
+				  numBackClipRects, pBackClipRects);
 }
 
 static const __DRIgetDrawableInfoExtension getDrawableInfoExtension = {
-   {__DRI_GET_DRAWABLE_INFO, __DRI_GET_DRAWABLE_INFO_VERSION},
-   __glXDRIGetDrawableInfo
+    { __DRI_GET_DRAWABLE_INFO, __DRI_GET_DRAWABLE_INFO_VERSION },
+    __glXDRIGetDrawableInfo
 };
 
 static const __DRIextension *loader_extensions[] = {
-   &systemTimeExtension.base,
-   &getDrawableInfoExtension.base,
+    &systemTimeExtension.base,
+    &getDrawableInfoExtension.base,
 #ifdef XDAMAGE_1_1_INTERFACE
-   &damageExtension.base,
+    &damageExtension.base,
 #endif
-   NULL
+    NULL
 };
 
 #ifndef GLX_USE_APPLEGL
@@ -280,392 +271,391 @@ static const __DRIextension *loader_extensions[] = {
  *          the client-side driver on success, or \c NULL on failure.
  */
 static void *
-CallCreateNewScreen(Display * dpy, int scrn, __GLXscreenConfigs * psc,
-                    __GLXDRIdisplayPrivate * driDpy)
+CallCreateNewScreen(Display *dpy, int scrn, __GLXscreenConfigs *psc,
+		    __GLXDRIdisplayPrivate * driDpy)
 {
-   void *psp = NULL;
-   drm_handle_t hSAREA;
-   drmAddress pSAREA = MAP_FAILED;
-   char *BusID;
-   __DRIversion ddx_version;
-   __DRIversion dri_version;
-   __DRIversion drm_version;
-   __DRIframebuffer framebuffer;
-   int fd = -1;
-   int status;
-
-   drm_magic_t magic;
-   drmVersionPtr version;
-   int newlyopened;
-   char *driverName;
-   drm_handle_t hFB;
-   int junk;
-   const __DRIconfig **driver_configs;
-
-   /* DRI protocol version. */
-   dri_version.major = driDpy->driMajor;
-   dri_version.minor = driDpy->driMinor;
-   dri_version.patch = driDpy->driPatch;
-
-   framebuffer.base = MAP_FAILED;
-   framebuffer.dev_priv = NULL;
-
-   if (!XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
-      ErrorMessageF("XF86DRIOpenConnection failed\n");
-      goto handle_error;
-   }
-
-   fd = drmOpenOnce(NULL, BusID, &newlyopened);
-
-   Xfree(BusID);                /* No longer needed */
-
-   if (fd < 0) {
-      ErrorMessageF("drmOpenOnce failed (%s)\n", strerror(-fd));
-      goto handle_error;
-   }
-
-   if (drmGetMagic(fd, &magic)) {
-      ErrorMessageF("drmGetMagic failed\n");
-      goto handle_error;
-   }
-
-   version = drmGetVersion(fd);
-   if (version) {
-      drm_version.major = version->version_major;
-      drm_version.minor = version->version_minor;
-      drm_version.patch = version->version_patchlevel;
-      drmFreeVersion(version);
-   }
-   else {
-      drm_version.major = -1;
-      drm_version.minor = -1;
-      drm_version.patch = -1;
-   }
-
-   if (newlyopened && !XF86DRIAuthConnection(dpy, scrn, magic)) {
-      ErrorMessageF("XF86DRIAuthConnection failed\n");
-      goto handle_error;
-   }
-
-   /* Get device name (like "tdfx") and the ddx version numbers.
-    * We'll check the version in each DRI driver's "createNewScreen"
-    * function. */
-   if (!XF86DRIGetClientDriverName(dpy, scrn,
-                                   &ddx_version.major,
-                                   &ddx_version.minor,
-                                   &ddx_version.patch, &driverName)) {
-      ErrorMessageF("XF86DRIGetClientDriverName failed\n");
-      goto handle_error;
-   }
-
-   Xfree(driverName);           /* No longer needed. */
-
-   /*
-    * Get device-specific info.  pDevPriv will point to a struct
-    * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h) that
-    * has information about the screen size, depth, pitch, ancilliary
-    * buffers, DRM mmap handles, etc.
-    */
-   if (!XF86DRIGetDeviceInfo(dpy, scrn, &hFB, &junk,
-                             &framebuffer.size, &framebuffer.stride,
-                             &framebuffer.dev_priv_size,
-                             &framebuffer.dev_priv)) {
-      ErrorMessageF("XF86DRIGetDeviceInfo failed");
-      goto handle_error;
-   }
-
-   framebuffer.width = DisplayWidth(dpy, scrn);
-   framebuffer.height = DisplayHeight(dpy, scrn);
-
-   /* Map the framebuffer region. */
-   status = drmMap(fd, hFB, framebuffer.size,
-                   (drmAddressPtr) & framebuffer.base);
-   if (status != 0) {
-      ErrorMessageF("drmMap of framebuffer failed (%s)", strerror(-status));
-      goto handle_error;
-   }
-
-   /* Map the SAREA region.  Further mmap regions may be setup in
-    * each DRI driver's "createNewScreen" function.
-    */
-   status = drmMap(fd, hSAREA, SAREA_MAX, &pSAREA);
-   if (status != 0) {
-      ErrorMessageF("drmMap of SAREA failed (%s)", strerror(-status));
-      goto handle_error;
-   }
-
-   psp = (*psc->legacy->createNewScreen) (scrn,
-                                          &ddx_version,
-                                          &dri_version,
-                                          &drm_version,
-                                          &framebuffer,
-                                          pSAREA,
-                                          fd,
-                                          loader_extensions,
-                                          &driver_configs, psc);
-
-   if (psp == NULL) {
-      ErrorMessageF("Calling driver entry point failed");
-      goto handle_error;
-   }
-
-   psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs);
-   psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs);
-
-   return psp;
+    void *psp = NULL;
+    drm_handle_t hSAREA;
+    drmAddress pSAREA = MAP_FAILED;
+    char *BusID;
+    __DRIversion   ddx_version;
+    __DRIversion   dri_version;
+    __DRIversion   drm_version;
+    __DRIframebuffer  framebuffer;
+    int   fd = -1;
+    int   status;
+
+    drm_magic_t magic;
+    drmVersionPtr version;
+    int newlyopened;
+    char *driverName;
+    drm_handle_t  hFB;
+    int        junk;
+    const __DRIconfig **driver_configs;
+
+    /* DRI protocol version. */
+    dri_version.major = driDpy->driMajor;
+    dri_version.minor = driDpy->driMinor;
+    dri_version.patch = driDpy->driPatch;
+
+    framebuffer.base = MAP_FAILED;
+    framebuffer.dev_priv = NULL;
+
+    if (!XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
+	ErrorMessageF("XF86DRIOpenConnection failed\n");
+	goto handle_error;
+    }
+
+    fd = drmOpenOnce(NULL, BusID, &newlyopened);
+
+    Xfree(BusID); /* No longer needed */
+
+    if (fd < 0) {
+	ErrorMessageF("drmOpenOnce failed (%s)\n", strerror(-fd));
+	goto handle_error;
+    }
+
+    if (drmGetMagic(fd, &magic)) {
+	ErrorMessageF("drmGetMagic failed\n");
+	goto handle_error;
+    }
+
+    version = drmGetVersion(fd);
+    if (version) {
+	drm_version.major = version->version_major;
+	drm_version.minor = version->version_minor;
+	drm_version.patch = version->version_patchlevel;
+	drmFreeVersion(version);
+    }
+    else {
+	drm_version.major = -1;
+	drm_version.minor = -1;
+	drm_version.patch = -1;
+    }
+
+    if (newlyopened && !XF86DRIAuthConnection(dpy, scrn, magic)) {
+	ErrorMessageF("XF86DRIAuthConnection failed\n");
+	goto handle_error;
+    }
+
+    /* Get device name (like "tdfx") and the ddx version numbers.
+     * We'll check the version in each DRI driver's "createNewScreen"
+     * function. */
+    if (!XF86DRIGetClientDriverName(dpy, scrn,
+				    &ddx_version.major,
+				    &ddx_version.minor,
+				    &ddx_version.patch,
+				    &driverName)) {
+	ErrorMessageF("XF86DRIGetClientDriverName failed\n");
+	goto handle_error;
+    }
+
+    Xfree(driverName); /* No longer needed. */
+
+    /*
+     * Get device-specific info.  pDevPriv will point to a struct
+     * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h) that
+     * has information about the screen size, depth, pitch, ancilliary
+     * buffers, DRM mmap handles, etc.
+     */
+    if (!XF86DRIGetDeviceInfo(dpy, scrn, &hFB, &junk,
+			      &framebuffer.size, &framebuffer.stride,
+			      &framebuffer.dev_priv_size, &framebuffer.dev_priv)) {
+	ErrorMessageF("XF86DRIGetDeviceInfo failed");
+	goto handle_error;
+    }
+
+    framebuffer.width = DisplayWidth(dpy, scrn);
+    framebuffer.height = DisplayHeight(dpy, scrn);
+
+    /* Map the framebuffer region. */
+    status = drmMap(fd, hFB, framebuffer.size, 
+		    (drmAddressPtr)&framebuffer.base);
+    if (status != 0) {
+	ErrorMessageF("drmMap of framebuffer failed (%s)", strerror(-status));
+	goto handle_error;
+    }
+
+    /* Map the SAREA region.  Further mmap regions may be setup in
+     * each DRI driver's "createNewScreen" function.
+     */
+    status = drmMap(fd, hSAREA, SAREA_MAX, &pSAREA);
+    if (status != 0) {
+	ErrorMessageF("drmMap of SAREA failed (%s)", strerror(-status));
+	goto handle_error;
+    }
+
+    psp = (*psc->legacy->createNewScreen)(scrn,
+					  &ddx_version,
+					  &dri_version,
+					  &drm_version,
+					  &framebuffer,
+					  pSAREA,
+					  fd,
+					  loader_extensions,
+					  &driver_configs,
+					  psc);
+
+    if (psp == NULL) {
+	ErrorMessageF("Calling driver entry point failed");
+	goto handle_error;
+    }
+
+    psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs);
+    psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs);
+
+    return psp;
 
  handle_error:
-   if (pSAREA != MAP_FAILED)
-      drmUnmap(pSAREA, SAREA_MAX);
+    if (pSAREA != MAP_FAILED)
+	drmUnmap(pSAREA, SAREA_MAX);
 
-   if (framebuffer.base != MAP_FAILED)
-      drmUnmap((drmAddress) framebuffer.base, framebuffer.size);
+    if (framebuffer.base != MAP_FAILED)
+	drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
 
-   if (framebuffer.dev_priv != NULL)
-      Xfree(framebuffer.dev_priv);
+    if (framebuffer.dev_priv != NULL)
+	Xfree(framebuffer.dev_priv);
 
-   if (fd >= 0)
-      drmCloseOnce(fd);
+    if (fd >= 0)
+	drmCloseOnce(fd);
 
-   XF86DRICloseConnection(dpy, scrn);
+    XF86DRICloseConnection(dpy, scrn);
 
-   ErrorMessageF("reverting to software direct rendering\n");
+    ErrorMessageF("reverting to software direct rendering\n");
 
-   return NULL;
+    return NULL;
 }
 
 #else /* !GLX_USE_APPLEGL */
 
 static void *
-CallCreateNewScreen(Display * dpy, int scrn, __GLXscreenConfigs * psc,
-                    __GLXDRIdisplayPrivate * driDpy)
+CallCreateNewScreen(Display *dpy, int scrn, __GLXscreenConfigs *psc,
+		    __GLXDRIdisplayPrivate * driDpy)
 {
-   return NULL;
+    return NULL;
 }
 
 #endif /* !GLX_USE_APPLEGL */
 
-static void
-driDestroyContext(__GLXDRIcontext * context,
-                  __GLXscreenConfigs * psc, Display * dpy)
+static void driDestroyContext(__GLXDRIcontext *context,
+			      __GLXscreenConfigs *psc, Display *dpy)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+			
+    (*psc->core->destroyContext)(pcp->driContext);
 
-   (*psc->core->destroyContext) (pcp->driContext);
-
-   XF86DRIDestroyContext(psc->dpy, psc->scr, pcp->hwContextID);
-   Xfree(pcp);
+    XF86DRIDestroyContext(psc->dpy, psc->scr, pcp->hwContextID);
+    Xfree(pcp);
 }
 
-static Bool
-driBindContext(__GLXDRIcontext * context,
-               __GLXDRIdrawable * draw, __GLXDRIdrawable * read)
+static Bool driBindContext(__GLXDRIcontext *context,
+			   __GLXDRIdrawable *draw, __GLXDRIdrawable *read)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
-   const __DRIcoreExtension *core = pcp->psc->core;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    const __DRIcoreExtension *core = pcp->psc->core;
 
-   return (*core->bindContext) (pcp->driContext,
-                                draw->driDrawable, read->driDrawable);
+    return (*core->bindContext)(pcp->driContext,
+				draw->driDrawable,
+				read->driDrawable);
 }
 
-static void
-driUnbindContext(__GLXDRIcontext * context)
+static void driUnbindContext(__GLXDRIcontext *context)
 {
-   __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
-   const __DRIcoreExtension *core = pcp->psc->core;
+    __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context;
+    const __DRIcoreExtension *core = pcp->psc->core;
 
-   (*core->unbindContext) (pcp->driContext);
+    (*core->unbindContext)(pcp->driContext);
 }
 
-static __GLXDRIcontext *
-driCreateContext(__GLXscreenConfigs * psc,
-                 const __GLcontextModes * mode,
-                 GLXContext gc, GLXContext shareList, int renderType)
+static __GLXDRIcontext *driCreateContext(__GLXscreenConfigs *psc,
+					 const __GLcontextModes *mode,
+					 GLXContext gc,
+					 GLXContext shareList, int renderType)
 {
-   __GLXDRIcontextPrivate *pcp, *pcp_shared;
-   drm_context_t hwContext;
-   __DRIcontext *shared = NULL;
-   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode;
-
-   if (!psc || !psc->driScreen)
-      return NULL;
-
-   if (shareList) {
-      pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext;
-      shared = pcp_shared->driContext;
-   }
-
-   pcp = Xmalloc(sizeof *pcp);
-   if (pcp == NULL)
-      return NULL;
-
-   pcp->psc = psc;
-   if (!XF86DRICreateContextWithConfig(psc->dpy, psc->scr,
-                                       mode->visualID,
-                                       &pcp->hwContextID, &hwContext)) {
-      Xfree(pcp);
-      return NULL;
-   }
-
-   pcp->driContext =
-      (*psc->legacy->createNewContext) (psc->__driScreen,
-                                        config->driConfig,
-                                        renderType, shared, hwContext, pcp);
-   if (pcp->driContext == NULL) {
-      XF86DRIDestroyContext(psc->dpy, psc->scr, pcp->hwContextID);
-      Xfree(pcp);
-      return NULL;
-   }
-
-   pcp->base.destroyContext = driDestroyContext;
-   pcp->base.bindContext = driBindContext;
-   pcp->base.unbindContext = driUnbindContext;
-
-   return &pcp->base;
+    __GLXDRIcontextPrivate *pcp, *pcp_shared;
+    drm_context_t hwContext;
+    __DRIcontext *shared = NULL;
+    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode;
+
+    if (!psc || !psc->driScreen)
+	return NULL;
+
+    if (shareList) {
+	pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext;
+	shared = pcp_shared->driContext;
+    }
+
+    pcp = Xmalloc(sizeof *pcp);
+    if (pcp == NULL)
+	return NULL;
+
+    pcp->psc = psc;
+    if (!XF86DRICreateContextWithConfig(psc->dpy, psc->scr,
+					mode->visualID,
+					&pcp->hwContextID, &hwContext)) {
+	Xfree(pcp);
+	return NULL;
+    }
+
+    pcp->driContext =
+        (*psc->legacy->createNewContext)(psc->__driScreen,
+					 config->driConfig,
+					 renderType,
+					 shared,
+					 hwContext,
+					 pcp);
+    if (pcp->driContext == NULL) {
+	XF86DRIDestroyContext(psc->dpy, psc->scr, pcp->hwContextID);
+	Xfree(pcp);
+	return NULL;
+    }
+
+    pcp->base.destroyContext = driDestroyContext;
+    pcp->base.bindContext = driBindContext;
+    pcp->base.unbindContext = driUnbindContext;
+
+    return &pcp->base;
 }
 
-static void
-driDestroyDrawable(__GLXDRIdrawable * pdraw)
+static void driDestroyDrawable(__GLXDRIdrawable *pdraw)
 {
-   __GLXscreenConfigs *psc = pdraw->psc;
+    __GLXscreenConfigs *psc = pdraw->psc;
 
-   (*psc->core->destroyDrawable) (pdraw->driDrawable);
-   XF86DRIDestroyDrawable(psc->dpy, psc->scr, pdraw->drawable);
-   Xfree(pdraw);
+    (*psc->core->destroyDrawable)(pdraw->driDrawable);
+    XF86DRIDestroyDrawable(psc->dpy, psc->scr, pdraw->drawable);
+    Xfree(pdraw);
 }
 
-static __GLXDRIdrawable *
-driCreateDrawable(__GLXscreenConfigs * psc,
-                  XID xDrawable,
-                  GLXDrawable drawable, const __GLcontextModes * modes)
+static __GLXDRIdrawable *driCreateDrawable(__GLXscreenConfigs *psc,
+					   XID xDrawable,
+					   GLXDrawable drawable,
+					   const __GLcontextModes *modes)
 {
-   __GLXDRIdrawable *pdraw;
-   drm_drawable_t hwDrawable;
-   void *empty_attribute_list = NULL;
-   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
-
-   /* Old dri can't handle GLX 1.3+ drawable constructors. */
-   if (xDrawable != drawable)
-      return NULL;
-
-   pdraw = Xmalloc(sizeof(*pdraw));
-   if (!pdraw)
-      return NULL;
-
-   pdraw->drawable = drawable;
-   pdraw->psc = psc;
-
-   if (!XF86DRICreateDrawable(psc->dpy, psc->scr, drawable, &hwDrawable))
-      return NULL;
-
-   /* Create a new drawable */
-   pdraw->driDrawable =
-      (*psc->legacy->createNewDrawable) (psc->__driScreen,
-                                         config->driConfig,
-                                         hwDrawable,
-                                         GLX_WINDOW_BIT,
-                                         empty_attribute_list, pdraw);
-
-   if (!pdraw->driDrawable) {
-      XF86DRIDestroyDrawable(psc->dpy, psc->scr, drawable);
-      Xfree(pdraw);
-      return NULL;
-   }
-
-   pdraw->destroyDrawable = driDestroyDrawable;
-
-   return pdraw;
+    __GLXDRIdrawable *pdraw;
+    drm_drawable_t hwDrawable;
+    void *empty_attribute_list = NULL;
+    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
+
+    /* Old dri can't handle GLX 1.3+ drawable constructors. */
+    if (xDrawable != drawable)
+	return NULL;
+
+    pdraw = Xmalloc(sizeof(*pdraw));
+    if (!pdraw)
+	return NULL;
+
+    pdraw->drawable = drawable;
+    pdraw->psc = psc;
+
+    if (!XF86DRICreateDrawable(psc->dpy, psc->scr, drawable, &hwDrawable))
+	return NULL;
+
+    /* Create a new drawable */
+    pdraw->driDrawable =
+	(*psc->legacy->createNewDrawable)(psc->__driScreen,
+					  config->driConfig,
+					  hwDrawable,
+					  GLX_WINDOW_BIT,
+					  empty_attribute_list,
+					  pdraw);
+
+    if (!pdraw->driDrawable) {
+	XF86DRIDestroyDrawable(psc->dpy, psc->scr, drawable);
+	Xfree(pdraw);
+	return NULL;
+    }
+
+    pdraw->destroyDrawable = driDestroyDrawable;
+
+    return pdraw;
 }
 
-static void
-driSwapBuffers(__GLXDRIdrawable * pdraw)
+static void driSwapBuffers(__GLXDRIdrawable *pdraw)
 {
-   (*pdraw->psc->core->swapBuffers) (pdraw->driDrawable);
+   (*pdraw->psc->core->swapBuffers)(pdraw->driDrawable);
 }
 
-static void
-driDestroyScreen(__GLXscreenConfigs * psc)
+static void driDestroyScreen(__GLXscreenConfigs *psc)
 {
-   /* Free the direct rendering per screen data */
-   if (psc->__driScreen)
-      (*psc->core->destroyScreen) (psc->__driScreen);
-   psc->__driScreen = NULL;
-   if (psc->driver)
-      dlclose(psc->driver);
+    /* Free the direct rendering per screen data */
+    if (psc->__driScreen)
+	(*psc->core->destroyScreen)(psc->__driScreen);
+    psc->__driScreen = NULL;
+    if (psc->driver)
+	dlclose(psc->driver);
 }
 
-static __GLXDRIscreen *
-driCreateScreen(__GLXscreenConfigs * psc, int screen,
-                __GLXdisplayPrivate * priv)
+static __GLXDRIscreen *driCreateScreen(__GLXscreenConfigs *psc, int screen,
+				       __GLXdisplayPrivate *priv)
 {
-   __GLXDRIdisplayPrivate *pdp;
-   __GLXDRIscreen *psp;
-   const __DRIextension **extensions;
-   char *driverName;
-   int i;
-
-   psp = Xmalloc(sizeof *psp);
-   if (psp == NULL)
-      return NULL;
-
-   /* Initialize per screen dynamic client GLX extensions */
-   psc->ext_list_first_time = GL_TRUE;
-
-   if (!driGetDriverName(priv->dpy, screen, &driverName)) {
-      Xfree(psp);
-      return NULL;
-   }
-
-   psc->driver = driOpenDriver(driverName);
-   Xfree(driverName);
-   if (psc->driver == NULL) {
-      Xfree(psp);
-      return NULL;
-   }
-
-   extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
-   if (extensions == NULL) {
-      ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
-      Xfree(psp);
-      return NULL;
-   }
-
-   for (i = 0; extensions[i]; i++) {
-      if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
-         psc->core = (__DRIcoreExtension *) extensions[i];
-      if (strcmp(extensions[i]->name, __DRI_LEGACY) == 0)
-         psc->legacy = (__DRIlegacyExtension *) extensions[i];
-   }
-
-   if (psc->core == NULL || psc->legacy == NULL) {
-      Xfree(psp);
-      return NULL;
-   }
-
-   pdp = (__GLXDRIdisplayPrivate *) priv->driDisplay;
-   psc->__driScreen = CallCreateNewScreen(psc->dpy, screen, psc, pdp);
-   if (psc->__driScreen == NULL) {
-      dlclose(psc->driver);
-      Xfree(psp);
-      return NULL;
-   }
-
-   driBindExtensions(psc, 0);
-
-   psp->destroyScreen = driDestroyScreen;
-   psp->createContext = driCreateContext;
-   psp->createDrawable = driCreateDrawable;
-   psp->swapBuffers = driSwapBuffers;
-
-   return psp;
+    __GLXDRIdisplayPrivate *pdp;
+    __GLXDRIscreen *psp;
+    const __DRIextension **extensions;
+    char *driverName;
+    int i;
+
+    psp = Xmalloc(sizeof *psp);
+    if (psp == NULL)
+	return NULL;
+
+    /* Initialize per screen dynamic client GLX extensions */
+    psc->ext_list_first_time = GL_TRUE;
+
+    if (!driGetDriverName(priv->dpy, screen, &driverName)) {
+	Xfree(psp);
+	return NULL;
+    }
+
+    psc->driver = driOpenDriver(driverName);
+    Xfree(driverName);
+    if (psc->driver == NULL) {
+	Xfree(psp);
+	return NULL;
+    }
+
+    extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
+    if (extensions == NULL) {
+ 	ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
+	Xfree(psp);
+	return NULL;
+    }
+
+    for (i = 0; extensions[i]; i++) {
+	if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
+	    psc->core = (__DRIcoreExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_LEGACY) == 0)
+	    psc->legacy = (__DRIlegacyExtension *) extensions[i];
+    }
+
+    if (psc->core == NULL || psc->legacy == NULL) {
+	Xfree(psp);
+	return NULL;
+    }
+  
+    pdp = (__GLXDRIdisplayPrivate *) priv->driDisplay;
+    psc->__driScreen =
+ 	CallCreateNewScreen(psc->dpy, screen, psc, pdp);
+    if (psc->__driScreen == NULL) {
+ 	dlclose(psc->driver);
+ 	Xfree(psp);
+ 	return NULL;
+    }
+
+    driBindExtensions(psc, 0);
+
+    psp->destroyScreen = driDestroyScreen;
+    psp->createContext = driCreateContext;
+    psp->createDrawable = driCreateDrawable;
+    psp->swapBuffers = driSwapBuffers;
+
+    return psp;
 }
 
 /* Called from __glXFreeDisplayPrivate.
  */
-static void
-driDestroyDisplay(__GLXDRIdisplay * dpy)
+static void driDestroyDisplay(__GLXDRIdisplay *dpy)
 {
-   Xfree(dpy);
+    Xfree(dpy);
 }
 
 /*
@@ -673,34 +663,33 @@ driDestroyDisplay(__GLXDRIdisplay * dpy)
  * This is called from __glXInitialize() when we are given a new
  * display pointer.
  */
-_X_HIDDEN __GLXDRIdisplay *
-driCreateDisplay(Display * dpy)
+_X_HIDDEN __GLXDRIdisplay *driCreateDisplay(Display *dpy)
 {
-   __GLXDRIdisplayPrivate *pdpyp;
-   int eventBase, errorBase;
-   int major, minor, patch;
+    __GLXDRIdisplayPrivate *pdpyp;
+    int eventBase, errorBase;
+    int major, minor, patch;
 
-   if (!XF86DRIQueryExtension(dpy, &eventBase, &errorBase)) {
-      return NULL;
-   }
+    if (!XF86DRIQueryExtension(dpy, &eventBase, &errorBase)) {
+	return NULL;
+    }
 
-   if (!XF86DRIQueryVersion(dpy, &major, &minor, &patch)) {
-      return NULL;
-   }
+    if (!XF86DRIQueryVersion(dpy, &major, &minor, &patch)) {
+	return NULL;
+    }
 
-   pdpyp = Xmalloc(sizeof *pdpyp);
-   if (!pdpyp) {
-      return NULL;
-   }
+    pdpyp = Xmalloc(sizeof *pdpyp);
+    if (!pdpyp) {
+	return NULL;
+    }
 
-   pdpyp->driMajor = major;
-   pdpyp->driMinor = minor;
-   pdpyp->driPatch = patch;
+    pdpyp->driMajor = major;
+    pdpyp->driMinor = minor;
+    pdpyp->driPatch = patch;
 
-   pdpyp->base.destroyDisplay = driDestroyDisplay;
-   pdpyp->base.createScreen = driCreateScreen;
+    pdpyp->base.destroyDisplay = driDestroyDisplay;
+    pdpyp->base.createScreen = driCreateScreen;
 
-   return &pdpyp->base;
+    return &pdpyp->base;
 }
 
 #endif /* GLX_DIRECT_RENDERING */
diff --git a/src/glx/x11/glxclient.h b/src/glx/x11/glxclient.h
index 93fb7fb2d7d..06010b4bf00 100644
--- a/src/glx/x11/glxclient.h
+++ b/src/glx/x11/glxclient.h
@@ -81,7 +81,7 @@
 
 
 
-#define GLX_MAJOR_VERSION	1       /* current version numbers */
+#define GLX_MAJOR_VERSION	1	/* current version numbers */
 #define GLX_MINOR_VERSION	4
 
 #define __GLX_MAX_TEXTURE_UNITS 32
@@ -113,73 +113,70 @@ typedef struct __GLXDRIcontextRec __GLXDRIcontext;
 
 #include "glxextensions.h"
 
-struct __GLXDRIdisplayRec
-{
+struct __GLXDRIdisplayRec {
     /**
      * Method to destroy the private DRI display data.
      */
-   void (*destroyDisplay) (__GLXDRIdisplay * display);
+    void (*destroyDisplay)(__GLXDRIdisplay *display);
 
-   __GLXDRIscreen *(*createScreen) (__GLXscreenConfigs * psc, int screen,
-                                    __GLXdisplayPrivate * priv);
+    __GLXDRIscreen *(*createScreen)(__GLXscreenConfigs *psc, int screen,
+				    __GLXdisplayPrivate *priv);
 };
 
-struct __GLXDRIscreenRec
-{
+struct __GLXDRIscreenRec {
 
-   void (*destroyScreen) (__GLXscreenConfigs * psc);
+    void (*destroyScreen)(__GLXscreenConfigs *psc);
 
-   __GLXDRIcontext *(*createContext) (__GLXscreenConfigs * psc,
-                                      const __GLcontextModes * mode,
-                                      GLXContext gc,
-                                      GLXContext shareList, int renderType);
+    __GLXDRIcontext *(*createContext)(__GLXscreenConfigs *psc,
+				      const __GLcontextModes *mode,
+				      GLXContext gc,
+				      GLXContext shareList, int renderType);
+	
+    __GLXDRIdrawable *(*createDrawable)(__GLXscreenConfigs *psc,
+					XID drawable,
+					GLXDrawable glxDrawable,
+					const __GLcontextModes *modes);
 
-   __GLXDRIdrawable *(*createDrawable) (__GLXscreenConfigs * psc,
-                                        XID drawable,
-                                        GLXDrawable glxDrawable,
-                                        const __GLcontextModes * modes);
-
-   void (*swapBuffers) (__GLXDRIdrawable * pdraw);
+    void (*swapBuffers)(__GLXDRIdrawable *pdraw);
 };
 
-struct __GLXDRIcontextRec
-{
-   void (*destroyContext) (__GLXDRIcontext * context,
-                           __GLXscreenConfigs * psc, Display * dpy);
-     Bool(*bindContext) (__GLXDRIcontext * context, __GLXDRIdrawable * pdraw,
-                         __GLXDRIdrawable * pread);
-
-   void (*unbindContext) (__GLXDRIcontext * context);
+struct __GLXDRIcontextRec {
+    void (*destroyContext)(__GLXDRIcontext *context, __GLXscreenConfigs *psc,
+			   Display *dpy);
+    Bool (*bindContext)(__GLXDRIcontext *context,
+			__GLXDRIdrawable *pdraw,
+			__GLXDRIdrawable *pread);
+    
+    void (*unbindContext)(__GLXDRIcontext *context);
 };
 
-struct __GLXDRIdrawableRec
-{
-   void (*destroyDrawable) (__GLXDRIdrawable * drawable);
+struct __GLXDRIdrawableRec {
+    void (*destroyDrawable)(__GLXDRIdrawable *drawable);
 
-   XID xDrawable;
-   XID drawable;
-   __GLXscreenConfigs *psc;
-   GLenum textureTarget;
-   __DRIdrawable *driDrawable;
+    XID xDrawable;
+    XID drawable;
+    __GLXscreenConfigs *psc;
+    GLenum textureTarget;
+    __DRIdrawable *driDrawable;
 };
 
 /*
 ** Function to create and DRI display data and initialize the display
 ** dependent methods.
 */
-extern __GLXDRIdisplay *driswCreateDisplay(Display * dpy);
-extern __GLXDRIdisplay *driCreateDisplay(Display * dpy);
-extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy);
+extern __GLXDRIdisplay *driswCreateDisplay(Display *dpy);
+extern __GLXDRIdisplay *driCreateDisplay(Display *dpy);
+extern __GLXDRIdisplay *dri2CreateDisplay(Display *dpy);
 
-extern void DRI_glXUseXFont(Font font, int first, int count, int listbase);
+extern void DRI_glXUseXFont( Font font, int first, int count, int listbase );
 
 /*
 ** Functions to obtain driver configuration information from a direct
 ** rendering client application
 */
-extern const char *glXGetScreenDriver(Display * dpy, int scrNum);
+extern const char *glXGetScreenDriver (Display *dpy, int scrNum);
 
-extern const char *glXGetDriverConfig(const char *driverName);
+extern const char *glXGetDriverConfig (const char *driverName);
 
 #endif
 
@@ -187,57 +184,53 @@ extern const char *glXGetDriverConfig(const char *driverName);
 
 #define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
 
-typedef struct __GLXpixelStoreModeRec
-{
-   GLboolean swapEndian;
-   GLboolean lsbFirst;
-   GLuint rowLength;
-   GLuint imageHeight;
-   GLuint imageDepth;
-   GLuint skipRows;
-   GLuint skipPixels;
-   GLuint skipImages;
-   GLuint alignment;
+typedef struct __GLXpixelStoreModeRec {
+    GLboolean swapEndian;
+    GLboolean lsbFirst;
+    GLuint rowLength;
+    GLuint imageHeight;
+    GLuint imageDepth;
+    GLuint skipRows;
+    GLuint skipPixels;
+    GLuint skipImages;
+    GLuint alignment;
 } __GLXpixelStoreMode;
 
 
-typedef struct __GLXattributeRec
-{
-   GLuint mask;
+typedef struct __GLXattributeRec {
+    GLuint mask;
 
     /**
      * Pixel storage state.  Most of the pixel store mode state is kept
      * here and used by the client code to manage the packing and
      * unpacking of data sent to/received from the server.
      */
-   __GLXpixelStoreMode storePack, storeUnpack;
+    __GLXpixelStoreMode storePack, storeUnpack;
 
     /**
      * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
      * disabled?
      */
-   GLboolean NoDrawArraysProtocol;
-
+    GLboolean NoDrawArraysProtocol;
+    
     /**
      * Vertex Array storage state.  The vertex array component
      * state is stored here and is used to manage the packing of
      * DrawArrays data sent to the server.
      */
-   struct array_state_vector *array_state;
+    struct array_state_vector * array_state;
 } __GLXattribute;
 
-typedef struct __GLXattributeMachineRec
-{
-   __GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
-   __GLXattribute **stackPointer;
+typedef struct __GLXattributeMachineRec {
+	__GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
+	__GLXattribute **stackPointer;
 } __GLXattributeMachine;
 
 /**
  * GLX state that needs to be kept on the client.  One of these records
  * exist for each context that has been made current by this client.
  */
-struct __GLXcontextRec
-{
+struct __GLXcontextRec {
     /**
      * \name Drawing command buffer.
      *
@@ -254,13 +247,13 @@ struct __GLXcontextRec
      * These must be the first 6 fields since they are static initialized
      * in the dummy context in glxext.c
      */
-   /*@{ */
-   GLubyte *buf;
-   GLubyte *pc;
-   GLubyte *limit;
-   GLubyte *bufEnd;
-   GLint bufSize;
-   /*@} */
+    /*@{*/
+    GLubyte *buf;
+    GLubyte *pc;
+    GLubyte *limit;
+    GLubyte *bufEnd;
+    GLint bufSize;
+    /*@}*/
 
     /**
      * The XID of this rendering context.  When the context is created a
@@ -268,24 +261,24 @@ struct __GLXcontextRec
      * destroyed but is still current to some thread. In this case the
      * context will be freed on next MakeCurrent.
      */
-   XID xid;
+    XID xid;
 
     /**
      * The XID of the \c shareList context.
      */
-   XID share_xid;
+    XID share_xid;
 
     /**
      * Screen number.
      */
-   GLint screen;
-   __GLXscreenConfigs *psc;
+    GLint screen;
+    __GLXscreenConfigs *psc;
 
     /**
      * \c GL_TRUE if the context was created with ImportContext, which
      * means the server-side context was created by another X client.
      */
-   GLboolean imported;
+    GLboolean imported;
 
     /**
      * The context tag returned by MakeCurrent when this context is made
@@ -295,7 +288,7 @@ struct __GLXcontextRec
      * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
      * context)).
      */
-   GLXContextTag currentContextTag;
+    GLXContextTag currentContextTag;
 
     /**
      * \name Rendering mode
@@ -304,11 +297,11 @@ struct __GLXcontextRec
      * When \c glRenderMode is called, the buffer associated with the
      * previous rendering mode (feedback or select) is filled.
      */
-   /*@{ */
-   GLenum renderMode;
-   GLfloat *feedbackBuf;
-   GLuint *selectBuf;
-   /*@} */
+    /*@{*/
+    GLenum renderMode;
+    GLfloat *feedbackBuf;
+    GLuint *selectBuf;
+    /*@}*/
 
     /**
      * This is \c GL_TRUE if the pixel unpack modes are such that an image
@@ -316,43 +309,43 @@ struct __GLXcontextRec
      * still be true that the server will have to do some work.  This
      * just promises that a straight copy will fetch the correct bytes.
      */
-   GLboolean fastImageUnpack;
+    GLboolean fastImageUnpack;
 
     /**
      * Fill newImage with the unpacked form of \c oldImage getting it
      * ready for transport to the server.
      */
-   void (*fillImage) (__GLXcontext *, GLint, GLint, GLint, GLint, GLenum,
-                      GLenum, const GLvoid *, GLubyte *, GLubyte *);
+    void (*fillImage)(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		      GLenum, const GLvoid*, GLubyte*, GLubyte*);
 
     /**
      * Client side attribs.
      */
-   __GLXattributeMachine attributes;
+    __GLXattributeMachine attributes;
 
     /**
      * Client side error code.  This is set when client side gl API
      * routines need to set an error because of a bad enumerant or
      * running out of memory, etc.
      */
-   GLenum error;
+    GLenum error;
 
     /**
      * Whether this context does direct rendering.
      */
-   Bool isDirect;
+    Bool isDirect;
 
     /**
      * \c dpy of current display for this context.  Will be \c NULL if not
      * current to any display, or if this is the "dummy context".
      */
-   Display *currentDpy;
+    Display *currentDpy;
 
     /**
      * The current drawable for this context.  Will be None if this
      * context is not current to any drawable.  currentReadable is below.
      */
-   GLXDrawable currentDrawable;
+    GLXDrawable currentDrawable;
 
     /**
      * \name GL Constant Strings
@@ -361,38 +354,38 @@ struct __GLXcontextRec
      * These pertain to GL attributes, not to be confused with
      * GLX versioning attributes.
      */
-   /*@{ */
-   GLubyte *vendor;
-   GLubyte *renderer;
-   GLubyte *version;
-   GLubyte *extensions;
-   /*@} */
+    /*@{*/
+    GLubyte *vendor;
+    GLubyte *renderer;
+    GLubyte *version;
+    GLubyte *extensions;
+    /*@}*/
 
     /**
      * Record the dpy this context was created on for later freeing
      */
-   Display *createDpy;
+    Display *createDpy;
 
     /**
      * Maximum small render command size.  This is the smaller of 64k and
      * the size of the above buffer.
      */
-   GLint maxSmallRenderCommandSize;
+    GLint maxSmallRenderCommandSize;
 
     /**
      * Major opcode for the extension.  Copied here so a lookup isn't
      * needed.
      */
-   GLint majorOpcode;
+    GLint majorOpcode;
 
     /**
      * Pointer to the mode used to create this context.
      */
-   const __GLcontextModes *mode;
+    const __GLcontextModes * mode;
 
 #ifdef GLX_DIRECT_RENDERING
-   __GLXDRIcontext *driContext;
-   __DRIcontext *__driContext;
+    __GLXDRIcontext *driContext;
+    __DRIcontext *__driContext;
 #endif
 
     /**
@@ -401,7 +394,7 @@ struct __GLXcontextRec
      *
      * \since Internal API version 20030606.
      */
-   GLXDrawable currentReadable;
+    GLXDrawable currentReadable;
 
    /** 
     * Pointer to client-state data that is private to libGL.  This is only
@@ -410,13 +403,13 @@ struct __GLXcontextRec
     * No internal API version change was made for this change.  Client-side
     * drivers should NEVER use this data or even care that it exists.
     */
-   void *client_state_private;
+   void * client_state_private;
 
    /**
     * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
     */
    int renderType;
-
+    
    /**
     * \name Raw server GL version
     *
@@ -424,12 +417,12 @@ struct __GLXcontextRec
     * returned by the server, and it may not reflect what is actually
     * supported (or reported) by the client-side library.
     */
-   /*@{ */
+    /*@{*/
    int server_major;        /**< Major version number. */
    int server_minor;        /**< Minor version number. */
-   /*@} */
+    /*@}*/
 
-   char gl_extension_bits[__GL_EXT_BYTES];
+    char gl_extension_bits[ __GL_EXT_BYTES ];
 };
 
 #define __glXSetError(gc,code) \
@@ -471,57 +464,56 @@ extern void __glFreeAttributeState(__GLXcontext *);
  * One of these records exists per screen of the display.  It contains
  * a pointer to the config data for that screen (if the screen supports GL).
  */
-struct __GLXscreenConfigsRec
-{
+struct __GLXscreenConfigsRec {
     /**
      * GLX extension string reported by the X-server.
      */
-   const char *serverGLXexts;
+    const char *serverGLXexts;
 
     /**
      * GLX extension string to be reported to applications.  This is the
      * set of extensions that the application can actually use.
      */
-   char *effectiveGLXexts;
+    char *effectiveGLXexts;
 
 #ifdef GLX_DIRECT_RENDERING
     /**
      * Per screen direct rendering interface functions and data.
      */
-   __DRIscreen *__driScreen;
-   const __DRIcoreExtension *core;
-   const __DRIlegacyExtension *legacy;
-   const __DRIswrastExtension *swrast;
-   const __DRIdri2Extension *dri2;
-   __glxHashTable *drawHash;
-   Display *dpy;
-   int scr, fd;
-   void *driver;
+    __DRIscreen *__driScreen;
+    const __DRIcoreExtension *core;
+    const __DRIlegacyExtension *legacy;
+    const __DRIswrastExtension *swrast;
+    const __DRIdri2Extension *dri2;
+    __glxHashTable *drawHash;
+    Display *dpy;
+    int scr, fd;
+    void *driver;
 
-   __GLXDRIscreen *driScreen;
+    __GLXDRIscreen *driScreen;
 
 #ifdef __DRI_COPY_SUB_BUFFER
-   const __DRIcopySubBufferExtension *copySubBuffer;
+    const __DRIcopySubBufferExtension *copySubBuffer;
 #endif
 
 #ifdef __DRI_SWAP_CONTROL
-   const __DRIswapControlExtension *swapControl;
+    const __DRIswapControlExtension *swapControl;
 #endif
 
 #ifdef __DRI_ALLOCATE
-   const __DRIallocateExtension *allocate;
+    const __DRIallocateExtension *allocate;
 #endif
 
 #ifdef __DRI_FRAME_TRACKING
-   const __DRIframeTrackingExtension *frameTracking;
+    const __DRIframeTrackingExtension *frameTracking;
 #endif
 
 #ifdef __DRI_MEDIA_STREAM_COUNTER
-   const __DRImediaStreamCounterExtension *msc;
+    const __DRImediaStreamCounterExtension *msc;
 #endif
 
 #ifdef __DRI_TEX_BUFFER
-   const __DRItexBufferExtension *texBuffer;
+    const __DRItexBufferExtension *texBuffer;
 #endif
 
 #endif
@@ -529,7 +521,7 @@ struct __GLXscreenConfigsRec
     /**
      * Linked list of glx visuals and  fbconfigs for this screen.
      */
-   __GLcontextModes *visuals, *configs;
+    __GLcontextModes *visuals, *configs;
 
     /**
      * Per-screen dynamic GLX extension tracking.  The \c direct_support
@@ -538,10 +530,10 @@ struct __GLXscreenConfigsRec
      * this field.  The \c __GLXscreenConfigs structure is not used outside
      * libGL.
      */
-   /*@{ */
-   unsigned char direct_support[8];
-   GLboolean ext_list_first_time;
-   /*@} */
+    /*@{*/
+    unsigned char direct_support[8];
+    GLboolean ext_list_first_time;
+    /*@}*/
 
 };
 
@@ -549,27 +541,26 @@ struct __GLXscreenConfigsRec
  * Per display private data.  One of these records exists for each display
  * that is using the OpenGL (GLX) extension.
  */
-struct __GLXdisplayPrivateRec
-{
+struct __GLXdisplayPrivateRec {
     /**
      * Back pointer to the display
      */
-   Display *dpy;
+    Display *dpy;
 
     /**
      * The \c majorOpcode is common to all connections to the same server.
      * It is also copied into the context structure.
      */
-   int majorOpcode;
+    int majorOpcode;
 
     /**
      * \name Server Version
      *
      * Major and minor version returned by the server during initialization.
      */
-   /*@{ */
-   int majorVersion, minorVersion;
-   /*@} */
+    /*@{*/
+    int majorVersion, minorVersion;
+    /*@}*/
 
     /**
      * \name Storage for the servers GLX vendor and versions strings.
@@ -577,40 +568,40 @@ struct __GLXdisplayPrivateRec
      * These are the same for all screens on this display. These fields will
      * be filled in on demand.
      */
-   /*@{ */
-   const char *serverGLXvendor;
-   const char *serverGLXversion;
-   /*@} */
+    /*@{*/
+    const char *serverGLXvendor;
+    const char *serverGLXversion;
+    /*@}*/
 
     /**
      * Configurations of visuals for all screens on this display.
      * Also, per screen data which now includes the server \c GLX_EXTENSION
      * string.
      */
-   __GLXscreenConfigs *screenConfigs;
+    __GLXscreenConfigs *screenConfigs;
 
 #ifdef GLX_DIRECT_RENDERING
     /**
      * Per display direct rendering interface functions and data.
      */
-   __GLXDRIdisplay *driswDisplay;
-   __GLXDRIdisplay *driDisplay;
-   __GLXDRIdisplay *dri2Display;
+    __GLXDRIdisplay *driswDisplay;
+    __GLXDRIdisplay *driDisplay;
+    __GLXDRIdisplay *dri2Display;
 #endif
 };
 
 
-extern GLubyte *__glXFlushRenderBuffer(__GLXcontext *, GLubyte *);
+extern GLubyte *__glXFlushRenderBuffer(__GLXcontext*, GLubyte*);
 
-extern void __glXSendLargeChunk(__GLXcontext * gc, GLint requestNumber,
-                                GLint totalRequests,
-                                const GLvoid * data, GLint dataLen);
+extern void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+				GLint totalRequests,
+				const GLvoid * data, GLint dataLen);
 
 extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint,
-                                  const GLvoid *, GLint);
+				  const GLvoid *, GLint);
 
 /* Initialize the GLX extension for dpy */
-extern __GLXdisplayPrivate *__glXInitialize(Display *);
+extern __GLXdisplayPrivate *__glXInitialize(Display*);
 
 /************************************************************************/
 
@@ -619,12 +610,12 @@ extern int __glXDebug;
 /* This is per-thread storage in an MT environment */
 #if defined( USE_XTHREADS ) || defined( PTHREADS )
 
-extern void __glXSetCurrentContext(__GLXcontext * c);
+extern void __glXSetCurrentContext(__GLXcontext *c);
 
 # if defined( GLX_USE_TLS )
 
-extern __thread void *__glX_tls_Context
-   __attribute__ ((tls_model("initial-exec")));
+extern __thread void * __glX_tls_Context
+    __attribute__((tls_model("initial-exec")));
 
 #  define __glXGetCurrentContext()	__glX_tls_Context
 
@@ -644,7 +635,7 @@ extern __GLXcontext *__glXcurrentContext;
 
 extern void __glXSetCurrentContextNull(void);
 
-extern void __glXFreeContext(__GLXcontext *);
+extern void __glXFreeContext(__GLXcontext*);
 
 
 /*
@@ -667,7 +658,7 @@ extern pthread_mutex_t __glXmutex;
 /*
 ** Setup for a command.  Initialize the extension for dpy if necessary.
 */
-extern CARD8 __glXSetupForCommand(Display * dpy);
+extern CARD8 __glXSetupForCommand(Display *dpy);
 
 /************************************************************************/
 
@@ -678,11 +669,9 @@ extern CARD8 __glXSetupForCommand(Display * dpy);
 extern const GLuint __glXDefaultPixelStore[9];
 
 /* Send an image to the server using RenderLarge. */
-extern void __glXSendLargeImage(__GLXcontext * gc, GLint compsize, GLint dim,
-                                GLint width, GLint height, GLint depth,
-                                GLenum format, GLenum type,
-                                const GLvoid * src, GLubyte * pc,
-                                GLubyte * modes);
+extern void __glXSendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim,
+    GLint width, GLint height, GLint depth, GLenum format, GLenum type,
+    const GLvoid *src, GLubyte *pc, GLubyte *modes);
 
 /* Return the size, in bytes, of some pixel data */
 extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum);
@@ -702,23 +691,23 @@ extern GLint __glBytesPerElement(GLenum type);
 ** updated to contain the modes needed by the server to decode the
 ** sent data.
 */
-extern void __glFillImage(__GLXcontext *, GLint, GLint, GLint, GLint, GLenum,
-                          GLenum, const GLvoid *, GLubyte *, GLubyte *);
+extern void __glFillImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+			  GLenum, const GLvoid*, GLubyte*, GLubyte*);
 
 /* Copy map data with a stride into a packed buffer */
 extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
 extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
 extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
-                          const GLfloat *, GLfloat *);
+			  const GLfloat *, GLfloat *);
 extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
-                          const GLdouble *, GLdouble *);
+			  const GLdouble *, GLdouble *);
 
 /*
 ** Empty an image out of the reply buffer into the clients memory applying
 ** the pack modes to pack back into the clients requested format.
 */
-extern void __glEmptyImage(__GLXcontext *, GLint, GLint, GLint, GLint, GLenum,
-                           GLenum, const GLubyte *, GLvoid *);
+extern void __glEmptyImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		           GLenum, const GLubyte *, GLvoid *);
 
 
 /*
@@ -731,7 +720,7 @@ extern void __glXFreeVertexArrayState(__GLXcontext *);
 ** Inform the Server of the major and minor numbers and of the client
 ** libraries extension string.
 */
-extern void __glXClientInfo(Display * dpy, int opcode);
+extern void __glXClientInfo (  Display *dpy, int opcode );
 
 /************************************************************************/
 
@@ -739,21 +728,18 @@ extern void __glXClientInfo(Display * dpy, int opcode);
 ** Declarations that should be in Xlib
 */
 #ifdef __GL_USE_OUR_PROTOTYPES
-extern void _XFlush(Display *);
-extern Status _XReply(Display *, xReply *, int, Bool);
-extern void _XRead(Display *, void *, long);
-extern void _XSend(Display *, const void *, long);
+extern void _XFlush(Display*);
+extern Status _XReply(Display*, xReply*, int, Bool);
+extern void _XRead(Display*, void*, long);
+extern void _XSend(Display*, const void*, long);
 #endif
 
 
-extern void __glXInitializeVisualConfigFromTags(__GLcontextModes * config,
-                                                int count, const INT32 * bp,
-                                                Bool tagged_only,
-                                                Bool fbconfig_style_tags);
+extern void __glXInitializeVisualConfigFromTags( __GLcontextModes *config,
+    int count, const INT32 *bp, Bool tagged_only, Bool fbconfig_style_tags );
 
-extern char *__glXGetStringFromServer(Display * dpy, int opcode,
-                                      CARD32 glxCode, CARD32 for_whom,
-                                      CARD32 name);
+extern char * __glXGetStringFromServer( Display * dpy, int opcode,
+    CARD32 glxCode, CARD32 for_whom, CARD32 name );
 
 extern char *__glXstrdup(const char *str);
 
@@ -762,16 +748,15 @@ extern const char __glXGLClientVersion[];
 extern const char __glXGLClientExtensions[];
 
 /* Get the unadjusted system time */
-extern int __glXGetUST(int64_t * ust);
+extern int __glXGetUST( int64_t * ust );
 
 extern GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
-                                    int32_t * numerator,
-                                    int32_t * denominator);
+				    int32_t * numerator, int32_t * denominator);
 
 #ifdef GLX_DIRECT_RENDERING
 GLboolean
-__driGetMscRateOML(__DRIdrawable * draw,
-                   int32_t * numerator, int32_t * denominator, void *private);
+__driGetMscRateOML(__DRIdrawable *draw,
+		   int32_t *numerator, int32_t *denominator, void *private);
 #endif
 
 #endif /* !__GLX_client_h__ */
diff --git a/src/glx/x11/glxcmds.c b/src/glx/x11/glxcmds.c
index b2e2b5e771a..72ab48929d3 100644
--- a/src/glx/x11/glxcmds.c
+++ b/src/glx/x11/glxcmds.c
@@ -54,13 +54,12 @@ static const char __glXGLXClientVersion[] = "1.4";
 #ifdef GLX_DIRECT_RENDERING
 
 static Bool windowExistsFlag;
-static int
-windowExistsErrorHandler(Display * dpy, XErrorEvent * xerr)
+static int windowExistsErrorHandler(Display *dpy, XErrorEvent *xerr)
 {
-   if (xerr->error_code == BadWindow) {
-      windowExistsFlag = GL_FALSE;
-   }
-   return 0;
+    if (xerr->error_code == BadWindow) {
+	windowExistsFlag = GL_FALSE;
+    }
+    return 0;
 }
 
 /**
@@ -70,39 +69,37 @@ windowExistsErrorHandler(Display * dpy, XErrorEvent * xerr)
  * \param dpy    Display to destroy drawables for
  * \param screen Screen number to destroy drawables for
  */
-static void
-GarbageCollectDRIDrawables(Display * dpy, __GLXscreenConfigs * sc)
-{
-   XID draw;
-   __GLXDRIdrawable *pdraw;
-   XWindowAttributes xwa;
-   int (*oldXErrorHandler) (Display *, XErrorEvent *);
-
-   /* Set no-op error handler so Xlib doesn't bail out if the windows
-    * has alreay been destroyed on the server. */
-   XSync(dpy, GL_FALSE);
-   oldXErrorHandler = XSetErrorHandler(windowExistsErrorHandler);
-
-   if (__glxHashFirst(sc->drawHash, &draw, (void *) &pdraw) == 1) {
-      do {
-         windowExistsFlag = GL_TRUE;
-         XGetWindowAttributes(dpy, draw, &xwa); /* dummy request */
-         if (!windowExistsFlag) {
-            /* Destroy the local drawable data, if the drawable no
-               longer exists in the Xserver */
-            (*pdraw->destroyDrawable) (pdraw);
-            __glxHashDelete(sc->drawHash, draw);
-         }
-      } while (__glxHashNext(sc->drawHash, &draw, (void *) &pdraw) == 1);
-   }
-
-   XSync(dpy, GL_FALSE);
-   XSetErrorHandler(oldXErrorHandler);
-}
-
-extern __GLXDRIdrawable *GetGLXDRIDrawable(Display * dpy,
-                                           GLXDrawable drawable,
-                                           int *const scrn_num);
+static void GarbageCollectDRIDrawables(Display *dpy, __GLXscreenConfigs *sc)
+{
+    XID draw;
+    __GLXDRIdrawable *pdraw;
+    XWindowAttributes xwa;
+    int (*oldXErrorHandler)(Display *, XErrorEvent *);
+
+    /* Set no-op error handler so Xlib doesn't bail out if the windows
+     * has alreay been destroyed on the server. */
+    XSync(dpy, GL_FALSE);
+    oldXErrorHandler = XSetErrorHandler(windowExistsErrorHandler);
+
+    if (__glxHashFirst(sc->drawHash, &draw, (void *)&pdraw) == 1) {
+	do {
+	    windowExistsFlag = GL_TRUE;
+	    XGetWindowAttributes(dpy, draw, &xwa); /* dummy request */
+	    if (!windowExistsFlag) {
+		/* Destroy the local drawable data, if the drawable no
+		   longer exists in the Xserver */
+		(*pdraw->destroyDrawable)(pdraw);
+                __glxHashDelete(sc->drawHash, draw);
+	    }
+	} while (__glxHashNext(sc->drawHash, &draw, (void *)&pdraw) == 1);
+    }
+
+    XSync(dpy, GL_FALSE);
+    XSetErrorHandler(oldXErrorHandler);
+}
+
+extern __GLXDRIdrawable *
+GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable, int * const scrn_num);
 
 /**
  * Get the __DRIdrawable for the drawable associated with a GLXContext
@@ -114,30 +111,30 @@ extern __GLXDRIdrawable *GetGLXDRIDrawable(Display * dpy,
  *           the drawable is not associated with a direct-rendering context.
  */
 _X_HIDDEN __GLXDRIdrawable *
-GetGLXDRIDrawable(Display * dpy, GLXDrawable drawable, int *const scrn_num)
+GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable, int * const scrn_num)
 {
-   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
-   __GLXDRIdrawable *pdraw;
-   const unsigned screen_count = ScreenCount(dpy);
-   unsigned i;
-   __GLXscreenConfigs *psc;
-
-   if (priv == NULL)
-      return NULL;
+    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+    __GLXDRIdrawable *pdraw;
+    const unsigned  screen_count = ScreenCount(dpy);
+    unsigned   i;
+    __GLXscreenConfigs *psc;
 
-   for (i = 0; i < screen_count; i++) {
-      psc = &priv->screenConfigs[i];
-      if (psc->drawHash == NULL)
-         continue;
+    if (priv == NULL)
+	return NULL;
+    
+    for (i = 0; i < screen_count; i++) {
+	psc = &priv->screenConfigs[i];
+	if (psc->drawHash == NULL)
+	    continue;
 
-      if (__glxHashLookup(psc->drawHash, drawable, (void *) &pdraw) == 0) {
-         if (scrn_num != NULL)
-            *scrn_num = i;
-         return pdraw;
-      }
-   }
+	if (__glxHashLookup(psc->drawHash, drawable, (void *) &pdraw) == 0) {
+	    if (scrn_num != NULL)
+		*scrn_num = i;
+	    return pdraw;
+	}
+    }
 
-   return NULL;
+    return NULL;
 }
 
 #endif
@@ -158,44 +155,44 @@ GetGLXDRIDrawable(Display * dpy, GLXDrawable drawable, int *const scrn_num)
  */
 
 static __GLXscreenConfigs *
-GetGLXScreenConfigs(Display * dpy, int scrn)
+GetGLXScreenConfigs(Display *dpy, int scrn)
 {
-   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
 
-   return (priv->screenConfigs != NULL) ? &priv->screenConfigs[scrn] : NULL;
+    return (priv->screenConfigs != NULL) ? &priv->screenConfigs[scrn] : NULL;
 }
 
 
 static int
-GetGLXPrivScreenConfig(Display * dpy, int scrn, __GLXdisplayPrivate ** ppriv,
-                       __GLXscreenConfigs ** ppsc)
+GetGLXPrivScreenConfig( Display *dpy, int scrn, __GLXdisplayPrivate ** ppriv,
+			__GLXscreenConfigs ** ppsc )
 {
-   /* Initialize the extension, if needed .  This has the added value
-    * of initializing/allocating the display private 
-    */
-
-   if (dpy == NULL) {
-      return GLX_NO_EXTENSION;
-   }
+    /* Initialize the extension, if needed .  This has the added value
+     * of initializing/allocating the display private 
+     */
+    
+    if ( dpy == NULL ) {
+	return GLX_NO_EXTENSION;
+    }
 
-   *ppriv = __glXInitialize(dpy);
-   if (*ppriv == NULL) {
-      return GLX_NO_EXTENSION;
-   }
+    *ppriv = __glXInitialize(dpy);
+    if ( *ppriv == NULL ) {
+	return GLX_NO_EXTENSION;
+    }
 
-   /* Check screen number to see if its valid */
-   if ((scrn < 0) || (scrn >= ScreenCount(dpy))) {
-      return GLX_BAD_SCREEN;
-   }
+    /* Check screen number to see if its valid */
+    if ((scrn < 0) || (scrn >= ScreenCount(dpy))) {
+	return GLX_BAD_SCREEN;
+    }
 
-   /* Check to see if the GL is supported on this screen */
-   *ppsc = &((*ppriv)->screenConfigs[scrn]);
-   if ((*ppsc)->configs == NULL) {
-      /* No support for GL on this screen regardless of visual */
-      return GLX_BAD_VISUAL;
-   }
+    /* Check to see if the GL is supported on this screen */
+    *ppsc = &((*ppriv)->screenConfigs[scrn]);
+    if ( (*ppsc)->configs == NULL ) {
+	/* No support for GL on this screen regardless of visual */
+	return GLX_BAD_VISUAL;
+    }
 
-   return Success;
+    return Success;
 }
 
 
@@ -210,26 +207,27 @@ GetGLXPrivScreenConfig(Display * dpy, int scrn, __GLXdisplayPrivate ** ppriv,
  *          is returned.
  */
 static __GLcontextModes *
-ValidateGLXFBConfig(Display * dpy, GLXFBConfig config)
-{
-   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
-   const unsigned num_screens = ScreenCount(dpy);
-   unsigned i;
-   const __GLcontextModes *modes;
-
-
-   if (priv != NULL) {
-      for (i = 0; i < num_screens; i++) {
-         for (modes = priv->screenConfigs[i].configs; modes != NULL;
-              modes = modes->next) {
-            if (modes == (__GLcontextModes *) config) {
-               return (__GLcontextModes *) config;
-            }
-         }
-      }
-   }
+ValidateGLXFBConfig( Display * dpy, GLXFBConfig config )
+{
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+    const unsigned num_screens = ScreenCount(dpy);
+    unsigned   i;
+    const __GLcontextModes * modes;
 
-   return NULL;
+
+    if ( priv != NULL ) {
+	for ( i = 0 ; i < num_screens ; i++ ) {
+	    for ( modes = priv->screenConfigs[i].configs
+		  ; modes != NULL
+		  ; modes = modes->next ) {
+		if ( modes == (__GLcontextModes *) config ) {
+		    return (__GLcontextModes *) config;
+		}
+	    }
+	}
+    }
+
+    return NULL;
 }
 
 
@@ -243,100 +241,99 @@ ValidateGLXFBConfig(Display * dpy, GLXFBConfig config)
  * function called \c __glXAllocateClientState that allocates the memory and
  * does all the initialization (including the pixel pack / unpack).
  */
-static GLXContext
-AllocateGLXContext(Display * dpy)
-{
-   GLXContext gc;
-   int bufSize;
-   CARD8 opcode;
-   __GLXattribute *state;
-
-   if (!dpy)
-      return NULL;
-
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return NULL;
-   }
-
-   /* Allocate our context record */
-   gc = (GLXContext) Xmalloc(sizeof(struct __GLXcontextRec));
-   if (!gc) {
-      /* Out of memory */
-      return NULL;
-   }
-   memset(gc, 0, sizeof(struct __GLXcontextRec));
-
-   state = Xmalloc(sizeof(struct __GLXattributeRec));
-   if (state == NULL) {
-      /* Out of memory */
-      Xfree(gc);
-      return NULL;
-   }
-   gc->client_state_private = state;
-   memset(gc->client_state_private, 0, sizeof(struct __GLXattributeRec));
-   state->NoDrawArraysProtocol = (getenv("LIBGL_NO_DRAWARRAYS") != NULL);
-
-   /*
+static
+GLXContext AllocateGLXContext( Display *dpy )
+{
+     GLXContext gc;
+     int bufSize;
+     CARD8 opcode;
+    __GLXattribute *state;
+
+    if (!dpy)
+        return NULL;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return NULL;
+    }
+
+    /* Allocate our context record */
+    gc = (GLXContext) Xmalloc(sizeof(struct __GLXcontextRec));
+    if (!gc) {
+	/* Out of memory */
+	return NULL;
+    }
+    memset(gc, 0, sizeof(struct __GLXcontextRec));
+
+    state = Xmalloc(sizeof(struct __GLXattributeRec));
+    if (state == NULL) {
+	/* Out of memory */
+	Xfree(gc);
+	return NULL;
+    }
+    gc->client_state_private = state;
+    memset(gc->client_state_private, 0, sizeof(struct __GLXattributeRec));
+    state->NoDrawArraysProtocol = (getenv("LIBGL_NO_DRAWARRAYS") != NULL);
+
+    /*
     ** Create a temporary buffer to hold GLX rendering commands.  The size
     ** of the buffer is selected so that the maximum number of GLX rendering
     ** commands can fit in a single X packet and still have room in the X
     ** packet for the GLXRenderReq header.
     */
 
-   bufSize = (XMaxRequestSize(dpy) * 4) - sz_xGLXRenderReq;
-   gc->buf = (GLubyte *) Xmalloc(bufSize);
-   if (!gc->buf) {
-      Xfree(gc->client_state_private);
-      Xfree(gc);
-      return NULL;
-   }
-   gc->bufSize = bufSize;
+    bufSize = (XMaxRequestSize(dpy) * 4) - sz_xGLXRenderReq;
+    gc->buf = (GLubyte *) Xmalloc(bufSize);
+    if (!gc->buf) {
+	Xfree(gc->client_state_private);
+	Xfree(gc);
+	return NULL;
+    }
+    gc->bufSize = bufSize;
 
-   /* Fill in the new context */
-   gc->renderMode = GL_RENDER;
+    /* Fill in the new context */
+    gc->renderMode = GL_RENDER;
 
-   state->storePack.alignment = 4;
-   state->storeUnpack.alignment = 4;
+    state->storePack.alignment = 4;
+    state->storeUnpack.alignment = 4;
 
-   gc->attributes.stackPointer = &gc->attributes.stack[0];
+    gc->attributes.stackPointer = &gc->attributes.stack[0];
 
-   /*
+    /*
     ** PERFORMANCE NOTE: A mode dependent fill image can speed things up.
     ** Other code uses the fastImageUnpack bit, but it is never set
     ** to GL_TRUE.
     */
-   gc->fastImageUnpack = GL_FALSE;
-   gc->fillImage = __glFillImage;
-   gc->pc = gc->buf;
-   gc->bufEnd = gc->buf + bufSize;
-   gc->isDirect = GL_FALSE;
-   if (__glXDebug) {
-      /*
-       ** Set limit register so that there will be one command per packet
-       */
-      gc->limit = gc->buf;
-   }
-   else {
-      gc->limit = gc->buf + bufSize - __GLX_BUFFER_LIMIT_SIZE;
-   }
-   gc->createDpy = dpy;
-   gc->majorOpcode = opcode;
-
-   /*
+    gc->fastImageUnpack = GL_FALSE;
+    gc->fillImage = __glFillImage;
+    gc->pc = gc->buf;
+    gc->bufEnd = gc->buf + bufSize;
+    gc->isDirect = GL_FALSE;
+    if (__glXDebug) {
+	/*
+	** Set limit register so that there will be one command per packet
+	*/
+	gc->limit = gc->buf;
+    } else {
+	gc->limit = gc->buf + bufSize - __GLX_BUFFER_LIMIT_SIZE;
+    }
+    gc->createDpy = dpy;
+    gc->majorOpcode = opcode;
+
+    /*
     ** Constrain the maximum drawing command size allowed to be
     ** transfered using the X_GLXRender protocol request.  First
     ** constrain by a software limit, then constrain by the protocl
     ** limit.
     */
-   if (bufSize > __GLX_RENDER_CMD_SIZE_LIMIT) {
-      bufSize = __GLX_RENDER_CMD_SIZE_LIMIT;
-   }
-   if (bufSize > __GLX_MAX_RENDER_CMD_SIZE) {
-      bufSize = __GLX_MAX_RENDER_CMD_SIZE;
-   }
-   gc->maxSmallRenderCommandSize = bufSize;
-   return gc;
+    if (bufSize > __GLX_RENDER_CMD_SIZE_LIMIT) {
+        bufSize = __GLX_RENDER_CMD_SIZE_LIMIT;
+    }
+    if (bufSize > __GLX_MAX_RENDER_CMD_SIZE) {
+        bufSize = __GLX_MAX_RENDER_CMD_SIZE;
+    }
+    gc->maxSmallRenderCommandSize = bufSize;
+    return gc;
 }
 
 
@@ -350,370 +347,348 @@ AllocateGLXContext(Display * dpy)
  */
 
 static GLXContext
-CreateContext(Display * dpy, XVisualInfo * vis,
-              const __GLcontextModes * const fbconfig,
-              GLXContext shareList,
-              Bool allowDirect, GLXContextID contextID,
-              Bool use_glx_1_3, int renderType)
+CreateContext(Display *dpy, XVisualInfo *vis,
+	      const __GLcontextModes * const fbconfig,
+	      GLXContext shareList,
+	      Bool allowDirect, GLXContextID contextID,
+	      Bool use_glx_1_3, int renderType)
 {
-   GLXContext gc;
+    GLXContext gc;
 #ifdef GLX_DIRECT_RENDERING
-   int screen = (fbconfig == NULL) ? vis->screen : fbconfig->screen;
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+    int screen = (fbconfig == NULL) ? vis->screen : fbconfig->screen;
+    __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
 #endif
 
-   if (dpy == NULL)
-      return NULL;
+    if ( dpy == NULL )
+       return NULL;
 
-   gc = AllocateGLXContext(dpy);
-   if (!gc)
-      return NULL;
+    gc = AllocateGLXContext(dpy);
+    if (!gc)
+	return NULL;
 
-   if (None == contextID) {
-      if ((vis == NULL) && (fbconfig == NULL))
-         return NULL;
+    if (None == contextID) {
+	if ( (vis == NULL) && (fbconfig == NULL) )
+	    return NULL;
 
 #ifdef GLX_DIRECT_RENDERING
-      if (allowDirect && psc->driScreen) {
-         const __GLcontextModes *mode;
-
-         if (fbconfig == NULL) {
-            mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
-            if (mode == NULL) {
-               xError error;
-
-               error.errorCode = BadValue;
-               error.resourceID = vis->visualid;
-               error.sequenceNumber = dpy->request;
-               error.type = X_Error;
-               error.majorCode = gc->majorOpcode;
-               error.minorCode = X_GLXCreateContext;
-               _XError(dpy, &error);
-               return None;
-            }
-         }
-         else {
-            mode = fbconfig;
-         }
-
-         gc->driContext = psc->driScreen->createContext(psc, mode, gc,
-                                                        shareList,
-                                                        renderType);
-         if (gc->driContext != NULL) {
-            gc->screen = mode->screen;
-            gc->psc = psc;
-            gc->mode = mode;
-            gc->isDirect = GL_TRUE;
-         }
-      }
+	if (allowDirect && psc->driScreen) {
+	    const __GLcontextModes * mode;
+
+	    if (fbconfig == NULL) {
+		mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
+		if (mode == NULL) {
+		   xError error;
+
+		   error.errorCode = BadValue;
+		   error.resourceID = vis->visualid;
+		   error.sequenceNumber = dpy->request;
+		   error.type = X_Error;
+		   error.majorCode = gc->majorOpcode;
+		   error.minorCode = X_GLXCreateContext;
+		   _XError(dpy, &error);
+		   return None;
+		}
+	    }
+	    else {
+		mode = fbconfig;
+	    }
+
+	    gc->driContext = psc->driScreen->createContext(psc, mode, gc,
+							   shareList,
+							   renderType);
+	    if (gc->driContext != NULL) {
+		gc->screen = mode->screen;
+		gc->psc = psc;
+		gc->mode = mode;
+		gc->isDirect = GL_TRUE;
+	    }
+	}
 #endif
 
-      LockDisplay(dpy);
-      if (fbconfig == NULL) {
-         xGLXCreateContextReq *req;
-
-         /* Send the glXCreateContext request */
-         GetReq(GLXCreateContext, req);
-         req->reqType = gc->majorOpcode;
-         req->glxCode = X_GLXCreateContext;
-         req->context = gc->xid = XAllocID(dpy);
-         req->visual = vis->visualid;
-         req->screen = vis->screen;
-         req->shareList = shareList ? shareList->xid : None;
+	LockDisplay(dpy);
+	if ( fbconfig == NULL ) {
+	    xGLXCreateContextReq *req;
+
+	    /* Send the glXCreateContext request */
+	    GetReq(GLXCreateContext,req);
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXCreateContext;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->visual = vis->visualid;
+	    req->screen = vis->screen;
+	    req->shareList = shareList ? shareList->xid : None;
 #ifdef GLX_DIRECT_RENDERING
-         req->isDirect = gc->driContext != NULL;
+	    req->isDirect = gc->driContext != NULL;
 #else
-         req->isDirect = 0;
+	    req->isDirect = 0;
 #endif
-      }
-      else if (use_glx_1_3) {
-         xGLXCreateNewContextReq *req;
-
-         /* Send the glXCreateNewContext request */
-         GetReq(GLXCreateNewContext, req);
-         req->reqType = gc->majorOpcode;
-         req->glxCode = X_GLXCreateNewContext;
-         req->context = gc->xid = XAllocID(dpy);
-         req->fbconfig = fbconfig->fbconfigID;
-         req->screen = fbconfig->screen;
-         req->renderType = renderType;
-         req->shareList = shareList ? shareList->xid : None;
+	}
+	else if ( use_glx_1_3 ) {
+	    xGLXCreateNewContextReq *req;
+
+	    /* Send the glXCreateNewContext request */
+	    GetReq(GLXCreateNewContext,req);
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXCreateNewContext;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->fbconfig = fbconfig->fbconfigID;
+	    req->screen = fbconfig->screen;
+	    req->renderType = renderType;
+	    req->shareList = shareList ? shareList->xid : None;
 #ifdef GLX_DIRECT_RENDERING
-         req->isDirect = gc->driContext != NULL;
+	    req->isDirect = gc->driContext != NULL;
 #else
-         req->isDirect = 0;
+	    req->isDirect = 0;
 #endif
-      }
-      else {
-         xGLXVendorPrivateWithReplyReq *vpreq;
-         xGLXCreateContextWithConfigSGIXReq *req;
-
-         /* Send the glXCreateNewContext request */
-         GetReqExtra(GLXVendorPrivateWithReply,
-                     sz_xGLXCreateContextWithConfigSGIXReq -
-                     sz_xGLXVendorPrivateWithReplyReq, vpreq);
-         req = (xGLXCreateContextWithConfigSGIXReq *) vpreq;
-         req->reqType = gc->majorOpcode;
-         req->glxCode = X_GLXVendorPrivateWithReply;
-         req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
-         req->context = gc->xid = XAllocID(dpy);
-         req->fbconfig = fbconfig->fbconfigID;
-         req->screen = fbconfig->screen;
-         req->renderType = renderType;
-         req->shareList = shareList ? shareList->xid : None;
+	}
+	else {
+	    xGLXVendorPrivateWithReplyReq *vpreq;
+	    xGLXCreateContextWithConfigSGIXReq *req;
+
+	    /* Send the glXCreateNewContext request */
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXCreateContextWithConfigSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXVendorPrivateWithReply;
+	    req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->fbconfig = fbconfig->fbconfigID;
+	    req->screen = fbconfig->screen;
+	    req->renderType = renderType;
+	    req->shareList = shareList ? shareList->xid : None;
 #ifdef GLX_DIRECT_RENDERING
-         req->isDirect = gc->driContext != NULL;
+	    req->isDirect = gc->driContext != NULL;
 #else
-         req->isDirect = 0;
+	    req->isDirect = 0;
 #endif
-      }
+	}
 
-      UnlockDisplay(dpy);
-      SyncHandle();
-      gc->imported = GL_FALSE;
-   }
-   else {
-      gc->xid = contextID;
-      gc->imported = GL_TRUE;
-   }
+	UnlockDisplay(dpy);
+	SyncHandle();
+	gc->imported = GL_FALSE;
+    }
+    else {
+	gc->xid = contextID;
+	gc->imported = GL_TRUE;
+    }
 
-   return gc;
+    return gc;
 }
 
-PUBLIC GLXContext
-glXCreateContext(Display * dpy, XVisualInfo * vis,
-                 GLXContext shareList, Bool allowDirect)
+PUBLIC GLXContext glXCreateContext(Display *dpy, XVisualInfo *vis,
+				   GLXContext shareList, Bool allowDirect)
 {
    return CreateContext(dpy, vis, NULL, shareList, allowDirect, None,
-                        False, 0);
+			False, 0);
 }
 
-_X_HIDDEN void
-__glXFreeContext(__GLXcontext * gc)
+_X_HIDDEN void __glXFreeContext(__GLXcontext *gc)
 {
-   if (gc->vendor)
-      XFree((char *) gc->vendor);
-   if (gc->renderer)
-      XFree((char *) gc->renderer);
-   if (gc->version)
-      XFree((char *) gc->version);
-   if (gc->extensions)
-      XFree((char *) gc->extensions);
-   __glFreeAttributeState(gc);
-   XFree((char *) gc->buf);
-   Xfree((char *) gc->client_state_private);
-   XFree((char *) gc);
-
+    if (gc->vendor) XFree((char *) gc->vendor);
+    if (gc->renderer) XFree((char *) gc->renderer);
+    if (gc->version) XFree((char *) gc->version);
+    if (gc->extensions) XFree((char *) gc->extensions);
+    __glFreeAttributeState(gc);
+    XFree((char *) gc->buf);
+    Xfree((char *) gc->client_state_private);
+    XFree((char *) gc);
+    
 }
 
 /*
 ** Destroy the named context
 */
-static void
-DestroyContext(Display * dpy, GLXContext gc)
+static void 
+DestroyContext(Display *dpy, GLXContext gc)
 {
-   xGLXDestroyContextReq *req;
-   GLXContextID xid;
-   CARD8 opcode;
-   GLboolean imported;
+    xGLXDestroyContextReq *req;
+    GLXContextID xid;
+    CARD8 opcode;
+    GLboolean imported;
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode || !gc) {
-      return;
-   }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode || !gc) {
+	return;
+    }
 
-   __glXLock();
-   xid = gc->xid;
-   imported = gc->imported;
-   gc->xid = None;
+    __glXLock();
+    xid = gc->xid;
+    imported = gc->imported;
+    gc->xid = None;
 
 #ifdef GLX_DIRECT_RENDERING
-   /* Destroy the direct rendering context */
-   if (gc->driContext) {
-      (*gc->driContext->destroyContext) (gc->driContext, gc->psc, dpy);
-      gc->driContext = NULL;
-      GarbageCollectDRIDrawables(dpy, gc->psc);
-   }
+    /* Destroy the direct rendering context */
+    if (gc->driContext) {
+	(*gc->driContext->destroyContext)(gc->driContext, gc->psc, dpy);
+	gc->driContext = NULL;
+	GarbageCollectDRIDrawables(dpy, gc->psc);
+    }
 #endif
 
-   __glXFreeVertexArrayState(gc);
+    __glXFreeVertexArrayState(gc);
 
-   if (gc->currentDpy) {
-      /* Have to free later cuz it's in use now */
-      __glXUnlock();
-   }
-   else {
-      /* Destroy the handle if not current to anybody */
-      __glXUnlock();
-      __glXFreeContext(gc);
-   }
+    if (gc->currentDpy) {
+	/* Have to free later cuz it's in use now */
+	__glXUnlock();
+    } else {
+	/* Destroy the handle if not current to anybody */
+	__glXUnlock();
+	__glXFreeContext(gc);
+    }
 
-   if (!imported) {
-      /* 
-       ** This dpy also created the server side part of the context.
-       ** Send the glXDestroyContext request.
-       */
-      LockDisplay(dpy);
-      GetReq(GLXDestroyContext, req);
-      req->reqType = opcode;
-      req->glxCode = X_GLXDestroyContext;
-      req->context = xid;
-      UnlockDisplay(dpy);
-      SyncHandle();
-   }
+    if (!imported) {
+	/* 
+	** This dpy also created the server side part of the context.
+	** Send the glXDestroyContext request.
+	*/
+	LockDisplay(dpy);
+	GetReq(GLXDestroyContext,req);
+	req->reqType = opcode;
+	req->glxCode = X_GLXDestroyContext;
+	req->context = xid;
+	UnlockDisplay(dpy);
+	SyncHandle();
+    }
 }
 
-PUBLIC void
-glXDestroyContext(Display * dpy, GLXContext gc)
+PUBLIC void glXDestroyContext(Display *dpy, GLXContext gc)
 {
-   DestroyContext(dpy, gc);
+    DestroyContext(dpy, gc);
 }
 
 /*
 ** Return the major and minor version #s for the GLX extension
 */
-PUBLIC Bool
-glXQueryVersion(Display * dpy, int *major, int *minor)
+PUBLIC Bool glXQueryVersion(Display *dpy, int *major, int *minor)
 {
-   __GLXdisplayPrivate *priv;
+    __GLXdisplayPrivate *priv;
 
-   /* Init the extension.  This fetches the major and minor version. */
-   priv = __glXInitialize(dpy);
-   if (!priv)
-      return GL_FALSE;
+    /* Init the extension.  This fetches the major and minor version. */
+    priv = __glXInitialize(dpy);
+    if (!priv) return GL_FALSE;
 
-   if (major)
-      *major = priv->majorVersion;
-   if (minor)
-      *minor = priv->minorVersion;
-   return GL_TRUE;
+    if (major) *major = priv->majorVersion;
+    if (minor) *minor = priv->minorVersion;
+    return GL_TRUE;
 }
 
 /*
 ** Query the existance of the GLX extension
 */
-PUBLIC Bool
-glXQueryExtension(Display * dpy, int *errorBase, int *eventBase)
-{
-   int major_op, erb, evb;
-   Bool rv;
-
-   rv = XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_op, &evb, &erb);
-   if (rv) {
-      if (errorBase)
-         *errorBase = erb;
-      if (eventBase)
-         *eventBase = evb;
-   }
-   return rv;
+PUBLIC Bool glXQueryExtension(Display *dpy, int *errorBase, int *eventBase)
+{
+    int major_op, erb, evb;
+    Bool rv;
+
+    rv = XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_op, &evb, &erb);
+    if (rv) {
+	if (errorBase) *errorBase = erb;
+	if (eventBase) *eventBase = evb;
+    }
+    return rv;
 }
 
 /*
 ** Put a barrier in the token stream that forces the GL to finish its
 ** work before X can proceed.
 */
-PUBLIC void
-glXWaitGL(void)
+PUBLIC void glXWaitGL(void)
 {
-   xGLXWaitGLReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   Display *dpy = gc->currentDpy;
+    xGLXWaitGLReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
 
-   if (!dpy)
-      return;
+    if (!dpy) return;
 
-   /* Flush any pending commands out */
-   __glXFlushRenderBuffer(gc, gc->pc);
+    /* Flush any pending commands out */
+    __glXFlushRenderBuffer(gc, gc->pc);
 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext) {
+    if (gc->driContext) {
 /* This bit of ugliness unwraps the glFinish function */
 #ifdef glFinish
 #undef glFinish
 #endif
-      glFinish();
-      return;
-   }
+	glFinish();
+	return;
+    }
 #endif
 
-   /* Send the glXWaitGL request */
-   LockDisplay(dpy);
-   GetReq(GLXWaitGL, req);
-   req->reqType = gc->majorOpcode;
-   req->glxCode = X_GLXWaitGL;
-   req->contextTag = gc->currentContextTag;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    /* Send the glXWaitGL request */
+    LockDisplay(dpy);
+    GetReq(GLXWaitGL,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXWaitGL;
+    req->contextTag = gc->currentContextTag;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
 /*
 ** Put a barrier in the token stream that forces X to finish its
 ** work before GL can proceed.
 */
-PUBLIC void
-glXWaitX(void)
+PUBLIC void glXWaitX(void)
 {
-   xGLXWaitXReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   Display *dpy = gc->currentDpy;
+    xGLXWaitXReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
 
-   if (!dpy)
-      return;
+    if (!dpy) return;
 
-   /* Flush any pending commands out */
-   __glXFlushRenderBuffer(gc, gc->pc);
+    /* Flush any pending commands out */
+    __glXFlushRenderBuffer(gc, gc->pc);
 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext) {
-      XSync(dpy, False);
-      return;
-   }
+    if (gc->driContext) {
+	XSync(dpy, False);
+	return;
+    }
 #endif
 
-   /*
+    /*
     ** Send the glXWaitX request.
     */
-   LockDisplay(dpy);
-   GetReq(GLXWaitX, req);
-   req->reqType = gc->majorOpcode;
-   req->glxCode = X_GLXWaitX;
-   req->contextTag = gc->currentContextTag;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    LockDisplay(dpy);
+    GetReq(GLXWaitX,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXWaitX;
+    req->contextTag = gc->currentContextTag;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
-PUBLIC void
-glXUseXFont(Font font, int first, int count, int listBase)
+PUBLIC void glXUseXFont(Font font, int first, int count, int listBase)
 {
-   xGLXUseXFontReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   Display *dpy = gc->currentDpy;
+    xGLXUseXFontReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
 
-   if (!dpy)
-      return;
+    if (!dpy) return;
 
-   /* Flush any pending commands out */
-   (void) __glXFlushRenderBuffer(gc, gc->pc);
+    /* Flush any pending commands out */
+    (void) __glXFlushRenderBuffer(gc, gc->pc);
 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext) {
+    if (gc->driContext) {
       DRI_glXUseXFont(font, first, count, listBase);
       return;
-   }
+    }
 #endif
 
-   /* Send the glXUseFont request */
-   LockDisplay(dpy);
-   GetReq(GLXUseXFont, req);
-   req->reqType = gc->majorOpcode;
-   req->glxCode = X_GLXUseXFont;
-   req->contextTag = gc->currentContextTag;
-   req->font = font;
-   req->first = first;
-   req->count = count;
-   req->listBase = listBase;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    /* Send the glXUseFont request */
+    LockDisplay(dpy);
+    GetReq(GLXUseXFont,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXUseXFont;
+    req->contextTag = gc->currentContextTag;
+    req->font = font;
+    req->first = first;
+    req->count = count;
+    req->listBase = listBase;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
 /************************************************************************/
@@ -722,48 +697,46 @@ glXUseXFont(Font font, int first, int count, int listBase)
 ** Copy the source context to the destination context using the
 ** attribute "mask".
 */
-PUBLIC void
-glXCopyContext(Display * dpy, GLXContext source,
-               GLXContext dest, unsigned long mask)
+PUBLIC void glXCopyContext(Display *dpy, GLXContext source,
+			   GLXContext dest, unsigned long mask)
 {
-   xGLXCopyContextReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   GLXContextTag tag;
-   CARD8 opcode;
+    xGLXCopyContextReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    GLXContextTag tag;
+    CARD8 opcode;
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return;
-   }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext) {
-      /* NOT_DONE: This does not work yet */
-   }
+    if (gc->driContext) {
+	/* NOT_DONE: This does not work yet */
+    }
 #endif
 
-   /*
+    /*
     ** If the source is the current context, send its tag so that the context
     ** can be flushed before the copy.
     */
-   if (source == gc && dpy == gc->currentDpy) {
-      tag = gc->currentContextTag;
-   }
-   else {
-      tag = 0;
-   }
-
-   /* Send the glXCopyContext request */
-   LockDisplay(dpy);
-   GetReq(GLXCopyContext, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXCopyContext;
-   req->source = source ? source->xid : None;
-   req->dest = dest ? dest->xid : None;
-   req->mask = mask;
-   req->contextTag = tag;
-   UnlockDisplay(dpy);
-   SyncHandle();
+    if (source == gc && dpy == gc->currentDpy) {
+	tag = gc->currentContextTag;
+    } else {
+	tag = 0;
+    }
+
+    /* Send the glXCopyContext request */
+    LockDisplay(dpy);
+    GetReq(GLXCopyContext,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXCopyContext;
+    req->source = source ? source->xid : None;
+    req->dest = dest ? dest->xid : None;
+    req->mask = mask;
+    req->contextTag = tag;
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
 
@@ -775,29 +748,28 @@ glXCopyContext(Display * dpy, GLXContext source,
  *
  * \returns \c GL_TRUE if the context is direct rendering or not.
  */
-static Bool
-__glXIsDirect(Display * dpy, GLXContextID contextID)
+static Bool __glXIsDirect(Display *dpy, GLXContextID contextID)
 {
-   xGLXIsDirectReq *req;
-   xGLXIsDirectReply reply;
-   CARD8 opcode;
+    xGLXIsDirectReq *req;
+    xGLXIsDirectReply reply;
+    CARD8 opcode;
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return GL_FALSE;
-   }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return GL_FALSE;
+    }
 
-   /* Send the glXIsDirect request */
-   LockDisplay(dpy);
-   GetReq(GLXIsDirect, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXIsDirect;
-   req->context = contextID;
-   _XReply(dpy, (xReply *) & reply, 0, False);
-   UnlockDisplay(dpy);
-   SyncHandle();
+    /* Send the glXIsDirect request */
+    LockDisplay(dpy);
+    GetReq(GLXIsDirect,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXIsDirect;
+    req->context = contextID;
+    _XReply(dpy, (xReply*) &reply, 0, False);
+    UnlockDisplay(dpy);
+    SyncHandle();
 
-   return reply.isDirect;
+    return reply.isDirect;
 }
 
 /**
@@ -806,116 +778,110 @@ __glXIsDirect(Display * dpy, GLXContextID contextID)
  * \c GLX_DIRECT_RENDERING is not defined?  Do we really need to bother with
  * the GLX protocol here at all?
  */
-PUBLIC Bool
-glXIsDirect(Display * dpy, GLXContext gc)
+PUBLIC Bool glXIsDirect(Display *dpy, GLXContext gc)
 {
-   if (!gc) {
-      return GL_FALSE;
+    if (!gc) {
+	return GL_FALSE;
 #ifdef GLX_DIRECT_RENDERING
-   }
-   else if (gc->driContext) {
-      return GL_TRUE;
+    } else if (gc->driContext) {
+	return GL_TRUE;
 #endif
-   }
-   return __glXIsDirect(dpy, gc->xid);
+    }
+    return __glXIsDirect(dpy, gc->xid);
 }
 
-PUBLIC GLXPixmap
-glXCreateGLXPixmap(Display * dpy, XVisualInfo * vis, Pixmap pixmap)
+PUBLIC GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *vis, 
+				    Pixmap pixmap)
 {
-   xGLXCreateGLXPixmapReq *req;
-   GLXPixmap xid;
-   CARD8 opcode;
+    xGLXCreateGLXPixmapReq *req;
+    GLXPixmap xid;
+    CARD8 opcode;
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return None;
-   }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return None;
+    }
 
-   /* Send the glXCreateGLXPixmap request */
-   LockDisplay(dpy);
-   GetReq(GLXCreateGLXPixmap, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXCreateGLXPixmap;
-   req->screen = vis->screen;
-   req->visual = vis->visualid;
-   req->pixmap = pixmap;
-   req->glxpixmap = xid = XAllocID(dpy);
-   UnlockDisplay(dpy);
-   SyncHandle();
-   return xid;
+    /* Send the glXCreateGLXPixmap request */
+    LockDisplay(dpy);
+    GetReq(GLXCreateGLXPixmap,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXCreateGLXPixmap;
+    req->screen = vis->screen;
+    req->visual = vis->visualid;
+    req->pixmap = pixmap;
+    req->glxpixmap = xid = XAllocID(dpy);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return xid;
 }
 
 /*
 ** Destroy the named pixmap
 */
-PUBLIC void
-glXDestroyGLXPixmap(Display * dpy, GLXPixmap glxpixmap)
-{
-   xGLXDestroyGLXPixmapReq *req;
-   CARD8 opcode;
-
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return;
-   }
-
-   /* Send the glXDestroyGLXPixmap request */
-   LockDisplay(dpy);
-   GetReq(GLXDestroyGLXPixmap, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXDestroyGLXPixmap;
-   req->glxpixmap = glxpixmap;
-   UnlockDisplay(dpy);
-   SyncHandle();
-}
-
-PUBLIC void
-glXSwapBuffers(Display * dpy, GLXDrawable drawable)
-{
-   xGLXSwapBuffersReq *req;
-   GLXContext gc;
-   GLXContextTag tag;
-   CARD8 opcode;
+PUBLIC void glXDestroyGLXPixmap(Display *dpy, GLXPixmap glxpixmap)
+{
+    xGLXDestroyGLXPixmapReq *req;
+    CARD8 opcode;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
+    
+    /* Send the glXDestroyGLXPixmap request */
+    LockDisplay(dpy);
+    GetReq(GLXDestroyGLXPixmap,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXDestroyGLXPixmap;
+    req->glxpixmap = glxpixmap;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
+{
+    xGLXSwapBuffersReq *req;
+    GLXContext gc;
+    GLXContextTag tag;
+    CARD8 opcode;
 #ifdef GLX_DIRECT_RENDERING
-   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
+    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
 
-   if (pdraw != NULL) {
-      glFlush();
-      (*pdraw->psc->driScreen->swapBuffers) (pdraw);
-      return;
-   }
+    if (pdraw != NULL) {
+	glFlush();	    
+	(*pdraw->psc->driScreen->swapBuffers)(pdraw);
+	return;
+    }
 #endif
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return;
-   }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
 
-   /*
+    /*
     ** The calling thread may or may not have a current context.  If it
     ** does, send the context tag so the server can do a flush.
     */
-   gc = __glXGetCurrentContext();
-   if ((gc != NULL) && (dpy == gc->currentDpy) &&
-       ((drawable == gc->currentDrawable)
-        || (drawable == gc->currentReadable))) {
-      tag = gc->currentContextTag;
-   }
-   else {
-      tag = 0;
-   }
-
-   /* Send the glXSwapBuffers request */
-   LockDisplay(dpy);
-   GetReq(GLXSwapBuffers, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXSwapBuffers;
-   req->drawable = drawable;
-   req->contextTag = tag;
-   UnlockDisplay(dpy);
-   SyncHandle();
-   XFlush(dpy);
+    gc = __glXGetCurrentContext();
+    if ((gc != NULL) && (dpy == gc->currentDpy) && 
+ 	((drawable == gc->currentDrawable) || (drawable == gc->currentReadable)) ) {
+	tag = gc->currentContextTag;
+    } else {
+	tag = 0;
+    }
+
+    /* Send the glXSwapBuffers request */
+    LockDisplay(dpy);
+    GetReq(GLXSwapBuffers,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXSwapBuffers;
+    req->drawable = drawable;
+    req->contextTag = tag;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    XFlush(dpy);
 }
 
 
@@ -923,72 +889,70 @@ glXSwapBuffers(Display * dpy, GLXDrawable drawable)
 ** Return configuration information for the given display, screen and
 ** visual combination.
 */
-PUBLIC int
-glXGetConfig(Display * dpy, XVisualInfo * vis, int attribute,
-             int *value_return)
-{
-   __GLXdisplayPrivate *priv;
-   __GLXscreenConfigs *psc;
-   __GLcontextModes *modes;
-   int status;
-
-   status = GetGLXPrivScreenConfig(dpy, vis->screen, &priv, &psc);
-   if (status == Success) {
-      modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
-
-      /* Lookup attribute after first finding a match on the visual */
-      if (modes != NULL) {
-         return _gl_get_context_mode_data(modes, attribute, value_return);
-      }
-
-      status = GLX_BAD_VISUAL;
-   }
-
-   /*
+PUBLIC int glXGetConfig(Display *dpy, XVisualInfo *vis, int attribute,
+			int *value_return)
+{
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+    __GLcontextModes *modes;
+    int   status;
+
+    status = GetGLXPrivScreenConfig( dpy, vis->screen, & priv, & psc );
+    if ( status == Success ) {
+	modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
+
+	/* Lookup attribute after first finding a match on the visual */
+	if ( modes != NULL ) {
+	    return _gl_get_context_mode_data( modes, attribute, value_return );
+	}
+	
+	status = GLX_BAD_VISUAL;
+    }
+
+    /*
     ** If we can't find the config for this visual, this visual is not
     ** supported by the OpenGL implementation on the server.
     */
-   if ((status == GLX_BAD_VISUAL) && (attribute == GLX_USE_GL)) {
-      *value_return = GL_FALSE;
-      status = Success;
-   }
+    if ( (status == GLX_BAD_VISUAL) && (attribute == GLX_USE_GL) ) {
+	*value_return = GL_FALSE;
+	status = Success;
+    }
 
-   return status;
+    return status;
 }
 
 /************************************************************************/
 
 static void
-init_fbconfig_for_chooser(__GLcontextModes * config,
-                          GLboolean fbconfig_style_tags)
+init_fbconfig_for_chooser( __GLcontextModes * config,
+			   GLboolean fbconfig_style_tags )
 {
-   memset(config, 0, sizeof(__GLcontextModes));
-   config->visualID = (XID) GLX_DONT_CARE;
-   config->visualType = GLX_DONT_CARE;
+    memset( config, 0, sizeof( __GLcontextModes ) );
+    config->visualID = (XID) GLX_DONT_CARE;
+    config->visualType = GLX_DONT_CARE;
 
-   /* glXChooseFBConfig specifies different defaults for these two than
-    * glXChooseVisual.
-    */
-   if (fbconfig_style_tags) {
-      config->rgbMode = GL_TRUE;
-      config->doubleBufferMode = GLX_DONT_CARE;
-   }
+    /* glXChooseFBConfig specifies different defaults for these two than
+     * glXChooseVisual.
+     */
+    if ( fbconfig_style_tags ) {
+	config->rgbMode = GL_TRUE;
+	config->doubleBufferMode = GLX_DONT_CARE;
+    }
 
-   config->visualRating = GLX_DONT_CARE;
-   config->transparentPixel = GLX_NONE;
-   config->transparentRed = GLX_DONT_CARE;
-   config->transparentGreen = GLX_DONT_CARE;
-   config->transparentBlue = GLX_DONT_CARE;
-   config->transparentAlpha = GLX_DONT_CARE;
-   config->transparentIndex = GLX_DONT_CARE;
+    config->visualRating = GLX_DONT_CARE;
+    config->transparentPixel = GLX_NONE;
+    config->transparentRed = GLX_DONT_CARE;
+    config->transparentGreen = GLX_DONT_CARE;
+    config->transparentBlue = GLX_DONT_CARE;
+    config->transparentAlpha = GLX_DONT_CARE;
+    config->transparentIndex = GLX_DONT_CARE;
 
-   config->drawableType = GLX_WINDOW_BIT;
-   config->renderType =
-      (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
-   config->xRenderable = GLX_DONT_CARE;
-   config->fbconfigID = (GLXFBConfigID) (GLX_DONT_CARE);
+    config->drawableType = GLX_WINDOW_BIT;
+    config->renderType = (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+    config->xRenderable = GLX_DONT_CARE;
+    config->fbconfigID = (GLXFBConfigID)(GLX_DONT_CARE);
 
-   config->swapMethod = GLX_DONT_CARE;
+    config->swapMethod = GLX_DONT_CARE;
 }
 
 #define MATCH_DONT_CARE( param ) \
@@ -1021,80 +985,80 @@ init_fbconfig_for_chooser(__GLcontextModes * config,
  * \param b  Server specified config to test against \c a.
  */
 static Bool
-fbconfigs_compatible(const __GLcontextModes * const a,
-                     const __GLcontextModes * const b)
-{
-   MATCH_DONT_CARE(doubleBufferMode);
-   MATCH_DONT_CARE(visualType);
-   MATCH_DONT_CARE(visualRating);
-   MATCH_DONT_CARE(xRenderable);
-   MATCH_DONT_CARE(fbconfigID);
-   MATCH_DONT_CARE(swapMethod);
-
-   MATCH_MINIMUM(rgbBits);
-   MATCH_MINIMUM(numAuxBuffers);
-   MATCH_MINIMUM(redBits);
-   MATCH_MINIMUM(greenBits);
-   MATCH_MINIMUM(blueBits);
-   MATCH_MINIMUM(alphaBits);
-   MATCH_MINIMUM(depthBits);
-   MATCH_MINIMUM(stencilBits);
-   MATCH_MINIMUM(accumRedBits);
-   MATCH_MINIMUM(accumGreenBits);
-   MATCH_MINIMUM(accumBlueBits);
-   MATCH_MINIMUM(accumAlphaBits);
-   MATCH_MINIMUM(sampleBuffers);
-   MATCH_MINIMUM(maxPbufferWidth);
-   MATCH_MINIMUM(maxPbufferHeight);
-   MATCH_MINIMUM(maxPbufferPixels);
-   MATCH_MINIMUM(samples);
-
-   MATCH_DONT_CARE(stereoMode);
-   MATCH_EXACT(level);
-
-   if (((a->drawableType & b->drawableType) == 0)
-       || ((a->renderType & b->renderType) == 0)) {
-      return False;
-   }
-
-
-   /* There is a bug in a few of the XFree86 DDX drivers.  They contain
-    * visuals with a "transparent type" of 0 when they really mean GLX_NONE.
-    * Technically speaking, it is a bug in the DDX driver, but there is
-    * enough of an installed base to work around the problem here.  In any
-    * case, 0 is not a valid value of the transparent type, so we'll treat 0 
-    * from the app as GLX_DONT_CARE. We'll consider GLX_NONE from the app and
-    * 0 from the server to be a match to maintain backward compatibility with
-    * the (broken) drivers.
-    */
-
-   if (a->transparentPixel != GLX_DONT_CARE && a->transparentPixel != 0) {
-      if (a->transparentPixel == GLX_NONE) {
-         if (b->transparentPixel != GLX_NONE && b->transparentPixel != 0)
-            return False;
-      }
-      else {
-         MATCH_EXACT(transparentPixel);
-      }
-
-      switch (a->transparentPixel) {
-      case GLX_TRANSPARENT_RGB:
-         MATCH_DONT_CARE(transparentRed);
-         MATCH_DONT_CARE(transparentGreen);
-         MATCH_DONT_CARE(transparentBlue);
-         MATCH_DONT_CARE(transparentAlpha);
-         break;
-
-      case GLX_TRANSPARENT_INDEX:
-         MATCH_DONT_CARE(transparentIndex);
-         break;
-
-      default:
-         break;
-      }
-   }
-
-   return True;
+fbconfigs_compatible( const __GLcontextModes * const a,
+		      const __GLcontextModes * const b )
+{
+    MATCH_DONT_CARE( doubleBufferMode );
+    MATCH_DONT_CARE( visualType );
+    MATCH_DONT_CARE( visualRating );
+    MATCH_DONT_CARE( xRenderable );
+    MATCH_DONT_CARE( fbconfigID );
+    MATCH_DONT_CARE( swapMethod );
+
+    MATCH_MINIMUM( rgbBits );
+    MATCH_MINIMUM( numAuxBuffers );
+    MATCH_MINIMUM( redBits );
+    MATCH_MINIMUM( greenBits );
+    MATCH_MINIMUM( blueBits );
+    MATCH_MINIMUM( alphaBits );
+    MATCH_MINIMUM( depthBits );
+    MATCH_MINIMUM( stencilBits );
+    MATCH_MINIMUM( accumRedBits );
+    MATCH_MINIMUM( accumGreenBits );
+    MATCH_MINIMUM( accumBlueBits );
+    MATCH_MINIMUM( accumAlphaBits );
+    MATCH_MINIMUM( sampleBuffers );
+    MATCH_MINIMUM( maxPbufferWidth );
+    MATCH_MINIMUM( maxPbufferHeight );
+    MATCH_MINIMUM( maxPbufferPixels );
+    MATCH_MINIMUM( samples );
+
+    MATCH_DONT_CARE( stereoMode );
+    MATCH_EXACT( level );
+
+    if ( ((a->drawableType & b->drawableType) == 0)
+	 || ((a->renderType & b->renderType) == 0) ) {
+	return False;
+    }
+
+
+    /* There is a bug in a few of the XFree86 DDX drivers.  They contain
+     * visuals with a "transparent type" of 0 when they really mean GLX_NONE.
+     * Technically speaking, it is a bug in the DDX driver, but there is
+     * enough of an installed base to work around the problem here.  In any
+     * case, 0 is not a valid value of the transparent type, so we'll treat 0 
+     * from the app as GLX_DONT_CARE. We'll consider GLX_NONE from the app and
+     * 0 from the server to be a match to maintain backward compatibility with
+     * the (broken) drivers.
+     */
+
+    if ( a->transparentPixel != GLX_DONT_CARE
+         && a->transparentPixel != 0 ) {
+        if ( a->transparentPixel == GLX_NONE ) {
+            if ( b->transparentPixel != GLX_NONE && b->transparentPixel != 0 )
+                return False;
+        } else {
+            MATCH_EXACT( transparentPixel );
+        }
+
+	switch ( a->transparentPixel ) {
+	  case GLX_TRANSPARENT_RGB:
+	    MATCH_DONT_CARE( transparentRed );
+	    MATCH_DONT_CARE( transparentGreen );
+	    MATCH_DONT_CARE( transparentBlue );
+	    MATCH_DONT_CARE( transparentAlpha );
+	    break;
+
+	  case GLX_TRANSPARENT_INDEX:
+	    MATCH_DONT_CARE( transparentIndex );
+	    break;
+
+	  default:
+	    break;
+	}
+    }
+
+    return True;
 }
 
 
@@ -1144,66 +1108,66 @@ fbconfigs_compatible(const __GLcontextModes * const a,
  * \sa qsort, glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
  */
 static int
-fbconfig_compare(const __GLcontextModes * const *const a,
-                 const __GLcontextModes * const *const b)
+fbconfig_compare( const __GLcontextModes * const * const a,
+		  const __GLcontextModes * const * const b )
 {
-   /* The order of these comparisons must NOT change.  It is defined by
-    * the GLX 1.3 spec and ARB_multisample.
-    */
+    /* The order of these comparisons must NOT change.  It is defined by
+     * the GLX 1.3 spec and ARB_multisample.
+     */
 
-   PREFER_SMALLER(visualSelectGroup);
+    PREFER_SMALLER( visualSelectGroup );
 
-   /* The sort order for the visualRating is GLX_NONE, GLX_SLOW, and
-    * GLX_NON_CONFORMANT_CONFIG.  It just so happens that this is the
-    * numerical sort order of the enums (0x8000, 0x8001, and 0x800D).
-    */
-   PREFER_SMALLER(visualRating);
+    /* The sort order for the visualRating is GLX_NONE, GLX_SLOW, and
+     * GLX_NON_CONFORMANT_CONFIG.  It just so happens that this is the
+     * numerical sort order of the enums (0x8000, 0x8001, and 0x800D).
+     */
+    PREFER_SMALLER( visualRating );
 
-   /* This isn't quite right.  It is supposed to compare the sum of the
-    * components the user specifically set minimums for.
-    */
-   PREFER_LARGER_OR_ZERO(redBits);
-   PREFER_LARGER_OR_ZERO(greenBits);
-   PREFER_LARGER_OR_ZERO(blueBits);
-   PREFER_LARGER_OR_ZERO(alphaBits);
+    /* This isn't quite right.  It is supposed to compare the sum of the
+     * components the user specifically set minimums for.
+     */
+    PREFER_LARGER_OR_ZERO( redBits );
+    PREFER_LARGER_OR_ZERO( greenBits );
+    PREFER_LARGER_OR_ZERO( blueBits );
+    PREFER_LARGER_OR_ZERO( alphaBits );
 
-   PREFER_SMALLER(rgbBits);
+    PREFER_SMALLER( rgbBits );
 
-   if (((*a)->doubleBufferMode != (*b)->doubleBufferMode)) {
-      /* Prefer single-buffer.
-       */
-      return (!(*a)->doubleBufferMode) ? -1 : 1;
-   }
+    if ( ((*a)->doubleBufferMode != (*b)->doubleBufferMode) ) {
+	/* Prefer single-buffer.
+	 */
+	return ( !(*a)->doubleBufferMode ) ? -1 : 1;
+    }
 
-   PREFER_SMALLER(numAuxBuffers);
+    PREFER_SMALLER( numAuxBuffers );
 
-   PREFER_LARGER_OR_ZERO(depthBits);
-   PREFER_SMALLER(stencilBits);
+    PREFER_LARGER_OR_ZERO( depthBits );
+    PREFER_SMALLER( stencilBits );
 
-   /* This isn't quite right.  It is supposed to compare the sum of the
-    * components the user specifically set minimums for.
-    */
-   PREFER_LARGER_OR_ZERO(accumRedBits);
-   PREFER_LARGER_OR_ZERO(accumGreenBits);
-   PREFER_LARGER_OR_ZERO(accumBlueBits);
-   PREFER_LARGER_OR_ZERO(accumAlphaBits);
+    /* This isn't quite right.  It is supposed to compare the sum of the
+     * components the user specifically set minimums for.
+     */
+    PREFER_LARGER_OR_ZERO( accumRedBits );
+    PREFER_LARGER_OR_ZERO( accumGreenBits );
+    PREFER_LARGER_OR_ZERO( accumBlueBits );
+    PREFER_LARGER_OR_ZERO( accumAlphaBits );
 
-   PREFER_SMALLER(visualType);
+    PREFER_SMALLER( visualType );
 
-   /* None of the multisample specs say where this comparison should happen,
-    * so I put it near the end.
-    */
-   PREFER_SMALLER(sampleBuffers);
-   PREFER_SMALLER(samples);
+    /* None of the multisample specs say where this comparison should happen,
+     * so I put it near the end.
+     */
+    PREFER_SMALLER( sampleBuffers );
+    PREFER_SMALLER( samples );
 
-   /* None of the pbuffer or fbconfig specs say that this comparison needs
-    * to happen at all, but it seems like it should.
-    */
-   PREFER_LARGER(maxPbufferWidth);
-   PREFER_LARGER(maxPbufferHeight);
-   PREFER_LARGER(maxPbufferPixels);
+    /* None of the pbuffer or fbconfig specs say that this comparison needs
+     * to happen at all, but it seems like it should.
+     */
+    PREFER_LARGER( maxPbufferWidth );
+    PREFER_LARGER( maxPbufferHeight );
+    PREFER_LARGER( maxPbufferPixels );
 
-   return 0;
+    return 0;
 }
 
 
@@ -1230,48 +1194,49 @@ fbconfig_compare(const __GLcontextModes * const *const a,
  * \sa glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
  */
 static int
-choose_visual(__GLcontextModes ** configs, int num_configs,
-              const int *attribList, GLboolean fbconfig_style_tags)
-{
-   __GLcontextModes test_config;
-   int base;
-   int i;
-
-   /* This is a fairly direct implementation of the selection method
-    * described by GLX_SGIX_fbconfig.  Start by culling out all the
-    * configs that are not compatible with the selected parameter
-    * list.
-    */
-
-   init_fbconfig_for_chooser(&test_config, fbconfig_style_tags);
-   __glXInitializeVisualConfigFromTags(&test_config, 512,
-                                       (const INT32 *) attribList,
-                                       GL_TRUE, fbconfig_style_tags);
-
-   base = 0;
-   for (i = 0; i < num_configs; i++) {
-      if (fbconfigs_compatible(&test_config, configs[i])) {
-         configs[base] = configs[i];
-         base++;
-      }
-   }
-
-   if (base == 0) {
-      return 0;
-   }
-
-   if (base < num_configs) {
-      (void) memset(&configs[base], 0, sizeof(void *) * (num_configs - base));
-   }
-
-   /* After the incompatible configs are removed, the resulting
-    * list is sorted according to the rules set out in the various
-    * specifications.
-    */
-
-   qsort(configs, base, sizeof(__GLcontextModes *),
-         (int (*)(const void *, const void *)) fbconfig_compare);
-   return base;
+choose_visual( __GLcontextModes ** configs, int num_configs,
+	       const int *attribList, GLboolean fbconfig_style_tags )
+{
+    __GLcontextModes    test_config;
+    int   base;
+    int   i;
+
+    /* This is a fairly direct implementation of the selection method
+     * described by GLX_SGIX_fbconfig.  Start by culling out all the
+     * configs that are not compatible with the selected parameter
+     * list.
+     */
+
+    init_fbconfig_for_chooser( & test_config, fbconfig_style_tags );
+    __glXInitializeVisualConfigFromTags( & test_config, 512,
+					 (const INT32 *) attribList,
+					 GL_TRUE, fbconfig_style_tags );
+
+    base = 0;
+    for ( i = 0 ; i < num_configs ; i++ ) {
+	if ( fbconfigs_compatible( & test_config, configs[i] ) ) {
+	    configs[ base ] = configs[ i ];
+	    base++;
+	}
+    }
+
+    if ( base == 0 ) {
+	return 0;
+    }
+ 
+    if ( base < num_configs ) {
+	(void) memset( & configs[ base ], 0, 
+		       sizeof( void * ) * (num_configs - base) );
+    }
+
+    /* After the incompatible configs are removed, the resulting
+     * list is sorted according to the rules set out in the various
+     * specifications.
+     */
+    
+    qsort( configs, base, sizeof( __GLcontextModes * ),
+	   (int (*)(const void*, const void*)) fbconfig_compare );
+    return base;
 }
 
 
@@ -1281,171 +1246,162 @@ choose_visual(__GLcontextModes ** configs, int num_configs,
 ** Return the visual that best matches the template.  Return None if no
 ** visual matches the template.
 */
-PUBLIC XVisualInfo *
-glXChooseVisual(Display * dpy, int screen, int *attribList)
+PUBLIC XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *attribList)
 {
-   XVisualInfo *visualList = NULL;
-   __GLXdisplayPrivate *priv;
-   __GLXscreenConfigs *psc;
-   __GLcontextModes test_config;
-   __GLcontextModes *modes;
-   const __GLcontextModes *best_config = NULL;
+    XVisualInfo *visualList = NULL;
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+    __GLcontextModes  test_config;
+    __GLcontextModes *modes;
+    const __GLcontextModes *best_config = NULL;
 
-   /*
+    /*
     ** Get a list of all visuals, return if list is empty
     */
-   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
-      return None;
-   }
-
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return None;
+    }
+   
 
-   /*
+    /*
     ** Build a template from the defaults and the attribute list
     ** Free visual list and return if an unexpected token is encountered
     */
-   init_fbconfig_for_chooser(&test_config, GL_FALSE);
-   __glXInitializeVisualConfigFromTags(&test_config, 512,
-                                       (const INT32 *) attribList,
-                                       GL_TRUE, GL_FALSE);
+    init_fbconfig_for_chooser( & test_config, GL_FALSE );
+    __glXInitializeVisualConfigFromTags( & test_config, 512, 
+					 (const INT32 *) attribList,
+					 GL_TRUE, GL_FALSE );
 
-   /*
+    /*
     ** Eliminate visuals that don't meet minimum requirements
     ** Compute a score for those that do
     ** Remember which visual, if any, got the highest score
     */
-   for (modes = psc->visuals; modes != NULL; modes = modes->next) {
-      if (fbconfigs_compatible(&test_config, modes)
-          && ((best_config == NULL)
-              ||
-              (fbconfig_compare
-               ((const __GLcontextModes * const *const) &modes,
-                &best_config) < 0))) {
-         best_config = modes;
-      }
-   }
-
-   /*
+    for ( modes = psc->visuals ; modes != NULL ; modes = modes->next ) {
+	if ( fbconfigs_compatible( & test_config, modes )
+	     && ((best_config == NULL)
+		 || (fbconfig_compare( (const __GLcontextModes * const * const)&modes, &best_config ) < 0)) ) {
+	    best_config = modes;
+	}
+    }
+
+    /*
     ** If no visual is acceptable, return None
     ** Otherwise, create an XVisualInfo list with just the selected X visual
     ** and return this.
     */
-   if (best_config != NULL) {
-      XVisualInfo visualTemplate;
-      int i;
-
-      visualTemplate.screen = screen;
-      visualTemplate.visualid = best_config->visualID;
-      visualList = XGetVisualInfo(dpy, VisualScreenMask | VisualIDMask,
-                                  &visualTemplate, &i);
-   }
+    if (best_config != NULL) {
+	XVisualInfo visualTemplate;
+	int  i;
+
+	visualTemplate.screen = screen;
+	visualTemplate.visualid = best_config->visualID;
+	visualList = XGetVisualInfo( dpy, VisualScreenMask|VisualIDMask,
+				     &visualTemplate, &i );
+    }
 
-   return visualList;
+    return visualList;
 }
 
 
-PUBLIC const char *
-glXQueryExtensionsString(Display * dpy, int screen)
+PUBLIC const char *glXQueryExtensionsString( Display *dpy, int screen )
 {
-   __GLXscreenConfigs *psc;
-   __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+    __GLXdisplayPrivate *priv;
 
-   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
-      return NULL;
-   }
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return NULL;
+    }
 
-   if (!psc->effectiveGLXexts) {
-      if (!psc->serverGLXexts) {
-         psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
-                                                       X_GLXQueryServerString,
-                                                       screen,
-                                                       GLX_EXTENSIONS);
-      }
+    if (!psc->effectiveGLXexts) {
+        if (!psc->serverGLXexts) {
+	    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
+					  	   X_GLXQueryServerString,
+					  	   screen, GLX_EXTENSIONS);
+	}
 
-      __glXCalculateUsableExtensions(psc,
+	__glXCalculateUsableExtensions(psc,
 #ifdef GLX_DIRECT_RENDERING
-                                     (psc->driScreen != NULL),
+				       (psc->driScreen != NULL),
 #else
-                                     GL_FALSE,
+				       GL_FALSE,
 #endif
-                                     priv->minorVersion);
-   }
+				       priv->minorVersion);
+    }
 
-   return psc->effectiveGLXexts;
+    return psc->effectiveGLXexts;
 }
 
-PUBLIC const char *
-glXGetClientString(Display * dpy, int name)
+PUBLIC const char *glXGetClientString( Display *dpy, int name )
 {
-   switch (name) {
-   case GLX_VENDOR:
-      return (__glXGLXClientVendorName);
-   case GLX_VERSION:
-      return (__glXGLXClientVersion);
-   case GLX_EXTENSIONS:
-      return (__glXGetClientExtensions());
-   default:
-      return NULL;
-   }
+    switch(name) {
+	case GLX_VENDOR:
+	    return (__glXGLXClientVendorName);
+	case GLX_VERSION:
+	    return (__glXGLXClientVersion);
+	case GLX_EXTENSIONS:
+	    return (__glXGetClientExtensions());
+	default:
+	    return NULL;
+    }
 }
 
-PUBLIC const char *
-glXQueryServerString(Display * dpy, int screen, int name)
+PUBLIC const char *glXQueryServerString( Display *dpy, int screen, int name )
 {
-   __GLXscreenConfigs *psc;
-   __GLXdisplayPrivate *priv;
-   const char **str;
+    __GLXscreenConfigs *psc;
+    __GLXdisplayPrivate *priv;
+    const char ** str;
 
 
-   if (GetGLXPrivScreenConfig(dpy, screen, &priv, &psc) != Success) {
-      return NULL;
-   }
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return NULL;
+    }
 
-   switch (name) {
-   case GLX_VENDOR:
-      str = &priv->serverGLXvendor;
-      break;
-   case GLX_VERSION:
-      str = &priv->serverGLXversion;
-      break;
-   case GLX_EXTENSIONS:
-      str = &psc->serverGLXexts;
-      break;
-   default:
-      return NULL;
-   }
+    switch(name) {
+	case GLX_VENDOR:
+	    str = & priv->serverGLXvendor;
+	    break;
+	case GLX_VERSION:
+	    str = & priv->serverGLXversion;
+	    break;
+	case GLX_EXTENSIONS:
+	    str = & psc->serverGLXexts;
+	    break;
+	default:
+	    return NULL;
+    }
 
-   if (*str == NULL) {
-      *str = __glXGetStringFromServer(dpy, priv->majorOpcode,
-                                      X_GLXQueryServerString, screen, name);
-   }
-
-   return *str;
+    if ( *str == NULL ) {
+	*str = __glXGetStringFromServer(dpy, priv->majorOpcode,
+					X_GLXQueryServerString, screen, name);
+    }
+    
+    return *str;
 }
 
-void
-__glXClientInfo(Display * dpy, int opcode)
+void __glXClientInfo (  Display *dpy, int opcode  )
 {
-   xGLXClientInfoReq *req;
-   int size;
-   char *ext_str = __glXGetClientGLExtensionString();
-
-   /* Send the glXClientInfo request */
-   LockDisplay(dpy);
-   GetReq(GLXClientInfo, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXClientInfo;
-   req->major = GLX_MAJOR_VERSION;
-   req->minor = GLX_MINOR_VERSION;
+    xGLXClientInfoReq *req;
+    int size;
+    char * ext_str = __glXGetClientGLExtensionString();
 
-   size = strlen(ext_str) + 1;
-   req->length += (size + 3) >> 2;
-   req->numbytes = size;
-   Data(dpy, ext_str, size);
+    /* Send the glXClientInfo request */
+    LockDisplay(dpy);
+    GetReq(GLXClientInfo,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXClientInfo;
+    req->major = GLX_MAJOR_VERSION;
+    req->minor = GLX_MINOR_VERSION;
 
-   UnlockDisplay(dpy);
-   SyncHandle();
+    size = strlen( ext_str ) + 1;
+    req->length += (size + 3) >> 2;
+    req->numbytes = size;
+    Data(dpy, ext_str, size);
 
-   Xfree(ext_str);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    
+    Xfree( ext_str );
 }
 
 
@@ -1453,18 +1409,15 @@ __glXClientInfo(Display * dpy, int opcode)
 ** EXT_import_context
 */
 
-PUBLIC Display *
-glXGetCurrentDisplay(void)
+PUBLIC Display *glXGetCurrentDisplay(void)
 {
-   GLXContext gc = __glXGetCurrentContext();
-   if (NULL == gc)
-      return NULL;
-   return gc->currentDpy;
+    GLXContext gc = __glXGetCurrentContext();
+    if (NULL == gc) return NULL;
+    return gc->currentDpy;
 }
 
-PUBLIC
-GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
-          glXGetCurrentDisplay)
+PUBLIC GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
+	  glXGetCurrentDisplay)
 
 /**
  * Used internally by libGL to send \c xGLXQueryContextinfoExtReq requests
@@ -1480,174 +1433,170 @@ GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
  * This function dynamically determines whether to use the EXT_import_context
  * version of the protocol or the GLX 1.3 version of the protocol.
  */
-     static int __glXQueryContextInfo(Display * dpy, GLXContext ctx)
-{
-   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
-   xGLXQueryContextReply reply;
-   CARD8 opcode;
-   GLuint numValues;
-   int retval;
-
-   if (ctx == NULL) {
-      return GLX_BAD_CONTEXT;
-   }
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode) {
-      return 0;
-   }
-
-   /* Send the glXQueryContextInfoEXT request */
-   LockDisplay(dpy);
-
-   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
-      xGLXQueryContextReq *req;
-
-      GetReq(GLXQueryContext, req);
-
-      req->reqType = opcode;
-      req->glxCode = X_GLXQueryContext;
-      req->context = (unsigned int) (ctx->xid);
-   }
-   else {
-      xGLXVendorPrivateReq *vpreq;
-      xGLXQueryContextInfoEXTReq *req;
-
-      GetReqExtra(GLXVendorPrivate,
-                  sz_xGLXQueryContextInfoEXTReq - sz_xGLXVendorPrivateReq,
-                  vpreq);
-      req = (xGLXQueryContextInfoEXTReq *) vpreq;
-      req->reqType = opcode;
-      req->glxCode = X_GLXVendorPrivateWithReply;
-      req->vendorCode = X_GLXvop_QueryContextInfoEXT;
-      req->context = (unsigned int) (ctx->xid);
-   }
-
-   _XReply(dpy, (xReply *) & reply, 0, False);
-
-   numValues = reply.n;
-   if (numValues == 0)
-      retval = Success;
-   else if (numValues > __GLX_MAX_CONTEXT_PROPS)
-      retval = 0;
-   else {
-      int *propList, *pProp;
-      int nPropListBytes;
-      int i;
-
-      nPropListBytes = numValues << 3;
-      propList = (int *) Xmalloc(nPropListBytes);
-      if (NULL == propList) {
-         retval = 0;
-      }
-      else {
-         _XRead(dpy, (char *) propList, nPropListBytes);
-         pProp = propList;
-         for (i = 0; i < numValues; i++) {
-            switch (*pProp++) {
-            case GLX_SHARE_CONTEXT_EXT:
-               ctx->share_xid = *pProp++;
-               break;
-            case GLX_VISUAL_ID_EXT:
-               ctx->mode =
-                  _gl_context_modes_find_visual(ctx->psc->visuals, *pProp++);
-               break;
-            case GLX_SCREEN:
-               ctx->screen = *pProp++;
-               break;
-            case GLX_FBCONFIG_ID:
-               ctx->mode =
-                  _gl_context_modes_find_fbconfig(ctx->psc->configs,
-                                                  *pProp++);
-               break;
-            case GLX_RENDER_TYPE:
-               ctx->renderType = *pProp++;
-               break;
-            default:
-               pProp++;
-               continue;
-            }
-         }
-         Xfree((char *) propList);
-         retval = Success;
-      }
-   }
-   UnlockDisplay(dpy);
-   SyncHandle();
-   return retval;
+static int __glXQueryContextInfo(Display *dpy, GLXContext ctx)
+{
+    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+    xGLXQueryContextReply reply;
+    CARD8 opcode;
+    GLuint numValues;
+    int retval;
+
+    if (ctx == NULL) {
+	return GLX_BAD_CONTEXT;
+    }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return 0;
+    }
+
+    /* Send the glXQueryContextInfoEXT request */
+    LockDisplay(dpy);
+
+    if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+	xGLXQueryContextReq *req;
+
+	GetReq(GLXQueryContext, req);
+
+	req->reqType = opcode;
+	req->glxCode = X_GLXQueryContext;
+	req->context = (unsigned int)(ctx->xid);
+    }
+    else {
+	xGLXVendorPrivateReq *vpreq;
+	xGLXQueryContextInfoEXTReq *req;
+
+	GetReqExtra( GLXVendorPrivate,
+		     sz_xGLXQueryContextInfoEXTReq - sz_xGLXVendorPrivateReq,
+		     vpreq );
+	req = (xGLXQueryContextInfoEXTReq *)vpreq;
+	req->reqType = opcode;
+	req->glxCode = X_GLXVendorPrivateWithReply;
+	req->vendorCode = X_GLXvop_QueryContextInfoEXT;
+	req->context = (unsigned int)(ctx->xid);
+    }
+
+    _XReply(dpy, (xReply*) &reply, 0, False);
+
+    numValues = reply.n;
+    if (numValues == 0)
+	retval = Success;
+    else if (numValues > __GLX_MAX_CONTEXT_PROPS)
+	retval = 0;
+    else
+    {
+	int *propList, *pProp;
+	int nPropListBytes;
+	int i;
+
+	nPropListBytes = numValues << 3;
+	propList = (int *) Xmalloc(nPropListBytes);
+	if (NULL == propList) {
+	    retval = 0;
+	} else {
+	    _XRead(dpy, (char *)propList, nPropListBytes);
+	    pProp = propList;
+	    for (i=0; i < numValues; i++) {
+		switch (*pProp++) {
+		case GLX_SHARE_CONTEXT_EXT:
+		    ctx->share_xid = *pProp++;
+		    break;
+		case GLX_VISUAL_ID_EXT:
+		    ctx->mode =
+			_gl_context_modes_find_visual(ctx->psc->visuals, *pProp++);
+		    break;
+		case GLX_SCREEN:
+		    ctx->screen = *pProp++;
+		    break;
+		case GLX_FBCONFIG_ID:
+		    ctx->mode =
+			_gl_context_modes_find_fbconfig(ctx->psc->configs, *pProp++);
+		    break;
+		case GLX_RENDER_TYPE:
+		    ctx->renderType = *pProp++;
+		    break;
+		default:
+		    pProp++;
+		    continue;
+		}
+	    }
+	    Xfree((char *)propList);
+	    retval = Success;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return retval;
 }
 
 PUBLIC int
-glXQueryContext(Display * dpy, GLXContext ctx, int attribute, int *value)
+glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value)
 {
-   int retVal;
+    int retVal;
 
-   /* get the information from the server if we don't have it already */
+    /* get the information from the server if we don't have it already */
 #ifdef GLX_DIRECT_RENDERING
-   if (!ctx->driContext && (ctx->mode == NULL)) {
+    if (!ctx->driContext && (ctx->mode == NULL)) {
 #else
-   if (ctx->mode == NULL) {
+    if (ctx->mode == NULL) {
 #endif
-      retVal = __glXQueryContextInfo(dpy, ctx);
-      if (Success != retVal)
-         return retVal;
-   }
-   switch (attribute) {
-   case GLX_SHARE_CONTEXT_EXT:
-      *value = (int) (ctx->share_xid);
-      break;
-   case GLX_VISUAL_ID_EXT:
-      *value = ctx->mode ? ctx->mode->visualID : None;
-      break;
-   case GLX_SCREEN:
-      *value = (int) (ctx->screen);
-      break;
-   case GLX_FBCONFIG_ID:
-      *value = ctx->mode ? ctx->mode->fbconfigID : None;
-      break;
-   case GLX_RENDER_TYPE:
-      *value = (int) (ctx->renderType);
-      break;
-   default:
-      return GLX_BAD_ATTRIBUTE;
-   }
-   return Success;
+	retVal = __glXQueryContextInfo(dpy, ctx);
+	if (Success != retVal) return retVal;
+    }
+    switch (attribute) {
+    case GLX_SHARE_CONTEXT_EXT:
+	*value = (int)(ctx->share_xid);
+	break;
+    case GLX_VISUAL_ID_EXT:
+	*value = ctx->mode ? ctx->mode->visualID : None;
+	break;
+    case GLX_SCREEN:
+	*value = (int)(ctx->screen);
+	break;
+    case GLX_FBCONFIG_ID:
+	*value = ctx->mode ? ctx->mode->fbconfigID : None;
+	break;
+    case GLX_RENDER_TYPE:
+	*value = (int)(ctx->renderType);
+	break;
+    default:
+	return GLX_BAD_ATTRIBUTE;
+    }
+    return Success;
 }
 
-PUBLIC
-GLX_ALIAS(int, glXQueryContextInfoEXT,
-          (Display * dpy, GLXContext ctx, int attribute, int *value),
-          (dpy, ctx, attribute, value), glXQueryContext)
+PUBLIC GLX_ALIAS( int, glXQueryContextInfoEXT,
+	   (Display *dpy, GLXContext ctx, int attribute, int *value),
+	   (dpy, ctx, attribute, value),
+	   glXQueryContext )
 
-     PUBLIC GLXContextID glXGetContextIDEXT(const GLXContext ctx)
+PUBLIC GLXContextID glXGetContextIDEXT(const GLXContext ctx)
 {
-   return ctx->xid;
+    return ctx->xid;
 }
 
-PUBLIC GLXContext
-glXImportContextEXT(Display * dpy, GLXContextID contextID)
+PUBLIC GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID)
 {
-   GLXContext ctx;
+    GLXContext ctx;
 
-   if (contextID == None) {
-      return NULL;
-   }
-   if (__glXIsDirect(dpy, contextID)) {
-      return NULL;
-   }
+    if (contextID == None) {
+	return NULL;
+    }
+    if (__glXIsDirect(dpy, contextID)) {
+	return NULL;
+    }
 
-   ctx = CreateContext(dpy, NULL, NULL, NULL, False, contextID, False, 0);
-   if (NULL != ctx) {
-      if (Success != __glXQueryContextInfo(dpy, ctx)) {
-         return NULL;
-      }
-   }
-   return ctx;
+    ctx = CreateContext(dpy, NULL, NULL, NULL, False, contextID, False, 0);
+    if (NULL != ctx) {
+	if (Success != __glXQueryContextInfo(dpy, ctx)) {
+	   return NULL;
+	}
+    }
+    return ctx;
 }
 
-PUBLIC void
-glXFreeContextEXT(Display * dpy, GLXContext ctx)
+PUBLIC void glXFreeContextEXT(Display *dpy, GLXContext ctx)
 {
-   DestroyContext(dpy, ctx);
+    DestroyContext(dpy, ctx);
 }
 
 
@@ -1656,149 +1605,146 @@ glXFreeContextEXT(Display * dpy, GLXContext ctx)
  * GLX 1.3 functions - these are just stubs for now!
  */
 
-PUBLIC GLXFBConfig *
-glXChooseFBConfig(Display * dpy, int screen,
-                  const int *attribList, int *nitems)
+PUBLIC GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen,
+				      const int *attribList, int *nitems)
 {
-   __GLcontextModes **config_list;
-   int list_size;
+    __GLcontextModes ** config_list;
+    int   list_size;
 
 
-   config_list = (__GLcontextModes **)
-      glXGetFBConfigs(dpy, screen, &list_size);
+    config_list = (__GLcontextModes **) 
+	glXGetFBConfigs( dpy, screen, & list_size );
 
-   if ((config_list != NULL) && (list_size > 0) && (attribList != NULL)) {
-      list_size = choose_visual(config_list, list_size, attribList, GL_TRUE);
-      if (list_size == 0) {
-         XFree(config_list);
-         config_list = NULL;
-      }
-   }
+    if ( (config_list != NULL) && (list_size > 0) && (attribList != NULL) ) {
+	list_size = choose_visual( config_list, list_size, attribList,
+				   GL_TRUE );
+	if ( list_size == 0 ) {
+	    XFree( config_list );
+	    config_list = NULL;
+	}
+    }
 
-   *nitems = list_size;
-   return (GLXFBConfig *) config_list;
+    *nitems = list_size;
+    return (GLXFBConfig *) config_list;
 }
 
 
-PUBLIC GLXContext
-glXCreateNewContext(Display * dpy, GLXFBConfig config,
-                    int renderType, GLXContext shareList, Bool allowDirect)
+PUBLIC GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config,
+				      int renderType, GLXContext shareList,
+				      Bool allowDirect)
 {
-   return CreateContext(dpy, NULL, (__GLcontextModes *) config, shareList,
-                        allowDirect, None, True, renderType);
+    return CreateContext( dpy, NULL, (__GLcontextModes *) config, shareList,
+			  allowDirect, None, True, renderType );
 }
 
 
-PUBLIC GLXDrawable
-glXGetCurrentReadDrawable(void)
+PUBLIC GLXDrawable glXGetCurrentReadDrawable(void)
 {
-   GLXContext gc = __glXGetCurrentContext();
-   return gc->currentReadable;
+    GLXContext gc = __glXGetCurrentContext();
+    return gc->currentReadable;
 }
 
 
-PUBLIC GLXFBConfig *
-glXGetFBConfigs(Display * dpy, int screen, int *nelements)
+PUBLIC GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements)
 {
-   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
-   __GLcontextModes **config = NULL;
-   int i;
+    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+    __GLcontextModes ** config = NULL;
+    int   i;
 
-   *nelements = 0;
-   if ((priv->screenConfigs != NULL)
-       && (screen >= 0) && (screen <= ScreenCount(dpy))
-       && (priv->screenConfigs[screen].configs != NULL)
-       && (priv->screenConfigs[screen].configs->fbconfigID != GLX_DONT_CARE)) {
-      unsigned num_configs = 0;
-      __GLcontextModes *modes;
+    *nelements = 0;
+    if ( (priv->screenConfigs != NULL)
+	 && (screen >= 0) && (screen <= ScreenCount(dpy))
+	 && (priv->screenConfigs[screen].configs != NULL)
+	 && (priv->screenConfigs[screen].configs->fbconfigID != GLX_DONT_CARE) ) {
+	unsigned num_configs = 0;
+	__GLcontextModes * modes;
 
 
-      for (modes = priv->screenConfigs[screen].configs; modes != NULL;
-           modes = modes->next) {
-         if (modes->fbconfigID != GLX_DONT_CARE) {
-            num_configs++;
-         }
-      }
+	for ( modes = priv->screenConfigs[screen].configs
+	      ; modes != NULL
+	      ; modes = modes->next ) {
+	    if ( modes->fbconfigID != GLX_DONT_CARE ) {
+		num_configs++;
+	    }
+	}
 
-      config = (__GLcontextModes **) Xmalloc(sizeof(__GLcontextModes *)
-                                             * num_configs);
-      if (config != NULL) {
-         *nelements = num_configs;
-         i = 0;
-         for (modes = priv->screenConfigs[screen].configs; modes != NULL;
-              modes = modes->next) {
-            if (modes->fbconfigID != GLX_DONT_CARE) {
-               config[i] = modes;
-               i++;
-            }
-         }
-      }
-   }
-   return (GLXFBConfig *) config;
+	config = (__GLcontextModes **) Xmalloc( sizeof(__GLcontextModes *)
+						* num_configs );
+	if ( config != NULL ) {
+	    *nelements = num_configs;
+	    i = 0;
+	    for ( modes = priv->screenConfigs[screen].configs
+		  ; modes != NULL
+		  ; modes = modes->next ) {
+		if ( modes->fbconfigID != GLX_DONT_CARE ) {
+		    config[i] = modes;
+		    i++;
+		}
+	    }
+	}
+    }
+    return (GLXFBConfig *) config;
 }
 
 
-PUBLIC int
-glXGetFBConfigAttrib(Display * dpy, GLXFBConfig config,
-                     int attribute, int *value)
+PUBLIC int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config,
+				int attribute, int *value)
 {
-   __GLcontextModes *const modes = ValidateGLXFBConfig(dpy, config);
+    __GLcontextModes * const modes = ValidateGLXFBConfig( dpy, config );
 
-   return (modes != NULL)
-      ? _gl_get_context_mode_data(modes, attribute, value)
-      : GLXBadFBConfig;
+    return (modes != NULL)
+	? _gl_get_context_mode_data( modes, attribute, value )
+	: GLXBadFBConfig;
 }
 
 
-PUBLIC XVisualInfo *
-glXGetVisualFromFBConfig(Display * dpy, GLXFBConfig config)
+PUBLIC XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config)
 {
-   XVisualInfo visualTemplate;
-   __GLcontextModes *fbconfig = (__GLcontextModes *) config;
-   int count;
+    XVisualInfo visualTemplate;
+    __GLcontextModes * fbconfig = (__GLcontextModes *) config;
+    int  count;
 
-   /*
+    /*
     ** Get a list of all visuals, return if list is empty
     */
-   visualTemplate.visualid = fbconfig->visualID;
-   return XGetVisualInfo(dpy, VisualIDMask, &visualTemplate, &count);
+    visualTemplate.visualid = fbconfig->visualID;
+    return XGetVisualInfo(dpy,VisualIDMask,&visualTemplate,&count);
 }
 
 
 /*
 ** GLX_SGI_swap_control
 */
-static int
-__glXSwapIntervalSGI(int interval)
+static int __glXSwapIntervalSGI(int interval)
 {
    xGLXVendorPrivateReq *req;
    GLXContext gc = __glXGetCurrentContext();
-   Display *dpy;
-   CARD32 *interval_ptr;
+   Display * dpy;
+   CARD32 * interval_ptr;
    CARD8 opcode;
 
-   if (gc == NULL) {
+   if ( gc == NULL ) {
       return GLX_BAD_CONTEXT;
    }
-
-   if (interval <= 0) {
+   
+   if ( interval <= 0 ) {
       return GLX_BAD_VALUE;
    }
 
 #ifdef __DRI_SWAP_CONTROL
    if (gc->driContext) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(gc->currentDpy,
-                                                          gc->screen);
-      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(gc->currentDpy,
-                                                  gc->currentDrawable,
-                                                  NULL);
-      if (psc->swapControl != NULL && pdraw != NULL) {
-         psc->swapControl->setSwapInterval(pdraw->driDrawable, interval);
-         return 0;
-      }
-      else {
-         return GLX_BAD_CONTEXT;
-      }
+       __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							     gc->screen );
+       __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(gc->currentDpy,
+						   gc->currentDrawable,
+						   NULL);
+       if (psc->swapControl != NULL && pdraw != NULL) {
+	   psc->swapControl->setSwapInterval(pdraw->driDrawable, interval);
+	   return 0;
+       }
+       else {
+	   return GLX_BAD_CONTEXT;
+       }
    }
 #endif
    dpy = gc->currentDpy;
@@ -1809,7 +1755,7 @@ __glXSwapIntervalSGI(int interval)
 
    /* Send the glXSwapIntervalSGI request */
    LockDisplay(dpy);
-   GetReqExtra(GLXVendorPrivate, sizeof(CARD32), req);
+   GetReqExtra(GLXVendorPrivate,sizeof(CARD32),req);
    req->reqType = opcode;
    req->glxCode = X_GLXVendorPrivate;
    req->vendorCode = X_GLXvop_SwapIntervalSGI;
@@ -1829,27 +1775,26 @@ __glXSwapIntervalSGI(int interval)
 /*
 ** GLX_MESA_swap_control
 */
-static int
-__glXSwapIntervalMESA(unsigned int interval)
+static int __glXSwapIntervalMESA(unsigned int interval)
 {
 #ifdef __DRI_SWAP_CONTROL
    GLXContext gc = __glXGetCurrentContext();
 
-   if (interval < 0) {
+   if ( interval < 0 ) {
       return GLX_BAD_VALUE;
    }
 
    if (gc != NULL && gc->driContext) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(gc->currentDpy,
-                                                          gc->screen);
-
-      if ((psc != NULL) && (psc->driScreen != NULL)) {
-         __GLXDRIdrawable *pdraw =
-            GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
-         if (psc->swapControl != NULL && pdraw != NULL) {
-            psc->swapControl->setSwapInterval(pdraw->driDrawable, interval);
-            return 0;
-         }
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      
+      if ( (psc != NULL) && (psc->driScreen != NULL) ) {
+	 __GLXDRIdrawable *pdraw = 
+	     GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+	 if (psc->swapControl != NULL && pdraw != NULL) {
+	    psc->swapControl->setSwapInterval(pdraw->driDrawable, interval);
+	    return 0;
+	 }
       }
    }
 #else
@@ -1858,24 +1803,23 @@ __glXSwapIntervalMESA(unsigned int interval)
 
    return GLX_BAD_CONTEXT;
 }
+ 
 
-
-static int
-__glXGetSwapIntervalMESA(void)
+static int __glXGetSwapIntervalMESA(void)
 {
 #ifdef __DRI_SWAP_CONTROL
    GLXContext gc = __glXGetCurrentContext();
 
    if (gc != NULL && gc->driContext) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(gc->currentDpy,
-                                                          gc->screen);
-
-      if ((psc != NULL) && (psc->driScreen != NULL)) {
-         __GLXDRIdrawable *pdraw =
-            GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
-         if (psc->swapControl != NULL && pdraw != NULL) {
-            return psc->swapControl->getSwapInterval(pdraw->driDrawable);
-         }
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      
+      if ( (psc != NULL) && (psc->driScreen != NULL) ) {
+	 __GLXDRIdrawable *pdraw = 
+	     GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+	 if (psc->swapControl != NULL && pdraw != NULL) {
+	    return psc->swapControl->getSwapInterval(pdraw->driDrawable);
+	 }
       }
    }
 #endif
@@ -1888,17 +1832,16 @@ __glXGetSwapIntervalMESA(void)
 ** GLX_MESA_swap_frame_usage
 */
 
-static GLint
-__glXBeginFrameTrackingMESA(Display * dpy, GLXDrawable drawable)
+static GLint __glXBeginFrameTrackingMESA(Display *dpy, GLXDrawable drawable)
 {
-   int status = GLX_BAD_CONTEXT;
+   int   status = GLX_BAD_CONTEXT;
 #ifdef __DRI_FRAME_TRACKING
    int screen;
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
 
    if (pdraw != NULL && psc->frameTracking != NULL)
-      status = psc->frameTracking->frameTracking(pdraw->driDrawable, GL_TRUE);
+       status = psc->frameTracking->frameTracking(pdraw->driDrawable, GL_TRUE);
 #else
    (void) dpy;
    (void) drawable;
@@ -1906,19 +1849,18 @@ __glXBeginFrameTrackingMESA(Display * dpy, GLXDrawable drawable)
    return status;
 }
 
-
-static GLint
-__glXEndFrameTrackingMESA(Display * dpy, GLXDrawable drawable)
+    
+static GLint __glXEndFrameTrackingMESA(Display *dpy, GLXDrawable drawable)
 {
-   int status = GLX_BAD_CONTEXT;
+   int   status = GLX_BAD_CONTEXT;
 #ifdef __DRI_FRAME_TRACKING
    int screen;
-   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, & screen);
    __GLXscreenConfigs *psc = GetGLXScreenConfigs(dpy, screen);
 
    if (pdraw != NULL && psc->frameTracking != NULL)
-      status = psc->frameTracking->frameTracking(pdraw->driDrawable,
-                                                 GL_FALSE);
+       status = psc->frameTracking->frameTracking(pdraw->driDrawable,
+						  GL_FALSE);
 #else
    (void) dpy;
    (void) drawable;
@@ -1927,24 +1869,24 @@ __glXEndFrameTrackingMESA(Display * dpy, GLXDrawable drawable)
 }
 
 
-static GLint
-__glXGetFrameUsageMESA(Display * dpy, GLXDrawable drawable, GLfloat * usage)
+static GLint __glXGetFrameUsageMESA(Display *dpy, GLXDrawable drawable,
+				    GLfloat *usage)
 {
-   int status = GLX_BAD_CONTEXT;
+   int   status = GLX_BAD_CONTEXT;
 #ifdef __DRI_FRAME_TRACKING
    int screen;
-   __GLXDRIdrawable *const pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+   __GLXDRIdrawable * const pdraw = GetGLXDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
 
    if (pdraw != NULL && psc->frameTracking != NULL) {
-      int64_t sbc, missedFrames;
-      float lastMissedUsage;
+       int64_t sbc, missedFrames;
+       float   lastMissedUsage;
 
-      status = psc->frameTracking->queryFrameTracking(pdraw->driDrawable,
-                                                      &sbc,
-                                                      &missedFrames,
-                                                      &lastMissedUsage,
-                                                      usage);
+       status = psc->frameTracking->queryFrameTracking(pdraw->driDrawable,
+						       &sbc,
+						       &missedFrames,
+						       &lastMissedUsage,
+						       usage);
    }
 #else
    (void) dpy;
@@ -1955,24 +1897,22 @@ __glXGetFrameUsageMESA(Display * dpy, GLXDrawable drawable, GLfloat * usage)
 }
 
 
-static GLint
-__glXQueryFrameTrackingMESA(Display * dpy, GLXDrawable drawable,
-                            int64_t * sbc, int64_t * missedFrames,
-                            GLfloat * lastMissedUsage)
+static GLint __glXQueryFrameTrackingMESA(Display *dpy, GLXDrawable drawable,
+					 int64_t *sbc, int64_t *missedFrames,
+					 GLfloat *lastMissedUsage)
 {
-   int status = GLX_BAD_CONTEXT;
+   int   status = GLX_BAD_CONTEXT;
 #ifdef __DRI_FRAME_TRACKING
    int screen;
-   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
 
    if (pdraw != NULL && psc->frameTracking != NULL) {
-      float usage;
+      float   usage;
 
       status = psc->frameTracking->queryFrameTracking(pdraw->driDrawable,
-                                                      sbc, missedFrames,
-                                                      lastMissedUsage,
-                                                      &usage);
+						      sbc, missedFrames,
+						      lastMissedUsage, &usage);
    }
 #else
    (void) dpy;
@@ -1988,8 +1928,7 @@ __glXQueryFrameTrackingMESA(Display * dpy, GLXDrawable drawable,
 /*
 ** GLX_SGI_video_sync
 */
-static int
-__glXGetVideoSyncSGI(unsigned int *count)
+static int __glXGetVideoSyncSGI(unsigned int *count)
 {
    /* FIXME: Looking at the GLX_SGI_video_sync spec in the extension registry,
     * FIXME: there should be a GLX encoding for this call.  I can find no
@@ -2000,50 +1939,49 @@ __glXGetVideoSyncSGI(unsigned int *count)
 
 
    if (gc != NULL && gc->driContext) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(gc->currentDpy,
-                                                          gc->screen);
-      if (psc->msc && psc->driScreen) {
-         __GLXDRIdrawable *pdraw =
-            GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
-         int64_t temp;
-         int ret;
-
-         ret = (*psc->msc->getDrawableMSC) (psc->__driScreen,
-                                            pdraw->driDrawable, &temp);
-         *count = (unsigned) temp;
-
-         return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      if ( psc->msc && psc->driScreen ) {
+          __GLXDRIdrawable *pdraw = 
+              GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+	  int64_t temp; 
+	  int ret;
+ 
+	  ret = (*psc->msc->getDrawableMSC)(psc->__driScreen,
+					    pdraw->driDrawable, &temp);
+	  *count = (unsigned) temp;
+
+	  return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
       }
    }
 #else
-   (void) count;
+    (void) count;
 #endif
    return GLX_BAD_CONTEXT;
 }
 
-static int
-__glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+static int __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
 {
 #ifdef __DRI_MEDIA_STREAM_COUNTER
    GLXContext gc = __glXGetCurrentContext();
 
-   if (divisor <= 0 || remainder < 0)
-      return GLX_BAD_VALUE;
+   if ( divisor <= 0 || remainder < 0 )
+     return GLX_BAD_VALUE;
 
    if (gc != NULL && gc->driContext) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(gc->currentDpy,
-                                                          gc->screen);
-      if (psc->msc != NULL && psc->driScreen) {
-         __GLXDRIdrawable *pdraw =
-            GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
-         int ret;
-         int64_t msc;
-         int64_t sbc;
-
-         ret = (*psc->msc->waitForMSC) (pdraw->driDrawable, 0,
-                                        divisor, remainder, &msc, &sbc);
-         *count = (unsigned) msc;
-         return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      if (psc->msc != NULL && psc->driScreen ) {
+	 __GLXDRIdrawable *pdraw = 
+	     GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+	 int       ret;
+	 int64_t   msc;
+	 int64_t   sbc;
+
+	 ret = (*psc->msc->waitForMSC)(pdraw->driDrawable, 0,
+				       divisor, remainder, &msc, &sbc);
+	 *count = (unsigned) msc;
+	 return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
       }
    }
 #else
@@ -2059,112 +1997,109 @@ __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
 ** GLX_functions table.
 */
 
-PUBLIC
-GLX_ALIAS(int, glXGetFBConfigAttribSGIX,
-          (Display * dpy, GLXFBConfigSGIX config, int attribute, int *value),
-          (dpy, config, attribute, value), glXGetFBConfigAttrib)
+PUBLIC GLX_ALIAS(int, glXGetFBConfigAttribSGIX,
+	  (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value),
+	  (dpy, config, attribute, value),
+	  glXGetFBConfigAttrib)
 
-     PUBLIC GLX_ALIAS(GLXFBConfigSGIX *, glXChooseFBConfigSGIX,
-                      (Display * dpy, int screen, int *attrib_list,
-                       int *nelements), (dpy, screen, attrib_list, nelements),
-                      glXChooseFBConfig)
+PUBLIC GLX_ALIAS(GLXFBConfigSGIX *, glXChooseFBConfigSGIX,
+	  (Display *dpy, int screen, int *attrib_list, int *nelements),
+	  (dpy, screen, attrib_list, nelements),
+	  glXChooseFBConfig)
 
-     PUBLIC GLX_ALIAS(XVisualInfo *, glXGetVisualFromFBConfigSGIX,
-                      (Display * dpy, GLXFBConfigSGIX config),
-                      (dpy, config), glXGetVisualFromFBConfig)
+PUBLIC GLX_ALIAS(XVisualInfo *, glXGetVisualFromFBConfigSGIX,
+	  (Display * dpy, GLXFBConfigSGIX config),
+	  (dpy, config),
+	  glXGetVisualFromFBConfig)
 
-     PUBLIC GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display * dpy,
-                                                       GLXFBConfigSGIX config,
-                                                       Pixmap pixmap)
+PUBLIC GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy,
+                            GLXFBConfigSGIX config, Pixmap pixmap)
 {
-   xGLXVendorPrivateWithReplyReq *vpreq;
-   xGLXCreateGLXPixmapWithConfigSGIXReq *req;
-   GLXPixmap xid = None;
-   CARD8 opcode;
-   const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
-   __GLXscreenConfigs *psc;
+    xGLXVendorPrivateWithReplyReq *vpreq;
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req;
+    GLXPixmap xid = None;
+    CARD8 opcode;
+    const __GLcontextModes * const fbconfig = (__GLcontextModes *) config;
+    __GLXscreenConfigs * psc;
 
 
-   if ((dpy == NULL) || (config == NULL)) {
-      return None;
-   }
+    if ( (dpy == NULL) || (config == NULL) ) {
+	return None;
+    }
 
-   psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
-   if ((psc != NULL)
-       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
-      opcode = __glXSetupForCommand(dpy);
-      if (!opcode) {
-         return None;
-      }
+    psc = GetGLXScreenConfigs( dpy, fbconfig->screen );
+    if ( (psc != NULL) 
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit ) ) {
+	opcode = __glXSetupForCommand(dpy);
+	if (!opcode) {
+	    return None;
+	}
 
-      /* Send the glXCreateGLXPixmapWithConfigSGIX request */
-      LockDisplay(dpy);
-      GetReqExtra(GLXVendorPrivateWithReply,
-                  sz_xGLXCreateGLXPixmapWithConfigSGIXReq -
-                  sz_xGLXVendorPrivateWithReplyReq, vpreq);
-      req = (xGLXCreateGLXPixmapWithConfigSGIXReq *) vpreq;
-      req->reqType = opcode;
-      req->glxCode = X_GLXVendorPrivateWithReply;
-      req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
-      req->screen = fbconfig->screen;
-      req->fbconfig = fbconfig->fbconfigID;
-      req->pixmap = pixmap;
-      req->glxpixmap = xid = XAllocID(dpy);
-      UnlockDisplay(dpy);
-      SyncHandle();
-   }
+	/* Send the glXCreateGLXPixmapWithConfigSGIX request */
+	LockDisplay(dpy);
+	GetReqExtra(GLXVendorPrivateWithReply,
+		    sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
+	req->reqType = opcode;
+	req->glxCode = X_GLXVendorPrivateWithReply;
+	req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
+	req->screen = fbconfig->screen;
+	req->fbconfig = fbconfig->fbconfigID;
+	req->pixmap = pixmap;
+	req->glxpixmap = xid = XAllocID(dpy);
+	UnlockDisplay(dpy);
+	SyncHandle();
+    }
 
-   return xid;
+    return xid;
 }
 
-PUBLIC GLXContext
-glXCreateContextWithConfigSGIX(Display * dpy,
-                               GLXFBConfigSGIX config, int renderType,
-                               GLXContext shareList, Bool allowDirect)
+PUBLIC GLXContext glXCreateContextWithConfigSGIX(Display *dpy,
+                             GLXFBConfigSGIX config, int renderType,
+                             GLXContext shareList, Bool allowDirect)
 {
-   GLXContext gc = NULL;
-   const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
-   __GLXscreenConfigs *psc;
+    GLXContext gc = NULL;
+    const __GLcontextModes * const fbconfig = (__GLcontextModes *) config;
+    __GLXscreenConfigs * psc;
 
 
-   if ((dpy == NULL) || (config == NULL)) {
-      return None;
-   }
+    if ( (dpy == NULL) || (config == NULL) ) {
+	return None;
+    }
 
-   psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
-   if ((psc != NULL)
-       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
-      gc = CreateContext(dpy, NULL, (__GLcontextModes *) config, shareList,
-                         allowDirect, None, False, renderType);
-   }
+    psc = GetGLXScreenConfigs( dpy, fbconfig->screen );
+    if ( (psc != NULL) 
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit ) ) {
+	gc = CreateContext( dpy, NULL, (__GLcontextModes *) config, shareList,
+			    allowDirect, None, False, renderType );
+    }
 
-   return gc;
+    return gc;
 }
 
 
-PUBLIC GLXFBConfigSGIX
-glXGetFBConfigFromVisualSGIX(Display * dpy, XVisualInfo * vis)
+PUBLIC GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
+						    XVisualInfo *vis)
 {
-   __GLXdisplayPrivate *priv;
-   __GLXscreenConfigs *psc;
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
 
-   if ((GetGLXPrivScreenConfig(dpy, vis->screen, &priv, &psc) != Success)
-       && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)
-       && (psc->configs->fbconfigID != GLX_DONT_CARE)) {
-      return (GLXFBConfigSGIX) _gl_context_modes_find_visual(psc->configs,
-                                                             vis->visualid);
-   }
+    if ( (GetGLXPrivScreenConfig( dpy, vis->screen, & priv, & psc ) != Success)
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit )
+	 && (psc->configs->fbconfigID != GLX_DONT_CARE) ) {
+	return (GLXFBConfigSGIX) _gl_context_modes_find_visual( psc->configs,
+								vis->visualid );
+    }
 
-   return NULL;
+    return NULL;
 }
 
 
 /*
 ** GLX_SGIX_swap_group
 */
-static void
-__glXJoinSwapGroupSGIX(Display * dpy, GLXDrawable drawable,
-                       GLXDrawable member)
+static void __glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable,
+				   GLXDrawable member)
 {
    (void) dpy;
    (void) drawable;
@@ -2175,16 +2110,15 @@ __glXJoinSwapGroupSGIX(Display * dpy, GLXDrawable drawable,
 /*
 ** GLX_SGIX_swap_barrier
 */
-static void
-__glXBindSwapBarrierSGIX(Display * dpy, GLXDrawable drawable, int barrier)
+static void __glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable,
+				     int barrier)
 {
    (void) dpy;
    (void) drawable;
    (void) barrier;
 }
 
-static Bool
-__glXQueryMaxSwapBarriersSGIX(Display * dpy, int screen, int *max)
+static Bool __glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
 {
    (void) dpy;
    (void) screen;
@@ -2196,24 +2130,23 @@ __glXQueryMaxSwapBarriersSGIX(Display * dpy, int screen, int *max)
 /*
 ** GLX_OML_sync_control
 */
-static Bool
-__glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
-                      int64_t * ust, int64_t * msc, int64_t * sbc)
+static Bool __glXGetSyncValuesOML(Display *dpy, GLXDrawable drawable,
+				  int64_t *ust, int64_t *msc, int64_t *sbc)
 {
 #if defined(__DRI_SWAP_BUFFER_COUNTER) && defined(__DRI_MEDIA_STREAM_COUNTER)
-   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
-
-   if (priv != NULL) {
-      int i;
-      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &i);
-      __GLXscreenConfigs *const psc = &priv->screenConfigs[i];
-
-      assert((pdraw == NULL) || (i != -1));
-      return ((pdraw && psc->sbc && psc->msc)
-              && ((*psc->msc->getMSC) (psc->driScreen, msc) == 0)
-              && ((*psc->sbc->getSBC) (pdraw->driDrawable, sbc) == 0)
-              && (__glXGetUST(ust) == 0));
-   }
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+
+    if ( priv != NULL ) {
+	int   i;
+	__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &i);
+	__GLXscreenConfigs * const psc = &priv->screenConfigs[i];
+
+	assert( (pdraw == NULL) || (i != -1) );
+	return ( (pdraw && psc->sbc && psc->msc)
+		 && ((*psc->msc->getMSC)(psc->driScreen, msc) == 0)
+		 && ((*psc->sbc->getSBC)(pdraw->driDrawable, sbc) == 0)
+		 && (__glXGetUST(ust) == 0) );
+    }
 #else
    (void) dpy;
    (void) drawable;
@@ -2226,63 +2159,63 @@ __glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
 
 #ifdef GLX_DIRECT_RENDERING
 _X_HIDDEN GLboolean
-__driGetMscRateOML(__DRIdrawable * draw,
-                   int32_t * numerator, int32_t * denominator, void *private)
+__driGetMscRateOML(__DRIdrawable *draw,
+		   int32_t *numerator, int32_t *denominator, void *private)
 {
 #ifdef XF86VIDMODE
-   __GLXscreenConfigs *psc;
-   XF86VidModeModeLine mode_line;
-   int dot_clock;
-   int i;
-   __GLXDRIdrawable *glxDraw = private;
-
-   psc = glxDraw->psc;
-   if (XF86VidModeQueryVersion(psc->dpy, &i, &i) &&
-       XF86VidModeGetModeLine(psc->dpy, psc->scr, &dot_clock, &mode_line)) {
-      unsigned n = dot_clock * 1000;
-      unsigned d = mode_line.vtotal * mode_line.htotal;
-
+    __GLXscreenConfigs *psc;
+    XF86VidModeModeLine   mode_line;
+    int   dot_clock;
+    int   i;
+    __GLXDRIdrawable *glxDraw = private;
+
+    psc = glxDraw->psc;
+    if (XF86VidModeQueryVersion(psc->dpy, &i, &i) &&
+	XF86VidModeGetModeLine(psc->dpy, psc->scr, &dot_clock, &mode_line) ) {
+	unsigned   n = dot_clock * 1000;
+	unsigned   d = mode_line.vtotal * mode_line.htotal;
+	
 # define V_INTERLACE 0x010
 # define V_DBLSCAN   0x020
 
-      if (mode_line.flags & V_INTERLACE)
-         n *= 2;
-      else if (mode_line.flags & V_DBLSCAN)
-         d *= 2;
-
-      /* The OML_sync_control spec requires that if the refresh rate is a
-       * whole number, that the returned numerator be equal to the refresh
-       * rate and the denominator be 1.
-       */
-
-      if (n % d == 0) {
-         n /= d;
-         d = 1;
-      }
-      else {
-         static const unsigned f[] = { 13, 11, 7, 5, 3, 2, 0 };
-
-         /* This is a poor man's way to reduce a fraction.  It's far from
-          * perfect, but it will work well enough for this situation.
-          */
-
-         for (i = 0; f[i] != 0; i++) {
-            while (n % f[i] == 0 && d % f[i] == 0) {
-               d /= f[i];
-               n /= f[i];
-            }
-         }
-      }
-
-      *numerator = n;
-      *denominator = d;
-
-      return True;
-   }
-   else
-      return False;
+	if (mode_line.flags & V_INTERLACE)
+	    n *= 2;
+	else if (mode_line.flags & V_DBLSCAN)
+	    d *= 2;
+
+	/* The OML_sync_control spec requires that if the refresh rate is a
+	 * whole number, that the returned numerator be equal to the refresh
+	 * rate and the denominator be 1.
+	 */
+
+	if (n % d == 0) {
+	    n /= d;
+	    d = 1;
+	}
+	else {
+	    static const unsigned f[] = { 13, 11, 7, 5, 3, 2, 0 };
+
+	    /* This is a poor man's way to reduce a fraction.  It's far from
+	     * perfect, but it will work well enough for this situation.
+	     */
+
+	    for (i = 0; f[i] != 0; i++) {
+		while (n % f[i] == 0 && d % f[i] == 0) {
+		    d /= f[i];
+		    n /= f[i];
+		}
+	    }
+	}
+
+	*numerator = n;
+	*denominator = d;
+
+	return True;
+    }
+    else
+	return False;
 #else
-   return False;
+    return False;
 #endif
 }
 #endif
@@ -2303,17 +2236,17 @@ __driGetMscRateOML(__DRIdrawable * draw,
  *       when GLX_OML_sync_control appears in the client extension string.
  */
 
-_X_HIDDEN GLboolean
-__glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
-                   int32_t * numerator, int32_t * denominator)
+_X_HIDDEN GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
+				       int32_t * numerator,
+				       int32_t * denominator)
 {
 #if defined( GLX_DIRECT_RENDERING ) && defined( XF86VIDMODE )
-   __GLXDRIdrawable *draw = GetGLXDRIDrawable(dpy, drawable, NULL);
+    __GLXDRIdrawable *draw = GetGLXDRIDrawable(dpy, drawable, NULL);
 
-   if (draw == NULL)
-      return False;
+    if (draw == NULL)
+	return False;
 
-   return __driGetMscRateOML(draw->driDrawable, numerator, denominator, draw);
+    return __driGetMscRateOML(draw->driDrawable, numerator, denominator, draw);
 #else
    (void) dpy;
    (void) drawable;
@@ -2324,28 +2257,28 @@ __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
 }
 
 
-static int64_t
-__glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
-                       int64_t target_msc, int64_t divisor, int64_t remainder)
+static int64_t __glXSwapBuffersMscOML(Display *dpy, GLXDrawable drawable,
+				      int64_t target_msc, int64_t divisor,
+				      int64_t remainder)
 {
 #ifdef __DRI_SWAP_BUFFER_COUNTER
    int screen;
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
 
    /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
     * error", but it also says "It [glXSwapBuffersMscOML] will return a value
     * of -1 if the function failed because of errors detected in the input
     * parameters"
     */
-   if (divisor < 0 || remainder < 0 || target_msc < 0)
+   if ( divisor < 0 || remainder < 0 || target_msc < 0 )
       return -1;
-   if (divisor > 0 && remainder >= divisor)
+   if ( divisor > 0 && remainder >= divisor )
       return -1;
 
    if (pdraw != NULL && psc->counters != NULL)
-      return (*psc->sbc->swapBuffersMSC) (pdraw->driDrawable, target_msc,
-                                          divisor, remainder);
+      return (*psc->sbc->swapBuffersMSC)(pdraw->driDrawable, target_msc,
+					 divisor, remainder);
 
 #else
    (void) dpy;
@@ -2358,34 +2291,33 @@ __glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
 }
 
 
-static Bool
-__glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
-                   int64_t target_msc, int64_t divisor,
-                   int64_t remainder, int64_t * ust,
-                   int64_t * msc, int64_t * sbc)
+static Bool __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
+			       int64_t target_msc, int64_t divisor,
+			       int64_t remainder, int64_t *ust,
+			       int64_t *msc, int64_t *sbc)
 {
 #ifdef __DRI_MEDIA_STREAM_COUNTER
    int screen;
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
-   int ret;
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+   int  ret;
 
    /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
     * error", but the return type in the spec is Bool.
     */
-   if (divisor < 0 || remainder < 0 || target_msc < 0)
+   if ( divisor < 0 || remainder < 0 || target_msc < 0 )
       return False;
-   if (divisor > 0 && remainder >= divisor)
+   if ( divisor > 0 && remainder >= divisor )
       return False;
 
    if (pdraw != NULL && psc->msc != NULL) {
-      ret = (*psc->msc->waitForMSC) (pdraw->driDrawable, target_msc,
-                                     divisor, remainder, msc, sbc);
+      ret = (*psc->msc->waitForMSC)(pdraw->driDrawable, target_msc,
+				    divisor, remainder, msc, sbc);
 
       /* __glXGetUST returns zero on success and non-zero on failure.
        * This function returns True on success and False on failure.
        */
-      return ((ret == 0) && (__glXGetUST(ust) == 0));
+      return ( (ret == 0) && (__glXGetUST( ust ) == 0) );
    }
 #else
    (void) dpy;
@@ -2401,31 +2333,29 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
 }
 
 
-static Bool
-__glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
-                   int64_t target_sbc, int64_t * ust,
-                   int64_t * msc, int64_t * sbc)
+static Bool __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
+			       int64_t target_sbc, int64_t *ust,
+			       int64_t *msc, int64_t *sbc )
 {
 #ifdef __DRI_SWAP_BUFFER_COUNTER
    int screen;
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
-   int ret;
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+   int  ret;
 
    /* The OML_sync_control spec says this should "generate a GLX_BAD_VALUE
     * error", but the return type in the spec is Bool.
     */
-   if (target_sbc < 0)
+   if ( target_sbc < 0 )
       return False;
 
    if (pdraw != NULL && psc->sbc != NULL) {
-      ret =
-         (*psc->sbc->waitForSBC) (pdraw->driDrawable, target_sbc, msc, sbc);
+      ret = (*psc->sbc->waitForSBC)(pdraw->driDrawable, target_sbc, msc, sbc);
 
       /* __glXGetUST returns zero on success and non-zero on failure.
        * This function returns True on success and False on failure.
        */
-      return ((ret == 0) && (__glXGetUST(ust) == 0));
+      return( (ret == 0) && (__glXGetUST( ust ) == 0) );
    }
 #else
    (void) dpy;
@@ -2444,17 +2374,16 @@ __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
  */
 /*@{*/
 
-PUBLIC void *
-glXAllocateMemoryMESA(Display * dpy, int scrn,
-                      size_t size, float readFreq,
-                      float writeFreq, float priority)
+PUBLIC void *glXAllocateMemoryMESA(Display *dpy, int scrn,
+				   size_t size, float readFreq,
+				   float writeFreq, float priority)
 {
 #ifdef __DRI_ALLOCATE
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, scrn);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
 
    if (psc && psc->allocate)
-      return (*psc->allocate->allocateMemory) (psc->__driScreen, size,
-                                               readFreq, writeFreq, priority);
+       return (*psc->allocate->allocateMemory)(psc->__driScreen, size,
+					       readFreq, writeFreq, priority);
 
 #else
    (void) dpy;
@@ -2469,14 +2398,13 @@ glXAllocateMemoryMESA(Display * dpy, int scrn,
 }
 
 
-PUBLIC void
-glXFreeMemoryMESA(Display * dpy, int scrn, void *pointer)
+PUBLIC void glXFreeMemoryMESA(Display *dpy, int scrn, void *pointer)
 {
 #ifdef __DRI_ALLOCATE
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, scrn);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
 
    if (psc && psc->allocate)
-      (*psc->allocate->freeMemory) (psc->__driScreen, pointer);
+	 (*psc->allocate->freeMemory)(psc->__driScreen, pointer);
 
 #else
    (void) dpy;
@@ -2486,14 +2414,14 @@ glXFreeMemoryMESA(Display * dpy, int scrn, void *pointer)
 }
 
 
-PUBLIC GLuint
-glXGetMemoryOffsetMESA(Display * dpy, int scrn, const void *pointer)
+PUBLIC GLuint glXGetMemoryOffsetMESA( Display *dpy, int scrn,
+				      const void *pointer )
 {
 #ifdef __DRI_ALLOCATE
-   __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, scrn);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
 
    if (psc && psc->allocate)
-      return (*psc->allocate->memoryOffset) (psc->__driScreen, pointer);
+       return (*psc->allocate->memoryOffset)(psc->__driScreen, pointer);
 
 #else
    (void) dpy;
@@ -2503,7 +2431,6 @@ glXGetMemoryOffsetMESA(Display * dpy, int scrn, const void *pointer)
 
    return ~0L;
 }
-
 /*@}*/
 
 
@@ -2534,8 +2461,7 @@ glXGetMemoryOffsetMESA(Display * dpy, int scrn, const void *pointer)
  *     glXDestroyPbuffer glXDestroyPixmap glXDestroyWindow
  *     glXDestroyGLXPbufferSGIX glXDestroyGLXVideoSourceSGIX
  */
-static Bool
-__glXReleaseBuffersMESA(Display * dpy, GLXDrawable d)
+static Bool __glXReleaseBuffersMESA( Display *dpy, GLXDrawable d )
 {
    (void) dpy;
    (void) d;
@@ -2543,9 +2469,8 @@ __glXReleaseBuffersMESA(Display * dpy, GLXDrawable d)
 }
 
 
-PUBLIC GLXPixmap
-glXCreateGLXPixmapMESA(Display * dpy, XVisualInfo * visual,
-                       Pixmap pixmap, Colormap cmap)
+PUBLIC GLXPixmap glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visual,
+					 Pixmap pixmap, Colormap cmap )
 {
    (void) dpy;
    (void) visual;
@@ -2553,7 +2478,6 @@ glXCreateGLXPixmapMESA(Display * dpy, XVisualInfo * visual,
    (void) cmap;
    return 0;
 }
-
 /*@}*/
 
 
@@ -2561,70 +2485,68 @@ glXCreateGLXPixmapMESA(Display * dpy, XVisualInfo * visual,
  * GLX_MESA_copy_sub_buffer
  */
 #define X_GLXvop_CopySubBufferMESA 5154 /* temporary */
-static void
-__glXCopySubBufferMESA(Display * dpy, GLXDrawable drawable,
-                       int x, int y, int width, int height)
+static void __glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable,
+				   int x, int y, int width, int height)
 {
-   xGLXVendorPrivateReq *req;
-   GLXContext gc;
-   GLXContextTag tag;
-   CARD32 *drawable_ptr;
-   INT32 *x_ptr, *y_ptr, *w_ptr, *h_ptr;
-   CARD8 opcode;
+    xGLXVendorPrivateReq *req;
+    GLXContext gc;
+    GLXContextTag tag;
+    CARD32 *drawable_ptr;
+    INT32 *x_ptr, *y_ptr, *w_ptr, *h_ptr;
+    CARD8 opcode;
 
 #ifdef __DRI_COPY_SUB_BUFFER
-   int screen;
-   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-   if (pdraw != NULL) {
-      __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
-      if (psc->copySubBuffer != NULL) {
-         (*psc->copySubBuffer->copySubBuffer) (pdraw->driDrawable,
-                                               x, y, width, height);
-      }
-
-      return;
-   }
+    int screen;
+    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+    if ( pdraw != NULL ) {
+	__GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+	if (psc->copySubBuffer != NULL) {
+	    (*psc->copySubBuffer->copySubBuffer)(pdraw->driDrawable,
+						 x, y, width, height);
+	}
+
+	return;
+    }
 #endif
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode)
-      return;
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode)
+	return;
 
-   /*
+    /*
     ** The calling thread may or may not have a current context.  If it
     ** does, send the context tag so the server can do a flush.
     */
-   gc = __glXGetCurrentContext();
-   if ((gc != NULL) && (dpy == gc->currentDpy) &&
-       ((drawable == gc->currentDrawable) ||
-        (drawable == gc->currentReadable))) {
-      tag = gc->currentContextTag;
-   }
-   else {
-      tag = 0;
-   }
-
-   LockDisplay(dpy);
-   GetReqExtra(GLXVendorPrivate, sizeof(CARD32) + sizeof(INT32) * 4, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXVendorPrivate;
-   req->vendorCode = X_GLXvop_CopySubBufferMESA;
-   req->contextTag = tag;
-
-   drawable_ptr = (CARD32 *) (req + 1);
-   x_ptr = (INT32 *) (drawable_ptr + 1);
-   y_ptr = (INT32 *) (drawable_ptr + 2);
-   w_ptr = (INT32 *) (drawable_ptr + 3);
-   h_ptr = (INT32 *) (drawable_ptr + 4);
-
-   *drawable_ptr = drawable;
-   *x_ptr = x;
-   *y_ptr = y;
-   *w_ptr = width;
-   *h_ptr = height;
-
-   UnlockDisplay(dpy);
-   SyncHandle();
+    gc = __glXGetCurrentContext();
+    if ((gc != NULL) && (dpy == gc->currentDpy) &&
+	((drawable == gc->currentDrawable) ||
+	 (drawable == gc->currentReadable)) ) {
+	tag = gc->currentContextTag;
+    } else {
+	tag = 0;
+    }
+
+    LockDisplay(dpy);
+    GetReqExtra(GLXVendorPrivate, sizeof(CARD32) + sizeof(INT32) * 4,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXVendorPrivate;
+    req->vendorCode = X_GLXvop_CopySubBufferMESA;
+    req->contextTag = tag;
+
+    drawable_ptr = (CARD32 *) (req + 1);
+    x_ptr = (INT32 *) (drawable_ptr + 1);
+    y_ptr = (INT32 *) (drawable_ptr + 2);
+    w_ptr = (INT32 *) (drawable_ptr + 3);
+    h_ptr = (INT32 *) (drawable_ptr + 4);
+
+    *drawable_ptr = drawable;
+    *x_ptr = x;
+    *y_ptr = y;
+    *w_ptr = width;
+    *h_ptr = height;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
 
 
@@ -2632,112 +2554,114 @@ __glXCopySubBufferMESA(Display * dpy, GLXDrawable drawable,
  * GLX_EXT_texture_from_pixmap
  */
 /*@{*/
-static void
-__glXBindTexImageEXT(Display * dpy,
-                     GLXDrawable drawable, int buffer, const int *attrib_list)
-{
-   xGLXVendorPrivateReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   CARD32 *drawable_ptr;
-   INT32 *buffer_ptr;
-   CARD32 *num_attrib_ptr;
-   CARD32 *attrib_ptr;
-   CARD8 opcode;
-   unsigned int i;
-
-   if (gc == NULL)
-      return;
-
-   i = 0;
-   if (attrib_list) {
-      while (attrib_list[i * 2] != None)
-         i++;
-   }
-
+static void __glXBindTexImageEXT(Display *dpy,
+				 GLXDrawable drawable,
+				 int buffer,
+				 const int *attrib_list)
+{
+    xGLXVendorPrivateReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    CARD32 *drawable_ptr;
+    INT32 *buffer_ptr;
+    CARD32 *num_attrib_ptr;
+    CARD32 *attrib_ptr;
+    CARD8 opcode;
+    unsigned int i;
+
+    if (gc == NULL)
+	return;
+
+    i = 0;
+    if (attrib_list) {
+ 	while (attrib_list[i * 2] != None)
+ 	    i++;
+    }
+ 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext) {
-      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
+    if (gc->driContext) {
+	__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
 
-      if (pdraw != NULL)
-         (*pdraw->psc->texBuffer->setTexBuffer) (gc->__driContext,
-                                                 pdraw->textureTarget,
-                                                 pdraw->driDrawable);
+	if (pdraw != NULL)
+	    (*pdraw->psc->texBuffer->setTexBuffer)(gc->__driContext,
+						   pdraw->textureTarget,
+						   pdraw->driDrawable);
 
-      return;
-   }
+	return;
+    }
 #endif
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode)
-      return;
-
-   LockDisplay(dpy);
-   GetReqExtra(GLXVendorPrivate, 12 + 8 * i, req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXVendorPrivate;
-   req->vendorCode = X_GLXvop_BindTexImageEXT;
-   req->contextTag = gc->currentContextTag;
-
-   drawable_ptr = (CARD32 *) (req + 1);
-   buffer_ptr = (INT32 *) (drawable_ptr + 1);
-   num_attrib_ptr = (CARD32 *) (buffer_ptr + 1);
-   attrib_ptr = (CARD32 *) (num_attrib_ptr + 1);
-
-   *drawable_ptr = drawable;
-   *buffer_ptr = buffer;
-   *num_attrib_ptr = (CARD32) i;
-
-   i = 0;
-   if (attrib_list) {
-      while (attrib_list[i * 2] != None) {
-         *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 0];
-         *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 1];
-         i++;
-      }
-   }
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-}
-
-static void
-__glXReleaseTexImageEXT(Display * dpy, GLXDrawable drawable, int buffer)
-{
-   xGLXVendorPrivateReq *req;
-   GLXContext gc = __glXGetCurrentContext();
-   CARD32 *drawable_ptr;
-   INT32 *buffer_ptr;
-   CARD8 opcode;
-
-   if (gc == NULL)
-      return;
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode)
+	return;
+
+    LockDisplay(dpy);
+    GetReqExtra(GLXVendorPrivate, 12 + 8 * i,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXVendorPrivate;
+    req->vendorCode = X_GLXvop_BindTexImageEXT;
+    req->contextTag = gc->currentContextTag;
+
+    drawable_ptr = (CARD32 *) (req + 1);
+    buffer_ptr = (INT32 *) (drawable_ptr + 1);
+    num_attrib_ptr = (CARD32 *) (buffer_ptr + 1);
+    attrib_ptr = (CARD32 *) (num_attrib_ptr + 1);
+
+    *drawable_ptr = drawable;
+    *buffer_ptr = buffer;
+    *num_attrib_ptr = (CARD32) i;
+
+    i = 0;
+    if (attrib_list) {
+ 	while (attrib_list[i * 2] != None)
+ 	{
+ 	    *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 0];
+ 	    *attrib_ptr++ = (CARD32) attrib_list[i * 2 + 1];
+ 	    i++;
+ 	}
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+static void __glXReleaseTexImageEXT(Display *dpy,
+				    GLXDrawable drawable,
+				    int buffer)
+{
+    xGLXVendorPrivateReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    CARD32 *drawable_ptr;
+    INT32 *buffer_ptr;
+    CARD8 opcode;
+
+    if (gc == NULL)
+	return;
 
 #ifdef GLX_DIRECT_RENDERING
-   if (gc->driContext)
-      return;
+    if (gc->driContext)
+	return;
 #endif
 
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode)
-      return;
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode)
+	return;
 
-   LockDisplay(dpy);
-   GetReqExtra(GLXVendorPrivate, sizeof(CARD32) + sizeof(INT32), req);
-   req->reqType = opcode;
-   req->glxCode = X_GLXVendorPrivate;
-   req->vendorCode = X_GLXvop_ReleaseTexImageEXT;
-   req->contextTag = gc->currentContextTag;
+    LockDisplay(dpy);
+    GetReqExtra(GLXVendorPrivate, sizeof(CARD32)+sizeof(INT32),req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXVendorPrivate;
+    req->vendorCode = X_GLXvop_ReleaseTexImageEXT;
+    req->contextTag = gc->currentContextTag;
 
-   drawable_ptr = (CARD32 *) (req + 1);
-   buffer_ptr = (INT32 *) (drawable_ptr + 1);
+    drawable_ptr = (CARD32 *) (req + 1);
+    buffer_ptr = (INT32 *) (drawable_ptr + 1);
 
-   *drawable_ptr = drawable;
-   *buffer_ptr = buffer;
+    *drawable_ptr = drawable;
+    *buffer_ptr = buffer;
 
-   UnlockDisplay(dpy);
-   SyncHandle();
+    UnlockDisplay(dpy);
+    SyncHandle();
 }
-
 /*@}*/
 
 /**
@@ -2761,8 +2685,7 @@ __glXstrdup(const char *str)
 ** glXGetProcAddress support
 */
 
-struct name_address_pair
-{
+struct name_address_pair {
    const char *Name;
    GLvoid *Address;
 };
@@ -2907,6 +2830,7 @@ static const struct name_address_pair GLX_functions[] = {
    { NULL, NULL }   /* end of list */
 };
 
+
 static const GLvoid *
 get_glx_proc_address(const char *funcName)
 {
@@ -2915,7 +2839,7 @@ get_glx_proc_address(const char *funcName)
    /* try static functions */
    for (i = 0; GLX_functions[i].Name; i++) {
       if (strcmp(GLX_functions[i].Name, funcName) == 0)
-         return GLX_functions[i].Address;
+	 return GLX_functions[i].Address;
    }
 
    return NULL;
@@ -2931,9 +2855,9 @@ get_glx_proc_address(const char *funcName)
  *
  * \sa glXGetProcAddress
  */
-PUBLIC void (*glXGetProcAddressARB(const GLubyte * procName)) (void)
+PUBLIC void (*glXGetProcAddressARB(const GLubyte *procName))( void )
 {
-   typedef void (*gl_function) (void);
+   typedef void (*gl_function)( void );
    gl_function f;
 
 
@@ -2945,8 +2869,8 @@ PUBLIC void (*glXGetProcAddressARB(const GLubyte * procName)) (void)
     */
 
    f = (gl_function) get_glx_proc_address((const char *) procName);
-   if ((f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
-       && (procName[2] != 'X')) {
+   if ( (f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
+	&& (procName[2] != 'X') ) {
       f = (gl_function) _glapi_get_proc_address((const char *) procName);
    }
 
@@ -2962,9 +2886,9 @@ PUBLIC void (*glXGetProcAddressARB(const GLubyte * procName)) (void)
  *
  * \sa glXGetProcAddressARB
  */
-PUBLIC void (*glXGetProcAddress(const GLubyte * procName)) (void)
+PUBLIC void (*glXGetProcAddress(const GLubyte *procName))( void )
 #if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
-   __attribute__ ((alias("glXGetProcAddressARB")));
+    __attribute__ ((alias ("glXGetProcAddressARB")));
 #else
 {
    return glXGetProcAddressARB(procName);
@@ -2987,21 +2911,19 @@ PUBLIC void (*glXGetProcAddress(const GLubyte * procName)) (void)
  *
  * \since Internal API version 20030317.
  */
-_X_HIDDEN int
-__glXGetUST(int64_t * ust)
-{
-   struct timeval tv;
-
-   if (ust == NULL) {
-      return -EFAULT;
-   }
-
-   if (gettimeofday(&tv, NULL) == 0) {
-      ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec;
-      return 0;
-   }
-   else {
-      return -errno;
-   }
+_X_HIDDEN int __glXGetUST( int64_t * ust )
+{
+    struct timeval  tv;
+    
+    if ( ust == NULL ) {
+	return -EFAULT;
+    }
+
+    if ( gettimeofday( & tv, NULL ) == 0 ) {
+	ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec;
+	return 0;
+    } else {
+	return -errno;
+    }
 }
 #endif /* GLX_DIRECT_RENDERING */