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, 1131 insertions, 1261 deletions

diff --git a/Xext/sync.c b/Xext/sync.c
index 23360f002..d5d19d425 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -24,7 +24,6 @@ not be used in advertising or otherwise to promote the sale, use or
 other dealings in this Software without prior written authorization
 from The Open Group.
 
-
 Copyright 1991, 1993 by Digital Equipment Corporation, Maynard, Massachusetts,
 and Olivetti Research Limited, Cambridge, England.
 
@@ -81,25 +80,26 @@ PERFORMANCE OF THIS SOFTWARE.
 /*
  * Local Global Variables
  */
-static int      SyncEventBase;
-static int      SyncErrorBase;
-static RESTYPE  RTCounter = 0;
-static RESTYPE  RTAwait;
-static RESTYPE  RTAlarm;
-static RESTYPE  RTAlarmClient;
-static RESTYPE  RTFence;
+static int SyncEventBase;
+static int SyncErrorBase;
+static RESTYPE RTCounter = 0;
+static RESTYPE RTAwait;
+static RESTYPE RTAlarm;
+static RESTYPE RTAlarmClient;
+static RESTYPE RTFence;
 static int SyncNumSystemCounters = 0;
 static SyncCounter **SysCounterList = NULL;
 static int SyncNumInvalidCounterWarnings = 0;
+
 #define MAX_INVALID_COUNTER_WARNINGS	   5
 
 static const char *WARN_INVALID_COUNTER_COMPARE =
-"Warning: Non-counter XSync object using Counter-only\n"
-"         comparison.  Result will never be true.\n";
+    "Warning: Non-counter XSync object using Counter-only\n"
+    "         comparison.  Result will never be true.\n";
 
 static const char *WARN_INVALID_COUNTER_ALARM =
-"Warning: Non-counter XSync object used in alarm.  This is\n"
-"         the result of a programming error in the X server.\n";
+    "Warning: Non-counter XSync object used in alarm.  This is\n"
+    "         the result of a programming error in the X server.\n";
 
 #define IsSystemCounter(pCounter) \
     (pCounter && (pCounter->sync.client == NULL))
@@ -115,17 +115,15 @@ static void SyncInitServerTime(void);
 static void SyncInitIdleTime(void);
 
 static Bool
-SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)
+SyncCheckWarnIsCounter(const SyncObject * pSync, const char *warning)
 {
-    if (pSync && (SYNC_COUNTER != pSync->type))
-    {
-	if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS)
-	{
-	    ErrorF("%s", warning);
-	    ErrorF("         Counter type: %d\n", pSync->type);
-	}
+    if (pSync && (SYNC_COUNTER != pSync->type)) {
+        if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS) {
+            ErrorF("%s", warning);
+            ErrorF("         Counter type: %d\n", pSync->type);
+        }
 
-	return FALSE;
+        return FALSE;
     }
 
     return TRUE;
@@ -136,7 +134,7 @@ SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)
  *  delete and add triggers on this list.
  */
 static void
-SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)
+SyncDeleteTriggerFromSyncObject(SyncTrigger * pTrigger)
 {
     SyncTriggerList *pCur;
     SyncTriggerList *pPrev;
@@ -145,79 +143,76 @@ SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)
     /* pSync needs to be stored in pTrigger before calling here. */
 
     if (!pTrigger->pSync)
-	return;
+        return;
 
     pPrev = NULL;
     pCur = pTrigger->pSync->pTriglist;
 
-    while (pCur)
-    {
-	if (pCur->pTrigger == pTrigger)
-	{
-	    if (pPrev)
-		pPrev->next = pCur->next;
-	    else
-		pTrigger->pSync->pTriglist = pCur->next;
+    while (pCur) {
+        if (pCur->pTrigger == pTrigger) {
+            if (pPrev)
+                pPrev->next = pCur->next;
+            else
+                pTrigger->pSync->pTriglist = pCur->next;
+
+            free(pCur);
+            break;
+        }
 
-	    free(pCur);
-	    break;
-	}
-	
-	pPrev = pCur;
-	pCur = pCur->next;
+        pPrev = pCur;
+        pCur = pCur->next;
     }
 
-    if (SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	pCounter = (SyncCounter *)pTrigger->pSync;
+    if (SYNC_COUNTER == pTrigger->pSync->type) {
+        pCounter = (SyncCounter *) pTrigger->pSync;
 
-	if (IsSystemCounter(pCounter))
-	    SyncComputeBracketValues(pCounter);
-    } else if (SYNC_FENCE == pTrigger->pSync->type) {
-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-	pFence->funcs.DeleteTrigger(pTrigger);
+        if (IsSystemCounter(pCounter))
+            SyncComputeBracketValues(pCounter);
     }
-}
+    else if (SYNC_FENCE == pTrigger->pSync->type) {
+        SyncFence *pFence = (SyncFence *) pTrigger->pSync;
 
+        pFence->funcs.DeleteTrigger(pTrigger);
+    }
+}
 
 static int
-SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)
+SyncAddTriggerToSyncObject(SyncTrigger * pTrigger)
 {
     SyncTriggerList *pCur;
     SyncCounter *pCounter;
 
     if (!pTrigger->pSync)
-	return Success;
+        return Success;
 
     /* don't do anything if it's already there */
-    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next)
-    {
-	if (pCur->pTrigger == pTrigger)
-	    return Success;
+    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next) {
+        if (pCur->pTrigger == pTrigger)
+            return Success;
     }
 
     if (!(pCur = malloc(sizeof(SyncTriggerList))))
-	return BadAlloc;
+        return BadAlloc;
 
     pCur->pTrigger = pTrigger;
     pCur->next = pTrigger->pSync->pTriglist;
     pTrigger->pSync->pTriglist = pCur;
 
-    if (SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	pCounter = (SyncCounter *)pTrigger->pSync;
+    if (SYNC_COUNTER == pTrigger->pSync->type) {
+        pCounter = (SyncCounter *) pTrigger->pSync;
+
+        if (IsSystemCounter(pCounter))
+            SyncComputeBracketValues(pCounter);
+    }
+    else if (SYNC_FENCE == pTrigger->pSync->type) {
+        SyncFence *pFence = (SyncFence *) pTrigger->pSync;
 
-	if (IsSystemCounter(pCounter))
-	    SyncComputeBracketValues(pCounter);
-    } else if (SYNC_FENCE == pTrigger->pSync->type) {
-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-	pFence->funcs.AddTrigger(pTrigger);
+        pFence->funcs.AddTrigger(pTrigger);
     }
 
     return Success;
 }
 
-
 /*  Below are five possible functions that can be plugged into
  *  pTrigger->CheckTrigger for counter sync objects, corresponding to
  *  the four possible test-types, and the one possible function that
@@ -234,194 +229,182 @@ SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)
  */
 
 static Bool
-SyncCheckTriggerPositiveComparison(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerPositiveComparison(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));
+            XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));
 }
 
 static Bool
-SyncCheckTriggerNegativeComparison(SyncTrigger *pTrigger,  CARD64 oldval)
+SyncCheckTriggerNegativeComparison(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));
+            XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));
 }
 
 static Bool
