libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 1322 insertions, 1436 deletions

diff --git a/xorg-server/record/record.c b/xorg-server/record/record.c
index b956b4ab8..8a38118cd 100644
--- a/xorg-server/record/record.c
+++ b/xorg-server/record/record.c
@@ -45,7 +45,6 @@ and Jim Haggerty of Metheus.
 #include "eventconvert.h"
 #include "scrnintstr.h"
 
-
 #include <stdio.h>
 #include <assert.h>
 
@@ -58,7 +57,7 @@ and Jim Haggerty of Metheus.
 
 #include "protocol-versions.h"
 
-static RESTYPE RTContext;   /* internal resource type for Record contexts */
+static RESTYPE RTContext;       /* internal resource type for Record contexts */
 
 /* How many bytes of protocol data to buffer in a context. Don't set to less
  * than 32.
@@ -68,16 +67,16 @@ static RESTYPE RTContext;   /* internal resource type for Record contexts */
 /* Record Context structure */
 
 typedef struct {
-    XID		id;		   /* resource id of context */
-    ClientPtr	pRecordingClient;  /* client that has context enabled */
-    struct _RecordClientsAndProtocolRec *pListOfRCAP; /* all registered info */
-    ClientPtr	pBufClient;	   /* client whose protocol is in replyBuffer*/
-    unsigned int continuedReply:1; /* recording a reply that is split up? */
-    char	elemHeaders;	   /* element header flags (time/seq no.) */
-    char	bufCategory;	   /* category of protocol in replyBuffer */
-    int		numBufBytes;	   /* number of bytes in replyBuffer */
-    char	replyBuffer[REPLY_BUF_SIZE]; /* buffered recorded protocol */
-    int		inFlush;           /*  are we inside RecordFlushReplyBuffer */
+    XID id;                     /* resource id of context */
+    ClientPtr pRecordingClient; /* client that has context enabled */
+    struct _RecordClientsAndProtocolRec *pListOfRCAP;   /* all registered info */
+    ClientPtr pBufClient;       /* client whose protocol is in replyBuffer */
+    unsigned int continuedReply:1;      /* recording a reply that is split up? */
+    char elemHeaders;           /* element header flags (time/seq no.) */
+    char bufCategory;           /* category of protocol in replyBuffer */
+    int numBufBytes;            /* number of bytes in replyBuffer */
+    char replyBuffer[REPLY_BUF_SIZE];   /* buffered recorded protocol */
+    int inFlush;                /*  are we inside RecordFlushReplyBuffer */
 } RecordContextRec, *RecordContextPtr;
 
 /*  RecordMinorOpRec - to hold minor opcode selections for extension requests
@@ -85,15 +84,14 @@ typedef struct {
  */
 
 typedef union {
-    int count; /* first element of array: how many "major" structs to follow */
-    struct {   /* rest of array elements are this */
-	short first;		/* first major opcode */
-	short last;		/* last major opcode */
-	RecordSetPtr pMinOpSet; /*  minor opcode set for above major range */
+    int count;                  /* first element of array: how many "major" structs to follow */
+    struct {                    /* rest of array elements are this */
+        short first;            /* first major opcode */
+        short last;             /* last major opcode */
+        RecordSetPtr pMinOpSet; /*  minor opcode set for above major range */
     } major;
 } RecordMinorOpRec, *RecordMinorOpPtr;
 
-
 /*  RecordClientsAndProtocolRec, nicknamed RCAP - holds all the client and 
  *  protocol selections passed in a single CreateContext or RegisterClients.
  *  Generally, a context will have one of these from the create and an
@@ -102,21 +100,21 @@ typedef union {
  */
 
 typedef struct _RecordClientsAndProtocolRec {
-    RecordContextPtr pContext;		 /* context that owns this RCAP */
-    struct _RecordClientsAndProtocolRec *pNextRCAP; /* next RCAP on context */
-    RecordSetPtr     pRequestMajorOpSet; /* requests to record */
-    RecordMinorOpPtr pRequestMinOpInfo;  /* extension requests to record */
-    RecordSetPtr     pReplyMajorOpSet;   /* replies to record */
-    RecordMinorOpPtr pReplyMinOpInfo;    /* extension replies to record */
-    RecordSetPtr     pDeviceEventSet;    /* device events to record */
-    RecordSetPtr     pDeliveredEventSet; /* delivered events to record */
-    RecordSetPtr     pErrorSet;          /* errors to record */
-    XID *	     pClientIDs;	 /* array of clients to record */
-    short 	     numClients;	 /* number of clients in pClientIDs */
-    short	     sizeClients;	 /* size of pClientIDs array */
-    unsigned int     clientStarted:1;	 /* record new client connections? */
-    unsigned int     clientDied:1;	 /* record client disconnections? */
-    unsigned int     clientIDsSeparatelyAllocated:1; /* pClientIDs malloced? */
+    RecordContextPtr pContext;  /* context that owns this RCAP */
+    struct _RecordClientsAndProtocolRec *pNextRCAP;     /* next RCAP on context */
+    RecordSetPtr pRequestMajorOpSet;    /* requests to record */
+    RecordMinorOpPtr pRequestMinOpInfo; /* extension requests to record */
+    RecordSetPtr pReplyMajorOpSet;      /* replies to record */
+    RecordMinorOpPtr pReplyMinOpInfo;   /* extension replies to record */
+    RecordSetPtr pDeviceEventSet;       /* device events to record */
+    RecordSetPtr pDeliveredEventSet;    /* delivered events to record */
+    RecordSetPtr pErrorSet;     /* errors to record */
+    XID *pClientIDs;            /* array of clients to record */
+    short numClients;           /* number of clients in pClientIDs */
+    short sizeClients;          /* size of pClientIDs array */
+    unsigned int clientStarted:1;       /* record new client connections? */
+    unsigned int clientDied:1;  /* record client disconnections? */
+    unsigned int clientIDsSeparatelyAllocated:1;        /* pClientIDs malloced? */
 } RecordClientsAndProtocolRec, *RecordClientsAndProtocolPtr;
 
 /* how much bigger to make pRCAP->pClientIDs when reallocing */
@@ -137,10 +135,9 @@ static int numEnabledRCAPs;
 	return rc; \
 }
 
-static int RecordDeleteContext(
-    pointer /*value*/,
-    XID /*id*/
-);
+static int RecordDeleteContext(pointer /*value */ ,
+                               XID      /*id */
+    );
 
 void RecordExtensionInit(void);
 
@@ -151,24 +148,24 @@ void RecordExtensionInit(void);
 /*  To make declarations less obfuscated, have a typedef for a pointer to a
  *  Proc function.
  */
-typedef int (*ProcFunctionPtr)(
-    ClientPtr /*pClient*/
-);
+typedef int (*ProcFunctionPtr) (ClientPtr       /*pClient */
+    );
 
 /* Record client private.  Generally a client only has one of these if
  * any of its requests are being recorded.
  */
 typedef struct {
 /* ptr to client's proc vector before Record stuck its nose in */
-    ProcFunctionPtr *originalVector;   
-					
+    ProcFunctionPtr *originalVector;
+
 /* proc vector with pointers for recorded requests redirected to the
  * function RecordARequest
  */
-    ProcFunctionPtr recordVector[256]; 
+    ProcFunctionPtr recordVector[256];
 } RecordClientPrivateRec, *RecordClientPrivatePtr;
 
 static DevPrivateKeyRec RecordClientPrivateKeyRec;
+
 #define RecordClientPrivateKey (&RecordClientPrivateKeyRec)
 
 /*  RecordClientPrivatePtr RecordClientPrivate(ClientPtr)
@@ -176,7 +173,6 @@ static DevPrivateKeyRec RecordClientPrivateKeyRec;
  */
 #define RecordClientPrivate(_pClient) (RecordClientPrivatePtr) \
     dixLookupPrivate(&(_pClient)->devPrivates, RecordClientPrivateKey)
-
 
 /***************************************************************************/
 
@@ -184,7 +180,7 @@ static DevPrivateKeyRec RecordClientPrivateKeyRec;
 
 static RecordContextPtr *ppAllContexts;
 
-static int numContexts;/* number of contexts in ppAllContexts */
+static int numContexts;         /* number of contexts in ppAllContexts */
 
 /* number of currently enabled contexts.  All enabled contexts are bunched
  * up at the front of the ppAllContexts array, from ppAllContexts[0] to
@@ -210,14 +206,12 @@ RecordFindContextOnAllContexts(RecordContextPtr pContext)
     int i;
 
     assert(numContexts >= numEnabledContexts);
-    for (i = 0; i < numContexts; i++)
-    {
-	if (ppAllContexts[i] == pContext)
-	    return i;
+    for (i = 0; i < numContexts; i++) {
+        if (ppAllContexts[i] == pContext)
+            return i;
     }
     return -1;
-} /* RecordFindContextOnAllContexts */
-
+}                               /* RecordFindContextOnAllContexts */
 
 /***************************************************************************/
 
@@ -238,28 +232,23 @@ RecordFindContextOnAllContexts(RecordContextPtr pContext)
  *	data1/len1).
  */
 static void
-RecordFlushReplyBuffer(
-    RecordContextPtr pContext,
-    pointer data1,
-    int len1,
-    pointer data2,
-    int len2
-)
+RecordFlushReplyBuffer(RecordContextPtr pContext,
+                       pointer data1, int len1, pointer data2, int len2)
 {
-    if (!pContext->pRecordingClient || pContext->pRecordingClient->clientGone || pContext->inFlush)
-	return;
+    if (!pContext->pRecordingClient || pContext->pRecordingClient->clientGone ||
+        pContext->inFlush)
+        return;
     ++pContext->inFlush;
     if (pContext->numBufBytes)
-	WriteToClient(pContext->pRecordingClient, pContext->numBufBytes,
-		      (char *)pContext->replyBuffer);
+        WriteToClient(pContext->pRecordingClient, pContext->numBufBytes,
+                      (char *) pContext->replyBuffer);
     pContext->numBufBytes = 0;
     if (len1)
-	WriteToClient(pContext->pRecordingClient, len1, (char *)data1);
+        WriteToClient(pContext->pRecordingClient, len1, (char *) data1);
     if (len2)
-	WriteToClient(pContext->pRecordingClient, len2, (char *)data2);
+        WriteToClient(pContext->pRecordingClient, len2, (char *) data2);
     --pContext->inFlush;
-} /* RecordFlushReplyBuffer */
-
+}                               /* RecordFlushReplyBuffer */
 
 /* RecordAProtocolElement
  *
@@ -291,7 +280,8 @@ RecordFlushReplyBuffer(
  */
 static void
 RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
-		       int category, pointer data, int datalen, int padlen, int futurelen)
+                       int category, pointer data, int datalen, int padlen,
+                       int futurelen)
 {
     CARD32 elemHeaderData[2];
     int numElemHeaders = 0;
@@ -300,121 +290,112 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
     Bool gotServerTime = FALSE;
     int replylen;
 
-    if (futurelen >= 0)
-    { /* start of new protocol element */
-	xRecordEnableContextReply *pRep = (xRecordEnableContextReply *)
-							pContext->replyBuffer;
-	if (pContext->pBufClient != pClient ||
-	    pContext->bufCategory != category)
-	{
-	    RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
-	    pContext->pBufClient = pClient;
-	    pContext->bufCategory = category;
-	}
-
-	if (!pContext->numBufBytes)
-	{
-	    serverTime = GetTimeInMillis();
-	    gotServerTime = TRUE;
-	    pRep->type          = X_Reply;
-	    pRep->category      = category;
-	    pRep->sequenceNumber = pContext->pRecordingClient->sequence;
-	    pRep->length        = 0;
-	    pRep->elementHeader = pContext->elemHeaders;
-	    pRep->serverTime    = serverTime;
-	    if (pClient)
-	    {
-		pRep->clientSwapped =
-				(pClient->swapped != recordingClientSwapped);
-		pRep->idBase = pClient->clientAsMask;
-		pRep->recordedSequenceNumber = pClient->sequence;
-	    }
-	    else /* it's a device event, StartOfData, or EndOfData */
-	    {
-		pRep->clientSwapped = (category != XRecordFromServer) && 
-						recordingClientSwapped;
-		pRep->idBase = 0;
-		pRep->recordedSequenceNumber = 0;
-	    }
-
-	    if (recordingClientSwapped)
-	    {
-		swaps(&pRep->sequenceNumber);
-		swapl(&pRep->length);
-		swapl(&pRep->idBase);
-		swapl(&pRep->serverTime);
-		swapl(&pRep->recordedSequenceNumber);
-	    }
-	    pContext->numBufBytes = SIZEOF(xRecordEnableContextReply);
-	}
-
-	/* generate element headers if needed */
-
-	if ( ( (pContext->elemHeaders & XRecordFromClientTime)
-	      && category == XRecordFromClient)
-	    ||
-	    ( (pContext->elemHeaders & XRecordFromServerTime)
-	     && category == XRecordFromServer))
-	{
-	    if (gotServerTime)
-		elemHeaderData[numElemHeaders] = serverTime;
-	    else
-		elemHeaderData[numElemHeaders] = GetTimeInMillis();
-	    if (recordingClientSwapped)
-		swapl(&elemHeaderData[numElemHeaders]);
-	    numElemHeaders++;
-	}
-
-	if ( (pContext->elemHeaders & XRecordFromClientSequence)
-	    &&
-	    (category == XRecordFromClient || category == XRecordClientDied))
-	{
-	    elemHeaderData[numElemHeaders] = pClient->sequence;
-	    if (recordingClientSwapped)
-		swapl(&elemHeaderData[numElemHeaders]);
-	    numElemHeaders++;
-	}
-
-	/* adjust reply length */
-
-	replylen = pRep->length;
-	if (recordingClientSwapped) swapl(&replylen);
-	replylen += numElemHeaders + bytes_to_int32(datalen) +
+    if (futurelen >= 0) {       /* start of new protocol element */
+        xRecordEnableContextReply *pRep = (xRecordEnableContextReply *)
+            pContext->replyBuffer;
+
+        if (pContext->pBufClient != pClient ||
+            pContext->bufCategory != category) {
+            RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
+            pContext->pBufClient = pClient;
+            pContext->bufCategory = category;
+        }
+
+        if (!pContext->numBufBytes) {
+            serverTime = GetTimeInMillis();
+            gotServerTime = TRUE;
+            pRep->type = X_Reply;
+            pRep->category = category;
+            pRep->sequenceNumber = pContext->pRecordingClient->sequence;
+            pRep->length = 0;
+            pRep->elementHeader = pContext->elemHeaders;
+            pRep->serverTime = serverTime;
+            if (pClient) {
+                pRep->clientSwapped =
+                    (pClient->swapped != recordingClientSwapped);
+                pRep->idBase = pClient->clientAsMask;
+                pRep->recordedSequenceNumber = pClient->sequence;
+            }
+            else {              /* it's a device event, StartOfData, or EndOfData */
+
+                pRep->clientSwapped = (category != XRecordFromServer) &&
+                    recordingClientSwapped;
+                pRep->idBase = 0;
+                pRep->recordedSequenceNumber = 0;
+            }
+
+            if (recordingClientSwapped) {
+                swaps(&pRep->sequenceNumber);
+                swapl(&pRep->length);
+                swapl(&pRep->idBase);
+                swapl(&pRep->serverTime);
+                swapl(&pRep->recordedSequenceNumber);
+            }
+            pContext->numBufBytes = SIZEOF(xRecordEnableContextReply);
+        }
+
+        /* generate element headers if needed */
+
+        if (((pContext->elemHeaders & XRecordFromClientTime)
+             && category == XRecordFromClient)
+            || ((pContext->elemHeaders & XRecordFromServerTime)
+                && category == XRecordFromServer)) {
+            if (gotServerTime)
+                elemHeaderData[numElemHeaders] = serverTime;
+            else
+                elemHeaderData[numElemHeaders] = GetTimeInMillis();
+            if (recordingClientSwapped)
+                swapl(&elemHeaderData[numElemHeaders]);
+            numElemHeaders++;
+        }
+
+        if ((pContext->elemHeaders & XRecordFromClientSequence)
+            && (category == XRecordFromClient || category == XRecordClientDied)) {
+            elemHeaderData[numElemHeaders] = pClient->sequence;
+            if (recordingClientSwapped)
+                swapl(&elemHeaderData[numElemHeaders]);
+            numElemHeaders++;
+        }
+
+        /* adjust reply length */
+
+        replylen = pRep->length;
+        if (recordingClientSwapped)
+            swapl(&replylen);
+        replylen += numElemHeaders + bytes_to_int32(datalen) +
             bytes_to_int32(futurelen);
-	if (recordingClientSwapped) swapl(&replylen);
-	pRep->length = replylen;
-    } /* end if not continued reply */
+        if (recordingClientSwapped)
+            swapl(&replylen);
+        pRep->length = replylen;
+    }                           /* end if not continued reply */
 
     numElemHeaders *= 4;
 
     /* if space available >= space needed, buffer the data */
 
-    if (REPLY_BUF_SIZE - pContext->numBufBytes >= datalen + numElemHeaders)
-    {
-	if (numElemHeaders)
-	{
-	    memcpy(pContext->replyBuffer + pContext->numBufBytes,
-		   elemHeaderData, numElemHeaders);
-	    pContext->numBufBytes += numElemHeaders;
-	}
-	if (datalen)
-	{
-	    static char padBuffer[3]; /* as in FlushClient */
-	    memcpy(pContext->replyBuffer + pContext->numBufBytes,
-		   data, datalen - padlen);
-	    pContext->numBufBytes += datalen - padlen;
-	    memcpy(pContext->replyBuffer + pContext->numBufBytes,
-		   padBuffer, padlen);
-	    pContext->numBufBytes += padlen;
-	}
+    if (REPLY_BUF_SIZE - pContext->numBufBytes >= datalen + numElemHeaders) {
+        if (numElemHeaders) {
+            memcpy(pContext->replyBuffer + pContext->numBufBytes,
+                   elemHeaderData, numElemHeaders);
+            pContext->numBufBytes += numElemHeaders;
+        }
+        if (datalen) {
+            static char padBuffer[3];   /* as in FlushClient */
+
+            memcpy(pContext->replyBuffer + pContext->numBufBytes,
+                   data, datalen - padlen);
+            pContext->numBufBytes += datalen - padlen;
+            memcpy(pContext->replyBuffer + pContext->numBufBytes,
+                   padBuffer, padlen);
+            pContext->numBufBytes += padlen;
+        }
     }
-    else
-    {
-	RecordFlushReplyBuffer(pContext, (pointer)elemHeaderData,
-			       numElemHeaders, (pointer)data, datalen - padlen);
+    else {
+        RecordFlushReplyBuffer(pContext, (pointer) elemHeaderData,
+                               numElemHeaders, (pointer) data,
+                               datalen - padlen);
     }
-} /* RecordAProtocolElement */
-
+}                               /* RecordAProtocolElement */
 
 /* RecordFindClientOnContext
  *
@@ -434,30 +415,24 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
  * Side Effects: none.
  */
 static RecordClientsAndProtocolPtr
-RecordFindClientOnContext(
-    RecordContextPtr pContext,
-    XID clientspec,
-    int *pposition
-)
+RecordFindClientOnContext(RecordContextPtr pContext,
+                          XID clientspec, int *pposition)
 {
     RecordClientsAndProtocolPtr pRCAP;
 
-    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
-    {
-	int i;
-	for (i = 0; i < pRCAP->numClients; i++)
-	{
-	    if (pRCAP->pClientIDs[i] == clientspec)
-	    {
-		if (pposition)
-		    *pposition = i;
-		return pRCAP;
-	    }
-	}
+    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP) {
+        int i;
+
+        for (i = 0; i < pRCAP->numClients; i++) {
+            if (pRCAP->pClientIDs[i] == clientspec) {
+                if (pposition)
+                    *pposition = i;
+                return pRCAP;
+            }
+        }
     }
     return NULL;
-} /* RecordFindClientOnContext */
-
+}                               /* RecordFindClientOnContext */
 
 /* RecordABigRequest
  *
@@ -475,7 +450,7 @@ RecordFindClientOnContext(
  * Note: this function exists mainly to make RecordARequest smaller.
  */
 static void
