Introduce a consistent coding style

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

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

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

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

The comparison was done with this script:

dir1=$1
dir2=$2

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

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

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

1 files changed, 686 insertions, 692 deletions

diff --git a/hw/xfree86/xaa/xaaSpans.c b/hw/xfree86/xaa/xaaSpans.c
index a742cba1b..f03452a46 100644
--- a/hw/xfree86/xaa/xaaSpans.c
+++ b/hw/xfree86/xaa/xaaSpans.c
@@ -16,867 +16,861 @@
 #include "xaa.h"
 #include "xaalocal.h"
 
-
-static void XAARenderSolidSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderColor8x8Spans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderMono8x8Spans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderCacheBltSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderColorExpandSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderCacheExpandSpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
-static void XAARenderPixmapCopySpans(
-	GCPtr, int, DDXPointPtr, int*, int, int, int);
+static void XAARenderSolidSpans(GCPtr, int, DDXPointPtr, int *, int, int, int);
+static void XAARenderColor8x8Spans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                   int);
+static void XAARenderMono8x8Spans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                  int);
+static void XAARenderCacheBltSpans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                   int);
+static void XAARenderColorExpandSpans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                      int);
+static void XAARenderCacheExpandSpans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                      int);
+static void XAARenderPixmapCopySpans(GCPtr, int, DDXPointPtr, int *, int, int,
+                                     int);
 
 void
-XAAFillSpans(
-    DrawablePtr pDraw,
-    GC		*pGC,
-    int		nInit,		/* number of spans to fill */
-    DDXPointPtr pptInit,	/* pointer to list of start points */
-    int *pwidthInit,		/* pointer to list of n widths */
-    int fSorted 
-){
+XAAFillSpans(DrawablePtr pDraw, GC * pGC, int nInit,    /* number of spans to fill */
+             DDXPointPtr pptInit,       /* pointer to list of start points */
+             int *pwidthInit,   /* pointer to list of n widths */
+             int fSorted)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
     int type = 0;
     ClipAndRenderSpansFunc function;
     Bool fastClip = FALSE;
 
-    if((nInit <= 0) || !pGC->planemask)
+    if ((nInit <= 0) || !pGC->planemask)
         return;
 
-    if(!RegionNumRects(pGC->pCompositeClip))
-	return;
+    if (!RegionNumRects(pGC->pCompositeClip))
+        return;
 
-    switch(pGC->fillStyle) {
+    switch (pGC->fillStyle) {
     case FillSolid:
-	type = DO_SOLID;
-	break;
+        type = DO_SOLID;
+        break;
     case FillStippled:
-	type = (*infoRec->StippledFillChooser)(pGC);
-	break;
+        type = (*infoRec->StippledFillChooser) (pGC);
+        break;
     case FillOpaqueStippled:
-	if((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&
-                CHECK_PLANEMASK(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_ROP(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_ROPSRC(pGC,infoRec->FillSpansSolidFlags) &&
-                CHECK_FG(pGC,infoRec->FillSpansSolidFlags))
-	    type = DO_SOLID;
-	else
-	    type = (*infoRec->OpaqueStippledFillChooser)(pGC);
-	break;
+        if ((pGC->fgPixel == pGC->bgPixel) && infoRec->FillSpansSolid &&
+            CHECK_PLANEMASK(pGC, infoRec->FillSpansSolidFlags) &&
+            CHECK_ROP(pGC, infoRec->FillSpansSolidFlags) &&
+            CHECK_ROPSRC(pGC, infoRec->FillSpansSolidFlags) &&
+            CHECK_FG(pGC, infoRec->FillSpansSolidFlags))
+            type = DO_SOLID;
+        else
+            type = (*infoRec->OpaqueStippledFillChooser) (pGC);
+        break;
     case FillTiled:
-	type = (*infoRec->TiledFillChooser)(pGC);
-	break;
+        type = (*infoRec->TiledFillChooser) (pGC);
+        break;
     }
 
-    switch(type) {
+    switch (type) {
     case DO_SOLID:
-	function = XAARenderSolidSpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL) 
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderSolidSpans;
+        if (infoRec->ClippingFlags & HARDWARE_CLIP_SOLID_FILL)
+            fastClip = TRUE;
+        break;
     case DO_COLOR_8x8:
-	function = XAARenderColor8x8Spans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL) 
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderColor8x8Spans;
+        if (infoRec->ClippingFlags & HARDWARE_CLIP_COLOR_8x8_FILL)
+            fastClip = TRUE;
+        break;
     case DO_MONO_8x8:
-	function = XAARenderMono8x8Spans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL) 
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderMono8x8Spans;
+        if (infoRec->ClippingFlags & HARDWARE_CLIP_MONO_8x8_FILL)
+            fastClip = TRUE;
+        break;
     case DO_CACHE_BLT:
-	function = XAARenderCacheBltSpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderCacheBltSpans;
+        if (infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
+            fastClip = TRUE;
+        break;
     case DO_COLOR_EXPAND:
-	function = XAARenderColorExpandSpans;	
-	break;	
+        function = XAARenderColorExpandSpans;
+        break;
     case DO_CACHE_EXPAND:
-	function = XAARenderCacheExpandSpans;	
-	if(infoRec->ClippingFlags & 
-			HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND) 
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderCacheExpandSpans;
+        if (infoRec->ClippingFlags &
+            HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND)
+            fastClip = TRUE;
+        break;
     case DO_PIXMAP_COPY:
-	function = XAARenderPixmapCopySpans;	
-	if(infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
-		fastClip = TRUE; 
-	break;	
+        function = XAARenderPixmapCopySpans;
+        if (infoRec->ClippingFlags & HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY)
+            fastClip = TRUE;
+        break;
     case DO_IMAGE_WRITE:
     default:
-	(*XAAFallbackOps.FillSpans)(pDraw, pGC, nInit, pptInit,
-				pwidthInit, fSorted);
-	return;
+        (*XAAFallbackOps.FillSpans) (pDraw, pGC, nInit, pptInit,
+                                     pwidthInit, fSorted);
+        return;
     }
 
+    if ((nInit < 10) || (RegionNumRects(pGC->pCompositeClip) != 1))
+        fastClip = FALSE;
 
-    if((nInit < 10) || (RegionNumRects(pGC->pCompositeClip) != 1))
-	fastClip = FALSE;
-
-    if(fastClip) {
-	infoRec->ClipBox = &pGC->pCompositeClip->extents;
-	(*function)(pGC, nInit, pptInit, pwidthInit, fSorted, 
-					pDraw->x, pDraw->y);
-	infoRec->ClipBox = NULL;
-    } else
-	XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,
-					function, pDraw->x, pDraw->y);
+    if (fastClip) {
+        infoRec->ClipBox = &pGC->pCompositeClip->extents;
+        (*function) (pGC, nInit, pptInit, pwidthInit, fSorted,
+                     pDraw->x, pDraw->y);
+        infoRec->ClipBox = NULL;
+    }
+    else
+        XAAClipAndRenderSpans(pGC, pptInit, pwidthInit, nInit, fSorted,
+                              function, pDraw->x, pDraw->y);
 }
 
-
-	/*********************\
+        /*********************\
 	|     Solid Spans     |
 	\*********************/
 
-
 static void
-XAARenderSolidSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
+XAARenderSolidSpans(GCPtr pGC,
+                    int n,
+                    DDXPointPtr ppt,
+                    int *pwidth, int fSorted, int xorg, int yorg)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
-    (*infoRec->FillSolidSpans) (infoRec->pScrn, pGC->fgPixel, 
-		pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted);    
+    (*infoRec->FillSolidSpans) (infoRec->pScrn, pGC->fgPixel,
+                                pGC->alu, pGC->planemask, n, ppt, pwidth,
+                                fSorted);
 }
 
-
-	/************************\
+        /************************\
 	|     Mono 8x8 Spans     |
 	\************************/
 
-
 static void
-XAARenderMono8x8Spans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAAPixmapPtr pPriv;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-      fg = pPriv->fg;  bg = pPriv->bg;
-      break;
-   default:	/* Muffle compiler */
-      pPriv = NULL;	/* Kaboom */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillMono8x8PatternSpans) (infoRec->pScrn, 
-                fg, bg, pGC->alu, pGC->planemask, 
-                n, ppt, pwidth, fSorted, pPriv->pattern0, pPriv->pattern1, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));	  
-}
+XAARenderMono8x8Spans(GCPtr pGC,
+                      int n,
+                      DDXPointPtr ppt,
+                      int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    XAAPixmapPtr pPriv;
+    int fg, bg;
 
+    switch (pGC->fillStyle) {
+    case FillStippled:
+        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
+        fg = pGC->fgPixel;
+        bg = -1;
+        break;
+    case FillOpaqueStippled:
+        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->stipple);
+        fg = pGC->fgPixel;
+        bg = pGC->bgPixel;
+        break;
+    case FillTiled:
+        pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
+        fg = pPriv->fg;
+        bg = pPriv->bg;
+        break;
+    default:                   /* Muffle compiler */
+        pPriv = NULL;           /* Kaboom */
+        fg = -1;
+        bg = -1;
+        break;
+    }
 