-SyncCheckTriggerPositiveTransition(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerPositiveTransition(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    (XSyncValueLessThan(oldval, pTrigger->test_value) &&
-	     XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
+            (XSyncValueLessThan(oldval, pTrigger->test_value) &&
+             XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
 }
 
 static Bool
-SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerNegativeTransition(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
-	     XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
+            (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
+             XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
 }
 
 static Bool
-SyncCheckTriggerFence(SyncTrigger *pTrigger, CARD64 unused)
+SyncCheckTriggerFence(SyncTrigger * pTrigger, CARD64 unused)
 {
-    SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-    (void)unused;
+    SyncFence *pFence = (SyncFence *) pTrigger->pSync;
+
+    (void) unused;
 
-    return (pFence == NULL ||
-	    pFence->funcs.CheckTriggered(pFence));
+    return (pFence == NULL || pFence->funcs.CheckTriggered(pFence));
 }
 
 static int
-SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,
-		RESTYPE resType, Mask changes)
+SyncInitTrigger(ClientPtr client, SyncTrigger * pTrigger, XID syncObject,
+                RESTYPE resType, Mask changes)
 {
     SyncObject *pSync = pTrigger->pSync;
     SyncCounter *pCounter = NULL;
-    int		rc;
-    Bool	newSyncObject = FALSE;
-
-    if (changes & XSyncCACounter)
-    {
-	if (syncObject == None)
-	    pSync = NULL;
-	else if (Success != (rc = dixLookupResourceByType ((pointer *)&pSync,
-				syncObject, resType, client, DixReadAccess)))
-	{
-	    client->errorValue = syncObject;
-	    return rc;
-	}
-	if (pSync != pTrigger->pSync)
-	{ /* new counter for trigger */
-	    SyncDeleteTriggerFromSyncObject(pTrigger);
-	    pTrigger->pSync = pSync;
-	    newSyncObject = TRUE;
-	}
+    int rc;
+    Bool newSyncObject = FALSE;
+
+    if (changes & XSyncCACounter) {
+        if (syncObject == None)
+            pSync = NULL;
+        else if (Success != (rc = dixLookupResourceByType((pointer *) &pSync,
+                                                          syncObject, resType,
+                                                          client,
+                                                          DixReadAccess))) {
+            client->errorValue = syncObject;
+            return rc;
+        }
+        if (pSync != pTrigger->pSync) { /* new counter for trigger */
+            SyncDeleteTriggerFromSyncObject(pTrigger);
+            pTrigger->pSync = pSync;
+            newSyncObject = TRUE;
+        }
     }
 
     /* if system counter, ask it what the current value is */
 
-    if (pSync && SYNC_COUNTER == pSync->type)
-    {
-	pCounter = (SyncCounter *)pSync;
-
-	if (IsSystemCounter(pCounter))
-	{
-	    (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
-						      &pCounter->value);
-	}
-    }
-
-    if (changes & XSyncCAValueType)
-    {
-	if (pTrigger->value_type != XSyncRelative &&
-	    pTrigger->value_type != XSyncAbsolute)
-	{
-	    client->errorValue = pTrigger->value_type;
-	    return BadValue;
-	}
-    }
-
-    if (changes & XSyncCATestType)
-    {
-
-	if (pSync && SYNC_FENCE == pSync->type)
-	{
-	    pTrigger->CheckTrigger = SyncCheckTriggerFence;
-	}
-	else
-	{
-	    /* select appropriate CheckTrigger function */
-
-	    switch (pTrigger->test_type)
-	    {
-	    case XSyncPositiveTransition:
-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
-		break;
-	    case XSyncNegativeTransition:
-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
-		break;
-	    case XSyncPositiveComparison:
-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
-		break;
-	    case XSyncNegativeComparison:
-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
-		break;
-	    default:
-		client->errorValue = pTrigger->test_type;
-		return BadValue;
-	    }
-	}
-    }
-
-    if (changes & (XSyncCAValueType | XSyncCAValue))
-    {
-	if (pTrigger->value_type == XSyncAbsolute)
-	    pTrigger->test_value = pTrigger->wait_value;
-	else /* relative */
-	{
-	    Bool overflow;
-	    if (pCounter == NULL)
-		return BadMatch;
-
-	    XSyncValueAdd(&pTrigger->test_value, pCounter->value,
-			  pTrigger->wait_value, &overflow);
-	    if (overflow)
-	    {
-		client->errorValue = XSyncValueHigh32(pTrigger->wait_value);
-		return BadValue;
-	    }
-	}
+    if (pSync && SYNC_COUNTER == pSync->type) {
+        pCounter = (SyncCounter *) pSync;
+
+        if (IsSystemCounter(pCounter)) {
+            (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+                                                      &pCounter->value);
+        }
+    }
+
+    if (changes & XSyncCAValueType) {
+        if (pTrigger->value_type != XSyncRelative &&
+            pTrigger->value_type != XSyncAbsolute) {
+            client->errorValue = pTrigger->value_type;
+            return BadValue;
+        }
+    }
+
+    if (changes & XSyncCATestType) {
+
+        if (pSync && SYNC_FENCE == pSync->type) {
+            pTrigger->CheckTrigger = SyncCheckTriggerFence;
+        }
+        else {
+            /* select appropriate CheckTrigger function */
+
+            switch (pTrigger->test_type) {
+            case XSyncPositiveTransition:
+                pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
+                break;
+            case XSyncNegativeTransition:
+                pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
+                break;
+            case XSyncPositiveComparison:
+                pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
+                break;
+            case XSyncNegativeComparison:
+                pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
+                break;
+            default:
+                client->errorValue = pTrigger->test_type;
+                return BadValue;
+            }
+        }
+    }
+
+    if (changes & (XSyncCAValueType | XSyncCAValue)) {
+        if (pTrigger->value_type == XSyncAbsolute)
+            pTrigger->test_value = pTrigger->wait_value;
+        else {                  /* relative */
+
+            Bool overflow;
+
+            if (pCounter == NULL)
+                return BadMatch;
+
+            XSyncValueAdd(&pTrigger->test_value, pCounter->value,
+                          pTrigger->wait_value, &overflow);
+            if (overflow) {
+                client->errorValue = XSyncValueHigh32(pTrigger->wait_value);
+                return BadValue;
+            }
+        }
     }
 
     /*  we wait until we're sure there are no errors before registering
      *  a new counter on a trigger
      */
-    if (newSyncObject)
-    {
-	if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)
-	    return rc;
+    if (newSyncObject) {
+        if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)
+            return rc;
     }
-    else if (pCounter && IsSystemCounter(pCounter))
-    {
-	SyncComputeBracketValues(pCounter);
+    else if (pCounter && IsSystemCounter(pCounter)) {
+        SyncComputeBracketValues(pCounter);
     }
 
     return Success;
@@ -432,7 +415,7 @@ SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,
  *  clients.  The alarm maintains a list of clients interested in events.
  */
 static void
-SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
+SyncSendAlarmNotifyEvents(SyncAlarm * pAlarm)
 {
     SyncAlarmClientList *pcl;
     xSyncAlarmNotifyEvent ane;
@@ -440,23 +423,21 @@ SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
     SyncCounter *pCounter;
 
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
-	return;
+        return;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     UpdateCurrentTime();
 
     ane.type = SyncEventBase + XSyncAlarmNotify;
     ane.kind = XSyncAlarmNotify;
     ane.alarm = pAlarm->alarm_id;
-    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
-	ane.counter_value_lo = XSyncValueLow32(pCounter->value);
+    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type) {
+        ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
+        ane.counter_value_lo = XSyncValueLow32(pCounter->value);
     }
-    else
-    { /* XXX what else can we do if there's no counter? */
-	ane.counter_value_hi = ane.counter_value_lo = 0;
+    else {                      /* XXX what else can we do if there's no counter? */
+        ane.counter_value_hi = ane.counter_value_lo = 0;
     }
 
     ane.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value);
@@ -466,149 +447,141 @@ SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
 
     /* send to owner */
     if (pAlarm->events)
-	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
+        WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
 
     /* send to other interested clients */
     for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)
-	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
+        WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
 }
 
-
 /*  CounterNotify events only occur in response to an Await.  The events
  *  go only to the Awaiting client.
  */
 static void
-SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,
-			    int num_events)
+SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait ** ppAwait,
+                            int num_events)
 {
     xSyncCounterNotifyEvent *pEvents, *pev;
     int i;
 
     if (client->clientGone)
-	return;
+        return;
     pev = pEvents = malloc(num_events * sizeof(xSyncCounterNotifyEvent));
     if (!pEvents)
-	return;
+        return;
     UpdateCurrentTime();
-    for (i = 0; i < num_events; i++, ppAwait++, pev++)
-    {
-	SyncTrigger *pTrigger = &(*ppAwait)->trigger;
-	pev->type = SyncEventBase + XSyncCounterNotify;
-	pev->kind = XSyncCounterNotify;
-	pev->counter = pTrigger->pSync->id;
-	pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
-	pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
-	if (SYNC_COUNTER == pTrigger->pSync->type)
-	{
-	    SyncCounter *pCounter = (SyncCounter *)pTrigger->pSync;
-
-	    pev->counter_value_lo = XSyncValueLow32(pCounter->value);
-	    pev->counter_value_hi = XSyncValueHigh32(pCounter->value);
-	}
-	else
-	{
-	    pev->counter_value_lo = 0;
-	    pev->counter_value_hi = 0;
-	}
-
-	pev->time = currentTime.milliseconds;
-	pev->count = num_events - i - 1; /* events remaining */
-	pev->destroyed = pTrigger->pSync->beingDestroyed;
+    for (i = 0; i < num_events; i++, ppAwait++, pev++) {
+        SyncTrigger *pTrigger = &(*ppAwait)->trigger;
+
+        pev->type = SyncEventBase + XSyncCounterNotify;
+        pev->kind = XSyncCounterNotify;
+        pev->counter = pTrigger->pSync->id;
+        pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
+        pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
+        if (SYNC_COUNTER == pTrigger->pSync->type) {
+            SyncCounter *pCounter = (SyncCounter *) pTrigger->pSync;
+
+            pev->counter_value_lo = XSyncValueLow32(pCounter->value);
+            pev->counter_value_hi = XSyncValueHigh32(pCounter->value);
+        }
+        else {
+            pev->counter_value_lo = 0;
+            pev->counter_value_hi = 0;
+        }
+
+        pev->time = currentTime.milliseconds;
+        pev->count = num_events - i - 1;        /* events remaining */
+        pev->destroyed = pTrigger->pSync->beingDestroyed;
     }
     /* swapping will be taken care of by this */
-    WriteEventsToClient(client, num_events, (xEvent *)pEvents);
+    WriteEventsToClient(client, num_events, (xEvent *) pEvents);
     free(pEvents);
 }
 
-
 /* This function is called when an alarm's counter is destroyed.
  * It is plugged into pTrigger->CounterDestroyed (for alarm triggers).
  */
 static void
-SyncAlarmCounterDestroyed(SyncTrigger *pTrigger)
+SyncAlarmCounterDestroyed(SyncTrigger * pTrigger)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+    SyncAlarm *pAlarm = (SyncAlarm *) pTrigger;
 
     pAlarm->state = XSyncAlarmInactive;
     SyncSendAlarmNotifyEvents(pAlarm);
     pTrigger->pSync = NULL;
 }
 
-
 /*  This function is called when an alarm "goes off."
  *  It is plugged into pTrigger->TriggerFired (for alarm triggers).
  */
 static void
-SyncAlarmTriggerFired(SyncTrigger *pTrigger)
+SyncAlarmTriggerFired(SyncTrigger * pTrigger)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+    SyncAlarm *pAlarm = (SyncAlarm *) pTrigger;
     SyncCounter *pCounter;
     CARD64 new_test_value;
 
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
-	return;
+        return;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     /* no need to check alarm unless it's active */
     if (pAlarm->state != XSyncAlarmActive)
-	return;
+        return;
 
     /*  " if the counter value is None, or if the delta is 0 and
      *    the test-type is PositiveComparison or NegativeComparison,
      *    no change is made to value (test-value) and the alarm
      *    state is changed to Inactive before the event is generated."
      */
-    if (pCounter == NULL
-	|| (XSyncValueIsZero(pAlarm->delta)
-	    && (pAlarm->trigger.test_type == XSyncPositiveComparison
-		|| pAlarm->trigger.test_type == XSyncNegativeComparison)))
-	pAlarm->state = XSyncAlarmInactive;
+    if (pCounter == NULL || (XSyncValueIsZero(pAlarm->delta)
+                             && (pAlarm->trigger.test_type ==
+                                 XSyncPositiveComparison ||
+                                 pAlarm->trigger.test_type ==
+                                 XSyncNegativeComparison)))
+        pAlarm->state = XSyncAlarmInactive;
 
     new_test_value = pAlarm->trigger.test_value;
 
-    if (pAlarm->state == XSyncAlarmActive)
-    {
-	Bool overflow;
-	CARD64 oldvalue;
-	SyncTrigger *paTrigger = &pAlarm->trigger;
-	SyncCounter *paCounter;
-
-	if (!SyncCheckWarnIsCounter(paTrigger->pSync,
-				    WARN_INVALID_COUNTER_ALARM))
-	    return;
-
-	paCounter = (SyncCounter *)pTrigger->pSync;
-
-	/* "The alarm is updated by repeatedly adding delta to the
-	 *  value of the trigger and re-initializing it until it
-	 *  becomes FALSE."
-	 */
-	oldvalue = paTrigger->test_value;
-
-	/* XXX really should do something smarter here */
-
-	do
-	{
-	    XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
-			  pAlarm->delta, &overflow);
-	} while (!overflow &&
-	      (*paTrigger->CheckTrigger)(paTrigger,
-					paCounter->value));
-
-	new_test_value = paTrigger->test_value;
-	paTrigger->test_value = oldvalue;
-
-	/* "If this update would cause value to fall outside the range
-	 *  for an INT64...no change is made to value (test-value) and
-	 *  the alarm state is changed to Inactive before the event is
-	 *  generated."
-	 */
-	if (overflow)
-	{
-	    new_test_value = oldvalue;
-	    pAlarm->state = XSyncAlarmInactive;
-	}
+    if (pAlarm->state == XSyncAlarmActive) {
+        Bool overflow;
+        CARD64 oldvalue;
+        SyncTrigger *paTrigger = &pAlarm->trigger;
+        SyncCounter *paCounter;
+
+        if (!SyncCheckWarnIsCounter(paTrigger->pSync,
+                                    WARN_INVALID_COUNTER_ALARM))
+            return;
+
+        paCounter = (SyncCounter *) pTrigger->pSync;
+
+        /* "The alarm is updated by repeatedly adding delta to the
+         *  value of the trigger and re-initializing it until it
+         *  becomes FALSE."
+         */
+        oldvalue = paTrigger->test_value;
+
+        /* XXX really should do something smarter here */
+
+        do {
+            XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
+                          pAlarm->delta, &overflow);
+        } while (!overflow &&
+                 (*paTrigger->CheckTrigger) (paTrigger, paCounter->value));
+
+        new_test_value = paTrigger->test_value;
+        paTrigger->test_value = oldvalue;
+
+        /* "If this update would cause value to fall outside the range
+         *  for an INT64...no change is made to value (test-value) and
+         *  the alarm state is changed to Inactive before the event is
+         *  generated."
+         */
+        if (overflow) {
+            new_test_value = oldvalue;
+            pAlarm->state = XSyncAlarmInactive;
+        }
     }
     /*  The AlarmNotify event has to have the "new state of the alarm"
      *  which we can't be sure of until this point.  However, it has
@@ -620,28 +593,27 @@ SyncAlarmTriggerFired(SyncTrigger *pTrigger)
     pTrigger->test_value = new_test_value;
 }
 
-
 /*  This function is called when an Await unblocks, either as a result
  *  of the trigger firing OR the counter being destroyed.
  *  It goes into pTrigger->TriggerFired AND pTrigger->CounterDestroyed
  *  (for Await triggers).
  */
 static void
-SyncAwaitTriggerFired(SyncTrigger *pTrigger)
+SyncAwaitTriggerFired(SyncTrigger * pTrigger)
 {
-    SyncAwait *pAwait = (SyncAwait *)pTrigger;
+    SyncAwait *pAwait = (SyncAwait *) pTrigger;
     int numwaits;
     SyncAwaitUnion *pAwaitUnion;
     SyncAwait **ppAwait;
     int num_events = 0;
 
-    pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
+    pAwaitUnion = (SyncAwaitUnion *) pAwait->pHeader;
     numwaits = pAwaitUnion->header.num_waitconditions;
     ppAwait = malloc(numwaits * sizeof(SyncAwait *));
     if (!ppAwait)
-	goto bail;
+        goto bail;
 
-    pAwait = &(pAwaitUnion+1)->await;
+    pAwait = &(pAwaitUnion + 1)->await;
 
     /* "When a client is unblocked, all the CounterNotify events for
      *  the Await request are generated contiguously. If count is 0
@@ -652,132 +624,119 @@ SyncAwaitTriggerFired(SyncTrigger *pTrigger)
      *  need to be sent first, so that an accurate count field can
      *  be stored in the events.
      */
-    for ( ; numwaits; numwaits--, pAwait++)
-    {
-	CARD64 diff;
-	Bool overflow, diffgreater, diffequal;
-
-	/* "A CounterNotify event with the destroyed flag set to TRUE is
-	 *  always generated if the counter for one of the triggers is
-	 *  destroyed."
-	 */
-	if (pAwait->trigger.pSync->beingDestroyed)
-	{
-	    ppAwait[num_events++] = pAwait;
-	    continue;
-	}
-	
-	if (SYNC_COUNTER == pAwait->trigger.pSync->type)
-	{
-	    SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;
-
-	    /* "The difference between the counter and the test value is
-	     *  calculated by subtracting the test value from the value of
-	     *  the counter."
-	     */
-	    XSyncValueSubtract(&diff, pCounter->value,
-			       pAwait->trigger.test_value, &overflow);
-
-	    /* "If the difference lies outside the range for an INT64, an
-	     *  event is not generated."
-	     */
-	    if (overflow)
-		continue;
-	    diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);
-	    diffequal   = XSyncValueEqual(diff, pAwait->event_threshold);
-
-	    /* "If the test-type is PositiveTransition or
-	     *  PositiveComparison, a CounterNotify event is generated if
-	     *  the difference is at least event-threshold. If the test-type
-	     *  is NegativeTransition or NegativeComparison, a CounterNotify
-	     *  event is generated if the difference is at most
-	     *  event-threshold."
-	     */
-
-	    if ( ((pAwait->trigger.test_type == XSyncPositiveComparison ||
-		   pAwait->trigger.test_type == XSyncPositiveTransition)
-		  && (diffgreater || diffequal))
-		 ||
-		 ((pAwait->trigger.test_type == XSyncNegativeComparison ||
-		   pAwait->trigger.test_type == XSyncNegativeTransition)
-		  && (!diffgreater) /* less or equal */
-		 )
-	       )
-	    {
-		ppAwait[num_events++] = pAwait;
-	    }
-	}
+    for (; numwaits; numwaits--, pAwait++) {
+        CARD64 diff;
+        Bool overflow, diffgreater, diffequal;
+
+        /* "A CounterNotify event with the destroyed flag set to TRUE is
+         *  always generated if the counter for one of the triggers is
+         *  destroyed."
+         */
+        if (pAwait->trigger.pSync->beingDestroyed) {
+            ppAwait[num_events++] = pAwait;
+            continue;
+        }
+
+        if (SYNC_COUNTER == pAwait->trigger.pSync->type) {
+            SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;
+
+            /* "The difference between the counter and the test value is
+             *  calculated by subtracting the test value from the value of
+             *  the counter."
+             */
+            XSyncValueSubtract(&diff, pCounter->value,
+                               pAwait->trigger.test_value, &overflow);
+
+            /* "If the difference lies outside the range for an INT64, an
+             *  event is not generated."
+             */
+            if (overflow)
+                continue;
+            diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);
+            diffequal = XSyncValueEqual(diff, pAwait->event_threshold);
+
+            /* "If the test-type is PositiveTransition or
+             *  PositiveComparison, a CounterNotify event is generated if
+             *  the difference is at least event-threshold. If the test-type
+             *  is NegativeTransition or NegativeComparison, a CounterNotify
+             *  event is generated if the difference is at most
+             *  event-threshold."
+             */
+
+            if (((pAwait->trigger.test_type == XSyncPositiveComparison ||
+                  pAwait->trigger.test_type == XSyncPositiveTransition)
+                 && (diffgreater || diffequal))
+                ||
+                ((pAwait->trigger.test_type == XSyncNegativeComparison ||
+                  pAwait->trigger.test_type == XSyncNegativeTransition)
+                 && (!diffgreater)      /* less or equal */
+                )
+                ) {
+                ppAwait[num_events++] = pAwait;
+            }
+        }
     }
     if (num_events)
-	SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
-				    num_events);
+        SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
+                                    num_events);
     free(ppAwait);
 