-RecordABigRequest(RecordContextPtr pContext, ClientPtr client, xReq *stuff)
+RecordABigRequest(RecordContextPtr pContext, ClientPtr client, xReq * stuff)
 {
     CARD32 bigLength;
     int bytesLeft;
@@ -489,21 +464,22 @@ RecordABigRequest(RecordContextPtr pContext, ClientPtr client, xReq *stuff)
     /* record the request header */
     bytesLeft = client->req_len << 2;
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-			   (pointer)stuff, SIZEOF(xReq), 0, bytesLeft);
+                           (pointer) stuff, SIZEOF(xReq), 0, bytesLeft);
 
     /* reinsert the extended length field that was squished out */
     bigLength = client->req_len + bytes_to_int32(sizeof(bigLength));
     if (client->swapped)
-	swapl(&bigLength);
+        swapl(&bigLength);
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-               (pointer)&bigLength, sizeof(bigLength), 0, /* continuation */ -1);
+                           (pointer) &bigLength, sizeof(bigLength), 0,
+                           /* continuation */ -1);
     bytesLeft -= sizeof(bigLength);
 
     /* record the rest of the request after the length */
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-               (pointer)(stuff + 1), bytesLeft, 0, /* continuation */ -1);
-} /* RecordABigRequest */
-
+                           (pointer) (stuff + 1), bytesLeft, 0,
+                           /* continuation */ -1);
+}                               /* RecordABigRequest */
 
 /* RecordARequest
  *
@@ -529,60 +505,57 @@ RecordARequest(ClientPtr client)
     RecordClientsAndProtocolPtr pRCAP;
     int i;
     RecordClientPrivatePtr pClientPriv;
+
     REQUEST(xReq);
     int majorop;
 
     majorop = stuff->reqType;
-    for (i = 0; i < numEnabledContexts; i++)
-    {
-	pContext = ppAllContexts[i];
-	pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask,
-					  NULL);
-	if (pRCAP && pRCAP->pRequestMajorOpSet &&
-	    RecordIsMemberOfSet(pRCAP->pRequestMajorOpSet, majorop))
-	{
-	    if (majorop <= 127)
-	    { /* core request */
-
-		if (stuff->length == 0)
-		    RecordABigRequest(pContext, client, stuff);
-		else
-		    RecordAProtocolElement(pContext, client, XRecordFromClient,
-				(pointer)stuff, client->req_len << 2, 0, 0);
-	    }
-	    else /* extension, check minor opcode */
-	    {
-		int minorop = client->minorOp;
-		int numMinOpInfo;
-		RecordMinorOpPtr pMinorOpInfo = pRCAP->pRequestMinOpInfo;
-
-		assert (pMinorOpInfo);
-		numMinOpInfo = pMinorOpInfo->count;
-		pMinorOpInfo++;
-		assert (numMinOpInfo);
-		for ( ; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++)
-		{
-		    if (majorop >= pMinorOpInfo->major.first &&
-			majorop <= pMinorOpInfo->major.last &&
-			RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
-					    minorop))
-		    {
-			if (stuff->length == 0)
-			    RecordABigRequest(pContext, client, stuff);
-			else
-			    RecordAProtocolElement(pContext, client, 
-					XRecordFromClient, (pointer)stuff,
-					client->req_len << 2, 0, 0);
-			break;
-		    }			    
-		} /* end for each minor op info */
-	    } /* end extension request */
-	} /* end this RCAP wants this major opcode */
-    } /* end for each context */
+    for (i = 0; i < numEnabledContexts; i++) {
+        pContext = ppAllContexts[i];
+        pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask, NULL);
+        if (pRCAP && pRCAP->pRequestMajorOpSet &&
+            RecordIsMemberOfSet(pRCAP->pRequestMajorOpSet, majorop)) {
+            if (majorop <= 127) {       /* core request */
+
+                if (stuff->length == 0)
+                    RecordABigRequest(pContext, client, stuff);
+                else
+                    RecordAProtocolElement(pContext, client, XRecordFromClient,
+                                           (pointer) stuff,
+                                           client->req_len << 2, 0, 0);
+            }
+            else {              /* extension, check minor opcode */
+
+                int minorop = client->minorOp;
+                int numMinOpInfo;
+                RecordMinorOpPtr pMinorOpInfo = pRCAP->pRequestMinOpInfo;
+
+                assert(pMinorOpInfo);
+                numMinOpInfo = pMinorOpInfo->count;
+                pMinorOpInfo++;
+                assert(numMinOpInfo);
+                for (; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++) {
+                    if (majorop >= pMinorOpInfo->major.first &&
+                        majorop <= pMinorOpInfo->major.last &&
+                        RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
+                                            minorop)) {
+                        if (stuff->length == 0)
+                            RecordABigRequest(pContext, client, stuff);
+                        else
+                            RecordAProtocolElement(pContext, client,
+                                                   XRecordFromClient,
+                                                   (pointer) stuff,
+                                                   client->req_len << 2, 0, 0);
+                        break;
+                    }
+                }               /* end for each minor op info */
+            }                   /* end extension request */
+        }                       /* end this RCAP wants this major opcode */
+    }                           /* end for each context */
     pClientPriv = RecordClientPrivate(client);
     assert(pClientPriv);
-    return (* pClientPriv->originalVector[majorop])(client);
-} /* RecordARequest */
+    return (*pClientPriv->originalVector[majorop]) (client);
+}                               /* RecordARequest */
 
 /* RecordAReply
  *
@@ -609,65 +582,63 @@ RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
     RecordContextPtr pContext;
     RecordClientsAndProtocolPtr pRCAP;
     int eci;
-    ReplyInfoRec *pri = (ReplyInfoRec *)calldata;
+    ReplyInfoRec *pri = (ReplyInfoRec *) calldata;
     ClientPtr client = pri->client;
 
-    for (eci = 0; eci < numEnabledContexts; eci++)
-    {
-	pContext = ppAllContexts[eci];
-	pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask,
-					  NULL);
-	if (pRCAP)
-	{
-	    int majorop = client->majorOp;
-	    if (pContext->continuedReply)
-	    {
-		RecordAProtocolElement(pContext, client, XRecordFromServer,
-		   (pointer)pri->replyData, pri->dataLenBytes,
-			    pri->padBytes, /* continuation */ -1);
-		if (!pri->bytesRemaining)
-		    pContext->continuedReply = 0;
-	    }
-	    else if (pri->startOfReply && pRCAP->pReplyMajorOpSet &&
-		     RecordIsMemberOfSet(pRCAP->pReplyMajorOpSet, majorop))
-	    {
-		if (majorop <= 127)
-		{ /* core reply */
-		    RecordAProtocolElement(pContext, client, XRecordFromServer,
-		       (pointer)pri->replyData, pri->dataLenBytes, 0, pri->bytesRemaining);
-		    if (pri->bytesRemaining)
-			pContext->continuedReply = 1;
-		}
-		else /* extension, check minor opcode */
-		{
-		    int minorop = client->minorOp;
-		    int numMinOpInfo;
-		    RecordMinorOpPtr pMinorOpInfo = pRCAP->pReplyMinOpInfo;
-		    		    assert (pMinorOpInfo);
-		    numMinOpInfo = pMinorOpInfo->count;
-		    pMinorOpInfo++;
-		    assert (numMinOpInfo);
-		    for ( ; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++)
-		    {
-			if (majorop >= pMinorOpInfo->major.first &&
-			    majorop <= pMinorOpInfo->major.last &&
-			    RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
-						minorop))
-			{
-			    RecordAProtocolElement(pContext, client, 
-				XRecordFromServer, (pointer)pri->replyData,
-				pri->dataLenBytes, 0, pri->bytesRemaining);
-			    if (pri->bytesRemaining)
-				pContext->continuedReply = 1;
-			    break;
-			}			    
-		    } /* end for each minor op info */
-		} /* end extension reply */
-	    } /* end continued reply vs. start of reply */
-	} /* end client is registered on this context */
-    } /* end for each context */
-} /* RecordAReply */
-
+    for (eci = 0; eci < numEnabledContexts; eci++) {
+        pContext = ppAllContexts[eci];
+        pRCAP = RecordFindClientOnContext(pContext, client->clientAsMask, NULL);
+        if (pRCAP) {
+            int majorop = client->majorOp;
+
+            if (pContext->continuedReply) {
+                RecordAProtocolElement(pContext, client, XRecordFromServer,
+                                       (pointer) pri->replyData,
+                                       pri->dataLenBytes, pri->padBytes,
+                                       /* continuation */ -1);
+                if (!pri->bytesRemaining)
+                    pContext->continuedReply = 0;
+            }
+            else if (pri->startOfReply && pRCAP->pReplyMajorOpSet &&
+                     RecordIsMemberOfSet(pRCAP->pReplyMajorOpSet, majorop)) {
+                if (majorop <= 127) {   /* core reply */
+                    RecordAProtocolElement(pContext, client, XRecordFromServer,
+                                           (pointer) pri->replyData,
+                                           pri->dataLenBytes, 0,
+                                           pri->bytesRemaining);
+                    if (pri->bytesRemaining)
+                        pContext->continuedReply = 1;
+                }
+                else {          /* extension, check minor opcode */
+
+                    int minorop = client->minorOp;
+                    int numMinOpInfo;
+                    RecordMinorOpPtr pMinorOpInfo = pRCAP->pReplyMinOpInfo;
+
+                    assert(pMinorOpInfo);
+                    numMinOpInfo = pMinorOpInfo->count;
+                    pMinorOpInfo++;
+                    assert(numMinOpInfo);
+                    for (; numMinOpInfo; numMinOpInfo--, pMinorOpInfo++) {
+                        if (majorop >= pMinorOpInfo->major.first &&
+                            majorop <= pMinorOpInfo->major.last &&
+                            RecordIsMemberOfSet(pMinorOpInfo->major.pMinOpSet,
+                                                minorop)) {
+                            RecordAProtocolElement(pContext, client,
+                                                   XRecordFromServer,
+                                                   (pointer) pri->replyData,
+                                                   pri->dataLenBytes, 0,
+                                                   pri->bytesRemaining);
+                            if (pri->bytesRemaining)
+                                pContext->continuedReply = 1;
+                            break;
+                        }
+                    }           /* end for each minor op info */
+                }               /* end extension reply */
+            }                   /* end continued reply vs. start of reply */
+        }                       /* end client is registered on this context */
+    }                           /* end for each context */
+}                               /* RecordAReply */
 
 /* RecordADeliveredEventOrError
  *
@@ -685,109 +656,101 @@ RecordAReply(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
  *	it for this client.
  */
 static void
-RecordADeliveredEventOrError(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
+RecordADeliveredEventOrError(CallbackListPtr *pcbl, pointer nulldata,
+                             pointer calldata)
 {
-    EventInfoRec *pei = (EventInfoRec *)calldata;
+    EventInfoRec *pei = (EventInfoRec *) calldata;
     RecordContextPtr pContext;
     RecordClientsAndProtocolPtr pRCAP;
-    int eci; /* enabled context index */
+    int eci;                    /* enabled context index */
     ClientPtr pClient = pei->client;
 
-    for (eci = 0; eci < numEnabledContexts; eci++)
-    {
-	pContext = ppAllContexts[eci];
-	pRCAP = RecordFindClientOnContext(pContext, pClient->clientAsMask,
-					  NULL);
-	if (pRCAP && (pRCAP->pDeliveredEventSet || pRCAP->pErrorSet))
-	{
-	    int ev; /* event index */
-	    xEvent *pev = pei->events;
-	    for (ev = 0; ev < pei->count; ev++, pev++)
-	    {
-		int recordit = 0;
-		if (pRCAP->pErrorSet)
-		{
-		    recordit = RecordIsMemberOfSet(pRCAP->pErrorSet,
-						((xError *)(pev))->errorCode);
-		}
-		else if (pRCAP->pDeliveredEventSet)
-		{
-		    recordit = RecordIsMemberOfSet(pRCAP->pDeliveredEventSet,
-						   pev->u.u.type & 0177);
-		}
-		if (recordit)
-		{
-		    xEvent swappedEvent;
-		    xEvent *pEvToRecord = pev;
-
-		    if (pClient->swapped)
-		    {
-			(*EventSwapVector[pev->u.u.type & 0177])
-			    (pev, &swappedEvent);
-			pEvToRecord = &swappedEvent;
-			
-		    }
-		    RecordAProtocolElement(pContext, pClient,
-			XRecordFromServer, pEvToRecord, SIZEOF(xEvent), 0, 0);
-		}
-	    } /* end for each event */
-	} /* end this client is on this context */
-    } /* end for each enabled context */
-} /* RecordADeliveredEventOrError */
-
+    for (eci = 0; eci < numEnabledContexts; eci++) {
+        pContext = ppAllContexts[eci];
+        pRCAP = RecordFindClientOnContext(pContext, pClient->clientAsMask,
+                                          NULL);
+        if (pRCAP && (pRCAP->pDeliveredEventSet || pRCAP->pErrorSet)) {
+            int ev;             /* event index */
+            xEvent *pev = pei->events;
+
+            for (ev = 0; ev < pei->count; ev++, pev++) {
+                int recordit = 0;
+
+                if (pRCAP->pErrorSet) {
+                    recordit = RecordIsMemberOfSet(pRCAP->pErrorSet,
+                                                   ((xError *) (pev))->
+                                                   errorCode);
+                }
+                else if (pRCAP->pDeliveredEventSet) {
+                    recordit = RecordIsMemberOfSet(pRCAP->pDeliveredEventSet,
+                                                   pev->u.u.type & 0177);
+                }
+                if (recordit) {
+                    xEvent swappedEvent;
+                    xEvent *pEvToRecord = pev;
+
+                    if (pClient->swapped) {
+                        (*EventSwapVector[pev->u.u.type & 0177])
+                            (pev, &swappedEvent);
+                        pEvToRecord = &swappedEvent;
+
+                    }
+                    RecordAProtocolElement(pContext, pClient,
+                                           XRecordFromServer, pEvToRecord,
+                                           SIZEOF(xEvent), 0, 0);
+                }
+            }                   /* end for each event */
+        }                       /* end this client is on this context */
+    }                           /* end for each enabled context */
+}                               /* RecordADeliveredEventOrError */
 
 static void
 RecordSendProtocolEvents(RecordClientsAndProtocolPtr pRCAP,
-			RecordContextPtr pContext,
-			xEvent* pev, int count)
+                         RecordContextPtr pContext, xEvent *pev, int count)
 {
-    int ev; /* event index */
-
-    for (ev = 0; ev < count; ev++, pev++)
-    {
-	if (RecordIsMemberOfSet(pRCAP->pDeviceEventSet,
-		    pev->u.u.type & 0177))
-	{
-	    xEvent swappedEvent;
-	    xEvent *pEvToRecord = pev;
+    int ev;                     /* event index */
+
+    for (ev = 0; ev < count; ev++, pev++) {
+        if (RecordIsMemberOfSet(pRCAP->pDeviceEventSet, pev->u.u.type & 0177)) {
+            xEvent swappedEvent;
+            xEvent *pEvToRecord = pev;
+
 #ifdef PANORAMIX
-	    xEvent shiftedEvent;
-
-	    if (!noPanoramiXExtension &&
-		    (pev->u.u.type == MotionNotify ||
-		     pev->u.u.type == ButtonPress ||
-		     pev->u.u.type == ButtonRelease ||
-		     pev->u.u.type == KeyPress ||
-		     pev->u.u.type == KeyRelease)) {
-		int scr = XineramaGetCursorScreen(inputInfo.pointer);
-		memcpy(&shiftedEvent, pev, sizeof(xEvent));
-		shiftedEvent.u.keyButtonPointer.rootX +=
-		    screenInfo.screens[scr]->x -
-		    screenInfo.screens[0]->x;
-		shiftedEvent.u.keyButtonPointer.rootY +=
-		    screenInfo.screens[scr]->y -
-		    screenInfo.screens[0]->y;
-		pEvToRecord = &shiftedEvent;
-	    }
-#endif /* PANORAMIX */
-
-	    if (pContext->pRecordingClient->swapped)
-	    {
-		(*EventSwapVector[pEvToRecord->u.u.type & 0177])
-		    (pEvToRecord, &swappedEvent);
-		pEvToRecord = &swappedEvent;
-	    }
-
-	    RecordAProtocolElement(pContext, NULL,
-		    XRecordFromServer,  pEvToRecord, SIZEOF(xEvent), 0, 0);
-	    /* make sure device events get flushed in the absence
-	     * of other client activity
-	     */
-	    SetCriticalOutputPending();
-	}
-    } /* end for each event */
-
-} /* RecordADeviceEvent */
+            xEvent shiftedEvent;
+
+            if (!noPanoramiXExtension &&
+                (pev->u.u.type == MotionNotify ||
+                 pev->u.u.type == ButtonPress ||
+                 pev->u.u.type == ButtonRelease ||
+                 pev->u.u.type == KeyPress || pev->u.u.type == KeyRelease)) {
+                int scr = XineramaGetCursorScreen(inputInfo.pointer);
+
+                memcpy(&shiftedEvent, pev, sizeof(xEvent));
+                shiftedEvent.u.keyButtonPointer.rootX +=
+                    screenInfo.screens[scr]->x - screenInfo.screens[0]->x;
+                shiftedEvent.u.keyButtonPointer.rootY +=
+                    screenInfo.screens[scr]->y - screenInfo.screens[0]->y;
+                pEvToRecord = &shiftedEvent;
+            }
+#endif                          /* PANORAMIX */
+
+            if (pContext->pRecordingClient->swapped) {
+                (*EventSwapVector[pEvToRecord->u.u.type & 0177])
+                    (pEvToRecord, &swappedEvent);
+                pEvToRecord = &swappedEvent;
+            }
+
+            RecordAProtocolElement(pContext, NULL,
+                                   XRecordFromServer, pEvToRecord,
+                                   SIZEOF(xEvent), 0, 0);
+            /* make sure device events get flushed in the absence
+             * of other client activity
+             */
+            SetCriticalOutputPending();
+        }
+    }                           /* end for each event */
+
+}                               /* RecordADeviceEvent */
 
 /* RecordADeviceEvent
  *
@@ -806,40 +769,36 @@ RecordSendProtocolEvents(RecordClientsAndProtocolPtr pRCAP,
 static void
 RecordADeviceEvent(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
 {
-    DeviceEventInfoRec *pei = (DeviceEventInfoRec *)calldata;
+    DeviceEventInfoRec *pei = (DeviceEventInfoRec *) calldata;
     RecordContextPtr pContext;
     RecordClientsAndProtocolPtr pRCAP;
-    int eci; /* enabled context index */
-
-    for (eci = 0; eci < numEnabledContexts; eci++)
-    {
-	pContext = ppAllContexts[eci];
-	for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
-	{
-	    if (pRCAP->pDeviceEventSet)
-	    {
-		int count;
-		xEvent *xi_events = NULL;
-
-		/* TODO check return values */
-		if (IsMaster(pei->device))
-		{
-		    xEvent *core_events;
-		    EventToCore(pei->event, &core_events, &count);
-		    RecordSendProtocolEvents(pRCAP, pContext, core_events,
+    int eci;                    /* enabled context index */
+
+    for (eci = 0; eci < numEnabledContexts; eci++) {
+        pContext = ppAllContexts[eci];
+        for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP) {
+            if (pRCAP->pDeviceEventSet) {
+                int count;
+                xEvent *xi_events = NULL;
+
+                /* TODO check return values */
+                if (IsMaster(pei->device)) {
+                    xEvent *core_events;
+
+                    EventToCore(pei->event, &core_events, &count);
+                    RecordSendProtocolEvents(pRCAP, pContext, core_events,
                                              count);
-		    free(core_events);
-		}
-
-		EventToXI(pei->event, &xi_events, &count);
-		RecordSendProtocolEvents(pRCAP, pContext, xi_events, count);
-		free(xi_events);
-	    } /* end this RCAP selects device events */
-	} /* end for each RCAP on this context */
-    } /* end for each enabled context */
+                    free(core_events);
+                }
+
+                EventToXI(pei->event, &xi_events, &count);
+                RecordSendProtocolEvents(pRCAP, pContext, xi_events, count);
+                free(xi_events);
+            }                   /* end this RCAP selects device events */
+        }                       /* end for each RCAP on this context */
+    }                           /* end for each enabled context */
 }
 