-	/*************************\
+    (*infoRec->FillMono8x8PatternSpans) (infoRec->pScrn,
+                                         fg, bg, pGC->alu, pGC->planemask,
+                                         n, ppt, pwidth, fSorted,
+                                         pPriv->pattern0, pPriv->pattern1,
+                                         (xorg + pGC->patOrg.x),
+                                         (yorg + pGC->patOrg.y));
+}
+
+        /*************************\
 	|     Color 8x8 Spans     |
 	\*************************/
 
-
 static void
-XAARenderColor8x8Spans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-   PixmapPtr pPix;
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      pPix = pGC->stipple;
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   case FillTiled:
-      pPix = pGC->tile.pixmap;
-      fg = -1;  bg = -1;
-      break;
-   default:	/* Muffle compiler */
-      pPix = NULL;
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   pCache = (*infoRec->CacheColor8x8Pattern)(infoRec->pScrn, pPix, fg, bg);
-
-   (*infoRec->FillColor8x8PatternSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache,
-                (yorg + pGC->patOrg.x), (xorg + pGC->patOrg.y));
-}
+XAARenderColor8x8Spans(GCPtr pGC,
+                       int n,
+                       DDXPointPtr ppt,
+                       int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    XAACacheInfoPtr pCache;
+    PixmapPtr pPix;
+    int fg, bg;
+
+    switch (pGC->fillStyle) {
+    case FillStippled:
+        pPix = pGC->stipple;
+        fg = pGC->fgPixel;
+        bg = -1;
+        break;
+    case FillOpaqueStippled:
+        pPix = pGC->stipple;
+        fg = pGC->fgPixel;
+        bg = pGC->bgPixel;
+        break;
+    case FillTiled:
+        pPix = pGC->tile.pixmap;
+        fg = -1;
+        bg = -1;
+        break;
+    default:                   /* Muffle compiler */
+        pPix = NULL;
+        fg = -1;
+        bg = -1;
+        break;
+    }
 
+    pCache = (*infoRec->CacheColor8x8Pattern) (infoRec->pScrn, pPix, fg, bg);
 
-	/****************************\
+    (*infoRec->FillColor8x8PatternSpans) (infoRec->pScrn,
+                                          pGC->alu, pGC->planemask, n, ppt,
+                                          pwidth, fSorted, pCache,
+                                          (yorg + pGC->patOrg.x),
+                                          (xorg + pGC->patOrg.y));
+}
+
+        /****************************\
 	|     Color Expand Spans     |
 	\****************************/
 
-
 static void
-XAARenderColorExpandSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillColorExpandSpans) (infoRec->pScrn, fg, bg,
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-                pGC->stipple); 
+XAARenderColorExpandSpans(GCPtr pGC,
+                          int n,
+                          DDXPointPtr ppt,
+                          int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    int fg, bg;
 
-}
+    switch (pGC->fillStyle) {
+    case FillStippled:
+        fg = pGC->fgPixel;
+        bg = -1;
+        break;
+    case FillOpaqueStippled:
+        fg = pGC->fgPixel;
+        bg = pGC->bgPixel;
+        break;
+    default:                   /* Muffle compiler */
+        fg = -1;
+        bg = -1;
+        break;
+    }
+
+    (*infoRec->FillColorExpandSpans) (infoRec->pScrn, fg, bg,
+                                      pGC->alu, pGC->planemask, n, ppt, pwidth,
+                                      fSorted, (xorg + pGC->patOrg.x),
+                                      (yorg + pGC->patOrg.y), pGC->stipple);
 
