Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 335 insertions, 371 deletions

diff --git a/xorg-server/exa/exa_unaccel.c b/xorg-server/exa/exa_unaccel.c
index 492a352c6..fc0f6c42e 100644
--- a/xorg-server/exa/exa_unaccel.c
+++ b/xorg-server/exa/exa_unaccel.c
@@ -45,7 +45,7 @@ exaPrepareAccessGC(GCPtr pGC)
     if (pGC->stipple)
         exaPrepareAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
     if (pGC->fillStyle == FillTiled)
-	exaPrepareAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
+        exaPrepareAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
 }
 
 /**
@@ -55,7 +55,7 @@ void
 exaFinishAccessGC(GCPtr pGC)
 {
     if (pGC->fillStyle == FillTiled)
-	exaFinishAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
+        exaFinishAccess(&pGC->tile.pixmap->drawable, EXA_PREPARE_SRC);
     if (pGC->stipple)
         exaFinishAccess(&pGC->stipple->drawable, EXA_PREPARE_MASK);
 }
@@ -66,304 +66,303 @@ exaDrawableLocation(DrawablePtr pDrawable)
 {
     return exaDrawableIsOffscreen(pDrawable) ? 's' : 'm';
 }
-#endif /* DEBUG_TRACE_FALL */
+#endif                          /* DEBUG_TRACE_FALL */
 
 void
-ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans,
-		   DDXPointPtr ppt, int *pwidth, int fSorted)
+ExaCheckFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
+                  DDXPointPtr ppt, int *pwidth, int fSorted)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->FillSpans (pDrawable, pGC, nspans, ppt, pwidth, fSorted);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->FillSpans(pDrawable, pGC, nspans, ppt, pwidth, fSorted);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc,
-		 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
+ExaCheckSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
+                 DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    pGC->ops->SetSpans (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    pGC->ops->SetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth,
-		 int x, int y, int w, int h, int leftPad, int format,
-		 char *bits)
+ExaCheckPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
+                 int x, int y, int w, int h, int leftPad, int format,
+                 char *bits)
 {
     PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+
     ExaPixmapPriv(pPixmap);
 
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
     if (!pExaScr->prepare_access_reg || !pExaPixmap->pDamage ||
-	exaGCReadsDestination(pDrawable, pGC->planemask, pGC->fillStyle,
-			      pGC->alu, pGC->clientClipType))
-	exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
+        exaGCReadsDestination(pDrawable, pGC->planemask, pGC->fillStyle,
+                              pGC->alu, pGC->clientClipType))
+        exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
     else