-
 /* RecordFlushAllContexts
  *
  * Arguments:
@@ -853,29 +812,24 @@ RecordADeviceEvent(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
  *	the recording clients.
  */
 static void
-RecordFlushAllContexts(
-    CallbackListPtr *pcbl,
-    pointer nulldata,
-    pointer calldata
-)
+RecordFlushAllContexts(CallbackListPtr *pcbl,
+                       pointer nulldata, pointer calldata)
 {
-    int eci; /* enabled context index */
+    int eci;                    /* enabled context index */
     RecordContextPtr pContext;
 
-    for (eci = 0; eci < numEnabledContexts; eci++)
-    {
-	pContext = ppAllContexts[eci];
-
-	/* In most cases we leave it to RecordFlushReplyBuffer to make
-	 * this check, but this function could be called very often, so we
-	 * check before calling hoping to save the function call cost
-	 * most of the time.
-	 */
-	if (pContext->numBufBytes)
-	    RecordFlushReplyBuffer(ppAllContexts[eci], NULL, 0, NULL, 0);
-    }
-} /* RecordFlushAllContexts */
+    for (eci = 0; eci < numEnabledContexts; eci++) {
+        pContext = ppAllContexts[eci];
 
+        /* In most cases we leave it to RecordFlushReplyBuffer to make
+         * this check, but this function could be called very often, so we
+         * check before calling hoping to save the function call cost
+         * most of the time.
+         */
+        if (pContext->numBufBytes)
+            RecordFlushReplyBuffer(ppAllContexts[eci], NULL, 0, NULL, 0);
+    }
+}                               /* RecordFlushAllContexts */
 
 /* RecordInstallHooks
  *
@@ -902,70 +856,65 @@ RecordInstallHooks(RecordClientsAndProtocolPtr pRCAP, XID oneclient)
     XID client;
 
     if (oneclient)
-	client = oneclient;
+        client = oneclient;
     else
-	client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
-
-    while (client)
-    {
-	if (client != XRecordFutureClients)
-	{
-	    if (pRCAP->pRequestMajorOpSet)
-	    {
-		RecordSetIteratePtr pIter = NULL;
-		RecordSetInterval interval;
-		ClientPtr pClient = clients[CLIENT_ID(client)];
-
-		if (pClient && !RecordClientPrivate(pClient))
-		{
-		    RecordClientPrivatePtr pClientPriv;
-		    /* no Record proc vector; allocate one */
-		    pClientPriv = (RecordClientPrivatePtr)
-				malloc(sizeof(RecordClientPrivateRec));
-		    if (!pClientPriv)
-			return BadAlloc;
-		    /* copy old proc vector to new */
-		    memcpy(pClientPriv->recordVector, pClient->requestVector, 
-			   sizeof (pClientPriv->recordVector));
-		    pClientPriv->originalVector = pClient->requestVector;
-		    dixSetPrivate(&pClient->devPrivates,
-				  RecordClientPrivateKey, pClientPriv);
-		    pClient->requestVector = pClientPriv->recordVector;
-		}
-		while ((pIter = RecordIterateSet(pRCAP->pRequestMajorOpSet,
-						pIter, &interval)))
-		{
-		    unsigned int j;
-		    for (j = interval.first; j <= interval.last; j++)
-			pClient->requestVector[j] = RecordARequest;
-		}
-	    }
-	}
-	if (oneclient)
-	    client = 0;
-	else
-	    client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
+        client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
+
+    while (client) {
+        if (client != XRecordFutureClients) {
+            if (pRCAP->pRequestMajorOpSet) {
+                RecordSetIteratePtr pIter = NULL;
+                RecordSetInterval interval;
+                ClientPtr pClient = clients[CLIENT_ID(client)];
+
+                if (pClient && !RecordClientPrivate(pClient)) {
+                    RecordClientPrivatePtr pClientPriv;
+
+                    /* no Record proc vector; allocate one */
+                    pClientPriv = (RecordClientPrivatePtr)
+                        malloc(sizeof(RecordClientPrivateRec));
+                    if (!pClientPriv)
+                        return BadAlloc;
+                    /* copy old proc vector to new */
+                    memcpy(pClientPriv->recordVector, pClient->requestVector,
+                           sizeof(pClientPriv->recordVector));
+                    pClientPriv->originalVector = pClient->requestVector;
+                    dixSetPrivate(&pClient->devPrivates,
+                                  RecordClientPrivateKey, pClientPriv);
+                    pClient->requestVector = pClientPriv->recordVector;
+                }
+                while ((pIter = RecordIterateSet(pRCAP->pRequestMajorOpSet,
+                                                 pIter, &interval))) {
+                    unsigned int j;
+
+                    for (j = interval.first; j <= interval.last; j++)
+                        pClient->requestVector[j] = RecordARequest;
+                }
+            }
+        }
+        if (oneclient)
+            client = 0;
+        else
+            client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
     }
 
     assert(numEnabledRCAPs >= 0);
-    if (!oneclient && ++numEnabledRCAPs == 1)
-    { /* we're enabling the first context */
-	if (!AddCallback(&EventCallback, RecordADeliveredEventOrError, NULL))
-	    return BadAlloc;
-	if (!AddCallback(&DeviceEventCallback, RecordADeviceEvent, NULL))
-	    return BadAlloc;
-	if (!AddCallback(&ReplyCallback, RecordAReply, NULL))
-	    return BadAlloc;
-	if (!AddCallback(&FlushCallback, RecordFlushAllContexts, NULL))
-	    return BadAlloc;
-	/* Alternate context flushing scheme: delete the line above
-	 * and call RegisterBlockAndWakeupHandlers here passing
-	 * RecordFlushAllContexts.  Is this any better?
-	 */
+    if (!oneclient && ++numEnabledRCAPs == 1) { /* we're enabling the first context */
+        if (!AddCallback(&EventCallback, RecordADeliveredEventOrError, NULL))
+            return BadAlloc;
+        if (!AddCallback(&DeviceEventCallback, RecordADeviceEvent, NULL))
+            return BadAlloc;
+        if (!AddCallback(&ReplyCallback, RecordAReply, NULL))
+            return BadAlloc;
+        if (!AddCallback(&FlushCallback, RecordFlushAllContexts, NULL))
+            return BadAlloc;
+        /* Alternate context flushing scheme: delete the line above
+         * and call RegisterBlockAndWakeupHandlers here passing
+         * RecordFlushAllContexts.  Is this any better?
+         */
     }
     return Success;
-} /* RecordInstallHooks */
-
+}                               /* RecordInstallHooks */
 
 /* RecordUninstallHooks
  *
@@ -992,82 +941,75 @@ RecordUninstallHooks(RecordClientsAndProtocolPtr pRCAP, XID oneclient)
     XID client;
 
     if (oneclient)
-	client = oneclient;
+        client = oneclient;
     else
-	client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
-
-    while (client)
-    {
-	if (client != XRecordFutureClients)
-	{
-	    if (pRCAP->pRequestMajorOpSet)
-	    {
-		ClientPtr pClient = clients[CLIENT_ID(client)];
-		int c;
-		Bool otherRCAPwantsProcVector = FALSE;
-		RecordClientPrivatePtr pClientPriv = NULL;
-
-		assert (pClient);
-		pClientPriv = RecordClientPrivate(pClient);
-		assert (pClientPriv);
-		memcpy(pClientPriv->recordVector, pClientPriv->originalVector,
-		       sizeof (pClientPriv->recordVector));
-
-		for (c = 0; c < numEnabledContexts; c++)
-		{
-		    RecordClientsAndProtocolPtr pOtherRCAP;
-		    RecordContextPtr pContext = ppAllContexts[c];
-
-		    if (pContext == pRCAP->pContext) continue;
-		    pOtherRCAP = RecordFindClientOnContext(pContext, client,
-							   NULL);
-		    if (pOtherRCAP && pOtherRCAP->pRequestMajorOpSet)
-		    {
-			RecordSetIteratePtr pIter = NULL;
-			RecordSetInterval interval;
-
-			otherRCAPwantsProcVector = TRUE;
-			while ((pIter = RecordIterateSet(
-						pOtherRCAP->pRequestMajorOpSet,
-						pIter, &interval)))
-			{
-			    unsigned int j;
-			    for (j = interval.first; j <= interval.last; j++)
-				pClient->requestVector[j] = RecordARequest;
-			}
-		    }
-		}
-		if (!otherRCAPwantsProcVector)
-		{ /* nobody needs it, so free it */
-		    pClient->requestVector = pClientPriv->originalVector;
-		    dixSetPrivate(&pClient->devPrivates,
-				  RecordClientPrivateKey, NULL);
-		    free(pClientPriv);
-		}
-	    } /* end if this RCAP specifies any requests */
-	} /* end if not future clients */
-	if (oneclient)
-	    client = 0;
-	else
-	    client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
+        client = pRCAP->numClients ? pRCAP->pClientIDs[i++] : 0;
+
+    while (client) {
+        if (client != XRecordFutureClients) {
+            if (pRCAP->pRequestMajorOpSet) {
+                ClientPtr pClient = clients[CLIENT_ID(client)];
+                int c;
+                Bool otherRCAPwantsProcVector = FALSE;
+                RecordClientPrivatePtr pClientPriv = NULL;
+
+                assert(pClient);
+                pClientPriv = RecordClientPrivate(pClient);
+                assert(pClientPriv);
+                memcpy(pClientPriv->recordVector, pClientPriv->originalVector,
+                       sizeof(pClientPriv->recordVector));
+
+                for (c = 0; c < numEnabledContexts; c++) {
+                    RecordClientsAndProtocolPtr pOtherRCAP;
+                    RecordContextPtr pContext = ppAllContexts[c];
+
+                    if (pContext == pRCAP->pContext)
+                        continue;
+                    pOtherRCAP = RecordFindClientOnContext(pContext, client,
+                                                           NULL);
+                    if (pOtherRCAP && pOtherRCAP->pRequestMajorOpSet) {
+                        RecordSetIteratePtr pIter = NULL;
+                        RecordSetInterval interval;
+
+                        otherRCAPwantsProcVector = TRUE;
+                        while ((pIter =
+                                RecordIterateSet(pOtherRCAP->pRequestMajorOpSet,
+                                                 pIter, &interval))) {
+                            unsigned int j;
+
+                            for (j = interval.first; j <= interval.last; j++)
+                                pClient->requestVector[j] = RecordARequest;
+                        }
+                    }
+                }
+                if (!otherRCAPwantsProcVector) {        /* nobody needs it, so free it */
+                    pClient->requestVector = pClientPriv->originalVector;
+                    dixSetPrivate(&pClient->devPrivates,
+                                  RecordClientPrivateKey, NULL);
+                    free(pClientPriv);
+                }
+            }                   /* end if this RCAP specifies any requests */
+        }                       /* end if not future clients */
+        if (oneclient)
+            client = 0;
+        else
+            client = (i < pRCAP->numClients) ? pRCAP->pClientIDs[i++] : 0;
     }
 
     assert(numEnabledRCAPs >= 1);
-    if (!oneclient && --numEnabledRCAPs == 0)
-    { /* we're disabling the last context */
-	DeleteCallback(&EventCallback, RecordADeliveredEventOrError, NULL);
-	DeleteCallback(&DeviceEventCallback, RecordADeviceEvent, NULL);
-	DeleteCallback(&ReplyCallback, RecordAReply, NULL);
-	DeleteCallback(&FlushCallback, RecordFlushAllContexts, NULL);
-	/* Alternate context flushing scheme: delete the line above
-	 * and call RemoveBlockAndWakeupHandlers here passing
-	 * RecordFlushAllContexts.  Is this any better?
-	 */
-	/* Having deleted the callback, call it one last time. -gildea */
-	RecordFlushAllContexts(&FlushCallback, NULL, NULL);
+    if (!oneclient && --numEnabledRCAPs == 0) { /* we're disabling the last context */
+        DeleteCallback(&EventCallback, RecordADeliveredEventOrError, NULL);
+        DeleteCallback(&DeviceEventCallback, RecordADeviceEvent, NULL);
+        DeleteCallback(&ReplyCallback, RecordAReply, NULL);
+        DeleteCallback(&FlushCallback, RecordFlushAllContexts, NULL);
+        /* Alternate context flushing scheme: delete the line above
+         * and call RemoveBlockAndWakeupHandlers here passing
+         * RecordFlushAllContexts.  Is this any better?
+         */
+        /* Having deleted the callback, call it one last time. -gildea */
+        RecordFlushAllContexts(&FlushCallback, NULL, NULL);
     }
-} /* RecordUninstallHooks */
-
+}                               /* RecordUninstallHooks */
 
 /* RecordDeleteClientFromRCAP
  *
@@ -1089,32 +1031,29 @@ static void
 RecordDeleteClientFromRCAP(RecordClientsAndProtocolPtr pRCAP, int position)
 {
     if (pRCAP->pContext->pRecordingClient)
-	RecordUninstallHooks(pRCAP, pRCAP->pClientIDs[position]);
+        RecordUninstallHooks(pRCAP, pRCAP->pClientIDs[position]);
     if (position != pRCAP->numClients - 1)
-	pRCAP->pClientIDs[position] = pRCAP->pClientIDs[pRCAP->numClients - 1];
-    if (--pRCAP->numClients == 0)
-    {	/* no more clients; remove RCAP from context's list */
-	RecordContextPtr pContext = pRCAP->pContext;
-	if (pContext->pRecordingClient)
-	    RecordUninstallHooks(pRCAP, 0);
-	if (pContext->pListOfRCAP == pRCAP)
-	    pContext->pListOfRCAP = pRCAP->pNextRCAP;
-	else
-	{
-	    RecordClientsAndProtocolPtr prevRCAP;
-	    for (prevRCAP = pContext->pListOfRCAP;
-		 prevRCAP->pNextRCAP != pRCAP;
-		 prevRCAP = prevRCAP->pNextRCAP)
-		;
-	    prevRCAP->pNextRCAP = pRCAP->pNextRCAP;
-	}
-	/* free the RCAP */
-	if (pRCAP->clientIDsSeparatelyAllocated)
-	    free(pRCAP->pClientIDs);
-	free(pRCAP);
+        pRCAP->pClientIDs[position] = pRCAP->pClientIDs[pRCAP->numClients - 1];
+    if (--pRCAP->numClients == 0) {     /* no more clients; remove RCAP from context's list */
+        RecordContextPtr pContext = pRCAP->pContext;
+
+        if (pContext->pRecordingClient)
+            RecordUninstallHooks(pRCAP, 0);
+        if (pContext->pListOfRCAP == pRCAP)
+            pContext->pListOfRCAP = pRCAP->pNextRCAP;
+        else {
+            RecordClientsAndProtocolPtr prevRCAP;
+
+            for (prevRCAP = pContext->pListOfRCAP;
+                 prevRCAP->pNextRCAP != pRCAP; prevRCAP = prevRCAP->pNextRCAP);
+            prevRCAP->pNextRCAP = pRCAP->pNextRCAP;
+        }
+        /* free the RCAP */
+        if (pRCAP->clientIDsSeparatelyAllocated)
+            free(pRCAP->pClientIDs);
+        free(pRCAP);
     }