-bail:
+ bail:
     /* unblock the client */
     AttendClient(pAwaitUnion->header.client);
     /* delete the await */
     FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
 }
 
-
 /*  This function should always be used to change a counter's value so that
  *  any triggers depending on the counter will be checked.
  */
 void
-SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)
+SyncChangeCounter(SyncCounter * pCounter, CARD64 newval)
 {
-    SyncTriggerList       *ptl, *pnext;
+    SyncTriggerList *ptl, *pnext;
     CARD64 oldval;
 
     oldval = pCounter->value;
     pCounter->value = newval;
 
     /* run through triggers to see if any become true */
-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
-    {
-	pnext = ptl->next;
-	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))
-	    (*ptl->pTrigger->TriggerFired)(ptl->pTrigger);
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext) {
+        pnext = ptl->next;
+        if ((*ptl->pTrigger->CheckTrigger) (ptl->pTrigger, oldval))
+            (*ptl->pTrigger->TriggerFired) (ptl->pTrigger);
     }
 
-    if (IsSystemCounter(pCounter))
-    {
-	SyncComputeBracketValues(pCounter);
+    if (IsSystemCounter(pCounter)) {
+        SyncComputeBracketValues(pCounter);
     }
 }
 
-
 /* loosely based on dix/events.c/EventSelectForWindow */
 static Bool
-SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
+SyncEventSelectForAlarm(SyncAlarm * pAlarm, ClientPtr client, Bool wantevents)
 {
     SyncAlarmClientList *pClients;
 
-    if (client == pAlarm->client) /* alarm owner */
-    {
-	pAlarm->events = wantevents;
-	return Success;
+    if (client == pAlarm->client) {     /* alarm owner */
+        pAlarm->events = wantevents;
+        return Success;
     }
 
     /* see if the client is already on the list (has events selected) */
 
-    for (pClients = pAlarm->pEventClients; pClients;
-	 pClients = pClients->next)
-    {
-	if (pClients->client == client)
-	{
-	    /* client's presence on the list indicates desire for
-	     * events.  If the client doesn't want events, remove it
-	     * from the list.  If the client does want events, do
-	     * nothing, since it's already got them.
-	     */
-	    if (!wantevents)
-	    {
-		FreeResource(pClients->delete_id, RT_NONE);
-	    }
-	    return Success;
-	}
+    for (pClients = pAlarm->pEventClients; pClients; pClients = pClients->next) {
+        if (pClients->client == client) {
+            /* client's presence on the list indicates desire for
+             * events.  If the client doesn't want events, remove it
+             * from the list.  If the client does want events, do
+             * nothing, since it's already got them.
+             */
+            if (!wantevents) {
+                FreeResource(pClients->delete_id, RT_NONE);
+            }
+            return Success;
+        }
     }
 
     /*  if we get here, this client does not currently have
@@ -785,16 +744,16 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
      */
 
     if (!wantevents)
-	/* client doesn't want events, and we just discovered that it
-	 * doesn't have them, so there's nothing to do.
-	 */
-	return Success;
+        /* client doesn't want events, and we just discovered that it
+         * doesn't have them, so there's nothing to do.
+         */
+        return Success;
 
     /* add new client to pAlarm->pEventClients */
 
     pClients = malloc(sizeof(SyncAlarmClientList));
     if (!pClients)
-	return BadAlloc;
+        return BadAlloc;
 
     /*  register it as a resource so it will be cleaned up
      *  if the client dies
@@ -808,7 +767,7 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
     pClients->client = client;
 
     if (!AddResource(pClients->delete_id, RTAlarmClient, pAlarm))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
@@ -817,69 +776,66 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
  * ** SyncChangeAlarmAttributes ** This is used by CreateAlarm and ChangeAlarm
  */
 static int
-SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
-			  CARD32 *values)
-{
-    int		   status;
-    XSyncCounter   counter;
-    Mask	   origmask = mask;
-
-    counter =
-	pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;
-
-    while (mask)
-    {
-	int    index2 = lowbit(mask);
-	mask &= ~index2;
-	switch (index2)
-	{
-	  case XSyncCACounter:
-	    mask &= ~XSyncCACounter;
-	    /* sanity check in SyncInitTrigger */
-	    counter = *values++;
-	    break;
-
-	  case XSyncCAValueType:
-	    mask &= ~XSyncCAValueType;
-	    /* sanity check in SyncInitTrigger */
-	    pAlarm->trigger.value_type = *values++;
-	    break;
-
-	  case XSyncCAValue:
-	    mask &= ~XSyncCAValue;
-	    XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);
-	    values += 2;
-	    break;
-
-	  case XSyncCATestType:
-	    mask &= ~XSyncCATestType;
-	    /* sanity check in SyncInitTrigger */
-	    pAlarm->trigger.test_type = *values++;
-	    break;
-
-	  case XSyncCADelta:
-	    mask &= ~XSyncCADelta;
-	    XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);
-	    values += 2;
-	    break;
-
-	  case XSyncCAEvents:
-	    mask &= ~XSyncCAEvents;
-	    if ((*values != xTrue) && (*values != xFalse))
-	    {
-		client->errorValue = *values;
-		return BadValue;
-	    }
-	    status = SyncEventSelectForAlarm(pAlarm, client,
-					     (Bool)(*values++));
-	    if (status != Success)
-		return status;
-	    break;
-
-	  default:
-	    client->errorValue = mask;
-	    return BadValue;
-	}
+SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm * pAlarm, Mask mask,
+                          CARD32 *values)
+{
+    int status;
+    XSyncCounter counter;
+    Mask origmask = mask;
+
+    counter = pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;
+
+    while (mask) {
+        int index2 = lowbit(mask);
+
+        mask &= ~index2;
+        switch (index2) {
+        case XSyncCACounter:
+            mask &= ~XSyncCACounter;
+            /* sanity check in SyncInitTrigger */
+            counter = *values++;
+            break;
+
+        case XSyncCAValueType:
+            mask &= ~XSyncCAValueType;
+            /* sanity check in SyncInitTrigger */
+            pAlarm->trigger.value_type = *values++;
+            break;
+
+        case XSyncCAValue:
+            mask &= ~XSyncCAValue;
+            XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);
+            values += 2;
+            break;
+
+        case XSyncCATestType:
+            mask &= ~XSyncCATestType;
+            /* sanity check in SyncInitTrigger */
+            pAlarm->trigger.test_type = *values++;
+            break;
+
+        case XSyncCADelta:
+            mask &= ~XSyncCADelta;
+            XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);
+            values += 2;
+            break;
+
+        case XSyncCAEvents:
+            mask &= ~XSyncCAEvents;
+            if ((*values != xTrue) && (*values != xFalse)) {
+                client->errorValue = *values;
+                return BadValue;
+            }
+            status = SyncEventSelectForAlarm(pAlarm, client,
+                                             (Bool) (*values++));
+            if (status != Success)
+                return status;
+            break;
+
+        default:
+            client->errorValue = mask;
+            return BadValue;
+        }
     }
 
     /* "If the test-type is PositiveComparison or PositiveTransition
@@ -887,27 +843,26 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
      *  NegativeComparison or NegativeTransition and delta is
      *  greater than zero, a Match error is generated."
      */
-    if (origmask & (XSyncCADelta|XSyncCATestType))
-    {
-	CARD64 zero;
-	XSyncIntToValue(&zero, 0);
-	if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
-	      (pAlarm->trigger.test_type == XSyncPositiveTransition))
-	     && XSyncValueLessThan(pAlarm->delta, zero))
-	    ||
-	    (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
-	      (pAlarm->trigger.test_type == XSyncNegativeTransition))
-	     && XSyncValueGreaterThan(pAlarm->delta, zero))
-	   )
-	{
-	    return BadMatch;
-	}
+    if (origmask & (XSyncCADelta | XSyncCATestType)) {
+        CARD64 zero;
+
+        XSyncIntToValue(&zero, 0);
+        if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
+              (pAlarm->trigger.test_type == XSyncPositiveTransition))
+             && XSyncValueLessThan(pAlarm->delta, zero))
+            ||
+            (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
+              (pAlarm->trigger.test_type == XSyncNegativeTransition))
+             && XSyncValueGreaterThan(pAlarm->delta, zero))
+            ) {
+            return BadMatch;
+        }
     }
 
     /* postpone this until now, when we're sure nothing else can go wrong */
     if ((status = SyncInitTrigger(client, &pAlarm->trigger, counter, RTCounter,
-			     origmask & XSyncCAAllTrigger)) != Success)
-	return status;
+                                  origmask & XSyncCAAllTrigger)) != Success)
+        return status;
 
     /* XXX spec does not really say to do this - needs clarification */
     pAlarm->state = XSyncAlarmActive;
@@ -921,18 +876,18 @@ SyncCreate(ClientPtr client, XID id, unsigned char type)
 
     switch (type) {
     case SYNC_COUNTER:
-	pSync = malloc(sizeof(SyncCounter));
-	break;
+        pSync = malloc(sizeof(SyncCounter));
+        break;
     case SYNC_FENCE:
-	pSync = (SyncObject*)dixAllocateObjectWithPrivates(SyncFence,
-							   PRIVATE_SYNC_FENCE);
-	break;
+        pSync = (SyncObject *) dixAllocateObjectWithPrivates(SyncFence,
+                                                             PRIVATE_SYNC_FENCE);
+        break;
     default:
-	return NULL;
+        return NULL;
     }
 
     if (!pSync)
-	return NULL;
+        return NULL;
 
     pSync->client = client;
     pSync->id = id;
@@ -943,22 +898,19 @@ SyncCreate(ClientPtr client, XID id, unsigned char type)
     return pSync;
 }
 
-
 static SyncCounter *
 SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)
 {
     SyncCounter *pCounter;
 
-    if (!(pCounter = (SyncCounter *)SyncCreate(client,
-					       id,
-					       SYNC_COUNTER)))
-	return NULL;
+    if (!(pCounter = (SyncCounter *) SyncCreate(client, id, SYNC_COUNTER)))
+        return NULL;
 
     pCounter->value = initialvalue;
     pCounter->pSysCounterInfo = NULL;
 
     if (!AddResource(id, RTCounter, (pointer) pCounter))
-	return NULL;
+        return NULL;
 
     return pCounter;
 }
@@ -970,58 +922,54 @@ static int FreeCounter(void *, XID);
  */
 
 pointer
-SyncCreateSystemCounter(
-	const char *name,
-	CARD64 initial,
-	CARD64 resolution,
-	SyncCounterType counterType,
-	void (*QueryValue)(pointer /* pCounter */,
-	      	           CARD64 * /* pValue_return */),
-	void (*BracketValues)(pointer /* pCounter */,
-	       	              CARD64 * /* pbracket_less */,
-	                      CARD64 * /* pbracket_greater */)
-	)
-{
-    SyncCounter    *pCounter;
+SyncCreateSystemCounter(const char *name,
+                        CARD64 initial,
+                        CARD64 resolution,
+                        SyncCounterType counterType,
+                        void (*QueryValue) (pointer /* pCounter */ ,
+                                            CARD64 * /* pValue_return */ ),
+                        void (*BracketValues) (pointer /* pCounter */ ,
+                                               CARD64 * /* pbracket_less */ ,
+                                               CARD64 * /* pbracket_greater */ )
+    )
+{
+    SyncCounter *pCounter;
 
     SysCounterList = realloc(SysCounterList,
-			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));
+                             (SyncNumSystemCounters +
+                              1) * sizeof(SyncCounter *));
     if (!SysCounterList)
-	return NULL;
+        return NULL;
 
     /* this function may be called before SYNC has been initialized, so we
      * have to make sure RTCounter is created.
      */