-	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST,
-				    DamagePendingRegion(pExaPixmap->pDamage));
-    pGC->ops->PutImage (pDrawable, pGC, depth, x, y, w, h, leftPad, format, bits);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+        pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST,
+                                    DamagePendingRegion(pExaPixmap->pDamage));
+    pGC->ops->PutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
+                       bits);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckCopyNtoN (DrawablePtr pSrc, DrawablePtr pDst,  GCPtr pGC,
-	     BoxPtr	pbox, int nbox, int dx, int dy, Bool	reverse, 
-	     Bool upsidedown, Pixel bitplane, void *closure)
+ExaCheckCopyNtoN(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                 BoxPtr pbox, int nbox, int dx, int dy, Bool reverse,
+                 Bool upsidedown, Pixel bitplane, void *closure)
 {
     RegionRec reg;
     int xoff, yoff;
+
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
+                  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
 
     if (pExaScr->prepare_access_reg && RegionInitBoxes(&reg, pbox, nbox)) {
-	PixmapPtr pPixmap = exaGetDrawablePixmap(pSrc);
+        PixmapPtr pPixmap = exaGetDrawablePixmap(pSrc);
 
-	exaGetDrawableDeltas(pSrc, pPixmap, &xoff, &yoff);
-	RegionTranslate(&reg, xoff + dx, yoff + dy);
-	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, &reg);
-	RegionUninit(&reg);
-    } else
-	exaPrepareAccess (pSrc, EXA_PREPARE_SRC);
+        exaGetDrawableDeltas(pSrc, pPixmap, &xoff, &yoff);
+        RegionTranslate(&reg, xoff + dx, yoff + dy);
+        pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, &reg);
+        RegionUninit(&reg);
+    }
+    else
+        exaPrepareAccess(pSrc, EXA_PREPARE_SRC);
 
     if (pExaScr->prepare_access_reg &&
-	!exaGCReadsDestination(pDst, pGC->planemask, pGC->fillStyle,
-			       pGC->alu, pGC->clientClipType) &&
-	RegionInitBoxes (&reg, pbox, nbox)) {
-	PixmapPtr pPixmap = exaGetDrawablePixmap(pDst);
-
-	exaGetDrawableDeltas(pDst, pPixmap, &xoff, &yoff);
-	RegionTranslate(&reg, xoff, yoff);
-	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST, &reg);
-	RegionUninit(&reg);
-    } else
-	exaPrepareAccess (pDst, EXA_PREPARE_DEST);
+        !exaGCReadsDestination(pDst, pGC->planemask, pGC->fillStyle,
+                               pGC->alu, pGC->clientClipType) &&
+        RegionInitBoxes(&reg, pbox, nbox)) {
+        PixmapPtr pPixmap = exaGetDrawablePixmap(pDst);
+
+        exaGetDrawableDeltas(pDst, pPixmap, &xoff, &yoff);
+        RegionTranslate(&reg, xoff, yoff);
+        pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST, &reg);
+        RegionUninit(&reg);
+    }
+    else
+        exaPrepareAccess(pDst, EXA_PREPARE_DEST);
 
     /* This will eventually call fbCopyNtoN, with some calculation overhead. */
     while (nbox--) {
-	pGC->ops->CopyArea (pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx, pbox->y1 - pSrc->y + dy, 
-			pbox->x2 - pbox->x1, pbox->y2 - pbox->y1, pbox->x1 - pDst->x, pbox->y1 - pDst->y);
-	pbox++;
+        pGC->ops->CopyArea(pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx,
+                           pbox->y1 - pSrc->y + dy, pbox->x2 - pbox->x1,
+                           pbox->y2 - pbox->y1, pbox->x1 - pDst->x,
+                           pbox->y1 - pDst->y);
+        pbox++;
     }
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
+    exaFinishAccess(pSrc, EXA_PREPARE_SRC);
+    exaFinishAccess(pDst, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 static void
 ExaFallbackPrepareReg(DrawablePtr pDrawable,
-		      GCPtr pGC,
-		      int x, int y, int width, int height,
-		      int index, Bool checkReads)
+                      GCPtr pGC,
+                      int x, int y, int width, int height,
+                      int index, Bool checkReads)
 {
     ScreenPtr pScreen = pDrawable->pScreen;
+
     ExaScreenPriv(pScreen);
 
     if (pExaScr->prepare_access_reg &&
-	!(checkReads && exaGCReadsDestination(pDrawable,
-					      pGC->planemask,
-					      pGC->fillStyle,
-					      pGC->alu,
-					      pGC->clientClipType))) {
-	BoxRec box;
-	RegionRec reg;
-	int xoff, yoff;
-	PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
-
-	exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
-	box.x1 = pDrawable->x + x + xoff;
-	box.y1 = pDrawable->y + y + yoff;
-	box.x2 = box.x1 + width;
-	box.y2 = box.y1 + height;
-
-	RegionInit(&reg, &box, 1);
-	pExaScr->prepare_access_reg(pPixmap, index, &reg);
-	RegionUninit(&reg);
-    } else
-	exaPrepareAccess(pDrawable, index);
+        !(checkReads && exaGCReadsDestination(pDrawable,
+                                              pGC->planemask,
+                                              pGC->fillStyle,
+                                              pGC->alu, pGC->clientClipType))) {
+        BoxRec box;
+        RegionRec reg;
+        int xoff, yoff;
+        PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
+
+        exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
+        box.x1 = pDrawable->x + x + xoff;
+        box.y1 = pDrawable->y + y + yoff;
+        box.x2 = box.x1 + width;
+        box.y2 = box.y1 + height;
+
+        RegionInit(&reg, &box, 1);
+        pExaScr->prepare_access_reg(pPixmap, index, &reg);
+        RegionUninit(&reg);
+    }
+    else
+        exaPrepareAccess(pDrawable, index);
 }
 
-
 RegionPtr
-ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		 int srcx, int srcy, int w, int h, int dstx, int dsty)
+ExaCheckCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                 int srcx, int srcy, int w, int h, int dstx, int dsty)
 {
     RegionPtr ret;
 
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
-    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h,
-			  EXA_PREPARE_SRC, FALSE);
-    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h,
-			  EXA_PREPARE_DEST, TRUE);
-    ret = pGC->ops->CopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
+                  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
+    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h, EXA_PREPARE_SRC, FALSE);
+    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h, EXA_PREPARE_DEST, TRUE);
+    ret = pGC->ops->CopyArea(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty);
+    exaFinishAccess(pSrc, EXA_PREPARE_SRC);
+    exaFinishAccess(pDst, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 
     return ret;
 }
 
 RegionPtr
-ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
-		  int srcx, int srcy, int w, int h, int dstx, int dsty,
-		  unsigned long bitPlane)
+ExaCheckCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                  int srcx, int srcy, int w, int h, int dstx, int dsty,
+                  unsigned long bitPlane)
 {
     RegionPtr ret;
 
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
-		  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
-    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h,
-			  EXA_PREPARE_SRC, FALSE);
-    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h,
-			  EXA_PREPARE_DEST, TRUE);
-    ret = pGC->ops->CopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty,
-		       bitPlane);
-    exaFinishAccess (pSrc, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst, EXA_PREPARE_DEST);
+                  exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
+    ExaFallbackPrepareReg(pSrc, pGC, srcx, srcy, w, h, EXA_PREPARE_SRC, FALSE);
+    ExaFallbackPrepareReg(pDst, pGC, dstx, dsty, w, h, EXA_PREPARE_DEST, TRUE);
+    ret = pGC->ops->CopyPlane(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty,
+                              bitPlane);
+    exaFinishAccess(pSrc, EXA_PREPARE_SRC);
+    exaFinishAccess(pDst, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 
     return ret;
 }
 
 void
-ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
-		  DDXPointPtr pptInit)
+ExaCheckPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
+                  DDXPointPtr pptInit)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    pGC->ops->PolyPoint (pDrawable, pGC, mode, npt, pptInit);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    pGC->ops->PolyPoint(pDrawable, pGC, mode, npt, pptInit);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC,
-		  int mode, int npt, DDXPointPtr ppt)
+ExaCheckPolylines(DrawablePtr pDrawable, GCPtr pGC,
+                  int mode, int npt, DDXPointPtr ppt)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c), width %d, mode %d, count %d\n",
-		  pDrawable, exaDrawableLocation(pDrawable),
-		  pGC->lineWidth, mode, npt));
-
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->Polylines (pDrawable, pGC, mode, npt, ppt);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+                  pDrawable, exaDrawableLocation(pDrawable),
+                  pGC->lineWidth, mode, npt));
+
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->Polylines(pDrawable, pGC, mode, npt, ppt);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC,
-		    int nsegInit, xSegment *pSegInit)
+ExaCheckPolySegment(DrawablePtr pDrawable, GCPtr pGC,
+                    int nsegInit, xSegment * pSegInit)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c) width %d, count %d\n", pDrawable,
-		  exaDrawableLocation(pDrawable), pGC->lineWidth, nsegInit));
+                  exaDrawableLocation(pDrawable), pGC->lineWidth, nsegInit));
 
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolySegment (pDrawable, pGC, nsegInit, pSegInit);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->PolySegment(pDrawable, pGC, nsegInit, pSegInit);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC,
-		int narcs, xArc *pArcs)
+ExaCheckPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
 
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyArc (pDrawable, pGC, narcs, pArcs);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->PolyArc(pDrawable, pGC, narcs, pArcs);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC,
-		     int nrect, xRectangle *prect)
+ExaCheckPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
+                     int nrect, xRectangle *prect)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
 
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyFillRect (pDrawable, pGC, nrect, prect);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->PolyFillRect(pDrawable, pGC, nrect, prect);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		      int x, int y, unsigned int nglyph,
-		      CharInfoPtr *ppci, pointer pglyphBase)
+ExaCheckImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+                      int x, int y, unsigned int nglyph,
+                      CharInfoPtr * ppci, pointer pglyphBase)
 {
     EXA_PRE_FALLBACK_GC(pGC);
-    EXA_FALLBACK(("to %p (%c)\n", pDrawable,
-		  exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->ImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+    EXA_FALLBACK(("to %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->ImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC,
-		     int x, int y, unsigned int nglyph,
-		     CharInfoPtr *ppci, pointer pglyphBase)
+ExaCheckPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
+                     int x, int y, unsigned int nglyph,
+                     CharInfoPtr * ppci, pointer pglyphBase)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("to %p (%c), style %d alu %d\n", pDrawable,
-		  exaDrawableLocation(pDrawable), pGC->fillStyle, pGC->alu));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_DEST);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+                  exaDrawableLocation(pDrawable), pGC->fillStyle, pGC->alu));
+    exaPrepareAccess(pDrawable, EXA_PREPARE_DEST);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->PolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
 void
-ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap,
-		   DrawablePtr pDrawable,
-		   int w, int h, int x, int y)
+ExaCheckPushPixels(GCPtr pGC, PixmapPtr pBitmap,
+                   DrawablePtr pDrawable, int w, int h, int x, int y)
 {
     EXA_PRE_FALLBACK_GC(pGC);
     EXA_FALLBACK(("from %p to %p (%c,%c)\n", pBitmap, pDrawable,
-		  exaDrawableLocation(&pBitmap->drawable),
-		  exaDrawableLocation(pDrawable)));
-    ExaFallbackPrepareReg(pDrawable, pGC, x, y, w, h,
-			  EXA_PREPARE_DEST, TRUE);
+                  exaDrawableLocation(&pBitmap->drawable),
+                  exaDrawableLocation(pDrawable)));
+    ExaFallbackPrepareReg(pDrawable, pGC, x, y, w, h, EXA_PREPARE_DEST, TRUE);
     ExaFallbackPrepareReg(&pBitmap->drawable, pGC, 0, 0, w, h,
-			  EXA_PREPARE_SRC, FALSE);
-    exaPrepareAccessGC (pGC);
-    pGC->ops->PushPixels (pGC, pBitmap, pDrawable, w, h, x, y);
-    exaFinishAccessGC (pGC);
-    exaFinishAccess (&pBitmap->drawable, EXA_PREPARE_SRC);
-    exaFinishAccess (pDrawable, EXA_PREPARE_DEST);
+                          EXA_PREPARE_SRC, FALSE);
+    exaPrepareAccessGC(pGC);
+    pGC->ops->PushPixels(pGC, pBitmap, pDrawable, w, h, x, y);
+    exaFinishAccessGC(pGC);
+    exaFinishAccess(&pBitmap->drawable, EXA_PREPARE_SRC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK_GC(pGC);
 }
 
@@ -372,77 +371,72 @@ ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 {
     DrawablePtr pDrawable = &pWin->drawable;
     ScreenPtr pScreen = pDrawable->pScreen;
+
     EXA_PRE_FALLBACK(pScreen);
     EXA_FALLBACK(("from %p\n", pWin));
 
     /* Only need the source bits, the destination region will be overwritten */
     if (pExaScr->prepare_access_reg) {
-	PixmapPtr pPixmap = pScreen->GetWindowPixmap(pWin);
-	int xoff, yoff;
+        PixmapPtr pPixmap = pScreen->GetWindowPixmap(pWin);
+        int xoff, yoff;
 
-	exaGetDrawableDeltas(&pWin->drawable, pPixmap, &xoff, &yoff);
-	RegionTranslate(prgnSrc, xoff, yoff);
-	pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, prgnSrc);
-	RegionTranslate(prgnSrc, -xoff, -yoff);
-    } else
-	exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);
+        exaGetDrawableDeltas(&pWin->drawable, pPixmap, &xoff, &yoff);
+        RegionTranslate(prgnSrc, xoff, yoff);
+        pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, prgnSrc);
+        RegionTranslate(prgnSrc, -xoff, -yoff);
+    }
+    else
+        exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);
 
     swap(pExaScr, pScreen, CopyWindow);
-    pScreen->CopyWindow (pWin, ptOldOrg, prgnSrc);
+    pScreen->CopyWindow(pWin, ptOldOrg, prgnSrc);
     swap(pExaScr, pScreen, CopyWindow);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_SRC);
     EXA_POST_FALLBACK(pScreen);
 }
 
 void
 ExaCheckGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