-} /* RecordDeleteClientFromRCAP */
-
+}                               /* RecordDeleteClientFromRCAP */
 
 /* RecordAddClientToRCAP
  *
@@ -1135,35 +1074,33 @@ RecordDeleteClientFromRCAP(RecordClientsAndProtocolPtr pRCAP, int position)
 static void
 RecordAddClientToRCAP(RecordClientsAndProtocolPtr pRCAP, XID clientspec)
 {
-    if (pRCAP->numClients == pRCAP->sizeClients)
-    {
-	if (pRCAP->clientIDsSeparatelyAllocated)
-	{
-	    XID *pNewIDs = (XID *)realloc(pRCAP->pClientIDs,
-			(pRCAP->sizeClients + CLIENT_ARRAY_GROWTH_INCREMENT) *
-								sizeof(XID));
-	    if (!pNewIDs)
-		return;
-	    pRCAP->pClientIDs = pNewIDs;
-	    pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
-	}
-	else
-	{
-	    XID *pNewIDs = (XID *)malloc((pRCAP->sizeClients +
-				CLIENT_ARRAY_GROWTH_INCREMENT) * sizeof(XID));
-	    if (!pNewIDs)
-		return;
-	    memcpy(pNewIDs, pRCAP->pClientIDs, pRCAP->numClients *sizeof(XID));
-	    pRCAP->pClientIDs = pNewIDs;
-	    pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
-	    pRCAP->clientIDsSeparatelyAllocated = 1;
-	}
+    if (pRCAP->numClients == pRCAP->sizeClients) {
+        if (pRCAP->clientIDsSeparatelyAllocated) {
+            XID *pNewIDs = (XID *) realloc(pRCAP->pClientIDs,
+                                           (pRCAP->sizeClients +
+                                            CLIENT_ARRAY_GROWTH_INCREMENT) *
+                                           sizeof(XID));
+            if (!pNewIDs)
+                return;
+            pRCAP->pClientIDs = pNewIDs;
+            pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
+        }
+        else {
+            XID *pNewIDs = (XID *) malloc((pRCAP->sizeClients +
+                                           CLIENT_ARRAY_GROWTH_INCREMENT) *
+                                          sizeof(XID));
+            if (!pNewIDs)
+                return;
+            memcpy(pNewIDs, pRCAP->pClientIDs, pRCAP->numClients * sizeof(XID));
+            pRCAP->pClientIDs = pNewIDs;
+            pRCAP->sizeClients += CLIENT_ARRAY_GROWTH_INCREMENT;
+            pRCAP->clientIDsSeparatelyAllocated = 1;
+        }
     }
     pRCAP->pClientIDs[pRCAP->numClients++] = clientspec;
     if (pRCAP->pContext->pRecordingClient)
-	RecordInstallHooks(pRCAP, clientspec);
-} /* RecordDeleteClientFromRCAP */
-
+        RecordInstallHooks(pRCAP, clientspec);
+}                               /* RecordDeleteClientFromRCAP */
 
 /* RecordDeleteClientFromContext
  *
@@ -1185,9 +1122,8 @@ RecordDeleteClientFromContext(RecordContextPtr pContext, XID clientspec)
     int position;
 
     if ((pRCAP = RecordFindClientOnContext(pContext, clientspec, &position)))
-	RecordDeleteClientFromRCAP(pRCAP, position);
-} /* RecordDeleteClientFromContext */
-
+        RecordDeleteClientFromRCAP(pRCAP, position);
+}                               /* RecordDeleteClientFromContext */
 
 /* RecordSanityCheckClientSpecifiers
  *
@@ -1202,38 +1138,36 @@ RecordDeleteClientFromContext(RecordContextPtr pContext, XID clientspec)
  * Side Effects: none.
  */
 static int
-RecordSanityCheckClientSpecifiers(ClientPtr client, XID *clientspecs, int nspecs, XID errorspec)
+RecordSanityCheckClientSpecifiers(ClientPtr client, XID *clientspecs,
+                                  int nspecs, XID errorspec)
 {
     int i;
     int clientIndex;
     int rc;
     pointer value;
 
-    for (i = 0; i < nspecs; i++)
-    {
-	if (clientspecs[i] == XRecordCurrentClients ||
-	    clientspecs[i] == XRecordFutureClients ||
-	    clientspecs[i] == XRecordAllClients)
-	    continue;
-	if (errorspec && (CLIENT_BITS(clientspecs[i]) == errorspec) )
-	    return BadMatch;
-	clientIndex = CLIENT_ID(clientspecs[i]);
-	if (clientIndex && clients[clientIndex] &&
-	    clients[clientIndex]->clientState == ClientStateRunning)
-	{
-	    if (clientspecs[i] == clients[clientIndex]->clientAsMask)
-		continue;
+    for (i = 0; i < nspecs; i++) {
+        if (clientspecs[i] == XRecordCurrentClients ||
+            clientspecs[i] == XRecordFutureClients ||
+            clientspecs[i] == XRecordAllClients)
+            continue;
+        if (errorspec && (CLIENT_BITS(clientspecs[i]) == errorspec))
+            return BadMatch;
+        clientIndex = CLIENT_ID(clientspecs[i]);
+        if (clientIndex && clients[clientIndex] &&
+            clients[clientIndex]->clientState == ClientStateRunning) {
+            if (clientspecs[i] == clients[clientIndex]->clientAsMask)
+                continue;
             rc = dixLookupResourceByClass(&value, clientspecs[i], RC_ANY,
                                           client, DixGetAttrAccess);
             if (rc != Success)
                 return rc;
-	}
-	else
-	    return BadMatch;
+        }
+        else
+            return BadMatch;
     }
     return Success;
-} /* RecordSanityCheckClientSpecifiers */
-
+}                               /* RecordSanityCheckClientSpecifiers */
 
 /* RecordCanonicalizeClientSpecifiers
  *
@@ -1265,7 +1199,8 @@ RecordSanityCheckClientSpecifiers(ClientPtr client, XID *clientspecs, int nspecs
  *	pClientspecs may be modified in place.
  */
 static XID *
-RecordCanonicalizeClientSpecifiers(XID *pClientspecs, int *pNumClientspecs, XID excludespec)
+RecordCanonicalizeClientSpecifiers(XID *pClientspecs, int *pNumClientspecs,
+                                   XID excludespec)
 {
     int i;
     int numClients = *pNumClientspecs;
@@ -1274,54 +1209,50 @@ RecordCanonicalizeClientSpecifiers(XID *pClientspecs, int *pNumClientspecs, XID
      *  client id bits.  This makes searching for a particular client simpler
      *  (and faster.)
      */
-    for (i = 0; i < numClients; i++)
-    {
-	XID cs = pClientspecs[i];
-	if (cs > XRecordAllClients)
-	    pClientspecs[i] = CLIENT_BITS(cs);
+    for (i = 0; i < numClients; i++) {
+        XID cs = pClientspecs[i];
+
+        if (cs > XRecordAllClients)
+            pClientspecs[i] = CLIENT_BITS(cs);
     }
 
-    for (i = 0; i < numClients; i++)
-    {
-	if (pClientspecs[i] == XRecordAllClients ||
-	    pClientspecs[i] == XRecordCurrentClients)
-	{ /* expand All/Current */
-	    int j, nc;
-	    XID *pCanon = (XID *)malloc(sizeof(XID) * (currentMaxClients + 1));
-	    if (!pCanon) return NULL;
-	    for (nc = 0, j = 1; j < currentMaxClients; j++)
-	    {
-		ClientPtr client = clients[j];
-		if (client != NullClient &&
-		    client->clientState == ClientStateRunning &&
-		    client->clientAsMask != excludespec)
-		{
-		    pCanon[nc++] = client->clientAsMask;
-		}
-	    }
-	    if (pClientspecs[i] == XRecordAllClients)
-		pCanon[nc++] = XRecordFutureClients;
-	    *pNumClientspecs = nc;
-	    return pCanon;
-	}
-	else /* not All or Current */
-	{
-	    int j;
-	    for (j = i + 1; j < numClients; )
-	    {
-		if (pClientspecs[i] == pClientspecs[j])
-		{
-		    pClientspecs[j] = pClientspecs[--numClients];
-		}
-		else
-		    j++;
-	    }
-	}
-    } /* end for each clientspec */
+    for (i = 0; i < numClients; i++) {
+        if (pClientspecs[i] == XRecordAllClients || pClientspecs[i] == XRecordCurrentClients) { /* expand All/Current */
+            int j, nc;
+            XID *pCanon = (XID *) malloc(sizeof(XID) * (currentMaxClients + 1));
+
+            if (!pCanon)
+                return NULL;
+            for (nc = 0, j = 1; j < currentMaxClients; j++) {
+                ClientPtr client = clients[j];
+
+                if (client != NullClient &&
+                    client->clientState == ClientStateRunning &&
+                    client->clientAsMask != excludespec) {
+                    pCanon[nc++] = client->clientAsMask;
+                }
+            }
+            if (pClientspecs[i] == XRecordAllClients)
+                pCanon[nc++] = XRecordFutureClients;
+            *pNumClientspecs = nc;
+            return pCanon;
+        }
+        else {                  /* not All or Current */
+
+            int j;
+
+            for (j = i + 1; j < numClients;) {
+                if (pClientspecs[i] == pClientspecs[j]) {
+                    pClientspecs[j] = pClientspecs[--numClients];
+                }
+                else
+                    j++;
+            }
+        }
+    }                           /* end for each clientspec */
     *pNumClientspecs = numClients;
     return pClientspecs;
-} /* RecordCanonicalizeClientSpecifiers */
-
+}                               /* RecordCanonicalizeClientSpecifiers */
 
 /****************************************************************************/
 
@@ -1344,8 +1275,7 @@ static int
 RecordPadAlign(int size, int align)
 {
     return (align - (size & (align - 1))) & (align - 1);
-} /* RecordPadAlign */
-
+}                               /* RecordPadAlign */
 
 /* RecordSanityCheckRegisterClients
  *
@@ -1362,7 +1292,8 @@ RecordPadAlign(int size, int align)
  * Side Effects: none.
  */
 static int
-RecordSanityCheckRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegisterClientsReq *stuff)
+RecordSanityCheckRegisterClients(RecordContextPtr pContext, ClientPtr client,
+                                 xRecordRegisterClientsReq * stuff)
 {
     int err;
     xRecordRange *pRange;
@@ -1370,119 +1301,107 @@ RecordSanityCheckRegisterClients(RecordContextPtr pContext, ClientPtr client, xR
     XID recordingClient;
 
     if (((client->req_len << 2) - SIZEOF(xRecordRegisterClientsReq)) !=
-	4 * stuff->nClients + SIZEOF(xRecordRange) * stuff->nRanges)
-	return BadLength;
+        4 * stuff->nClients + SIZEOF(xRecordRange) * stuff->nRanges)
+        return BadLength;
 
     if (stuff->elementHeader &
-     ~(XRecordFromClientSequence|XRecordFromClientTime|XRecordFromServerTime))
-    {
-	client->errorValue = stuff->elementHeader;
-	return BadValue;
+        ~(XRecordFromClientSequence | XRecordFromClientTime |
+          XRecordFromServerTime)) {
+        client->errorValue = stuff->elementHeader;
+        return BadValue;
     }
 
     recordingClient = pContext->pRecordingClient ?
-		      pContext->pRecordingClient->clientAsMask : 0;
-    err = RecordSanityCheckClientSpecifiers(client, (XID *)&stuff[1],
-					    stuff->nClients, recordingClient);
-    if (err != Success) return err;
-
-    pRange = (xRecordRange *)(((XID *)&stuff[1]) + stuff->nClients);
-    for (i = 0; i < stuff->nRanges; i++, pRange++)
-    {
-	if (pRange->coreRequestsFirst > pRange->coreRequestsLast)
-	{
-	    client->errorValue = pRange->coreRequestsFirst;
-	    return BadValue;
-	}
-	if (pRange->coreRepliesFirst > pRange->coreRepliesLast)
-	{
-	    client->errorValue = pRange->coreRepliesFirst;
-	    return BadValue;
-	}
-	if ((pRange->extRequestsMajorFirst || pRange->extRequestsMajorLast) &&
-	    (pRange->extRequestsMajorFirst < 128 ||
-	     pRange->extRequestsMajorLast < 128 ||
-	     pRange->extRequestsMajorFirst > pRange->extRequestsMajorLast))
-	{
-	    client->errorValue = pRange->extRequestsMajorFirst;
-	    return BadValue;
-	}
-	if (pRange->extRequestsMinorFirst > pRange->extRequestsMinorLast)
-	{
-	    client->errorValue = pRange->extRequestsMinorFirst;
-	    return BadValue;
-	}
-	if ((pRange->extRepliesMajorFirst || pRange->extRepliesMajorLast) &&
-	    (pRange->extRepliesMajorFirst < 128 ||
-	     pRange->extRepliesMajorLast < 128 ||
-	     pRange->extRepliesMajorFirst > pRange->extRepliesMajorLast))
-	{
-	    client->errorValue = pRange->extRepliesMajorFirst;
-	    return BadValue;
-	}
-	if (pRange->extRepliesMinorFirst > pRange->extRepliesMinorLast)
-	{
-	    client->errorValue = pRange->extRepliesMinorFirst;
-	    return BadValue;
-	}
-	if ((pRange->deliveredEventsFirst || pRange->deliveredEventsLast) &&
-	    (pRange->deliveredEventsFirst < 2 ||
-	     pRange->deliveredEventsLast < 2 ||
-	     pRange->deliveredEventsFirst > pRange->deliveredEventsLast))
-	{
-	    client->errorValue = pRange->deliveredEventsFirst;
-	    return BadValue;
-	}
-	if ((pRange->deviceEventsFirst || pRange->deviceEventsLast) &&
-	    (pRange->deviceEventsFirst < 2 ||
-	     pRange->deviceEventsLast < 2 ||
-	     pRange->deviceEventsFirst > pRange->deviceEventsLast))
-	{
-	    client->errorValue = pRange->deviceEventsFirst;
-	    return BadValue;
-	}
-	if (pRange->errorsFirst > pRange->errorsLast)
-	{
-	    client->errorValue = pRange->errorsFirst;
-	    return BadValue;
-	}
-	if (pRange->clientStarted != xFalse && pRange->clientStarted != xTrue)
-	{
-	    client->errorValue = pRange->clientStarted;
-	    return BadValue;
-	}
-	if (pRange->clientDied != xFalse && pRange->clientDied != xTrue)
-	{
-	    client->errorValue = pRange->clientDied;
-	    return BadValue;
-	}
-    } /* end for each range */
+        pContext->pRecordingClient->clientAsMask : 0;
+    err = RecordSanityCheckClientSpecifiers(client, (XID *) &stuff[1],
+                                            stuff->nClients, recordingClient);
+    if (err != Success)
+        return err;
+
+    pRange = (xRecordRange *) (((XID *) &stuff[1]) + stuff->nClients);
+    for (i = 0; i < stuff->nRanges; i++, pRange++) {
+        if (pRange->coreRequestsFirst > pRange->coreRequestsLast) {
+            client->errorValue = pRange->coreRequestsFirst;
+            return BadValue;
+        }
+        if (pRange->coreRepliesFirst > pRange->coreRepliesLast) {
+            client->errorValue = pRange->coreRepliesFirst;
+            return BadValue;
+        }
+        if ((pRange->extRequestsMajorFirst || pRange->extRequestsMajorLast) &&
+            (pRange->extRequestsMajorFirst < 128 ||
+             pRange->extRequestsMajorLast < 128 ||
+             pRange->extRequestsMajorFirst > pRange->extRequestsMajorLast)) {
+            client->errorValue = pRange->extRequestsMajorFirst;
+            return BadValue;
+        }
+        if (pRange->extRequestsMinorFirst > pRange->extRequestsMinorLast) {
+            client->errorValue = pRange->extRequestsMinorFirst;
+            return BadValue;
+        }
+        if ((pRange->extRepliesMajorFirst || pRange->extRepliesMajorLast) &&
+            (pRange->extRepliesMajorFirst < 128 ||
+             pRange->extRepliesMajorLast < 128 ||
+             pRange->extRepliesMajorFirst > pRange->extRepliesMajorLast)) {
+            client->errorValue = pRange->extRepliesMajorFirst;
+            return BadValue;
+        }
+        if (pRange->extRepliesMinorFirst > pRange->extRepliesMinorLast) {
+            client->errorValue = pRange->extRepliesMinorFirst;
+            return BadValue;
+        }
+        if ((pRange->deliveredEventsFirst || pRange->deliveredEventsLast) &&
+            (pRange->deliveredEventsFirst < 2 ||
+             pRange->deliveredEventsLast < 2 ||
+             pRange->deliveredEventsFirst > pRange->deliveredEventsLast)) {
+            client->errorValue = pRange->deliveredEventsFirst;
+            return BadValue;
+        }
+        if ((pRange->deviceEventsFirst || pRange->deviceEventsLast) &&
+            (pRange->deviceEventsFirst < 2 ||
+             pRange->deviceEventsLast < 2 ||
+             pRange->deviceEventsFirst > pRange->deviceEventsLast)) {
+            client->errorValue = pRange->deviceEventsFirst;
+            return BadValue;
+        }
+        if (pRange->errorsFirst > pRange->errorsLast) {
+            client->errorValue = pRange->errorsFirst;
+            return BadValue;
+        }
+        if (pRange->clientStarted != xFalse && pRange->clientStarted != xTrue) {
+            client->errorValue = pRange->clientStarted;
+            return BadValue;
+        }
+        if (pRange->clientDied != xFalse && pRange->clientDied != xTrue) {
+            client->errorValue = pRange->clientDied;
+            return BadValue;
+        }
+    }                           /* end for each range */
     return Success;
-} /* end RecordSanityCheckRegisterClients */
+}                               /* end RecordSanityCheckRegisterClients */
 
 /* This is a tactical structure used to gather information about all the sets
  * (RecordSetPtr) that need to be created for an RCAP in the process of 
  * digesting a list of RECORDRANGEs (converting it to the internal
  * representation).
  */