-    if (RTCounter == 0)
-    {
-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
-	if (RTCounter == 0)
-	{
-	    return NULL;
-	}
+    if (RTCounter == 0) {
+        RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+        if (RTCounter == 0) {
+            return NULL;
+        }
     }
 
     pCounter = SyncCreateCounter(NULL, FakeClientID(0), initial);
 
-    if (pCounter)
-    {
-	SysCounterInfo *psci;
-
-	psci = malloc(sizeof(SysCounterInfo));
-	if (!psci)
-	{
-	    FreeResource(pCounter->sync.id, RT_NONE);
-	    return pCounter;
-	}
-	pCounter->pSysCounterInfo = psci;
-	psci->name = name;
-	psci->resolution = resolution;
-	psci->counterType = counterType;
-	psci->QueryValue = QueryValue;
-	psci->BracketValues = BracketValues;
-	XSyncMaxValue(&psci->bracket_greater);
-	XSyncMinValue(&psci->bracket_less);
-	SysCounterList[SyncNumSystemCounters++] = pCounter;
+    if (pCounter) {
+        SysCounterInfo *psci;
+
+        psci = malloc(sizeof(SysCounterInfo));
+        if (!psci) {
+            FreeResource(pCounter->sync.id, RT_NONE);
+            return pCounter;
+        }
+        pCounter->pSysCounterInfo = psci;
+        psci->name = name;
+        psci->resolution = resolution;
+        psci->counterType = counterType;
+        psci->QueryValue = QueryValue;
+        psci->BracketValues = BracketValues;
+        XSyncMaxValue(&psci->bracket_greater);
+        XSyncMinValue(&psci->bracket_less);
+        SysCounterList[SyncNumSystemCounters++] = pCounter;
     }
     return pCounter;
 }
@@ -1029,12 +977,13 @@ SyncCreateSystemCounter(
 void
 SyncDestroySystemCounter(pointer pSysCounter)
 {
-    SyncCounter *pCounter = (SyncCounter *)pSysCounter;
+    SyncCounter *pCounter = (SyncCounter *) pSysCounter;
+
     FreeResource(pCounter->sync.id, RT_NONE);
 }
 
 static void
-SyncComputeBracketValues(SyncCounter *pCounter)
+SyncComputeBracketValues(SyncCounter * pCounter)
 {
     SyncTriggerList *pCur;
     SyncTrigger *pTrigger;
@@ -1044,89 +993,81 @@ SyncComputeBracketValues(SyncCounter *pCounter)
     SyncCounterType ct;
 
     if (!pCounter)
-	return;
+        return;
 
     psci = pCounter->pSysCounterInfo;
     ct = pCounter->pSysCounterInfo->counterType;
     if (ct == XSyncCounterNeverChanges)
-	return;
+        return;
 
     XSyncMaxValue(&psci->bracket_greater);
     XSyncMinValue(&psci->bracket_less);
 
-    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next)
-    {
-	pTrigger = pCur->pTrigger;
-	
+    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next) {
+        pTrigger = pCur->pTrigger;
+
         if (pTrigger->test_type == XSyncPositiveComparison &&
-	    ct != XSyncCounterNeverIncreases)
-	{
-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueLessThan(pTrigger->test_value,
-				   psci->bracket_greater))
-	    {
-		psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    }
-	}
-	else if (pTrigger->test_type == XSyncNegativeComparison &&
-		 ct != XSyncCounterNeverDecreases)
-	{
-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueGreaterThan(pTrigger->test_value,
-				      psci->bracket_less))
-	    {
-		psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    }
-	}
-	else if (pTrigger->test_type == XSyncNegativeTransition &&
-		   ct != XSyncCounterNeverIncreases)
-	{
-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))
-	    {
-		psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
-		       XSyncValueLessThan(pTrigger->test_value,
-					  psci->bracket_greater))
-	    {
-	        /*
-		 * The value is exactly equal to our threshold.  We want one
-		 * more event in the positive direction to ensure we pick up
-		 * when the value *exceeds* this threshold.
-		 */
-	        psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    }
-	}
+            ct != XSyncCounterNeverIncreases) {
+            if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueLessThan(pTrigger->test_value,
+                                   psci->bracket_greater)) {
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+        }
+        else if (pTrigger->test_type == XSyncNegativeComparison &&
+                 ct != XSyncCounterNeverDecreases) {
+            if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueGreaterThan(pTrigger->test_value,
+                                      psci->bracket_less)) {
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+        }
+        else if (pTrigger->test_type == XSyncNegativeTransition &&
+                 ct != XSyncCounterNeverIncreases) {
+            if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))
+            {
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+            else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+                     XSyncValueLessThan(pTrigger->test_value,
+                                        psci->bracket_greater)) {
+                /*
+                 * The value is exactly equal to our threshold.  We want one
+                 * more event in the positive direction to ensure we pick up
+                 * when the value *exceeds* this threshold.
+                 */
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+        }
         else if (pTrigger->test_type == XSyncPositiveTransition &&
-		  ct != XSyncCounterNeverDecreases)
-	{
-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))
-	    {
-		psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
-		       XSyncValueGreaterThan(pTrigger->test_value,
-					     psci->bracket_less))
-	    {
-	        /*
-		 * The value is exactly equal to our threshold.  We want one
-		 * more event in the negative direction to ensure we pick up
-		 * when the value is less than this threshold.
-		 */
-	        psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    }
-	}
-    } /* end for each trigger */
-
-    if (pnewgtval || pnewltval)
-    {
-	(*psci->BracketValues)((pointer)pCounter, pnewltval, pnewgtval);
+                 ct != XSyncCounterNeverDecreases) {
+            if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))
+            {
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+            else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+                     XSyncValueGreaterThan(pTrigger->test_value,
+                                           psci->bracket_less)) {
+                /*
+                 * The value is exactly equal to our threshold.  We want one
+                 * more event in the negative direction to ensure we pick up
+                 * when the value is less than this threshold.
+                 */
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+        }
+    }                           /* end for each trigger */
+
+    if (pnewgtval || pnewltval) {
+        (*psci->BracketValues) ((pointer) pCounter, pnewltval, pnewgtval);
     }
 }
 
@@ -1138,7 +1079,7 @@ SyncComputeBracketValues(SyncCounter *pCounter)
 static int
 FreeAlarm(void *addr, XID id)
 {
-    SyncAlarm      *pAlarm = (SyncAlarm *) addr;
+    SyncAlarm *pAlarm = (SyncAlarm *) addr;
 
     pAlarm->state = XSyncAlarmDestroyed;
 
@@ -1147,7 +1088,7 @@ FreeAlarm(void *addr, XID id)
     /* delete event selections */
 
     while (pAlarm->pEventClients)
-	FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);
+        FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);
 
     SyncDeleteTriggerFromSyncObject(&pAlarm->trigger);
 
@@ -1155,7 +1096,6 @@ FreeAlarm(void *addr, XID id)
     return Success;
 }
 
-
 /*
  * ** Cleanup after the destruction of a Counter
  */
@@ -1163,44 +1103,37 @@ FreeAlarm(void *addr, XID id)
 static int
 FreeCounter(void *env, XID id)
 {
-    SyncCounter     *pCounter = (SyncCounter *) env;
+    SyncCounter *pCounter = (SyncCounter *) env;
     SyncTriggerList *ptl, *pnext;
 
     pCounter->sync.beingDestroyed = TRUE;
     /* tell all the counter's triggers that the counter has been destroyed */
-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
-    {
-	(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);
-	pnext = ptl->next;
-	free(ptl); /* destroy the trigger list as we go */
-    }
-    if (IsSystemCounter(pCounter))
-    {
-	int i, found = 0;
-
-	free(pCounter->pSysCounterInfo);
-
-	/* find the counter in the list of system counters and remove it */
-
-	if (SysCounterList)
-	{
-	    for (i = 0; i < SyncNumSystemCounters; i++)
-	    {
-		if (SysCounterList[i] == pCounter)
-		{
-		    found = i;
-		    break;
-		}
-	    }
-	    if (found < (SyncNumSystemCounters-1))
-	    {
-		for (i = found; i < SyncNumSystemCounters-1; i++)
-		{
-		    SysCounterList[i] = SysCounterList[i+1];
-		}
-	    }
-	}
-	SyncNumSystemCounters--;
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext) {
+        (*ptl->pTrigger->CounterDestroyed) (ptl->pTrigger);
+        pnext = ptl->next;
+        free(ptl);              /* destroy the trigger list as we go */
+    }
+    if (IsSystemCounter(pCounter)) {
+        int i, found = 0;
+
+        free(pCounter->pSysCounterInfo);
+
+        /* find the counter in the list of system counters and remove it */
+
+        if (SysCounterList) {
+            for (i = 0; i < SyncNumSystemCounters; i++) {
+                if (SysCounterList[i] == pCounter) {
+                    found = i;
+                    break;
+                }
+            }
+            if (found < (SyncNumSystemCounters - 1)) {
+                for (i = found; i < SyncNumSystemCounters - 1; i++) {
+                    SysCounterList[i] = SysCounterList[i + 1];
+                }
+            }
+        }
+        SyncNumSystemCounters--;
     }
     free(pCounter);
     return Success;
@@ -1217,19 +1150,19 @@ FreeAwait(void *addr, XID id)
     SyncAwait *pAwait;
     int numwaits;
 
-    pAwait = &(pAwaitUnion+1)->await; /* first await on list */
+    pAwait = &(pAwaitUnion + 1)->await; /* first await on list */
 
     /* remove triggers from counters */
 
     for (numwaits = pAwaitUnion->header.num_waitconditions; numwaits;
-	 numwaits--, pAwait++)
-    {
-	/* If the counter is being destroyed, FreeCounter will delete
-	 * the trigger list itself, so don't do it here.
-	 */
-	SyncObject *pSync = pAwait->trigger.pSync;
-	if (pSync && !pSync->beingDestroyed)
-	    SyncDeleteTriggerFromSyncObject(&pAwait->trigger);
+         numwaits--, pAwait++) {
+        /* If the counter is being destroyed, FreeCounter will delete
+         * the trigger list itself, so don't do it here.
+         */
+        SyncObject *pSync = pAwait->trigger.pSync;
+
+        if (pSync && !pSync->beingDestroyed)
+            SyncDeleteTriggerFromSyncObject(&pAwait->trigger);
     }
     free(pAwaitUnion);
     return Success;
@@ -1239,40 +1172,35 @@ FreeAwait(void *addr, XID id)
 static int
 FreeAlarmClient(void *value, XID id)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)value;
+    SyncAlarm *pAlarm = (SyncAlarm *) value;
     SyncAlarmClientList *pCur, *pPrev;
 
     for (pPrev = NULL, pCur = pAlarm->pEventClients;
-	 pCur;
-	 pPrev = pCur, pCur = pCur->next)
-    {
-	if (pCur->delete_id == id)
-	{
-	    if (pPrev)
-		pPrev->next = pCur->next;
-	    else
-		pAlarm->pEventClients = pCur->next;
-	    free(pCur);
-	    return Success;
-	}
+         pCur; pPrev = pCur, pCur = pCur->next) {
+        if (pCur->delete_id == id) {
+            if (pPrev)
+                pPrev->next = pCur->next;
+            else
+                pAlarm->pEventClients = pCur->next;
+            free(pCur);
+            return Success;
+        }
     }
     FatalError("alarm client not on event list");
-    /*NOTREACHED*/
-}
-
+ /*NOTREACHED*/}
 
 /*
  * *****  Proc functions
  */
 
-
 /*
  * ** Initialize the extension
  */
 static int
 ProcSyncInitialize(ClientPtr client)
 {
-    xSyncInitializeReply  rep;
+    xSyncInitializeReply rep;
+
     REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
     memset(&rep, 0, sizeof(xSyncInitializeReply));
@@ -1282,9 +1210,8 @@ ProcSyncInitialize(ClientPtr client)
     rep.minorVersion = SERVER_SYNC_MINOR_VERSION;
     rep.length = 0;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(rep), (char *) &rep);
     return Success;