-		unsigned int format, unsigned long planeMask, char *d)
+                 unsigned int format, unsigned long planeMask, char *d)
 {
     ScreenPtr pScreen = pDrawable->pScreen;
+
     EXA_PRE_FALLBACK(pScreen);
-    EXA_FALLBACK(("from %p (%c)\n", pDrawable,
-		  exaDrawableLocation(pDrawable)));
+    EXA_FALLBACK(("from %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
 
-    ExaFallbackPrepareReg(pDrawable, NULL, x, y, w, h,
-			  EXA_PREPARE_SRC, FALSE);
+    ExaFallbackPrepareReg(pDrawable, NULL, x, y, w, h, EXA_PREPARE_SRC, FALSE);
     swap(pExaScr, pScreen, GetImage);
-    pScreen->GetImage (pDrawable, x, y, w, h, format, planeMask, d);
+    pScreen->GetImage(pDrawable, x, y, w, h, format, planeMask, d);
     swap(pExaScr, pScreen, GetImage);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_SRC);
     EXA_POST_FALLBACK(pScreen);
 }
 
 void
-ExaCheckGetSpans (DrawablePtr pDrawable,
-		 int wMax,
-		 DDXPointPtr ppt,
-		 int *pwidth,
-		 int nspans,
-		 char *pdstStart)
+ExaCheckGetSpans(DrawablePtr pDrawable,
+                 int wMax,
+                 DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
 {
     ScreenPtr pScreen = pDrawable->pScreen;
 
     EXA_PRE_FALLBACK(pScreen);
     EXA_FALLBACK(("from %p (%c)\n", pDrawable, exaDrawableLocation(pDrawable)));
-    exaPrepareAccess (pDrawable, EXA_PREPARE_SRC);
+    exaPrepareAccess(pDrawable, EXA_PREPARE_SRC);
     swap(pExaScr, pScreen, GetSpans);
-    pScreen->GetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
+    pScreen->GetSpans(pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
     swap(pExaScr, pScreen, GetSpans);
-    exaFinishAccess (pDrawable, EXA_PREPARE_SRC);
+    exaFinishAccess(pDrawable, EXA_PREPARE_SRC);
     EXA_POST_FALLBACK(pScreen);
 }
 
 static void
 ExaSrcValidate(DrawablePtr pDrawable,
-	       int x,
-	       int y,
-	       int width,
-	       int height,
-	       unsigned int subWindowMode)
+               int x, int y, int width, int height, unsigned int subWindowMode)
 {
     ScreenPtr pScreen = pDrawable->pScreen;
+
     ExaScreenPriv(pScreen);
-    PixmapPtr pPix = exaGetDrawablePixmap (pDrawable);
+    PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);
     BoxRec box;
     RegionRec reg;
     RegionPtr dst;
@@ -455,8 +449,7 @@ ExaSrcValidate(DrawablePtr pDrawable,
     box.x2 = box.x1 + width;
     box.y2 = box.y1 + height;
 
-    dst = (pExaScr->srcPix == pPix) ? &pExaScr->srcReg :
-	&pExaScr->maskReg;
+    dst = (pExaScr->srcPix == pPix) ? &pExaScr->srcReg : &pExaScr->maskReg;
 
     RegionInit(&reg, &box, 1);
     RegionUnion(dst, dst, &reg);
@@ -470,19 +463,16 @@ ExaSrcValidate(DrawablePtr pDrawable,
 }
 
 static Bool
-ExaPrepareCompositeReg(ScreenPtr  pScreen,
-		       CARD8      op,
-		       PicturePtr pSrc,
-		       PicturePtr pMask,
-		       PicturePtr pDst,
-		       INT16      xSrc,
-		       INT16      ySrc,
-		       INT16      xMask,
-		       INT16      yMask,
-		       INT16      xDst,
-		       INT16      yDst,
-		       CARD16     width,
-		       CARD16     height)
+ExaPrepareCompositeReg(ScreenPtr pScreen,
+                       CARD8 op,
+                       PicturePtr pSrc,
+                       PicturePtr pMask,
+                       PicturePtr pDst,
+                       INT16 xSrc,
+                       INT16 ySrc,
+                       INT16 xMask,
+                       INT16 yMask,
+                       INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
 {
     RegionRec region;
     RegionPtr dstReg = NULL;
@@ -491,65 +481,57 @@ ExaPrepareCompositeReg(ScreenPtr  pScreen,
     PixmapPtr pSrcPix = NULL;
     PixmapPtr pMaskPix = NULL;
     PixmapPtr pDstPix;
+
     ExaScreenPriv(pScreen);
     Bool ret;
 
-
     RegionNull(&region);
 
     if (pSrc->pDrawable) {
-	pSrcPix = exaGetDrawablePixmap(pSrc->pDrawable);
-	RegionNull(&pExaScr->srcReg);
-	srcReg = &pExaScr->srcReg;
-	pExaScr->srcPix = pSrcPix;
-	if (pSrc != pDst)
-	    RegionTranslate(pSrc->pCompositeClip,
-			     -pSrc->pDrawable->x,
-			     -pSrc->pDrawable->y);
+        pSrcPix = exaGetDrawablePixmap(pSrc->pDrawable);
+        RegionNull(&pExaScr->srcReg);
+        srcReg = &pExaScr->srcReg;
+        pExaScr->srcPix = pSrcPix;
+        if (pSrc != pDst)
+            RegionTranslate(pSrc->pCompositeClip,
+                            -pSrc->pDrawable->x, -pSrc->pDrawable->y);
     }
 
     if (pMask && pMask->pDrawable) {
-	pMaskPix = exaGetDrawablePixmap(pMask->pDrawable);
-	RegionNull(&pExaScr->maskReg);
-	maskReg = &pExaScr->maskReg;
-	if (pMask != pDst && pMask != pSrc)
-	    RegionTranslate(pMask->pCompositeClip,
-			     -pMask->pDrawable->x,
-			     -pMask->pDrawable->y);
+        pMaskPix = exaGetDrawablePixmap(pMask->pDrawable);
+        RegionNull(&pExaScr->maskReg);
+        maskReg = &pExaScr->maskReg;
+        if (pMask != pDst && pMask != pSrc)
+            RegionTranslate(pMask->pCompositeClip,
+                            -pMask->pDrawable->x, -pMask->pDrawable->y);
     }
 
     RegionTranslate(pDst->pCompositeClip,
-		     -pDst->pDrawable->x,
-		     -pDst->pDrawable->y);
+                    -pDst->pDrawable->x, -pDst->pDrawable->y);
 
     pExaScr->SavedSourceValidate = ExaSrcValidate;
     swap(pExaScr, pScreen, SourceValidate);
-    ret = miComputeCompositeRegion (&region, pSrc, pMask, pDst,
-				    xSrc, ySrc, xMask, yMask,
-				    xDst,
-				    yDst,
-				    width, height);
+    ret = miComputeCompositeRegion(&region, pSrc, pMask, pDst,
+                                   xSrc, ySrc, xMask, yMask,
+                                   xDst, yDst, width, height);
     swap(pExaScr, pScreen, SourceValidate);
 
     RegionTranslate(pDst->pCompositeClip,
-		     pDst->pDrawable->x,
-		     pDst->pDrawable->y);
+                    pDst->pDrawable->x, pDst->pDrawable->y);
     if (pSrc->pDrawable && pSrc != pDst)
-	RegionTranslate(pSrc->pCompositeClip,
-			 pSrc->pDrawable->x,
-			 pSrc->pDrawable->y);
+        RegionTranslate(pSrc->pCompositeClip,
+                        pSrc->pDrawable->x, pSrc->pDrawable->y);
     if (pMask && pMask->pDrawable && pMask != pDst && pMask != pSrc)
-	RegionTranslate(pMask->pCompositeClip,
-			 pMask->pDrawable->x,
-			 pMask->pDrawable->y);
+        RegionTranslate(pMask->pCompositeClip,
+                        pMask->pDrawable->x, pMask->pDrawable->y);
 
     if (!ret) {
-	if (srcReg)
-	    RegionUninit(srcReg);
-	if (maskReg)
-	    RegionUninit(maskReg);
+        if (srcReg)
+            RegionUninit(srcReg);
+        if (maskReg)
+            RegionUninit(maskReg);
 
-	return FALSE;
+        return FALSE;
     }
 
     /**
@@ -558,44 +540,40 @@ ExaPrepareCompositeReg(ScreenPtr  pScreen,
      */
 
     if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
-	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pSrc->alphaMap->pDrawable),
-				    EXA_PREPARE_AUX_SRC,
-				    NULL);
+        pExaScr->
+            prepare_access_reg(exaGetDrawablePixmap(pSrc->alphaMap->pDrawable),
+                               EXA_PREPARE_AUX_SRC, NULL);
     if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
-	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pMask->alphaMap->pDrawable),
-				    EXA_PREPARE_AUX_MASK,
-				    NULL);
+        pExaScr->
+            prepare_access_reg(exaGetDrawablePixmap(pMask->alphaMap->pDrawable),
+                               EXA_PREPARE_AUX_MASK, NULL);
 
     if (pSrcPix)