-typedef struct
-{
-    int nintervals;	/* number of intervals in following array */
-    RecordSetInterval *intervals;  /* array of intervals for this set */
-    int size;		/* size of intevals array; >= nintervals */
-    int align;		/* alignment restriction for set */
-    int offset;		/* where to store set pointer rel. to start of RCAP */
-    short first, last;	/* if for extension, major opcode interval */
+typedef struct {
+    int nintervals;             /* number of intervals in following array */
+    RecordSetInterval *intervals;       /* array of intervals for this set */
+    int size;                   /* size of intevals array; >= nintervals */
+    int align;                  /* alignment restriction for set */
+    int offset;                 /* where to store set pointer rel. to start of RCAP */
+    short first, last;          /* if for extension, major opcode interval */
 } SetInfoRec, *SetInfoPtr;
 
 /* These constant are used to index into an array of SetInfoRec. */
-enum {REQ,	/* set info for requests */
-      REP,	/* set info for replies */
-      ERR,	/* set info for errors */
-      DEV,	/* set info for device events */
-      DLEV,	/* set info for delivered events */
-      PREDEFSETS};  /* number of predefined array entries */
-
+enum { REQ,                     /* set info for requests */
+    REP,                        /* set info for replies */
+    ERR,                        /* set info for errors */
+    DEV,                        /* set info for device events */
+    DLEV,                       /* set info for delivered events */
+    PREDEFSETS
+};                              /* number of predefined array entries */
 
 /* RecordAllocIntervals
  *
@@ -1501,14 +1420,13 @@ RecordAllocIntervals(SetInfoPtr psi, int nIntervals)
 {
     assert(!psi->intervals);
     psi->intervals = (RecordSetInterval *)
-			malloc(nIntervals * sizeof(RecordSetInterval));
+        malloc(nIntervals * sizeof(RecordSetInterval));
     if (!psi->intervals)
-	return BadAlloc;
+        return BadAlloc;
     memset(psi->intervals, 0, nIntervals * sizeof(RecordSetInterval));
     psi->size = nIntervals;
     return Success;
-} /* end RecordAllocIntervals */
-
+}                               /* end RecordAllocIntervals */
 
 /* RecordConvertRangesToIntervals
  *
@@ -1534,66 +1452,57 @@ RecordAllocIntervals(SetInfoPtr psi, int nIntervals)
  *	increased accordingly.
  */
 static int
-RecordConvertRangesToIntervals(
-    SetInfoPtr psi,
-    xRecordRange *pRanges,
-    int nRanges,
-    int byteoffset,
-    SetInfoPtr pExtSetInfo,
-    int *pnExtSetInfo
-)
+RecordConvertRangesToIntervals(SetInfoPtr psi,
+                               xRecordRange * pRanges,
+                               int nRanges,
+                               int byteoffset,
+                               SetInfoPtr pExtSetInfo, int *pnExtSetInfo)
 {
     int i;
     CARD8 *pCARD8;
     int first, last;
     int err;
 
-    for (i = 0; i < nRanges; i++, pRanges++)
-    {
-	pCARD8 = ((CARD8 *)pRanges) + byteoffset;
-	first = pCARD8[0];
-	last  = pCARD8[1];
-	if (first || last)
-	{
-	    if (!psi->intervals)
-	    {
-		err = RecordAllocIntervals(psi, 2 * (nRanges - i));
-		if (err != Success)
-		    return err;
-	    }
-	    psi->intervals[psi->nintervals].first = first;
-	    psi->intervals[psi->nintervals].last  = last;
-	    psi->nintervals++;
-	    assert(psi->nintervals <= psi->size);
-	    if (pExtSetInfo)
-	    {
-		SetInfoPtr pesi = pExtSetInfo;
-		CARD16 *pCARD16 = (CARD16 *)(pCARD8 + 2);
-		int j;
-
-		for (j = 0; j < *pnExtSetInfo; j++, pesi++)
-		{
-		    if ( (first == pesi->first) && (last == pesi->last) )
-			break;
-		}
-		if (j == *pnExtSetInfo)
-		{
-		    err = RecordAllocIntervals(pesi, 2 * (nRanges - i));
-		    if (err != Success)
-			return err;
-		    pesi->first = first;
-		    pesi->last  = last;
-		    (*pnExtSetInfo)++;
-		}
-		pesi->intervals[pesi->nintervals].first = pCARD16[0];
-		pesi->intervals[pesi->nintervals].last  = pCARD16[1];
-		pesi->nintervals++;
-		assert(pesi->nintervals <= pesi->size);
-	    }
-	}
+    for (i = 0; i < nRanges; i++, pRanges++) {
+        pCARD8 = ((CARD8 *) pRanges) + byteoffset;
+        first = pCARD8[0];
+        last = pCARD8[1];
+        if (first || last) {
+            if (!psi->intervals) {
+                err = RecordAllocIntervals(psi, 2 * (nRanges - i));
+                if (err != Success)
+                    return err;
+            }
+            psi->intervals[psi->nintervals].first = first;
+            psi->intervals[psi->nintervals].last = last;
+            psi->nintervals++;
+            assert(psi->nintervals <= psi->size);
+            if (pExtSetInfo) {
+                SetInfoPtr pesi = pExtSetInfo;
+                CARD16 *pCARD16 = (CARD16 *) (pCARD8 + 2);
+                int j;
+
+                for (j = 0; j < *pnExtSetInfo; j++, pesi++) {
+                    if ((first == pesi->first) && (last == pesi->last))
+                        break;
+                }
+                if (j == *pnExtSetInfo) {
+                    err = RecordAllocIntervals(pesi, 2 * (nRanges - i));
+                    if (err != Success)
+                        return err;
+                    pesi->first = first;
+                    pesi->last = last;
+                    (*pnExtSetInfo)++;
+                }
+                pesi->intervals[pesi->nintervals].first = pCARD16[0];
+                pesi->intervals[pesi->nintervals].last = pCARD16[1];
+                pesi->nintervals++;
+                assert(pesi->nintervals <= pesi->size);
+            }
+        }
     }
     return Success;
-}  /* end RecordConvertRangesToIntervals */
+}                               /* end RecordConvertRangesToIntervals */
 
 #define offset_of(_structure, _field) \
     ((char *)(& (_structure . _field)) - (char *)(&_structure))
@@ -1619,7 +1528,8 @@ RecordConvertRangesToIntervals(
  *	to record the new clients and protocol.
  */
 static int
-RecordRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegisterClientsReq *stuff)
+RecordRegisterClients(RecordContextPtr pContext, ClientPtr client,
+                      xRecordRegisterClientsReq * stuff)
 {
     int err;
     int i;
@@ -1645,84 +1555,98 @@ RecordRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegist
 
     err = RecordSanityCheckRegisterClients(pContext, client, stuff);
     if (err != Success)
-	return err;
+        return err;
 
     /* if element headers changed, flush buffer */
-	
-    if (pContext->elemHeaders != stuff->elementHeader)
-    {
-	RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
-	pContext->elemHeaders = stuff->elementHeader;
+
+    if (pContext->elemHeaders != stuff->elementHeader) {
+        RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
+        pContext->elemHeaders = stuff->elementHeader;
     }
 
     nClients = stuff->nClients;
     if (!nClients)
-	/* if empty clients list, we're done. */
-	return Success;
+        /* if empty clients list, we're done. */
+        return Success;
 
     recordingClient = pContext->pRecordingClient ?
-		      pContext->pRecordingClient->clientAsMask : 0;
-    pCanonClients = RecordCanonicalizeClientSpecifiers((XID *)&stuff[1],
-						 &nClients, recordingClient);
+        pContext->pRecordingClient->clientAsMask : 0;
+    pCanonClients = RecordCanonicalizeClientSpecifiers((XID *) &stuff[1],
+                                                       &nClients,
+                                                       recordingClient);
     if (!pCanonClients)
-	return BadAlloc;
+        return BadAlloc;
 
     /* We may have to create as many as one set for each "predefined"
      * protocol types, plus one per range for extension reuests, plus one per
      * range for extension replies.
      */
     maxSets = PREDEFSETS + 2 * stuff->nRanges;
-    si = (SetInfoPtr)malloc(sizeof(SetInfoRec) * maxSets);
-    if (!si)
-    {
-	err = BadAlloc;
-	goto bailout;
+    si = (SetInfoPtr) malloc(sizeof(SetInfoRec) * maxSets);
+    if (!si) {
+        err = BadAlloc;
+        goto bailout;
     }
     memset(si, 0, sizeof(SetInfoRec) * maxSets);
 
     /* theoretically you must do this because NULL may not be all-bits-zero */
     for (i = 0; i < maxSets; i++)
-	si[i].intervals = NULL;
+        si[i].intervals = NULL;
 
     pExtReqSets = si + PREDEFSETS;
     pExtRepSets = pExtReqSets + stuff->nRanges;
 
-    pRanges = (xRecordRange *)(((XID *)&stuff[1]) + stuff->nClients);
+    pRanges = (xRecordRange *) (((XID *) &stuff[1]) + stuff->nClients);
 
     err = RecordConvertRangesToIntervals(&si[REQ], pRanges, stuff->nRanges,
-			offset_of(rr, coreRequestsFirst), NULL, NULL);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, coreRequestsFirst), NULL,
+                                         NULL);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[REQ], pRanges, stuff->nRanges,
-	   offset_of(rr, extRequestsMajorFirst), pExtReqSets, &nExtReqSets);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, extRequestsMajorFirst),
+                                         pExtReqSets, &nExtReqSets);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[REP], pRanges, stuff->nRanges,
-			offset_of(rr, coreRepliesFirst), NULL, NULL);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, coreRepliesFirst), NULL,
+                                         NULL);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[REP], pRanges, stuff->nRanges,
-	   offset_of(rr, extRepliesMajorFirst), pExtRepSets, &nExtRepSets);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, extRepliesMajorFirst),
+                                         pExtRepSets, &nExtRepSets);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[ERR], pRanges, stuff->nRanges,
-			offset_of(rr, errorsFirst), NULL, NULL);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, errorsFirst), NULL,
+                                         NULL);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[DLEV], pRanges, stuff->nRanges,
-			offset_of(rr, deliveredEventsFirst), NULL, NULL);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, deliveredEventsFirst),
+                                         NULL, NULL);
+    if (err != Success)
+        goto bailout;
 
     err = RecordConvertRangesToIntervals(&si[DEV], pRanges, stuff->nRanges,
-			offset_of(rr, deviceEventsFirst), NULL, NULL);
-    if (err != Success) goto bailout;
+                                         offset_of(rr, deviceEventsFirst), NULL,
+                                         NULL);
+    if (err != Success)
+        goto bailout;
 
     /* collect client-started and client-died */
 