@@ -1296,7 +1223,7 @@ ProcSyncInitialize(ClientPtr client)
 static int
 ProcSyncListSystemCounters(ClientPtr client)
 {
-    xSyncListSystemCountersReply  rep;
+    xSyncListSystemCountersReply rep;
     int i, len;
     xSyncSystemCounter *list = NULL, *walklist = NULL;
 
@@ -1306,60 +1233,56 @@ ProcSyncListSystemCounters(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.nCounters = SyncNumSystemCounters;
 
-    for (i = len = 0; i < SyncNumSystemCounters; i++)
-    {
-	const char *name = SysCounterList[i]->pSysCounterInfo->name;
-	/* pad to 4 byte boundary */
-	len += pad_to_int32(sz_xSyncSystemCounter + strlen(name));
+    for (i = len = 0; i < SyncNumSystemCounters; i++) {
+        const char *name = SysCounterList[i]->pSysCounterInfo->name;
+
+        /* pad to 4 byte boundary */
+        len += pad_to_int32(sz_xSyncSystemCounter + strlen(name));
     }
 
-    if (len)
-    {
-	walklist = list = malloc(len);
-	if (!list)
-	    return BadAlloc;
+    if (len) {
+        walklist = list = malloc(len);
+        if (!list)
+            return BadAlloc;
     }
 
     rep.length = bytes_to_int32(len);
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.nCounters);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.nCounters);
     }
 
-    for (i = 0; i < SyncNumSystemCounters; i++)
-    {
-	int namelen;
-	char *pname_in_reply;
-	SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;
+    for (i = 0; i < SyncNumSystemCounters; i++) {
+        int namelen;
+        char *pname_in_reply;
+        SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;
 
-	walklist->counter = SysCounterList[i]->sync.id;
-	walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
-	walklist->resolution_lo = XSyncValueLow32(psci->resolution);
-	namelen = strlen(psci->name);
-	walklist->name_length = namelen;
+        walklist->counter = SysCounterList[i]->sync.id;
+        walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
+        walklist->resolution_lo = XSyncValueLow32(psci->resolution);
+        namelen = strlen(psci->name);
+        walklist->name_length = namelen;
 
-	if (client->swapped)
-	{
-	    swapl(&walklist->counter);
-	    swapl(&walklist->resolution_hi);
-	    swapl(&walklist->resolution_lo);
-	    swaps(&walklist->name_length);
-	}
+        if (client->swapped) {
+            swapl(&walklist->counter);
+            swapl(&walklist->resolution_hi);
+            swapl(&walklist->resolution_lo);
+            swaps(&walklist->name_length);
+        }
 
-	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;
-	strncpy(pname_in_reply, psci->name, namelen);
-	walklist = (xSyncSystemCounter *) (((char *)walklist) +
-				pad_to_int32(sz_xSyncSystemCounter + namelen));
+        pname_in_reply = ((char *) walklist) + sz_xSyncSystemCounter;
+        strncpy(pname_in_reply, psci->name, namelen);
+        walklist = (xSyncSystemCounter *) (((char *) walklist) +
+                                           pad_to_int32(sz_xSyncSystemCounter +
+                                                        namelen));
     }
 
     WriteToClient(client, sizeof(rep), (char *) &rep);
-    if (len)
-    {
-	WriteToClient(client, len, (char *) list);
-	free(list);
+    if (len) {
+        WriteToClient(client, len, (char *) list);
+        free(list);
     }
 
     return Success;
@@ -1378,24 +1301,23 @@ ProcSyncSetPriority(ClientPtr client)
     REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
 
     if (stuff->id == None)
-	priorityclient = client;
+        priorityclient = client;
     else {
-	rc = dixLookupClient(&priorityclient, stuff->id, client,
-			     DixSetAttrAccess);
-	if (rc != Success)
-	    return rc;
+        rc = dixLookupClient(&priorityclient, stuff->id, client,
+                             DixSetAttrAccess);
+        if (rc != Success)
+            return rc;
     }
 
-    if (priorityclient->priority != stuff->priority)
-    {
-	priorityclient->priority = stuff->priority;
+    if (priorityclient->priority != stuff->priority) {
+        priorityclient->priority = stuff->priority;
 
-	/*  The following will force the server back into WaitForSomething
-	 *  so that the change in this client's priority is immediately
-	 *  reflected.
-	 */
-	isItTimeToYield = TRUE;
-	dispatchException |= DE_PRIORITYCHANGE;
+        /*  The following will force the server back into WaitForSomething
+         *  so that the change in this client's priority is immediately
+         *  reflected.
+         */
+        isItTimeToYield = TRUE;
+        dispatchException |= DE_PRIORITYCHANGE;
     }
     return Success;
 }
@@ -1414,12 +1336,12 @@ ProcSyncGetPriority(ClientPtr client)
     REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
 
     if (stuff->id == None)
-	priorityclient = client;
+        priorityclient = client;
     else {
-	rc = dixLookupClient(&priorityclient, stuff->id, client,
-			     DixGetAttrAccess);
-	if (rc != Success)
-	    return rc;
+        rc = dixLookupClient(&priorityclient, stuff->id, client,
+                             DixGetAttrAccess);
+        if (rc != Success)
+            return rc;
     }
 
     rep.type = X_Reply;
@@ -1427,10 +1349,9 @@ ProcSyncGetPriority(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.priority = priorityclient->priority;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.priority);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.priority);
     }
 
     WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
@@ -1445,15 +1366,16 @@ static int
 ProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
-    CARD64          initial;
+    CARD64 initial;
 
     REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
 
     LEGAL_NEW_RESOURCE(stuff->cid, client);
 
-    XSyncIntsToValue(&initial, stuff->initial_value_lo, stuff->initial_value_hi);
+    XSyncIntsToValue(&initial, stuff->initial_value_lo,
+                     stuff->initial_value_hi);
     if (!SyncCreateCounter(client, stuff->cid, initial))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
@@ -1465,21 +1387,20 @@ static int
 ProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
-    SyncCounter    *pCounter;
-    CARD64	   newvalue;
-    int	rc;
+    SyncCounter *pCounter;
+    CARD64 newvalue;
+    int rc;
 
     REQUEST_SIZE_MATCH(xSyncSetCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->cid, RTCounter,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->cid;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->cid;
+        return BadAccess;
     }
 
     XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
@@ -1494,31 +1415,29 @@ static int
 ProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
-    SyncCounter    *pCounter;
-    CARD64          newvalue;
-    Bool	    overflow;
-    int	rc;
+    SyncCounter *pCounter;
+    CARD64 newvalue;
+    Bool overflow;
+    int rc;
 
     REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->cid, RTCounter,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->cid;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->cid;
+        return BadAccess;
     }
 
     XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
     XSyncValueAdd(&newvalue, pCounter->value, newvalue, &overflow);
-    if (overflow)
-    {
-	/* XXX 64 bit value can't fit in 32 bits; do the best we can */
-	client->errorValue = stuff->value_hi;
-	return BadValue;
+    if (overflow) {
+        /* XXX 64 bit value can't fit in 32 bits; do the best we can */
+        client->errorValue = stuff->value_hi;
+        return BadValue;
     }
     SyncChangeCounter(pCounter, newvalue);
     return Success;
@@ -1531,26 +1450,25 @@ static int
 ProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
-    SyncCounter    *pCounter;
+    SyncCounter *pCounter;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter, RTCounter,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->counter,
+                                 RTCounter, client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->counter;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->counter;
+        return BadAccess;
     }
     FreeResource(pCounter->sync.id, RT_NONE);
     return Success;
 }
 
-static SyncAwaitUnion*
+static SyncAwaitUnion *
 SyncAwaitPrologue(ClientPtr client, int items)
 {
     SyncAwaitUnion *pAwaitUnion;
@@ -1558,9 +1476,9 @@ SyncAwaitPrologue(ClientPtr client, int items)
     /*  all the memory for the entire await list is allocated
      *  here in one chunk
      */
-    pAwaitUnion = malloc((items+1) * sizeof(SyncAwaitUnion));
+    pAwaitUnion = malloc((items + 1) * sizeof(SyncAwaitUnion));
     if (!pAwaitUnion)
-	return NULL;
+        return NULL;
 
     /* first item is the header, remainder are real wait conditions */
 
@@ -1569,13 +1487,13 @@ SyncAwaitPrologue(ClientPtr client, int items)
     pAwaitUnion->header.num_waitconditions = 0;
 
     if (!AddResource(pAwaitUnion->header.delete_id, RTAwait, pAwaitUnion))
-	return NULL;
+        return NULL;
 
     return pAwaitUnion;
 }
 
 static void
-SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)
+SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion * pAwaitUnion)
 {
     SyncAwait *pAwait;
     int i;
@@ -1584,27 +1502,25 @@ SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)
 
     /* see if any of the triggers are already true */
 
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pAwait++)
-    {
-	CARD64 value;
-
-	/*  don't have to worry about NULL counters because the request
-	 *  errors before we get here out if they occur
-	 */
-	switch (pAwait->trigger.pSync->type) {
-	case SYNC_COUNTER:
-	    value = ((SyncCounter *)pAwait->trigger.pSync)->value;
-	    break;
-	default:
-	    XSyncIntToValue(&value, 0);
-	}
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pAwait++) {
+        CARD64 value;
+
+        /*  don't have to worry about NULL counters because the request
+         *  errors before we get here out if they occur
+         */
+        switch (pAwait->trigger.pSync->type) {
+        case SYNC_COUNTER:
+            value = ((SyncCounter *) pAwait->trigger.pSync)->value;
+            break;
+        default:
+            XSyncIntToValue(&value, 0);
+        }
 
-	if ((*pAwait->trigger.CheckTrigger)(&pAwait->trigger, value))
-	{
-	    (*pAwait->trigger.TriggerFired)(&pAwait->trigger);
-	    break; /* once is enough */
-	}
+        if ((*pAwait->trigger.CheckTrigger) (&pAwait->trigger, value)) {
+            (*pAwait->trigger.TriggerFired) (&pAwait->trigger);
+            break;              /* once is enough */
+        }
     }
 }
 
@@ -1615,12 +1531,12 @@ static int
 ProcSyncAwait(ClientPtr client)
 {
     REQUEST(xSyncAwaitReq);
-    int             len, items;
-    int             i;
+    int len, items;
+    int i;
     xSyncWaitCondition *pProtocolWaitConds;
     SyncAwaitUnion *pAwaitUnion;
-    SyncAwait	   *pAwait;
-    int		   status;
+    SyncAwait *pAwait;
+    int status;
 
     REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);
 
@@ -1628,63 +1544,58 @@ ProcSyncAwait(ClientPtr client)
     len -= sz_xSyncAwaitReq;
     items = len / sz_xSyncWaitCondition;
 
-    if (items * sz_xSyncWaitCondition != len)
-    {
-	return BadLength;
+    if (items * sz_xSyncWaitCondition != len) {
+        return BadLength;
     }
-    if (items == 0)
-    {
-	client->errorValue = items; /* XXX protocol change */
-	return BadValue;
+    if (items == 0) {
+        client->errorValue = items;     /* XXX protocol change */
+        return BadValue;
     }
 
     if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
-	return BadAlloc;
+        return BadAlloc;
 
     /* don't need to do any more memory allocation for this request! */
 
     pProtocolWaitConds = (xSyncWaitCondition *) & stuff[1];
 
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++)
-    {
-	if (pProtocolWaitConds->counter == None) /* XXX protocol change */
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    client->errorValue = pProtocolWaitConds->counter;
-	    return SyncErrorBase + XSyncBadCounter;
-	}
-
-	/* sanity checks are in SyncInitTrigger */
-	pAwait->trigger.pSync = NULL;
-	pAwait->trigger.value_type = pProtocolWaitConds->value_type;
-	XSyncIntsToValue(&pAwait->trigger.wait_value,
-			 pProtocolWaitConds->wait_value_lo,
-			 pProtocolWaitConds->wait_value_hi);
-	pAwait->trigger.test_type = pProtocolWaitConds->test_type;
-
-	status = SyncInitTrigger(client, &pAwait->trigger,
-				 pProtocolWaitConds->counter, RTCounter,
-				 XSyncCAAllTrigger);
-	if (status != Success)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    return status;
-	}
-	/* this is not a mistake -- same function works for both cases */
-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
-	XSyncIntsToValue(&pAwait->event_threshold,
-			 pProtocolWaitConds->event_threshold_lo,
-			 pProtocolWaitConds->event_threshold_hi);
-	pAwait->pHeader = &pAwaitUnion->header;
-	pAwaitUnion->header.num_waitconditions++;
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++) {
+        if (pProtocolWaitConds->counter == None) {      /* XXX protocol change */
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            client->errorValue = pProtocolWaitConds->counter;
+            return SyncErrorBase + XSyncBadCounter;
+        }
+
+        /* sanity checks are in SyncInitTrigger */
+        pAwait->trigger.pSync = NULL;
+        pAwait->trigger.value_type = pProtocolWaitConds->value_type;
+        XSyncIntsToValue(&pAwait->trigger.wait_value,
+                         pProtocolWaitConds->wait_value_lo,
+                         pProtocolWaitConds->wait_value_hi);
+        pAwait->trigger.test_type = pProtocolWaitConds->test_type;
+
+        status = SyncInitTrigger(client, &pAwait->trigger,
+                                 pProtocolWaitConds->counter, RTCounter,
+                                 XSyncCAAllTrigger);
+        if (status != Success) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            return status;
+        }
+        /* this is not a mistake -- same function works for both cases */
+        pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+        pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+        XSyncIntsToValue(&pAwait->event_threshold,
+                         pProtocolWaitConds->event_threshold_lo,
+                         pProtocolWaitConds->event_threshold_hi);
+        pAwait->pHeader = &pAwaitUnion->header;
+        pAwaitUnion->header.num_waitconditions++;
     }
 
     SyncAwaitEpilogue(client, items, pAwaitUnion);
@@ -1692,7 +1603,6 @@ ProcSyncAwait(ClientPtr client)
     return Success;
 }
 
-
 /*
  * ** Query a counter
  */
@@ -1701,15 +1611,15 @@ ProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     xSyncQueryCounterReply rep;
-    SyncCounter    *pCounter;
+    SyncCounter *pCounter;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter,
-				 RTCounter, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->counter,
+                                 RTCounter, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -1717,26 +1627,23 @@ ProcSyncQueryCounter(ClientPtr client)
 
     /* if system counter, ask it what the current value is */
 