-	pExaScr->prepare_access_reg(pSrcPix,
-				    EXA_PREPARE_SRC,
-				    srcReg);
+        pExaScr->prepare_access_reg(pSrcPix, EXA_PREPARE_SRC, srcReg);
 
     if (pMaskPix)
-	pExaScr->prepare_access_reg(pMaskPix,
-				    EXA_PREPARE_MASK,
-				    maskReg);
+        pExaScr->prepare_access_reg(pMaskPix, EXA_PREPARE_MASK, maskReg);
 
     if (srcReg)
-	RegionUninit(srcReg);
+        RegionUninit(srcReg);
     if (maskReg)
-	RegionUninit(maskReg);
+        RegionUninit(maskReg);
 
     pDstPix = exaGetDrawablePixmap(pDst->pDrawable);
     if (!exaOpReadsDestination(op)) {
-	int xoff;
-	int yoff;
+        int xoff;
+        int yoff;
 
-	exaGetDrawableDeltas (pDst->pDrawable, pDstPix, &xoff, &yoff);
-	RegionTranslate(&region, pDst->pDrawable->x + xoff,
-			 pDst->pDrawable->y + yoff);
-	dstReg = &region;
+        exaGetDrawableDeltas(pDst->pDrawable, pDstPix, &xoff, &yoff);
+        RegionTranslate(&region, pDst->pDrawable->x + xoff,
+                        pDst->pDrawable->y + yoff);
+        dstReg = &region;
     }
 
     if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	pExaScr->prepare_access_reg(exaGetDrawablePixmap(pDst->alphaMap->pDrawable),
-				    EXA_PREPARE_AUX_DEST,
-				    dstReg);
+        pExaScr->
+            prepare_access_reg(exaGetDrawablePixmap(pDst->alphaMap->pDrawable),
+                               EXA_PREPARE_AUX_DEST, dstReg);
     pExaScr->prepare_access_reg(pDstPix, EXA_PREPARE_DEST, dstReg);
 
     RegionUninit(&region);