-    for (i = 0; i < stuff->nRanges; i++)
-    {
-	if (pRanges[i].clientStarted) clientStarted = TRUE;
-	if (pRanges[i].clientDied)    clientDied    = TRUE;
+    for (i = 0; i < stuff->nRanges; i++) {
+        if (pRanges[i].clientStarted)
+            clientStarted = TRUE;
+        if (pRanges[i].clientDied)
+            clientDied = TRUE;
     }
 
     /*  We now have all the information collected to create all the sets,
@@ -1737,154 +1661,152 @@ RecordRegisterClients(RecordContextPtr pContext, ClientPtr client, xRecordRegist
     clientListOffset = totRCAPsize + pad;
     totRCAPsize += pad + sizeClients * sizeof(XID);
 
-    if (nExtReqSets)
-    {
-	pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
-	extReqSetsOffset = totRCAPsize + pad;
-	totRCAPsize += pad + (nExtReqSets + 1) * sizeof(RecordMinorOpRec);
+    if (nExtReqSets) {
+        pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
+        extReqSetsOffset = totRCAPsize + pad;
+        totRCAPsize += pad + (nExtReqSets + 1) * sizeof(RecordMinorOpRec);
     }
-    if (nExtRepSets)
-    {
-	pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
-	extRepSetsOffset = totRCAPsize + pad;
-	totRCAPsize += pad + (nExtRepSets + 1) * sizeof(RecordMinorOpRec);
+    if (nExtRepSets) {
+        pad = RecordPadAlign(totRCAPsize, sizeof(RecordSetPtr));
+        extRepSetsOffset = totRCAPsize + pad;
+        totRCAPsize += pad + (nExtRepSets + 1) * sizeof(RecordMinorOpRec);
     }
 
-    for (i = 0; i < maxSets; i++)
-    {
-	if (si[i].nintervals)
-	{
-	    si[i].size = RecordSetMemoryRequirements(
-				si[i].intervals, si[i].nintervals, &si[i].align);
-	    pad = RecordPadAlign(totRCAPsize, si[i].align);
-	    si[i].offset = pad + totRCAPsize;
-	    totRCAPsize += pad + si[i].size;
-	}
+    for (i = 0; i < maxSets; i++) {
+        if (si[i].nintervals) {
+            si[i].size =
+                RecordSetMemoryRequirements(si[i].intervals, si[i].nintervals,
+                                            &si[i].align);
+            pad = RecordPadAlign(totRCAPsize, si[i].align);
+            si[i].offset = pad + totRCAPsize;
+            totRCAPsize += pad + si[i].size;
+        }
     }
 
     /* allocate memory for the whole RCAP */
 
-    pRCAP = (RecordClientsAndProtocolPtr)malloc(totRCAPsize);
-    if (!pRCAP) 
-    {
-	err = BadAlloc;
-	goto bailout;
+    pRCAP = (RecordClientsAndProtocolPtr) malloc(totRCAPsize);
+    if (!pRCAP) {
+        err = BadAlloc;
+        goto bailout;
     }
 
     /* fill in the RCAP */
 
     pRCAP->pContext = pContext;
-    pRCAP->pClientIDs = (XID *)((char *)pRCAP + clientListOffset);
-    pRCAP->numClients  = nClients;
+    pRCAP->pClientIDs = (XID *) ((char *) pRCAP + clientListOffset);
+    pRCAP->numClients = nClients;
     pRCAP->sizeClients = sizeClients;
     pRCAP->clientIDsSeparatelyAllocated = 0;
-    for (i = 0; i < nClients; i++)
-    {
-	RecordDeleteClientFromContext(pContext, pCanonClients[i]);
-	pRCAP->pClientIDs[i] = pCanonClients[i];
+    for (i = 0; i < nClients; i++) {
+        RecordDeleteClientFromContext(pContext, pCanonClients[i]);
+        pRCAP->pClientIDs[i] = pCanonClients[i];
     }
 
     /* create all the sets */
 
-    if (si[REQ].intervals)
-    {
-	pRCAP->pRequestMajorOpSet =
-	    RecordCreateSet(si[REQ].intervals, si[REQ].nintervals,
-		(RecordSetPtr)((char *)pRCAP + si[REQ].offset), si[REQ].size);
+    if (si[REQ].intervals) {
+        pRCAP->pRequestMajorOpSet =
+            RecordCreateSet(si[REQ].intervals, si[REQ].nintervals,
+                            (RecordSetPtr) ((char *) pRCAP + si[REQ].offset),
+                            si[REQ].size);
     }
-    else pRCAP->pRequestMajorOpSet = NULL;
+    else
+        pRCAP->pRequestMajorOpSet = NULL;
 
-    if (si[REP].intervals)
-    {
-	pRCAP->pReplyMajorOpSet =
-	    RecordCreateSet(si[REP].intervals, si[REP].nintervals,
-		(RecordSetPtr)((char *)pRCAP + si[REP].offset), si[REP].size);
+    if (si[REP].intervals) {
+        pRCAP->pReplyMajorOpSet =
+            RecordCreateSet(si[REP].intervals, si[REP].nintervals,
+                            (RecordSetPtr) ((char *) pRCAP + si[REP].offset),
+                            si[REP].size);
     }
-    else pRCAP->pReplyMajorOpSet = NULL;
+    else
+        pRCAP->pReplyMajorOpSet = NULL;
 
-    if (si[ERR].intervals)
-    {
-	pRCAP->pErrorSet =
-	    RecordCreateSet(si[ERR].intervals, si[ERR].nintervals,
-		(RecordSetPtr)((char *)pRCAP + si[ERR].offset), si[ERR].size);
+    if (si[ERR].intervals) {
+        pRCAP->pErrorSet =
+            RecordCreateSet(si[ERR].intervals, si[ERR].nintervals,
+                            (RecordSetPtr) ((char *) pRCAP + si[ERR].offset),
+                            si[ERR].size);
     }
-    else pRCAP->pErrorSet = NULL;
+    else
+        pRCAP->pErrorSet = NULL;
 
-    if (si[DEV].intervals)
-    {
-	pRCAP->pDeviceEventSet =
-	    RecordCreateSet(si[DEV].intervals, si[DEV].nintervals,
-		(RecordSetPtr)((char *)pRCAP + si[DEV].offset), si[DEV].size);
+    if (si[DEV].intervals) {
+        pRCAP->pDeviceEventSet =
+            RecordCreateSet(si[DEV].intervals, si[DEV].nintervals,
+                            (RecordSetPtr) ((char *) pRCAP + si[DEV].offset),
+                            si[DEV].size);
     }
-    else pRCAP->pDeviceEventSet = NULL;
+    else
+        pRCAP->pDeviceEventSet = NULL;
 
-    if (si[DLEV].intervals)
-    {
-	pRCAP->pDeliveredEventSet =
-	    RecordCreateSet(si[DLEV].intervals, si[DLEV].nintervals,
-	      (RecordSetPtr)((char *)pRCAP + si[DLEV].offset), si[DLEV].size);
+    if (si[DLEV].intervals) {
+        pRCAP->pDeliveredEventSet =
+            RecordCreateSet(si[DLEV].intervals, si[DLEV].nintervals,
+                            (RecordSetPtr) ((char *) pRCAP + si[DLEV].offset),
+                            si[DLEV].size);
     }
-    else pRCAP->pDeliveredEventSet = NULL;
-
-    if (nExtReqSets)
-    {
-	pRCAP->pRequestMinOpInfo = (RecordMinorOpPtr)
-					((char *)pRCAP + extReqSetsOffset);
-	pRCAP->pRequestMinOpInfo[0].count = nExtReqSets;
-	for (i = 0; i < nExtReqSets; i++, pExtReqSets++)
-	{
-	    pRCAP->pRequestMinOpInfo[i+1].major.first = pExtReqSets->first;
-	    pRCAP->pRequestMinOpInfo[i+1].major.last  = pExtReqSets->last;
-	    pRCAP->pRequestMinOpInfo[i+1].major.pMinOpSet =
-		RecordCreateSet(pExtReqSets->intervals,
-				pExtReqSets->nintervals, 
-		  (RecordSetPtr)((char *)pRCAP + pExtReqSets->offset),
-				pExtReqSets->size);
-	}
+    else
+        pRCAP->pDeliveredEventSet = NULL;
+
+    if (nExtReqSets) {
+        pRCAP->pRequestMinOpInfo = (RecordMinorOpPtr)
+            ((char *) pRCAP + extReqSetsOffset);
+        pRCAP->pRequestMinOpInfo[0].count = nExtReqSets;
+        for (i = 0; i < nExtReqSets; i++, pExtReqSets++) {
+            pRCAP->pRequestMinOpInfo[i + 1].major.first = pExtReqSets->first;
+            pRCAP->pRequestMinOpInfo[i + 1].major.last = pExtReqSets->last;
+            pRCAP->pRequestMinOpInfo[i + 1].major.pMinOpSet =
+                RecordCreateSet(pExtReqSets->intervals,
+                                pExtReqSets->nintervals,
+                                (RecordSetPtr) ((char *) pRCAP +
+                                                pExtReqSets->offset),
+                                pExtReqSets->size);
+        }
     }
-    else pRCAP->pRequestMinOpInfo = NULL;
-
-    if (nExtRepSets)
-    {
-	pRCAP->pReplyMinOpInfo = (RecordMinorOpPtr)
-					((char *)pRCAP + extRepSetsOffset);
-	pRCAP->pReplyMinOpInfo[0].count = nExtRepSets;
-	for (i = 0; i < nExtRepSets; i++, pExtRepSets++)
-	{
-	    pRCAP->pReplyMinOpInfo[i+1].major.first = pExtRepSets->first;
-	    pRCAP->pReplyMinOpInfo[i+1].major.last  = pExtRepSets->last;
-	    pRCAP->pReplyMinOpInfo[i+1].major.pMinOpSet =
-		RecordCreateSet(pExtRepSets->intervals,
-				pExtRepSets->nintervals, 
-		  (RecordSetPtr)((char *)pRCAP + pExtRepSets->offset),
-				pExtRepSets->size);
-	}
+    else
+        pRCAP->pRequestMinOpInfo = NULL;
+
+    if (nExtRepSets) {
+        pRCAP->pReplyMinOpInfo = (RecordMinorOpPtr)
+            ((char *) pRCAP + extRepSetsOffset);
+        pRCAP->pReplyMinOpInfo[0].count = nExtRepSets;
+        for (i = 0; i < nExtRepSets; i++, pExtRepSets++) {
+            pRCAP->pReplyMinOpInfo[i + 1].major.first = pExtRepSets->first;
+            pRCAP->pReplyMinOpInfo[i + 1].major.last = pExtRepSets->last;
+            pRCAP->pReplyMinOpInfo[i + 1].major.pMinOpSet =
+                RecordCreateSet(pExtRepSets->intervals,
+                                pExtRepSets->nintervals,
+                                (RecordSetPtr) ((char *) pRCAP +
+                                                pExtRepSets->offset),
+                                pExtRepSets->size);
+        }
     }
-    else pRCAP->pReplyMinOpInfo = NULL;
+    else
+        pRCAP->pReplyMinOpInfo = NULL;
 
     pRCAP->clientStarted = clientStarted;
-    pRCAP->clientDied    = clientDied;
+    pRCAP->clientDied = clientDied;
 
     /* link the RCAP onto the context */
 
     pRCAP->pNextRCAP = pContext->pListOfRCAP;
     pContext->pListOfRCAP = pRCAP;
 
-    if (pContext->pRecordingClient) /* context enabled */
-	RecordInstallHooks(pRCAP, 0);
+    if (pContext->pRecordingClient)     /* context enabled */
+        RecordInstallHooks(pRCAP, 0);
 
-bailout:
-    if (si)
-    {
-	for (i = 0; i < maxSets; i++)
-	    free(si[i].intervals);
-	free(si);
+ bailout:
+    if (si) {
+        for (i = 0; i < maxSets; i++)
+            free(si[i].intervals);
+        free(si);
     }
-    if (pCanonClients && pCanonClients != (XID *)&stuff[1])
-	free(pCanonClients);
+    if (pCanonClients && pCanonClients != (XID *) &stuff[1])
+        free(pCanonClients);
     return err;
-} /* RecordRegisterClients */
-
+}                               /* RecordRegisterClients */
 
 /* Proc functions all take a client argument, execute the request in
  * client->requestBuffer, and return a protocol error status.
@@ -1894,25 +1816,23 @@ static int
 ProcRecordQueryVersion(ClientPtr client)
 {
     /* REQUEST(xRecordQueryVersionReq); */
-    xRecordQueryVersionReply 	rep;
+    xRecordQueryVersionReply rep;
 
     REQUEST_SIZE_MATCH(xRecordQueryVersionReq);
-    rep.type        	= X_Reply;
-    rep.sequenceNumber 	= client->sequence;
-    rep.length         	= 0;
-    rep.majorVersion  	= SERVER_RECORD_MAJOR_VERSION;
-    rep.minorVersion  	= SERVER_RECORD_MINOR_VERSION;
-    if(client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swaps(&rep.majorVersion);
-	swaps(&rep.minorVersion);
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length = 0;
+    rep.majorVersion = SERVER_RECORD_MAJOR_VERSION;
+    rep.minorVersion = SERVER_RECORD_MINOR_VERSION;
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
     }
-    (void)WriteToClient(client, sizeof(xRecordQueryVersionReply),
-			(char *)&rep);
+    (void) WriteToClient(client, sizeof(xRecordQueryVersionReply),
+                         (char *) &rep);
     return Success;
-} /* ProcRecordQueryVersion */
-
+}                               /* ProcRecordQueryVersion */
 
 static int
 ProcRecordCreateContext(ClientPtr client)
@@ -1925,16 +1845,16 @@ ProcRecordCreateContext(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
     LEGAL_NEW_RESOURCE(stuff->context, client);
 
-    pContext = (RecordContextPtr)malloc(sizeof(RecordContextRec));
+    pContext = (RecordContextPtr) malloc(sizeof(RecordContextRec));
     if (!pContext)
-	goto bailout;
+        goto bailout;
 
     /* make sure there is room in ppAllContexts to store the new context */
 
     ppNewAllContexts = (RecordContextPtr *)
-	realloc(ppAllContexts, sizeof(RecordContextPtr) * (numContexts + 1));
+        realloc(ppAllContexts, sizeof(RecordContextPtr) * (numContexts + 1));
     if (!ppNewAllContexts)
-	goto bailout;
+        goto bailout;
     ppAllContexts = ppNewAllContexts;
 
     pContext->id = stuff->context;
@@ -1948,44 +1868,42 @@ ProcRecordCreateContext(ClientPtr client)
     pContext->inFlush = 0;
 
     err = RecordRegisterClients(pContext, client,
-				(xRecordRegisterClientsReq *)stuff);
+                                (xRecordRegisterClientsReq *) stuff);
     if (err != Success)
-	goto bailout;
+        goto bailout;
 
-    if (AddResource(pContext->id, RTContext, pContext))
-    {
-	ppAllContexts[numContexts++] = pContext;
-	return Success;
+    if (AddResource(pContext->id, RTContext, pContext)) {
+        ppAllContexts[numContexts++] = pContext;
+        return Success;
     }
-    else
-    {
-	RecordDeleteContext((pointer)pContext, pContext->id);
-	return BadAlloc;
+    else {
+        RecordDeleteContext((pointer) pContext, pContext->id);
+        return BadAlloc;
     }
-bailout:
+ bailout:
     free(pContext);
     return err;
-} /* ProcRecordCreateContext */
-
+}                               /* ProcRecordCreateContext */
 
 static int
 ProcRecordRegisterClients(ClientPtr client)
 {
     RecordContextPtr pContext;
+
     REQUEST(xRecordRegisterClientsReq);
 
     REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
     VERIFY_CONTEXT(pContext, stuff->context, client);
 
     return RecordRegisterClients(pContext, client, stuff);
-} /* ProcRecordRegisterClients */
-
+}                               /* ProcRecordRegisterClients */
 
 static int
 ProcRecordUnregisterClients(ClientPtr client)
 {
     RecordContextPtr pContext;
     int err;
+
     REQUEST(xRecordUnregisterClientsReq);
     XID *pCanonClients;
     int nClients;
@@ -1993,29 +1911,27 @@ ProcRecordUnregisterClients(ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xRecordUnregisterClientsReq);
     if ((client->req_len << 2) - SIZEOF(xRecordUnregisterClientsReq) !=
-	4 * stuff->nClients)
-	return BadLength;
+        4 * stuff->nClients)
+        return BadLength;
     VERIFY_CONTEXT(pContext, stuff->context, client);
-    err = RecordSanityCheckClientSpecifiers(client, (XID *)&stuff[1],
-					    stuff->nClients, 0);
+    err = RecordSanityCheckClientSpecifiers(client, (XID *) &stuff[1],
+                                            stuff->nClients, 0);
     if (err != Success)
-	return err;
+        return err;
 
     nClients = stuff->nClients;
-    pCanonClients = RecordCanonicalizeClientSpecifiers((XID *)&stuff[1],
-						 &nClients, 0);
+    pCanonClients = RecordCanonicalizeClientSpecifiers((XID *) &stuff[1],
+                                                       &nClients, 0);
     if (!pCanonClients)
-	return BadAlloc;
+        return BadAlloc;
 
-    for (i = 0; i < nClients; i++)
-    {
-	RecordDeleteClientFromContext(pContext, pCanonClients[i]);
+    for (i = 0; i < nClients; i++) {
+        RecordDeleteClientFromContext(pContext, pCanonClients[i]);
     }
-    if (pCanonClients != (XID *)&stuff[1])
-	free(pCanonClients);
+    if (pCanonClients != (XID *) &stuff[1])
+        free(pCanonClients);
     return Success;
-} /* ProcRecordUnregisterClients */
-
+}                               /* ProcRecordUnregisterClients */
 
 /****************************************************************************/
 
@@ -2026,12 +1942,11 @@ ProcRecordUnregisterClients(ClientPtr client)
  */
 
 typedef struct {
-    xRecordRange *pRanges;  /* array of xRecordRanges for one RCAP */
-    int size;		/* number of elements in pRanges, >= nRanges */
-    int nRanges;	/* number of occupied element of pRanges */
+    xRecordRange *pRanges;      /* array of xRecordRanges for one RCAP */
+    int size;                   /* number of elements in pRanges, >= nRanges */
+    int nRanges;                /* number of occupied element of pRanges */
 } GetContextRangeInfoRec, *GetContextRangeInfoPtr;
 
-
 /* RecordAllocRanges
  *
  * Arguments:
@@ -2050,22 +1965,22 @@ RecordAllocRanges(GetContextRangeInfoPtr pri, int nRanges)
 {
     int newsize;
     xRecordRange *pNewRange;
+
 #define SZINCR 8
 
     newsize = max(pri->size + SZINCR, nRanges);
-    pNewRange = (xRecordRange *)realloc(pri->pRanges,
-			 newsize * sizeof(xRecordRange));
+    pNewRange = (xRecordRange *) realloc(pri->pRanges,
+                                         newsize * sizeof(xRecordRange));
     if (!pNewRange)
-	return BadAlloc;
+        return BadAlloc;
 
     pri->pRanges = pNewRange;
     pri->size = newsize;
     memset(&pri->pRanges[pri->size - SZINCR], 0, SZINCR * sizeof(xRecordRange));
     if (pri->nRanges < nRanges)
-	pri->nRanges = nRanges;
+        pri->nRanges = nRanges;
     return Success;
-} /* RecordAllocRanges */
-
+}                               /* RecordAllocRanges */
 
 /* RecordConvertSetToRanges
  *
@@ -2090,14 +2005,10 @@ RecordAllocRanges(GetContextRangeInfoPtr pri, int nRanges)
  *	more than the index of the last xRecordRange that was touched.
  */
 static int
-RecordConvertSetToRanges(
-    RecordSetPtr pSet,
-    GetContextRangeInfoPtr pri,
-    int byteoffset,
-    Bool card8,
-    unsigned int imax,
-    int *pStartIndex
-)
+RecordConvertSetToRanges(RecordSetPtr pSet,
+                         GetContextRangeInfoPtr pri,
+                         int byteoffset,
+                         Bool card8, unsigned int imax, int *pStartIndex)
 {
     int nRanges;
     RecordSetIteratePtr pIter = NULL;
@@ -2107,41 +2018,38 @@ RecordConvertSetToRanges(
     int err;
 
     if (!pSet)
-	return Success;
+        return Success;
 
     nRanges = pStartIndex ? *pStartIndex : 0;
-    while ((pIter = RecordIterateSet(pSet, pIter, &interval)))
-    {
-	if (interval.first > imax) break;
-	if (interval.last  > imax) interval.last = imax;
-	nRanges++;
-	if (nRanges > pri->size)
-	{
-	    err = RecordAllocRanges(pri, nRanges);
-	    if (err != Success)
-		return err;
-	}
-	else
-	    pri->nRanges = max(pri->nRanges, nRanges);
-	if (card8)
-	{
-	    pCARD8 = ((CARD8 *)&pri->pRanges[nRanges-1]) + byteoffset;
-	    *pCARD8++ = interval.first;
-	    *pCARD8   = interval.last;
-	}
-	else
-	{
-	    pCARD16 = (CARD16 *)
-			(((char *)&pri->pRanges[nRanges-1]) + byteoffset);
-	    *pCARD16++ = interval.first;
-	    *pCARD16   = interval.last;
-	}
+    while ((pIter = RecordIterateSet(pSet, pIter, &interval))) {
+        if (interval.first > imax)
+            break;
+        if (interval.last > imax)
+            interval.last = imax;
+        nRanges++;
+        if (nRanges > pri->size) {
+            err = RecordAllocRanges(pri, nRanges);
+            if (err != Success)
+                return err;
+        }
+        else
+            pri->nRanges = max(pri->nRanges, nRanges);
+        if (card8) {
+            pCARD8 = ((CARD8 *) &pri->pRanges[nRanges - 1]) + byteoffset;
+            *pCARD8++ = interval.first;
+            *pCARD8 = interval.last;
+        }
+        else {
+            pCARD16 = (CARD16 *)
+                (((char *) &pri->pRanges[nRanges - 1]) + byteoffset);
+            *pCARD16++ = interval.first;
+            *pCARD16 = interval.last;
+        }
     }
     if (pStartIndex)
-	*pStartIndex = nRanges;
+        *pStartIndex = nRanges;
     return Success;
-} /* RecordConvertSetToRanges */
-
+}                               /* RecordConvertSetToRanges */
 
 /* RecordConvertMinorOpInfoToRanges
  *
@@ -2159,11 +2067,8 @@ RecordConvertSetToRanges(
  *	byteoffset is filled in with the information from pMinOpInfo.
  */
 static int
-RecordConvertMinorOpInfoToRanges(
-    RecordMinorOpPtr pMinOpInfo,
-    GetContextRangeInfoPtr pri,
-    int byteoffset
-)
+RecordConvertMinorOpInfoToRanges(RecordMinorOpPtr pMinOpInfo,
+                                 GetContextRangeInfoPtr pri, int byteoffset)
 {
     int nsets;
     int start;
@@ -2171,28 +2076,28 @@ RecordConvertMinorOpInfoToRanges(
     int err;
 
     if (!pMinOpInfo)
-	return Success;
+        return Success;
 
     nsets = pMinOpInfo->count;
     pMinOpInfo++;
     start = 0;
-    for (i = 0; i < nsets; i++)
-    {
-	int j, s;
-	s = start;
-	err = RecordConvertSetToRanges(pMinOpInfo[i].major.pMinOpSet, pri,
-				byteoffset + 2, FALSE, 65535, &start);
-	if (err != Success) return err;
-	for (j = s; j < start; j++)
-	{
-	    CARD8 *pCARD8 = ((CARD8 *)&pri->pRanges[j]) + byteoffset;
-	    *pCARD8++ = pMinOpInfo[i].major.first;
-	    *pCARD8   = pMinOpInfo[i].major.last;
-	}
+    for (i = 0; i < nsets; i++) {
+        int j, s;
+
+        s = start;
+        err = RecordConvertSetToRanges(pMinOpInfo[i].major.pMinOpSet, pri,
+                                       byteoffset + 2, FALSE, 65535, &start);
+        if (err != Success)
+            return err;
+        for (j = s; j < start; j++) {
+            CARD8 *pCARD8 = ((CARD8 *) &pri->pRanges[j]) + byteoffset;
+
+            *pCARD8++ = pMinOpInfo[i].major.first;
+            *pCARD8 = pMinOpInfo[i].major.last;
+        }
     }
     return Success;
-} /* RecordConvertMinorOpInfoToRanges */
-
+}                               /* RecordConvertMinorOpInfoToRanges */
 
 /* RecordSwapRanges
  *
@@ -2206,23 +2111,23 @@ RecordConvertMinorOpInfoToRanges(
  *	The 16 bit fields of each xRecordRange are byte swapped.
  */
 static void
-RecordSwapRanges(xRecordRange *pRanges, int nRanges)
+RecordSwapRanges(xRecordRange * pRanges, int nRanges)
 {
     int i;
-    for (i = 0; i < nRanges; i++, pRanges++)
-    {
-	swaps(&pRanges->extRequestsMinorFirst);
-	swaps(&pRanges->extRequestsMinorLast);
-	swaps(&pRanges->extRepliesMinorFirst);
-	swaps(&pRanges->extRepliesMinorLast);
-    }
-} /* RecordSwapRanges */
 
+    for (i = 0; i < nRanges; i++, pRanges++) {
+        swaps(&pRanges->extRequestsMinorFirst);
+        swaps(&pRanges->extRequestsMinorLast);
+        swaps(&pRanges->extRepliesMinorFirst);
+        swaps(&pRanges->extRepliesMinorLast);
+    }
+}                               /* RecordSwapRanges */
 
 static int
 ProcRecordGetContext(ClientPtr client)
 {
     RecordContextPtr pContext;
+
     REQUEST(xRecordGetContextReq);
     xRecordGetContextReply rep;
     RecordClientsAndProtocolPtr pRCAP;
@@ -2238,19 +2143,19 @@ ProcRecordGetContext(ClientPtr client)
     /* how many RCAPs are there on this context? */
 
     for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
-	nRCAPs++;
+        nRCAPs++;
 
     /* allocate and initialize space for record range info */
 
-    pRangeInfo = (GetContextRangeInfoPtr)malloc(
-				nRCAPs * sizeof(GetContextRangeInfoRec));
+    pRangeInfo =
+        (GetContextRangeInfoPtr) malloc(nRCAPs *
+                                        sizeof(GetContextRangeInfoRec));
     if (!pRangeInfo && nRCAPs > 0)
-	return BadAlloc;
-    for (i = 0; i < nRCAPs; i++)
-    {
-	pRangeInfo[i].pRanges = NULL;
-	pRangeInfo[i].size = 0;
-	pRangeInfo[i].nRanges = 0;
+        return BadAlloc;
+    for (i = 0; i < nRCAPs; i++) {
+        pRangeInfo[i].pRanges = NULL;
+        pRangeInfo[i].size = 0;
+        pRangeInfo[i].nRanges = 0;
     }
 
     /* convert the RCAP (internal) representation of the recorded protocol
@@ -2259,46 +2164,57 @@ ProcRecordGetContext(ClientPtr client)
      */
 
     for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
-	 pRCAP;
-	 pRCAP = pRCAP->pNextRCAP, pri++)
-    {
-	xRecordRange rr;
-
-	err = RecordConvertSetToRanges(pRCAP->pRequestMajorOpSet, pri,
-			offset_of(rr, coreRequestsFirst), TRUE, 127, NULL);
-	if (err != Success) goto bailout;
-
-	err = RecordConvertSetToRanges(pRCAP->pReplyMajorOpSet, pri,
-			offset_of(rr, coreRepliesFirst), TRUE, 127, NULL);
-	if (err != Success) goto bailout;
-
-	err = RecordConvertSetToRanges(pRCAP->pDeliveredEventSet, pri,
-			offset_of(rr, deliveredEventsFirst), TRUE, 255, NULL);
-	if (err != Success) goto bailout;
-
-	err = RecordConvertSetToRanges(pRCAP->pDeviceEventSet, pri,
-			offset_of(rr, deviceEventsFirst), TRUE, 255, NULL);
-	if (err != Success) goto bailout;
-
-	err = RecordConvertSetToRanges(pRCAP->pErrorSet, pri,
-			      offset_of(rr, errorsFirst), TRUE, 255, NULL);
-	if (err != Success) goto bailout;
-
-	err = RecordConvertMinorOpInfoToRanges(pRCAP->pRequestMinOpInfo,
-				pri, offset_of(rr, extRequestsMajorFirst));
-	if (err != Success) goto bailout;
-
-	err = RecordConvertMinorOpInfoToRanges(pRCAP->pReplyMinOpInfo,
-				pri, offset_of(rr, extRepliesMajorFirst));
-	if (err != Success) goto bailout;
-
-	if (pRCAP->clientStarted || pRCAP->clientDied)
-	{
-	    if (pri->nRanges == 0)
-		RecordAllocRanges(pri, 1);
-	    pri->pRanges[0].clientStarted = pRCAP->clientStarted;
-	    pri->pRanges[0].clientDied    = pRCAP->clientDied;
-	}
+         pRCAP; pRCAP = pRCAP->pNextRCAP, pri++) {
+        xRecordRange rr;
+
+        err = RecordConvertSetToRanges(pRCAP->pRequestMajorOpSet, pri,
+                                       offset_of(rr, coreRequestsFirst), TRUE,
+                                       127, NULL);
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertSetToRanges(pRCAP->pReplyMajorOpSet, pri,
+                                       offset_of(rr, coreRepliesFirst), TRUE,
+                                       127, NULL);
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertSetToRanges(pRCAP->pDeliveredEventSet, pri,
+                                       offset_of(rr, deliveredEventsFirst),
+                                       TRUE, 255, NULL);
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertSetToRanges(pRCAP->pDeviceEventSet, pri,
+                                       offset_of(rr, deviceEventsFirst), TRUE,
+                                       255, NULL);
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertSetToRanges(pRCAP->pErrorSet, pri,
+                                       offset_of(rr, errorsFirst), TRUE, 255,
+                                       NULL);
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertMinorOpInfoToRanges(pRCAP->pRequestMinOpInfo,
+                                               pri, offset_of(rr,
+                                                              extRequestsMajorFirst));
+        if (err != Success)
+            goto bailout;
+
+        err = RecordConvertMinorOpInfoToRanges(pRCAP->pReplyMinOpInfo,
+                                               pri, offset_of(rr,
+                                                              extRepliesMajorFirst));
+        if (err != Success)
+            goto bailout;
+
+        if (pRCAP->clientStarted || pRCAP->clientDied) {
+            if (pri->nRanges == 0)
+                RecordAllocRanges(pri, 1);
+            pri->pRanges[0].clientStarted = pRCAP->clientStarted;
+            pri->pRanges[0].clientDied = pRCAP->clientDied;
+        }
     }
 
     /* calculate number of clients and reply length */
@@ -2306,68 +2222,61 @@ ProcRecordGetContext(ClientPtr client)
     rep.nClients = 0;
     rep.length = 0;
     for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
-	 pRCAP;
-	 pRCAP = pRCAP->pNextRCAP, pri++)
-    {
-	rep.nClients += pRCAP->numClients;
-	rep.length += pRCAP->numClients *
-		( bytes_to_int32(sizeof(xRecordClientInfo)) +
-		  pri->nRanges * bytes_to_int32(sizeof(xRecordRange)));
+         pRCAP; pRCAP = pRCAP->pNextRCAP, pri++) {
+        rep.nClients += pRCAP->numClients;
+        rep.length += pRCAP->numClients *
+            (bytes_to_int32(sizeof(xRecordClientInfo)) +
+             pri->nRanges * bytes_to_int32(sizeof(xRecordRange)));
     }
 
     /* write the reply header */
 
     rep.type = X_Reply;
-    rep.sequenceNumber 	= client->sequence;
+    rep.sequenceNumber = client->sequence;
     rep.enabled = pContext->pRecordingClient != NULL;
     rep.elementHeader = pContext->elemHeaders;
-    if(client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.nClients);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.nClients);
     }
-    (void)WriteToClient(client, sizeof(xRecordGetContextReply),
-			(char *)&rep);
+    (void) WriteToClient(client, sizeof(xRecordGetContextReply), (char *) &rep);
 
     /* write all the CLIENT_INFOs */
 
     for (pRCAP = pContext->pListOfRCAP, pri = pRangeInfo;
-	 pRCAP;
-	 pRCAP = pRCAP->pNextRCAP, pri++)
-    {
-	xRecordClientInfo rci;
-	rci.nRanges = pri->nRanges;
-	if (client->swapped)
-	{
-	    swapl(&rci.nRanges);
-	    RecordSwapRanges(pri->pRanges, pri->nRanges);
-	}
-	for (i = 0; i < pRCAP->numClients; i++)
-	{
-	    rci.clientResource = pRCAP->pClientIDs[i];
-	    if (client->swapped) swapl(&rci.clientResource);
-	    WriteToClient(client, sizeof(xRecordClientInfo), (char *)&rci);
-	    WriteToClient(client, sizeof(xRecordRange) * pri->nRanges,
-			  (char *)pri->pRanges);
-	}
+         pRCAP; pRCAP = pRCAP->pNextRCAP, pri++) {
+        xRecordClientInfo rci;
+
+        rci.nRanges = pri->nRanges;
+        if (client->swapped) {
+            swapl(&rci.nRanges);
+            RecordSwapRanges(pri->pRanges, pri->nRanges);
+        }
+        for (i = 0; i < pRCAP->numClients; i++) {
+            rci.clientResource = pRCAP->pClientIDs[i];
+            if (client->swapped)
+                swapl(&rci.clientResource);
+            WriteToClient(client, sizeof(xRecordClientInfo), (char *) &rci);
+            WriteToClient(client, sizeof(xRecordRange) * pri->nRanges,
+                          (char *) pri->pRanges);
+        }
     }
     err = Success;
 
-bailout:
-    for (i = 0; i < nRCAPs; i++)
-    {
-	free(pRangeInfo[i].pRanges);
+ bailout:
+    for (i = 0; i < nRCAPs; i++) {
+        free(pRangeInfo[i].pRanges);
     }
     free(pRangeInfo);
     return err;
-} /* ProcRecordGetContext */
-
+}                               /* ProcRecordGetContext */
 
 static int
 ProcRecordEnableContext(ClientPtr client)
 {
     RecordContextPtr pContext;
+
     REQUEST(xRecordEnableContextReq);
     int i;
     RecordClientsAndProtocolPtr pRCAP;
@@ -2375,24 +2284,23 @@ ProcRecordEnableContext(ClientPtr client)
     REQUEST_SIZE_MATCH(xRecordGetContextReq);
     VERIFY_CONTEXT(pContext, stuff->context, client);
     if (pContext->pRecordingClient)
-	return BadMatch; /* already enabled */
+        return BadMatch;        /* already enabled */
 
     /* install record hooks for each RCAP */
 
-    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
-    {
-	int err = RecordInstallHooks(pRCAP, 0);
-	if (err != Success)
-	{ /* undo the previous installs */
-	    RecordClientsAndProtocolPtr pUninstallRCAP;
-	    for (pUninstallRCAP = pContext->pListOfRCAP;
-		 pUninstallRCAP != pRCAP;
-		 pUninstallRCAP = pUninstallRCAP->pNextRCAP)
-	    {
-		RecordUninstallHooks(pUninstallRCAP, 0);
-	    }
-	    return err;
-	}
+    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP) {
+        int err = RecordInstallHooks(pRCAP, 0);
+
+        if (err != Success) {   /* undo the previous installs */
+            RecordClientsAndProtocolPtr pUninstallRCAP;
+
+            for (pUninstallRCAP = pContext->pListOfRCAP;
+                 pUninstallRCAP != pRCAP;
+                 pUninstallRCAP = pUninstallRCAP->pNextRCAP) {
+                RecordUninstallHooks(pUninstallRCAP, 0);
+            }
+            return err;
+        }
     }
 
     /* Disallow further request processing on this connection until
@@ -2403,17 +2311,16 @@ ProcRecordEnableContext(ClientPtr client)
 
     /* Don't allow the data connection to record itself; unregister it. */
     RecordDeleteClientFromContext(pContext,
-				  pContext->pRecordingClient->clientAsMask);
+                                  pContext->pRecordingClient->clientAsMask);
 
     /* move the newly enabled context to the front part of ppAllContexts,
      * where all the enabled contexts are
      */
     i = RecordFindContextOnAllContexts(pContext);
     assert(i >= numEnabledContexts);
-    if (i != numEnabledContexts)
-    {
-	ppAllContexts[i] = ppAllContexts[numEnabledContexts];
-	ppAllContexts[numEnabledContexts] = pContext;
+    if (i != numEnabledContexts) {
+        ppAllContexts[i] = ppAllContexts[numEnabledContexts];
+        ppAllContexts[numEnabledContexts] = pContext;
     }
 
     ++numEnabledContexts;
@@ -2423,8 +2330,7 @@ ProcRecordEnableContext(ClientPtr client)
     RecordAProtocolElement(pContext, NULL, XRecordStartOfData, NULL, 0, 0, 0);
     RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
     return Success;
-} /* ProcRecordEnableContext */
-
+}                               /* ProcRecordEnableContext */
 
 /* RecordDisableContext
  *
@@ -2448,18 +2354,17 @@ RecordDisableContext(RecordContextPtr pContext)
     RecordClientsAndProtocolPtr pRCAP;
     int i;
 
-    if (!pContext->pRecordingClient) return;
-    if (!pContext->pRecordingClient->clientGone)
-    {
-	RecordAProtocolElement(pContext, NULL, XRecordEndOfData, NULL, 0, 0, 0);
-	RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
-	/* Re-enable request processing on this connection. */
-	AttendClient(pContext->pRecordingClient);
+    if (!pContext->pRecordingClient)
+        return;
+    if (!pContext->pRecordingClient->clientGone) {
+        RecordAProtocolElement(pContext, NULL, XRecordEndOfData, NULL, 0, 0, 0);
+        RecordFlushReplyBuffer(pContext, NULL, 0, NULL, 0);
+        /* Re-enable request processing on this connection. */
+        AttendClient(pContext->pRecordingClient);
     }
 
-    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP)
-    {
-	RecordUninstallHooks(pRCAP, 0);
+    for (pRCAP = pContext->pListOfRCAP; pRCAP; pRCAP = pRCAP->pNextRCAP) {
+        RecordUninstallHooks(pRCAP, 0);
     }
 
     pContext->pRecordingClient = NULL;
@@ -2468,29 +2373,27 @@ RecordDisableContext(RecordContextPtr pContext)
      * where all the disabled contexts are
      */
     i = RecordFindContextOnAllContexts(pContext);
-    assert( (i != -1) && (i < numEnabledContexts) );
-    if (i != (numEnabledContexts - 1) )
-    {
-	ppAllContexts[i] = ppAllContexts[numEnabledContexts-1];
-	ppAllContexts[numEnabledContexts-1] = pContext;
+    assert((i != -1) && (i < numEnabledContexts));
+    if (i != (numEnabledContexts - 1)) {
+        ppAllContexts[i] = ppAllContexts[numEnabledContexts - 1];
+        ppAllContexts[numEnabledContexts - 1] = pContext;
     }
     --numEnabledContexts;
     assert(numEnabledContexts >= 0);
-} /* RecordDisableContext */
-
+}                               /* RecordDisableContext */
 
 static int
 ProcRecordDisableContext(ClientPtr client)
 {
     RecordContextPtr pContext;
+
     REQUEST(xRecordDisableContextReq);
 
     REQUEST_SIZE_MATCH(xRecordDisableContextReq);
     VERIFY_CONTEXT(pContext, stuff->context, client);
     RecordDisableContext(pContext);
     return Success;
-} /* ProcRecordDisableContext */
-
+}                               /* ProcRecordDisableContext */
 
 /* RecordDeleteContext
  *
@@ -2508,7 +2411,7 @@ static int
 RecordDeleteContext(pointer value, XID id)
 {
     int i;
-    RecordContextPtr pContext = (RecordContextPtr)value;
+    RecordContextPtr pContext = (RecordContextPtr) value;
     RecordClientsAndProtocolPtr pRCAP;
 
     RecordDisableContext(pContext);
@@ -2517,74 +2420,68 @@ RecordDeleteContext(pointer value, XID id)
      *  As a result, the RCAPs will be freed.
      */
 