-    if (IsSystemCounter(pCounter))
-    {
-	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
-						  &pCounter->value);
+    if (IsSystemCounter(pCounter)) {
+        (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+                                                  &pCounter->value);
     }
 
     rep.value_hi = XSyncValueHigh32(pCounter->value);
     rep.value_lo = XSyncValueLow32(pCounter->value);
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.value_hi);
-	swapl(&rep.value_lo);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.value_hi);
+        swapl(&rep.value_lo);
     }
     WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
     return Success;
 }
 
-
 /*
  * ** Create Alarm
  */
@@ -1744,10 +1651,10 @@ static int
 ProcSyncCreateAlarm(ClientPtr client)
 {
     REQUEST(xSyncCreateAlarmReq);
-    SyncAlarm      *pAlarm;
-    int             status;
-    unsigned long   len, vmask;
-    SyncTrigger	    *pTrigger;
+    SyncAlarm *pAlarm;
+    int status;
+    unsigned long len, vmask;
+    SyncTrigger *pTrigger;
 
     REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);
 
@@ -1756,12 +1663,11 @@ ProcSyncCreateAlarm(ClientPtr client)
     vmask = stuff->valueMask;
     len = client->req_len - bytes_to_int32(sizeof(xSyncCreateAlarmReq));
     /* the "extra" call to Ones accounts for the presence of 64 bit values */
-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
-	return BadLength;
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue | XSyncCADelta))))
+        return BadLength;
 
-    if (!(pAlarm = malloc(sizeof(SyncAlarm))))
-    {
-	return BadAlloc;
+    if (!(pAlarm = malloc(sizeof(SyncAlarm)))) {
+        return BadAlloc;
     }
 
     /* set up defaults */
@@ -1774,11 +1680,10 @@ ProcSyncCreateAlarm(ClientPtr client)
     pTrigger->TriggerFired = SyncAlarmTriggerFired;
     pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed;
     status = SyncInitTrigger(client, pTrigger, None, RTCounter,
-			     XSyncCAAllTrigger);
-    if (status != Success)
-    {
-	free(pAlarm);
-	return status;
+                             XSyncCAAllTrigger);
+    if (status != Success) {
+        free(pAlarm);
+        return status;
     }
 
     pAlarm->client = client;
@@ -1788,39 +1693,35 @@ ProcSyncCreateAlarm(ClientPtr client)
     pAlarm->state = XSyncAlarmInactive;
     pAlarm->pEventClients = NULL;
     status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
-				       (CARD32 *)&stuff[1]);
-    if (status != Success)
-    {
-	free(pAlarm);
-	return status;
+                                       (CARD32 *) &stuff[1]);
+    if (status != Success) {
+        free(pAlarm);
+        return status;
     }
 
     if (!AddResource(stuff->id, RTAlarm, pAlarm))
-	return BadAlloc;
+        return BadAlloc;
 
     /*  see if alarm already triggered.  NULL counter will not trigger
      *  in CreateAlarm and sets alarm state to Inactive.
      */
 
-    if (!pTrigger->pSync)
-    {
-	pAlarm->state = XSyncAlarmInactive; /* XXX protocol change */
+    if (!pTrigger->pSync) {
+        pAlarm->state = XSyncAlarmInactive;     /* XXX protocol change */
     }
-    else
-    {
-	SyncCounter *pCounter;
+    else {
+        SyncCounter *pCounter;
 
-	if (!SyncCheckWarnIsCounter(pTrigger->pSync,
-				    WARN_INVALID_COUNTER_ALARM))
-	{
-	    FreeResource(stuff->id, RT_NONE);
-	    return BadAlloc;
-	}
+        if (!SyncCheckWarnIsCounter(pTrigger->pSync,
+                                    WARN_INVALID_COUNTER_ALARM)) {
+            FreeResource(stuff->id, RT_NONE);
+            return BadAlloc;
+        }
 
-	pCounter = (SyncCounter *)pTrigger->pSync;
+        pCounter = (SyncCounter *) pTrigger->pSync;
 
-	if ((*pTrigger->CheckTrigger)(pTrigger, pCounter->value))
-	    (*pTrigger->TriggerFired)(pTrigger);
+        if ((*pTrigger->CheckTrigger) (pTrigger, pCounter->value))
+            (*pTrigger->TriggerFired) (pTrigger);
     }
 
     return Success;
@@ -1833,40 +1734,39 @@ static int
 ProcSyncChangeAlarm(ClientPtr client)
 {
     REQUEST(xSyncChangeAlarmReq);
-    SyncAlarm   *pAlarm;
+    SyncAlarm *pAlarm;
     SyncCounter *pCounter = NULL;
-    long        vmask;
-    int         len, status;
+    long vmask;
+    int len, status;
 
     REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
 
-    status = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				     client, DixWriteAccess);
+    status = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                     client, DixWriteAccess);
     if (status != Success)
-	return status;
+        return status;
 
     vmask = stuff->valueMask;
     len = client->req_len - bytes_to_int32(sizeof(xSyncChangeAlarmReq));
     /* the "extra" call to Ones accounts for the presence of 64 bit values */
-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
-	return BadLength;
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue | XSyncCADelta))))
+        return BadLength;
 
     if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
-					    (CARD32 *)&stuff[1])) != Success)
-	return status;
+                                            (CARD32 *) &stuff[1])) != Success)
+        return status;
 
     if (SyncCheckWarnIsCounter(pAlarm->trigger.pSync,
-			       WARN_INVALID_COUNTER_ALARM))
-	pCounter = (SyncCounter *)pAlarm->trigger.pSync;
+                               WARN_INVALID_COUNTER_ALARM))
+        pCounter = (SyncCounter *) pAlarm->trigger.pSync;
 
     /*  see if alarm already triggered.  NULL counter WILL trigger
      *  in ChangeAlarm.
      */
 
     if (!pCounter ||
-	(*pAlarm->trigger.CheckTrigger)(&pAlarm->trigger, pCounter->value))
-    {
-	(*pAlarm->trigger.TriggerFired)(&pAlarm->trigger);
+        (*pAlarm->trigger.CheckTrigger) (&pAlarm->trigger, pCounter->value)) {
+        (*pAlarm->trigger.TriggerFired) (&pAlarm->trigger);
     }
     return Success;
 }
@@ -1875,29 +1775,30 @@ static int
 ProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
-    SyncAlarm      *pAlarm;
+    SyncAlarm *pAlarm;
     xSyncQueryAlarmReply rep;
-    SyncTrigger    *pTrigger;
+    SyncTrigger *pTrigger;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
 
-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				 client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                 client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
-    rep.length = bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));
+    rep.length =
+        bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));
     rep.sequenceNumber = client->sequence;
 
     pTrigger = &pAlarm->trigger;
     rep.counter = (pTrigger->pSync) ? pTrigger->pSync->id : None;
 
-#if 0 /* XXX unclear what to do, depends on whether relative value-types
-       * are "consumed" immediately and are considered absolute from then
-       * on.
-       */
+#if 0                           /* XXX unclear what to do, depends on whether relative value-types
+                                 * are "consumed" immediately and are considered absolute from then
+                                 * on.
+                                 */
     rep.value_type = pTrigger->value_type;
     rep.wait_value_hi = XSyncValueHigh32(pTrigger->wait_value);
     rep.wait_value_lo = XSyncValueLow32(pTrigger->wait_value);
@@ -1913,16 +1814,15 @@ ProcSyncQueryAlarm(ClientPtr client)
     rep.events = pAlarm->events;
     rep.state = pAlarm->state;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.counter);
-	swapl(&rep.wait_value_hi);
-	swapl(&rep.wait_value_lo);
-	swapl(&rep.test_type);
-	swapl(&rep.delta_hi);
-	swapl(&rep.delta_lo);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.counter);
+        swapl(&rep.wait_value_hi);
+        swapl(&rep.wait_value_lo);
+        swapl(&rep.test_type);
+        swapl(&rep.delta_hi);
+        swapl(&rep.delta_lo);
     }
 
     WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
@@ -1934,14 +1834,15 @@ ProcSyncDestroyAlarm(ClientPtr client)
 {
     SyncAlarm *pAlarm;
     int rc;
+
     REQUEST(xSyncDestroyAlarmReq);
 
     REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
 
-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     FreeResource(stuff->alarm, RT_NONE);
     return Success;
@@ -1959,19 +1860,17 @@ ProcSyncCreateFence(ClientPtr client)
 
     rc = dixLookupDrawable(&pDraw, stuff->d, client, M_ANY, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     LEGAL_NEW_RESOURCE(stuff->fid, client);
 
-    if (!(pFence = (SyncFence *)SyncCreate(client,
-					   stuff->fid,
-					   SYNC_FENCE)))
-	return BadAlloc;
+    if (!(pFence = (SyncFence *) SyncCreate(client, stuff->fid, SYNC_FENCE)))
+        return BadAlloc;
 
     miSyncInitFence(pDraw->pScreen, pFence, stuff->initially_triggered);
 
     if (!AddResource(stuff->fid, RTFence, (pointer) pFence))
-	return BadAlloc;
+        return BadAlloc;
 
     return client->noClientException;
 }
@@ -1986,14 +1885,14 @@ FreeFence(void *obj, XID id)
     return Success;
 }
 
-int SyncVerifyFence(SyncFence **ppSyncFence, XID fid,
-		    ClientPtr client, Mask mode)
+int
+SyncVerifyFence(SyncFence ** ppSyncFence, XID fid, ClientPtr client, Mask mode)
 {
-    int rc = dixLookupResourceByType((pointer *)ppSyncFence, fid, RTFence,
-				     client, mode);
+    int rc = dixLookupResourceByType((pointer *) ppSyncFence, fid, RTFence,
+                                     client, mode);
 
     if (rc != Success)
-	client->errorValue = fid;
+        client->errorValue = fid;
 
     return rc;
 }
@@ -2007,10 +1906,10 @@ ProcSyncTriggerFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     miSyncTriggerFence(pFence);
 
@@ -2026,13 +1925,13 @@ ProcSyncResetFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncResetFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (pFence->funcs.CheckTriggered(pFence) != TRUE)
-	return BadMatch;
+        return BadMatch;
 
     pFence->funcs.Reset(pFence);
 
@@ -2048,10 +1947,10 @@ ProcSyncDestroyFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     FreeResource(stuff->fid, RT_NONE);
     return client->noClientException;
@@ -2067,10 +1966,10 @@ ProcSyncQueryFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid,
-				 RTFence, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid,
+                                 RTFence, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -2078,10 +1977,9 @@ ProcSyncQueryFence(ClientPtr client)
 
     rep.triggered = pFence->funcs.CheckTriggered(pFence);
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
     }
 
     WriteToClient(client, sizeof(xSyncQueryFenceReply), (char *) &rep);
@@ -2094,6 +1992,7 @@ ProcSyncAwaitFence(ClientPtr client)
     REQUEST(xSyncAwaitFenceReq);
     SyncAwaitUnion *pAwaitUnion;
     SyncAwait *pAwait;
+
     /* Use CARD32 rather than XSyncFence because XIDs are hard-coded to
      * CARD32 in protocol definitions */
     CARD32 *pProtocolFences;
@@ -2108,62 +2007,56 @@ ProcSyncAwaitFence(ClientPtr client)
     len -= sz_xSyncAwaitFenceReq;
     items = len / sizeof(CARD32);
 
-    if (items * sizeof(CARD32) != len)
-    {
-	return BadLength;
+    if (items * sizeof(CARD32) != len) {
+        return BadLength;
     }
-    if (items == 0)
-    {
-	client->errorValue = items;
-	return BadValue;
+    if (items == 0) {
+        client->errorValue = items;
+        return BadValue;
     }
 
     if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
-	return BadAlloc;
+        return BadAlloc;
 
     /* don't need to do any more memory allocation for this request! */
 
-    pProtocolFences = (CARD32 *) & stuff[1];
-
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pProtocolFences++, pAwait++)
-    {
-	if (*pProtocolFences == None)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    client->errorValue = *pProtocolFences;
-	    return SyncErrorBase + XSyncBadFence;
-	}
-
-	pAwait->trigger.pSync = NULL;
-	/* Provide acceptable values for these unused fields to
-	 * satisfy SyncInitTrigger's validation logic
-	 */
-	pAwait->trigger.value_type = XSyncAbsolute;
-	XSyncIntToValue(&pAwait->trigger.wait_value, 0);
-	pAwait->trigger.test_type = 0;
-
-	status = SyncInitTrigger(client, &pAwait->trigger,
-				 *pProtocolFences, RTFence,
-				 XSyncCAAllTrigger);
-	if (status != Success)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    return status;
-	}
-	/* this is not a mistake -- same function works for both cases */
-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
-	/* event_threshold is unused for fence syncs */
-	XSyncIntToValue(&pAwait->event_threshold, 0);
-	pAwait->pHeader = &pAwaitUnion->header;
-	pAwaitUnion->header.num_waitconditions++;
+    pProtocolFences = (CARD32 *) &stuff[1];
+
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolFences++, pAwait++) {
+        if (*pProtocolFences == None) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            client->errorValue = *pProtocolFences;
+            return SyncErrorBase + XSyncBadFence;
+        }
+
+        pAwait->trigger.pSync = NULL;
+        /* Provide acceptable values for these unused fields to
+         * satisfy SyncInitTrigger's validation logic
+         */
+        pAwait->trigger.value_type = XSyncAbsolute;
+        XSyncIntToValue(&pAwait->trigger.wait_value, 0);
+        pAwait->trigger.test_type = 0;
+
+        status = SyncInitTrigger(client, &pAwait->trigger,
+                                 *pProtocolFences, RTFence, XSyncCAAllTrigger);
+        if (status != Success) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            return status;
+        }
+        /* this is not a mistake -- same function works for both cases */
+        pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+        pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+        /* event_threshold is unused for fence syncs */
+        XSyncIntToValue(&pAwait->event_threshold, 0);
+        pAwait->pHeader = &pAwaitUnion->header;
+        pAwaitUnion->header.num_waitconditions++;
     }
 
     SyncAwaitEpilogue(client, items, pAwaitUnion);