+}
 
-	/*************************\
+        /*************************\
 	|     Cache Blt Spans     |
 	\*************************/
 
-
 static void
-XAARenderCacheBltSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, -1);
-      break;
-   case FillOpaqueStippled:
-      pCache = (*infoRec->CacheStipple)(infoRec->pScrn, pGC->stipple, 
-					pGC->fgPixel, pGC->bgPixel);
-      break;
-   case FillTiled:
-      pCache = (*infoRec->CacheTile)(infoRec->pScrn, pGC->tile.pixmap);
-      break;
-   default:	/* Muffle compiler */
-      pCache = NULL;
-      break;
-   }
-
-   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));
+XAARenderCacheBltSpans(GCPtr pGC,
+                       int n,
+                       DDXPointPtr ppt,
+                       int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    XAACacheInfoPtr pCache;
 
-}
+    switch (pGC->fillStyle) {
+    case FillStippled:
+        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
+                                           pGC->fgPixel, -1);
+        break;
+    case FillOpaqueStippled:
+        pCache = (*infoRec->CacheStipple) (infoRec->pScrn, pGC->stipple,
+                                           pGC->fgPixel, pGC->bgPixel);
+        break;
+    case FillTiled:
+        pCache = (*infoRec->CacheTile) (infoRec->pScrn, pGC->tile.pixmap);
+        break;
+    default:                   /* Muffle compiler */
+        pCache = NULL;
+        break;
+    }
+
+    (*infoRec->FillCacheBltSpans) (infoRec->pScrn,
+                                   pGC->alu, pGC->planemask, n, ppt, pwidth,
+                                   fSorted, pCache, (xorg + pGC->patOrg.x),
+                                   (yorg + pGC->patOrg.y));
 
+}
 
-	/****************************\
+        /****************************\
 	|     Cache Expand Spans     |
 	\****************************/
 
-
 static void
-XAARenderCacheExpandSpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   int fg, bg;
-
-   switch(pGC->fillStyle) {
-   case FillStippled:
-      fg = pGC->fgPixel;  bg = -1;
-      break;
-   case FillOpaqueStippled:
-      fg = pGC->fgPixel;  bg = pGC->bgPixel;
-      break;
-   default:	/* Muffle compiler */
-      fg = -1;  bg = -1;
-      break;
-   }
-
-   (*infoRec->FillCacheExpandSpans) (infoRec->pScrn, fg, bg,
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted,
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y),
-                pGC->stipple); 
-}
+XAARenderCacheExpandSpans(GCPtr pGC,
+                          int n,
+                          DDXPointPtr ppt,
+                          int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    int fg, bg;
+
+    switch (pGC->fillStyle) {
+    case FillStippled:
+        fg = pGC->fgPixel;
+        bg = -1;
+        break;
+    case FillOpaqueStippled:
+        fg = pGC->fgPixel;
+        bg = pGC->bgPixel;
+        break;
+    default:                   /* Muffle compiler */
+        fg = -1;
+        bg = -1;
+        break;
+    }
 
+    (*infoRec->FillCacheExpandSpans) (infoRec->pScrn, fg, bg,
+                                      pGC->alu, pGC->planemask, n, ppt, pwidth,
+                                      fSorted, (xorg + pGC->patOrg.x),
+                                      (yorg + pGC->patOrg.y), pGC->stipple);
+}
 
-	/***************************\
+        /***************************\
 	|     Pixmap Copy Spans     |
 	\***************************/
 