-    while ((pRCAP = pContext->pListOfRCAP))
-    {
-	int numClients = pRCAP->numClients;
-	/* when the last client is deleted, the RCAP will go away. */
-	while(numClients--)
-	{
-	    RecordDeleteClientFromRCAP(pRCAP, numClients);
-	}
+    while ((pRCAP = pContext->pListOfRCAP)) {
+        int numClients = pRCAP->numClients;
+
+        /* when the last client is deleted, the RCAP will go away. */
+        while (numClients--) {
+            RecordDeleteClientFromRCAP(pRCAP, numClients);
+        }
     }
 
     /* remove context from AllContexts list */
 
-    if (-1 != (i = RecordFindContextOnAllContexts(pContext)))
-    {
-	ppAllContexts[i] = ppAllContexts[numContexts - 1];
-	if (--numContexts == 0)
-	{
-	    free(ppAllContexts);
-	    ppAllContexts = NULL;
-	}
+    if (-1 != (i = RecordFindContextOnAllContexts(pContext))) {
+        ppAllContexts[i] = ppAllContexts[numContexts - 1];
+        if (--numContexts == 0) {
+            free(ppAllContexts);
+            ppAllContexts = NULL;
+        }
     }
     free(pContext);
 
     return Success;
-} /* RecordDeleteContext */
-
+}                               /* RecordDeleteContext */
 
 static int
 ProcRecordFreeContext(ClientPtr client)
 {
     RecordContextPtr pContext;
+
     REQUEST(xRecordFreeContextReq);
 
     REQUEST_SIZE_MATCH(xRecordFreeContextReq);
     VERIFY_CONTEXT(pContext, stuff->context, client);
     FreeResource(stuff->context, RT_NONE);
     return Success;
-} /* ProcRecordFreeContext */
-
+}                               /* ProcRecordFreeContext */
 
 static int
 ProcRecordDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-	case X_RecordQueryVersion:
-	    return ProcRecordQueryVersion(client);
-	case X_RecordCreateContext:
-	    return ProcRecordCreateContext(client);
-	case X_RecordRegisterClients:
-	    return ProcRecordRegisterClients(client);
-	case X_RecordUnregisterClients:
-	    return ProcRecordUnregisterClients(client);
-	case X_RecordGetContext:
-	    return ProcRecordGetContext(client);
-	case X_RecordEnableContext:
-	    return ProcRecordEnableContext(client);
-	case X_RecordDisableContext:
-	    return ProcRecordDisableContext(client);
-	case X_RecordFreeContext:
-	    return ProcRecordFreeContext(client);
-       default:
-	    return BadRequest;
+    switch (stuff->data) {
+    case X_RecordQueryVersion:
+        return ProcRecordQueryVersion(client);
+    case X_RecordCreateContext:
+        return ProcRecordCreateContext(client);
+    case X_RecordRegisterClients:
+        return ProcRecordRegisterClients(client);
+    case X_RecordUnregisterClients:
+        return ProcRecordUnregisterClients(client);
+    case X_RecordGetContext:
+        return ProcRecordGetContext(client);
+    case X_RecordEnableContext:
+        return ProcRecordEnableContext(client);
+    case X_RecordDisableContext:
+        return ProcRecordDisableContext(client);
+    case X_RecordFreeContext:
+        return ProcRecordFreeContext(client);
+    default:
+        return BadRequest;
     }
-} /* ProcRecordDispatch */
-
+}                               /* ProcRecordDispatch */
 
 static int
 SProcRecordQueryVersion(ClientPtr client)
@@ -2596,11 +2493,10 @@ SProcRecordQueryVersion(ClientPtr client)
     swaps(&stuff->majorVersion);
     swaps(&stuff->minorVersion);
     return ProcRecordQueryVersion(client);
-} /* SProcRecordQueryVersion */
-
+}                               /* SProcRecordQueryVersion */
 
 static int
-SwapCreateRegister(xRecordRegisterClientsReq *stuff)
+SwapCreateRegister(xRecordRegisterClientsReq * stuff)
 {
     int i;
     XID *pClientID;
@@ -2608,48 +2504,46 @@ SwapCreateRegister(xRecordRegisterClientsReq *stuff)
     swapl(&stuff->context);
     swapl(&stuff->nClients);
     swapl(&stuff->nRanges);
-    pClientID = (XID *)&stuff[1];
-    if (stuff->nClients > stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq))
-	return BadLength;
-    for (i = 0; i < stuff->nClients; i++, pClientID++)
-    {
-	swapl(pClientID);
+    pClientID = (XID *) &stuff[1];
+    if (stuff->nClients >
+        stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq))
+        return BadLength;
+    for (i = 0; i < stuff->nClients; i++, pClientID++) {
+        swapl(pClientID);
     }
-    if (stuff->nRanges > stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq)
-	- stuff->nClients)
-	return BadLength;
-    RecordSwapRanges((xRecordRange *)pClientID, stuff->nRanges);
+    if (stuff->nRanges >
+        stuff->length - bytes_to_int32(sz_xRecordRegisterClientsReq)
+        - stuff->nClients)
+        return BadLength;
+    RecordSwapRanges((xRecordRange *) pClientID, stuff->nRanges);
     return Success;
-} /* SwapCreateRegister */
-
+}                               /* SwapCreateRegister */
 
 static int
 SProcRecordCreateContext(ClientPtr client)
 {
     REQUEST(xRecordCreateContextReq);
-    int			status;
+    int status;
 
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
-    if ((status = SwapCreateRegister((pointer)stuff)) != Success)
-	return status;
+    if ((status = SwapCreateRegister((pointer) stuff)) != Success)
+        return status;
     return ProcRecordCreateContext(client);
-} /* SProcRecordCreateContext */
-
+}                               /* SProcRecordCreateContext */
 
 static int
 SProcRecordRegisterClients(ClientPtr client)
 {
     REQUEST(xRecordRegisterClientsReq);
-    int			status;
+    int status;
 
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
-    if ((status = SwapCreateRegister((pointer)stuff)) != Success)
-	return status;
+    if ((status = SwapCreateRegister((pointer) stuff)) != Success)
+        return status;
     return ProcRecordRegisterClients(client);
-} /* SProcRecordRegisterClients */
-
+}                               /* SProcRecordRegisterClients */
 
 static int
 SProcRecordUnregisterClients(ClientPtr client)
@@ -2662,8 +2556,7 @@ SProcRecordUnregisterClients(ClientPtr client)
     swapl(&stuff->nClients);
     SwapRestL(stuff);
     return ProcRecordUnregisterClients(client);
-} /* SProcRecordUnregisterClients */
-
+}                               /* SProcRecordUnregisterClients */
 
 static int
 SProcRecordGetContext(ClientPtr client)
@@ -2674,7 +2567,7 @@ SProcRecordGetContext(ClientPtr client)
     REQUEST_SIZE_MATCH(xRecordGetContextReq);
     swapl(&stuff->context);
     return ProcRecordGetContext(client);
-} /* SProcRecordGetContext */
+}                               /* SProcRecordGetContext */
 
 static int
 SProcRecordEnableContext(ClientPtr client)
@@ -2685,8 +2578,7 @@ SProcRecordEnableContext(ClientPtr client)
     REQUEST_SIZE_MATCH(xRecordEnableContextReq);
     swapl(&stuff->context);
     return ProcRecordEnableContext(client);
-} /* SProcRecordEnableContext */
-
+}                               /* SProcRecordEnableContext */
 
 static int
 SProcRecordDisableContext(ClientPtr client)
@@ -2697,8 +2589,7 @@ SProcRecordDisableContext(ClientPtr client)
     REQUEST_SIZE_MATCH(xRecordDisableContextReq);
     swapl(&stuff->context);
     return ProcRecordDisableContext(client);
-} /* SProcRecordDisableContext */
-
+}                               /* SProcRecordDisableContext */
 
 static int
 SProcRecordFreeContext(ClientPtr client)
@@ -2709,36 +2600,34 @@ SProcRecordFreeContext(ClientPtr client)
     REQUEST_SIZE_MATCH(xRecordFreeContextReq);
     swapl(&stuff->context);
     return ProcRecordFreeContext(client);
-} /* SProcRecordFreeContext */
-
+}                               /* SProcRecordFreeContext */
 
 static int
 SProcRecordDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-	case X_RecordQueryVersion:
-	    return SProcRecordQueryVersion(client);
-	case X_RecordCreateContext:
-	    return SProcRecordCreateContext(client);
-	case X_RecordRegisterClients:
-	    return SProcRecordRegisterClients(client);
-	case X_RecordUnregisterClients:
-	    return SProcRecordUnregisterClients(client);
-	case X_RecordGetContext:
-	    return SProcRecordGetContext(client);
-	case X_RecordEnableContext:
-	    return SProcRecordEnableContext(client);
-	case X_RecordDisableContext:
-	    return SProcRecordDisableContext(client);
-	case X_RecordFreeContext:
-	    return SProcRecordFreeContext(client);
-       default:
-	    return BadRequest;
+    switch (stuff->data) {
+    case X_RecordQueryVersion:
+        return SProcRecordQueryVersion(client);
+    case X_RecordCreateContext:
+        return SProcRecordCreateContext(client);
+    case X_RecordRegisterClients:
+        return SProcRecordRegisterClients(client);
+    case X_RecordUnregisterClients:
+        return SProcRecordUnregisterClients(client);
+    case X_RecordGetContext:
+        return SProcRecordGetContext(client);
+    case X_RecordEnableContext:
+        return SProcRecordEnableContext(client);
+    case X_RecordDisableContext:
+        return SProcRecordDisableContext(client);
+    case X_RecordFreeContext:
+        return SProcRecordFreeContext(client);
+    default:
+        return BadRequest;
     }
-} /* SProcRecordDispatch */
+}                               /* SProcRecordDispatch */
 
 /* RecordConnectionSetupInfo
  *
@@ -2753,34 +2642,35 @@ SProcRecordDispatch(ClientPtr client)
  *	The connection setup info is sent to the recording client.
  */
 static void
-RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec *pci)
+RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec * pci)
 {
     int prefixsize = SIZEOF(xConnSetupPrefix);
     int restsize = pci->prefix->length * 4;
 
-    if (pci->client->swapped)
-    {
-	char *pConnSetup = (char *)malloc(prefixsize + restsize);
-	if (!pConnSetup)
-	    return;
-	SwapConnSetupPrefix(pci->prefix, (xConnSetupPrefix*)pConnSetup);
-	SwapConnSetupInfo((char*)pci->setup, (char*)(pConnSetup + prefixsize));
-	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			       (pointer)pConnSetup, prefixsize + restsize, 0, 0);
-	free(pConnSetup);
+    if (pci->client->swapped) {
+        char *pConnSetup = (char *) malloc(prefixsize + restsize);
+
+        if (!pConnSetup)
+            return;
+        SwapConnSetupPrefix(pci->prefix, (xConnSetupPrefix *) pConnSetup);
+        SwapConnSetupInfo((char *) pci->setup,
+                          (char *) (pConnSetup + prefixsize));
+        RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
+                               (pointer) pConnSetup, prefixsize + restsize, 0,
+                               0);
+        free(pConnSetup);
     }
-    else
-    {
-	/* don't alloc and copy as in the swapped case; just send the
-	 * data in two pieces
-	 */
-	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->prefix, prefixsize, 0, restsize);
-	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->setup, restsize, 0, /* continuation */ -1);
+    else {
+        /* don't alloc and copy as in the swapped case; just send the
+         * data in two pieces
+         */
+        RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
+                               (pointer) pci->prefix, prefixsize, 0, restsize);
+        RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
+                               (pointer) pci->setup, restsize, 0,
+                               /* continuation */ -1);
     }
-} /* RecordConnectionSetupInfo */
-
+}                               /* RecordConnectionSetupInfo */
 
 /* RecordDeleteContext
  *
@@ -2806,67 +2696,65 @@ RecordConnectionSetupInfo(RecordContextPtr pContext, NewClientInfoRec *pci)
  */
 
 static void
-RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer calldata)
+RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata,
+                         pointer calldata)
 {
-    NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
+    NewClientInfoRec *pci = (NewClientInfoRec *) calldata;
     int i;
     ClientPtr pClient = pci->client;
     RecordContextPtr *ppAllContextsCopy = NULL;
     int numContextsCopy = 0;
 
-    switch (pClient->clientState)
-    {
-    case ClientStateRunning: /* new client */
-	for (i = 0; i < numContexts; i++)
-	{
-	    RecordClientsAndProtocolPtr pRCAP;
-	    RecordContextPtr pContext = ppAllContexts[i];
-
-	    if ((pRCAP = RecordFindClientOnContext(pContext,
-					    XRecordFutureClients, NULL)))
-	    {
-		RecordAddClientToRCAP(pRCAP, pClient->clientAsMask);
-		if (pContext->pRecordingClient && pRCAP->clientStarted)
-		    RecordConnectionSetupInfo(pContext, pci);
-	    }
-	}
-    break;
+    switch (pClient->clientState) {
+    case ClientStateRunning:   /* new client */
+        for (i = 0; i < numContexts; i++) {
+            RecordClientsAndProtocolPtr pRCAP;
+            RecordContextPtr pContext = ppAllContexts[i];
+
+            if ((pRCAP = RecordFindClientOnContext(pContext,
+                                                   XRecordFutureClients, NULL)))
+            {
+                RecordAddClientToRCAP(pRCAP, pClient->clientAsMask);
+                if (pContext->pRecordingClient && pRCAP->clientStarted)
+                    RecordConnectionSetupInfo(pContext, pci);
+            }
+        }
+        break;
 
     case ClientStateGone:
-    case ClientStateRetained: /* client disconnected */
+    case ClientStateRetained:  /* client disconnected */
 
         /* RecordDisableContext modifies contents of ppAllContexts. */
-	numContextsCopy = numContexts;
-	ppAllContextsCopy = malloc(numContextsCopy * sizeof(RecordContextPtr));
-	assert(ppAllContextsCopy);
-	memcpy(ppAllContextsCopy, ppAllContexts, numContextsCopy * sizeof(RecordContextPtr));
-
-	for (i = 0; i < numContextsCopy; i++)
-	{
-	    RecordClientsAndProtocolPtr pRCAP;
-	    RecordContextPtr pContext = ppAllContextsCopy[i];
-	    int pos;
-
-	    if (pContext->pRecordingClient == pClient)
-		RecordDisableContext(pContext);
-	    if ((pRCAP = RecordFindClientOnContext(pContext,
-				    pClient->clientAsMask, &pos)))
-	    {
-		if (pContext->pRecordingClient && pRCAP->clientDied)
-		    RecordAProtocolElement(pContext, pClient,
-					   XRecordClientDied, NULL, 0, 0, 0);
-		RecordDeleteClientFromRCAP(pRCAP, pos);
-	    }
-	}
-
-	free(ppAllContextsCopy);
-    break;
+        numContextsCopy = numContexts;
+        ppAllContextsCopy = malloc(numContextsCopy * sizeof(RecordContextPtr));
+        assert(ppAllContextsCopy);
+        memcpy(ppAllContextsCopy, ppAllContexts,
+               numContextsCopy * sizeof(RecordContextPtr));
+
+        for (i = 0; i < numContextsCopy; i++) {
+            RecordClientsAndProtocolPtr pRCAP;
+            RecordContextPtr pContext = ppAllContextsCopy[i];
+            int pos;
+
+            if (pContext->pRecordingClient == pClient)
+                RecordDisableContext(pContext);
+            if ((pRCAP = RecordFindClientOnContext(pContext,
+                                                   pClient->clientAsMask,
+                                                   &pos))) {
+                if (pContext->pRecordingClient && pRCAP->clientDied)
+                    RecordAProtocolElement(pContext, pClient,
+                                           XRecordClientDied, NULL, 0, 0, 0);
+                RecordDeleteClientFromRCAP(pRCAP, pos);
+            }
+        }
+
+        free(ppAllContextsCopy);
+        break;
 
     default:
-    break;
-    } /* end switch on client state */
-} /* RecordAClientStateChange */
-
+        break;
+    }                           /* end switch on client state */
+}                               /* RecordAClientStateChange */
 
 /* RecordCloseDown
  *
@@ -2880,11 +2768,10 @@ RecordAClientStateChange(CallbackListPtr *pcbl, pointer nulldata, pointer callda
  *	
  */
 static void
-RecordCloseDown(ExtensionEntry *extEntry)
+RecordCloseDown(ExtensionEntry * extEntry)
 {
     DeleteCallback(&ClientStateCallback, RecordAClientStateChange, NULL);
-} /* RecordCloseDown */
-
+}                               /* RecordCloseDown */
 
 /* RecordExtensionInit
  *
@@ -2895,14 +2782,14 @@ RecordCloseDown(ExtensionEntry *extEntry)
  * Side Effects:
  *	Enables the RECORD extension if possible.
  */
-void 
+void
 RecordExtensionInit(void)
 {
     ExtensionEntry *extentry;
 
     RTContext = CreateNewResourceType(RecordDeleteContext, "RecordContext");
     if (!RTContext)
-	return;
+        return;
 
     if (!dixRegisterPrivateKey(RecordClientPrivateKey, PRIVATE_CLIENT, 0))
         return;
@@ -2911,17 +2798,16 @@ RecordExtensionInit(void)
     numContexts = numEnabledContexts = numEnabledRCAPs = 0;
 
     if (!AddCallback(&ClientStateCallback, RecordAClientStateChange, NULL))
-	return;
+        return;
 
     extentry = AddExtension(RECORD_NAME, RecordNumEvents, RecordNumErrors,
-			    ProcRecordDispatch, SProcRecordDispatch,
-			    RecordCloseDown, StandardMinorOpcode);
-    if (!extentry)
-    {
-	DeleteCallback(&ClientStateCallback, RecordAClientStateChange, NULL);
-	return;
+                            ProcRecordDispatch, SProcRecordDispatch,
+                            RecordCloseDown, StandardMinorOpcode);
+    if (!extentry) {
+        DeleteCallback(&ClientStateCallback, RecordAClientStateChange, NULL);
+        return;
     }
-    SetResourceTypeErrorValue(RTContext, extentry->errorBase + XRecordBadContext);
-
-} /* RecordExtensionInit */
+    SetResourceTypeErrorValue(RTContext,
+                              extentry->errorBase + XRecordBadContext);
 
+}                               /* RecordExtensionInit */