@@ -2179,50 +2072,49 @@ ProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-      case X_SyncInitialize:
-	return ProcSyncInitialize(client);
-      case X_SyncListSystemCounters:
-	return ProcSyncListSystemCounters(client);
-      case X_SyncCreateCounter:
-	return ProcSyncCreateCounter(client);
-      case X_SyncSetCounter:
-	return ProcSyncSetCounter(client);
-      case X_SyncChangeCounter:
-	return ProcSyncChangeCounter(client);
-      case X_SyncQueryCounter:
-	return ProcSyncQueryCounter(client);
-      case X_SyncDestroyCounter:
-	return ProcSyncDestroyCounter(client);
-      case X_SyncAwait:
-	return ProcSyncAwait(client);
-      case X_SyncCreateAlarm:
-	return ProcSyncCreateAlarm(client);
-      case X_SyncChangeAlarm:
-	return ProcSyncChangeAlarm(client);
-      case X_SyncQueryAlarm:
-	return ProcSyncQueryAlarm(client);
-      case X_SyncDestroyAlarm:
-	return ProcSyncDestroyAlarm(client);
-      case X_SyncSetPriority:
-	return ProcSyncSetPriority(client);
-      case X_SyncGetPriority:
-	return ProcSyncGetPriority(client);
-      case X_SyncCreateFence:
-	return ProcSyncCreateFence(client);
-      case X_SyncTriggerFence:
-	return ProcSyncTriggerFence(client);
-      case X_SyncResetFence:
-	return ProcSyncResetFence(client);
-      case X_SyncDestroyFence:
-	return ProcSyncDestroyFence(client);
-      case X_SyncQueryFence:
-	return ProcSyncQueryFence(client);
-      case X_SyncAwaitFence:
-	return ProcSyncAwaitFence(client);
-      default:
-	return BadRequest;
+    switch (stuff->data) {
+    case X_SyncInitialize:
+        return ProcSyncInitialize(client);
+    case X_SyncListSystemCounters:
+        return ProcSyncListSystemCounters(client);
+    case X_SyncCreateCounter:
+        return ProcSyncCreateCounter(client);
+    case X_SyncSetCounter:
+        return ProcSyncSetCounter(client);
+    case X_SyncChangeCounter:
+        return ProcSyncChangeCounter(client);
+    case X_SyncQueryCounter:
+        return ProcSyncQueryCounter(client);
+    case X_SyncDestroyCounter:
+        return ProcSyncDestroyCounter(client);
+    case X_SyncAwait:
+        return ProcSyncAwait(client);
+    case X_SyncCreateAlarm:
+        return ProcSyncCreateAlarm(client);
+    case X_SyncChangeAlarm:
+        return ProcSyncChangeAlarm(client);
+    case X_SyncQueryAlarm:
+        return ProcSyncQueryAlarm(client);
+    case X_SyncDestroyAlarm:
+        return ProcSyncDestroyAlarm(client);
+    case X_SyncSetPriority:
+        return ProcSyncSetPriority(client);
+    case X_SyncGetPriority:
+        return ProcSyncGetPriority(client);
+    case X_SyncCreateFence:
+        return ProcSyncCreateFence(client);
+    case X_SyncTriggerFence:
+        return ProcSyncTriggerFence(client);
+    case X_SyncResetFence:
+        return ProcSyncResetFence(client);
+    case X_SyncDestroyFence:
+        return ProcSyncDestroyFence(client);
+    case X_SyncQueryFence:
+        return ProcSyncQueryFence(client);
+    case X_SyncAwaitFence:
+        return ProcSyncAwaitFence(client);
+    default:
+        return BadRequest;
     }
 }
 
@@ -2235,7 +2127,7 @@ SProcSyncInitialize(ClientPtr client)
 {
     REQUEST(xSyncInitializeReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncInitializeReq);
+    REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
     return ProcSyncInitialize(client);
 }
@@ -2245,7 +2137,7 @@ SProcSyncListSystemCounters(ClientPtr client)
 {
     REQUEST(xSyncListSystemCountersReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);
+    REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
 
     return ProcSyncListSystemCounters(client);
 }
@@ -2255,7 +2147,7 @@ SProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncCreateCounterReq);
+    REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->initial_value_lo);
     swapl(&stuff->initial_value_hi);
@@ -2268,7 +2160,7 @@ SProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncSetCounterReq);
+    REQUEST_SIZE_MATCH(xSyncSetCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->value_lo);
     swapl(&stuff->value_hi);
@@ -2281,7 +2173,7 @@ SProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncChangeCounterReq);
+    REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->value_lo);
     swapl(&stuff->value_hi);
@@ -2294,7 +2186,7 @@ SProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryCounterReq);
+    REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
     swapl(&stuff->counter);
 
     return ProcSyncQueryCounter(client);
@@ -2305,7 +2197,7 @@ SProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
     swapl(&stuff->counter);
 
     return ProcSyncDestroyCounter(client);
@@ -2352,7 +2244,7 @@ SProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);
+    REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
     swapl(&stuff->alarm);
 
     return ProcSyncQueryAlarm(client);