-
 static void
-XAARenderPixmapCopySpans(
-    GCPtr pGC,
-    int	n,
-    DDXPointPtr ppt,
-    int *pwidth,
-    int fSorted,
-    int xorg, int yorg 
-){
-   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
-   XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
-   XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
-
-   pCache->x = pPriv->offscreenArea->box.x1;
-   pCache->y = pPriv->offscreenArea->box.y1;
-   pCache->w = pCache->orig_w = 
-		pPriv->offscreenArea->box.x2 - pCache->x;
-   pCache->h = pCache->orig_h = 
-		pPriv->offscreenArea->box.y2 - pCache->y;
-   pCache->trans_color = -1;
-
-   (*infoRec->FillCacheBltSpans) (infoRec->pScrn, 
-                pGC->alu, pGC->planemask, n, ppt, pwidth, fSorted, pCache, 
-                (xorg + pGC->patOrg.x), (yorg + pGC->patOrg.y));
+XAARenderPixmapCopySpans(GCPtr pGC,
+                         int n,
+                         DDXPointPtr ppt,
+                         int *pwidth, int fSorted, int xorg, int yorg)
+{
+    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
+    XAACacheInfoPtr pCache = &(infoRec->ScratchCacheInfoRec);
+    XAAPixmapPtr pPriv = XAA_GET_PIXMAP_PRIVATE(pGC->tile.pixmap);
+
+    pCache->x = pPriv->offscreenArea->box.x1;
+    pCache->y = pPriv->offscreenArea->box.y1;
+    pCache->w = pCache->orig_w = pPriv->offscreenArea->box.x2 - pCache->x;
+    pCache->h = pCache->orig_h = pPriv->offscreenArea->box.y2 - pCache->y;
+    pCache->trans_color = -1;
+
+    (*infoRec->FillCacheBltSpans) (infoRec->pScrn,
+                                   pGC->alu, pGC->planemask, n, ppt, pwidth,
+                                   fSorted, pCache, (xorg + pGC->patOrg.x),
+                                   (yorg + pGC->patOrg.y));
 }
 
-
-
-
-
-	/****************\
+        /****************\
 	|     Solid      |
 	\****************/
 
-
 void
-XAAFillSolidSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted 
-){
+XAAFillSolidSpans(ScrnInfoPtr pScrn,
+                  int fg, int rop,
+                  unsigned int planemask,
+                  int n, DDXPointPtr ppt, int *pwidth, int fSorted)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
 
-    (*infoRec->SetupForSolidFill)(pScrn, fg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-    while(n--) {
-	if (*pwidth > 0)
-            (*infoRec->SubsequentSolidFillRect)(pScrn, ppt->x, ppt->y, 
-								*pwidth, 1);
-	ppt++; pwidth++;
+    (*infoRec->SetupForSolidFill) (pScrn, fg, rop, planemask);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        if (*pwidth > 0)
+            (*infoRec->SubsequentSolidFillRect) (pScrn, ppt->x, ppt->y,
+                                                 *pwidth, 1);
+        ppt++;
+        pwidth++;
     }
 
-    if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
     SET_SYNC_FLAG(infoRec);
 }
 
-	/***************\
+        /***************\
 	|   Mono 8x8    |
 	\***************/
 
-
 void
-XAAFillMono8x8PatternSpansScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   int pattern0, int pattern1,
-   int xorigin, int yorigin 
-){
+XAAFillMono8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
+                                       int fg, int bg, int rop,
+                                       unsigned int planemask,
+                                       int n,
+                                       DDXPointPtr ppt,
+                                       int *pwidth, int fSorted,
+                                       int pattern0, int pattern1,
+                                       int xorigin, int yorigin)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int patx = pattern0, paty = pattern1;
     int xorg = (-xorigin) & 0x07;
     int yorg = (-yorigin) & 0x07;
 