@@ -603,80 +581,70 @@ ExaPrepareCompositeReg(ScreenPtr  pScreen,
 }
 
 void
-ExaCheckComposite (CARD8      op,
-                   PicturePtr pSrc,
-                   PicturePtr pMask,
-                   PicturePtr pDst,
-                   INT16      xSrc,
-                   INT16      ySrc,
-                   INT16      xMask,
-                   INT16      yMask,
-                   INT16      xDst,
-                   INT16      yDst,
-                   CARD16     width,
-                   CARD16     height)
+ExaCheckComposite(CARD8 op,
+                  PicturePtr pSrc,
+                  PicturePtr pMask,
+                  PicturePtr pDst,
+                  INT16 xSrc,
+                  INT16 ySrc,
+                  INT16 xMask,
+                  INT16 yMask,
+                  INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
 {
     ScreenPtr pScreen = pDst->pDrawable->pScreen;
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+
     EXA_PRE_FALLBACK(pScreen);
 
     if (pExaScr->prepare_access_reg) {
-	if (!ExaPrepareCompositeReg(pScreen, op, pSrc, pMask, pDst, xSrc,
-				   ySrc, xMask, yMask, xDst, yDst, width,
-				   height))
-	    goto out_no_clip;
-    } else {
-
-	/* We need to prepare access to any separate alpha maps first,
-	 * in case the driver doesn't support EXA_PREPARE_AUX*,
-	 * in which case EXA_PREPARE_SRC may be used for moving them out.
-	 */
-
-	if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
-	    exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
-	if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
-	    exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
-	if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	    exaPrepareAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
-
-	exaPrepareAccess (pDst->pDrawable, EXA_PREPARE_DEST);
-
-	EXA_FALLBACK(("from picts %p/%p to pict %p\n",
-		      pSrc, pMask, pDst));
-
-	if (pSrc->pDrawable != NULL)
-	    exaPrepareAccess (pSrc->pDrawable, EXA_PREPARE_SRC);
-	if (pMask && pMask->pDrawable != NULL)
-	    exaPrepareAccess (pMask->pDrawable, EXA_PREPARE_MASK);
+        if (!ExaPrepareCompositeReg(pScreen, op, pSrc, pMask, pDst, xSrc,
+                                    ySrc, xMask, yMask, xDst, yDst, width,
+                                    height))
+            goto out_no_clip;
+    }
+    else {
+
+        /* We need to prepare access to any separate alpha maps first,
+         * in case the driver doesn't support EXA_PREPARE_AUX*,
+         * in which case EXA_PREPARE_SRC may be used for moving them out.
+         */
+
+        if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
+            exaPrepareAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
+        if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
+            exaPrepareAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
+        if (pDst->alphaMap && pDst->alphaMap->pDrawable)
+            exaPrepareAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
+
+        exaPrepareAccess(pDst->pDrawable, EXA_PREPARE_DEST);
+
+        EXA_FALLBACK(("from picts %p/%p to pict %p\n", pSrc, pMask, pDst));
+
+        if (pSrc->pDrawable != NULL)
+            exaPrepareAccess(pSrc->pDrawable, EXA_PREPARE_SRC);
+        if (pMask && pMask->pDrawable != NULL)
+            exaPrepareAccess(pMask->pDrawable, EXA_PREPARE_MASK);
     }
 
     swap(pExaScr, ps, Composite);
-    ps->Composite (op,
-                 pSrc,
-                 pMask,
-                 pDst,
-                 xSrc,
-                 ySrc,
-                 xMask,
-                 yMask,
-                 xDst,
-                 yDst,
-                 width,
-                 height);
+    ps->Composite(op,
+                  pSrc,
+                  pMask,
+                  pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height);
     swap(pExaScr, ps, Composite);
     if (pMask && pMask->pDrawable != NULL)
-	exaFinishAccess (pMask->pDrawable, EXA_PREPARE_MASK);
+        exaFinishAccess(pMask->pDrawable, EXA_PREPARE_MASK);
     if (pSrc->pDrawable != NULL)
-	exaFinishAccess (pSrc->pDrawable, EXA_PREPARE_SRC);
-    exaFinishAccess (pDst->pDrawable, EXA_PREPARE_DEST);
+        exaFinishAccess(pSrc->pDrawable, EXA_PREPARE_SRC);
+    exaFinishAccess(pDst->pDrawable, EXA_PREPARE_DEST);
     if (pDst->alphaMap && pDst->alphaMap->pDrawable)
-	exaFinishAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
+        exaFinishAccess(pDst->alphaMap->pDrawable, EXA_PREPARE_AUX_DEST);
     if (pSrc->alphaMap && pSrc->alphaMap->pDrawable)
-	exaFinishAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
+        exaFinishAccess(pSrc->alphaMap->pDrawable, EXA_PREPARE_AUX_SRC);
     if (pMask && pMask->alphaMap && pMask->alphaMap->pDrawable)
-	exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
+        exaFinishAccess(pMask->alphaMap->pDrawable, EXA_PREPARE_AUX_MASK);
 
-out_no_clip:
+ out_no_clip:
     EXA_POST_FALLBACK(pScreen);
 }
 
@@ -684,17 +652,15 @@ out_no_clip:
  * Avoid migration ping-pong when using a mask.
  */
 void
-ExaCheckGlyphs (CARD8	      op,
-		PicturePtr    pSrc,
-		PicturePtr    pDst,
-		PictFormatPtr maskFormat,
-		INT16	      xSrc,
-		INT16	      ySrc,
-		int	      nlist,
-		GlyphListPtr  list,
-		GlyphPtr      *glyphs)
+ExaCheckGlyphs(CARD8 op,
+               PicturePtr pSrc,
+               PicturePtr pDst,
+               PictFormatPtr maskFormat,
+               INT16 xSrc,
+               INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
 {
     ScreenPtr pScreen = pDst->pDrawable->pScreen;
+
     EXA_PRE_FALLBACK(pScreen);
 
     miGlyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
@@ -703,21 +669,19 @@ ExaCheckGlyphs (CARD8	      op,
 }
 
 void
-ExaCheckAddTraps (PicturePtr	pPicture,
-		  INT16		x_off,
-		  INT16		y_off,
-		  int		ntrap,
-		  xTrap		*traps)
+ExaCheckAddTraps(PicturePtr pPicture,
+                 INT16 x_off, INT16 y_off, int ntrap, xTrap * traps)
 {
     ScreenPtr pScreen = pPicture->pDrawable->pScreen;
-    PictureScreenPtr	ps = GetPictureScreen(pScreen);
+    PictureScreenPtr ps = GetPictureScreen(pScreen);
+
     EXA_PRE_FALLBACK(pScreen);
 
     EXA_FALLBACK(("to pict %p (%c)\n",
-		  exaDrawableLocation(pPicture->pDrawable)));
+                  exaDrawableLocation(pPicture->pDrawable)));
     exaPrepareAccess(pPicture->pDrawable, EXA_PREPARE_DEST);
     swap(pExaScr, ps, AddTraps);
-    ps->AddTraps (pPicture, x_off, y_off, ntrap, traps);
+    ps->AddTraps(pPicture, x_off, y_off, ntrap, traps);
     swap(pExaScr, ps, AddTraps);
     exaFinishAccess(pPicture->pDrawable, EXA_PREPARE_DEST);
     EXA_POST_FALLBACK(pScreen);
@@ -728,37 +692,37 @@ ExaCheckAddTraps (PicturePtr	pPicture,
  * that happen to be 1x1.  Pixmap must be at least 8bpp.
  */
 CARD32
-exaGetPixmapFirstPixel (PixmapPtr pPixmap)
+exaGetPixmapFirstPixel(PixmapPtr pPixmap)
 {
     switch (pPixmap->drawable.bitsPerPixel) {
     case 32:
-	{
-	    CARD32 pixel;
+    {
+        CARD32 pixel;
 
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
+        pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
+                                            ZPixmap, ~0, (char *) &pixel);
+        return pixel;
+    }
     case 16:
-	{
-	    CARD16 pixel;
+    {
+        CARD16 pixel;
 
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
+        pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
+                                            ZPixmap, ~0, (char *) &pixel);
+        return pixel;
+    }
     case 8:
     case 4:
     case 1:
-	{
-	    CARD8 pixel;
+    {
+        CARD8 pixel;
 
-	    pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
-						ZPixmap, ~0, (char*)&pixel);
-	    return pixel;
-	}
+        pPixmap->drawable.pScreen->GetImage(&pPixmap->drawable, 0, 0, 1, 1,
+                                            ZPixmap, ~0, (char *) &pixel);
+        return pixel;
+    }
     default:
-	FatalError("%s called for invalid bpp %d\n", __FUNCTION__,
-		   pPixmap->drawable.bitsPerPixel);
+        FatalError("%s called for invalid bpp %d\n", __FUNCTION__,
+                   pPixmap->drawable.bitsPerPixel);
     }
 }