@@ -2363,7 +2255,7 @@ SProcSyncDestroyAlarm(ClientPtr client)
 {
     REQUEST(xSyncDestroyAlarmReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
     swapl(&stuff->alarm);
 
     return ProcSyncDestroyAlarm(client);
@@ -2374,7 +2266,7 @@ SProcSyncSetPriority(ClientPtr client)
 {
     REQUEST(xSyncSetPriorityReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncSetPriorityReq);
+    REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
     swapl(&stuff->id);
     swapl(&stuff->priority);
 
@@ -2386,7 +2278,7 @@ SProcSyncGetPriority(ClientPtr client)
 {
     REQUEST(xSyncGetPriorityReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncGetPriorityReq);
+    REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
     swapl(&stuff->id);
 
     return ProcSyncGetPriority(client);
@@ -2397,7 +2289,7 @@ SProcSyncCreateFence(ClientPtr client)
 {
     REQUEST(xSyncCreateFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncCreateFenceReq);
+    REQUEST_SIZE_MATCH(xSyncCreateFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncCreateFence(client);
@@ -2408,7 +2300,7 @@ SProcSyncTriggerFence(ClientPtr client)
 {
     REQUEST(xSyncTriggerFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncTriggerFenceReq);
+    REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncTriggerFence(client);
@@ -2419,7 +2311,7 @@ SProcSyncResetFence(ClientPtr client)
 {
     REQUEST(xSyncResetFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncResetFenceReq);
+    REQUEST_SIZE_MATCH(xSyncResetFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncResetFence(client);
@@ -2430,7 +2322,7 @@ SProcSyncDestroyFence(ClientPtr client)
 {
     REQUEST(xSyncDestroyFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyFenceReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncDestroyFence(client);
@@ -2441,7 +2333,7 @@ SProcSyncQueryFence(ClientPtr client)
 {
     REQUEST(xSyncQueryFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryFenceReq);
+    REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncQueryFence(client);
@@ -2463,50 +2355,49 @@ SProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-      case X_SyncInitialize:
-	return SProcSyncInitialize(client);
-      case X_SyncListSystemCounters:
-	return SProcSyncListSystemCounters(client);
-      case X_SyncCreateCounter:
-	return SProcSyncCreateCounter(client);
-      case X_SyncSetCounter:
-	return SProcSyncSetCounter(client);
-      case X_SyncChangeCounter:
-	return SProcSyncChangeCounter(client);
-      case X_SyncQueryCounter:
-	return SProcSyncQueryCounter(client);
-      case X_SyncDestroyCounter:
-	return SProcSyncDestroyCounter(client);
-      case X_SyncAwait:
-	return SProcSyncAwait(client);
-      case X_SyncCreateAlarm:
-	return SProcSyncCreateAlarm(client);
-      case X_SyncChangeAlarm:
-	return SProcSyncChangeAlarm(client);
-      case X_SyncQueryAlarm:
-	return SProcSyncQueryAlarm(client);
-      case X_SyncDestroyAlarm:
-	return SProcSyncDestroyAlarm(client);
-      case X_SyncSetPriority:
-	return SProcSyncSetPriority(client);
-      case X_SyncGetPriority:
-	return SProcSyncGetPriority(client);
-      case X_SyncCreateFence:
-	return SProcSyncCreateFence(client);
-      case X_SyncTriggerFence:
-	return SProcSyncTriggerFence(client);
-      case X_SyncResetFence:
-	return SProcSyncResetFence(client);
-      case X_SyncDestroyFence:
-	return SProcSyncDestroyFence(client);
-      case X_SyncQueryFence:
-	return SProcSyncQueryFence(client);
-      case X_SyncAwaitFence:
-	return SProcSyncAwaitFence(client);
-      default:
-	return BadRequest;
+    switch (stuff->data) {
+    case X_SyncInitialize:
+        return SProcSyncInitialize(client);
+    case X_SyncListSystemCounters:
+        return SProcSyncListSystemCounters(client);
+    case X_SyncCreateCounter:
+        return SProcSyncCreateCounter(client);
+    case X_SyncSetCounter:
+        return SProcSyncSetCounter(client);
+    case X_SyncChangeCounter:
+        return SProcSyncChangeCounter(client);
+    case X_SyncQueryCounter:
+        return SProcSyncQueryCounter(client);
+    case X_SyncDestroyCounter:
+        return SProcSyncDestroyCounter(client);
+    case X_SyncAwait:
+        return SProcSyncAwait(client);
+    case X_SyncCreateAlarm:
+        return SProcSyncCreateAlarm(client);
+    case X_SyncChangeAlarm:
+        return SProcSyncChangeAlarm(client);
+    case X_SyncQueryAlarm:
+        return SProcSyncQueryAlarm(client);
+    case X_SyncDestroyAlarm:
+        return SProcSyncDestroyAlarm(client);
+    case X_SyncSetPriority:
+        return SProcSyncSetPriority(client);
+    case X_SyncGetPriority:
+        return SProcSyncGetPriority(client);
+    case X_SyncCreateFence:
+        return SProcSyncCreateFence(client);
+    case X_SyncTriggerFence:
+        return SProcSyncTriggerFence(client);
+    case X_SyncResetFence:
+        return SProcSyncResetFence(client);
+    case X_SyncDestroyFence:
+        return SProcSyncDestroyFence(client);
+    case X_SyncQueryFence:
+        return SProcSyncQueryFence(client);
+    case X_SyncAwaitFence:
+        return SProcSyncAwaitFence(client);
+    default:
+        return BadRequest;
     }
 }
 
@@ -2515,7 +2406,8 @@ SProcSyncDispatch(ClientPtr client)
  */
 
 static void
-SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
+SCounterNotifyEvent(xSyncCounterNotifyEvent * from,
+                    xSyncCounterNotifyEvent * to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2530,9 +2422,8 @@ SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
     to->destroyed = from->destroyed;
 }
 
-
 static void
-SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
+SAlarmNotifyEvent(xSyncAlarmNotifyEvent * from, xSyncAlarmNotifyEvent * to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2551,7 +2442,7 @@ SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
  */
 /* ARGSUSED */
 static void
-SyncResetProc(ExtensionEntry *extEntry)
+SyncResetProc(ExtensionEntry * extEntry)
 {
     free(SysCounterList);
     SysCounterList = NULL;
@@ -2565,41 +2456,40 @@ void
 SyncExtensionInit(void)
 {
     ExtensionEntry *extEntry;
-    int 	    s;
+    int s;
 
     for (s = 0; s < screenInfo.numScreens; s++)
-	miSyncSetup(screenInfo.screens[s]);
+        miSyncSetup(screenInfo.screens[s]);
 
-    if (RTCounter == 0)
-    {
-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+    if (RTCounter == 0) {
+        RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
     }
     RTAlarm = CreateNewResourceType(FreeAlarm, "SyncAlarm");
     RTAwait = CreateNewResourceType(FreeAwait, "SyncAwait");
     RTFence = CreateNewResourceType(FreeFence, "SyncFence");
     if (RTAwait)
-	RTAwait |= RC_NEVERRETAIN;
+        RTAwait |= RC_NEVERRETAIN;
     RTAlarmClient = CreateNewResourceType(FreeAlarmClient, "SyncAlarmClient");
     if (RTAlarmClient)
-	RTAlarmClient |= RC_NEVERRETAIN;
+        RTAlarmClient |= RC_NEVERRETAIN;
 
     if (RTCounter == 0 || RTAwait == 0 || RTAlarm == 0 ||
-	RTAlarmClient == 0 ||
-	(extEntry = AddExtension(SYNC_NAME,
-				 XSyncNumberEvents, XSyncNumberErrors,
-				 ProcSyncDispatch, SProcSyncDispatch,
-				 SyncResetProc,
-				 StandardMinorOpcode)) == NULL)
-    {
-	ErrorF("Sync Extension %d.%d failed to Initialise\n",
-		SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
-	return;
+        RTAlarmClient == 0 ||
+        (extEntry = AddExtension(SYNC_NAME,
+                                 XSyncNumberEvents, XSyncNumberErrors,
+                                 ProcSyncDispatch, SProcSyncDispatch,
+                                 SyncResetProc, StandardMinorOpcode)) == NULL) {
+        ErrorF("Sync Extension %d.%d failed to Initialise\n",
+               SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+        return;
     }
 
     SyncEventBase = extEntry->eventBase;
     SyncErrorBase = extEntry->errorBase;
-    EventSwapVector[SyncEventBase + XSyncCounterNotify] = (EventSwapPtr) SCounterNotifyEvent;
-    EventSwapVector[SyncEventBase + XSyncAlarmNotify] = (EventSwapPtr) SAlarmNotifyEvent;
+    EventSwapVector[SyncEventBase + XSyncCounterNotify] =
+        (EventSwapPtr) SCounterNotifyEvent;
+    EventSwapVector[SyncEventBase + XSyncAlarmNotify] =
+        (EventSwapPtr) SAlarmNotifyEvent;
 
     SetResourceTypeErrorValue(RTCounter, SyncErrorBase + XSyncBadCounter);
     SetResourceTypeErrorValue(RTAlarm, SyncErrorBase + XSyncBadAlarm);
@@ -2616,17 +2506,14 @@ SyncExtensionInit(void)
 
 #ifdef DEBUG
     fprintf(stderr, "Sync Extension %d.%d\n",
-	    SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+            SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
 #endif
 }
 
-
 /*
  * ***** SERVERTIME implementation - should go in its own file in OS directory?
  */
 
-
-
 static pointer ServertimeCounter;
 static XSyncValue Now;
 static XSyncValue *pnext_time;
@@ -2643,72 +2530,62 @@ static XSyncValue *pnext_time;
 *** Server Block Handler
 *** code inspired by multibuffer extension (now deprecated)
  */
-/*ARGSUSED*/
-static void
+ /*ARGSUSED*/ static void
 ServertimeBlockHandler(void *env, struct timeval **wt, void *LastSelectMask)
 {
     XSyncValue delay;
     unsigned long timeout;
 
-    if (pnext_time)
-    {
+    if (pnext_time) {
         GetTime();
 
-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
-	{
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time)) {
             timeout = 0;
         }
-	else
-	{
-	    Bool overflow;
+        else {
+            Bool overflow;
+
             XSyncValueSubtract(&delay, *pnext_time, Now, &overflow);
-	    (void)overflow;
+            (void) overflow;
             timeout = XSyncValueLow32(delay);
         }
-        AdjustWaitForDelay(wt, timeout); /* os/utils.c */
+        AdjustWaitForDelay(wt, timeout);        /* os/utils.c */
     }
 }
 
 /*
 *** Wakeup Handler
  */
-/*ARGSUSED*/
-static void
+ /*ARGSUSED*/ static void
 ServertimeWakeupHandler(void *env, int rc, void *LastSelectMask)
 {
-    if (pnext_time)
-    {
+    if (pnext_time) {
         GetTime();
 
-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
-	{
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time)) {
             SyncChangeCounter(ServertimeCounter, Now);
         }
     }
 }
 
 static void
-ServertimeQueryValue(void *pCounter, CARD64 *pValue_return)
+ServertimeQueryValue(void *pCounter, CARD64 * pValue_return)
 {
     GetTime();
     *pValue_return = Now;
 }
 
 static void
-ServertimeBracketValues(void *pCounter, CARD64 *pbracket_less,
-			CARD64 *pbracket_greater)
+ServertimeBracketValues(void *pCounter, CARD64 * pbracket_less,
+                        CARD64 * pbracket_greater)
 {
-    if (!pnext_time && pbracket_greater)
-    {
-	RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
-				       ServertimeWakeupHandler,
-				       NULL);
+    if (!pnext_time && pbracket_greater) {
+        RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
+                                       ServertimeWakeupHandler, NULL);
     }
-    else if (pnext_time && !pbracket_greater)
-    {
-	RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,
-				     ServertimeWakeupHandler,
-				     NULL);
+    else if (pnext_time && !pbracket_greater) {
+        RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,
+                                     ServertimeWakeupHandler, NULL);
     }
     pnext_time = pbracket_greater;
 }
@@ -2721,13 +2598,12 @@ SyncInitServerTime(void)
     XSyncIntsToValue(&Now, GetTimeInMillis(), 0);
     XSyncIntToValue(&resolution, 4);
     ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution,
-			    XSyncCounterNeverDecreases,
-			    ServertimeQueryValue, ServertimeBracketValues);
+                                                XSyncCounterNeverDecreases,
+                                                ServertimeQueryValue,
+                                                ServertimeBracketValues);
     pnext_time = NULL;
 }
 
-
-
 /*
  * IDLETIME implementation
  */
@@ -2737,10 +2613,11 @@ static XSyncValue *pIdleTimeValueLess;
 static XSyncValue *pIdleTimeValueGreater;
 
 static void
-IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return)
+IdleTimeQueryValue(pointer pCounter, CARD64 * pValue_return)
 {
     CARD32 idle = GetTimeInMillis() - lastDeviceEventTime.milliseconds;
-    XSyncIntsToValue (pValue_return, idle, 0);
+
+    XSyncIntsToValue(pValue_return, idle, 0);
 }
 
 static void
@@ -2751,127 +2628,120 @@ IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
     SyncTrigger *trig;
 
     if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
-	return;
+        return;
 
     old_idle = IdleTimeCounter->value;
-    IdleTimeQueryValue (NULL, &idle);
-    IdleTimeCounter->value = idle; /* push, so CheckTrigger works */
-
-    if (pIdleTimeValueLess &&
-        XSyncValueLessOrEqual (idle, *pIdleTimeValueLess))
-    {
-	/*
-	 * We've been idle for less than the threshold value, and someone
-	 * wants to know about that, but now we need to know whether they
-	 * want level or edge trigger.  Check the trigger list against the
-	 * current idle time, and if any succeed, bomb out of select()
-	 * immediately so we can reschedule.
-	 */
-
-	for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
-	    trig = list->pTrigger;
-	    if (trig->CheckTrigger(trig, old_idle)) {
-		AdjustWaitForDelay(wt, 0);
-		break;
-	    }
-	}
-	/* 
-	 * We've been called exactly on the idle time, but we have a
-	 * NegativeTransition trigger which requires a transition from an
-	 * idle time greater than this.  Schedule a wakeup for the next
-	 * millisecond so we won't miss a transition.
-	 */
-	if (XSyncValueEqual (idle, *pIdleTimeValueLess))
-	    AdjustWaitForDelay(wt, 1);
-    }
-    else if (pIdleTimeValueGreater)
-    {
-	/*
-	 * There's a threshold in the positive direction.  If we've been
-	 * idle less than it, schedule a wakeup for sometime in the future.
-	 * If we've been idle more than it, and someone wants to know about
-	 * that level-triggered, schedule an immediate wakeup.
-	 */
-	unsigned long timeout = -1;
-
-	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {
-	    XSyncValue value;
-	    Bool overflow;
-
-	    XSyncValueSubtract (&value, *pIdleTimeValueGreater,
-	                        idle, &overflow);
-	    timeout = min(timeout, XSyncValueLow32 (value));
-	} else {
-	    for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
-		trig = list->pTrigger;
-		if (trig->CheckTrigger(trig, old_idle)) {
-		    timeout = min(timeout, 0);
-		    break;
-		}
-	    }
-	}
-
-	AdjustWaitForDelay (wt, timeout);
-    }
-
-    IdleTimeCounter->value = old_idle; /* pop */
+    IdleTimeQueryValue(NULL, &idle);
+    IdleTimeCounter->value = idle;      /* push, so CheckTrigger works */
+
+    if (pIdleTimeValueLess && XSyncValueLessOrEqual(idle, *pIdleTimeValueLess)) {
+        /*
+         * We've been idle for less than the threshold value, and someone
+         * wants to know about that, but now we need to know whether they
+         * want level or edge trigger.  Check the trigger list against the
+         * current idle time, and if any succeed, bomb out of select()
+         * immediately so we can reschedule.
+         */
+
+        for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
+            trig = list->pTrigger;
+            if (trig->CheckTrigger(trig, old_idle)) {
+                AdjustWaitForDelay(wt, 0);
+                break;
+            }
+        }
+        /* 
+         * We've been called exactly on the idle time, but we have a
+         * NegativeTransition trigger which requires a transition from an
+         * idle time greater than this.  Schedule a wakeup for the next
+         * millisecond so we won't miss a transition.
+         */
+        if (XSyncValueEqual(idle, *pIdleTimeValueLess))
+            AdjustWaitForDelay(wt, 1);
+    }
+    else if (pIdleTimeValueGreater) {
+        /*
+         * There's a threshold in the positive direction.  If we've been
+         * idle less than it, schedule a wakeup for sometime in the future.
+         * If we've been idle more than it, and someone wants to know about
+         * that level-triggered, schedule an immediate wakeup.
+         */
+        unsigned long timeout = -1;
+
+        if (XSyncValueLessThan(idle, *pIdleTimeValueGreater)) {
+            XSyncValue value;
+            Bool overflow;
+
+            XSyncValueSubtract(&value, *pIdleTimeValueGreater, idle, &overflow);
+            timeout = min(timeout, XSyncValueLow32(value));
+        }
+        else {
+            for (list = IdleTimeCounter->sync.pTriglist; list;
+                 list = list->next) {
+                trig = list->pTrigger;
+                if (trig->CheckTrigger(trig, old_idle)) {
+                    timeout = min(timeout, 0);
+                    break;
+                }
+            }
+        }
+
+        AdjustWaitForDelay(wt, timeout);
+    }
+
+    IdleTimeCounter->value = old_idle;  /* pop */
 }
 
 static void
-IdleTimeWakeupHandler (pointer env, int rc, pointer LastSelectMask)
+IdleTimeWakeupHandler(pointer env, int rc, pointer LastSelectMask)
 {
     XSyncValue idle;
 
     if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
-	return;
+        return;
 
-    IdleTimeQueryValue (NULL, &idle);
+    IdleTimeQueryValue(NULL, &idle);
 
     if ((pIdleTimeValueGreater &&
-         XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||
+         XSyncValueGreaterOrEqual(idle, *pIdleTimeValueGreater)) ||
         (pIdleTimeValueLess &&
-	 XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))
-    {
-	SyncChangeCounter (IdleTimeCounter, idle);
+         XSyncValueLessOrEqual(idle, *pIdleTimeValueLess))) {
+        SyncChangeCounter(IdleTimeCounter, idle);
     }
 }
 
 static void
-IdleTimeBracketValues (pointer pCounter, CARD64 *pbracket_less,
-                       CARD64 *pbracket_greater)
+IdleTimeBracketValues(pointer pCounter, CARD64 * pbracket_less,
+                      CARD64 * pbracket_greater)
 {
     Bool registered = (pIdleTimeValueLess || pIdleTimeValueGreater);
 
-    if (registered && !pbracket_less && !pbracket_greater)
-    {
-	RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,
-	                             IdleTimeWakeupHandler,
-	                             NULL);
+    if (registered && !pbracket_less && !pbracket_greater) {
+        RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,
+                                     IdleTimeWakeupHandler, NULL);
     }
-    else if (!registered && (pbracket_less || pbracket_greater))
-    {
-	RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,
-	                               IdleTimeWakeupHandler,
-	                               NULL);
+    else if (!registered && (pbracket_less || pbracket_greater)) {
+        RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,
+                                       IdleTimeWakeupHandler, NULL);
     }
 
     pIdleTimeValueGreater = pbracket_greater;
-    pIdleTimeValueLess    = pbracket_less;
+    pIdleTimeValueLess = pbracket_less;
 }
 
 static void
-SyncInitIdleTime (void)
+SyncInitIdleTime(void)
 {
     CARD64 resolution;
     XSyncValue idle;
 
-    IdleTimeQueryValue (NULL, &idle);
-    XSyncIntToValue (&resolution, 4);
+    IdleTimeQueryValue(NULL, &idle);
+    XSyncIntToValue(&resolution, 4);
 
-    IdleTimeCounter = SyncCreateSystemCounter ("IDLETIME", idle, resolution,
-                                               XSyncCounterUnrestricted,
-                                               IdleTimeQueryValue,
-                                               IdleTimeBracketValues);
+    IdleTimeCounter = SyncCreateSystemCounter("IDLETIME", idle, resolution,
+                                              XSyncCounterUnrestricted,
+                                              IdleTimeQueryValue,
+                                              IdleTimeBracketValues);
 
     pIdleTimeValueLess = pIdleTimeValueGreater = NULL;
 }