-
-    if(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-	    xorg = patx; yorg = paty;
+    if (infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS) {
+        if (!(infoRec->Mono8x8PatternFillFlags &
+              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+            XAARotateMonoPattern(&patx, &paty, xorg, yorg,
+                                 (infoRec->Mono8x8PatternFillFlags &
+                                  BIT_ORDER_IN_BYTE_MSBFIRST));
+            xorg = patx;
+            yorg = paty;
+        }
+    }
+    else {
+        XAACacheInfoPtr pCache =
+            (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
+        patx = pCache->x;
+        paty = pCache->y;
+        if (!(infoRec->Mono8x8PatternFillFlags &
+              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+            int slot = (yorg << 3) + xorg;
+
+            patx += pCache->offsets[slot].x;
+            paty += pCache->offsets[slot].y;
+            xorg = patx;
+            yorg = paty;
         }
-    } else {
-	XAACacheInfoPtr pCache =
-		(*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
-   	if(!(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    int slot = (yorg << 3) + xorg;
-	    patx += pCache->offsets[slot].x;
-	    paty += pCache->offsets[slot].y;
-	    xorg = patx;  yorg = paty;
-	}	
     }
 
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-	fg, bg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
+    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
+                                            fg, bg, rop, planemask);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
+                                                      xorg, yorg, ppt->x,
+                                                      ppt->y, *pwidth, 1);
+        ppt++;
+        pwidth++;
+    }
 
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
-     SET_SYNC_FLAG(infoRec);
+    SET_SYNC_FLAG(infoRec);
 }
 
-
 void
-XAAFillMono8x8PatternSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   int pattern0, int pattern1,
-   int xorigin, int yorigin 
-){
+XAAFillMono8x8PatternSpans(ScrnInfoPtr pScrn,
+                           int fg, int bg, int rop,
+                           unsigned int planemask,
+                           int n,
+                           DDXPointPtr ppt,
+                           int *pwidth, int fSorted,
+                           int pattern0, int pattern1, int xorigin, int yorigin)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int patx = pattern0, paty = pattern1;
     int xorg, yorg, slot;
     XAACacheInfoPtr pCache = NULL;
 
-
-    if(!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)){
-	pCache = (*infoRec->CacheMono8x8Pattern)(pScrn, pattern0, pattern1);
-	patx = pCache->x;  paty = pCache->y;
+    if (!(infoRec->Mono8x8PatternFillFlags & HARDWARE_PATTERN_PROGRAMMED_BITS)) {
+        pCache = (*infoRec->CacheMono8x8Pattern) (pScrn, pattern0, pattern1);
+        patx = pCache->x;
+        paty = pCache->y;
     }
 
-    (*infoRec->SetupForMono8x8PatternFill)(pScrn, patx, paty,
-					fg, bg, rop, planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	xorg = (ppt->x - xorigin) & 0x07;
-	yorg = (ppt->y - yorigin) & 0x07;
-
-   	if(!(infoRec->Mono8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    if(infoRec->Mono8x8PatternFillFlags & 
-				HARDWARE_PATTERN_PROGRAMMED_BITS) {
-		patx = pattern0; paty = pattern1;
-		XAARotateMonoPattern(&patx, &paty, xorg, yorg,
-				(infoRec->Mono8x8PatternFillFlags & 		
-				BIT_ORDER_IN_BYTE_MSBFIRST));
-		xorg = patx; yorg = paty;
-	    } else {
-		slot = (yorg << 3) + xorg;
-	    	xorg = patx + pCache->offsets[slot].x;
-	    	yorg = paty + pCache->offsets[slot].y;
-	    }
+    (*infoRec->SetupForMono8x8PatternFill) (pScrn, patx, paty,
+                                            fg, bg, rop, planemask);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        xorg = (ppt->x - xorigin) & 0x07;
+        yorg = (ppt->y - yorigin) & 0x07;
+
+        if (!(infoRec->Mono8x8PatternFillFlags &
+              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+            if (infoRec->Mono8x8PatternFillFlags &
+                HARDWARE_PATTERN_PROGRAMMED_BITS) {
+                patx = pattern0;
+                paty = pattern1;
+                XAARotateMonoPattern(&patx, &paty, xorg, yorg,
+                                     (infoRec->Mono8x8PatternFillFlags &
+                                      BIT_ORDER_IN_BYTE_MSBFIRST));
+                xorg = patx;
+                yorg = paty;
+            }
+            else {
+                slot = (yorg << 3) + xorg;
+                xorg = patx + pCache->offsets[slot].x;
+                yorg = paty + pCache->offsets[slot].y;
+            }
         }
 
-        (*infoRec->SubsequentMono8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
+        (*infoRec->SubsequentMono8x8PatternFillRect) (pScrn,
+                                                      xorg, yorg, ppt->x,
+                                                      ppt->y, *pwidth, 1);
+        ppt++;
+        pwidth++;
+    }
 
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
-     SET_SYNC_FLAG(infoRec);
+    SET_SYNC_FLAG(infoRec);
 }
 
-
-
-	/****************\
+        /****************\
 	|   Color 8x8    |
 	\****************/
 
-
 void
-XAAFillColor8x8PatternSpansScreenOrigin(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorigin, int yorigin 
-){
+XAAFillColor8x8PatternSpansScreenOrigin(ScrnInfoPtr pScrn,
+                                        int rop,
+                                        unsigned int planemask,
+                                        int n,
+                                        DDXPointPtr ppt,
+                                        int *pwidth, int fSorted,
+                                        XAACacheInfoPtr pCache,
+                                        int xorigin, int yorigin)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int patx = pCache->x, paty = pCache->y;
     int xorg = (-xorigin) & 0x07;
     int yorg = (-yorigin) & 0x07;
 
+    if (!(infoRec->Color8x8PatternFillFlags &
+          HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+        int slot = (yorg << 3) + xorg;
 
-    if(!(infoRec->Color8x8PatternFillFlags & 
-					HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	int slot = (yorg << 3) + xorg;
-	paty += pCache->offsets[slot].y;
-	patx += pCache->offsets[slot].x;
-	xorg = patx;  yorg = paty;
-    }	
-
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, patx, paty,
-			 rop, planemask, pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
- 
-    if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
+        paty += pCache->offsets[slot].y;
+        patx += pCache->offsets[slot].x;
+        xorg = patx;
+        yorg = paty;
+    }
+
+    (*infoRec->SetupForColor8x8PatternFill) (pScrn, patx, paty,
+                                             rop, planemask,
+                                             pCache->trans_color);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
+                                                       xorg, yorg, ppt->x,
+                                                       ppt->y, *pwidth, 1);
+        ppt++;
+        pwidth++;
+    }
 
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
+
+    SET_SYNC_FLAG(infoRec);
+}
 
 void
-XAAFillColor8x8PatternSpans(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth, int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorigin, int yorigin 
-){
+XAAFillColor8x8PatternSpans(ScrnInfoPtr pScrn,
+                            int rop,
+                            unsigned int planemask,
+                            int n,
+                            DDXPointPtr ppt,
+                            int *pwidth, int fSorted,
+                            XAACacheInfoPtr pCache, int xorigin, int yorigin)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
     int xorg, yorg, slot;
 
-    (*infoRec->SetupForColor8x8PatternFill)(pScrn, pCache->x, pCache->y,
-			 rop, planemask, pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	xorg = (ppt->x - xorigin) & 0x07;
-	yorg = (ppt->y - yorigin) & 0x07;
-
-   	if(!(infoRec->Color8x8PatternFillFlags & 		
-				HARDWARE_PATTERN_PROGRAMMED_ORIGIN)){
-	    slot = (yorg << 3) + xorg;
-	    yorg = pCache->y + pCache->offsets[slot].y;
-	    xorg = pCache->x + pCache->offsets[slot].x;
+    (*infoRec->SetupForColor8x8PatternFill) (pScrn, pCache->x, pCache->y,
+                                             rop, planemask,
+                                             pCache->trans_color);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        xorg = (ppt->x - xorigin) & 0x07;
+        yorg = (ppt->y - yorigin) & 0x07;
+
+        if (!(infoRec->Color8x8PatternFillFlags &
+              HARDWARE_PATTERN_PROGRAMMED_ORIGIN)) {
+            slot = (yorg << 3) + xorg;
+            yorg = pCache->y + pCache->offsets[slot].y;
+            xorg = pCache->x + pCache->offsets[slot].x;
         }
 
-        (*infoRec->SubsequentColor8x8PatternFillRect)(pScrn, 
-			xorg, yorg, ppt->x, ppt->y, *pwidth, 1);
-	ppt++; pwidth++;
-     }
+        (*infoRec->SubsequentColor8x8PatternFillRect) (pScrn,
+                                                       xorg, yorg, ppt->x,
+                                                       ppt->y, *pwidth, 1);
+        ppt++;
+        pwidth++;
+    }
 
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
-     SET_SYNC_FLAG(infoRec);
+    SET_SYNC_FLAG(infoRec);
 }
 
-	/*****************\
+        /*****************\
 	|   Cache Blit    |
 	\*****************/
 
-
 void
-XAAFillCacheBltSpans(
-   ScrnInfoPtr pScrn,
-   int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth,
-   int fSorted,
-   XAACacheInfoPtr pCache,
-   int xorg, int yorg
-){
+XAAFillCacheBltSpans(ScrnInfoPtr pScrn,
+                     int rop,
+                     unsigned int planemask,
+                     int n,
+                     DDXPointPtr ppt,
+                     int *pwidth,
+                     int fSorted, XAACacheInfoPtr pCache, int xorg, int yorg)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w;  
-
-    (*infoRec->SetupForScreenToScreenCopy)(pScrn, 1, 1, rop, planemask,
-		pCache->trans_color);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	x = ppt->x;
-	w = *pwidth; 
-	phaseX = (x - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	phaseY = (ppt->y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-
-	while(1) {
-	    blit_w = pCache->w - phaseX;
-	    if(blit_w > w) blit_w = w;
-
-            (*infoRec->SubsequentScreenToScreenCopy)(pScrn, 
-		pCache->x + phaseX, pCache->y + phaseY,
-		x, ppt->y, blit_w, 1);
-
-	    w -= blit_w;
-	    if(!w) break;
-	    x += blit_w;
-	    phaseX = (phaseX + blit_w) % pCache->orig_w;
-	}
-	ppt++; pwidth++;
-     }
-
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
-
-     SET_SYNC_FLAG(infoRec);
-}
+    int x, w, phaseX, phaseY, blit_w;
+
+    (*infoRec->SetupForScreenToScreenCopy) (pScrn, 1, 1, rop, planemask,
+                                            pCache->trans_color);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        x = ppt->x;
+        w = *pwidth;
+        phaseX = (x - xorg) % pCache->orig_w;
+        if (phaseX < 0)
+            phaseX += pCache->orig_w;
+        phaseY = (ppt->y - yorg) % pCache->orig_h;
+        if (phaseY < 0)
+            phaseY += pCache->orig_h;
+
+        while (1) {
+            blit_w = pCache->w - phaseX;
+            if (blit_w > w)
+                blit_w = w;
+
+            (*infoRec->SubsequentScreenToScreenCopy) (pScrn,
+                                                      pCache->x + phaseX,
+                                                      pCache->y + phaseY, x,
+                                                      ppt->y, blit_w, 1);
+
+            w -= blit_w;
+            if (!w)
+                break;
+            x += blit_w;
+            phaseX = (phaseX + blit_w) % pCache->orig_w;
+        }
+        ppt++;
+        pwidth++;
+    }
+
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
+    SET_SYNC_FLAG(infoRec);
+}
 
-	/****************\
+        /****************\
 	|  Cache Expand  |
 	\****************/
 
-
 void
-XAAFillCacheExpandSpans(
-   ScrnInfoPtr pScrn,
-   int fg, int bg, int rop,
-   unsigned int planemask,
-   int n,
-   DDXPointPtr ppt,
-   int *pwidth,
-   int fSorted,
-   int xorg, int yorg,
-   PixmapPtr pPix
-){
+XAAFillCacheExpandSpans(ScrnInfoPtr pScrn,
+                        int fg, int bg, int rop,
+                        unsigned int planemask,
+                        int n,
+                        DDXPointPtr ppt,
+                        int *pwidth,
+                        int fSorted, int xorg, int yorg, PixmapPtr pPix)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
-    int x, w, phaseX, phaseY, blit_w, cacheWidth;  
+    int x, w, phaseX, phaseY, blit_w, cacheWidth;
     XAACacheInfoPtr pCache;
 
-    pCache = (*infoRec->CacheMonoStipple)(pScrn, pPix);
-
-    cacheWidth = (pCache->w * pScrn->bitsPerPixel) / 
-	infoRec->CacheColorExpandDensity;
-
-    (*infoRec->SetupForScreenToScreenColorExpandFill)(pScrn, fg, bg, rop, 
-							planemask);
-
-    if(infoRec->ClipBox)
-	(*infoRec->SetClippingRectangle)(infoRec->pScrn,
-		infoRec->ClipBox->x1, infoRec->ClipBox->y1, 
-		infoRec->ClipBox->x2 - 1, infoRec->ClipBox->y2 - 1);
-
-     while(n--) {
-	x = ppt->x;
-	w = *pwidth; 
-	phaseX = (x - xorg) % pCache->orig_w;
-	if(phaseX < 0) phaseX += pCache->orig_w;
-	phaseY = (ppt->y - yorg) % pCache->orig_h;
-	if(phaseY < 0) phaseY += pCache->orig_h;
-
-	while(1) {
-	    blit_w = cacheWidth - phaseX;
-	    if(blit_w > w) blit_w = w;
-
-	    (*infoRec->SubsequentScreenToScreenColorExpandFill)(
-			pScrn, x, ppt->y, blit_w, 1,
-			pCache->x, pCache->y + phaseY, phaseX);
-
-	    w -= blit_w;
-	    if(!w) break;
-	    x += blit_w;
-	    phaseX = (phaseX + blit_w) % pCache->orig_w;
-	}
-	ppt++; pwidth++;
-     }
+    pCache = (*infoRec->CacheMonoStipple) (pScrn, pPix);
+
+    cacheWidth = (pCache->w * pScrn->bitsPerPixel) /
+        infoRec->CacheColorExpandDensity;
+
+    (*infoRec->SetupForScreenToScreenColorExpandFill) (pScrn, fg, bg, rop,
+                                                       planemask);
+
+    if (infoRec->ClipBox)
+        (*infoRec->SetClippingRectangle) (infoRec->pScrn,
+                                          infoRec->ClipBox->x1,
+                                          infoRec->ClipBox->y1,
+                                          infoRec->ClipBox->x2 - 1,
+                                          infoRec->ClipBox->y2 - 1);
+
+    while (n--) {
+        x = ppt->x;
+        w = *pwidth;
+        phaseX = (x - xorg) % pCache->orig_w;
+        if (phaseX < 0)
+            phaseX += pCache->orig_w;
+        phaseY = (ppt->y - yorg) % pCache->orig_h;
+        if (phaseY < 0)
+            phaseY += pCache->orig_h;
+
+        while (1) {
+            blit_w = cacheWidth - phaseX;
+            if (blit_w > w)
+                blit_w = w;
+
+            (*infoRec->SubsequentScreenToScreenColorExpandFill) (pScrn, x,
+                                                                 ppt->y, blit_w,
+                                                                 1, pCache->x,
+                                                                 pCache->y +
+                                                                 phaseY,
+                                                                 phaseX);
+
+            w -= blit_w;
+            if (!w)
+                break;
+            x += blit_w;
+            phaseX = (phaseX + blit_w) % pCache->orig_w;
+        }
+        ppt++;
+        pwidth++;
+    }
 
-     if(infoRec->ClipBox)
-	(*infoRec->DisableClipping)(infoRec->pScrn);
+    if (infoRec->ClipBox)
+        (*infoRec->DisableClipping) (infoRec->pScrn);
 
-     SET_SYNC_FLAG(infoRec);
+    SET_SYNC_FLAG(infoRec);
 }
 
-
-
 void
-XAAClipAndRenderSpans(
-    GCPtr pGC, 
-    DDXPointPtr	ppt,
-    int		*pwidth,
-    int		nspans,
-    int		fSorted,
-    ClipAndRenderSpansFunc func,
-    int 	xorg,
-    int		yorg
-){
+XAAClipAndRenderSpans(GCPtr pGC,
+                      DDXPointPtr ppt,
+                      int *pwidth,
+                      int nspans,
+                      int fSorted,
+                      ClipAndRenderSpansFunc func, int xorg, int yorg)
+{
     XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
     DDXPointPtr pptNew, pptBase;
-    int	*pwidthBase, *pwidthNew;
-    int	Right, numRects, MaxBoxes;
+    int *pwidthBase, *pwidthNew;
+    int Right, numRects, MaxBoxes;
 
-    MaxBoxes = infoRec->PreAllocSize/(sizeof(DDXPointRec) + sizeof(int));
-    pptBase = (DDXPointRec*)infoRec->PreAllocMem;
-    pwidthBase = (int*)(&pptBase[MaxBoxes]);
+    MaxBoxes = infoRec->PreAllocSize / (sizeof(DDXPointRec) + sizeof(int));
+    pptBase = (DDXPointRec *) infoRec->PreAllocMem;
+    pwidthBase = (int *) (&pptBase[MaxBoxes]);
 
     pptNew = pptBase;
     pwidthNew = pwidthBase;
 
     numRects = RegionNumRects(pGC->pCompositeClip);
 
-    if(numRects == 1) {
+    if (numRects == 1) {
         BoxPtr pextent = RegionRects(pGC->pCompositeClip);
-	    
-	while(nspans--) {
-	    if ((pextent->y1 <= ppt->y) && (ppt->y < pextent->y2)) {
-		pptNew->x = max(pextent->x1, ppt->x);
-		Right = ppt->x + *pwidth; 
-		*pwidthNew = min(pextent->x2, Right) - pptNew->x;
-
-		if (*pwidthNew > 0) {
-		    pptNew->y = ppt->y;
-		    pptNew++;
-		    pwidthNew++;
-
-		    if(pptNew >= (pptBase + MaxBoxes)) {
-			(*func)(pGC, MaxBoxes, pptBase, pwidthBase, fSorted, 	
-								xorg, yorg);
-			pptNew = pptBase;
-			pwidthNew = pwidthBase;
-		    }
-		}
-	    }
-	    ppt++;
-	    pwidth++;
-	}
-    } else if (numRects) {
-	BoxPtr	pbox;
-	int nbox;
-
-	while(nspans--) {
-	    nbox = numRects;
-	    pbox = RegionRects(pGC->pCompositeClip);
-
-	    /* find the first band */
-	    while(nbox && (pbox->y2 <= ppt->y)) {
-		pbox++;
-		nbox--;
-	    }
-
-	    if(nbox && (pbox->y1 <= ppt->y)) {
-		int orig_y = pbox->y1;
-		Right = ppt->x + *pwidth;
-		while(nbox && (orig_y == pbox->y1)) {
-		    if(pbox->x2 <= ppt->x) {
-			nbox--;
-			pbox++;
-			continue;
-		    }
-
-		    if(pbox->x1 >= Right) {
-			nbox = 0;
-			break;
-		    }
-
-		    pptNew->x = max(pbox->x1, ppt->x);
-		    *pwidthNew = min(pbox->x2, Right) - pptNew->x;
-		    if(*pwidthNew > 0) {
-			pptNew->y = ppt->y;
-			pptNew++;
-			pwidthNew++;
-
-			if(pptNew >= (pptBase + MaxBoxes)) {
-			    (*func)(pGC, MaxBoxes, pptBase, pwidthBase, 
-							fSorted, xorg, yorg);
-			    pptNew = pptBase;
-			    pwidthNew = pwidthBase;
-			}
-		    }
-		    pbox++;
-		    nbox--;
-		}
-	    }
-	    ppt++;
-	    pwidth++;
-	}
+
+        while (nspans--) {
+            if ((pextent->y1 <= ppt->y) && (ppt->y < pextent->y2)) {
+                pptNew->x = max(pextent->x1, ppt->x);
+                Right = ppt->x + *pwidth;
+                *pwidthNew = min(pextent->x2, Right) - pptNew->x;
+
+                if (*pwidthNew > 0) {
+                    pptNew->y = ppt->y;
+                    pptNew++;
+                    pwidthNew++;
+
+                    if (pptNew >= (pptBase + MaxBoxes)) {
+                        (*func) (pGC, MaxBoxes, pptBase, pwidthBase, fSorted,
+                                 xorg, yorg);
+                        pptNew = pptBase;
+                        pwidthNew = pwidthBase;
+                    }
+                }
+            }
+            ppt++;
+            pwidth++;
+        }
+    }
+    else if (numRects) {
+        BoxPtr pbox;
+        int nbox;
+
+        while (nspans--) {
+            nbox = numRects;
+            pbox = RegionRects(pGC->pCompositeClip);
+
+            /* find the first band */
+            while (nbox && (pbox->y2 <= ppt->y)) {
+                pbox++;
+                nbox--;
+            }
+
+            if (nbox && (pbox->y1 <= ppt->y)) {
+                int orig_y = pbox->y1;
+
+                Right = ppt->x + *pwidth;
+                while (nbox && (orig_y == pbox->y1)) {
+                    if (pbox->x2 <= ppt->x) {
+                        nbox--;
+                        pbox++;
+                        continue;
+                    }
+
+                    if (pbox->x1 >= Right) {
+                        nbox = 0;
+                        break;
+                    }
+
+                    pptNew->x = max(pbox->x1, ppt->x);
+                    *pwidthNew = min(pbox->x2, Right) - pptNew->x;
+                    if (*pwidthNew > 0) {
+                        pptNew->y = ppt->y;
+                        pptNew++;
+                        pwidthNew++;
+
+                        if (pptNew >= (pptBase + MaxBoxes)) {
+                            (*func) (pGC, MaxBoxes, pptBase, pwidthBase,
+                                     fSorted, xorg, yorg);
+                            pptNew = pptBase;
+                            pwidthNew = pwidthBase;
+                        }
+                    }
+                    pbox++;
+                    nbox--;
+                }
+            }
+            ppt++;
+            pwidth++;
+        }
     }
 
-    if(pptNew != pptBase)
-	(*func)(pGC, pptNew - pptBase, pptBase, pwidthBase, fSorted, 
-						xorg, yorg);
+    if (pptNew != pptBase)
+        (*func) (pGC, pptNew - pptBase, pptBase, pwidthBase, fSorted,
+                 xorg, yorg);
 }