Update to xserver 1.12.2. tested by naddy@, krw@, mpi@.

1 files changed, 219 insertions, 241 deletions

diff --git a/xserver/damageext/damageext.c b/xserver/damageext/damageext.c
index 02db88a8e..f21f71ca8 100644
--- a/xserver/damageext/damageext.c
+++ b/xserver/damageext/damageext.c
@@ -27,24 +27,25 @@
 #include "damageextint.h"
 #include "protocol-versions.h"
 
-static unsigned char	DamageReqCode;
-static int		DamageEventBase;
-static RESTYPE		DamageExtType;
-static RESTYPE		DamageExtWinType;
+static unsigned char DamageReqCode;
+static int DamageEventBase;
+static RESTYPE DamageExtType;
+static RESTYPE DamageExtWinType;
 
 static DevPrivateKeyRec DamageClientPrivateKeyRec;
+
 #define DamageClientPrivateKey (&DamageClientPrivateKeyRec)
 
 static void
-DamageExtNotify (DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
+DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
 {
-    ClientPtr		pClient = pDamageExt->pClient;
-    DamageClientPtr	pDamageClient = GetDamageClient (pClient);
-    DrawablePtr		pDrawable = pDamageExt->pDrawable;
-    xDamageNotifyEvent	ev;
-    int			i;
+    ClientPtr pClient = pDamageExt->pClient;
+    DamageClientPtr pDamageClient = GetDamageClient(pClient);
+    DrawablePtr pDrawable = pDamageExt->pDrawable;
+    xDamageNotifyEvent ev;
+    int i;
 
-    UpdateCurrentTimeIf ();
+    UpdateCurrentTimeIf();
     ev.type = DamageEventBase + XDamageNotify;
     ev.level = pDamageExt->level;
     ev.drawable = pDamageExt->drawable;
@@ -54,82 +55,79 @@ DamageExtNotify (DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
     ev.geometry.y = pDrawable->y;
     ev.geometry.width = pDrawable->width;
     ev.geometry.height = pDrawable->height;
-    if (pBoxes)
-    {
-	for (i = 0; i < nBoxes; i++)
-	{
-	    ev.level = pDamageExt->level;
-	    if (i < nBoxes - 1)
-		ev.level |= DamageNotifyMore;
-	    ev.area.x = pBoxes[i].x1;
-	    ev.area.y = pBoxes[i].y1;
-	    ev.area.width = pBoxes[i].x2 - pBoxes[i].x1;
-	    ev.area.height = pBoxes[i].y2 - pBoxes[i].y1;
-	    WriteEventsToClient (pClient, 1, (xEvent *) &ev);
-	}
+    if (pBoxes) {
+        for (i = 0; i < nBoxes; i++) {
+            ev.level = pDamageExt->level;
+            if (i < nBoxes - 1)
+                ev.level |= DamageNotifyMore;
+            ev.area.x = pBoxes[i].x1;
+            ev.area.y = pBoxes[i].y1;
+            ev.area.width = pBoxes[i].x2 - pBoxes[i].x1;
+            ev.area.height = pBoxes[i].y2 - pBoxes[i].y1;
+            WriteEventsToClient(pClient, 1, (xEvent *) &ev);
+        }
     }
-    else
-    {
-	ev.area.x = 0;
-	ev.area.y = 0;
-	ev.area.width = pDrawable->width;
-	ev.area.height = pDrawable->height;
-	WriteEventsToClient (pClient, 1, (xEvent *) &ev);
+    else {
+        ev.area.x = 0;
+        ev.area.y = 0;
+        ev.area.width = pDrawable->width;
+        ev.area.height = pDrawable->height;
+        WriteEventsToClient(pClient, 1, (xEvent *) &ev);
     }
     /* Composite extension marks clients with manual Subwindows as critical */
-    if (pDamageClient->critical > 0)
-    {
-	SetCriticalOutputPending ();
-	pClient->smart_priority = SMART_MAX_PRIORITY;
+    if (pDamageClient->critical > 0) {
+        SetCriticalOutputPending();
+        pClient->smart_priority = SMART_MAX_PRIORITY;
     }
 }
 
 static void
-DamageExtReport (DamagePtr pDamage, RegionPtr pRegion, void *closure)
+DamageExtReport(DamagePtr pDamage, RegionPtr pRegion, void *closure)
 {
-    DamageExtPtr    pDamageExt = closure;
+    DamageExtPtr pDamageExt = closure;
 
     switch (pDamageExt->level) {
     case DamageReportRawRegion:
     case DamageReportDeltaRegion:
-	DamageExtNotify (pDamageExt, RegionRects(pRegion), RegionNumRects(pRegion));
-	break;
+        DamageExtNotify(pDamageExt, RegionRects(pRegion),
+                        RegionNumRects(pRegion));
+        break;
     case DamageReportBoundingBox:
-	DamageExtNotify (pDamageExt, RegionExtents(pRegion), 1);
-	break;
+        DamageExtNotify(pDamageExt, RegionExtents(pRegion), 1);
+        break;
     case DamageReportNonEmpty:
-	DamageExtNotify (pDamageExt, NullBox, 0);
-	break;
+        DamageExtNotify(pDamageExt, NullBox, 0);
+        break;
     case DamageReportNone:
-	break;
+        break;
     }
 }
 
 static void
-DamageExtDestroy (DamagePtr pDamage, void *closure)
+DamageExtDestroy(DamagePtr pDamage, void *closure)
 {
-    DamageExtPtr    pDamageExt = closure;
-    
+    DamageExtPtr pDamageExt = closure;
+
     pDamageExt->pDamage = 0;
     if (pDamageExt->id)
-	FreeResource (pDamageExt->id, RT_NONE);
+        FreeResource(pDamageExt->id, RT_NONE);
 }
 
 void
-DamageExtSetCritical (ClientPtr pClient, Bool critical)
+DamageExtSetCritical(ClientPtr pClient, Bool critical)
 {
-    DamageClientPtr pDamageClient = GetDamageClient (pClient);
+    DamageClientPtr pDamageClient = GetDamageClient(pClient);
 
     if (pDamageClient)
-	pDamageClient->critical += critical ? 1 : -1;
+        pDamageClient->critical += critical ? 1 : -1;
 }
 
 static int
 ProcDamageQueryVersion(ClientPtr client)
 {
-    DamageClientPtr pDamageClient = GetDamageClient (client);
+    DamageClientPtr pDamageClient = GetDamageClient(client);
     xDamageQueryVersionReply rep;
-    register int n;
+
     REQUEST(xDamageQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
@@ -137,157 +135,153 @@ ProcDamageQueryVersion(ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     if (stuff->majorVersion < SERVER_DAMAGE_MAJOR_VERSION) {
-	rep.majorVersion = stuff->majorVersion;
-	rep.minorVersion = stuff->minorVersion;
-    } else {
-	rep.majorVersion = SERVER_DAMAGE_MAJOR_VERSION;
-	if (stuff->majorVersion == SERVER_DAMAGE_MAJOR_VERSION &&
-	    stuff->minorVersion < SERVER_DAMAGE_MINOR_VERSION)
-	    rep.minorVersion = stuff->minorVersion;
-	else
-	    rep.minorVersion = SERVER_DAMAGE_MINOR_VERSION;
+        rep.majorVersion = stuff->majorVersion;
+        rep.minorVersion = stuff->minorVersion;
+    }
+    else {
+        rep.majorVersion = SERVER_DAMAGE_MAJOR_VERSION;
+        if (stuff->majorVersion == SERVER_DAMAGE_MAJOR_VERSION &&
+            stuff->minorVersion < SERVER_DAMAGE_MINOR_VERSION)
+            rep.minorVersion = stuff->minorVersion;
+        else
+            rep.minorVersion = SERVER_DAMAGE_MINOR_VERSION;
     }
     pDamageClient->major_version = rep.majorVersion;
     pDamageClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.majorVersion);
+        swapl(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xDamageQueryVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDamageQueryVersionReply), (char *) &rep);
     return Success;
 }
 
 static int
-ProcDamageCreate (ClientPtr client)
+ProcDamageCreate(ClientPtr client)
 {
-    DrawablePtr		pDrawable;
-    DamageExtPtr	pDamageExt;
-    DamageReportLevel	level;
-    RegionPtr		pRegion;
-    int			rc;
-    
+    DrawablePtr pDrawable;
+    DamageExtPtr pDamageExt;
+    DamageReportLevel level;
+    RegionPtr pRegion;
+    int rc;
+
     REQUEST(xDamageCreateReq);
 
     REQUEST_SIZE_MATCH(xDamageCreateReq);
     LEGAL_NEW_RESOURCE(stuff->damage, client);
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
-			   DixGetAttrAccess|DixReadAccess);
+                           DixGetAttrAccess | DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     switch (stuff->level) {
     case XDamageReportRawRectangles:
-	level = DamageReportRawRegion;
-	break;
+        level = DamageReportRawRegion;
+        break;
     case XDamageReportDeltaRectangles:
-	level = DamageReportDeltaRegion;
-	break;
+        level = DamageReportDeltaRegion;
+        break;
     case XDamageReportBoundingBox:
-	level = DamageReportBoundingBox;
-	break;
+        level = DamageReportBoundingBox;
+        break;
     case XDamageReportNonEmpty:
-	level = DamageReportNonEmpty;
-	break;
+        level = DamageReportNonEmpty;
+        break;
     default:
-	client->errorValue = stuff->level;
-	return BadValue;
+        client->errorValue = stuff->level;
+        return BadValue;
     }
-    
-    pDamageExt = malloc(sizeof (DamageExtRec));
+
+    pDamageExt = malloc(sizeof(DamageExtRec));
     if (!pDamageExt)
-	return BadAlloc;
+        return BadAlloc;
     pDamageExt->id = stuff->damage;
     pDamageExt->drawable = stuff->drawable;
     pDamageExt->pDrawable = pDrawable;
     pDamageExt->level = level;
     pDamageExt->pClient = client;
-    pDamageExt->pDamage = DamageCreate (DamageExtReport,
-					DamageExtDestroy,
-					level,
-					FALSE,
-					pDrawable->pScreen,
-					pDamageExt);
-    if (!pDamageExt->pDamage)
-    {
-	free(pDamageExt);
-	return BadAlloc;
+    pDamageExt->pDamage = DamageCreate(DamageExtReport,
+                                       DamageExtDestroy,
+                                       level,
+                                       FALSE, pDrawable->pScreen, pDamageExt);
+    if (!pDamageExt->pDamage) {
+        free(pDamageExt);
+        return BadAlloc;
     }
-    if (!AddResource (stuff->damage, DamageExtType, (pointer) pDamageExt))
-	return BadAlloc;
+    if (!AddResource(stuff->damage, DamageExtType, (pointer) pDamageExt))
+        return BadAlloc;
 
-    DamageSetReportAfterOp (pDamageExt->pDamage, TRUE);
-    DamageRegister (pDamageExt->pDrawable, pDamageExt->pDamage);
+    DamageSetReportAfterOp(pDamageExt->pDamage, TRUE);
+    DamageRegister(pDamageExt->pDrawable, pDamageExt->pDamage);
 
-    if (pDrawable->type == DRAWABLE_WINDOW)
-    {
-	pRegion = &((WindowPtr) pDrawable)->borderClip;
-	DamageReportDamage(pDamageExt->pDamage, pRegion);
+    if (pDrawable->type == DRAWABLE_WINDOW) {
+        pRegion = &((WindowPtr) pDrawable)->borderClip;
+        DamageReportDamage(pDamageExt->pDamage, pRegion);
     }
 
     return Success;
 }
 
 static int
-ProcDamageDestroy (ClientPtr client)
+ProcDamageDestroy(ClientPtr client)
 {
     REQUEST(xDamageDestroyReq);
-    DamageExtPtr    pDamageExt;
+    DamageExtPtr pDamageExt;
 
     REQUEST_SIZE_MATCH(xDamageDestroyReq);
     VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
-    FreeResource (stuff->damage, RT_NONE);
+    FreeResource(stuff->damage, RT_NONE);
     return Success;
 }
 
 static int
-ProcDamageSubtract (ClientPtr client)
+ProcDamageSubtract(ClientPtr client)
 {
     REQUEST(xDamageSubtractReq);
-    DamageExtPtr    pDamageExt;
-    RegionPtr	    pRepair;
-    RegionPtr	    pParts;
+    DamageExtPtr pDamageExt;
+    RegionPtr pRepair;
+    RegionPtr pParts;
 
     REQUEST_SIZE_MATCH(xDamageSubtractReq);
     VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
     VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, DixWriteAccess);
     VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, DixWriteAccess);
 
-    if (pDamageExt->level != DamageReportRawRegion)
-    {
-	DamagePtr   pDamage = pDamageExt->pDamage;
-	if (pRepair)
-	{
-	    if (pParts)
-		RegionIntersect(pParts, DamageRegion (pDamage), pRepair);
-	    if (DamageSubtract (pDamage, pRepair))
-		DamageExtReport (pDamage, DamageRegion (pDamage), (void *) pDamageExt);
-	}
-	else
-	{
-	    if (pParts)
-		RegionCopy(pParts, DamageRegion (pDamage));
-	    DamageEmpty (pDamage);
-	}
+    if (pDamageExt->level != DamageReportRawRegion) {
+        DamagePtr pDamage = pDamageExt->pDamage;
+
+        if (pRepair) {
+            if (pParts)
+                RegionIntersect(pParts, DamageRegion(pDamage), pRepair);
+            if (DamageSubtract(pDamage, pRepair))
+                DamageExtReport(pDamage, DamageRegion(pDamage),
+                                (void *) pDamageExt);
+        }
+        else {
+            if (pParts)
+                RegionCopy(pParts, DamageRegion(pDamage));
+            DamageEmpty(pDamage);
+        }
     }
     return Success;
 }
 
 static int
-ProcDamageAdd (ClientPtr client)
+ProcDamageAdd(ClientPtr client)
 {
     REQUEST(xDamageAddReq);
-    DrawablePtr	    pDrawable;
-    RegionPtr	    pRegion;
-    int		    rc;
+    DrawablePtr pDrawable;
+    RegionPtr pRegion;
+    int rc;
 
     REQUEST_SIZE_MATCH(xDamageAddReq);
     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
-			   DixWriteAccess);
+                           DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     /* The region is relative to the drawable origin, so translate it out to
      * screen coordinates like damage expects.
@@ -301,221 +295,205 @@ ProcDamageAdd (ClientPtr client)
 
 /* Major version controls available requests */
 static const int version_requests[] = {
-    X_DamageQueryVersion,	/* before client sends QueryVersion */
-    X_DamageAdd,		/* Version 1 */
+    X_DamageQueryVersion,       /* before client sends QueryVersion */
+    X_DamageAdd,                /* Version 1 */
 };
 
 #define NUM_VERSION_REQUESTS	(sizeof (version_requests) / sizeof (version_requests[0]))
-    
-static int (*ProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
+
+static int (*ProcDamageVector[XDamageNumberRequests]) (ClientPtr) = {
 /*************** Version 1 ******************/
     ProcDamageQueryVersion,
-    ProcDamageCreate,
-    ProcDamageDestroy,
-    ProcDamageSubtract,
+        ProcDamageCreate, ProcDamageDestroy, ProcDamageSubtract,
 /*************** Version 1.1 ****************/
-    ProcDamageAdd,
-};
-
+ProcDamageAdd,};
 
 static int
-ProcDamageDispatch (ClientPtr client)
+ProcDamageDispatch(ClientPtr client)
 {
     REQUEST(xDamageReq);
-    DamageClientPtr pDamageClient = GetDamageClient (client);
+    DamageClientPtr pDamageClient = GetDamageClient(client);
 
     if (pDamageClient->major_version >= NUM_VERSION_REQUESTS)
-	return BadRequest;
+        return BadRequest;
     if (stuff->damageReqType > version_requests[pDamageClient->major_version])
-	return BadRequest;
+        return BadRequest;
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
 SProcDamageQueryVersion(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
-SProcDamageCreate (ClientPtr client)
+SProcDamageCreate(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageCreateReq);
-    
-    swaps (&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageCreateReq);
-    swapl (&stuff->damage, n);
-    swapl (&stuff->drawable, n);
+    swapl(&stuff->damage);
+    swapl(&stuff->drawable);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
-SProcDamageDestroy (ClientPtr client)
+SProcDamageDestroy(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageDestroyReq);
-    
-    swaps (&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageDestroyReq);
-    swapl (&stuff->damage, n);
+    swapl(&stuff->damage);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
-SProcDamageSubtract (ClientPtr client)
+SProcDamageSubtract(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageSubtractReq);
-    
-    swaps (&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageSubtractReq);
-    swapl (&stuff->damage, n);
-    swapl (&stuff->repair, n);
-    swapl (&stuff->parts, n);
+    swapl(&stuff->damage);
+    swapl(&stuff->repair);
+    swapl(&stuff->parts);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
-SProcDamageAdd (ClientPtr client)
+SProcDamageAdd(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageAddReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageSubtractReq);
-    swapl (&stuff->drawable, n);
-    swapl (&stuff->region, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->region);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
-static int (*SProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
+static int (*SProcDamageVector[XDamageNumberRequests]) (ClientPtr) = {
 /*************** Version 1 ******************/
     SProcDamageQueryVersion,
-    SProcDamageCreate,
-    SProcDamageDestroy,
-    SProcDamageSubtract,
+        SProcDamageCreate, SProcDamageDestroy, SProcDamageSubtract,
 /*************** Version 1.1 ****************/
-    SProcDamageAdd,
-};
+SProcDamageAdd,};
 
 static int
-SProcDamageDispatch (ClientPtr client)
+SProcDamageDispatch(ClientPtr client)
 {
     REQUEST(xDamageReq);
     if (stuff->damageReqType >= XDamageNumberRequests)
-	return BadRequest;
+        return BadRequest;
     return (*SProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static void
-DamageClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+DamageClientCallback(CallbackListPtr *list, pointer closure, pointer data)
 {
-    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
-    ClientPtr		pClient = clientinfo->client;
-    DamageClientPtr	pDamageClient = GetDamageClient (pClient);
+    NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
+    ClientPtr pClient = clientinfo->client;
+    DamageClientPtr pDamageClient = GetDamageClient(pClient);
 
     pDamageClient->critical = 0;
     pDamageClient->major_version = 0;
     pDamageClient->minor_version = 0;
 }
 
-/*ARGSUSED*/
-static void
-DamageResetProc (ExtensionEntry *extEntry)
+ /*ARGSUSED*/ static void
+DamageResetProc(ExtensionEntry * extEntry)
 {
-    DeleteCallback (&ClientStateCallback, DamageClientCallback, 0);
+    DeleteCallback(&ClientStateCallback, DamageClientCallback, 0);
 }
 
 static int
-FreeDamageExt (pointer value, XID did)
+FreeDamageExt(pointer value, XID did)
 {
-    DamageExtPtr    pDamageExt = (DamageExtPtr) value;
+    DamageExtPtr pDamageExt = (DamageExtPtr) value;
 
     /*
      * Get rid of the resource table entry hanging from the window id
      */
     pDamageExt->id = 0;
     if (WindowDrawable(pDamageExt->pDrawable->type))
-	FreeResourceByType (pDamageExt->pDrawable->id, DamageExtWinType, TRUE);
-    if (pDamageExt->pDamage)
-    {
-	DamageUnregister (pDamageExt->pDrawable, pDamageExt->pDamage);
-	DamageDestroy (pDamageExt->pDamage);
+        FreeResourceByType(pDamageExt->pDrawable->id, DamageExtWinType, TRUE);
+    if (pDamageExt->pDamage) {
+        DamageUnregister(pDamageExt->pDrawable, pDamageExt->pDamage);
+        DamageDestroy(pDamageExt->pDamage);
     }
     free(pDamageExt);
     return Success;
 }
 
 static int
-FreeDamageExtWin (pointer value, XID wid)
+FreeDamageExtWin(pointer value, XID wid)
 {
-    DamageExtPtr    pDamageExt = (DamageExtPtr) value;
+    DamageExtPtr pDamageExt = (DamageExtPtr) value;
 
     if (pDamageExt->id)
-	FreeResource (pDamageExt->id, RT_NONE);
+        FreeResource(pDamageExt->id, RT_NONE);
     return Success;
 }
 
 static void
-SDamageNotifyEvent (xDamageNotifyEvent *from,
-		    xDamageNotifyEvent *to)
+SDamageNotifyEvent(xDamageNotifyEvent * from, xDamageNotifyEvent * to)
 {
     to->type = from->type;
-    cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->drawable, to->drawable);
-    cpswapl (from->damage, to->damage);
-    cpswaps (from->area.x, to->area.x);
-    cpswaps (from->area.y, to->area.y);
-    cpswaps (from->area.width, to->area.width);
-    cpswaps (from->area.height, to->area.height);
-    cpswaps (from->geometry.x, to->geometry.x);
-    cpswaps (from->geometry.y, to->geometry.y);
-    cpswaps (from->geometry.width, to->geometry.width);
-    cpswaps (from->geometry.height, to->geometry.height);
+    cpswaps(from->sequenceNumber, to->sequenceNumber);
+    cpswapl(from->drawable, to->drawable);
+    cpswapl(from->damage, to->damage);
+    cpswaps(from->area.x, to->area.x);
+    cpswaps(from->area.y, to->area.y);
+    cpswaps(from->area.width, to->area.width);
+    cpswaps(from->area.height, to->area.height);
+    cpswaps(from->geometry.x, to->geometry.x);
+    cpswaps(from->geometry.y, to->geometry.y);
+    cpswaps(from->geometry.width, to->geometry.width);
+    cpswaps(from->geometry.height, to->geometry.height);
 }
 
 void
 DamageExtensionInit(void)
 {
     ExtensionEntry *extEntry;
-    int		    s;
+    int s;
 
     for (s = 0; s < screenInfo.numScreens; s++)
-	DamageSetup (screenInfo.screens[s]);
+        DamageSetup(screenInfo.screens[s]);
 
-    DamageExtType = CreateNewResourceType (FreeDamageExt, "DamageExt");
+    DamageExtType = CreateNewResourceType(FreeDamageExt, "DamageExt");
     if (!DamageExtType)
-	return;
+        return;
 
-    DamageExtWinType = CreateNewResourceType (FreeDamageExtWin, "DamageExtWin");
+    DamageExtWinType = CreateNewResourceType(FreeDamageExtWin, "DamageExtWin");
     if (!DamageExtWinType)
-	return;
-
-    if (!dixRegisterPrivateKey(&DamageClientPrivateKeyRec, PRIVATE_CLIENT, sizeof (DamageClientRec)))
-	return;
-
-    if (!AddCallback (&ClientStateCallback, DamageClientCallback, 0))
-	return;
-
-    if ((extEntry = AddExtension(DAMAGE_NAME, XDamageNumberEvents, 
-				 XDamageNumberErrors,
-				 ProcDamageDispatch, SProcDamageDispatch,
-				 DamageResetProc, StandardMinorOpcode)) != 0)
-    {
-	DamageReqCode = (unsigned char)extEntry->base;
-	DamageEventBase = extEntry->eventBase;
-	EventSwapVector[DamageEventBase + XDamageNotify] =
-			(EventSwapPtr) SDamageNotifyEvent;
-	SetResourceTypeErrorValue(DamageExtType, extEntry->errorBase + BadDamage);
+        return;
+
+    if (!dixRegisterPrivateKey
+        (&DamageClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(DamageClientRec)))
+        return;
+
+    if (!AddCallback(&ClientStateCallback, DamageClientCallback, 0))
+        return;
+
+    if ((extEntry = AddExtension(DAMAGE_NAME, XDamageNumberEvents,
+                                 XDamageNumberErrors,
+                                 ProcDamageDispatch, SProcDamageDispatch,
+                                 DamageResetProc, StandardMinorOpcode)) != 0) {
+        DamageReqCode = (unsigned char) extEntry->base;
+        DamageEventBase = extEntry->eventBase;
+        EventSwapVector[DamageEventBase + XDamageNotify] =
+            (EventSwapPtr) SDamageNotifyEvent;
+        SetResourceTypeErrorValue(DamageExtType,
+                                  extEntry->errorBase + BadDamage);
     }
 }