configure.ac: Bump to Version 1.12.3

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

Xext/bigreq.c

@@ -43,16 +43,16 @@ from The Open Group.
 void BigReqExtensionInit(INITARGS);
 
 static int
-ProcBigReqDispatch (ClientPtr client)
+ProcBigReqDispatch(ClientPtr client)
 {
     REQUEST(xBigReqEnableReq);
     xBigReqEnableReply rep;
 
     if (client->swapped) {
-	swaps(&stuff->length);
+        swaps(&stuff->length);
     }
     if (stuff->brReqType != X_BigReqEnable)
-	return BadRequest;
+        return BadRequest;
     REQUEST_SIZE_MATCH(xBigReqEnableReq);
     client->big_requests = TRUE;
     memset(&rep, 0, sizeof(xBigReqEnableReply));
@@ -61,10 +61,10 @@ ProcBigReqDispatch (ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.max_request_size = maxBigRequestSize;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.max_request_size);
+        swapl(&rep.max_request_size);
     }
-    WriteToClient(client, sizeof(xBigReqEnableReply), (char *)&rep);
+    WriteToClient(client, sizeof(xBigReqEnableReply), (char *) &rep);
     return Success;
 }
 
@@ -72,6 +72,6 @@ void
 BigReqExtensionInit(INITARGS)
 {
     AddExtension(XBigReqExtensionName, 0, 0,
-		 ProcBigReqDispatch, ProcBigReqDispatch,
+                 ProcBigReqDispatch, ProcBigReqDispatch,
-		 NULL, StandardMinorOpcode);
+                 NULL, StandardMinorOpcode);
 }

Xext/dpms.c

@@ -55,11 +55,11 @@ ProcDPMSGetVersion(ClientPtr client)
     rep.majorVersion = DPMSMajorVersion;
     rep.minorVersion = DPMSMinorVersion;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swaps(&rep.majorVersion);
+        swaps(&rep.majorVersion);
-	swaps(&rep.minorVersion);
+        swaps(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *) &rep);
     return Success;
 }
 
@@ -77,9 +77,9 @@ ProcDPMSCapable(ClientPtr client)
     rep.capable = DPMSCapableFlag;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
     }
-    WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDPMSCapableReply), (char *) &rep);
     return Success;
 }
 
@@ -99,12 +99,12 @@ ProcDPMSGetTimeouts(ClientPtr client)
     rep.off = DPMSOffTime / MILLI_PER_SECOND;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swaps(&rep.standby);
+        swaps(&rep.standby);
-	swaps(&rep.suspend);
+        swaps(&rep.suspend);
-	swaps(&rep.off);
+        swaps(&rep.off);
     }
-    WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *) &rep);
     return Success;
 }
 
@@ -115,15 +115,13 @@ ProcDPMSSetTimeouts(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
 
-    if ((stuff->off != 0)&&(stuff->off < stuff->suspend)) 
+    if ((stuff->off != 0) && (stuff->off < stuff->suspend)) {
-    {
+        client->errorValue = stuff->off;
-	client->errorValue = stuff->off;
+        return BadValue;
-	return BadValue;
     }
-    if ((stuff->suspend != 0)&&(stuff->suspend < stuff->standby))
+    if ((stuff->suspend != 0) && (stuff->suspend < stuff->standby)) {
-    {
+        client->errorValue = stuff->suspend;
-	client->errorValue = stuff->suspend;
+        return BadValue;
-	return BadValue;
     }
 
     DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND;
@@ -142,9 +140,9 @@ ProcDPMSEnable(ClientPtr client)
     REQUEST_SIZE_MATCH(xDPMSEnableReq);
 
     if (DPMSCapableFlag) {
-	DPMSEnabled = TRUE;
+        DPMSEnabled = TRUE;
-	if (!was_enabled)
+        if (!was_enabled)
-	    SetScreenSaverTimer();
+            SetScreenSaverTimer();
     }
 
     return Success;
@@ -172,14 +170,13 @@ ProcDPMSForceLevel(ClientPtr client)
     REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
 
     if (!DPMSEnabled)
-	return BadMatch;
+        return BadMatch;
 
     if (stuff->level != DPMSModeOn &&
         stuff->level != DPMSModeStandby &&
-        stuff->level != DPMSModeSuspend &&
+        stuff->level != DPMSModeSuspend && stuff->level != DPMSModeOff) {
-        stuff->level != DPMSModeOff) {
+        client->errorValue = stuff->level;
-	client->errorValue = stuff->level;
+        return BadValue;
-	return BadValue;
     }
 
     DPMSSet(client, stuff->level);
@@ -202,38 +199,37 @@ ProcDPMSInfo(ClientPtr client)
     rep.state = DPMSEnabled;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swaps(&rep.power_level);
+        swaps(&rep.power_level);
     }
-    WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep);
+    WriteToClient(client, sizeof(xDPMSInfoReply), (char *) &rep);
     return Success;
 }
 
 static int
-ProcDPMSDispatch (ClientPtr client)
+ProcDPMSDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
     case X_DPMSGetVersion:
-	return ProcDPMSGetVersion(client);
+        return ProcDPMSGetVersion(client);
     case X_DPMSCapable:
-	return ProcDPMSCapable(client);
+        return ProcDPMSCapable(client);
     case X_DPMSGetTimeouts:
-	return ProcDPMSGetTimeouts(client);
+        return ProcDPMSGetTimeouts(client);
     case X_DPMSSetTimeouts:
-	return ProcDPMSSetTimeouts(client);
+        return ProcDPMSSetTimeouts(client);
     case X_DPMSEnable:
-	return ProcDPMSEnable(client);
+        return ProcDPMSEnable(client);
     case X_DPMSDisable:
-	return ProcDPMSDisable(client);
+        return ProcDPMSDisable(client);
     case X_DPMSForceLevel:
-	return ProcDPMSForceLevel(client);
+        return ProcDPMSForceLevel(client);
     case X_DPMSInfo:
-	return ProcDPMSInfo(client);
+        return ProcDPMSInfo(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -332,29 +328,28 @@ SProcDPMSInfo(ClientPtr client)
 }
 
 static int
-SProcDPMSDispatch (ClientPtr client)
+SProcDPMSDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
     case X_DPMSGetVersion:
-	return SProcDPMSGetVersion(client);
+        return SProcDPMSGetVersion(client);
     case X_DPMSCapable:
-	return SProcDPMSCapable(client);
+        return SProcDPMSCapable(client);
     case X_DPMSGetTimeouts:
-	return SProcDPMSGetTimeouts(client);
+        return SProcDPMSGetTimeouts(client);
     case X_DPMSSetTimeouts:
-	return SProcDPMSSetTimeouts(client);
+        return SProcDPMSSetTimeouts(client);
     case X_DPMSEnable:
-	return SProcDPMSEnable(client);
+        return SProcDPMSEnable(client);
     case X_DPMSDisable:
-	return SProcDPMSDisable(client);
+        return SProcDPMSDisable(client);
     case X_DPMSForceLevel:
-	return SProcDPMSForceLevel(client);
+        return SProcDPMSForceLevel(client);
     case X_DPMSInfo:
-	return SProcDPMSInfo(client);
+        return SProcDPMSInfo(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -362,6 +357,6 @@ void
 DPMSExtensionInit(INITARGS)
 {
     AddExtension(DPMSExtensionName, 0, 0,
-		 ProcDPMSDispatch, SProcDPMSDispatch,
+                 ProcDPMSDispatch, SProcDPMSDispatch,
-		 NULL, StandardMinorOpcode);
+                 NULL, StandardMinorOpcode);
 }

Xext/dpmsproc.h

@@ -9,7 +9,7 @@
 
 #include "dixstruct.h"
 
-int  DPMSSet(ClientPtr client, int level);
+int DPMSSet(ClientPtr client, int level);
 Bool DPMSSupported(void);
 
 #endif

Xext/dpmsstubs.c

@@ -34,12 +34,14 @@ Equipment Corporation.
 
 #define FALSE 0
 
-Bool DPMSSupported(void)
+Bool
+DPMSSupported(void)
 {
     return FALSE;
 }
 
-int DPMSSet(ClientPtr client, int level)
+int
+DPMSSet(ClientPtr client, int level)
 {
     return Success;
 }

Xext/geext.c

@@ -35,18 +35,18 @@
 
 DevPrivateKeyRec GEClientPrivateKeyRec;
 
-int RT_GECLIENT  = 0;
+int RT_GECLIENT = 0;
 
 GEExtension GEExtensions[MAXEXTENSIONS];
 
 /* Major available requests */
 static const int version_requests[] = {
-    X_GEQueryVersion,	/* before client sends QueryVersion */
+    X_GEQueryVersion,           /* before client sends QueryVersion */
-    X_GEQueryVersion,	/* must be set to last request in version 1 */
+    X_GEQueryVersion,           /* must be set to last request in version 1 */
 };
 
 /* Forward declarations */
-static void SGEGenericEvent(xEvent* from, xEvent* to);
+static void SGEGenericEvent(xEvent *from, xEvent *to);
 
 #define NUM_VERSION_REQUESTS	(sizeof (version_requests) / sizeof (version_requests[0]))
 #define EXT_MASK(ext) ((ext) & 0x7F)
@@ -60,6 +60,7 @@ ProcGEQueryVersion(ClientPtr client)
 {
     GEClientInfoPtr pGEClient = GEGetClient(client);
     xGEQueryVersionReply rep;
+
     REQUEST(xGEQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xGEQueryVersionReq);
@@ -77,22 +78,20 @@ ProcGEQueryVersion(ClientPtr client)
     pGEClient->major_version = stuff->majorVersion;
     pGEClient->minor_version = stuff->minorVersion;
 
-    if (client->swapped)
+    if (client->swapped) {
-    {
+        swaps(&rep.sequenceNumber);
-	swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
-	swapl(&rep.length);
+        swaps(&rep.majorVersion);
-	swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
-	swaps(&rep.minorVersion);
     }
 
-    WriteToClient(client, sizeof(xGEQueryVersionReply), (char*)&rep);
+    WriteToClient(client, sizeof(xGEQueryVersionReply), (char *) &rep);
     return Success;
 }
 
-int (*ProcGEVector[GENumberRequests])(ClientPtr) = {
+int (*ProcGEVector[GENumberRequests]) (ClientPtr) = {
     /* Version 1.0 */
-    ProcGEQueryVersion
+ProcGEQueryVersion};
-};
 
 /************************************************************/
 /*                swapped request handlers                  */
@@ -106,14 +105,12 @@ SProcGEQueryVersion(ClientPtr client)
     REQUEST_SIZE_MATCH(xGEQueryVersionReq);
     swaps(&stuff->majorVersion);
     swaps(&stuff->minorVersion);
-    return(*ProcGEVector[stuff->ReqType])(client);
+    return (*ProcGEVector[stuff->ReqType]) (client);
 }
 
-int (*SProcGEVector[GENumberRequests])(ClientPtr) = {
+int (*SProcGEVector[GENumberRequests]) (ClientPtr) = {
     /* Version 1.0 */
-    SProcGEQueryVersion
+SProcGEQueryVersion};
-};
-
 
 /************************************************************/
 /*                callbacks                                 */
@@ -124,6 +121,7 @@ static int
 ProcGEDispatch(ClientPtr client)
 {
     GEClientInfoPtr pGEClient = GEGetClient(client);
+
     REQUEST(xGEReq);
 
     if (pGEClient->major_version >= NUM_VERSION_REQUESTS)
@@ -131,7 +129,7 @@ ProcGEDispatch(ClientPtr client)
     if (stuff->ReqType > version_requests[pGEClient->major_version])
         return BadRequest;
 
-    return (ProcGEVector[stuff->ReqType])(client);
+    return (ProcGEVector[stuff->ReqType]) (client);
 }
 
 /* dispatch swapped requests */
@@ -141,7 +139,7 @@ SProcGEDispatch(ClientPtr client)
     REQUEST(xGEReq);
     if (stuff->ReqType >= GENumberRequests)
         return BadRequest;
-    return (*SProcGEVector[stuff->ReqType])(client);
+    return (*SProcGEVector[stuff->ReqType]) (client);
 }
 
 /**
@@ -151,13 +149,11 @@ SProcGEDispatch(ClientPtr client)
  * used in the furture for versioning support.
  */
 static void
-GEClientCallback(CallbackListPtr *list,
+GEClientCallback(CallbackListPtr *list, pointer closure, pointer data)
-                 pointer closure,
-                 pointer data)
 {
-    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
+    NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
-    ClientPtr		pClient = clientinfo->client;
+    ClientPtr pClient = clientinfo->client;
-    GEClientInfoPtr     pGEClient = GEGetClient(pClient);
+    GEClientInfoPtr pGEClient = GEGetClient(pClient);
 
     pGEClient->major_version = 0;
     pGEClient->minor_version = 0;
@@ -165,7 +161,7 @@ GEClientCallback(CallbackListPtr *list,
 
 /* Reset extension. Called on server shutdown. */
 static void
-GEResetProc(ExtensionEntry *extEntry)
+GEResetProc(ExtensionEntry * extEntry)
 {
     DeleteCallback(&ClientStateCallback, GEClientCallback, 0);
     EventSwapVector[GenericEvent] = NotImplemented;
@@ -179,13 +175,12 @@ GEResetProc(ExtensionEntry *extEntry)
  *  work.
  */
 static void
-SGEGenericEvent(xEvent* from, xEvent* to)
+SGEGenericEvent(xEvent *from, xEvent *to)
 {
-    xGenericEvent* gefrom = (xGenericEvent*)from;
+    xGenericEvent *gefrom = (xGenericEvent *) from;
-    xGenericEvent* geto = (xGenericEvent*)to;
+    xGenericEvent *geto = (xGenericEvent *) to;
 
-    if ((gefrom->extension & 0x7f) > MAXEXTENSIONS)
+    if ((gefrom->extension & 0x7f) > MAXEXTENSIONS) {
-    {
         ErrorF("GE: Invalid extension offset for event.\n");
         return;
     }
@@ -203,23 +198,23 @@ GEExtensionInit(void)
 {
     ExtensionEntry *extEntry;
 
-    if (!dixRegisterPrivateKey(&GEClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(GEClientInfoRec)))
+    if (!dixRegisterPrivateKey
+        (&GEClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(GEClientInfoRec)))
         FatalError("GEExtensionInit: GE private request failed.\n");
 
-    if(!AddCallback(&ClientStateCallback, GEClientCallback, 0))
+    if (!AddCallback(&ClientStateCallback, GEClientCallback, 0)) {
-    {
         FatalError("GEExtensionInit: register client callback failed.\n");
     }
 
-    if((extEntry = AddExtension(GE_NAME,
+    if ((extEntry = AddExtension(GE_NAME,
-                        0, GENumberErrors,
+                                 0, GENumberErrors,
-                        ProcGEDispatch, SProcGEDispatch,
+                                 ProcGEDispatch, SProcGEDispatch,
-                        GEResetProc, StandardMinorOpcode)) != 0)
+                                 GEResetProc, StandardMinorOpcode)) != 0) {
-    {
         memset(GEExtensions, 0, sizeof(GEExtensions));
 
         EventSwapVector[GenericEvent] = (EventSwapPtr) SGEGenericEvent;
-    } else {
+    }
+    else {
         FatalError("GEInit: AddExtensions failed.\n");
     }
 
@@ -238,24 +233,22 @@ GEExtensionInit(void)
  */
 void
 GERegisterExtension(int extension,
-                    void (*ev_swap)(xGenericEvent* from, xGenericEvent* to))
+                    void (*ev_swap) (xGenericEvent *from, xGenericEvent *to))
 {
-    if (EXT_MASK(extension) >=  MAXEXTENSIONS)
+    if (EXT_MASK(extension) >= MAXEXTENSIONS)
         FatalError("GE: extension > MAXEXTENSIONS. This should not happen.\n");
 
     /* extension opcodes are > 128, might as well save some space here */
     GEExtensions[EXT_MASK(extension)].evswap = ev_swap;
 }
 
-
 /* Sets type and extension field for a generic event. This is just an
  * auxiliary function, extensions could do it manually too.
  */
 void
-GEInitEvent(xGenericEvent* ev, int extension)
+GEInitEvent(xGenericEvent *ev, int extension)
 {
     ev->type = GenericEvent;
     ev->extension = extension;
     ev->length = 0;
 }
-

Xext/geext.h

@@ -37,10 +37,9 @@ from the author.
 /** Struct to keep information about registered extensions */
 typedef struct _GEExtension {
     /** Event swapping routine */
-    void (*evswap)(xGenericEvent* from, xGenericEvent* to);
+    void (*evswap) (xGenericEvent *from, xGenericEvent *to);
 } GEExtension, *GEExtensionPtr;
 
-
 /* All registered extensions and their handling functions. */
 extern _X_EXPORT GEExtension GEExtensions[MAXEXTENSIONS];
 
@@ -70,14 +69,15 @@ extern _X_EXPORT GEExtension GEExtensions[MAXEXTENSIONS];
          GEEXT(ev) == (ext) && \
          GEV(ev)->evtype == (ev_type))
 
-
 /* Interface for other extensions */
-extern _X_EXPORT void GERegisterExtension(
+extern _X_EXPORT void GERegisterExtension(int extension,
-        int extension,
+                                          void (*ev_dispatch) (xGenericEvent
-        void (*ev_dispatch)(xGenericEvent* from, xGenericEvent* to));
+                                                               *from,
+                                                               xGenericEvent
+                                                               *to));
 
-extern _X_EXPORT void GEInitEvent(xGenericEvent* ev, int extension);
+extern _X_EXPORT void GEInitEvent(xGenericEvent *ev, int extension);
 
 extern _X_EXPORT void GEExtensionInit(void);
 
-#endif /* _GEEXT_H_ */
+#endif                          /* _GEEXT_H_ */

Xext/geint.h

@@ -38,16 +38,17 @@
 #include <X11/extensions/geproto.h>
 
 extern _X_EXPORT DevPrivateKeyRec GEClientPrivateKeyRec;
+
 #define GEClientPrivateKey (&GEClientPrivateKeyRec)
 
 typedef struct _GEClientInfo {
-    CARD32  major_version;
+    CARD32 major_version;
-    CARD32  minor_version;
+    CARD32 minor_version;
 } GEClientInfoRec, *GEClientInfoPtr;
 
 #define GEGetClient(pClient)    ((GEClientInfoPtr)(dixLookupPrivate(&((pClient)->devPrivates), GEClientPrivateKey)))
 
-extern _X_EXPORT int (*ProcGEVector[/*GENumRequests*/])(ClientPtr);
+extern _X_EXPORT int (*ProcGEVector[ /*GENumRequests */ ]) (ClientPtr);
-extern _X_EXPORT int (*SProcGEVector[/*GENumRequests*/])(ClientPtr);
+extern _X_EXPORT int (*SProcGEVector[ /*GENumRequests */ ]) (ClientPtr);
 
-#endif /* _GEINT_H_ */
+#endif                          /* _GEINT_H_ */

Xext/panoramiX.h

@@ -26,7 +26,6 @@ Equipment Corporation.
 
 ******************************************************************/
 
-
 /* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */
 
 /*  
@@ -47,25 +46,25 @@ Equipment Corporation.
 #include "dixstruct.h"
 
 typedef struct _PanoramiXInfo {
-    XID id ;
+    XID id;
 } PanoramiXInfo;
 
 typedef struct {
     PanoramiXInfo info[MAXSCREENS];
     RESTYPE type;
     union {
-	struct {
+        struct {
-	    char   visibility;
+            char visibility;
-	    char   class;
+            char class;
-            char   root;
+            char root;
-	} win;
+        } win;
-	struct {
+        struct {
-	    Bool shared;
+            Bool shared;
-	} pix;
+        } pix;
-	struct {
+        struct {
-	    Bool root;
+            Bool root;
-	} pict;
+        } pict;
-	char raw_data[4];
+        char raw_data[4];
     } u;
 } PanoramiXRes;
 
@@ -77,4 +76,4 @@ typedef struct {
 #define IS_SHARED_PIXMAP(r) (((r)->type == XRT_PIXMAP) && (r)->u.pix.shared)
 
 #define IS_ROOT_DRAWABLE(d) (((d)->type == XRT_WINDOW) && (d)->u.win.root)
-#endif /* _PANORAMIX_H_ */
+#endif                          /* _PANORAMIX_H_ */

Xext/panoramiXSwap.c

@@ -48,89 +48,86 @@ Equipment Corporation.
 #include "panoramiXh.h"
 
 static int
-SProcPanoramiXQueryVersion (ClientPtr client)
+SProcPanoramiXQueryVersion(ClientPtr client)
 {
-	REQUEST(xPanoramiXQueryVersionReq);
+    REQUEST(xPanoramiXQueryVersionReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
+    REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
-	return ProcPanoramiXQueryVersion(client);
+    return ProcPanoramiXQueryVersion(client);
 }
 
 static int
 SProcPanoramiXGetState(ClientPtr client)
 {
-	REQUEST(xPanoramiXGetStateReq);
+    REQUEST(xPanoramiXGetStateReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
+    REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
-	swapl(&stuff->window);
+    swapl(&stuff->window);
-	return ProcPanoramiXGetState(client);
+    return ProcPanoramiXGetState(client);
 }
 
 static int
 SProcPanoramiXGetScreenCount(ClientPtr client)
 {
-	REQUEST(xPanoramiXGetScreenCountReq);
+    REQUEST(xPanoramiXGetScreenCountReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
+    REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
-	swapl(&stuff->window);
+    swapl(&stuff->window);
-	return ProcPanoramiXGetScreenCount(client);
+    return ProcPanoramiXGetScreenCount(client);
 }
 
 static int
 SProcPanoramiXGetScreenSize(ClientPtr client)
 {
-	REQUEST(xPanoramiXGetScreenSizeReq);
+    REQUEST(xPanoramiXGetScreenSizeReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+    REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
-	swapl(&stuff->window);
+    swapl(&stuff->window);
-	swapl(&stuff->screen);
+    swapl(&stuff->screen);
-	return ProcPanoramiXGetScreenSize(client);
+    return ProcPanoramiXGetScreenSize(client);
 }
 
-
 static int
 SProcXineramaIsActive(ClientPtr client)
 {
-	REQUEST(xXineramaIsActiveReq);
+    REQUEST(xXineramaIsActiveReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
+    REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
-	return ProcXineramaIsActive(client);
+    return ProcXineramaIsActive(client);
 }
 
-
 static int
 SProcXineramaQueryScreens(ClientPtr client)
 {
-	REQUEST(xXineramaQueryScreensReq);
+    REQUEST(xXineramaQueryScreensReq);
 
-	swaps(&stuff->length);
+    swaps(&stuff->length);
-	REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
+    REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
-	return ProcXineramaQueryScreens(client);
+    return ProcXineramaQueryScreens(client);
 }
 
-
 int
-SProcPanoramiXDispatch (ClientPtr client)
+SProcPanoramiXDispatch(ClientPtr client)
-{   REQUEST(xReq);
+{
-    switch (stuff->data)
+    REQUEST(xReq);
-    {
+    switch (stuff->data) {
-	case X_PanoramiXQueryVersion:
+    case X_PanoramiXQueryVersion:
-	     return SProcPanoramiXQueryVersion(client);
+        return SProcPanoramiXQueryVersion(client);
-	case X_PanoramiXGetState:
+    case X_PanoramiXGetState:
-	     return SProcPanoramiXGetState(client);
+        return SProcPanoramiXGetState(client);
-	case X_PanoramiXGetScreenCount:
+    case X_PanoramiXGetScreenCount:
-	     return SProcPanoramiXGetScreenCount(client);
+        return SProcPanoramiXGetScreenCount(client);
-	case X_PanoramiXGetScreenSize:
+    case X_PanoramiXGetScreenSize:
-	     return SProcPanoramiXGetScreenSize(client);
+        return SProcPanoramiXGetScreenSize(client);
-	case X_XineramaIsActive:
+    case X_XineramaIsActive:
-	     return SProcXineramaIsActive(client);
+        return SProcXineramaIsActive(client);
-	case X_XineramaQueryScreens:
+    case X_XineramaQueryScreens:
-	     return SProcXineramaQueryScreens(client);
+        return SProcXineramaQueryScreens(client);
     }
     return BadRequest;
 }

Xext/panoramiXh.h

@@ -70,4 +70,4 @@ extern int SProcPanoramiXDispatch(ClientPtr client);
 extern int connBlockScreenStart;
 extern xConnSetupPrefix connSetupPrefix;
 
-extern int (* SavedProcVector[256]) (ClientPtr client);
+extern int (*SavedProcVector[256]) (ClientPtr client);

Xext/panoramiXsrv.h

@@ -15,8 +15,9 @@ extern _X_EXPORT int PanoramiXPixHeight;
 extern _X_EXPORT VisualID PanoramiXTranslateVisualID(int screen, VisualID orig);
 extern _X_EXPORT void PanoramiXConsolidate(void);
 extern _X_EXPORT Bool PanoramiXCreateConnectionBlock(void);
-extern _X_EXPORT PanoramiXRes * PanoramiXFindIDByScrnum(RESTYPE, XID, int);
+extern _X_EXPORT PanoramiXRes *PanoramiXFindIDByScrnum(RESTYPE, XID, int);
-extern _X_EXPORT Bool XineramaRegisterConnectionBlockCallback(void (*func)(void));
+extern _X_EXPORT Bool
+XineramaRegisterConnectionBlockCallback(void (*func) (void));
 extern _X_EXPORT int XineramaDeleteResource(pointer, XID);
 
 extern _X_EXPORT void XineramaReinitData(void);
@@ -35,24 +36,20 @@ extern _X_EXPORT RESTYPE XRT_PICTURE;
  * layers agree that the visuals are equal.  The first visual is always from
  * screen 0.
  */
-typedef Bool (*XineramaVisualsEqualProcPtr)(VisualPtr, ScreenPtr, VisualPtr);
+typedef Bool (*XineramaVisualsEqualProcPtr) (VisualPtr, ScreenPtr, VisualPtr);
 extern _X_EXPORT XineramaVisualsEqualProcPtr XineramaVisualsEqualPtr;
 
-extern _X_EXPORT void XineramaGetImageData(
+extern _X_EXPORT void XineramaGetImageData(DrawablePtr *pDrawables,
-    DrawablePtr *pDrawables,
+                                           int left,
-    int left,
+                                           int top,
-    int top,
+                                           int width,
-    int width, 
+                                           int height,
-    int height,
+                                           unsigned int format,
-    unsigned int format,
+                                           unsigned long planemask,
-    unsigned long planemask,
+                                           char *data, int pitch, Bool isRoot);
-    char *data,
-    int pitch,
-    Bool isRoot
-);
 
-static inline void panoramix_setup_ids(PanoramiXRes *resource, 
+static inline void
-                                       ClientPtr client, XID base_id)
+panoramix_setup_ids(PanoramiXRes * resource, ClientPtr client, XID base_id)
 {
     int j;
 
@@ -62,4 +59,4 @@ static inline void panoramix_setup_ids(PanoramiXRes *resource,
     }
 }
 
-#endif /* _PANORAMIXSRV_H_ */
+#endif                          /* _PANORAMIXSRV_H_ */

Xext/securitysrv.h

@@ -32,52 +32,51 @@ from The Open Group.
 
 /* Allow client side portions of <X11/extensions/security.h> to compile */
 #ifndef Status
-# define Status int
+#define Status int
-# define NEED_UNDEF_Status
+#define NEED_UNDEF_Status
 #endif
 #ifndef Display
-# define Display void
+#define Display void
-# define NEED_UNDEF_Display
+#define NEED_UNDEF_Display
 #endif
 
 #include <X11/extensions/secur.h>
 
 #ifdef NEED_UNDEF_Status
-# undef Status
+#undef Status
-# undef NEED_UNDEF_Status
+#undef NEED_UNDEF_Status
 #endif
 #ifdef NEED_UNDEF_Display
-# undef Display
+#undef Display
-# undef NEED_UNDEF_Display
+#undef NEED_UNDEF_Display
 #endif
 
-
+#include "input.h"              /* for DeviceIntPtr */
-#include "input.h"    /* for DeviceIntPtr */
+#include "property.h"           /* for PropertyPtr */
-#include "property.h" /* for PropertyPtr */
+#include "pixmap.h"             /* for DrawablePtr */
-#include "pixmap.h"   /* for DrawablePtr */
+#include "resource.h"           /* for RESTYPE */
-#include "resource.h" /* for RESTYPE */
 
 /* resource type to pass in LookupIDByType for authorizations */
 extern RESTYPE SecurityAuthorizationResType;
 
 /* this is what we store for an authorization */
 typedef struct {
-    XID id;			/* resource ID */
+    XID id;                     /* resource ID */
-    CARD32 timeout;	/* how long to live in seconds after refcnt == 0 */
+    CARD32 timeout;             /* how long to live in seconds after refcnt == 0 */
-    unsigned int trustLevel;	/* trusted/untrusted */
+    unsigned int trustLevel;    /* trusted/untrusted */
-    XID group;			/* see embedding extension */
+    XID group;                  /* see embedding extension */
-    unsigned int refcnt;	/* how many clients connected with this auth */
+    unsigned int refcnt;        /* how many clients connected with this auth */
-    unsigned int secondsRemaining; /* overflow time amount for >49 days */
+    unsigned int secondsRemaining;      /* overflow time amount for >49 days */
-    OsTimerPtr timer;		/* timer for this auth */
+    OsTimerPtr timer;           /* timer for this auth */
     struct _OtherClients *eventClients; /* clients wanting events */
 } SecurityAuthorizationRec, *SecurityAuthorizationPtr;
 
 typedef struct {
-    XID group;	/* the group that was sent in GenerateAuthorization */
+    XID group;                  /* the group that was sent in GenerateAuthorization */
-    Bool valid; /* did anyone recognize it? if so, set to TRUE */
+    Bool valid;                 /* did anyone recognize it? if so, set to TRUE */
 } SecurityValidateGroupInfoRec;
 
 /* Give this value or higher to the -audit option to get security messages */
 #define SECURITY_AUDIT_LEVEL 4
 
-#endif /* _SECURITY_SRV_H */
+#endif                          /* _SECURITY_SRV_H */

Xext/shmint.h

@@ -42,28 +42,28 @@
     int			/* sh */, \
     int			/* dx */, \
     int			/* dy */, \
-    char *		/* data */
+    char *                      /* data */
 
 #define XSHM_CREATE_PIXMAP_ARGS \
     ScreenPtr	/* pScreen */, \
     int		/* width */, \
     int		/* height */, \
     int		/* depth */, \
-    char *	/* addr */
+    char *                      /* addr */
 
 typedef struct _ShmFuncs {
-    PixmapPtr	(* CreatePixmap)(XSHM_CREATE_PIXMAP_ARGS);
+    PixmapPtr (*CreatePixmap) (XSHM_CREATE_PIXMAP_ARGS);
-    void	(* PutImage)(XSHM_PUT_IMAGE_ARGS);
+    void (*PutImage) (XSHM_PUT_IMAGE_ARGS);
 } ShmFuncs, *ShmFuncsPtr;
 
 extern _X_EXPORT void
-ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
+ ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
 
 extern _X_EXPORT void
-ShmRegisterFbFuncs(ScreenPtr pScreen);
+ ShmRegisterFbFuncs(ScreenPtr pScreen);
 
 extern _X_EXPORT RESTYPE ShmSegType;
 extern _X_EXPORT int ShmCompletionCode;
 extern _X_EXPORT int BadShmSegCode;
 
-#endif /* _SHMINT_H_ */
+#endif                          /* _SHMINT_H_ */

Xext/sleepuntil.c

@@ -41,185 +41,169 @@ in this Software without prior written authorization from The Open Group.
 #include "scrnintstr.h"
 
 typedef struct _Sertafied {
-    struct _Sertafied	*next;
+    struct _Sertafied *next;
-    TimeStamp		revive;
+    TimeStamp revive;
-    ClientPtr		pClient;
+    ClientPtr pClient;
-    XID			id;
+    XID id;
-    void		(*notifyFunc)(
+    void (*notifyFunc) (ClientPtr /* client */ ,
-			ClientPtr /* client */,
+                        pointer /* closure */
-			pointer /* closure */
+        );
-			);
 
-    pointer		closure;
+    pointer closure;
 } SertafiedRec, *SertafiedPtr;
 
 static SertafiedPtr pPending;
-static RESTYPE	    SertafiedResType;
+static RESTYPE SertafiedResType;
-static Bool	    BlockHandlerRegistered;
+static Bool BlockHandlerRegistered;
-static int	    SertafiedGeneration;
+static int SertafiedGeneration;
 
-static void	    ClientAwaken(
+static void ClientAwaken(ClientPtr /* client */ ,
-    ClientPtr /* client */,
+                         pointer        /* closure */
-    pointer /* closure */
+    );
-);
+static int SertafiedDelete(pointer /* value */ ,
-static int	    SertafiedDelete(
+                           XID  /* id */
-    pointer /* value */,
+    );
-    XID /* id */
+static void SertafiedBlockHandler(pointer /* data */ ,
-);
+                                  OSTimePtr /* wt */ ,
-static void	    SertafiedBlockHandler(
+                                  pointer       /* LastSelectMask */
-    pointer /* data */,
+    );
-    OSTimePtr /* wt */,
+static void SertafiedWakeupHandler(pointer /* data */ ,
-    pointer /* LastSelectMask */
+                                   int /* i */ ,
-);
+                                   pointer      /* LastSelectMask */
-static void	    SertafiedWakeupHandler(
+    );
-    pointer /* data */,
-    int /* i */,
-    pointer /* LastSelectMask */
-);
 
 int
-ClientSleepUntil (ClientPtr client,
+ClientSleepUntil(ClientPtr client,
-                  TimeStamp *revive,
+                 TimeStamp *revive,
-                  void (*notifyFunc)(ClientPtr, pointer),
+                 void (*notifyFunc) (ClientPtr, pointer), pointer closure)
-                  pointer closure)
 {
-    SertafiedPtr	pRequest, pReq, pPrev;
+    SertafiedPtr pRequest, pReq, pPrev;
 
-    if (SertafiedGeneration != serverGeneration)
+    if (SertafiedGeneration != serverGeneration) {
-    {
+        SertafiedResType = CreateNewResourceType(SertafiedDelete,
-	SertafiedResType = CreateNewResourceType (SertafiedDelete,
+                                                 "ClientSleep");
-						  "ClientSleep");
+        if (!SertafiedResType)
-	if (!SertafiedResType)
+            return FALSE;
-	    return FALSE;
+        SertafiedGeneration = serverGeneration;
-	SertafiedGeneration = serverGeneration;
+        BlockHandlerRegistered = FALSE;
-	BlockHandlerRegistered = FALSE;
     }
-    pRequest = malloc(sizeof (SertafiedRec));
+    pRequest = malloc(sizeof(SertafiedRec));
     if (!pRequest)
-	return FALSE;
+        return FALSE;
     pRequest->pClient = client;
     pRequest->revive = *revive;
-    pRequest->id = FakeClientID (client->index);
+    pRequest->id = FakeClientID(client->index);
     pRequest->closure = closure;
-    if (!BlockHandlerRegistered)
+    if (!BlockHandlerRegistered) {
-    {
+        if (!RegisterBlockAndWakeupHandlers(SertafiedBlockHandler,
-	if (!RegisterBlockAndWakeupHandlers (SertafiedBlockHandler,
+                                            SertafiedWakeupHandler,
-					     SertafiedWakeupHandler,
+                                            (pointer) 0)) {
-					     (pointer) 0))
+            free(pRequest);
-	{
+            return FALSE;
-	    free(pRequest);
+        }
-	    return FALSE;
+        BlockHandlerRegistered = TRUE;
-	}
-	BlockHandlerRegistered = TRUE;
     }
     pRequest->notifyFunc = 0;
-    if (!AddResource (pRequest->id, SertafiedResType, (pointer) pRequest))
+    if (!AddResource(pRequest->id, SertafiedResType, (pointer) pRequest))
-	return FALSE;
+        return FALSE;
     if (!notifyFunc)
-	notifyFunc = ClientAwaken;
+        notifyFunc = ClientAwaken;
     pRequest->notifyFunc = notifyFunc;
     /* Insert into time-ordered queue, with earliest activation time coming first. */
     pPrev = 0;
-    for (pReq = pPending; pReq; pReq = pReq->next)
+    for (pReq = pPending; pReq; pReq = pReq->next) {
-    {
+        if (CompareTimeStamps(pReq->revive, *revive) == LATER)
-	if (CompareTimeStamps (pReq->revive, *revive) == LATER)
+            break;
-	    break;
+        pPrev = pReq;
-	pPrev = pReq;
     }
     if (pPrev)
-	pPrev->next = pRequest;
+        pPrev->next = pRequest;
     else
-	pPending = pRequest;
+        pPending = pRequest;
     pRequest->next = pReq;
-    IgnoreClient (client);
+    IgnoreClient(client);
     return TRUE;
 }
 
 static void
-ClientAwaken (ClientPtr client, pointer closure)
+ClientAwaken(ClientPtr client, pointer closure)
 {
     if (!client->clientGone)
-	AttendClient (client);
+        AttendClient(client);
 }
 
-
 static int
-SertafiedDelete (pointer value, XID id)
+SertafiedDelete(pointer value, XID id)
 {
-    SertafiedPtr	pRequest = (SertafiedPtr)value;
+    SertafiedPtr pRequest = (SertafiedPtr) value;
-    SertafiedPtr	pReq, pPrev;
+    SertafiedPtr pReq, pPrev;
 
     pPrev = 0;
     for (pReq = pPending; pReq; pPrev = pReq, pReq = pReq->next)
-	if (pReq == pRequest)
+        if (pReq == pRequest) {
-	{
+            if (pPrev)
-	    if (pPrev)
+                pPrev->next = pReq->next;
-		pPrev->next = pReq->next;
+            else
-	    else
+                pPending = pReq->next;
-		pPending = pReq->next;
+            break;
-	    break;
+        }
-	}
     if (pRequest->notifyFunc)
-	(*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure);
+        (*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure);
     free(pRequest);
     return TRUE;
 }
 
 static void
-SertafiedBlockHandler (pointer data, OSTimePtr wt, pointer LastSelectMask)
+SertafiedBlockHandler(pointer data, OSTimePtr wt, pointer LastSelectMask)
 {
-    SertafiedPtr	    pReq, pNext;
+    SertafiedPtr pReq, pNext;
-    unsigned long	    delay;
+    unsigned long delay;
-    TimeStamp		    now;
+    TimeStamp now;
 
     if (!pPending)
-	return;
+        return;
-    now.milliseconds = GetTimeInMillis ();
+    now.milliseconds = GetTimeInMillis();
     now.months = currentTime.months;
     if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
-	now.months++;
+        now.months++;
-    for (pReq = pPending; pReq; pReq = pNext)
+    for (pReq = pPending; pReq; pReq = pNext) {
-    {
+        pNext = pReq->next;
-	pNext = pReq->next;
+        if (CompareTimeStamps(pReq->revive, now) == LATER)
-	if (CompareTimeStamps (pReq->revive, now) == LATER)
+            break;
-	    break;
+        FreeResource(pReq->id, RT_NONE);
-	FreeResource (pReq->id, RT_NONE);
 
- 	/* AttendClient() may have been called via the resource delete
+        /* AttendClient() may have been called via the resource delete
- 	 * function so a client may have input to be processed and so
+         * function so a client may have input to be processed and so
- 	 *  set delay to 0 to prevent blocking in WaitForSomething().
+         *  set delay to 0 to prevent blocking in WaitForSomething().
- 	 */
+         */
- 	AdjustWaitForDelay (wt, 0);
+        AdjustWaitForDelay(wt, 0);
     }
     pReq = pPending;
     if (!pReq)
-	return;
+        return;
     delay = pReq->revive.milliseconds - now.milliseconds;
-    AdjustWaitForDelay (wt, delay);
+    AdjustWaitForDelay(wt, delay);
 }
 
 static void
-SertafiedWakeupHandler (pointer data, int i, pointer LastSelectMask)
+SertafiedWakeupHandler(pointer data, int i, pointer LastSelectMask)
 {
-    SertafiedPtr	pReq, pNext;
+    SertafiedPtr pReq, pNext;
-    TimeStamp		now;
+    TimeStamp now;
 
-    now.milliseconds = GetTimeInMillis ();
+    now.milliseconds = GetTimeInMillis();
     now.months = currentTime.months;
     if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
-	now.months++;
+        now.months++;
-    for (pReq = pPending; pReq; pReq = pNext)
+    for (pReq = pPending; pReq; pReq = pNext) {
-    {
+        pNext = pReq->next;
-	pNext = pReq->next;
+        if (CompareTimeStamps(pReq->revive, now) == LATER)
-	if (CompareTimeStamps (pReq->revive, now) == LATER)
+            break;
-	    break;
+        FreeResource(pReq->id, RT_NONE);
-	FreeResource (pReq->id, RT_NONE);
     }
-    if (!pPending)
+    if (!pPending) {
-    {
+        RemoveBlockAndWakeupHandlers(SertafiedBlockHandler,
-	RemoveBlockAndWakeupHandlers (SertafiedBlockHandler,
+                                     SertafiedWakeupHandler, (pointer) 0);
-				      SertafiedWakeupHandler,
+        BlockHandlerRegistered = FALSE;
-				      (pointer) 0);
-	BlockHandlerRegistered = FALSE;
     }
 }

Xext/sleepuntil.h

@@ -33,14 +33,10 @@
 
 #include "dix.h"
 
-extern int ClientSleepUntil(
+extern int ClientSleepUntil(ClientPtr client,
-    ClientPtr client,
+                            TimeStamp *revive,
-    TimeStamp *revive,
+                            void (*notifyFunc) (ClientPtr /* client */ ,
-    void (*notifyFunc)(
+                                                pointer /* closure */
-	ClientPtr /* client */,
+                            ), pointer Closure);
-	pointer   /* closure */
-	),
-    pointer Closure
-);
 
 #endif

Xext/syncsdk.h

@@ -27,7 +27,7 @@
 #include "misync.h"
 
 extern _X_EXPORT int
-SyncVerifyFence(SyncFence **ppFence, XID fid, ClientPtr client, Mask mode);
+ SyncVerifyFence(SyncFence ** ppFence, XID fid, ClientPtr client, Mask mode);
 
 #define VERIFY_SYNC_FENCE(pFence, fid, client, mode)			\
     do {								\
@@ -43,5 +43,4 @@ SyncVerifyFence(SyncFence **ppFence, XID fid, ClientPtr client, Mask mode);
 	    VERIFY_SYNC_FENCE((pFence), (fid), (client), (mode));	\
     } while (0)
 
-#endif /* _SYNCSDK_H_ */
+#endif                          /* _SYNCSDK_H_ */
-

Xext/syncsrv.h

@@ -66,81 +66,80 @@ typedef enum {
 } SyncCounterType;
 
 typedef struct _SysCounterInfo {
-    const char	*name;
+    const char *name;
-    CARD64	resolution;
+    CARD64 resolution;
-    CARD64	bracket_greater;
+    CARD64 bracket_greater;
-    CARD64	bracket_less;
+    CARD64 bracket_less;
-    SyncCounterType counterType;  /* how can this counter change */
+    SyncCounterType counterType;        /* how can this counter change */
-    void        (*QueryValue)(
+    void (*QueryValue) (pointer /*pCounter */ ,
-			      pointer /*pCounter*/,
+                        CARD64 *        /*freshvalue */
-			      CARD64 * /*freshvalue*/
+        );
-);
+    void (*BracketValues) (pointer /*pCounter */ ,
-    void	(*BracketValues)(
+                           CARD64 * /*lessthan */ ,
-				 pointer /*pCounter*/,
+                           CARD64 *     /*greaterthan */
-				 CARD64 * /*lessthan*/,
+        );
-				 CARD64 * /*greaterthan*/
-);
 } SysCounterInfo;
 
-
-
 typedef struct _SyncAlarmClientList {
-    ClientPtr	client;
+    ClientPtr client;
-    XID		delete_id;
+    XID delete_id;
     struct _SyncAlarmClientList *next;
 } SyncAlarmClientList;
 
 typedef struct _SyncAlarm {
     SyncTrigger trigger;
-    ClientPtr	client;
+    ClientPtr client;
-    XSyncAlarm 	alarm_id;
+    XSyncAlarm alarm_id;
-    CARD64	delta;
+    CARD64 delta;
-    int		events;
+    int events;
-    int		state;
+    int state;
     SyncAlarmClientList *pEventClients;
 } SyncAlarm;
 
 typedef struct {
-    ClientPtr	client;
+    ClientPtr client;
-    CARD32 	delete_id;
+    CARD32 delete_id;
-    int		num_waitconditions;
+    int num_waitconditions;
 } SyncAwaitHeader;
 
 typedef struct {
     SyncTrigger trigger;
-    CARD64	event_threshold;
+    CARD64 event_threshold;
     SyncAwaitHeader *pHeader;
 } SyncAwait;
 
 typedef union {
     SyncAwaitHeader header;
-    SyncAwait	    await;
+    SyncAwait await;
 } SyncAwaitUnion;
 
-extern pointer SyncCreateSystemCounter(
+extern pointer SyncCreateSystemCounter(const char * /* name */ ,
-    const char */* name */,
+                                       CARD64 /* inital_value */ ,
-    CARD64  	/* inital_value */,
+                                       CARD64 /* resolution */ ,
-    CARD64  	/* resolution */,
+                                       SyncCounterType
-    SyncCounterType /* change characterization */,
+                                       /* change characterization */ ,
-    void        (* /*QueryValue*/ ) (
+                                       void (* /*QueryValue */ )(
-        pointer /* pCounter */,
+                                                                    pointer
-        CARD64 * /* pValue_return */), /* XXX prototype */
+                                                                    /* pCounter */
-    void        (* /*BracketValues*/) (
+                                                                    ,
-        pointer /* pCounter */, 
+                                                                    CARD64 * /* pValue_return */ ),     /* XXX prototype */
-        CARD64 * /* pbracket_less */,
+                                       void (* /*BracketValues */ )(
-        CARD64 * /* pbracket_greater */)
+                                                                       pointer
-);
+                                                                       /* pCounter */
+                                                                       ,
+                                                                       CARD64 *
+                                                                       /* pbracket_less */
+                                                                       ,
+                                                                       CARD64 *
+                                                                       /* pbracket_greater */
+                                                                       )
+    );
 
-extern void SyncChangeCounter(
+extern void SyncChangeCounter(SyncCounter * /* pCounter */ ,
-    SyncCounter *	/* pCounter*/,
+                              CARD64    /* new_value */
-    CARD64  		/* new_value */
+    );
-);
 
-extern void SyncDestroySystemCounter(
+extern void SyncDestroySystemCounter(pointer pCounter);
-    pointer pCounter
-);
-
-extern void InitServertime(void);
 
 extern void SyncExtensionInit(void);
-#endif /* _SYNCSRV_H_ */
+#endif                          /* _SYNCSRV_H_ */

Xext/xace.c

@@ -34,49 +34,53 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <X11/Xtrans/Xtrans.h>
 #include "../os/osdep.h"
 
-_X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS] = {0};
+_X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS] = { 0 };
 
 /* Special-cased hook functions.  Called by Xserver.
  */
-int XaceHookDispatch(ClientPtr client, int major)
+int
+XaceHookDispatch(ClientPtr client, int major)
 {
     /* Call the audit begin callback, there is no return value. */
     XaceAuditRec rec = { client, 0 };
     CallCallbacks(&XaceHooks[XACE_AUDIT_BEGIN], &rec);
 
     if (major < 128) {
-	/* Call the core dispatch hook */
+        /* Call the core dispatch hook */
-	XaceCoreDispatchRec rec = { client, Success /* default allow */ };
+        XaceCoreDispatchRec rec = { client, Success /* default allow */  };
-	CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec);
+        CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec);
-	return rec.status;
+        return rec.status;
-    } else {
+    }
-	/* Call the extension dispatch hook */
+    else {
-	ExtensionEntry *ext = GetExtensionEntry(major);
+        /* Call the extension dispatch hook */
-	XaceExtAccessRec rec = { client, ext, DixUseAccess, Success };
+        ExtensionEntry *ext = GetExtensionEntry(major);
-	if (ext)
+        XaceExtAccessRec rec = { client, ext, DixUseAccess, Success };
-	    CallCallbacks(&XaceHooks[XACE_EXT_DISPATCH], &rec);
+        if (ext)
-	/* On error, pretend extension doesn't exist */
+            CallCallbacks(&XaceHooks[XACE_EXT_DISPATCH], &rec);
-	return (rec.status == Success) ? Success : BadRequest;
+        /* On error, pretend extension doesn't exist */
+        return (rec.status == Success) ? Success : BadRequest;
     }
 }
 
-int XaceHookPropertyAccess(ClientPtr client, WindowPtr pWin,
+int
-			   PropertyPtr *ppProp, Mask access_mode)
+XaceHookPropertyAccess(ClientPtr client, WindowPtr pWin,
+                       PropertyPtr *ppProp, Mask access_mode)
 {
     XacePropertyAccessRec rec = { client, pWin, ppProp, access_mode, Success };
     CallCallbacks(&XaceHooks[XACE_PROPERTY_ACCESS], &rec);
     return rec.status;
 }
 
-int XaceHookSelectionAccess(ClientPtr client,
+int
-			    Selection **ppSel, Mask access_mode)
+XaceHookSelectionAccess(ClientPtr client, Selection ** ppSel, Mask access_mode)
 {
     XaceSelectionAccessRec rec = { client, ppSel, access_mode, Success };
     CallCallbacks(&XaceHooks[XACE_SELECTION_ACCESS], &rec);
     return rec.status;
 }
 
-void XaceHookAuditEnd(ClientPtr ptr, int result)
+void
+XaceHookAuditEnd(ClientPtr ptr, int result)
 {
     XaceAuditRec rec = { ptr, result };
     /* call callbacks, there is no return value. */
@@ -85,25 +89,26 @@ void XaceHookAuditEnd(ClientPtr ptr, int result)
 
 /* Entry point for hook functions.  Called by Xserver.
  */
-int XaceHook(int hook, ...)
+int
+XaceHook(int hook, ...)
 {
     union {
-	XaceResourceAccessRec res;
+        XaceResourceAccessRec res;
-	XaceDeviceAccessRec dev;
+        XaceDeviceAccessRec dev;
-	XaceSendAccessRec send;
+        XaceSendAccessRec send;
-	XaceReceiveAccessRec recv;
+        XaceReceiveAccessRec recv;
-	XaceClientAccessRec client;
+        XaceClientAccessRec client;
-	XaceExtAccessRec ext;
+        XaceExtAccessRec ext;
-	XaceServerAccessRec server;
+        XaceServerAccessRec server;
-	XaceScreenAccessRec screen;
+        XaceScreenAccessRec screen;
-	XaceAuthAvailRec auth;
+        XaceAuthAvailRec auth;
-	XaceKeyAvailRec key;
+        XaceKeyAvailRec key;
     } u;
-    int *prv = NULL;	/* points to return value from callback */
+    int *prv = NULL;            /* points to return value from callback */
-    va_list ap;		/* argument list */
+    va_list ap;                 /* argument list */
 
     if (!XaceHooks[hook])
-	return Success;
+        return Success;
 
     va_start(ap, hook);
 
@@ -112,83 +117,94 @@ int XaceHook(int hook, ...)
      * the arguments and integer return parameter, or in some cases just
      * sets calldata directly to a single argument (with no return result)
      */
-    switch (hook)
+    switch (hook) {
-    {
+    case XACE_RESOURCE_ACCESS:
-	case XACE_RESOURCE_ACCESS:
+        u.res.client = va_arg(ap, ClientPtr);
-	    u.res.client = va_arg(ap, ClientPtr);
+        u.res.id = va_arg(ap, XID);
-	    u.res.id = va_arg(ap, XID);
+        u.res.rtype = va_arg(ap, RESTYPE);
-	    u.res.rtype = va_arg(ap, RESTYPE);
+        u.res.res = va_arg(ap, pointer);
-	    u.res.res = va_arg(ap, pointer);
+        u.res.ptype = va_arg(ap, RESTYPE);
-	    u.res.ptype = va_arg(ap, RESTYPE);
+        u.res.parent = va_arg(ap, pointer);
-	    u.res.parent = va_arg(ap, pointer);
+        u.res.access_mode = va_arg(ap, Mask);
-	    u.res.access_mode = va_arg(ap, Mask);
+
-	    u.res.status = Success; /* default allow */
+        u.res.status = Success; /* default allow */
-	    prv = &u.res.status;
+        prv = &u.res.status;
-	    break;
+        break;
-	case XACE_DEVICE_ACCESS:
+    case XACE_DEVICE_ACCESS:
-	    u.dev.client = va_arg(ap, ClientPtr);
+        u.dev.client = va_arg(ap, ClientPtr);
-	    u.dev.dev = va_arg(ap, DeviceIntPtr);
+        u.dev.dev = va_arg(ap, DeviceIntPtr);
-	    u.dev.access_mode = va_arg(ap, Mask);
+        u.dev.access_mode = va_arg(ap, Mask);
-	    u.dev.status = Success; /* default allow */
+
-	    prv = &u.dev.status;
+        u.dev.status = Success; /* default allow */
-	    break;
+        prv = &u.dev.status;
-	case XACE_SEND_ACCESS:
+        break;
-	    u.send.client = va_arg(ap, ClientPtr);
+    case XACE_SEND_ACCESS:
-	    u.send.dev = va_arg(ap, DeviceIntPtr);
+        u.send.client = va_arg(ap, ClientPtr);
-	    u.send.pWin = va_arg(ap, WindowPtr);
+        u.send.dev = va_arg(ap, DeviceIntPtr);
-	    u.send.events = va_arg(ap, xEventPtr);
+        u.send.pWin = va_arg(ap, WindowPtr);
-	    u.send.count = va_arg(ap, int);
+
-	    u.send.status = Success; /* default allow */
+        u.send.events = va_arg(ap, xEventPtr);
-	    prv = &u.send.status;
+        u.send.count = va_arg(ap, int);
-	    break;
+
-	case XACE_RECEIVE_ACCESS:
+        u.send.status = Success;        /* default allow */
-	    u.recv.client = va_arg(ap, ClientPtr);
+        prv = &u.send.status;
-	    u.recv.pWin = va_arg(ap, WindowPtr);
+        break;
-	    u.recv.events = va_arg(ap, xEventPtr);
+    case XACE_RECEIVE_ACCESS:
-	    u.recv.count = va_arg(ap, int);
+        u.recv.client = va_arg(ap, ClientPtr);
-	    u.recv.status = Success; /* default allow */
+        u.recv.pWin = va_arg(ap, WindowPtr);
-	    prv = &u.recv.status;
+
-	    break;
+        u.recv.events = va_arg(ap, xEventPtr);
-	case XACE_CLIENT_ACCESS:
+        u.recv.count = va_arg(ap, int);
-	    u.client.client = va_arg(ap, ClientPtr);
+
-	    u.client.target = va_arg(ap, ClientPtr);
+        u.recv.status = Success;        /* default allow */
-	    u.client.access_mode = va_arg(ap, Mask);
+        prv = &u.recv.status;
-	    u.client.status = Success; /* default allow */
+        break;
-	    prv = &u.client.status;
+    case XACE_CLIENT_ACCESS:
-	    break;
+        u.client.client = va_arg(ap, ClientPtr);
-	case XACE_EXT_ACCESS:
+        u.client.target = va_arg(ap, ClientPtr);
-	    u.ext.client = va_arg(ap, ClientPtr);
+        u.client.access_mode = va_arg(ap, Mask);
-	    u.ext.ext = va_arg(ap, ExtensionEntry*);
+
-	    u.ext.access_mode = DixGetAttrAccess;
+        u.client.status = Success;      /* default allow */
-	    u.ext.status = Success; /* default allow */
+        prv = &u.client.status;
-	    prv = &u.ext.status;
+        break;
-	    break;
+    case XACE_EXT_ACCESS:
-	case XACE_SERVER_ACCESS:
+        u.ext.client = va_arg(ap, ClientPtr);
-	    u.server.client = va_arg(ap, ClientPtr);
+
-	    u.server.access_mode = va_arg(ap, Mask);
+        u.ext.ext = va_arg(ap, ExtensionEntry *);
-	    u.server.status = Success; /* default allow */
+        u.ext.access_mode = DixGetAttrAccess;
-	    prv = &u.server.status;
+        u.ext.status = Success; /* default allow */
-	    break;
+        prv = &u.ext.status;
-	case XACE_SCREEN_ACCESS:
+        break;
-	case XACE_SCREENSAVER_ACCESS:
+    case XACE_SERVER_ACCESS:
-	    u.screen.client = va_arg(ap, ClientPtr);
+        u.server.client = va_arg(ap, ClientPtr);
-	    u.screen.screen = va_arg(ap, ScreenPtr);
+        u.server.access_mode = va_arg(ap, Mask);
-	    u.screen.access_mode = va_arg(ap, Mask);
+
-	    u.screen.status = Success; /* default allow */
+        u.server.status = Success;      /* default allow */
-	    prv = &u.screen.status;
+        prv = &u.server.status;
-	    break;
+        break;
-	case XACE_AUTH_AVAIL:
+    case XACE_SCREEN_ACCESS:
-	    u.auth.client = va_arg(ap, ClientPtr);
+    case XACE_SCREENSAVER_ACCESS:
-	    u.auth.authId = va_arg(ap, XID);
+        u.screen.client = va_arg(ap, ClientPtr);
-	    break;
+        u.screen.screen = va_arg(ap, ScreenPtr);
-	case XACE_KEY_AVAIL:
+        u.screen.access_mode = va_arg(ap, Mask);
-	    u.key.event = va_arg(ap, xEventPtr);
+
-	    u.key.keybd = va_arg(ap, DeviceIntPtr);
+        u.screen.status = Success;      /* default allow */
-	    u.key.count = va_arg(ap, int);
+        prv = &u.screen.status;
-	    break;
+        break;
-	default:
+    case XACE_AUTH_AVAIL:
-	    va_end(ap);
+        u.auth.client = va_arg(ap, ClientPtr);
-	    return 0;	/* unimplemented hook number */
+        u.auth.authId = va_arg(ap, XID);
+
+        break;
+    case XACE_KEY_AVAIL:
+        u.key.event = va_arg(ap, xEventPtr);
+        u.key.keybd = va_arg(ap, DeviceIntPtr);
+        u.key.count = va_arg(ap, int);
+
+        break;
+    default:
+        va_end(ap);
+        return 0;               /* unimplemented hook number */
     }
     va_end(ap);
 
@@ -218,17 +234,14 @@ int XaceHook(int hook, ...)
  *	region of the window will be destroyed (overwritten) in pBuf.
  */
 void
-XaceCensorImage(
+XaceCensorImage(ClientPtr client,
-	ClientPtr client,
+                RegionPtr pVisibleRegion,
-	RegionPtr pVisibleRegion,
+                long widthBytesLine,
-	long widthBytesLine,
+                DrawablePtr pDraw,
-	DrawablePtr pDraw,
+                int x, int y, int w, int h, unsigned int format, char *pBuf)
-	int x, int y, int w, int h,
-	unsigned int format,
-	char *pBuf)
 {
-    RegionRec imageRegion;  /* region representing x,y,w,h */
+    RegionRec imageRegion;      /* region representing x,y,w,h */
-    RegionRec censorRegion; /* region to obliterate */
+    RegionRec censorRegion;     /* region to obliterate */
     BoxRec imageBox;
     int nRects;
 
@@ -242,90 +255,87 @@ XaceCensorImage(
     /* censorRegion = imageRegion - visibleRegion */
     RegionSubtract(&censorRegion, &imageRegion, pVisibleRegion);
     nRects = RegionNumRects(&censorRegion);
-    if (nRects > 0)
+    if (nRects > 0) {           /* we have something to censor */
-    { /* we have something to censor */
+        GCPtr pScratchGC = NULL;
-	GCPtr pScratchGC = NULL;
+        PixmapPtr pPix = NULL;
-	PixmapPtr pPix = NULL;
+        xRectangle *pRects = NULL;
-	xRectangle *pRects = NULL;
+        Bool failed = FALSE;
-	Bool failed = FALSE;
+        int depth = 1;
-	int depth = 1;
+        int bitsPerPixel = 1;
-	int bitsPerPixel = 1;
+        int i;
-	int i;
+        BoxPtr pBox;
-	BoxPtr pBox;
 
-	/* convert region to list-of-rectangles for PolyFillRect */
+        /* convert region to list-of-rectangles for PolyFillRect */
 
-	pRects = malloc(nRects * sizeof(xRectangle));
+        pRects = malloc(nRects * sizeof(xRectangle));
-	if (!pRects)
+        if (!pRects) {
-	{
+            failed = TRUE;
-	    failed = TRUE;
+            goto failSafe;
-	    goto failSafe;
+        }
-	}
+        for (pBox = RegionRects(&censorRegion), i = 0; i < nRects; i++, pBox++) {
-	for (pBox = RegionRects(&censorRegion), i = 0;
+            pRects[i].x = pBox->x1;
-	     i < nRects;
+            pRects[i].y = pBox->y1 - imageBox.y1;
-	     i++, pBox++)
+            pRects[i].width = pBox->x2 - pBox->x1;
-	{
+            pRects[i].height = pBox->y2 - pBox->y1;
-	    pRects[i].x = pBox->x1;
+        }
-	    pRects[i].y = pBox->y1 - imageBox.y1;
-	    pRects[i].width  = pBox->x2 - pBox->x1;
-	    pRects[i].height = pBox->y2 - pBox->y1;
-	}
 
-	/* use pBuf as a fake pixmap */
+        /* use pBuf as a fake pixmap */
 
-	if (format == ZPixmap)
+        if (format == ZPixmap) {
-	{
+            depth = pDraw->depth;
-	    depth = pDraw->depth;
+            bitsPerPixel = pDraw->bitsPerPixel;
-	    bitsPerPixel = pDraw->bitsPerPixel;
+        }
-	}
 
-	pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
+        pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
-		    depth, bitsPerPixel,
+                                      depth, bitsPerPixel,
-		    widthBytesLine, (pointer)pBuf);
+                                      widthBytesLine, (pointer) pBuf);
-	if (!pPix)
+        if (!pPix) {
-	{
+            failed = TRUE;
-	    failed = TRUE;
+            goto failSafe;
-	    goto failSafe;
+        }
-	}
 
-	pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen);
+        pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen);
-	if (!pScratchGC)
+        if (!pScratchGC) {
-	{
+            failed = TRUE;
-	    failed = TRUE;
+            goto failSafe;
-	    goto failSafe;
+        }
-	}
 
-	ValidateGC(&pPix->drawable, pScratchGC);
+        ValidateGC(&pPix->drawable, pScratchGC);
-	(* pScratchGC->ops->PolyFillRect)(&pPix->drawable,
+        (*pScratchGC->ops->PolyFillRect) (&pPix->drawable,
-			    pScratchGC, nRects, pRects);
+                                          pScratchGC, nRects, pRects);
 
-    failSafe:
+ failSafe:
-	if (failed)
+        if (failed) {
-	{
+            /* Censoring was not completed above.  To be safe, wipe out
-	    /* Censoring was not completed above.  To be safe, wipe out
+             * all the image data so that nothing trusted gets out.
-	     * all the image data so that nothing trusted gets out.
+             */
-	     */
+            memset(pBuf, 0, (int) (widthBytesLine * h));
-	    memset(pBuf, 0, (int)(widthBytesLine * h));
+        }
-	}
+        free(pRects);
-	free(pRects);
+        if (pScratchGC)
-	if (pScratchGC) FreeScratchGC(pScratchGC);
+            FreeScratchGC(pScratchGC);
-	if (pPix)       FreeScratchPixmapHeader(pPix);
+        if (pPix)
+            FreeScratchPixmapHeader(pPix);
     }
     RegionUninit(&imageRegion);
     RegionUninit(&censorRegion);
-} /* XaceCensorImage */
+}                               /* XaceCensorImage */
 
 /*
  * Xtrans wrappers for use by modules
  */
-int XaceGetConnectionNumber(ClientPtr client)
+int
+XaceGetConnectionNumber(ClientPtr client)
 {
-    XtransConnInfo ci = ((OsCommPtr)client->osPrivate)->trans_conn;
+    XtransConnInfo ci = ((OsCommPtr) client->osPrivate)->trans_conn;
+
     return _XSERVTransGetConnectionNumber(ci);
 }
 
-int XaceIsLocal(ClientPtr client)
+int
+XaceIsLocal(ClientPtr client)
 {
-    XtransConnInfo ci = ((OsCommPtr)client->osPrivate)->trans_conn;
+    XtransConnInfo ci = ((OsCommPtr) client->osPrivate)->trans_conn;
+
     return _XSERVTransIsLocal(ci);
 }

Xext/xace.h

@@ -61,18 +61,18 @@ extern _X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS];
 /* Entry point for hook functions.  Called by Xserver.
  * Required by libdbe and libextmod
  */
-extern _X_EXPORT int XaceHook(
+extern _X_EXPORT int XaceHook(int /*hook */ ,
-    int /*hook*/,
+                              ...       /*appropriate args for hook */
-    ... /*appropriate args for hook*/
     );
 
 /* Special-cased hook functions
  */
 extern _X_EXPORT int XaceHookDispatch(ClientPtr ptr, int major);
 extern _X_EXPORT int XaceHookPropertyAccess(ClientPtr ptr, WindowPtr pWin,
-				   PropertyPtr *ppProp, Mask access_mode);
+                                            PropertyPtr *ppProp,
-extern _X_EXPORT int XaceHookSelectionAccess(ClientPtr ptr,
+                                            Mask access_mode);
-				   Selection **ppSel, Mask access_mode);
+extern _X_EXPORT int XaceHookSelectionAccess(ClientPtr ptr, Selection ** ppSel,
+                                             Mask access_mode);
 extern _X_EXPORT void XaceHookAuditEnd(ClientPtr ptr, int result);
 
 /* Register a callback for a given hook.
@@ -93,17 +93,14 @@ extern _X_EXPORT int XaceIsLocal(ClientPtr ptr);
 /* From the original Security extension...
  */
 
-extern _X_EXPORT void XaceCensorImage(
+extern _X_EXPORT void XaceCensorImage(ClientPtr client,
-    ClientPtr client,
+                                      RegionPtr pVisibleRegion,
-    RegionPtr pVisibleRegion,
+                                      long widthBytesLine,
-    long widthBytesLine,
+                                      DrawablePtr pDraw,
-    DrawablePtr pDraw,
+                                      int x, int y, int w, int h,
-    int x, int y, int w, int h,
+                                      unsigned int format, char *pBuf);
-    unsigned int format,
-    char * pBuf
-    );
 
-#else /* XACE */
+#else                           /* XACE */
 
 /* Default window background */
 #define XaceBackgroundNoneState(w)		None
@@ -126,6 +123,6 @@ extern _X_EXPORT void XaceCensorImage(
 #define XaceCensorImage(...) { ; }
 #endif
 
-#endif /* XACE */
+#endif                          /* XACE */
 
-#endif /* _XACE_H */
+#endif                          /* _XACE_H */

Xext/xacestr.h

@@ -144,4 +144,4 @@ typedef struct {
     int requestResult;
 } XaceAuditRec;
 
-#endif /* _XACESTR_H */
+#endif                          /* _XACESTR_H */

Xext/xcmisc.c

@@ -54,11 +54,11 @@ ProcXCMiscGetVersion(ClientPtr client)
     rep.majorVersion = XCMiscMajorVersion;
     rep.minorVersion = XCMiscMinorVersion;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swaps(&rep.majorVersion);
+        swaps(&rep.majorVersion);
-	swaps(&rep.minorVersion);
+        swaps(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *) &rep);
     return Success;
 }
 
@@ -76,11 +76,11 @@ ProcXCMiscGetXIDRange(ClientPtr client)
     rep.start_id = min_id;
     rep.count = max_id - min_id + 1;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.start_id);
+        swapl(&rep.start_id);
-	swapl(&rep.count);
+        swapl(&rep.count);
     }
-    WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *) &rep);
     return Success;
 }
 
@@ -95,12 +95,11 @@ ProcXCMiscGetXIDList(ClientPtr client)
     REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);
 
     if (stuff->count > UINT32_MAX / sizeof(XID))
-	    return BadAlloc;
+        return BadAlloc;
 
-    pids = (XID *)malloc(stuff->count * sizeof(XID));
+    pids = (XID *) malloc(stuff->count * sizeof(XID));
-    if (!pids)
+    if (!pids) {
-    {
+        return BadAlloc;
-	return BadAlloc;
     }
     count = GetXIDList(client, stuff->count, pids);
     rep.type = X_Reply;
@@ -108,34 +107,32 @@ ProcXCMiscGetXIDList(ClientPtr client)
     rep.length = count;
     rep.count = count;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
+        swapl(&rep.length);
-	swapl(&rep.count);
+        swapl(&rep.count);
     }
-    WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *) &rep);
-    if (count)
+    if (count) {
-    {
+        client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-    	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+        WriteSwappedDataToClient(client, count * sizeof(XID), pids);
-	WriteSwappedDataToClient(client, count * sizeof(XID), pids);
     }
     free(pids);
     return Success;
 }
 
 static int
-ProcXCMiscDispatch (ClientPtr client)
+ProcXCMiscDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
     case X_XCMiscGetVersion:
-	return ProcXCMiscGetVersion(client);
+        return ProcXCMiscGetVersion(client);
     case X_XCMiscGetXIDRange:
-	return ProcXCMiscGetXIDRange(client);
+        return ProcXCMiscGetXIDRange(client);
     case X_XCMiscGetXIDList:
-	return ProcXCMiscGetXIDList(client);
+        return ProcXCMiscGetXIDList(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -171,19 +168,18 @@ SProcXCMiscGetXIDList(ClientPtr client)
 }
 
 static int
-SProcXCMiscDispatch (ClientPtr client)
+SProcXCMiscDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
     case X_XCMiscGetVersion:
-	return SProcXCMiscGetVersion(client);
+        return SProcXCMiscGetVersion(client);
     case X_XCMiscGetXIDRange:
-	return SProcXCMiscGetXIDRange(client);
+        return SProcXCMiscGetXIDRange(client);
     case X_XCMiscGetXIDList:
-	return SProcXCMiscGetXIDList(client);
+        return SProcXCMiscGetXIDList(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -191,6 +187,6 @@ void
 XCMiscExtensionInit(INITARGS)
 {
     AddExtension(XCMiscExtensionName, 0, 0,
-		 ProcXCMiscDispatch, SProcXCMiscDispatch,
+                 ProcXCMiscDispatch, SProcXCMiscDispatch,
-		 NULL, StandardMinorOpcode);
+                 NULL, StandardMinorOpcode);
 }

Xext/xf86bigfont.c

@@ -76,11 +76,9 @@
 #include <X11/extensions/xf86bigfproto.h>
 #include "xf86bigfontsrv.h"
 
-static void XF86BigfontResetProc(
+static void XF86BigfontResetProc(ExtensionEntry *       /* extEntry */
-    ExtensionEntry *	/* extEntry */
     );
 
-
 #ifdef HAS_SHM
 
 /* A random signature, transmitted to the clients so they can verify that the
@@ -100,8 +98,7 @@ static Bool badSysCall = FALSE;
 #include <sys/signal.h>
 
 static void
-SigSysHandler(
+SigSysHandler(int signo)
-     int signo)
 {
     badSysCall = TRUE;
 }
@@ -109,7 +106,7 @@ SigSysHandler(
 static Bool
 CheckForShmSyscall(void)
 {
-    void (*oldHandler)(int);
+    void (*oldHandler) (int);
     int shmid = -1;
 
     /* If no SHM support in the kernel, the bad syscall will generate SIGSYS */
@@ -117,13 +114,11 @@ CheckForShmSyscall(void)
 
     badSysCall = FALSE;
     shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT);
-    if (shmid != -1)
+    if (shmid != -1) {
-    {
         /* Successful allocation - clean up */
-	shmctl(shmid, IPC_RMID, NULL);
+        shmctl(shmid, IPC_RMID, NULL);
     }
-    else
+    else {
-    {
         /* Allocation failed */
         badSysCall = TRUE;
     }
@@ -158,8 +153,7 @@ typedef struct _ShmDesc {
 static ShmDescPtr ShmList = (ShmDescPtr) NULL;
 
 static ShmDescPtr
-shmalloc(
+shmalloc(unsigned int size)
-    unsigned int size)
 {
     ShmDescPtr pDesc;
     int shmid;
@@ -167,7 +161,7 @@ shmalloc(
 
 #ifdef MUST_CHECK_FOR_SHM_SYSCALL
     if (pagesize == 0)
-	return (ShmDescPtr) NULL;
+        return (ShmDescPtr) NULL;
 #endif
 
     /* On some older Linux systems, the number of shared memory segments
@@ -177,27 +171,27 @@ shmalloc(
        the glyph metrics on the other hand. If the glyph metrics size is
        small, we prefer the traditional way. */
     if (size < 3500)
-	return (ShmDescPtr) NULL;
+        return (ShmDescPtr) NULL;
 
     pDesc = malloc(sizeof(ShmDescRec));
     if (!pDesc)
-	return (ShmDescPtr) NULL;
+        return (ShmDescPtr) NULL;
 
-    size = (size + pagesize-1) & -pagesize;
+    size = (size + pagesize - 1) & -pagesize;
     shmid = shmget(IPC_PRIVATE, size, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
     if (shmid == -1) {
-	ErrorF(XF86BIGFONTNAME " extension: shmget() failed, size = %u, %s\n",
+        ErrorF(XF86BIGFONTNAME " extension: shmget() failed, size = %u, %s\n",
-	       size, strerror(errno));
+               size, strerror(errno));
-	free(pDesc);
+        free(pDesc);
-	return (ShmDescPtr) NULL;
+        return (ShmDescPtr) NULL;
     }
 
-    if ((addr = shmat(shmid, 0, 0)) == (char *)-1) {
+    if ((addr = shmat(shmid, 0, 0)) == (char *) -1) {
-	ErrorF(XF86BIGFONTNAME " extension: shmat() failed, size = %u, %s\n",
+        ErrorF(XF86BIGFONTNAME " extension: shmat() failed, size = %u, %s\n",
-	       size, strerror(errno));
+               size, strerror(errno));
-	shmctl(shmid, IPC_RMID, (void *) 0);
+        shmctl(shmid, IPC_RMID, (void *) 0);
-	free(pDesc);
+        free(pDesc);
-	return (ShmDescPtr) NULL;
+        return (ShmDescPtr) NULL;
     }
 
 #ifdef EARLY_REMOVE
@@ -206,7 +200,8 @@ shmalloc(
 
     pDesc->shmid = shmid;
     pDesc->attach_addr = addr;
-    if (ShmList) ShmList->prev = &pDesc->next;
+    if (ShmList)
+        ShmList->prev = &pDesc->next;
     pDesc->next = ShmList;
     pDesc->prev = &ShmList;
     ShmList = pDesc;
@@ -215,15 +210,15 @@ shmalloc(
 }
 
 static void
-shmdealloc(
+shmdealloc(ShmDescPtr pDesc)
-    ShmDescPtr pDesc)
 {
 #ifndef EARLY_REMOVE
     shmctl(pDesc->shmid, IPC_RMID, (void *) 0);
 #endif
     shmdt(pDesc->attach_addr);
 
-    if (pDesc->next) pDesc->next->prev = pDesc->prev;
+    if (pDesc->next)
+        pDesc->next->prev = pDesc->prev;
     *pDesc->prev = pDesc->next;
     free(pDesc);
 }
@@ -232,8 +227,7 @@ shmdealloc(
 
 /* Called when a font is closed. */
 void
-XF86BigfontFreeFontShm(
+XF86BigfontFreeFontShm(FontPtr pFont)
-    FontPtr pFont)
 {
 #ifdef HAS_SHM
     ShmDescPtr pDesc;
@@ -242,11 +236,11 @@ XF86BigfontFreeFontShm(
      * called shmdealloc() for all segments, we don't need to do it here.
      */
     if (!ShmList)
-	return;
+        return;
 
     pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex);
     if (pDesc)
-	shmdealloc(pDesc);
+        shmdealloc(pDesc);
 #endif
 }
 
@@ -256,14 +250,13 @@ XF86BigfontCleanup(void)
 {
 #ifdef HAS_SHM
     while (ShmList)
-	shmdealloc(ShmList);
+        shmdealloc(ShmList);
 #endif
 }
 
 /* Called when a server generation dies. */
 static void
-XF86BigfontResetProc(
+XF86BigfontResetProc(ExtensionEntry * extEntry)
-    ExtensionEntry* extEntry)
 {
     /* This function is normally called from CloseDownExtensions(), called
      * from main(). It will be followed by a call to FreeAllResources(),
@@ -276,12 +269,10 @@ XF86BigfontResetProc(
     XF86BigfontCleanup();
 }
 
-
 /* ========== Handling of extension specific requests ========== */
 
 static int
-ProcXF86BigfontQueryVersion(
+ProcXF86BigfontQueryVersion(ClientPtr client)
-    ClientPtr client)
 {
     xXF86BigfontQueryVersionReply reply;
 
@@ -296,33 +287,33 @@ ProcXF86BigfontQueryVersion(
 #ifdef HAS_SHM
     reply.signature = signature;
 #else
-    reply.signature = 0; /* This is redundant. Avoids uninitialized memory. */
+    reply.signature = 0;        /* This is redundant. Avoids uninitialized memory. */
 #endif
     reply.capabilities =
 #ifdef HAS_SHM
-	(LocalClient(client) && !client->swapped ? XF86Bigfont_CAP_LocalShm : 0)
+        (LocalClient(client) && !client->swapped ? XF86Bigfont_CAP_LocalShm : 0)
 #else
-	0
+        0
 #endif
-	; /* may add more bits here in future versions */
+        ;                       /* may add more bits here in future versions */
     if (client->swapped) {
-	char tmp;
+        char tmp;
-	swaps(&reply.sequenceNumber);
+
-	swapl(&reply.length);
+        swaps(&reply.sequenceNumber);
-	swaps(&reply.majorVersion);
+        swapl(&reply.length);
-	swaps(&reply.minorVersion);
+        swaps(&reply.majorVersion);
-	swapl(&reply.uid);
+        swaps(&reply.minorVersion);
-	swapl(&reply.gid);
+        swapl(&reply.uid);
-	swapl(&reply.signature);
+        swapl(&reply.gid);
+        swapl(&reply.signature);
     }
     WriteToClient(client,
-		  sizeof(xXF86BigfontQueryVersionReply), (char *)&reply);
+                  sizeof(xXF86BigfontQueryVersionReply), (char *) &reply);
     return Success;
 }
 
 static void
-swapCharInfo(
+swapCharInfo(xCharInfo * pCI)
-    xCharInfo *pCI)
 {
     char tmp;
 
@@ -342,52 +333,55 @@ swapCharInfo(
 	          (p->ascent << 11) + (p->descent << 6)) ^ p->attributes)
 
 static int
-ProcXF86BigfontQueryFont(
+ProcXF86BigfontQueryFont(ClientPtr client)
-    ClientPtr client)
 {
     FontPtr pFont;
+
     REQUEST(xXF86BigfontQueryFontReq);
     CARD32 stuff_flags;
-    xCharInfo* pmax;
+    xCharInfo *pmax;
-    xCharInfo* pmin;
+    xCharInfo *pmin;
     int nCharInfos;
     int shmid;
+
 #ifdef HAS_SHM
     ShmDescPtr pDesc = NULL;
 #else
 #define pDesc 0
 #endif
-    xCharInfo* pCI;
+    xCharInfo *pCI;
-    CARD16* pIndex2UniqIndex;
+    CARD16 *pIndex2UniqIndex;
-    CARD16* pUniqIndex2Index;
+    CARD16 *pUniqIndex2Index;
     CARD32 nUniqCharInfos;
 
 #if 0
     REQUEST_SIZE_MATCH(xXF86BigfontQueryFontReq);
 #else
     switch (client->req_len) {
-	case 2: /* client with version 1.0 libX11 */
+    case 2:                    /* client with version 1.0 libX11 */
-	    stuff_flags = (LocalClient(client) && !client->swapped ? XF86Bigfont_FLAGS_Shm : 0);
+        stuff_flags = (LocalClient(client) &&
-	    break;
+                       !client->swapped ? XF86Bigfont_FLAGS_Shm : 0);
-	case 3: /* client with version 1.1 libX11 */
+        break;
-	    stuff_flags = stuff->flags;
+    case 3:                    /* client with version 1.1 libX11 */
-	    break;
+        stuff_flags = stuff->flags;
-	default:
+        break;
-	    return BadLength;
+    default:
+        return BadLength;
     }
 #endif
-    if (dixLookupFontable(&pFont, stuff->id, client, DixGetAttrAccess) != Success)
+    if (dixLookupFontable(&pFont, stuff->id, client, DixGetAttrAccess) !=
-	return BadFont;    /* procotol spec says only error is BadFont */
+        Success)
+        return BadFont;         /* procotol spec says only error is BadFont */
 
     pmax = FONTINKMAX(pFont);
     pmin = FONTINKMIN(pFont);
     nCharInfos =
-       (pmax->rightSideBearing == pmin->rightSideBearing
+        (pmax->rightSideBearing == pmin->rightSideBearing
-        && pmax->leftSideBearing == pmin->leftSideBearing
+         && pmax->leftSideBearing == pmin->leftSideBearing
-        && pmax->descent == pmin->descent
+         && pmax->descent == pmin->descent
-        && pmax->ascent == pmin->ascent
+         && pmax->ascent == pmin->ascent
-        && pmax->characterWidth == pmin->characterWidth)
+         && pmax->characterWidth == pmin->characterWidth)
-       ? 0 : N2dChars(pFont);
+        ? 0 : N2dChars(pFont);
     shmid = -1;
     pCI = NULL;
     pIndex2UniqIndex = NULL;
@@ -396,278 +390,289 @@ ProcXF86BigfontQueryFont(
 
     if (nCharInfos > 0) {
 #ifdef HAS_SHM
-	if (!badSysCall)
+        if (!badSysCall)
-	    pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex);
+            pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex);
-	if (pDesc) {
+        if (pDesc) {
-	    pCI = (xCharInfo *) pDesc->attach_addr;
+            pCI = (xCharInfo *) pDesc->attach_addr;
-	    if (stuff_flags & XF86Bigfont_FLAGS_Shm)
+            if (stuff_flags & XF86Bigfont_FLAGS_Shm)
-		shmid = pDesc->shmid;
+                shmid = pDesc->shmid;
-	} else {
+        }
-	    if (stuff_flags & XF86Bigfont_FLAGS_Shm && !badSysCall)
+        else {
-		pDesc = shmalloc(nCharInfos * sizeof(xCharInfo)
+            if (stuff_flags & XF86Bigfont_FLAGS_Shm && !badSysCall)
-				 + sizeof(CARD32));
+                pDesc = shmalloc(nCharInfos * sizeof(xCharInfo)
-	    if (pDesc) {
+                                 + sizeof(CARD32));
-		pCI = (xCharInfo *) pDesc->attach_addr;
+            if (pDesc) {
-		shmid = pDesc->shmid;
+                pCI = (xCharInfo *) pDesc->attach_addr;
-	    } else {
+                shmid = pDesc->shmid;
+            }
+            else {
 #endif
-		pCI = malloc(nCharInfos * sizeof(xCharInfo));
+                pCI = malloc(nCharInfos * sizeof(xCharInfo));
-		if (!pCI)
+                if (!pCI)
-		    return BadAlloc;
+                    return BadAlloc;
 #ifdef HAS_SHM
-	    }
+            }
 #endif
-	    /* Fill nCharInfos starting at pCI. */
+            /* Fill nCharInfos starting at pCI. */
-	    {
+            {
-		xCharInfo* prCI = pCI;
+                xCharInfo *prCI = pCI;
-		int ninfos = 0;
+                int ninfos = 0;
-		int ncols = pFont->info.lastCol - pFont->info.firstCol + 1;
+                int ncols = pFont->info.lastCol - pFont->info.firstCol + 1;
-		int row;
+                int row;
-		for (row = pFont->info.firstRow;
+
-		     row <= pFont->info.lastRow && ninfos < nCharInfos;
+                for (row = pFont->info.firstRow;
-		     row++) {
+                     row <= pFont->info.lastRow && ninfos < nCharInfos; row++) {
-		    unsigned char chars[512];
+                    unsigned char chars[512];
-		    xCharInfo* tmpCharInfos[256];
+                    xCharInfo *tmpCharInfos[256];
-		    unsigned long count;
+                    unsigned long count;
-		    int col;
+                    int col;
-		    unsigned long i;
+                    unsigned long i;
-		    i = 0;
+
-		    for (col = pFont->info.firstCol;
+                    i = 0;
-			 col <= pFont->info.lastCol;
+                    for (col = pFont->info.firstCol;
-			 col++) {
+                         col <= pFont->info.lastCol; col++) {
-			chars[i++] = row;
+                        chars[i++] = row;
-			chars[i++] = col;
+                        chars[i++] = col;
-		    }
+                    }
-		    (*pFont->get_metrics) (pFont, ncols, chars, TwoD16Bit,
+                    (*pFont->get_metrics) (pFont, ncols, chars, TwoD16Bit,
-					   &count, tmpCharInfos);
+                                           &count, tmpCharInfos);
-		    for (i = 0; i < count && ninfos < nCharInfos; i++) {
+                    for (i = 0; i < count && ninfos < nCharInfos; i++) {
-			*prCI++ = *tmpCharInfos[i];
+                        *prCI++ = *tmpCharInfos[i];
-			ninfos++;
+                        ninfos++;
-		    }
+                    }
-		}
+                }
-	    }
+            }
 #ifdef HAS_SHM
-	    if (pDesc && !badSysCall) {
+            if (pDesc && !badSysCall) {
-		*(CARD32 *)(pCI + nCharInfos) = signature;
+                *(CARD32 *) (pCI + nCharInfos) = signature;
-		if (!FontSetPrivate(pFont, FontShmdescIndex, pDesc)) {
+                if (!FontSetPrivate(pFont, FontShmdescIndex, pDesc)) {
-		    shmdealloc(pDesc);
+                    shmdealloc(pDesc);
-		    return BadAlloc;
+                    return BadAlloc;
-		}
+                }
-	    }
+            }
-	}
+        }
 #endif
-	if (shmid == -1) {
+        if (shmid == -1) {
-	    /* Cannot use shared memory, so remove-duplicates the xCharInfos
+            /* Cannot use shared memory, so remove-duplicates the xCharInfos
-	       using a temporary hash table. */
+               using a temporary hash table. */
-	    /* Note that CARD16 is suitable as index type, because
+            /* Note that CARD16 is suitable as index type, because
-	       nCharInfos <= 0x10000. */
+               nCharInfos <= 0x10000. */
-	    CARD32 hashModulus;
+            CARD32 hashModulus;
-	    CARD16* pHash2UniqIndex;
+            CARD16 *pHash2UniqIndex;
-	    CARD16* pUniqIndex2NextUniqIndex;
+            CARD16 *pUniqIndex2NextUniqIndex;
-	    CARD32 NextIndex;
+            CARD32 NextIndex;
-	    CARD32 NextUniqIndex;
+            CARD32 NextUniqIndex;
-	    CARD16* tmp;
+            CARD16 *tmp;
-	    CARD32 i, j;
+            CARD32 i, j;
 
-	    hashModulus = 67;
+            hashModulus = 67;
-	    if (hashModulus > nCharInfos+1)
+            if (hashModulus > nCharInfos + 1)
-		hashModulus = nCharInfos+1;
+                hashModulus = nCharInfos + 1;
 
-	    tmp = malloc((4*nCharInfos+1) * sizeof(CARD16));
+            tmp = malloc((4 * nCharInfos + 1) * sizeof(CARD16));
-	    if (!tmp) {
+            if (!tmp) {
-		if (!pDesc) free(pCI);
+                if (!pDesc)
-		return BadAlloc;
+                    free(pCI);
-	    }
+                return BadAlloc;
-	    pIndex2UniqIndex = tmp;
+            }
-		/* nCharInfos elements */
+            pIndex2UniqIndex = tmp;
-	    pUniqIndex2Index = tmp + nCharInfos;
+            /* nCharInfos elements */
-		/* max. nCharInfos elements */
+            pUniqIndex2Index = tmp + nCharInfos;
-	    pUniqIndex2NextUniqIndex = tmp + 2*nCharInfos;
+            /* max. nCharInfos elements */
-		/* max. nCharInfos elements */
+            pUniqIndex2NextUniqIndex = tmp + 2 * nCharInfos;
-	    pHash2UniqIndex = tmp + 3*nCharInfos;
+            /* max. nCharInfos elements */
-		/* hashModulus (<= nCharInfos+1) elements */
+            pHash2UniqIndex = tmp + 3 * nCharInfos;
+            /* hashModulus (<= nCharInfos+1) elements */
 
-	    /* Note that we can use 0xffff as end-of-list indicator, because
+            /* Note that we can use 0xffff as end-of-list indicator, because
-	       even if nCharInfos = 0x10000, 0xffff can not occur as valid
+               even if nCharInfos = 0x10000, 0xffff can not occur as valid
-	       entry before the last element has been inserted. And once the
+               entry before the last element has been inserted. And once the
-	       last element has been inserted, we don't need the hash table
+               last element has been inserted, we don't need the hash table
-	       any more. */
+               any more. */
-	    for (j = 0; j < hashModulus; j++)
+            for (j = 0; j < hashModulus; j++)
-		pHash2UniqIndex[j] = (CARD16)(-1);
+                pHash2UniqIndex[j] = (CARD16) (-1);
 
-	    NextUniqIndex = 0;
+            NextUniqIndex = 0;
-	    for (NextIndex = 0; NextIndex < nCharInfos; NextIndex++) {
+            for (NextIndex = 0; NextIndex < nCharInfos; NextIndex++) {
-		xCharInfo* p = &pCI[NextIndex];
+                xCharInfo *p = &pCI[NextIndex];
-		CARD32 hashCode = hashCI(p) % hashModulus;
+                CARD32 hashCode = hashCI(p) % hashModulus;
-		for (i = pHash2UniqIndex[hashCode];
+
-		     i != (CARD16)(-1);
+                for (i = pHash2UniqIndex[hashCode];
-		     i = pUniqIndex2NextUniqIndex[i]) {
+                     i != (CARD16) (-1); i = pUniqIndex2NextUniqIndex[i]) {
-		    j = pUniqIndex2Index[i];
+                    j = pUniqIndex2Index[i];
-		    if (pCI[j].leftSideBearing == p->leftSideBearing
+                    if (pCI[j].leftSideBearing == p->leftSideBearing
-			&& pCI[j].rightSideBearing == p->rightSideBearing
+                        && pCI[j].rightSideBearing == p->rightSideBearing
-			&& pCI[j].characterWidth == p->characterWidth
+                        && pCI[j].characterWidth == p->characterWidth
-			&& pCI[j].ascent == p->ascent
+                        && pCI[j].ascent == p->ascent
-			&& pCI[j].descent == p->descent
+                        && pCI[j].descent == p->descent
-			&& pCI[j].attributes == p->attributes)
+                        && pCI[j].attributes == p->attributes)
-			break;
+                        break;
-		}
+                }
-		if (i != (CARD16)(-1)) {
+                if (i != (CARD16) (-1)) {
-		    /* Found *p at Index j, UniqIndex i */
+                    /* Found *p at Index j, UniqIndex i */
-		    pIndex2UniqIndex[NextIndex] = i;
+                    pIndex2UniqIndex[NextIndex] = i;
-		} else {
+                }
-		    /* Allocate a new entry in the Uniq table */
+                else {
-		    if (hashModulus <= 2*NextUniqIndex
+                    /* Allocate a new entry in the Uniq table */
-			&& hashModulus < nCharInfos+1) {
+                    if (hashModulus <= 2 * NextUniqIndex
-			/* Time to increate hash table size */
+                        && hashModulus < nCharInfos + 1) {
-			hashModulus = 2*hashModulus+1;
+                        /* Time to increate hash table size */
-			if (hashModulus > nCharInfos+1)
+                        hashModulus = 2 * hashModulus + 1;
-			    hashModulus = nCharInfos+1;
+                        if (hashModulus > nCharInfos + 1)
-			for (j = 0; j < hashModulus; j++)
+                            hashModulus = nCharInfos + 1;
-			    pHash2UniqIndex[j] = (CARD16)(-1);
+                        for (j = 0; j < hashModulus; j++)
-			for (i = 0; i < NextUniqIndex; i++)
+                            pHash2UniqIndex[j] = (CARD16) (-1);
-			    pUniqIndex2NextUniqIndex[i] = (CARD16)(-1);
+                        for (i = 0; i < NextUniqIndex; i++)
-			for (i = 0; i < NextUniqIndex; i++) {
+                            pUniqIndex2NextUniqIndex[i] = (CARD16) (-1);
-			    j = pUniqIndex2Index[i];
+                        for (i = 0; i < NextUniqIndex; i++) {
-			    p = &pCI[j];
+                            j = pUniqIndex2Index[i];
-			    hashCode = hashCI(p) % hashModulus;
+                            p = &pCI[j];
-			    pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode];
+                            hashCode = hashCI(p) % hashModulus;
-			    pHash2UniqIndex[hashCode] = i;
+                            pUniqIndex2NextUniqIndex[i] =
-			}
+                                pHash2UniqIndex[hashCode];
-			p = &pCI[NextIndex];
+                            pHash2UniqIndex[hashCode] = i;
-			hashCode = hashCI(p) % hashModulus;
+                        }
-		    }
+                        p = &pCI[NextIndex];
-		    i = NextUniqIndex++;
+                        hashCode = hashCI(p) % hashModulus;
-		    pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode];
+                    }
-		    pHash2UniqIndex[hashCode] = i;
+                    i = NextUniqIndex++;
-		    pUniqIndex2Index[i] = NextIndex;
+                    pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode];
-		    pIndex2UniqIndex[NextIndex] = i;
+                    pHash2UniqIndex[hashCode] = i;
-		}
+                    pUniqIndex2Index[i] = NextIndex;
-	    }
+                    pIndex2UniqIndex[NextIndex] = i;
-	    nUniqCharInfos = NextUniqIndex;
+                }
-	    /* fprintf(stderr, "font metrics: nCharInfos = %d, nUniqCharInfos = %d, hashModulus = %d\n", nCharInfos, nUniqCharInfos, hashModulus); */
+            }
-	}
+            nUniqCharInfos = NextUniqIndex;
+            /* fprintf(stderr, "font metrics: nCharInfos = %d, nUniqCharInfos = %d, hashModulus = %d\n", nCharInfos, nUniqCharInfos, hashModulus); */
+        }
     }
 
     {
-	int nfontprops = pFont->info.nprops;
+        int nfontprops = pFont->info.nprops;
-	int rlength =
+        int rlength = sizeof(xXF86BigfontQueryFontReply)
-	   sizeof(xXF86BigfontQueryFontReply)
+            + nfontprops * sizeof(xFontProp)
-	   + nfontprops * sizeof(xFontProp)
+            + (nCharInfos > 0 && shmid == -1
-	   + (nCharInfos > 0 && shmid == -1
+               ? nUniqCharInfos * sizeof(xCharInfo)
-	      ? nUniqCharInfos * sizeof(xCharInfo)
+               + (nCharInfos + 1) / 2 * 2 * sizeof(CARD16)
-	        + (nCharInfos+1)/2 * 2 * sizeof(CARD16)
+               : 0);
-	      : 0);
+        xXF86BigfontQueryFontReply *reply = malloc(rlength);
-	xXF86BigfontQueryFontReply* reply = malloc(rlength);
+        char *p;
-	char* p;
+
-	if (!reply) {
+        if (!reply) {
-	    if (nCharInfos > 0) {
+            if (nCharInfos > 0) {
-		if (shmid == -1) free(pIndex2UniqIndex);
+                if (shmid == -1)
-		if (!pDesc) free(pCI);
+                    free(pIndex2UniqIndex);
-	    }
+                if (!pDesc)
-	    return BadAlloc;
+                    free(pCI);
-	}
+            }
-	reply->type = X_Reply;
+            return BadAlloc;
-	reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
+        }
-	reply->sequenceNumber = client->sequence;
+        reply->type = X_Reply;
-	reply->minBounds = pFont->info.ink_minbounds;
+        reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
-	reply->maxBounds = pFont->info.ink_maxbounds;
+        reply->sequenceNumber = client->sequence;
-	reply->minCharOrByte2 = pFont->info.firstCol;
+        reply->minBounds = pFont->info.ink_minbounds;
-	reply->maxCharOrByte2 = pFont->info.lastCol;
+        reply->maxBounds = pFont->info.ink_maxbounds;
-	reply->defaultChar = pFont->info.defaultCh;
+        reply->minCharOrByte2 = pFont->info.firstCol;
-	reply->nFontProps = pFont->info.nprops;
+        reply->maxCharOrByte2 = pFont->info.lastCol;
-	reply->drawDirection = pFont->info.drawDirection;
+        reply->defaultChar = pFont->info.defaultCh;
-	reply->minByte1 = pFont->info.firstRow;
+        reply->nFontProps = pFont->info.nprops;
-	reply->maxByte1 = pFont->info.lastRow;
+        reply->drawDirection = pFont->info.drawDirection;
-	reply->allCharsExist = pFont->info.allExist;
+        reply->minByte1 = pFont->info.firstRow;
-	reply->fontAscent = pFont->info.fontAscent;
+        reply->maxByte1 = pFont->info.lastRow;
-	reply->fontDescent = pFont->info.fontDescent;
+        reply->allCharsExist = pFont->info.allExist;
-	reply->nCharInfos = nCharInfos;
+        reply->fontAscent = pFont->info.fontAscent;
+        reply->fontDescent = pFont->info.fontDescent;
+        reply->nCharInfos = nCharInfos;
         reply->nUniqCharInfos = nUniqCharInfos;
-	reply->shmid = shmid;
+        reply->shmid = shmid;
-	reply->shmsegoffset = 0;
+        reply->shmsegoffset = 0;
-	if (client->swapped) {
+        if (client->swapped) {
-	    char tmp;
+            char tmp;
-	    swaps(&reply->sequenceNumber);
+
-	    swapl(&reply->length);
+            swaps(&reply->sequenceNumber);
-	    swapCharInfo(&reply->minBounds);
+            swapl(&reply->length);
-	    swapCharInfo(&reply->maxBounds);
+            swapCharInfo(&reply->minBounds);
-	    swaps(&reply->minCharOrByte2);
+            swapCharInfo(&reply->maxBounds);
-	    swaps(&reply->maxCharOrByte2);
+            swaps(&reply->minCharOrByte2);
-	    swaps(&reply->defaultChar);
+            swaps(&reply->maxCharOrByte2);
-	    swaps(&reply->nFontProps);
+            swaps(&reply->defaultChar);
-	    swaps(&reply->fontAscent);
+            swaps(&reply->nFontProps);
-	    swaps(&reply->fontDescent);
+            swaps(&reply->fontAscent);
-	    swapl(&reply->nCharInfos);
+            swaps(&reply->fontDescent);
-	    swapl(&reply->nUniqCharInfos);
+            swapl(&reply->nCharInfos);
-	    swapl(&reply->shmid);
+            swapl(&reply->nUniqCharInfos);
-	    swapl(&reply->shmsegoffset);
+            swapl(&reply->shmid);
-	}
+            swapl(&reply->shmsegoffset);
-	p = (char*) &reply[1];
+        }
-	{
+        p = (char *) &reply[1];
-	    FontPropPtr pFP;
+        {
-	    xFontProp* prFP;
+            FontPropPtr pFP;
-	    int i;
+            xFontProp *prFP;
-	    for (i = 0, pFP = pFont->info.props, prFP = (xFontProp *) p;
+            int i;
-		 i < nfontprops;
+
-		 i++, pFP++, prFP++) {
+            for (i = 0, pFP = pFont->info.props, prFP = (xFontProp *) p;
-		prFP->name = pFP->name;
+                 i < nfontprops; i++, pFP++, prFP++) {
-		prFP->value = pFP->value;
+                prFP->name = pFP->name;
-		if (client->swapped) {
+                prFP->value = pFP->value;
-		    char tmp;
+                if (client->swapped) {
-		    swapl(&prFP->name);
+                    char tmp;
-		    swapl(&prFP->value);
+
-		}
+                    swapl(&prFP->name);
-	    }
+                    swapl(&prFP->value);
-	    p = (char*) prFP;
+                }
-	}
+            }
-	if (nCharInfos > 0 && shmid == -1) {
+            p = (char *) prFP;
-	    xCharInfo* pci;
+        }
-	    CARD16* ps;
+        if (nCharInfos > 0 && shmid == -1) {
-	    int i, j;
+            xCharInfo *pci;
-	    pci = (xCharInfo*) p;
+            CARD16 *ps;
-	    for (i = 0; i < nUniqCharInfos; i++, pci++) {
+            int i, j;
-		*pci = pCI[pUniqIndex2Index[i]];
+
-		if (client->swapped)
+            pci = (xCharInfo *) p;
-		    swapCharInfo(pci);
+            for (i = 0; i < nUniqCharInfos; i++, pci++) {
-	    }
+                *pci = pCI[pUniqIndex2Index[i]];
-	    ps = (CARD16*) pci;
+                if (client->swapped)
-	    for (j = 0; j < nCharInfos; j++, ps++) {
+                    swapCharInfo(pci);
-		*ps = pIndex2UniqIndex[j];
+            }
-		if (client->swapped) {
+            ps = (CARD16 *) pci;
-		    char tmp;
+            for (j = 0; j < nCharInfos; j++, ps++) {
-		    swaps(ps);
+                *ps = pIndex2UniqIndex[j];
-		}
+                if (client->swapped) {
-	    }
+                    char tmp;
-	}
+
-	WriteToClient(client, rlength, (char *)reply);
+                    swaps(ps);
-	free(reply);
+                }
-	if (nCharInfos > 0) {
+            }
-	    if (shmid == -1) free(pIndex2UniqIndex);
+        }
-	    if (!pDesc) free(pCI);
+        WriteToClient(client, rlength, (char *) reply);
-	}
+        free(reply);
-	return Success;
+        if (nCharInfos > 0) {
+            if (shmid == -1)
+                free(pIndex2UniqIndex);
+            if (!pDesc)
+                free(pCI);
+        }
+        return Success;
     }
 }
 
 static int
-ProcXF86BigfontDispatch(
+ProcXF86BigfontDispatch(ClientPtr client)
-    ClientPtr client)
 {
     REQUEST(xReq);
 
     switch (stuff->data) {
-	case X_XF86BigfontQueryVersion:
+    case X_XF86BigfontQueryVersion:
-	    return ProcXF86BigfontQueryVersion(client);
+        return ProcXF86BigfontQueryVersion(client);
-	case X_XF86BigfontQueryFont:
+    case X_XF86BigfontQueryFont:
-	    return ProcXF86BigfontQueryFont(client);
+        return ProcXF86BigfontQueryFont(client);
-	default:
+    default:
-	    return BadRequest;
+        return BadRequest;
     }
 }
 
 static int
-SProcXF86BigfontQueryVersion(
+SProcXF86BigfontQueryVersion(ClientPtr client)
-    ClientPtr client)
 {
     REQUEST(xXF86BigfontQueryVersionReq);
     char tmp;
@@ -677,8 +682,7 @@ SProcXF86BigfontQueryVersion(
 }
 
 static int
-SProcXF86BigfontQueryFont(
+SProcXF86BigfontQueryFont(ClientPtr client)
-    ClientPtr client)
 {
     REQUEST(xXF86BigfontQueryFontReq);
     char tmp;
@@ -690,18 +694,17 @@ SProcXF86BigfontQueryFont(
 }
 
 static int
-SProcXF86BigfontDispatch(
+SProcXF86BigfontDispatch(ClientPtr client)
-    ClientPtr client)
 {
     REQUEST(xReq);
 
     switch (stuff->data) {
-	case X_XF86BigfontQueryVersion:
+    case X_XF86BigfontQueryVersion:
-	    return SProcXF86BigfontQueryVersion(client);
+        return SProcXF86BigfontQueryVersion(client);
-	case X_XF86BigfontQueryFont:
+    case X_XF86BigfontQueryFont:
-	    return SProcXF86BigfontQueryFont(client);
+        return SProcXF86BigfontQueryFont(client);
-	default:
+    default:
-	    return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -709,41 +712,41 @@ void
 XFree86BigfontExtensionInit(void)
 {
     if (AddExtension(XF86BIGFONTNAME,
-		     XF86BigfontNumberEvents,
+                     XF86BigfontNumberEvents,
-		     XF86BigfontNumberErrors,
+                     XF86BigfontNumberErrors,
-		     ProcXF86BigfontDispatch,
+                     ProcXF86BigfontDispatch,
-		     SProcXF86BigfontDispatch,
+                     SProcXF86BigfontDispatch,
-		     XF86BigfontResetProc,
+                     XF86BigfontResetProc, StandardMinorOpcode)) {
-		     StandardMinorOpcode)) {
 #ifdef HAS_SHM
 #ifdef MUST_CHECK_FOR_SHM_SYSCALL
-	/*
+        /*
-	 * Note: Local-clients will not be optimized without shared memory
+         * Note: Local-clients will not be optimized without shared memory
-	 * support. Remote-client optimization does not depend on shared
+         * support. Remote-client optimization does not depend on shared
-	 * memory support.  Thus, the extension is still registered even
+         * memory support.  Thus, the extension is still registered even
-	 * when shared memory support is not functional.
+         * when shared memory support is not functional.
-	 */
+         */
-	if (!CheckForShmSyscall()) {
+        if (!CheckForShmSyscall()) {
-	    ErrorF(XF86BIGFONTNAME " extension local-client optimization disabled due to lack of shared memory support in the kernel\n");
+            ErrorF(XF86BIGFONTNAME
-	    return;
+                   " extension local-client optimization disabled due to lack of shared memory support in the kernel\n");
-	}
+            return;
+        }
 #endif
 
-	srand((unsigned int) time(NULL));
+        srand((unsigned int) time(NULL));
-	signature = ((unsigned int) (65536.0/(RAND_MAX+1.0) * rand()) << 16)
+        signature = ((unsigned int) (65536.0 / (RAND_MAX + 1.0) * rand()) << 16)
-	           + (unsigned int) (65536.0/(RAND_MAX+1.0) * rand());
+            + (unsigned int) (65536.0 / (RAND_MAX + 1.0) * rand());
-	/* fprintf(stderr, "signature = 0x%08X\n", signature); */
+        /* fprintf(stderr, "signature = 0x%08X\n", signature); */
 
-	FontShmdescIndex = AllocateFontPrivateIndex();
+        FontShmdescIndex = AllocateFontPrivateIndex();
 
 #if !defined(CSRG_BASED) && !defined(__CYGWIN__)
-	pagesize = SHMLBA;
+        pagesize = SHMLBA;
 #else
-# ifdef _SC_PAGESIZE
+#ifdef _SC_PAGESIZE
-	pagesize = sysconf(_SC_PAGESIZE);
+        pagesize = sysconf(_SC_PAGESIZE);
-# else
+#else
-	pagesize = getpagesize();
+        pagesize = getpagesize();
-# endif
+#endif
 #endif
 #endif
     }

Xext/xres.c

@@ -24,12 +24,12 @@
 #include "protocol-versions.h"
 
 static int
-ProcXResQueryVersion (ClientPtr client)
+ProcXResQueryVersion(ClientPtr client)
 {
     REQUEST(xXResQueryVersionReq);
     xXResQueryVersionReply rep;
 
-    REQUEST_SIZE_MATCH (xXResQueryVersionReq);
+    REQUEST_SIZE_MATCH(xXResQueryVersionReq);
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -42,12 +42,12 @@ ProcXResQueryVersion (ClientPtr client)
         swaps(&rep.server_major);
         swaps(&rep.server_minor);
     }
-    WriteToClient(client, sizeof (xXResQueryVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXResQueryVersionReply), (char *) &rep);
     return Success;
 }
 
 static int
-ProcXResQueryClients (ClientPtr client)
+ProcXResQueryClients(ClientPtr client)
 {
     /* REQUEST(xXResQueryClientsReq); */
     xXResQueryClientsReply rep;
@@ -59,11 +59,11 @@ ProcXResQueryClients (ClientPtr client)
     current_clients = malloc(currentMaxClients * sizeof(int));
 
     num_clients = 0;
-    for(i = 0; i < currentMaxClients; i++) {
+    for (i = 0; i < currentMaxClients; i++) {
-       if(clients[i]) {
+        if (clients[i]) {
-           current_clients[num_clients] = i;
+            current_clients[num_clients] = i;
-           num_clients++;   
+            num_clients++;
-       }
+        }
     }
 
     rep.type = X_Reply;
@@ -75,20 +75,20 @@ ProcXResQueryClients (ClientPtr client)
         swapl(&rep.length);
         swapl(&rep.num_clients);
     }
-    WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep);
+    WriteToClient(client, sizeof(xXResQueryClientsReply), (char *) &rep);
 
-    if(num_clients) {
+    if (num_clients) {
         xXResClient scratch;
 
-        for(i = 0; i < num_clients; i++) {
+        for (i = 0; i < num_clients; i++) {
             scratch.resource_base = clients[current_clients[i]]->clientAsMask;
             scratch.resource_mask = RESOURCE_ID_MASK;
 
-            if(client->swapped) {
+            if (client->swapped) {
                 swapl(&scratch.resource_base);
                 swapl(&scratch.resource_mask);
             }
-            WriteToClient (client, sz_xXResClient, (char *) &scratch);
+            WriteToClient(client, sz_xXResClient, (char *) &scratch);
         }
     }
 
@@ -97,17 +97,16 @@ ProcXResQueryClients (ClientPtr client)
     return Success;
 }
 
-
 static void
-ResFindAllRes (pointer value, XID id, RESTYPE type, pointer cdata)
+ResFindAllRes(pointer value, XID id, RESTYPE type, pointer cdata)
 {
-    int *counts = (int *)cdata;
+    int *counts = (int *) cdata;
 
     counts[(type & TypeMask) - 1]++;
 }
 
 static int
-ProcXResQueryClientResources (ClientPtr client)
+ProcXResQueryClientResources(ClientPtr client)
 {
     REQUEST(xXResQueryClientResourcesReq);
     xXResQueryClientResourcesReply rep;
@@ -118,7 +117,7 @@ ProcXResQueryClientResources (ClientPtr client)
 
     clientID = CLIENT_ID(stuff->xid);
 
-    if((clientID >= currentMaxClients) || !clients[clientID]) {
+    if ((clientID >= currentMaxClients) || !clients[clientID]) {
         client->errorValue = stuff->xid;
         return BadValue;
     }
@@ -129,8 +128,9 @@ ProcXResQueryClientResources (ClientPtr client)
 
     num_types = 0;
 
-    for(i = 0; i <= lastResourceType; i++) {
+    for (i = 0; i <= lastResourceType; i++) {
-       if(counts[i]) num_types++;
+        if (counts[i])
+            num_types++;
     }
 
     rep.type = X_Reply;
@@ -143,31 +143,34 @@ ProcXResQueryClientResources (ClientPtr client)
         swapl(&rep.num_types);
     }
 
-    WriteToClient (client,sizeof(xXResQueryClientResourcesReply),(char*)&rep);
+    WriteToClient(client, sizeof(xXResQueryClientResourcesReply),
+                  (char *) &rep);
 
-    if(num_types) {
+    if (num_types) {
         xXResType scratch;
-	const char *name;
+        const char *name;
 
-        for(i = 0; i < lastResourceType; i++) {
+        for (i = 0; i < lastResourceType; i++) {
-            if(!counts[i]) continue;
+            if (!counts[i])
+                continue;
 
-	    name = LookupResourceName(i + 1);
+            name = LookupResourceName(i + 1);
             if (strcmp(name, XREGISTRY_UNKNOWN))
-		scratch.resource_type = MakeAtom(name, strlen(name), TRUE);
+                scratch.resource_type = MakeAtom(name, strlen(name), TRUE);
-	    else {
+            else {
                 char buf[40];
+
                 snprintf(buf, sizeof(buf), "Unregistered resource %i", i + 1);
-		scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE);
+                scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE);
             }
 
             scratch.count = counts[i];
 
-            if(client->swapped) {
+            if (client->swapped) {
                 swapl(&scratch.resource_type);
                 swapl(&scratch.count);
             }
-            WriteToClient (client, sz_xXResType, (char *) &scratch);
+            WriteToClient(client, sz_xXResType, (char *) &scratch);
         }
     }
 
@@ -177,57 +180,57 @@ ProcXResQueryClientResources (ClientPtr client)
 }
 
 static unsigned long
-ResGetApproxPixmapBytes (PixmapPtr pix)
+ResGetApproxPixmapBytes(PixmapPtr pix)
 {
-   unsigned long nPixels;
+    unsigned long nPixels;
-   int           bytesPerPixel; 
+    int bytesPerPixel;
 
-   bytesPerPixel = pix->drawable.bitsPerPixel>>3;
+    bytesPerPixel = pix->drawable.bitsPerPixel >> 3;
-   nPixels       = pix->drawable.width * pix->drawable.height;
+    nPixels = pix->drawable.width * pix->drawable.height;
 
-   /* Divide by refcnt as pixmap could be shared between clients,  
+    /* Divide by refcnt as pixmap could be shared between clients,  
-    * so total pixmap mem is shared between these. 
+     * so total pixmap mem is shared between these. 
-   */
+     */
-   return ( nPixels * bytesPerPixel ) / pix->refcnt;
+    return (nPixels * bytesPerPixel) / pix->refcnt;
 }
 
 static void
-ResFindPixmaps (pointer value, XID id, pointer cdata)
+ResFindPixmaps(pointer value, XID id, pointer cdata)
 {
-   unsigned long *bytes = (unsigned long *)cdata;
+    unsigned long *bytes = (unsigned long *) cdata;
-   PixmapPtr pix = (PixmapPtr)value;
+    PixmapPtr pix = (PixmapPtr) value;
 
-   *bytes += ResGetApproxPixmapBytes(pix);
+    *bytes += ResGetApproxPixmapBytes(pix);
 }
 
 static void
-ResFindWindowPixmaps (pointer value, XID id, pointer cdata)
+ResFindWindowPixmaps(pointer value, XID id, pointer cdata)
 {
-   unsigned long *bytes = (unsigned long *)cdata;
+    unsigned long *bytes = (unsigned long *) cdata;
-   WindowPtr pWin = (WindowPtr)value;
+    WindowPtr pWin = (WindowPtr) value;
 
-   if (pWin->backgroundState == BackgroundPixmap)
+    if (pWin->backgroundState == BackgroundPixmap)
-     *bytes += ResGetApproxPixmapBytes(pWin->background.pixmap);
+        *bytes += ResGetApproxPixmapBytes(pWin->background.pixmap);
 
-   if (pWin->border.pixmap != NULL && !pWin->borderIsPixel)
+    if (pWin->border.pixmap != NULL && !pWin->borderIsPixel)
-     *bytes += ResGetApproxPixmapBytes(pWin->border.pixmap);
+        *bytes += ResGetApproxPixmapBytes(pWin->border.pixmap);
 }
 
 static void
-ResFindGCPixmaps (pointer value, XID id, pointer cdata)
+ResFindGCPixmaps(pointer value, XID id, pointer cdata)
 {
-   unsigned long *bytes = (unsigned long *)cdata;
+    unsigned long *bytes = (unsigned long *) cdata;
-   GCPtr pGC = (GCPtr)value;
+    GCPtr pGC = (GCPtr) value;
 
-   if (pGC->stipple != NULL)
+    if (pGC->stipple != NULL)
-     *bytes += ResGetApproxPixmapBytes(pGC->stipple);
+        *bytes += ResGetApproxPixmapBytes(pGC->stipple);
 
-   if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel)
+    if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel)
-     *bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap);
+        *bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap);
 }
 
 static int
-ProcXResQueryClientPixmapBytes (ClientPtr client)
+ProcXResQueryClientPixmapBytes(ClientPtr client)
 {
     REQUEST(xXResQueryClientPixmapBytesReq);
     xXResQueryClientPixmapBytesReply rep;
@@ -238,7 +241,7 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
 
     clientID = CLIENT_ID(stuff->xid);
 
-    if((clientID >= currentMaxClients) || !clients[clientID]) {
+    if ((clientID >= currentMaxClients) || !clients[clientID]) {
         client->errorValue = stuff->xid;
         return BadValue;
     }
@@ -246,21 +249,19 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
     bytes = 0;
 
     FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps,
-                              (pointer)(&bytes));
+                              (pointer) (&bytes));
 
     /* 
      * Make sure win background pixmaps also held to account. 
      */
     FindClientResourcesByType(clients[clientID], RT_WINDOW,
-			      ResFindWindowPixmaps, 
+                              ResFindWindowPixmaps, (pointer) (&bytes));
-                              (pointer)(&bytes));
 
     /* 
      * GC Tile & Stipple pixmaps too.
-    */
+     */
     FindClientResourcesByType(clients[clientID], RT_GC,
-			      ResFindGCPixmaps, 
+                              ResFindGCPixmaps, (pointer) (&bytes));
-                              (pointer)(&bytes));
 
 #ifdef COMPOSITE
     /* FIXME: include composite pixmaps too */
@@ -281,13 +282,14 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
         swapl(&rep.bytes);
         swapl(&rep.bytes_overflow);
     }
-    WriteToClient (client,sizeof(xXResQueryClientPixmapBytesReply),(char*)&rep);
+    WriteToClient(client, sizeof(xXResQueryClientPixmapBytesReply),
+                  (char *) &rep);
 
     return Success;
 }
 
 static int
-ProcResDispatch (ClientPtr client)
+ProcResDispatch(ClientPtr client)
 {
     REQUEST(xReq);
     switch (stuff->data) {
@@ -299,40 +301,41 @@ ProcResDispatch (ClientPtr client)
         return ProcXResQueryClientResources(client);
     case X_XResQueryClientPixmapBytes:
         return ProcXResQueryClientPixmapBytes(client);
-    default: break;
+    default:
+        break;
     }
 
     return BadRequest;
 }
 
 static int
-SProcXResQueryVersion (ClientPtr client)
+SProcXResQueryVersion(ClientPtr client)
 {
     REQUEST(xXResQueryVersionReq);
-    REQUEST_SIZE_MATCH (xXResQueryVersionReq);
+    REQUEST_SIZE_MATCH(xXResQueryVersionReq);
     return ProcXResQueryVersion(client);
 }
 
 static int
-SProcXResQueryClientResources (ClientPtr client)
+SProcXResQueryClientResources(ClientPtr client)
 {
     REQUEST(xXResQueryClientResourcesReq);
-    REQUEST_SIZE_MATCH (xXResQueryClientResourcesReq);
+    REQUEST_SIZE_MATCH(xXResQueryClientResourcesReq);
     swapl(&stuff->xid);
     return ProcXResQueryClientResources(client);
 }
 
 static int
-SProcXResQueryClientPixmapBytes (ClientPtr client)
+SProcXResQueryClientPixmapBytes(ClientPtr client)
 {
     REQUEST(xXResQueryClientPixmapBytesReq);
-    REQUEST_SIZE_MATCH (xXResQueryClientPixmapBytesReq);
+    REQUEST_SIZE_MATCH(xXResQueryClientPixmapBytesReq);
     swapl(&stuff->xid);
     return ProcXResQueryClientPixmapBytes(client);
 }
 
 static int
-SProcResDispatch (ClientPtr client)
+SProcResDispatch(ClientPtr client)
 {
     REQUEST(xReq);
     swaps(&stuff->length);
@@ -340,13 +343,14 @@ SProcResDispatch (ClientPtr client)
     switch (stuff->data) {
     case X_XResQueryVersion:
         return SProcXResQueryVersion(client);
-    case X_XResQueryClients:  /* nothing to swap */
+    case X_XResQueryClients:   /* nothing to swap */
         return ProcXResQueryClients(client);
     case X_XResQueryClientResources:
         return SProcXResQueryClientResources(client);
     case X_XResQueryClientPixmapBytes:
         return SProcXResQueryClientPixmapBytes(client);
-    default: break;
+    default:
+        break;
     }
 
     return BadRequest;
@@ -356,6 +360,6 @@ void
 ResExtensionInit(INITARGS)
 {
     (void) AddExtension(XRES_NAME, 0, 0,
-                            ProcResDispatch, SProcResDispatch,
+                        ProcResDispatch, SProcResDispatch,
-                            NULL, StandardMinorOpcode);
+                        NULL, StandardMinorOpcode);
 }

Xext/xselinux.h

@@ -53,87 +53,87 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #define X_SELinuxGetClientContext		22
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
-    CARD8   client_major;
+    CARD8 client_major;
-    CARD8   client_minor;
+    CARD8 client_minor;
 } SELinuxQueryVersionReq;
 
 typedef struct {
-    CARD8   type;
+    CARD8 type;
-    CARD8   pad1;
+    CARD8 pad1;
-    CARD16  sequenceNumber;
+    CARD16 sequenceNumber;
-    CARD32  length;
+    CARD32 length;
-    CARD16  server_major;
+    CARD16 server_major;
-    CARD16  server_minor;
+    CARD16 server_minor;
-    CARD32  pad2;
+    CARD32 pad2;
-    CARD32  pad3;
+    CARD32 pad3;
-    CARD32  pad4;
+    CARD32 pad4;
-    CARD32  pad5;
+    CARD32 pad5;
-    CARD32  pad6; 
+    CARD32 pad6;
 } SELinuxQueryVersionReply;
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
-    CARD32  context_len;
+    CARD32 context_len;
 } SELinuxSetCreateContextReq;
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
 } SELinuxGetCreateContextReq;
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
-    CARD32  id;
+    CARD32 id;
-    CARD32  context_len;
+    CARD32 context_len;
 } SELinuxSetContextReq;
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
-    CARD32  id;
+    CARD32 id;
 } SELinuxGetContextReq;
 
 typedef struct {
-    CARD8   reqType;
+    CARD8 reqType;
-    CARD8   SELinuxReqType;
+    CARD8 SELinuxReqType;
-    CARD16  length;
+    CARD16 length;
-    CARD32  window;
+    CARD32 window;
-    CARD32  property;
+    CARD32 property;
 } SELinuxGetPropertyContextReq;
 
 typedef struct {
-    CARD8   type;
+    CARD8 type;
-    CARD8   pad1;
+    CARD8 pad1;
-    CARD16  sequenceNumber;
+    CARD16 sequenceNumber;
-    CARD32  length;
+    CARD32 length;
-    CARD32  context_len;
+    CARD32 context_len;
-    CARD32  pad2;
+    CARD32 pad2;
-    CARD32  pad3;
+    CARD32 pad3;
-    CARD32  pad4;
+    CARD32 pad4;
-    CARD32  pad5;
+    CARD32 pad5;
-    CARD32  pad6;
+    CARD32 pad6;
 } SELinuxGetContextReply;
 
 typedef struct {
-    CARD8   type;
+    CARD8 type;
-    CARD8   pad1;
+    CARD8 pad1;
-    CARD16  sequenceNumber;
+    CARD16 sequenceNumber;
-    CARD32  length;
+    CARD32 length;
-    CARD32  count;
+    CARD32 count;
-    CARD32  pad2;
+    CARD32 pad2;
-    CARD32  pad3;
+    CARD32 pad3;
-    CARD32  pad4;
+    CARD32 pad4;
-    CARD32  pad5;
+    CARD32 pad5;
-    CARD32  pad6;
+    CARD32 pad6;
 } SELinuxListItemsReply;
 
-#endif /* _XSELINUX_H */
+#endif                          /* _XSELINUX_H */

Xext/xselinux_ext.c

@@ -44,7 +44,6 @@ typedef struct {
     CARD32 id;
 } SELinuxListItemRec;
 
-
 /*
  * Extension Dispatch
  */
@@ -53,8 +52,9 @@ static security_context_t
 SELinuxCopyContext(char *ptr, unsigned len)
 {
     security_context_t copy = malloc(len + 1);
+
     if (!copy)
-	return NULL;
+        return NULL;
     strncpy(copy, ptr, len);
     copy[len] = '\0';
     return copy;
@@ -71,12 +71,12 @@ ProcSELinuxQueryVersion(ClientPtr client)
     rep.server_major = SELINUX_MAJOR_VERSION;
     rep.server_minor = SELINUX_MINOR_VERSION;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
+        swapl(&rep.length);
-	swaps(&rep.server_major);
+        swaps(&rep.server_major);
-	swaps(&rep.server_minor);
+        swaps(&rep.server_minor);
     }
-    WriteToClient(client, sizeof(rep), (char *)&rep);
+    WriteToClient(client, sizeof(rep), (char *) &rep);
     return Success;
 }
 
@@ -88,9 +88,9 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
     int len = 0;
 
     if (sid) {
-	if (avc_sid_to_context_raw(sid, &ctx) < 0)
+        if (avc_sid_to_context_raw(sid, &ctx) < 0)
-	    return BadValue;
+            return BadValue;
-	len = strlen(ctx) + 1;
+        len = strlen(ctx) + 1;
     }
 
     rep.type = X_Reply;
@@ -99,12 +99,12 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
     rep.context_len = len;
 
     if (client->swapped) {
-	swapl(&rep.length);
+        swapl(&rep.length);
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.context_len);
+        swapl(&rep.context_len);
     }
 
-    WriteToClient(client, sizeof(SELinuxGetContextReply), (char *)&rep);
+    WriteToClient(client, sizeof(SELinuxGetContextReply), (char *) &rep);
     WriteToClient(client, len, ctx);
     freecon(ctx);
     return Success;
@@ -123,20 +123,20 @@ ProcSELinuxSetCreateContext(ClientPtr client, unsigned offset)
     REQUEST_FIXED_SIZE(SELinuxSetCreateContextReq, stuff->context_len);
 
     if (stuff->context_len > 0) {
-	ctx = SELinuxCopyContext((char *)(stuff + 1), stuff->context_len);
+        ctx = SELinuxCopyContext((char *) (stuff + 1), stuff->context_len);
-	if (!ctx)
+        if (!ctx)
-	    return BadAlloc;
+            return BadAlloc;
     }
 
     ptr = dixLookupPrivate(privPtr, subjectKey);
-    pSid = (security_id_t *)(ptr + offset);
+    pSid = (security_id_t *) (ptr + offset);
     *pSid = NULL;
 
     rc = Success;
     if (stuff->context_len > 0) {
-	if (security_check_context_raw(ctx) < 0 ||
+        if (security_check_context_raw(ctx) < 0 ||
-	    avc_context_to_sid_raw(ctx, pSid) < 0)
+            avc_context_to_sid_raw(ctx, pSid) < 0)
-	    rc = BadValue;
+            rc = BadValue;
     }
 
     free(ctx);
@@ -152,11 +152,11 @@ ProcSELinuxGetCreateContext(ClientPtr client, unsigned offset)
     REQUEST_SIZE_MATCH(SELinuxGetCreateContextReq);
 
     if (offset == CTX_DEV)
-	ptr = dixLookupPrivate(&serverClient->devPrivates, subjectKey);
+        ptr = dixLookupPrivate(&serverClient->devPrivates, subjectKey);
     else
-	ptr = dixLookupPrivate(&client->devPrivates, subjectKey);
+        ptr = dixLookupPrivate(&client->devPrivates, subjectKey);
 
-    pSid = (security_id_t *)(ptr + offset);
+    pSid = (security_id_t *) (ptr + offset);
     return SELinuxSendContextReply(client, *pSid);
 }
 
@@ -174,19 +174,19 @@ ProcSELinuxSetDeviceContext(ClientPtr client)
     REQUEST_FIXED_SIZE(SELinuxSetContextReq, stuff->context_len);
 
     if (stuff->context_len < 1)
-	return BadLength;
+        return BadLength;
-    ctx = SELinuxCopyContext((char *)(stuff + 1), stuff->context_len);
+    ctx = SELinuxCopyContext((char *) (stuff + 1), stuff->context_len);
     if (!ctx)
-	return BadAlloc;
+        return BadAlloc;
 
     rc = dixLookupDevice(&dev, stuff->id, client, DixManageAccess);
     if (rc != Success)
-	goto out;
+        goto out;
 
     if (security_check_context_raw(ctx) < 0 ||
-	avc_context_to_sid_raw(ctx, &sid) < 0) {
+        avc_context_to_sid_raw(ctx, &sid) < 0) {
-	rc = BadValue;
+        rc = BadValue;
-	goto out;
+        goto out;
     }
 
     subj = dixLookupPrivate(&dev->devPrivates, subjectKey);
@@ -195,7 +195,7 @@ ProcSELinuxSetDeviceContext(ClientPtr client)
     obj->sid = sid;
 
     rc = Success;
-out:
+ out:
     free(ctx);
     return rc;
 }
@@ -212,7 +212,7 @@ ProcSELinuxGetDeviceContext(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->id, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     subj = dixLookupPrivate(&dev->devPrivates, subjectKey);
     return SELinuxSendContextReply(client, subj->sid);
@@ -231,12 +231,12 @@ ProcSELinuxGetDrawableContext(ClientPtr client)
 
     rc = dixLookupDrawable(&pDraw, stuff->id, client, 0, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (pDraw->type == DRAWABLE_PIXMAP)
-	privatePtr = &((PixmapPtr)pDraw)->devPrivates;
+        privatePtr = &((PixmapPtr) pDraw)->devPrivates;
     else
-	privatePtr = &((WindowPtr)pDraw)->devPrivates;
+        privatePtr = &((WindowPtr) pDraw)->devPrivates;
 
     obj = dixLookupPrivate(privatePtr, objectKey);
     return SELinuxSendContextReply(client, obj->sid);
@@ -255,12 +255,12 @@ ProcSELinuxGetPropertyContext(ClientPtr client, pointer privKey)
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetPropAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rc = dixLookupProperty(&pProp, pWin, stuff->property, client,
-			   DixGetAttrAccess);
+                           DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     obj = dixLookupPrivate(&pProp->devPrivates, privKey);
     return SELinuxSendContextReply(client, obj->sid);
@@ -278,7 +278,7 @@ ProcSELinuxGetSelectionContext(ClientPtr client, pointer privKey)
 
     rc = dixLookupSelection(&pSel, stuff->id, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     obj = dixLookupPrivate(&pSel->devPrivates, privKey);
     return SELinuxSendContextReply(client, obj->sid);
@@ -296,23 +296,23 @@ ProcSELinuxGetClientContext(ClientPtr client)
 
     rc = dixLookupClient(&target, stuff->id, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     subj = dixLookupPrivate(&target->devPrivates, subjectKey);
     return SELinuxSendContextReply(client, subj->sid);
 }
 
 static int
-SELinuxPopulateItem(SELinuxListItemRec *i, PrivateRec **privPtr, CARD32 id,
+SELinuxPopulateItem(SELinuxListItemRec * i, PrivateRec ** privPtr, CARD32 id,
-		    int *size)
+                    int *size)
 {
     SELinuxObjectRec *obj = dixLookupPrivate(privPtr, objectKey);
     SELinuxObjectRec *data = dixLookupPrivate(privPtr, dataKey);
 
     if (avc_sid_to_context_raw(obj->sid, &i->octx) < 0)
-	return BadValue;
+        return BadValue;
     if (avc_sid_to_context_raw(data->sid, &i->dctx) < 0)
-	return BadValue;
+        return BadValue;
 
     i->id = id;
     i->octx_len = bytes_to_int32(strlen(i->octx) + 1);
@@ -323,19 +323,20 @@ SELinuxPopulateItem(SELinuxListItemRec *i, PrivateRec **privPtr, CARD32 id,
 }
 
 static void
-SELinuxFreeItems(SELinuxListItemRec *items, int count)
+SELinuxFreeItems(SELinuxListItemRec * items, int count)
 {
     int k;
+
     for (k = 0; k < count; k++) {
-	freecon(items[k].octx);
+        freecon(items[k].octx);
-	freecon(items[k].dctx);
+        freecon(items[k].dctx);
     }
     free(items);
 }
 
 static int
-SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
+SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec * items,
-			 int size, int count)
+                         int size, int count)
 {
     int rc, k, pos = 0;
     SELinuxListItemsReply rep;
@@ -343,31 +344,31 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
 
     buf = calloc(size, sizeof(CARD32));
     if (size && !buf) {
-	rc = BadAlloc;
+        rc = BadAlloc;
-	goto out;
+        goto out;
     }
 
     /* Fill in the buffer */
     for (k = 0; k < count; k++) {
-	buf[pos] = items[k].id;
+        buf[pos] = items[k].id;
-	if (client->swapped)
+        if (client->swapped)
-	    swapl(buf + pos);
+            swapl(buf + pos);
-	pos++;
+        pos++;
 
-	buf[pos] = items[k].octx_len * 4;
+        buf[pos] = items[k].octx_len * 4;
-	if (client->swapped)
+        if (client->swapped)
-	    swapl(buf + pos);
+            swapl(buf + pos);
-	pos++;
+        pos++;
 
-	buf[pos] = items[k].dctx_len * 4;
+        buf[pos] = items[k].dctx_len * 4;
-	if (client->swapped)
+        if (client->swapped)
-	    swapl(buf + pos);
+            swapl(buf + pos);
-	pos++;
+        pos++;
 
-	memcpy((char *)(buf + pos), items[k].octx, strlen(items[k].octx) + 1);
+        memcpy((char *) (buf + pos), items[k].octx, strlen(items[k].octx) + 1);
-	pos += items[k].octx_len;
+        pos += items[k].octx_len;
-	memcpy((char *)(buf + pos), items[k].dctx, strlen(items[k].dctx) + 1);
+        memcpy((char *) (buf + pos), items[k].dctx, strlen(items[k].dctx) + 1);
-	pos += items[k].dctx_len;
+        pos += items[k].dctx_len;
     }
 
     /* Send reply to client */
@@ -377,18 +378,18 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
     rep.count = count;
 
     if (client->swapped) {
-	swapl(&rep.length);
+        swapl(&rep.length);
-	swaps(&rep.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-	swapl(&rep.count);
+        swapl(&rep.count);
     }
 
-    WriteToClient(client, sizeof(SELinuxListItemsReply), (char *)&rep);
+    WriteToClient(client, sizeof(SELinuxListItemsReply), (char *) &rep);
-    WriteToClient(client, size * 4, (char *)buf);
+    WriteToClient(client, size * 4, (char *) buf);
 
     /* Free stuff and return */
     rc = Success;
     free(buf);
-out:
+ out:
     SELinuxFreeItems(items, count);
     return rc;
 }
@@ -407,27 +408,27 @@ ProcSELinuxListProperties(ClientPtr client)
 
     rc = dixLookupWindow(&pWin, stuff->id, client, DixListPropAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     /* Count the number of properties and allocate items */
     count = 0;
     for (pProp = wUserProps(pWin); pProp; pProp = pProp->next)
-	count++;
+        count++;
     items = calloc(count, sizeof(SELinuxListItemRec));
     if (count && !items)
-	return BadAlloc;
+        return BadAlloc;
 
     /* Fill in the items and calculate size */
     i = 0;
     size = 0;
     for (pProp = wUserProps(pWin); pProp; pProp = pProp->next) {
-	id = pProp->propertyName;
+        id = pProp->propertyName;
-	rc = SELinuxPopulateItem(items + i, &pProp->devPrivates, id, &size);
+        rc = SELinuxPopulateItem(items + i, &pProp->devPrivates, id, &size);
-	if (rc != Success) {
+        if (rc != Success) {
-	    SELinuxFreeItems(items, count);
+            SELinuxFreeItems(items, count);
-	    return rc;
+            return rc;
-	}
+        }
-	i++;
+        i++;
     }
 
     return SELinuxSendItemsToClient(client, items, size, count);
@@ -446,22 +447,22 @@ ProcSELinuxListSelections(ClientPtr client)
     /* Count the number of selections and allocate items */
     count = 0;
     for (pSel = CurrentSelections; pSel; pSel = pSel->next)
-	count++;
+        count++;
     items = calloc(count, sizeof(SELinuxListItemRec));
     if (count && !items)
-	return BadAlloc;
+        return BadAlloc;
 
     /* Fill in the items and calculate size */
     i = 0;
     size = 0;
     for (pSel = CurrentSelections; pSel; pSel = pSel->next) {
-	id = pSel->selection;
+        id = pSel->selection;
-	rc = SELinuxPopulateItem(items + i, &pSel->devPrivates, id, &size);
+        rc = SELinuxPopulateItem(items + i, &pSel->devPrivates, id, &size);
-	if (rc != Success) {
+        if (rc != Success) {
-	    SELinuxFreeItems(items, count);
+            SELinuxFreeItems(items, count);
-	    return rc;
+            return rc;
-	}
+        }
-	i++;
+        i++;
     }
 
     return SELinuxSendItemsToClient(client, items, size, count);
@@ -473,53 +474,53 @@ ProcSELinuxDispatch(ClientPtr client)
     REQUEST(xReq);
     switch (stuff->data) {
     case X_SELinuxQueryVersion:
-	return ProcSELinuxQueryVersion(client);
+        return ProcSELinuxQueryVersion(client);
     case X_SELinuxSetDeviceCreateContext:
-	return ProcSELinuxSetCreateContext(client, CTX_DEV);
+        return ProcSELinuxSetCreateContext(client, CTX_DEV);
     case X_SELinuxGetDeviceCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_DEV);
+        return ProcSELinuxGetCreateContext(client, CTX_DEV);
     case X_SELinuxSetDeviceContext:
-	return ProcSELinuxSetDeviceContext(client);
+        return ProcSELinuxSetDeviceContext(client);
     case X_SELinuxGetDeviceContext:
-	return ProcSELinuxGetDeviceContext(client);
+        return ProcSELinuxGetDeviceContext(client);
     case X_SELinuxSetDrawableCreateContext:
-	return ProcSELinuxSetCreateContext(client, CTX_WIN);
+        return ProcSELinuxSetCreateContext(client, CTX_WIN);
     case X_SELinuxGetDrawableCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_WIN);
+        return ProcSELinuxGetCreateContext(client, CTX_WIN);
     case X_SELinuxGetDrawableContext:
-	return ProcSELinuxGetDrawableContext(client);
+        return ProcSELinuxGetDrawableContext(client);
     case X_SELinuxSetPropertyCreateContext:
-	return ProcSELinuxSetCreateContext(client, CTX_PRP);
+        return ProcSELinuxSetCreateContext(client, CTX_PRP);
     case X_SELinuxGetPropertyCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_PRP);
+        return ProcSELinuxGetCreateContext(client, CTX_PRP);
     case X_SELinuxSetPropertyUseContext:
-	return ProcSELinuxSetCreateContext(client, USE_PRP);
+        return ProcSELinuxSetCreateContext(client, USE_PRP);
     case X_SELinuxGetPropertyUseContext:
-	return ProcSELinuxGetCreateContext(client, USE_PRP);
+        return ProcSELinuxGetCreateContext(client, USE_PRP);
     case X_SELinuxGetPropertyContext:
-	return ProcSELinuxGetPropertyContext(client, objectKey);
+        return ProcSELinuxGetPropertyContext(client, objectKey);
     case X_SELinuxGetPropertyDataContext:
-	return ProcSELinuxGetPropertyContext(client, dataKey);
+        return ProcSELinuxGetPropertyContext(client, dataKey);
     case X_SELinuxListProperties:
-	return ProcSELinuxListProperties(client);
+        return ProcSELinuxListProperties(client);
     case X_SELinuxSetSelectionCreateContext:
-	return ProcSELinuxSetCreateContext(client, CTX_SEL);
+        return ProcSELinuxSetCreateContext(client, CTX_SEL);
     case X_SELinuxGetSelectionCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_SEL);
+        return ProcSELinuxGetCreateContext(client, CTX_SEL);
     case X_SELinuxSetSelectionUseContext:
-	return ProcSELinuxSetCreateContext(client, USE_SEL);
+        return ProcSELinuxSetCreateContext(client, USE_SEL);
     case X_SELinuxGetSelectionUseContext:
-	return ProcSELinuxGetCreateContext(client, USE_SEL);
+        return ProcSELinuxGetCreateContext(client, USE_SEL);
     case X_SELinuxGetSelectionContext:
-	return ProcSELinuxGetSelectionContext(client, objectKey);
+        return ProcSELinuxGetSelectionContext(client, objectKey);
     case X_SELinuxGetSelectionDataContext:
-	return ProcSELinuxGetSelectionContext(client, dataKey);
+        return ProcSELinuxGetSelectionContext(client, dataKey);
     case X_SELinuxListSelections:
-	return ProcSELinuxListSelections(client);
+        return ProcSELinuxListSelections(client);
     case X_SELinuxGetClientContext:
-	return ProcSELinuxGetClientContext(client);
+        return ProcSELinuxGetClientContext(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
@@ -620,63 +621,62 @@ SProcSELinuxDispatch(ClientPtr client)
 
     switch (stuff->data) {
     case X_SELinuxQueryVersion:
-	return SProcSELinuxQueryVersion(client);
+        return SProcSELinuxQueryVersion(client);
     case X_SELinuxSetDeviceCreateContext:
-	return SProcSELinuxSetCreateContext(client, CTX_DEV);
+        return SProcSELinuxSetCreateContext(client, CTX_DEV);
     case X_SELinuxGetDeviceCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_DEV);
+        return ProcSELinuxGetCreateContext(client, CTX_DEV);
     case X_SELinuxSetDeviceContext:
-	return SProcSELinuxSetDeviceContext(client);
+        return SProcSELinuxSetDeviceContext(client);
     case X_SELinuxGetDeviceContext:
-	return SProcSELinuxGetDeviceContext(client);
+        return SProcSELinuxGetDeviceContext(client);
     case X_SELinuxSetDrawableCreateContext:
-	return SProcSELinuxSetCreateContext(client, CTX_WIN);
+        return SProcSELinuxSetCreateContext(client, CTX_WIN);
     case X_SELinuxGetDrawableCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_WIN);
+        return ProcSELinuxGetCreateContext(client, CTX_WIN);
     case X_SELinuxGetDrawableContext:
-	return SProcSELinuxGetDrawableContext(client);
+        return SProcSELinuxGetDrawableContext(client);
     case X_SELinuxSetPropertyCreateContext:
-	return SProcSELinuxSetCreateContext(client, CTX_PRP);
+        return SProcSELinuxSetCreateContext(client, CTX_PRP);
     case X_SELinuxGetPropertyCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_PRP);
+        return ProcSELinuxGetCreateContext(client, CTX_PRP);
     case X_SELinuxSetPropertyUseContext:
-	return SProcSELinuxSetCreateContext(client, USE_PRP);
+        return SProcSELinuxSetCreateContext(client, USE_PRP);
     case X_SELinuxGetPropertyUseContext:
-	return ProcSELinuxGetCreateContext(client, USE_PRP);
+        return ProcSELinuxGetCreateContext(client, USE_PRP);
     case X_SELinuxGetPropertyContext:
-	return SProcSELinuxGetPropertyContext(client, objectKey);
+        return SProcSELinuxGetPropertyContext(client, objectKey);
     case X_SELinuxGetPropertyDataContext:
-	return SProcSELinuxGetPropertyContext(client, dataKey);
+        return SProcSELinuxGetPropertyContext(client, dataKey);
     case X_SELinuxListProperties:
-	return SProcSELinuxListProperties(client);
+        return SProcSELinuxListProperties(client);
     case X_SELinuxSetSelectionCreateContext:
-	return SProcSELinuxSetCreateContext(client, CTX_SEL);
+        return SProcSELinuxSetCreateContext(client, CTX_SEL);
     case X_SELinuxGetSelectionCreateContext:
-	return ProcSELinuxGetCreateContext(client, CTX_SEL);
+        return ProcSELinuxGetCreateContext(client, CTX_SEL);
     case X_SELinuxSetSelectionUseContext:
-	return SProcSELinuxSetCreateContext(client, USE_SEL);
+        return SProcSELinuxSetCreateContext(client, USE_SEL);
     case X_SELinuxGetSelectionUseContext:
-	return ProcSELinuxGetCreateContext(client, USE_SEL);
+        return ProcSELinuxGetCreateContext(client, USE_SEL);
     case X_SELinuxGetSelectionContext:
-	return SProcSELinuxGetSelectionContext(client, objectKey);
+        return SProcSELinuxGetSelectionContext(client, objectKey);
     case X_SELinuxGetSelectionDataContext:
-	return SProcSELinuxGetSelectionContext(client, dataKey);
+        return SProcSELinuxGetSelectionContext(client, dataKey);
     case X_SELinuxListSelections:
-	return ProcSELinuxListSelections(client);
+        return ProcSELinuxListSelections(client);
     case X_SELinuxGetClientContext:
-	return SProcSELinuxGetClientContext(client);
+        return SProcSELinuxGetClientContext(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
-
 /*
  * Extension Setup / Teardown
  */
 
 static void
-SELinuxResetProc(ExtensionEntry *extEntry)
+SELinuxResetProc(ExtensionEntry * extEntry)
 {
     SELinuxFlaskReset();
     SELinuxLabelReset();
@@ -689,15 +689,15 @@ SELinuxExtensionInit(INITARGS)
 
     /* Check SELinux mode on system, configuration file, and boolean */
     if (!is_selinux_enabled()) {
-	LogMessage(X_INFO, "SELinux: Disabled on system\n");
+        LogMessage(X_INFO, "SELinux: Disabled on system\n");
-	return;
+        return;
     }
     if (selinuxEnforcingState == SELINUX_MODE_DISABLED) {
-	LogMessage(X_INFO, "SELinux: Disabled in configuration file\n");
+        LogMessage(X_INFO, "SELinux: Disabled in configuration file\n");
-	return;
+        return;
     }
     if (!security_get_boolean_active("xserver_object_manager")) {
-	LogMessage(X_INFO, "SELinux: Disabled by boolean\n");
+        LogMessage(X_INFO, "SELinux: Disabled by boolean\n");
         return;
     }
 
@@ -707,9 +707,9 @@ SELinuxExtensionInit(INITARGS)
 
     /* Add extension to server */
     extEntry = AddExtension(SELINUX_EXTENSION_NAME,
-			    SELinuxNumberEvents, SELinuxNumberErrors,
+                            SELinuxNumberEvents, SELinuxNumberErrors,
-			    ProcSELinuxDispatch, SProcSELinuxDispatch,
+                            ProcSELinuxDispatch, SProcSELinuxDispatch,
-			    SELinuxResetProc, StandardMinorOpcode);
+                            SELinuxResetProc, StandardMinorOpcode);
 
     AddExtensionAlias("Flask", extEntry);
 }

Xext/xselinux_label.c

@@ -43,8 +43,10 @@ static struct selabel_handle *label_hnd;
 
 /* Array of object classes indexed by resource type */
 SELinuxArrayRec arr_types;
+
 /* Array of event SIDs indexed by event type */
 SELinuxArrayRec arr_events;
+
 /* Array of property and selection SID structures */
 SELinuxArrayRec arr_atoms;
 
@@ -52,21 +54,21 @@ SELinuxArrayRec arr_atoms;
  * Dynamic array helpers
  */
 static void *
-SELinuxArrayGet(SELinuxArrayRec *rec, unsigned key)
+SELinuxArrayGet(SELinuxArrayRec * rec, unsigned key)
 {
     return (rec->size > key) ? rec->array[key] : 0;
 }
 
 static int
-SELinuxArraySet(SELinuxArrayRec *rec, unsigned key, void *val)
+SELinuxArraySet(SELinuxArrayRec * rec, unsigned key, void *val)
 {
     if (key >= rec->size) {
-	/* Need to increase size of array */
+        /* Need to increase size of array */
-	rec->array = realloc(rec->array, (key + 1) * sizeof(val));
+        rec->array = realloc(rec->array, (key + 1) * sizeof(val));
-	if (!rec->array)
+        if (!rec->array)
-	    return FALSE;
+            return FALSE;
-	memset(rec->array + rec->size, 0, (key - rec->size + 1) * sizeof(val));
+        memset(rec->array + rec->size, 0, (key - rec->size + 1) * sizeof(val));
-	rec->size = key + 1;
+        rec->size = key + 1;
     }
 
     rec->array[key] = val;
@@ -74,12 +76,13 @@ SELinuxArraySet(SELinuxArrayRec *rec, unsigned key, void *val)
 }
 
 static void
-SELinuxArrayFree(SELinuxArrayRec *rec, int free_elements)
+SELinuxArrayFree(SELinuxArrayRec * rec, int free_elements)
 {
     if (free_elements) {
-	unsigned i = rec->size;
+        unsigned i = rec->size;
-	while (i)
+
-	    free(rec->array[--i]);
+        while (i)
+            free(rec->array[--i]);
     }
 
     free(rec->array);
@@ -91,7 +94,7 @@ SELinuxArrayFree(SELinuxArrayRec *rec, int free_elements)
  * Looks up a name in the selection or property mappings
  */
 static int
-SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap)
+SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec * obj, int map, int polymap)
 {
     const char *name = NameForAtom(atom);
     security_context_t ctx;
@@ -101,19 +104,21 @@ SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap)
 
     /* Look in the mappings of names to contexts */
     if (selabel_lookup_raw(label_hnd, &ctx, name, map) == 0) {
-	obj->poly = 0;
+        obj->poly = 0;
-    } else if (errno != ENOENT) {
+    }
-	ErrorF("SELinux: a property label lookup failed!\n");
+    else if (errno != ENOENT) {
-	return BadValue;
+        ErrorF("SELinux: a property label lookup failed!\n");
-    } else if (selabel_lookup_raw(label_hnd, &ctx, name, polymap) < 0) {
+        return BadValue;
-	ErrorF("SELinux: a property label lookup failed!\n");
+    }
-	return BadValue;
+    else if (selabel_lookup_raw(label_hnd, &ctx, name, polymap) < 0) {
+        ErrorF("SELinux: a property label lookup failed!\n");
+        return BadValue;
     }
 
     /* Get a SID for context */
     if (avc_context_to_sid_raw(ctx, &obj->sid) < 0) {
-	ErrorF("SELinux: a context_to_SID_raw call failed!\n");
+        ErrorF("SELinux: a context_to_SID_raw call failed!\n");
-	rc = BadAlloc;
+        rc = BadAlloc;
     }
 
     freecon(ctx);
@@ -124,7 +129,7 @@ SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap)
  * Looks up the SID corresponding to the given property or selection atom
  */
 int
-SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn)
+SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec ** obj_rtn)
 {
     SELinuxAtomRec *rec;
     SELinuxObjectRec *obj;
@@ -132,30 +137,31 @@ SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn)
 
     rec = SELinuxArrayGet(&arr_atoms, atom);
     if (!rec) {
-	rec = calloc(1, sizeof(SELinuxAtomRec));
+        rec = calloc(1, sizeof(SELinuxAtomRec));
-	if (!rec || !SELinuxArraySet(&arr_atoms, atom, rec))
+        if (!rec || !SELinuxArraySet(&arr_atoms, atom, rec))
-	    return BadAlloc;
+            return BadAlloc;
     }
 
     if (prop) {
-	obj = &rec->prp;
+        obj = &rec->prp;
-	map = SELABEL_X_PROP;
+        map = SELABEL_X_PROP;
-	polymap = SELABEL_X_POLYPROP;
+        polymap = SELABEL_X_POLYPROP;
-    } else {
+    }
-	obj = &rec->sel;
+    else {
-	map = SELABEL_X_SELN;
+        obj = &rec->sel;
-	polymap = SELABEL_X_POLYSELN;
+        map = SELABEL_X_SELN;
+        polymap = SELABEL_X_POLYSELN;
     }
 
     if (!obj->sid) {
-	rc = SELinuxAtomToSIDLookup(atom, obj, map, polymap);
+        rc = SELinuxAtomToSIDLookup(atom, obj, map, polymap);
-	if (rc != Success)
+        if (rc != Success)
-	    goto out;
+            goto out;
     }
 
     *obj_rtn = obj;
     rc = Success;
-out:
+ out:
     return rc;
 }
 
@@ -163,8 +169,8 @@ out:
  * Looks up a SID for a selection/subject pair
  */
 int
-SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj,
+SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec * subj,
-		      security_id_t *sid_rtn, int *poly_rtn)
+                      security_id_t * sid_rtn, int *poly_rtn)
 {
     int rc;
     SELinuxObjectRec *obj;
@@ -173,26 +179,26 @@ SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj,
     /* Get the default context and polyinstantiation bit */
     rc = SELinuxAtomToSID(selection, 0, &obj);
     if (rc != Success)
-	return rc;
+        return rc;
 
     /* Check for an override context next */
     if (subj->sel_use_sid) {
-	tsid = subj->sel_use_sid;
+        tsid = subj->sel_use_sid;
-	goto out;
+        goto out;
     }
 
     tsid = obj->sid;
 
     /* Polyinstantiate if necessary to obtain the final SID */
     if (obj->poly && avc_compute_member(subj->sid, obj->sid,
-					SECCLASS_X_SELECTION, &tsid) < 0) {
+                                        SECCLASS_X_SELECTION, &tsid) < 0) {
-	ErrorF("SELinux: a compute_member call failed!\n");
+        ErrorF("SELinux: a compute_member call failed!\n");
-	return BadValue;
+        return BadValue;
     }
-out:
+ out:
     *sid_rtn = tsid;
     if (poly_rtn)
-	*poly_rtn = obj->poly;
+        *poly_rtn = obj->poly;
     return Success;
 }
 
@@ -200,8 +206,8 @@ out:
  * Looks up a SID for a property/subject pair
  */
 int
-SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj,
+SELinuxPropertyToSID(Atom property, SELinuxSubjectRec * subj,
-		     security_id_t *sid_rtn, int *poly_rtn)
+                     security_id_t * sid_rtn, int *poly_rtn)
 {
     int rc;
     SELinuxObjectRec *obj;
@@ -210,34 +216,33 @@ SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj,
     /* Get the default context and polyinstantiation bit */
     rc = SELinuxAtomToSID(property, 1, &obj);
     if (rc != Success)
-	return rc;
+        return rc;
 
     /* Check for an override context next */
     if (subj->prp_use_sid) {
-	tsid = subj->prp_use_sid;
+        tsid = subj->prp_use_sid;
-	goto out;
+        goto out;
     }
 
     /* Perform a transition */
-    if (avc_compute_create(subj->sid, obj->sid,
+    if (avc_compute_create(subj->sid, obj->sid, SECCLASS_X_PROPERTY, &tsid) < 0) {
-			   SECCLASS_X_PROPERTY, &tsid) < 0) {
+        ErrorF("SELinux: a compute_create call failed!\n");
-	ErrorF("SELinux: a compute_create call failed!\n");
+        return BadValue;
-	return BadValue;
     }
 
     /* Polyinstantiate if necessary to obtain the final SID */
     if (obj->poly) {
-	tsid2 = tsid;
+        tsid2 = tsid;
-	if (avc_compute_member(subj->sid, tsid2,
+        if (avc_compute_member(subj->sid, tsid2,
-			       SECCLASS_X_PROPERTY, &tsid) < 0) {
+                               SECCLASS_X_PROPERTY, &tsid) < 0) {
-	    ErrorF("SELinux: a compute_member call failed!\n");
+            ErrorF("SELinux: a compute_member call failed!\n");
-	    return BadValue;
+            return BadValue;
-	}
+        }
     }
-out:
+ out:
     *sid_rtn = tsid;
     if (poly_rtn)
-	*poly_rtn = obj->poly;
+        *poly_rtn = obj->poly;
     return Success;
 }
 
@@ -246,57 +251,58 @@ out:
  */
 int
 SELinuxEventToSID(unsigned type, security_id_t sid_of_window,
-		  SELinuxObjectRec *sid_return)
+                  SELinuxObjectRec * sid_return)
 {
     const char *name = LookupEventName(type);
     security_id_t sid;
     security_context_t ctx;
+
     type &= 127;
 
     sid = SELinuxArrayGet(&arr_events, type);
     if (!sid) {
-	/* Look in the mappings of event names to contexts */
+        /* Look in the mappings of event names to contexts */
-	if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EVENT) < 0) {
+        if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EVENT) < 0) {
-	    ErrorF("SELinux: an event label lookup failed!\n");
+            ErrorF("SELinux: an event label lookup failed!\n");
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	/* Get a SID for context */
+        /* Get a SID for context */
-	if (avc_context_to_sid_raw(ctx, &sid) < 0) {
+        if (avc_context_to_sid_raw(ctx, &sid) < 0) {
-	    ErrorF("SELinux: a context_to_SID_raw call failed!\n");
+            ErrorF("SELinux: a context_to_SID_raw call failed!\n");
-	    freecon(ctx);
+            freecon(ctx);
-	    return BadAlloc;
+            return BadAlloc;
-	}
+        }
-	freecon(ctx);
+        freecon(ctx);
-	/* Cache the SID value */
+        /* Cache the SID value */
-	if (!SELinuxArraySet(&arr_events, type, sid))
+        if (!SELinuxArraySet(&arr_events, type, sid))
-	    return BadAlloc;
+            return BadAlloc;
     }
 
     /* Perform a transition to obtain the final SID */
     if (avc_compute_create(sid_of_window, sid, SECCLASS_X_EVENT,
-			   &sid_return->sid) < 0) {
+                           &sid_return->sid) < 0) {
-	ErrorF("SELinux: a compute_create call failed!\n");
+        ErrorF("SELinux: a compute_create call failed!\n");
-	return BadValue;
+        return BadValue;
     }
 
     return Success;
 }
 
 int
-SELinuxExtensionToSID(const char *name, security_id_t *sid_rtn)
+SELinuxExtensionToSID(const char *name, security_id_t * sid_rtn)
 {
     security_context_t ctx;
 
     /* Look in the mappings of extension names to contexts */
     if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EXT) < 0) {
-	ErrorF("SELinux: a property label lookup failed!\n");
+        ErrorF("SELinux: a property label lookup failed!\n");
-	return BadValue;
+        return BadValue;
     }
     /* Get a SID for context */
     if (avc_context_to_sid_raw(ctx, sid_rtn) < 0) {
-	ErrorF("SELinux: a context_to_SID_raw call failed!\n");
+        ErrorF("SELinux: a context_to_SID_raw call failed!\n");
-	freecon(ctx);
+        freecon(ctx);
-	return BadAlloc;
+        return BadAlloc;
     }
     freecon(ctx);
     return Success;
@@ -312,32 +318,33 @@ SELinuxTypeToClass(RESTYPE type)
 
     tmp = SELinuxArrayGet(&arr_types, type & TypeMask);
     if (!tmp) {
-	unsigned long class = SECCLASS_X_RESOURCE;
+        unsigned long class = SECCLASS_X_RESOURCE;
 
-	if (type & RC_DRAWABLE)
+        if (type & RC_DRAWABLE)
-	    class = SECCLASS_X_DRAWABLE;
+            class = SECCLASS_X_DRAWABLE;
-	else if (type == RT_GC)
+        else if (type == RT_GC)
-	    class = SECCLASS_X_GC;
+            class = SECCLASS_X_GC;
-	else if (type == RT_FONT)
+        else if (type == RT_FONT)
-	    class = SECCLASS_X_FONT;
+            class = SECCLASS_X_FONT;
-	else if (type == RT_CURSOR)
+        else if (type == RT_CURSOR)
-	    class = SECCLASS_X_CURSOR;
+            class = SECCLASS_X_CURSOR;
-	else if (type == RT_COLORMAP)
+        else if (type == RT_COLORMAP)
-	    class = SECCLASS_X_COLORMAP;
+            class = SECCLASS_X_COLORMAP;
-	else {
+        else {
-	    /* Need to do a string lookup */
+            /* Need to do a string lookup */
-	    const char *str = LookupResourceName(type);
+            const char *str = LookupResourceName(type);
-	    if (!strcmp(str, "PICTURE"))
-		class = SECCLASS_X_DRAWABLE;
-	    else if (!strcmp(str, "GLYPHSET"))
-		class = SECCLASS_X_FONT;
-	}
 
-	tmp = (void *)class;
+            if (!strcmp(str, "PICTURE"))
-	SELinuxArraySet(&arr_types, type & TypeMask, tmp);
+                class = SECCLASS_X_DRAWABLE;
+            else if (!strcmp(str, "GLYPHSET"))
+                class = SECCLASS_X_FONT;
+        }
+
+        tmp = (void *) class;
+        SELinuxArraySet(&arr_types, type & TypeMask, tmp);
     }
 
-    return (security_class_t)(unsigned long)tmp;
+    return (security_class_t) (unsigned long) tmp;
 }
 
 security_context_t
@@ -346,7 +353,7 @@ SELinuxDefaultClientLabel(void)
     security_context_t ctx;
 
     if (selabel_lookup_raw(label_hnd, &ctx, "remote", SELABEL_X_CLIENT) < 0)
-	FatalError("SELinux: failed to look up remote-client context\n");
+        FatalError("SELinux: failed to look up remote-client context\n");
 
     return ctx;
 }
@@ -354,11 +361,11 @@ SELinuxDefaultClientLabel(void)
 void
 SELinuxLabelInit(void)
 {
-    struct selinux_opt selabel_option = { SELABEL_OPT_VALIDATE, (char *)1 };
+    struct selinux_opt selabel_option = { SELABEL_OPT_VALIDATE, (char *) 1 };
 
     label_hnd = selabel_open(SELABEL_CTX_X, &selabel_option, 1);
     if (!label_hnd)
-	FatalError("SELinux: Failed to open x_contexts mapping in policy\n");
+        FatalError("SELinux: Failed to open x_contexts mapping in policy\n");
 }
 
 void

Xext/xselinuxint.h

@@ -63,10 +63,13 @@ typedef struct {
  */
 
 extern DevPrivateKeyRec subjectKeyRec;
+
 #define subjectKey (&subjectKeyRec)
 extern DevPrivateKeyRec objectKeyRec;
+
 #define objectKey (&objectKeyRec)
 extern DevPrivateKeyRec dataKeyRec;
+
 #define dataKey (&dataKeyRec)
 
 /*
@@ -74,45 +77,45 @@ extern DevPrivateKeyRec dataKeyRec;
  */
 
 int
-SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn);
+ SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec ** obj_rtn);
 
 int
-SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj,
+
-		      security_id_t *sid_rtn, int *poly_rtn);
+SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec * subj,
+                      security_id_t * sid_rtn, int *poly_rtn);
 
 int
-SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj,
+
-		     security_id_t *sid_rtn, int *poly_rtn);
+SELinuxPropertyToSID(Atom property, SELinuxSubjectRec * subj,
+                     security_id_t * sid_rtn, int *poly_rtn);
 
 int
+
 SELinuxEventToSID(unsigned type, security_id_t sid_of_window,
-		  SELinuxObjectRec *sid_return);
+                  SELinuxObjectRec * sid_return);
 
 int
-SELinuxExtensionToSID(const char *name, security_id_t *sid_rtn);
+ SELinuxExtensionToSID(const char *name, security_id_t * sid_rtn);
 
-security_class_t
+security_class_t SELinuxTypeToClass(RESTYPE type);
-SELinuxTypeToClass(RESTYPE type);
 
-security_context_t
+security_context_t SELinuxDefaultClientLabel(void);
-SELinuxDefaultClientLabel(void);
 
 void
-SELinuxLabelInit(void);
+ SELinuxLabelInit(void);
 
 void
-SELinuxLabelReset(void);
+ SELinuxLabelReset(void);
 
 /*
  * Security module functions
  */
 
 void
-SELinuxFlaskInit(void);
+ SELinuxFlaskInit(void);
 
 void
-SELinuxFlaskReset(void);
+ SELinuxFlaskReset(void);
-
 
 /*
  * Private Flask definitions
@@ -139,416 +142,416 @@ SELinuxFlaskReset(void);
 #ifdef _XSELINUX_NEED_FLASK_MAP
 /* Mapping from DixAccess bits to Flask permissions */
 static struct security_class_mapping map[] = {
-    { "x_drawable",
+    {"x_drawable",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "list_property",	/* DixListPropAccess */
+      "list_property",          /* DixListPropAccess */
-          "get_property",	/* DixGetPropAccess */
+      "get_property",           /* DixGetPropAccess */
-          "set_property",	/* DixSetPropAccess */
+      "set_property",           /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "list_child",		/* DixListAccess */
+      "list_child",             /* DixListAccess */
-          "add_child",		/* DixAddAccess */
+      "add_child",              /* DixAddAccess */
-          "remove_child",	/* DixRemoveAccess */
+      "remove_child",           /* DixRemoveAccess */
-          "hide",		/* DixHideAccess */
+      "hide",                   /* DixHideAccess */
-          "show",		/* DixShowAccess */
+      "show",                   /* DixShowAccess */
-          "blend",		/* DixBlendAccess */
+      "blend",                  /* DixBlendAccess */
-          "override",		/* DixGrabAccess */
+      "override",               /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "send",		/* DixSendAccess */
+      "send",                   /* DixSendAccess */
-          "receive",		/* DixReceiveAccess */
+      "receive",                /* DixReceiveAccess */
-          "",			/* DixUseAccess */
+      "",                       /* DixUseAccess */
-          "manage",		/* DixManageAccess */
+      "manage",                 /* DixManageAccess */
-          NULL }},
+      NULL}},
-    { "x_screen",
+    {"x_screen",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "saver_getattr",	/* DixListPropAccess */
+      "saver_getattr",          /* DixListPropAccess */
-          "saver_setattr",	/* DixGetPropAccess */
+      "saver_setattr",          /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "hide_cursor",	/* DixHideAccess */
+      "hide_cursor",            /* DixHideAccess */
-          "show_cursor",	/* DixShowAccess */
+      "show_cursor",            /* DixShowAccess */
-          "saver_hide",		/* DixBlendAccess */
+      "saver_hide",             /* DixBlendAccess */
-          "saver_show",		/* DixGrabAccess */
+      "saver_show",             /* DixGrabAccess */
-          NULL }},
+      NULL}},
-    { "x_gc",
+    {"x_gc",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          NULL }},
+      NULL}},
-    { "x_font",
+    {"x_font",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "",			/* DixSetAttrAccess */
+      "",                       /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "add_glyph",		/* DixAddAccess */
+      "add_glyph",              /* DixAddAccess */
-          "remove_glyph",	/* DixRemoveAccess */
+      "remove_glyph",           /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          NULL }},
+      NULL}},
-    { "x_colormap",
+    {"x_colormap",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "",			/* DixSetAttrAccess */
+      "",                       /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "add_color",		/* DixAddAccess */
+      "add_color",              /* DixAddAccess */
-          "remove_color",	/* DixRemoveAccess */
+      "remove_color",           /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "install",		/* DixInstallAccess */
+      "install",                /* DixInstallAccess */
-          "uninstall",		/* DixUninstallAccess */
+      "uninstall",              /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          NULL }},
+      NULL}},
-    { "x_property",
+    {"x_property",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "write",		/* DixBlendAccess */
+      "write",                  /* DixBlendAccess */
-          NULL }},
+      NULL}},
-    { "x_selection",
+    {"x_selection",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "setattr",		/* DixCreateAccess */
+      "setattr",                /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          NULL }},
+      NULL}},
-    { "x_cursor",
+    {"x_cursor",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          NULL }},
+      NULL}},
-    { "x_client",
+    {"x_client",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "",			/* DixUseAccess */
+      "",                       /* DixUseAccess */
-          "manage",		/* DixManageAccess */
+      "manage",                 /* DixManageAccess */
-          NULL }},
+      NULL}},
-    { "x_pointer",
+    {"x_pointer",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "list_property",	/* DixListPropAccess */
+      "list_property",          /* DixListPropAccess */
-          "get_property",	/* DixGetPropAccess */
+      "get_property",           /* DixGetPropAccess */
-          "set_property",	/* DixSetPropAccess */
+      "set_property",           /* DixSetPropAccess */
-          "getfocus",		/* DixGetFocusAccess */
+      "getfocus",               /* DixGetFocusAccess */
-          "setfocus",		/* DixSetFocusAccess */
+      "setfocus",               /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "add",		/* DixAddAccess */
+      "add",                    /* DixAddAccess */
-          "remove",		/* DixRemoveAccess */
+      "remove",                 /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "grab",		/* DixGrabAccess */
+      "grab",                   /* DixGrabAccess */
-          "freeze",		/* DixFreezeAccess */
+      "freeze",                 /* DixFreezeAccess */
-          "force_cursor",	/* DixForceAccess */
+      "force_cursor",           /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          "manage",		/* DixManageAccess */
+      "manage",                 /* DixManageAccess */
-          "",			/* DixDebugAccess */
+      "",                       /* DixDebugAccess */
-          "bell",		/* DixBellAccess */
+      "bell",                   /* DixBellAccess */
-          NULL }},
+      NULL}},
-    { "x_keyboard",
+    {"x_keyboard",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "destroy",		/* DixDestroyAccess */
+      "destroy",                /* DixDestroyAccess */
-          "create",		/* DixCreateAccess */
+      "create",                 /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "list_property",	/* DixListPropAccess */
+      "list_property",          /* DixListPropAccess */
-          "get_property",	/* DixGetPropAccess */
+      "get_property",           /* DixGetPropAccess */
-          "set_property",	/* DixSetPropAccess */
+      "set_property",           /* DixSetPropAccess */
-          "getfocus",		/* DixGetFocusAccess */
+      "getfocus",               /* DixGetFocusAccess */
-          "setfocus",		/* DixSetFocusAccess */
+      "setfocus",               /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "add",		/* DixAddAccess */
+      "add",                    /* DixAddAccess */
-          "remove",		/* DixRemoveAccess */
+      "remove",                 /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "grab",		/* DixGrabAccess */
+      "grab",                   /* DixGrabAccess */
-          "freeze",		/* DixFreezeAccess */
+      "freeze",                 /* DixFreezeAccess */
-          "force_cursor",	/* DixForceAccess */
+      "force_cursor",           /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          "manage",		/* DixManageAccess */
+      "manage",                 /* DixManageAccess */
-          "",			/* DixDebugAccess */
+      "",                       /* DixDebugAccess */
-          "bell",		/* DixBellAccess */
+      "bell",                   /* DixBellAccess */
-          NULL }},
+      NULL}},
-    { "x_server",
+    {"x_server",
-        { "record",		/* DixReadAccess */
+     {"record",                 /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "getattr",		/* DixGetAttrAccess */
+      "getattr",                /* DixGetAttrAccess */
-          "setattr",		/* DixSetAttrAccess */
+      "setattr",                /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "grab",		/* DixGrabAccess */
+      "grab",                   /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "",			/* DixUseAccess */
+      "",                       /* DixUseAccess */
-          "manage",		/* DixManageAccess */
+      "manage",                 /* DixManageAccess */
-          "debug",		/* DixDebugAccess */
+      "debug",                  /* DixDebugAccess */
-          NULL }},
+      NULL}},
-    { "x_extension",
+    {"x_extension",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "query",		/* DixGetAttrAccess */
+      "query",                  /* DixGetAttrAccess */
-          "",			/* DixSetAttrAccess */
+      "",                       /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "",			/* DixSendAccess */
+      "",                       /* DixSendAccess */
-          "",			/* DixReceiveAccess */
+      "",                       /* DixReceiveAccess */
-          "use",		/* DixUseAccess */
+      "use",                    /* DixUseAccess */
-          NULL }},
+      NULL}},
-    { "x_event",
+    {"x_event",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "",			/* DixGetAttrAccess */
+      "",                       /* DixGetAttrAccess */
-          "",			/* DixSetAttrAccess */
+      "",                       /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "send",		/* DixSendAccess */
+      "send",                   /* DixSendAccess */
-          "receive",		/* DixReceiveAccess */
+      "receive",                /* DixReceiveAccess */
-          NULL }},
+      NULL}},
-    { "x_synthetic_event",
+    {"x_synthetic_event",
-        { "",			/* DixReadAccess */
+     {"",                       /* DixReadAccess */
-          "",			/* DixWriteAccess */
+      "",                       /* DixWriteAccess */
-          "",			/* DixDestroyAccess */
+      "",                       /* DixDestroyAccess */
-          "",			/* DixCreateAccess */
+      "",                       /* DixCreateAccess */
-          "",			/* DixGetAttrAccess */
+      "",                       /* DixGetAttrAccess */
-          "",			/* DixSetAttrAccess */
+      "",                       /* DixSetAttrAccess */
-          "",			/* DixListPropAccess */
+      "",                       /* DixListPropAccess */
-          "",			/* DixGetPropAccess */
+      "",                       /* DixGetPropAccess */
-          "",			/* DixSetPropAccess */
+      "",                       /* DixSetPropAccess */
-          "",			/* DixGetFocusAccess */
+      "",                       /* DixGetFocusAccess */
-          "",			/* DixSetFocusAccess */
+      "",                       /* DixSetFocusAccess */
-          "",			/* DixListAccess */
+      "",                       /* DixListAccess */
-          "",			/* DixAddAccess */
+      "",                       /* DixAddAccess */
-          "",			/* DixRemoveAccess */
+      "",                       /* DixRemoveAccess */
-          "",			/* DixHideAccess */
+      "",                       /* DixHideAccess */
-          "",			/* DixShowAccess */
+      "",                       /* DixShowAccess */
-          "",			/* DixBlendAccess */
+      "",                       /* DixBlendAccess */
-          "",			/* DixGrabAccess */
+      "",                       /* DixGrabAccess */
-          "",			/* DixFreezeAccess */
+      "",                       /* DixFreezeAccess */
-          "",			/* DixForceAccess */
+      "",                       /* DixForceAccess */
-          "",			/* DixInstallAccess */
+      "",                       /* DixInstallAccess */
-          "",			/* DixUninstallAccess */
+      "",                       /* DixUninstallAccess */
-          "send",		/* DixSendAccess */
+      "send",                   /* DixSendAccess */
-          "receive",		/* DixReceiveAccess */
+      "receive",                /* DixReceiveAccess */
-          NULL }},
+      NULL}},
-    { "x_resource",
+    {"x_resource",
-        { "read",		/* DixReadAccess */
+     {"read",                   /* DixReadAccess */
-          "write",		/* DixWriteAccess */
+      "write",                  /* DixWriteAccess */
-          "write",		/* DixDestroyAccess */
+      "write",                  /* DixDestroyAccess */
-          "write",		/* DixCreateAccess */
+      "write",                  /* DixCreateAccess */
-          "read",		/* DixGetAttrAccess */
+      "read",                   /* DixGetAttrAccess */
-          "write",		/* DixSetAttrAccess */
+      "write",                  /* DixSetAttrAccess */
-          "read",		/* DixListPropAccess */
+      "read",                   /* DixListPropAccess */
-          "read",		/* DixGetPropAccess */
+      "read",                   /* DixGetPropAccess */
-          "write",		/* DixSetPropAccess */
+      "write",                  /* DixSetPropAccess */
-          "read",		/* DixGetFocusAccess */
+      "read",                   /* DixGetFocusAccess */
-          "write",		/* DixSetFocusAccess */
+      "write",                  /* DixSetFocusAccess */
-          "read",		/* DixListAccess */
+      "read",                   /* DixListAccess */
-          "write",		/* DixAddAccess */
+      "write",                  /* DixAddAccess */
-          "write",		/* DixRemoveAccess */
+      "write",                  /* DixRemoveAccess */
-          "write",		/* DixHideAccess */
+      "write",                  /* DixHideAccess */
-          "read",		/* DixShowAccess */
+      "read",                   /* DixShowAccess */
-          "read",		/* DixBlendAccess */
+      "read",                   /* DixBlendAccess */
-          "write",		/* DixGrabAccess */
+      "write",                  /* DixGrabAccess */
-          "write",		/* DixFreezeAccess */
+      "write",                  /* DixFreezeAccess */
-          "write",		/* DixForceAccess */
+      "write",                  /* DixForceAccess */
-          "write",		/* DixInstallAccess */
+      "write",                  /* DixInstallAccess */
-          "write",		/* DixUninstallAccess */
+      "write",                  /* DixUninstallAccess */
-          "write",		/* DixSendAccess */
+      "write",                  /* DixSendAccess */
-          "read",		/* DixReceiveAccess */
+      "read",                   /* DixReceiveAccess */
-          "read",		/* DixUseAccess */
+      "read",                   /* DixUseAccess */
-          "write",		/* DixManageAccess */
+      "write",                  /* DixManageAccess */
-          "read",		/* DixDebugAccess */
+      "read",                   /* DixDebugAccess */
-          "write",		/* DixBellAccess */
+      "write",                  /* DixBellAccess */
-          NULL }},
+      NULL}},
-    { NULL }
+    {NULL}
 };
 
 /* x_resource "read" bits from the list above */
@@ -557,5 +560,5 @@ static struct security_class_mapping map[] = {
 			 DixShowAccess|DixBlendAccess|DixReceiveAccess| \
 			 DixUseAccess|DixDebugAccess)
 
-#endif /* _XSELINUX_NEED_FLASK_MAP */
+#endif                          /* _XSELINUX_NEED_FLASK_MAP */
-#endif /* _XSELINUXINT_H */
+#endif                          /* _XSELINUXINT_H */

Xext/xtest.c

@@ -62,7 +62,7 @@ extern int DeviceValuator;
 /* XTest events are sent during request processing and may be interruped by
  * a SIGIO. We need a separate event list to avoid events overwriting each
  * other's memory */
-static InternalEvent* xtest_evlist;
+static InternalEvent *xtest_evlist;
 
 /**
  * xtestpointer
@@ -81,11 +81,9 @@ DeviceIntPtr xtestpointer, xtestkeyboard;
 #include "panoramiXsrv.h"
 #endif
 
-static int XTestSwapFakeInput(
+static int XTestSwapFakeInput(ClientPtr /* client */ ,
-        ClientPtr /* client */,
+                              xReq *    /* req */
-        xReq * /* req */
+    );
-        );
-
 
 static int
 ProcXTestGetVersion(ClientPtr client)
@@ -102,7 +100,7 @@ ProcXTestGetVersion(ClientPtr client)
         swaps(&rep.sequenceNumber);
         swaps(&rep.minorVersion);
     }
-    WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXTestGetVersionReply), (char *) &rep);
     return Success;
 }
 
@@ -120,15 +118,18 @@ ProcXTestCompareCursor(ClientPtr client)
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
     if (rc != Success)
         return rc;
+
+    if (!ptr)
+        return BadAccess;
+
     if (stuff->cursor == None)
         pCursor = NullCursor;
     else if (stuff->cursor == XTestCurrentCursor)
         pCursor = GetSpriteCursor(ptr);
     else {
-        rc = dixLookupResourceByType((pointer *)&pCursor, stuff->cursor, RT_CURSOR,
+        rc = dixLookupResourceByType((pointer *) &pCursor, stuff->cursor,
-				     client, DixReadAccess);
+                                     RT_CURSOR, client, DixReadAccess);
-        if (rc != Success)
+        if (rc != Success) {
-        {
             client->errorValue = stuff->cursor;
             return rc;
         }
@@ -140,7 +141,7 @@ ProcXTestCompareCursor(ClientPtr client)
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
     }
-    WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
+    WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *) &rep);
     return Success;
 }
 
@@ -155,7 +156,7 @@ ProcXTestFakeInput(ClientPtr client)
     Bool extension = FALSE;
     deviceValuator *dv = NULL;
     ValuatorMask mask;
-    int valuators[MAX_VALUATORS] = {0};
+    int valuators[MAX_VALUATORS] = { 0 };
     int numValuators = 0;
     int firstValuator = 0;
     int nevents = 0;
@@ -169,18 +170,16 @@ ProcXTestFakeInput(ClientPtr client)
         return BadLength;
     nev /= sizeof(xEvent);
     UpdateCurrentTime();
-    ev = (xEvent *)&((xReq *)stuff)[1];
+    ev = (xEvent *) &((xReq *) stuff)[1];
     type = ev->u.u.type & 0177;
 
-    if (type >= EXTENSION_EVENT_BASE)
+    if (type >= EXTENSION_EVENT_BASE) {
-    {
         extension = TRUE;
 
         /* check device */
         rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client,
-                DixWriteAccess);
+                             DixWriteAccess);
-        if (rc != Success)
+        if (rc != Success) {
-        {
             client->errorValue = stuff->deviceid & 0177;
             return rc;
         }
@@ -188,144 +187,141 @@ ProcXTestFakeInput(ClientPtr client)
         /* check type */
         type -= DeviceValuator;
         switch (type) {
-            case XI_DeviceKeyPress:
+        case XI_DeviceKeyPress:
-            case XI_DeviceKeyRelease:
+        case XI_DeviceKeyRelease:
-                if (!dev->key)
+            if (!dev->key) {
-                {
-                    client->errorValue = ev->u.u.type;
-                    return BadValue;
-                }
-                break;
-            case XI_DeviceButtonPress:
-            case XI_DeviceButtonRelease:
-                if (!dev->button)
-                {
-                    client->errorValue = ev->u.u.type;
-                    return BadValue;
-                }
-                break;
-            case XI_DeviceMotionNotify:
-                if (!dev->valuator)
-                {
-                    client->errorValue = ev->u.u.type;
-                    return BadValue;
-                }
-                break;
-            case XI_ProximityIn:
-            case XI_ProximityOut:
-                if (!dev->proximity)
-                {
-                    client->errorValue = ev->u.u.type;
-                    return BadValue;
-                }
-                break;
-            default:
                 client->errorValue = ev->u.u.type;
                 return BadValue;
+            }
+            break;
+        case XI_DeviceButtonPress:
+        case XI_DeviceButtonRelease:
+            if (!dev->button) {
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+            }
+            break;
+        case XI_DeviceMotionNotify:
+            if (!dev->valuator) {
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+            }
+            break;
+        case XI_ProximityIn:
+        case XI_ProximityOut:
+            if (!dev->proximity) {
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+            }
+            break;
+        default:
+            client->errorValue = ev->u.u.type;
+            return BadValue;
         }
 
         /* check validity */
         if (nev == 1 && type == XI_DeviceMotionNotify)
-            return BadLength; /* DevMotion must be followed by DevValuator */
+            return BadLength;   /* DevMotion must be followed by DevValuator */
 
-        if (type == XI_DeviceMotionNotify)
+        if (type == XI_DeviceMotionNotify) {
-        {
+            firstValuator = ((deviceValuator *) (ev + 1))->first_valuator;
-            firstValuator = ((deviceValuator *)(ev+1))->first_valuator;
+            if (firstValuator > dev->valuator->numAxes) {
-            if (firstValuator > dev->valuator->numAxes)
-            {
                 client->errorValue = ev->u.u.type;
                 return BadValue;
             }
 
             if (ev->u.u.detail == xFalse)
                 flags |= POINTER_ABSOLUTE;
-        } else
+        }
-        {
+        else {
             firstValuator = 0;
             flags |= POINTER_ABSOLUTE;
         }
 
-        if (nev > 1 && !dev->valuator)
+        if (nev > 1 && !dev->valuator) {
-        {
             client->errorValue = dv->first_valuator;
             return BadValue;
         }
 
-
         /* check validity of valuator events */
         base = firstValuator;
-        for (n = 1; n < nev; n++)
+        for (n = 1; n < nev; n++) {
-        {
+            dv = (deviceValuator *) (ev + n);
-            dv = (deviceValuator *)(ev + n);
+            if (dv->type != DeviceValuator) {
-            if (dv->type != DeviceValuator)
-            {
                 client->errorValue = dv->type;
                 return BadValue;
             }
-            if (dv->first_valuator != base)
+            if (dv->first_valuator != base) {
-            {
                 client->errorValue = dv->first_valuator;
                 return BadValue;
             }
-            switch(dv->num_valuators)
+            switch (dv->num_valuators) {
-            {
+            case 6:
-                case 6: valuators[base + 5] = dv->valuator5;
+                valuators[base + 5] = dv->valuator5;
-                case 5: valuators[base + 4] = dv->valuator4;
+            case 5:
-                case 4: valuators[base + 3] = dv->valuator3;
+                valuators[base + 4] = dv->valuator4;
-                case 3: valuators[base + 2] = dv->valuator2;
+            case 4:
-                case 2: valuators[base + 1] = dv->valuator1;
+                valuators[base + 3] = dv->valuator3;
-                case 1: valuators[base] = dv->valuator0;
+            case 3:
-                        break;
+                valuators[base + 2] = dv->valuator2;
-                default:
+            case 2:
-                        client->errorValue = dv->num_valuators;
+                valuators[base + 1] = dv->valuator1;
-                        return BadValue;
+            case 1:
+                valuators[base] = dv->valuator0;
+                break;
+            default:
+                client->errorValue = dv->num_valuators;
+                return BadValue;
             }
 
             base += dv->num_valuators;
             numValuators += dv->num_valuators;
 
-            if (firstValuator + numValuators > dev->valuator->numAxes)
+            if (firstValuator + numValuators > dev->valuator->numAxes) {
-            {
                 client->errorValue = dv->num_valuators;
                 return BadValue;
             }
         }
         type = type - XI_DeviceKeyPress + KeyPress;
 
-    } else
+    }
-    {
+    else {
         if (nev != 1)
             return BadLength;
-        switch (type)
+        switch (type) {
-        {
+        case KeyPress:
-            case KeyPress:
+        case KeyRelease:
-            case KeyRelease:
+            dev = PickKeyboard(client);
-                dev = PickKeyboard(client);
+            break;
-                break;
+        case ButtonPress:
-            case ButtonPress:
+        case ButtonRelease:
-            case ButtonRelease:
+            dev = PickPointer(client);
-                dev = PickPointer(client);
+            break;
-                break;
+        case MotionNotify:
-            case MotionNotify:
+            dev = PickPointer(client);
-                dev = PickPointer(client);
+            valuators[0] = ev->u.keyButtonPointer.rootX;
-                valuators[0] = ev->u.keyButtonPointer.rootX;
+            valuators[1] = ev->u.keyButtonPointer.rootY;
-                valuators[1] = ev->u.keyButtonPointer.rootY;
+            numValuators = 2;
-                numValuators = 2;
+            firstValuator = 0;
-                firstValuator = 0;
+            if (ev->u.u.detail == xFalse)
-                if (ev->u.u.detail == xFalse)
+                flags = POINTER_ABSOLUTE | POINTER_SCREEN;
-                    flags = POINTER_ABSOLUTE | POINTER_SCREEN;
+            break;
-                break;
+        default:
-            default:
+            client->errorValue = ev->u.u.type;
-                client->errorValue = ev->u.u.type;
+            return BadValue;
-                return BadValue;
         }
 
+        /* Technically the protocol doesn't allow for BadAccess here but
+         * this can only happen when all MDs are disabled.  */
+        if (!dev)
+            return BadAccess;
+
         dev = GetXTestDevice(dev);
     }
 
+
     /* If the event has a time set, wait for it to pass */
-    if (ev->u.keyButtonPointer.time)
+    if (ev->u.keyButtonPointer.time) {
-    {
         TimeStamp activateTime;
         CARD32 ms;
 
@@ -339,92 +335,85 @@ ProcXTestFakeInput(ClientPtr client)
         /* see mbuf.c:QueueDisplayRequest (from the deprecated Multibuffer
          * extension) for code similar to this */
 
-        if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
+        if (!ClientSleepUntil(client, &activateTime, NULL, NULL)) {
-        {
             return BadAlloc;
         }
         /* swap the request back so we can simply re-execute it */
-        if (client->swapped)
+        if (client->swapped) {
-        {
+            (void) XTestSwapFakeInput(client, (xReq *) stuff);
-            (void) XTestSwapFakeInput(client, (xReq *)stuff);
             swaps(&stuff->length);
         }
-        ResetCurrentRequest (client);
+        ResetCurrentRequest(client);
         client->sequence--;
         return Success;
     }
 
-    switch (type)
+    switch (type) {
-    {
+    case KeyPress:
-        case KeyPress:
+    case KeyRelease:
-        case KeyRelease:
+        if (!dev->key)
-            if (!dev->key)
+            return BadDevice;
-                return BadDevice;
 
-            if (ev->u.u.detail < dev->key->xkbInfo->desc->min_key_code ||
+        if (ev->u.u.detail < dev->key->xkbInfo->desc->min_key_code ||
-                ev->u.u.detail > dev->key->xkbInfo->desc->max_key_code)
+            ev->u.u.detail > dev->key->xkbInfo->desc->max_key_code) {
-            {
+            client->errorValue = ev->u.u.detail;
-                client->errorValue = ev->u.u.detail;
+            return BadValue;
+        }
+
+        need_ptr_update = 0;
+        break;
+    case MotionNotify:
+        if (!dev->valuator)
+            return BadDevice;
+
+        if (!(extension || ev->u.keyButtonPointer.root == None)) {
+            rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root,
+                                 client, DixGetAttrAccess);
+            if (rc != Success)
+                return rc;
+            if (root->parent) {
+                client->errorValue = ev->u.keyButtonPointer.root;
                 return BadValue;
             }
+        }
+        if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse) {
+            client->errorValue = ev->u.u.detail;
+            return BadValue;
+        }
 
-            need_ptr_update = 0;
+        /* FIXME: Xinerama! */
-            break;
-        case MotionNotify:
-            if (!dev->valuator)
-                return BadDevice;
 
-            if (!(extension || ev->u.keyButtonPointer.root == None))
+        break;
-            {
+    case ButtonPress:
-                rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root,
+    case ButtonRelease:
-                                     client, DixGetAttrAccess);
+        if (!dev->button)
-                if (rc != Success)
+            return BadDevice;
-                    return rc;
-                if (root->parent)
-                {
-                    client->errorValue = ev->u.keyButtonPointer.root;
-                    return BadValue;
-                }
-            }
-            if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse)
-            {
-                client->errorValue = ev->u.u.detail;
-                return BadValue;
-            }
 
-            /* FIXME: Xinerama! */
+        if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons) {
-
+            client->errorValue = ev->u.u.detail;
-            break;
+            return BadValue;
-        case ButtonPress:
+        }
-        case ButtonRelease:
+        break;
-            if (!dev->button)
-                return BadDevice;
-
-            if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
-            {
-                client->errorValue = ev->u.u.detail;
-                return BadValue;
-            }
-            break;
     }
     if (screenIsSaved == SCREEN_SAVER_ON)
         dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
 
-    switch(type) {
+    switch (type) {
-        case MotionNotify:
+    case MotionNotify:
-            valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
+        valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
-            nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask);
+        nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask);
-            break;
+        break;
-        case ButtonPress:
+    case ButtonPress:
-        case ButtonRelease:
+    case ButtonRelease:
-            valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
+        valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
-            nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail,
+        nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail,
-                                       flags, &mask);
+                                   flags, &mask);
-            break;
+        break;
-        case KeyPress:
+    case KeyPress:
-        case KeyRelease:
+    case KeyRelease:
-            nevents = GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail, NULL);
+        nevents =
-            break;
+            GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail, NULL);
+        break;
     }
 
     for (i = 0; i < nevents; i++)
@@ -441,8 +430,7 @@ ProcXTestGrabControl(ClientPtr client)
     REQUEST(xXTestGrabControlReq);
 
     REQUEST_SIZE_MATCH(xXTestGrabControlReq);
-    if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse))
+    if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse)) {
-    {
         client->errorValue = stuff->impervious;
         return BadValue;
     }
@@ -454,21 +442,20 @@ ProcXTestGrabControl(ClientPtr client)
 }
 
 static int
-ProcXTestDispatch (ClientPtr client)
+ProcXTestDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
+    case X_XTestGetVersion:
-        case X_XTestGetVersion:
+        return ProcXTestGetVersion(client);
-            return ProcXTestGetVersion(client);
+    case X_XTestCompareCursor:
-        case X_XTestCompareCursor:
+        return ProcXTestCompareCursor(client);
-            return ProcXTestCompareCursor(client);
+    case X_XTestFakeInput:
-        case X_XTestFakeInput:
+        return ProcXTestFakeInput(client);
-            return ProcXTestFakeInput(client);
+    case X_XTestGrabControl:
-        case X_XTestGrabControl:
+        return ProcXTestGrabControl(client);
-            return ProcXTestGrabControl(client);
+    default:
-        default:
+        return BadRequest;
-            return BadRequest;
     }
 }
 
@@ -496,7 +483,7 @@ SProcXTestCompareCursor(ClientPtr client)
 }
 
 static int
-XTestSwapFakeInput(ClientPtr client, xReq *req)
+XTestSwapFakeInput(ClientPtr client, xReq * req)
 {
     int nev;
     xEvent *ev;
@@ -504,16 +491,15 @@ XTestSwapFakeInput(ClientPtr client, xReq *req)
     EventSwapPtr proc;
 
     nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
-    for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
+    for (ev = (xEvent *) &req[1]; --nev >= 0; ev++) {
-    {
         /* Swap event */
         proc = EventSwapVector[ev->u.u.type & 0177];
         /* no swapping proc; invalid event type? */
-        if (!proc ||  proc ==  NotImplemented) {
+        if (!proc || proc == NotImplemented) {
             client->errorValue = ev->u.u.type;
             return BadValue;
         }
-        (*proc)(ev, &sev);
+        (*proc) (ev, &sev);
         *ev = sev;
     }
     return Success;
@@ -522,7 +508,8 @@ XTestSwapFakeInput(ClientPtr client, xReq *req)
 static int
 SProcXTestFakeInput(ClientPtr client)
 {
-	int n;
+    int n;
+
     REQUEST(xReq);
 
     swaps(&stuff->length);
@@ -543,21 +530,20 @@ SProcXTestGrabControl(ClientPtr client)
 }
 
 static int
-SProcXTestDispatch (ClientPtr client)
+SProcXTestDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
+    switch (stuff->data) {
-    {
+    case X_XTestGetVersion:
-        case X_XTestGetVersion:
+        return SProcXTestGetVersion(client);
-            return SProcXTestGetVersion(client);
+    case X_XTestCompareCursor:
-        case X_XTestCompareCursor:
+        return SProcXTestCompareCursor(client);
-            return SProcXTestCompareCursor(client);
+    case X_XTestFakeInput:
-        case X_XTestFakeInput:
+        return SProcXTestFakeInput(client);
-            return SProcXTestFakeInput(client);
+    case X_XTestGrabControl:
-        case X_XTestGrabControl:
+        return SProcXTestGrabControl(client);
-            return SProcXTestGrabControl(client);
+    default:
-        default:
+        return BadRequest;
-            return BadRequest;
     }
 }
 
@@ -565,21 +551,22 @@ SProcXTestDispatch (ClientPtr client)
  * Allocate an virtual slave device for xtest events, this
  * is a slave device to inputInfo master devices
  */
-void InitXTestDevices(void)
+void
+InitXTestDevices(void)
 {
-    if(AllocXTestDevice(serverClient, "Virtual core",
+    if (AllocXTestDevice(serverClient, "Virtual core",
-                       &xtestpointer, &xtestkeyboard,
+                         &xtestpointer, &xtestkeyboard,
-                       inputInfo.pointer, inputInfo.keyboard) != Success)
+                         inputInfo.pointer, inputInfo.keyboard) != Success)
-        FatalError("Failed to allocate XTest devices");
+         FatalError("Failed to allocate XTest devices");
 
     if (ActivateDevice(xtestpointer, TRUE) != Success ||
         ActivateDevice(xtestkeyboard, TRUE) != Success)
         FatalError("Failed to activate XTest core devices.");
-    if (!EnableDevice(xtestpointer, TRUE) ||
+    if (!EnableDevice(xtestpointer, TRUE) || !EnableDevice(xtestkeyboard, TRUE))
-        !EnableDevice(xtestkeyboard, TRUE))
         FatalError("Failed to enable XTest core devices.");
 
     AttachDevice(NULL, xtestpointer, inputInfo.pointer);
+
     AttachDevice(NULL, xtestkeyboard, inputInfo.keyboard);
 }
 
@@ -588,7 +575,7 @@ void InitXTestDevices(void)
  */
 static int
 DeviceSetXTestProperty(DeviceIntPtr dev, Atom property,
-                      XIPropertyValuePtr prop, BOOL checkonly)
+                       XIPropertyValuePtr prop, BOOL checkonly)
 {
     if (property == XIGetKnownProperty(XI_PROP_XTEST_DEVICE))
         return BadAccess;
@@ -603,35 +590,42 @@ DeviceSetXTestProperty(DeviceIntPtr dev, Atom property,
  * This only creates the pair, Activate/Enable Device
  * still need to be called.
  */
-int AllocXTestDevice (ClientPtr client, const char* name,
+int
-                     DeviceIntPtr* ptr, DeviceIntPtr* keybd,
+AllocXTestDevice(ClientPtr client, const char *name,
-                     DeviceIntPtr master_ptr, DeviceIntPtr master_keybd)
+                 DeviceIntPtr *ptr, DeviceIntPtr *keybd,
+                 DeviceIntPtr master_ptr, DeviceIntPtr master_keybd)
 {
     int retval;
     char *xtestname;
     char dummy = 1;
 
     if (asprintf(&xtestname, "%s XTEST", name) == -1)
-	return BadAlloc;
+        return BadAlloc;
 
-    retval = AllocDevicePair( client, xtestname, ptr, keybd, CorePointerProc, CoreKeyboardProc, FALSE);
+    retval =
-    if ( retval == Success ){
+        AllocDevicePair(client, xtestname, ptr, keybd, CorePointerProc,
-	(*ptr)->xtest_master_id = master_ptr->id;
+                        CoreKeyboardProc, FALSE);
-	(*keybd)->xtest_master_id = master_keybd->id;
+    if (retval == Success) {
+        (*ptr)->xtest_master_id = master_ptr->id;
+        (*keybd)->xtest_master_id = master_keybd->id;
 
         XIChangeDeviceProperty(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
-                XA_INTEGER, 8, PropModeReplace, 1, &dummy,
+                               XA_INTEGER, 8, PropModeReplace, 1, &dummy,
-                FALSE);
+                               FALSE);
-        XISetDevicePropertyDeletable(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE);
+        XISetDevicePropertyDeletable(*ptr,
+                                     XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
+                                     FALSE);
         XIRegisterPropertyHandler(*ptr, DeviceSetXTestProperty, NULL, NULL);
         XIChangeDeviceProperty(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
-                XA_INTEGER, 8, PropModeReplace, 1, &dummy,
+                               XA_INTEGER, 8, PropModeReplace, 1, &dummy,
-                FALSE);
+                               FALSE);
-        XISetDevicePropertyDeletable(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE);
+        XISetDevicePropertyDeletable(*keybd,
+                                     XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
+                                     FALSE);
         XIRegisterPropertyHandler(*keybd, DeviceSetXTestProperty, NULL, NULL);
     }
 
-    free( xtestname );
+    free(xtestname);
 
     return retval;
 }
@@ -651,7 +645,7 @@ IsXTestDevice(DeviceIntPtr dev, DeviceIntPtr master)
     /* deviceid 0 is reserved for XIAllDevices, non-zero mid means XTest
      * device */
     if (master)
-	return dev->xtest_master_id == master->id;
+        return dev->xtest_master_id == master->id;
 
     return dev->xtest_master_id != 0;
 }
@@ -664,8 +658,7 @@ GetXTestDevice(DeviceIntPtr master)
 {
     DeviceIntPtr it;
 
-    for (it = inputInfo.devices; it; it = it->next)
+    for (it = inputInfo.devices; it; it = it->next) {
-    {
         if (IsXTestDevice(it, master))
             return it;
     }
@@ -675,7 +668,7 @@ GetXTestDevice(DeviceIntPtr master)
 }
 
 static void
-XTestExtensionTearDown(ExtensionEntry *e)
+XTestExtensionTearDown(ExtensionEntry * e)
 {
     FreeEventList(xtest_evlist, GetMaximumEventsNum());
     xtest_evlist = NULL;
@@ -685,8 +678,8 @@ void
 XTestExtensionInit(INITARGS)
 {
     AddExtension(XTestExtensionName, 0, 0,
-            ProcXTestDispatch, SProcXTestDispatch,
+                 ProcXTestDispatch, SProcXTestDispatch,
-            XTestExtensionTearDown, StandardMinorOpcode);
+                 XTestExtensionTearDown, StandardMinorOpcode);
 
     xtest_evlist = InitEventList(GetMaximumEventsNum());
 }

Xext/xvdix.h

@@ -73,132 +73,131 @@ extern _X_EXPORT RESTYPE XvRTPortNotify;
 #endif
 
 typedef struct {
-  int numerator;
+    int numerator;
-  int denominator;
+    int denominator;
 } XvRationalRec, *XvRationalPtr;
 
 typedef struct {
-  char depth;
+    char depth;
-  unsigned long visual;
+    unsigned long visual;
 } XvFormatRec, *XvFormatPtr;
 
 typedef struct {
-  unsigned long id;
+    unsigned long id;
-  ClientPtr client;
+    ClientPtr client;
 } XvGrabRec, *XvGrabPtr;
 
 typedef struct _XvVideoNotifyRec {
-  struct _XvVideoNotifyRec *next;
+    struct _XvVideoNotifyRec *next;
-  ClientPtr client;
+    ClientPtr client;
-  unsigned long id;
+    unsigned long id;
-  unsigned long mask;
+    unsigned long mask;
 } XvVideoNotifyRec, *XvVideoNotifyPtr;
 
 typedef struct _XvPortNotifyRec {
-  struct _XvPortNotifyRec *next;
+    struct _XvPortNotifyRec *next;
-  ClientPtr client;
+    ClientPtr client;
-  unsigned long id;
+    unsigned long id;
 } XvPortNotifyRec, *XvPortNotifyPtr;
 
 typedef struct {
-  int id;
+    int id;
-  ScreenPtr pScreen;
+    ScreenPtr pScreen;
-  char *name;
+    char *name;
-  unsigned short width, height;
+    unsigned short width, height;
-  XvRationalRec rate;
+    XvRationalRec rate;
 } XvEncodingRec, *XvEncodingPtr;
 
 typedef struct _XvAttributeRec {
-  int flags;
+    int flags;
-  int min_value;
+    int min_value;
-  int max_value;
+    int max_value;
-  char *name;
+    char *name;
 } XvAttributeRec, *XvAttributePtr;
 
 typedef struct {
-  int id;
+    int id;
-  int type;
+    int type;
-  int byte_order;
+    int byte_order;
-  char guid[16];
+    char guid[16];
-  int bits_per_pixel;
+    int bits_per_pixel;
-  int format;
+    int format;
-  int num_planes;
+    int num_planes;
 
-  /* for RGB formats only */
+    /* for RGB formats only */
-  int depth;
+    int depth;
-  unsigned int red_mask;       
+    unsigned int red_mask;
-  unsigned int green_mask;   
+    unsigned int green_mask;
-  unsigned int blue_mask;   
+    unsigned int blue_mask;
 
-  /* for YUV formats only */
+    /* for YUV formats only */
-  unsigned int y_sample_bits;
+    unsigned int y_sample_bits;
-  unsigned int u_sample_bits;
+    unsigned int u_sample_bits;
-  unsigned int v_sample_bits;   
+    unsigned int v_sample_bits;
-  unsigned int horz_y_period;
+    unsigned int horz_y_period;
-  unsigned int horz_u_period;
+    unsigned int horz_u_period;
-  unsigned int horz_v_period;
+    unsigned int horz_v_period;
-  unsigned int vert_y_period;
+    unsigned int vert_y_period;
-  unsigned int vert_u_period;
+    unsigned int vert_u_period;
-  unsigned int vert_v_period;
+    unsigned int vert_v_period;
-  char component_order[32];
+    char component_order[32];
-  int scanline_order;
+    int scanline_order;
 } XvImageRec, *XvImagePtr;
 
 typedef struct {
-  unsigned long base_id;
+    unsigned long base_id;
-  unsigned char type; 
+    unsigned char type;
-  char *name;
+    char *name;
-  int nEncodings;
+    int nEncodings;
-  XvEncodingPtr pEncodings;  
+    XvEncodingPtr pEncodings;
-  int nFormats;
+    int nFormats;
-  XvFormatPtr pFormats; 
+    XvFormatPtr pFormats;
-  int nAttributes;
+    int nAttributes;
-  XvAttributePtr pAttributes;
+    XvAttributePtr pAttributes;
-  int nImages;
+    int nImages;
-  XvImagePtr pImages;
+    XvImagePtr pImages;
-  int nPorts;
+    int nPorts;
-  struct _XvPortRec *pPorts;
+    struct _XvPortRec *pPorts;
-  ScreenPtr pScreen; 
+    ScreenPtr pScreen;
-  int (* ddAllocatePort)(unsigned long, struct _XvPortRec*, 
+    int (*ddAllocatePort) (unsigned long, struct _XvPortRec *,
-				struct _XvPortRec**);
+                           struct _XvPortRec **);
-  int (* ddFreePort)(struct _XvPortRec*);
+    int (*ddFreePort) (struct _XvPortRec *);
-  int (* ddPutVideo)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr,
+    int (*ddPutVideo) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                       INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16); 
+                       INT16, INT16, CARD16, CARD16);
-  int (* ddPutStill)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr,
+    int (*ddPutStill) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                       INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                       INT16, INT16, CARD16, CARD16);
-  int (* ddGetVideo)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr,
+    int (*ddGetVideo) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                       INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                       INT16, INT16, CARD16, CARD16);
-  int (* ddGetStill)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr,
+    int (*ddGetStill) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                       INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                       INT16, INT16, CARD16, CARD16);
-  int (* ddStopVideo)(ClientPtr, struct _XvPortRec*, DrawablePtr);
+    int (*ddStopVideo) (ClientPtr, struct _XvPortRec *, DrawablePtr);
-  int (* ddSetPortAttribute)(ClientPtr, struct _XvPortRec*, Atom, INT32);
+    int (*ddSetPortAttribute) (ClientPtr, struct _XvPortRec *, Atom, INT32);
-  int (* ddGetPortAttribute)(ClientPtr, struct _XvPortRec*, Atom, INT32*);
+    int (*ddGetPortAttribute) (ClientPtr, struct _XvPortRec *, Atom, INT32 *);
-  int (* ddQueryBestSize)(ClientPtr, struct _XvPortRec*, CARD8,
+    int (*ddQueryBestSize) (ClientPtr, struct _XvPortRec *, CARD8,
-   				CARD16, CARD16,CARD16, CARD16, 
+                            CARD16, CARD16, CARD16, CARD16,
-				unsigned int*, unsigned int*);
+                            unsigned int *, unsigned int *);
-  int (* ddPutImage)(ClientPtr, DrawablePtr, struct _XvPortRec*, GCPtr,
+    int (*ddPutImage) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                       INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16,
+                       INT16, INT16, CARD16, CARD16,
-				XvImagePtr, unsigned char*, Bool,
+                       XvImagePtr, unsigned char *, Bool, CARD16, CARD16);
-				CARD16, CARD16);
+    int (*ddQueryImageAttributes) (ClientPtr, struct _XvPortRec *, XvImagePtr,
-  int (* ddQueryImageAttributes)(ClientPtr, struct _XvPortRec*, XvImagePtr, 
+                                   CARD16 *, CARD16 *, int *, int *);
-				CARD16*, CARD16*, int*, int*);
+    DevUnion devPriv;
-  DevUnion devPriv;
 } XvAdaptorRec, *XvAdaptorPtr;
 
 typedef struct _XvPortRec {
-  unsigned long id;
+    unsigned long id;
-  XvAdaptorPtr pAdaptor;
+    XvAdaptorPtr pAdaptor;
-  XvPortNotifyPtr pNotify;
+    XvPortNotifyPtr pNotify;
-  DrawablePtr pDraw;
+    DrawablePtr pDraw;
-  ClientPtr client;
+    ClientPtr client;
-  XvGrabRec grab;
+    XvGrabRec grab;
-  TimeStamp time;
+    TimeStamp time;
-  DevUnion devPriv;
+    DevUnion devPriv;
 } XvPortRec, *XvPortPtr;
 
 #define VALIDATE_XV_PORT(portID, pPort, mode)\
@@ -210,15 +209,15 @@ typedef struct _XvPortRec {
     }
 
 typedef struct {
-  int version, revision;
+    int version, revision;
-  int nAdaptors;
+    int nAdaptors;
-  XvAdaptorPtr pAdaptors;
+    XvAdaptorPtr pAdaptors;
-  DestroyWindowProcPtr DestroyWindow;
+    DestroyWindowProcPtr DestroyWindow;
-  DestroyPixmapProcPtr DestroyPixmap;
+    DestroyPixmapProcPtr DestroyPixmap;
-  CloseScreenProcPtr CloseScreen;
+    CloseScreenProcPtr CloseScreen;
-  Bool (* ddCloseScreen)(int, ScreenPtr);
+    Bool (*ddCloseScreen) (int, ScreenPtr);
-  int (* ddQueryAdaptors)(ScreenPtr, XvAdaptorPtr*, int*);
+    int (*ddQueryAdaptors) (ScreenPtr, XvAdaptorPtr *, int *);
-  DevUnion devPriv;
+    DevUnion devPriv;
 } XvScreenRec, *XvScreenPtr;
 
 #define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = ((XvScreenPtr) \
@@ -244,32 +243,31 @@ extern _X_EXPORT int XvdiSendPortNotify(XvPortPtr, Atom, INT32);
 extern _X_EXPORT int XvdiVideoStopped(XvPortPtr, int);
 
 extern _X_EXPORT int XvdiPutVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                                  INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                                  INT16, INT16, CARD16, CARD16);
 extern _X_EXPORT int XvdiPutStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                                  INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                                  INT16, INT16, CARD16, CARD16);
 extern _X_EXPORT int XvdiGetVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                                  INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                                  INT16, INT16, CARD16, CARD16);
 extern _X_EXPORT int XvdiGetStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                                  INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16);
+                                  INT16, INT16, CARD16, CARD16);
 extern _X_EXPORT int XvdiPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
-   				INT16, INT16, CARD16, CARD16, 
+                                  INT16, INT16, CARD16, CARD16,
-				INT16, INT16, CARD16, CARD16,
+                                  INT16, INT16, CARD16, CARD16,
-				XvImagePtr, unsigned char*, Bool,
+                                  XvImagePtr, unsigned char *, Bool,
-				CARD16, CARD16);
+                                  CARD16, CARD16);
 extern _X_EXPORT int XvdiSelectVideoNotify(ClientPtr, DrawablePtr, BOOL);
 extern _X_EXPORT int XvdiSelectPortNotify(ClientPtr, XvPortPtr, BOOL);
 extern _X_EXPORT int XvdiSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32);
-extern _X_EXPORT int XvdiGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32*);
+extern _X_EXPORT int XvdiGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32 *);
 extern _X_EXPORT int XvdiStopVideo(ClientPtr, XvPortPtr, DrawablePtr);
 extern _X_EXPORT int XvdiPreemptVideo(ClientPtr, XvPortPtr, DrawablePtr);
 extern _X_EXPORT int XvdiMatchPort(XvPortPtr, DrawablePtr);
 extern _X_EXPORT int XvdiGrabPort(ClientPtr, XvPortPtr, Time, int *);
-extern _X_EXPORT int XvdiUngrabPort( ClientPtr, XvPortPtr, Time);
+extern _X_EXPORT int XvdiUngrabPort(ClientPtr, XvPortPtr, Time);
-#endif /* XorgLoader */
+#endif                          /* XorgLoader */
-
-#endif /* XVDIX_H */
 
+#endif                          /* XVDIX_H */

Xext/xvmc.c

@@ -26,14 +26,13 @@
 #include <sys/ipc.h>
 #include <sys/types.h>
 #include <sys/shm.h>
-#endif /* HAS_XVMCSHM */
+#endif                          /* HAS_XVMCSHM */
-   
-
 
 #define DR_CLIENT_DRIVER_NAME_SIZE 48
 #define DR_BUSID_SIZE 48
 
 static DevPrivateKeyRec XvMCScreenKeyRec;
+
 #define XvMCScreenKey (&XvMCScreenKeyRec)
 static Bool XvMCInUse;
 
@@ -47,71 +46,71 @@ static RESTYPE XvMCRTSurface;
 static RESTYPE XvMCRTSubpicture;
 
 typedef struct {
-   int num_adaptors;
+    int num_adaptors;
-   XvMCAdaptorPtr adaptors;
+    XvMCAdaptorPtr adaptors;
-   CloseScreenProcPtr	CloseScreen;
+    CloseScreenProcPtr CloseScreen;
-   char clientDriverName[DR_CLIENT_DRIVER_NAME_SIZE];
+    char clientDriverName[DR_CLIENT_DRIVER_NAME_SIZE];
-   char busID[DR_BUSID_SIZE];
+    char busID[DR_BUSID_SIZE];
-   int major;
+    int major;
-   int minor;
+    int minor;
-   int patchLevel;
+    int patchLevel;
 } XvMCScreenRec, *XvMCScreenPtr;
 
 #define XVMC_GET_PRIVATE(pScreen) \
     (XvMCScreenPtr)(dixLookupPrivate(&(pScreen)->devPrivates, XvMCScreenKey))
 
-
 static int
 XvMCDestroyContextRes(pointer data, XID id)
 {
-   XvMCContextPtr pContext = (XvMCContextPtr)data;
+    XvMCContextPtr pContext = (XvMCContextPtr) data;
 
-   pContext->refcnt--;
+    pContext->refcnt--;
 
-   if(!pContext->refcnt) {
+    if (!pContext->refcnt) {
-  	 XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
+        XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
-	(*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext)(pContext);
-	free(pContext);
-   }	   
 
-   return Success;
+        (*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext) (pContext);
+        free(pContext);
+    }
+
+    return Success;
 }
 
 static int
 XvMCDestroySurfaceRes(pointer data, XID id)
 {
-   XvMCSurfacePtr pSurface = (XvMCSurfacePtr)data;
+    XvMCSurfacePtr pSurface = (XvMCSurfacePtr) data;
-   XvMCContextPtr pContext = pSurface->context;
+    XvMCContextPtr pContext = pSurface->context;
-   XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
+    XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
-   (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface)(pSurface); 
+    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface) (pSurface);
-   free(pSurface);
+    free(pSurface);
 
-   XvMCDestroyContextRes((pointer)pContext, pContext->context_id);
+    XvMCDestroyContextRes((pointer) pContext, pContext->context_id);
 
-   return Success;
+    return Success;
 }
 
-
 static int
 XvMCDestroySubpictureRes(pointer data, XID id)
 {
-   XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr)data;
+    XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr) data;
-   XvMCContextPtr pContext = pSubpict->context;
+    XvMCContextPtr pContext = pSubpict->context;
-   XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
+    XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
-   (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture)(pSubpict); 
+    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture) (pSubpict);
-   free(pSubpict);
+    free(pSubpict);
 
-   XvMCDestroyContextRes((pointer)pContext, pContext->context_id);
+    XvMCDestroyContextRes((pointer) pContext, pContext->context_id);
 
-   return Success;
+    return Success;
 }
 
 static int
 ProcXvMCQueryVersion(ClientPtr client)
 {
     xvmcQueryVersionReply rep;
+
     /* REQUEST(xvmcQueryVersionReq); */
     REQUEST_SIZE_MATCH(xvmcQueryVersionReq);
     rep.type = X_Reply;
@@ -119,11 +118,10 @@ ProcXvMCQueryVersion(ClientPtr client)
     rep.length = 0;
     rep.major = SERVER_XVMC_MAJOR_VERSION;
     rep.minor = SERVER_XVMC_MINOR_VERSION;
-    WriteToClient(client, sizeof(xvmcQueryVersionReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcQueryVersionReply), (char *) &rep);
     return Success;
 }
 
-
 static int
 ProcXvMCListSurfaceTypes(ClientPtr client)
 {
@@ -134,21 +132,23 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
     xvmcSurfaceInfo info;
     XvMCAdaptorPtr adaptor = NULL;
     XvMCSurfaceInfoPtr surface;
+
     REQUEST(xvmcListSurfaceTypesReq);
     REQUEST_SIZE_MATCH(xvmcListSurfaceTypesReq);
 
     VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
 
-    if(XvMCInUse) { /* any adaptors at all */
+    if (XvMCInUse) {            /* any adaptors at all */
-       ScreenPtr pScreen = pPort->pAdaptor->pScreen;
+        ScreenPtr pScreen = pPort->pAdaptor->pScreen;
-       if((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) {  /* any this screen */
+
-          for(i = 0; i < pScreenPriv->num_adaptors; i++) {
+        if ((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) {        /* any this screen */
-             if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
+            for (i = 0; i < pScreenPriv->num_adaptors; i++) {
-               adaptor = &(pScreenPriv->adaptors[i]);
+                if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
-               break;
+                    adaptor = &(pScreenPriv->adaptors[i]);
-             }
+                    break;
-          }
+                }
-       }
+            }
+        }
     }
 
     rep.type = X_Reply;
@@ -156,19 +156,19 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
     rep.num = (adaptor) ? adaptor->num_surfaces : 0;
     rep.length = bytes_to_int32(rep.num * sizeof(xvmcSurfaceInfo));
 
-    WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char *) &rep);
 
-    for(i = 0; i < rep.num; i++) {
+    for (i = 0; i < rep.num; i++) {
-	surface = adaptor->surfaces[i];
+        surface = adaptor->surfaces[i];
-	info.surface_type_id = surface->surface_type_id;
+        info.surface_type_id = surface->surface_type_id;
-	info.chroma_format = surface->chroma_format;
+        info.chroma_format = surface->chroma_format;
-	info.max_width = surface->max_width;
+        info.max_width = surface->max_width;
-	info.max_height = surface->max_height;
+        info.max_height = surface->max_height;
-	info.subpicture_max_width = surface->subpicture_max_width;
+        info.subpicture_max_width = surface->subpicture_max_width;
-	info.subpicture_max_height = surface->subpicture_max_height;
+        info.subpicture_max_height = surface->subpicture_max_height;
-	info.mc_type = surface->mc_type;
+        info.mc_type = surface->mc_type;
-	info.flags = surface->flags;
+        info.flags = surface->flags;
-	WriteToClient(client, sizeof(xvmcSurfaceInfo), (char*)&info);
+        WriteToClient(client, sizeof(xvmcSurfaceInfo), (char *) &info);
     }
 
     return Success;
@@ -187,6 +187,7 @@ ProcXvMCCreateContext(ClientPtr client)
     XvMCAdaptorPtr adaptor = NULL;
     XvMCSurfaceInfoPtr surface = NULL;
     xvmcCreateContextReply rep;
+
     REQUEST(xvmcCreateContextReq);
     REQUEST_SIZE_MATCH(xvmcCreateContextReq);
 
@@ -194,43 +195,42 @@ ProcXvMCCreateContext(ClientPtr client)
 
     pScreen = pPort->pAdaptor->pScreen;
 
-    if(!XvMCInUse) /* no XvMC adaptors */
+    if (!XvMCInUse)             /* no XvMC adaptors */
-       return BadMatch;
+        return BadMatch;
 
-    if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) /* none this screen */
+    if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))     /* none this screen */
-       return BadMatch;
+        return BadMatch;
 
-    for(i = 0; i < pScreenPriv->num_adaptors; i++) {
+    for (i = 0; i < pScreenPriv->num_adaptors; i++) {
-	if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
+        if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
-	    adaptor = &(pScreenPriv->adaptors[i]);
+            adaptor = &(pScreenPriv->adaptors[i]);
-	    adapt_num = i; 
+            adapt_num = i;
-	    break;
+            break;
-	}
+        }
     }
 
-    if(adapt_num < 0) /* none this port */
+    if (adapt_num < 0)          /* none this port */
-	return BadMatch;	
+        return BadMatch;
 
-    for(i = 0; i < adaptor->num_surfaces; i++) {
+    for (i = 0; i < adaptor->num_surfaces; i++) {
-        if(adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
+        if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
             surface = adaptor->surfaces[i];
             break;
         }
     }
 
     /* adaptor doesn't support this suface_type_id */
-    if(!surface) return BadMatch;
+    if (!surface)
+        return BadMatch;
 
-
+    if ((stuff->width > surface->max_width) ||
-    if((stuff->width > surface->max_width) ||
+        (stuff->height > surface->max_height))
-       (stuff->height > surface->max_height))
         return BadValue;
 
-    if(!(pContext = malloc(sizeof(XvMCContextRec)))) {
+    if (!(pContext = malloc(sizeof(XvMCContextRec)))) {
-	return BadAlloc;
+        return BadAlloc;
     }
 
-
     pContext->pScreen = pScreen;
     pContext->adapt_num = adapt_num;
     pContext->context_id = stuff->context_id;
@@ -240,11 +240,11 @@ ProcXvMCCreateContext(ClientPtr client)
     pContext->flags = stuff->flags;
     pContext->refcnt = 1;
 
-    result = (*adaptor->CreateContext)(pPort, pContext, &dwords, &data);
+    result = (*adaptor->CreateContext) (pPort, pContext, &dwords, &data);
 
-    if(result != Success) {
+    if (result != Success) {
-	free(pContext);
+        free(pContext);
-	return result;
+        return result;
     }
 
     rep.type = X_Reply;
@@ -254,9 +254,9 @@ ProcXvMCCreateContext(ClientPtr client)
     rep.flags_return = pContext->flags;
     rep.length = dwords;
 
-    WriteToClient(client, sizeof(xvmcCreateContextReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcCreateContextReply), (char *) &rep);
-    if(dwords)
+    if (dwords)
-      WriteToClient(client, dwords << 2, (char*)data); 
+        WriteToClient(client, dwords << 2, (char *) data);
     AddResource(pContext->context_id, XvMCRTContext, pContext);
 
     free(data);
@@ -269,13 +269,14 @@ ProcXvMCDestroyContext(ClientPtr client)
 {
     pointer val;
     int rc;
+
     REQUEST(xvmcDestroyContextReq);
     REQUEST_SIZE_MATCH(xvmcDestroyContextReq);
 
     rc = dixLookupResourceByType(&val, stuff->context_id, XvMCRTContext,
-				 client, DixDestroyAccess);
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     FreeResource(stuff->context_id, RT_NONE);
 
@@ -292,27 +293,30 @@ ProcXvMCCreateSurface(ClientPtr client)
     XvMCSurfacePtr pSurface;
     XvMCScreenPtr pScreenPriv;
     xvmcCreateSurfaceReply rep;
+
     REQUEST(xvmcCreateSurfaceReq);
     REQUEST_SIZE_MATCH(xvmcCreateSurfaceReq);
 
-    result = dixLookupResourceByType((pointer *)&pContext, stuff->context_id,
+    result = dixLookupResourceByType((pointer *) &pContext, stuff->context_id,
-				     XvMCRTContext, client, DixUseAccess);
+                                     XvMCRTContext, client, DixUseAccess);
     if (result != Success)
         return result;
 
     pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
-    if(!(pSurface = malloc(sizeof(XvMCSurfaceRec)))) 
+    if (!(pSurface = malloc(sizeof(XvMCSurfaceRec))))
         return BadAlloc;
 
     pSurface->surface_id = stuff->surface_id;
     pSurface->surface_type_id = pContext->surface_type_id;
     pSurface->context = pContext;
 
-    result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface)(
+    result =
-                pSurface, &dwords, &data);
+        (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface) (pSurface,
+                                                                     &dwords,
+                                                                     &data);
 
-    if(result != Success) {
+    if (result != Success) {
         free(pSurface);
         return result;
     }
@@ -321,9 +325,9 @@ ProcXvMCCreateSurface(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.length = dwords;
 
-    WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char *) &rep);
-    if(dwords)
+    if (dwords)
-      WriteToClient(client, dwords << 2, (char*)data);
+        WriteToClient(client, dwords << 2, (char *) data);
     AddResource(pSurface->surface_id, XvMCRTSurface, pSurface);
 
     free(data);
@@ -338,11 +342,12 @@ ProcXvMCDestroySurface(ClientPtr client)
 {
     pointer val;
     int rc;
+
     REQUEST(xvmcDestroySurfaceReq);
     REQUEST_SIZE_MATCH(xvmcDestroySurfaceReq);
 
     rc = dixLookupResourceByType(&val, stuff->surface_id, XvMCRTSurface,
-				 client, DixDestroyAccess);
+                                 client, DixDestroyAccess);
     if (rc != Success)
         return rc;
 
@@ -363,11 +368,12 @@ ProcXvMCCreateSubpicture(ClientPtr client)
     xvmcCreateSubpictureReply rep;
     XvMCAdaptorPtr adaptor;
     XvMCSurfaceInfoPtr surface = NULL;
+
     REQUEST(xvmcCreateSubpictureReq);
     REQUEST_SIZE_MATCH(xvmcCreateSubpictureReq);
 
-    result = dixLookupResourceByType((pointer *)&pContext, stuff->context_id,
+    result = dixLookupResourceByType((pointer *) &pContext, stuff->context_id,
-				     XvMCRTContext, client, DixUseAccess);
+                                     XvMCRTContext, client, DixUseAccess);
     if (result != Success)
         return result;
 
@@ -376,51 +382,56 @@ ProcXvMCCreateSubpicture(ClientPtr client)
     adaptor = &(pScreenPriv->adaptors[pContext->adapt_num]);
 
     /* find which surface this context supports */
-    for(i = 0; i < adaptor->num_surfaces; i++) {
+    for (i = 0; i < adaptor->num_surfaces; i++) {
-	if(adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id){
+        if (adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id) {
-	   surface = adaptor->surfaces[i];
+            surface = adaptor->surfaces[i];
-	   break;
+            break;
-	}
+        }
     }
 
-    if(!surface) return BadMatch;
+    if (!surface)
+        return BadMatch;
 
     /* make sure this surface supports that xvimage format */
-    if(!surface->compatible_subpictures) return BadMatch;
+    if (!surface->compatible_subpictures)
+        return BadMatch;
 
-    for(i = 0; i < surface->compatible_subpictures->num_xvimages; i++) {
+    for (i = 0; i < surface->compatible_subpictures->num_xvimages; i++) {
-      if(surface->compatible_subpictures->xvimage_ids[i] == stuff->xvimage_id) {
+        if (surface->compatible_subpictures->xvimage_ids[i] ==
-	   image_supported = TRUE;
+            stuff->xvimage_id) {
-	   break;
+            image_supported = TRUE;
-      }
+            break;
+        }
     }
 
-    if(!image_supported) return BadMatch;
+    if (!image_supported)
+        return BadMatch;
 
     /* make sure the size is OK */
-    if((stuff->width > surface->subpicture_max_width) ||
+    if ((stuff->width > surface->subpicture_max_width) ||
-       (stuff->height > surface->subpicture_max_height))
+        (stuff->height > surface->subpicture_max_height))
-	return BadValue;
+        return BadValue;
 
-    if(!(pSubpicture = malloc(sizeof(XvMCSubpictureRec))))
+    if (!(pSubpicture = malloc(sizeof(XvMCSubpictureRec))))
         return BadAlloc;
 
     pSubpicture->subpicture_id = stuff->subpicture_id;
     pSubpicture->xvimage_id = stuff->xvimage_id;
     pSubpicture->width = stuff->width;
     pSubpicture->height = stuff->height;
-    pSubpicture->num_palette_entries = 0; /* overwritten by DDX */
+    pSubpicture->num_palette_entries = 0;       /* overwritten by DDX */
-    pSubpicture->entry_bytes = 0;         /* overwritten by DDX */
+    pSubpicture->entry_bytes = 0;       /* overwritten by DDX */
-    pSubpicture->component_order[0] = 0;  /* overwritten by DDX */
+    pSubpicture->component_order[0] = 0;        /* overwritten by DDX */
     pSubpicture->component_order[1] = 0;
     pSubpicture->component_order[2] = 0;
     pSubpicture->component_order[3] = 0;
     pSubpicture->context = pContext;
 
-    result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSubpicture)(
+    result =
-                pSubpicture, &dwords, &data);
+        (*pScreenPriv->adaptors[pContext->adapt_num].
+         CreateSubpicture) (pSubpicture, &dwords, &data);
 
-    if(result != Success) {
+    if (result != Success) {
         free(pSubpicture);
         return result;
     }
@@ -437,9 +448,9 @@ ProcXvMCCreateSubpicture(ClientPtr client)
     rep.component_order[3] = pSubpicture->component_order[3];
     rep.length = dwords;
 
-    WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char *) &rep);
-    if(dwords)
+    if (dwords)
-      WriteToClient(client, dwords << 2, (char*)data);
+        WriteToClient(client, dwords << 2, (char *) data);
     AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture);
 
     free(data);
@@ -454,11 +465,12 @@ ProcXvMCDestroySubpicture(ClientPtr client)
 {
     pointer val;
     int rc;
+
     REQUEST(xvmcDestroySubpictureReq);
     REQUEST_SIZE_MATCH(xvmcDestroySubpictureReq);
 
     rc = dixLookupResourceByType(&val, stuff->subpicture_id, XvMCRTSubpicture,
-				 client, DixDestroyAccess);
+                                 client, DixDestroyAccess);
     if (rc != Success)
         return rc;
 
@@ -467,7 +479,6 @@ ProcXvMCDestroySubpicture(ClientPtr client)
     return Success;
 }
 
-
 static int
 ProcXvMCListSubpictureTypes(ClientPtr client)
 {
@@ -480,6 +491,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
     xvImageFormatInfo info;
     XvImagePtr pImage;
     int i, j;
+
     REQUEST(xvmcListSubpictureTypesReq);
     REQUEST_SIZE_MATCH(xvmcListSubpictureTypesReq);
 
@@ -488,53 +500,55 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
     pScreen = pPort->pAdaptor->pScreen;
 
     if (!dixPrivateKeyRegistered(XvMCScreenKey))
-        return BadMatch;   /* No XvMC adaptors */
+        return BadMatch;        /* No XvMC adaptors */
 
-    if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
+    if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
-        return BadMatch;   /* None this screen */
+        return BadMatch;        /* None this screen */
 
-    for(i = 0; i < pScreenPriv->num_adaptors; i++) {
+    for (i = 0; i < pScreenPriv->num_adaptors; i++) {
-        if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
+        if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
             adaptor = &(pScreenPriv->adaptors[i]);
             break;
         }
     }
 
-    if(!adaptor) return BadMatch;
+    if (!adaptor)
+        return BadMatch;
 
-    for(i = 0; i < adaptor->num_surfaces; i++) {
+    for (i = 0; i < adaptor->num_surfaces; i++) {
-        if(adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
+        if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
             surface = adaptor->surfaces[i];
             break;
         }
     }
 
-    if(!surface) return BadMatch;
+    if (!surface)
+        return BadMatch;
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.num = 0;
-    if(surface->compatible_subpictures) 
+    if (surface->compatible_subpictures)
-	rep.num = surface->compatible_subpictures->num_xvimages;
+        rep.num = surface->compatible_subpictures->num_xvimages;
 
     rep.length = bytes_to_int32(rep.num * sizeof(xvImageFormatInfo));
 
-    WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), (char*)&rep);
+    WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), (char *) &rep);
 
-    for(i = 0; i < rep.num; i++) {
+    for (i = 0; i < rep.num; i++) {
-	pImage = NULL;
+        pImage = NULL;
-	for(j = 0; j < adaptor->num_subpictures; j++) {
+        for (j = 0; j < adaptor->num_subpictures; j++) {
-	    if(surface->compatible_subpictures->xvimage_ids[i] ==
+            if (surface->compatible_subpictures->xvimage_ids[i] ==
-	       adaptor->subpictures[j]->id)
+                adaptor->subpictures[j]->id) {
-	    {
+                pImage = adaptor->subpictures[j];
-		pImage = adaptor->subpictures[j];
+                break;
-	        break;
+            }
-	    }
+        }
-	}
+        if (!pImage)
-	if(!pImage) return BadImplementation;
+            return BadImplementation;
 
         info.id = pImage->id;
-	info.type = pImage->type;  
+        info.type = pImage->type;
         info.byte_order = pImage->byte_order;
         memcpy(&info.guid, pImage->guid, 16);
         info.bpp = pImage->bits_per_pixel;
@@ -555,7 +569,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
         info.vert_v_period = pImage->vert_v_period;
         memcpy(&info.comp_order, pImage->component_order, 32);
         info.scanline_order = pImage->scanline_order;
-	WriteToClient(client, sizeof(xvImageFormatInfo), (char*)&info);
+        WriteToClient(client, sizeof(xvImageFormatInfo), (char *) &info);
     }
 
     return Success;
@@ -590,8 +604,8 @@ ProcXvMCGetDRInfo(ClientPtr client)
     rep.busIDLen = bytes_to_int32(strlen(pScreenPriv->busID) + 1);
 
     rep.length = rep.nameLen + rep.busIDLen;
-    rep.nameLen <<=2;
+    rep.nameLen <<= 2;
-    rep.busIDLen <<=2;
+    rep.busIDLen <<= 2;
 
     /*
      * Read back to the client what she has put in the shared memory
@@ -600,64 +614,58 @@ ProcXvMCGetDRInfo(ClientPtr client)
 
     rep.isLocal = 1;
 #ifdef HAS_XVMCSHM
-    patternP = (CARD32 *)shmat( stuff->shmKey, NULL, SHM_RDONLY );
+    patternP = (CARD32 *) shmat(stuff->shmKey, NULL, SHM_RDONLY);
-    if ( -1 != (long) patternP) {
+    if (-1 != (long) patternP) {
         volatile CARD32 *patternC = patternP;
-	int i;
+        int i;
-	CARD32 magic = stuff->magic;
+        CARD32 magic = stuff->magic;
 
-	rep.isLocal = 1;
+        rep.isLocal = 1;
-	i = 1024 / sizeof(CARD32);
+        i = 1024 / sizeof(CARD32);
 
-	while ( i-- ) {
+        while (i--) {
-	    if (*patternC++ != magic) {
+            if (*patternC++ != magic) {
-		rep.isLocal = 0;
+                rep.isLocal = 0;
-		break;
+                break;
-	    }
+            }
-	    magic = ~magic;
+            magic = ~magic;
-	}
+        }
-	shmdt( (char *)patternP ); 
+        shmdt((char *) patternP);
     }
-#endif /* HAS_XVMCSHM */
+#endif                          /* HAS_XVMCSHM */
 
-    WriteToClient(client, sizeof(xvmcGetDRInfoReply), 
+    WriteToClient(client, sizeof(xvmcGetDRInfoReply), (char *) &rep);
-		  (char*)&rep);
     if (rep.length) {
-	WriteToClient(client, rep.nameLen, 
+        WriteToClient(client, rep.nameLen, pScreenPriv->clientDriverName);
-		      pScreenPriv->clientDriverName);
+        WriteToClient(client, rep.busIDLen, pScreenPriv->busID);
-	WriteToClient(client, rep.busIDLen, 
-		      pScreenPriv->busID);
     }
     return Success;
 }
 
-
+int (*ProcXvMCVector[xvmcNumRequest]) (ClientPtr) = {
-int (*ProcXvMCVector[xvmcNumRequest])(ClientPtr) = {
+ProcXvMCQueryVersion,
-  ProcXvMCQueryVersion,
+        ProcXvMCListSurfaceTypes,
-  ProcXvMCListSurfaceTypes,
+        ProcXvMCCreateContext,
-  ProcXvMCCreateContext,
+        ProcXvMCDestroyContext,
-  ProcXvMCDestroyContext,
+        ProcXvMCCreateSurface,
-  ProcXvMCCreateSurface,
+        ProcXvMCDestroySurface,
-  ProcXvMCDestroySurface,
+        ProcXvMCCreateSubpicture,
-  ProcXvMCCreateSubpicture,
+        ProcXvMCDestroySubpicture,
-  ProcXvMCDestroySubpicture,
+        ProcXvMCListSubpictureTypes, ProcXvMCGetDRInfo};
-  ProcXvMCListSubpictureTypes,
-  ProcXvMCGetDRInfo
-};
 
 static int
-ProcXvMCDispatch (ClientPtr client)
+ProcXvMCDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    if(stuff->data < xvmcNumRequest)
+    if (stuff->data < xvmcNumRequest)
-	return (*ProcXvMCVector[stuff->data])(client);
+        return (*ProcXvMCVector[stuff->data]) (client);
     else
-	return BadRequest;
+        return BadRequest;
 }
 
 static int
-SProcXvMCDispatch (ClientPtr client)
+SProcXvMCDispatch(ClientPtr client)
 {
     /* We only support local */
     return BadImplementation;
@@ -666,38 +674,42 @@ SProcXvMCDispatch (ClientPtr client)
 void
 XvMCExtensionInit(void)
 {
-   ExtensionEntry *extEntry;
+    ExtensionEntry *extEntry;
 
-   if (!dixPrivateKeyRegistered(XvMCScreenKey))
+    if (!dixPrivateKeyRegistered(XvMCScreenKey))
-	return;
+        return;
 
-   if(!(XvMCRTContext = CreateNewResourceType(XvMCDestroyContextRes,
+    if (!(XvMCRTContext = CreateNewResourceType(XvMCDestroyContextRes,
-					      "XvMCRTContext")))
+                                                "XvMCRTContext")))
-	return;
+        return;
 
-   if(!(XvMCRTSurface = CreateNewResourceType(XvMCDestroySurfaceRes,
+    if (!(XvMCRTSurface = CreateNewResourceType(XvMCDestroySurfaceRes,
-					      "XvMCRTSurface")))
+                                                "XvMCRTSurface")))
-	return;
+        return;
 
-   if(!(XvMCRTSubpicture = CreateNewResourceType(XvMCDestroySubpictureRes,
+    if (!(XvMCRTSubpicture = CreateNewResourceType(XvMCDestroySubpictureRes,
-						 "XvMCRTSubpicture")))
+                                                   "XvMCRTSubpicture")))
-	return;
+        return;
 
-   extEntry = AddExtension(XvMCName, XvMCNumEvents, XvMCNumErrors, 
+    extEntry = AddExtension(XvMCName, XvMCNumEvents, XvMCNumErrors,
-                              ProcXvMCDispatch, SProcXvMCDispatch,
+                            ProcXvMCDispatch, SProcXvMCDispatch,
-                              NULL, StandardMinorOpcode);
+                            NULL, StandardMinorOpcode);
 
-   if(!extEntry) return;
+    if (!extEntry)
+        return;
 
-   XvMCReqCode = extEntry->base;
+    XvMCReqCode = extEntry->base;
-   XvMCEventBase = extEntry->eventBase;
+    XvMCEventBase = extEntry->eventBase;
-   SetResourceTypeErrorValue(XvMCRTContext, extEntry->errorBase + XvMCBadContext);
+    SetResourceTypeErrorValue(XvMCRTContext,
-   SetResourceTypeErrorValue(XvMCRTSurface, extEntry->errorBase + XvMCBadSurface);
+                              extEntry->errorBase + XvMCBadContext);
-   SetResourceTypeErrorValue(XvMCRTSubpicture, extEntry->errorBase + XvMCBadSubpicture);
+    SetResourceTypeErrorValue(XvMCRTSurface,
+                              extEntry->errorBase + XvMCBadSurface);
+    SetResourceTypeErrorValue(XvMCRTSubpicture,
+                              extEntry->errorBase + XvMCBadSubpicture);
 }
 
 static Bool
-XvMCCloseScreen (int i, ScreenPtr pScreen)
+XvMCCloseScreen(int i, ScreenPtr pScreen)
 {
     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
 
@@ -705,40 +717,40 @@ XvMCCloseScreen (int i, ScreenPtr pScreen)
 
     free(pScreenPriv);
 
-    return (*pScreen->CloseScreen)(i, pScreen);
+    return (*pScreen->CloseScreen) (i, pScreen);
 }
 
-
 int
 XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
 {
-   XvMCScreenPtr pScreenPriv;
+    XvMCScreenPtr pScreenPriv;
 
-   if (!dixRegisterPrivateKey(&XvMCScreenKeyRec, PRIVATE_SCREEN, 0))
+    if (!dixRegisterPrivateKey(&XvMCScreenKeyRec, PRIVATE_SCREEN, 0))
-       return BadAlloc;
+        return BadAlloc;
 
-   if(!(pScreenPriv = malloc(sizeof(XvMCScreenRec))))
+    if (!(pScreenPriv = malloc(sizeof(XvMCScreenRec))))
-	return BadAlloc;
+        return BadAlloc;
 
-   dixSetPrivate(&pScreen->devPrivates, XvMCScreenKey, pScreenPriv);
+    dixSetPrivate(&pScreen->devPrivates, XvMCScreenKey, pScreenPriv);
 
-   pScreenPriv->CloseScreen = pScreen->CloseScreen;
+    pScreenPriv->CloseScreen = pScreen->CloseScreen;
-   pScreen->CloseScreen = XvMCCloseScreen;
+    pScreen->CloseScreen = XvMCCloseScreen;
 
-   pScreenPriv->num_adaptors = num;
+    pScreenPriv->num_adaptors = num;
-   pScreenPriv->adaptors = pAdapt;
+    pScreenPriv->adaptors = pAdapt;
-   pScreenPriv->clientDriverName[0] = 0;
+    pScreenPriv->clientDriverName[0] = 0;
-   pScreenPriv->busID[0] = 0;
+    pScreenPriv->busID[0] = 0;
-   pScreenPriv->major = 0;
+    pScreenPriv->major = 0;
-   pScreenPriv->minor = 0;
+    pScreenPriv->minor = 0;
-   pScreenPriv->patchLevel = 0;
+    pScreenPriv->patchLevel = 0;
 
-   XvMCInUse = TRUE;
+    XvMCInUse = TRUE;
 
-   return Success;
+    return Success;
 }
 
-XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
+XvImagePtr
+XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
 {
     XvImagePtr pImage = NULL;
     ScreenPtr pScreen = pPort->pAdaptor->pScreen;
@@ -749,20 +761,21 @@ XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
     if (!dixPrivateKeyRegistered(XvMCScreenKey))
         return NULL;
 
-    if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) 
+    if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
         return NULL;
 
-    for(i = 0; i < pScreenPriv->num_adaptors; i++) {
+    for (i = 0; i < pScreenPriv->num_adaptors; i++) {
-       if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
+        if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
-          adaptor = &(pScreenPriv->adaptors[i]);
+            adaptor = &(pScreenPriv->adaptors[i]);
-          break;
+            break;
-       }
+        }
     }
 
-    if(!adaptor) return NULL;
+    if (!adaptor)
+        return NULL;
 
-    for(i = 0; i < adaptor->num_subpictures; i++) {
+    for (i = 0; i < adaptor->num_subpictures; i++) {
-        if(adaptor->subpictures[i]->id == id) {
+        if (adaptor->subpictures[i]->id == id) {
             pImage = adaptor->subpictures[i];
             break;
         }
@@ -773,16 +786,14 @@ XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
 
 int
 xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name,
-		       char *busID, int major, int minor,
+                       char *busID, int major, int minor, int patchLevel)
-		       int patchLevel)
 {
     XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
-    strlcpy(pScreenPriv->clientDriverName, name,
+
-	    DR_CLIENT_DRIVER_NAME_SIZE);
+    strlcpy(pScreenPriv->clientDriverName, name, DR_CLIENT_DRIVER_NAME_SIZE);
     strlcpy(pScreenPriv->busID, busID, DR_BUSID_SIZE);
     pScreenPriv->major = major;
     pScreenPriv->minor = minor;
     pScreenPriv->patchLevel = patchLevel;
     return Success;
 }
-

Xext/xvmcext.h

@@ -5,114 +5,96 @@
 #include "xvdix.h"
 
 typedef struct {
-  int num_xvimages;
+    int num_xvimages;
-  int *xvimage_ids;
+    int *xvimage_ids;
 } XvMCImageIDList;
 
 typedef struct {
-  int surface_type_id;
+    int surface_type_id;
-  int chroma_format;
+    int chroma_format;
-  int color_description;
+    int color_description;
-  unsigned short max_width;
+    unsigned short max_width;
-  unsigned short max_height;
+    unsigned short max_height;
-  unsigned short subpicture_max_width;
+    unsigned short subpicture_max_width;
-  unsigned short subpicture_max_height;
+    unsigned short subpicture_max_height;
-  int mc_type;
+    int mc_type;
-  int flags;
+    int flags;
-  XvMCImageIDList *compatible_subpictures;
+    XvMCImageIDList *compatible_subpictures;
 } XvMCSurfaceInfoRec, *XvMCSurfaceInfoPtr;
 
 typedef struct {
-  XID context_id;
+    XID context_id;
-  ScreenPtr pScreen;
+    ScreenPtr pScreen;
-  int adapt_num;
+    int adapt_num;
-  int surface_type_id;
+    int surface_type_id;
-  unsigned short width;
+    unsigned short width;
-  unsigned short height;
+    unsigned short height;
-  CARD32 flags;
+    CARD32 flags;
-  int refcnt;
+    int refcnt;
-  pointer port_priv;
+    pointer port_priv;
-  pointer driver_priv;
+    pointer driver_priv;
 } XvMCContextRec, *XvMCContextPtr;
 
 typedef struct {
-  XID surface_id;
+    XID surface_id;
-  int surface_type_id;
+    int surface_type_id;
-  XvMCContextPtr context;
+    XvMCContextPtr context;
-  pointer driver_priv;
+    pointer driver_priv;
 } XvMCSurfaceRec, *XvMCSurfacePtr;
 
-
 typedef struct {
-  XID subpicture_id;
+    XID subpicture_id;
-  int xvimage_id;
+    int xvimage_id;
-  unsigned short width;
+    unsigned short width;
-  unsigned short height;
+    unsigned short height;
-  int num_palette_entries;
+    int num_palette_entries;
-  int entry_bytes;
+    int entry_bytes;
-  char component_order[4];
+    char component_order[4];
-  XvMCContextPtr context;
+    XvMCContextPtr context;
-  pointer driver_priv;
+    pointer driver_priv;
 } XvMCSubpictureRec, *XvMCSubpicturePtr;
 
-typedef int (*XvMCCreateContextProcPtr) (
+typedef int (*XvMCCreateContextProcPtr) (XvPortPtr port,
-  XvPortPtr port,
+                                         XvMCContextPtr context,
-  XvMCContextPtr context,
+                                         int *num_priv, CARD32 **priv);
-  int *num_priv,
-  CARD32 **priv 
-);
 
-typedef void (*XvMCDestroyContextProcPtr) (
+typedef void (*XvMCDestroyContextProcPtr) (XvMCContextPtr context);
-  XvMCContextPtr context
-);
 
-typedef int (*XvMCCreateSurfaceProcPtr) (
+typedef int (*XvMCCreateSurfaceProcPtr) (XvMCSurfacePtr surface,
-  XvMCSurfacePtr surface,
+                                         int *num_priv, CARD32 **priv);
-  int *num_priv,
-  CARD32 **priv
-);
 
-typedef void (*XvMCDestroySurfaceProcPtr) (
+typedef void (*XvMCDestroySurfaceProcPtr) (XvMCSurfacePtr surface);
-  XvMCSurfacePtr surface
-);
 
-typedef int (*XvMCCreateSubpictureProcPtr) (
+typedef int (*XvMCCreateSubpictureProcPtr) (XvMCSubpicturePtr subpicture,
-  XvMCSubpicturePtr subpicture,
+                                            int *num_priv, CARD32 **priv);
-  int *num_priv,
-  CARD32 **priv
-);
-
-typedef void (*XvMCDestroySubpictureProcPtr) (
-  XvMCSubpicturePtr subpicture
-);
 
+typedef void (*XvMCDestroySubpictureProcPtr) (XvMCSubpicturePtr subpicture);
 
 typedef struct {
-  XvAdaptorPtr			    xv_adaptor;
+    XvAdaptorPtr xv_adaptor;
-  int				    num_surfaces;
+    int num_surfaces;
-  XvMCSurfaceInfoPtr		    *surfaces;
+    XvMCSurfaceInfoPtr *surfaces;
-  int				    num_subpictures;
+    int num_subpictures;
-  XvImagePtr			    *subpictures;
+    XvImagePtr *subpictures;
-  XvMCCreateContextProcPtr          CreateContext; 
+    XvMCCreateContextProcPtr CreateContext;
-  XvMCDestroyContextProcPtr         DestroyContext; 
+    XvMCDestroyContextProcPtr DestroyContext;
-  XvMCCreateSurfaceProcPtr          CreateSurface;  
+    XvMCCreateSurfaceProcPtr CreateSurface;
-  XvMCDestroySurfaceProcPtr         DestroySurface; 
+    XvMCDestroySurfaceProcPtr DestroySurface;
-  XvMCCreateSubpictureProcPtr       CreateSubpicture; 
+    XvMCCreateSubpictureProcPtr CreateSubpicture;
-  XvMCDestroySubpictureProcPtr      DestroySubpicture;
+    XvMCDestroySubpictureProcPtr DestroySubpicture;
 } XvMCAdaptorRec, *XvMCAdaptorPtr;
 
 #ifndef XorgLoader
 extern _X_EXPORT void XvMCExtensionInit(void);
 
 extern _X_EXPORT int XvMCScreenInit(ScreenPtr pScreen,
-				    int num,
+                                    int num, XvMCAdaptorPtr adapt);
-				    XvMCAdaptorPtr adapt);
 
 extern _X_EXPORT XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id);
 
 extern _X_EXPORT int xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name,
-			   char *busID, int major, int minor, 
+                                            char *busID, int major, int minor,
-			   int patchLevel);
+                                            int patchLevel);
 #endif
 
-#endif /* _XVMC_H */
+#endif                          /* _XVMC_H */

Xi/allowev.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 
@@ -97,31 +97,31 @@ ProcXAllowDeviceEvents(ClientPtr client)
 
     rc = dixLookupDevice(&thisdev, stuff->deviceid, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
     time = ClientTimeToServerTime(stuff->time);
 
     switch (stuff->mode) {
     case ReplayThisDevice:
-	AllowSome(client, time, thisdev, NOT_GRABBED);
+        AllowSome(client, time, thisdev, NOT_GRABBED);
-	break;
+        break;
     case SyncThisDevice:
-	AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
+        AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
-	break;
+        break;
     case AsyncThisDevice:
-	AllowSome(client, time, thisdev, THAWED);
+        AllowSome(client, time, thisdev, THAWED);
-	break;
+        break;
     case AsyncOtherDevices:
-	AllowSome(client, time, thisdev, THAW_OTHERS);
+        AllowSome(client, time, thisdev, THAW_OTHERS);
-	break;
+        break;
     case SyncAll:
-	AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
+        AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
-	break;
+        break;
     case AsyncAll:
-	AllowSome(client, time, thisdev, THAWED_BOTH);
+        AllowSome(client, time, thisdev, THAWED_BOTH);
-	break;
+        break;
     default:
-	client->errorValue = stuff->mode;
+        client->errorValue = stuff->mode;
-	return BadValue;
+        return BadValue;
     }
     return Success;
 }

Xi/allowev.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef ALLOWEV_H
 #define ALLOWEV_H 1
 
-int SProcXAllowDeviceEvents(ClientPtr	/* client */
+int SProcXAllowDeviceEvents(ClientPtr   /* client */
     );
 
-int ProcXAllowDeviceEvents(ClientPtr	/* client */
+int ProcXAllowDeviceEvents(ClientPtr    /* client */
     );
 
-#endif /* ALLOWEV_H */
+#endif                          /* ALLOWEV_H */

Xi/chgdctl.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>	/* control constants */
+#include <X11/extensions/XIproto.h>     /* control constants */
 #include "XIstubs.h"
 
 #include "exglobals.h"
@@ -80,17 +80,17 @@ SProcXChangeDeviceControl(ClientPtr client)
     swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
     swaps(&stuff->control);
-    ctl = (xDeviceCtl*)&stuff[1];
+    ctl = (xDeviceCtl *) &stuff[1];
     swaps(&ctl->control);
     swaps(&ctl->length);
-    switch(stuff->control) {
+    switch (stuff->control) {
-        case DEVICE_ABS_CALIB:
+    case DEVICE_ABS_CALIB:
-        case DEVICE_ABS_AREA:
+    case DEVICE_ABS_AREA:
-        case DEVICE_CORE:
+    case DEVICE_CORE:
-        case DEVICE_ENABLE:
+    case DEVICE_ENABLE:
-        case DEVICE_RESOLUTION:
+    case DEVICE_RESOLUTION:
-            /* hmm. beer. *drool* */
+        /* hmm. beer. *drool* */
-            break;
+        break;
 
     }
     return (ProcXChangeDeviceControl(client));
@@ -130,44 +130,47 @@ ProcXChangeDeviceControl(ClientPtr client)
 
     switch (stuff->control) {
     case DEVICE_RESOLUTION:
-	r = (xDeviceResolutionCtl *) & stuff[1];
+        r = (xDeviceResolutionCtl *) &stuff[1];
-	if ((len < bytes_to_int32(sizeof(xDeviceResolutionCtl))) ||
+        if ((len < bytes_to_int32(sizeof(xDeviceResolutionCtl))) ||
-	    (len != bytes_to_int32(sizeof(xDeviceResolutionCtl)) + r->num_valuators)) {
+            (len !=
+             bytes_to_int32(sizeof(xDeviceResolutionCtl)) + r->num_valuators)) {
             ret = BadLength;
             goto out;
-	}
+        }
-	if (!dev->valuator) {
+        if (!dev->valuator) {
             ret = BadMatch;
             goto out;
-	}
+        }
-	if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) {
+        if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) {
-	    rep.status = AlreadyGrabbed;
+            rep.status = AlreadyGrabbed;
             ret = Success;
             goto out;
-	}
+        }
-	resolution = (CARD32 *) (r + 1);
+        resolution = (CARD32 *) (r + 1);
-	if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
+        if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
             ret = BadValue;
             goto out;
-	}
+        }
-	status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
+        status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
-	if (status == Success) {
+        if (status == Success) {
-	    a = &dev->valuator->axes[r->first_valuator];
+            a = &dev->valuator->axes[r->first_valuator];
-	    for (i = 0; i < r->num_valuators; i++)
+            for (i = 0; i < r->num_valuators; i++)
-		if (*(resolution + i) < (a + i)->min_resolution ||
+                if (*(resolution + i) < (a + i)->min_resolution ||
-		    *(resolution + i) > (a + i)->max_resolution)
+                    *(resolution + i) > (a + i)->max_resolution)
-		    return BadValue;
+                    return BadValue;
-	    for (i = 0; i < r->num_valuators; i++)
+            for (i = 0; i < r->num_valuators; i++)
-		(a++)->resolution = *resolution++;
+                (a++)->resolution = *resolution++;
 
             ret = Success;
-	} else if (status == DeviceBusy) {
+        }
-	    rep.status = DeviceBusy;
+        else if (status == DeviceBusy) {
+            rep.status = DeviceBusy;
             ret = Success;
-	} else {
+        }
+        else {
             ret = BadMatch;
-	}
+        }
-	break;
+        break;
     case DEVICE_ABS_CALIB:
     case DEVICE_ABS_AREA:
         /* Calibration is now done through properties, and never had any effect
@@ -180,7 +183,7 @@ ProcXChangeDeviceControl(ClientPtr client)
         ret = BadMatch;
         break;
     case DEVICE_ENABLE:
-        e = (xDeviceEnableCtl *)&stuff[1];
+        e = (xDeviceEnableCtl *) &stuff[1];
 
         status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
 
@@ -190,10 +193,12 @@ ProcXChangeDeviceControl(ClientPtr client)
             else
                 DisableDevice(dev, TRUE);
             ret = Success;
-        } else if (status == DeviceBusy) {
+        }
+        else if (status == DeviceBusy) {
             rep.status = DeviceBusy;
             ret = Success;
-        } else {
+        }
+        else {
             ret = BadMatch;
         }
 
@@ -202,7 +207,7 @@ ProcXChangeDeviceControl(ClientPtr client)
         ret = BadValue;
     }
 
-out:
+ out:
     if (ret == Success) {
         dpn.type = DevicePresenceNotify;
         dpn.time = currentTime.milliseconds;
@@ -227,9 +232,9 @@ out:
 
 void
 SRepXChangeDeviceControl(ClientPtr client, int size,
-			 xChangeDeviceControlReply * rep)
+                         xChangeDeviceControlReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/chgdctl.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGDCTL_H
 #define CHGDCTL_H 1
 
-int SProcXChangeDeviceControl(ClientPtr	/* client */
+int SProcXChangeDeviceControl(ClientPtr /* client */
     );
 
-int ProcXChangeDeviceControl(ClientPtr	/* client */
+int ProcXChangeDeviceControl(ClientPtr  /* client */
     );
 
 void SRepXChangeDeviceControl(ClientPtr /* client */ ,
-			      int /* size */ ,
+                              int /* size */ ,
-			      xChangeDeviceControlReply *	/* rep */
+                              xChangeDeviceControlReply *       /* rep */
     );
 
-#endif /* CHGDCTL_H */
+#endif                          /* CHGDCTL_H */

Xi/chgfctl.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>	/* control constants */
+#include <X11/extensions/XIproto.h>     /* control constants */
 
 #include "exglobals.h"
 
@@ -89,107 +89,110 @@ SProcXChangeFeedbackControl(ClientPtr client)
 
 static int
 ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
-		  KbdFeedbackPtr k, xKbdFeedbackCtl * f)
+                  KbdFeedbackPtr k, xKbdFeedbackCtl * f)
 {
     KeybdCtrl kctrl;
     int t;
     int key = DO_ALL;
 
     if (client->swapped) {
-	swaps(&f->length);
+        swaps(&f->length);
-	swaps(&f->pitch);
+        swaps(&f->pitch);
-	swaps(&f->duration);
+        swaps(&f->duration);
-	swapl(&f->led_mask);
+        swapl(&f->led_mask);
-	swapl(&f->led_values);
+        swapl(&f->led_values);
     }
 
     kctrl = k->ctrl;
     if (mask & DvKeyClickPercent) {
-	t = f->click;
+        t = f->click;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.click;
+            t = defaultKeyboardControl.click;
-	else if (t < 0 || t > 100) {
+        else if (t < 0 || t > 100) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	kctrl.click = t;
+        kctrl.click = t;
     }
 
     if (mask & DvPercent) {
-	t = f->percent;
+        t = f->percent;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell;
+            t = defaultKeyboardControl.bell;
-	else if (t < 0 || t > 100) {
+        else if (t < 0 || t > 100) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	kctrl.bell = t;
+        kctrl.bell = t;
     }
 
     if (mask & DvPitch) {
-	t = f->pitch;
+        t = f->pitch;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell_pitch;
+            t = defaultKeyboardControl.bell_pitch;
-	else if (t < 0) {
+        else if (t < 0) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	kctrl.bell_pitch = t;
+        kctrl.bell_pitch = t;
     }
 
     if (mask & DvDuration) {
-	t = f->duration;
+        t = f->duration;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell_duration;
+            t = defaultKeyboardControl.bell_duration;
-	else if (t < 0) {
+        else if (t < 0) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	kctrl.bell_duration = t;
+        kctrl.bell_duration = t;
     }
 
     if (mask & DvLed) {
-	kctrl.leds &= ~(f->led_mask);
+        kctrl.leds &= ~(f->led_mask);
-	kctrl.leds |= (f->led_mask & f->led_values);
+        kctrl.leds |= (f->led_mask & f->led_values);
     }
 
     if (mask & DvKey) {
-	key = (KeyCode) f->key;
+        key = (KeyCode) f->key;
-	if (key < 8 || key > 255) {
+        if (key < 8 || key > 255) {
-	    client->errorValue = key;
+            client->errorValue = key;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	if (!(mask & DvAutoRepeatMode))
+        if (!(mask & DvAutoRepeatMode))
-	    return BadMatch;
+            return BadMatch;
     }
 
     if (mask & DvAutoRepeatMode) {
-	int inx = (key >> 3);
+        int inx = (key >> 3);
-	int kmask = (1 << (key & 7));
+        int kmask = (1 << (key & 7));
 
-	t = (CARD8) f->auto_repeat_mode;
+        t = (CARD8) f->auto_repeat_mode;
-	if (t == AutoRepeatModeOff) {
+        if (t == AutoRepeatModeOff) {
-	    if (key == DO_ALL)
+            if (key == DO_ALL)
-		kctrl.autoRepeat = FALSE;
+                kctrl.autoRepeat = FALSE;
-	    else
+            else
-		kctrl.autoRepeats[inx] &= ~kmask;
+                kctrl.autoRepeats[inx] &= ~kmask;
-	} else if (t == AutoRepeatModeOn) {
+        }
-	    if (key == DO_ALL)
+        else if (t == AutoRepeatModeOn) {
-		kctrl.autoRepeat = TRUE;
+            if (key == DO_ALL)
-	    else
+                kctrl.autoRepeat = TRUE;
-		kctrl.autoRepeats[inx] |= kmask;
+            else
-	} else if (t == AutoRepeatModeDefault) {
+                kctrl.autoRepeats[inx] |= kmask;
-	    if (key == DO_ALL)
+        }
-		kctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
+        else if (t == AutoRepeatModeDefault) {
-	    else
+            if (key == DO_ALL)
-		kctrl.autoRepeats[inx] &= ~kmask;
+                kctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
-	    kctrl.autoRepeats[inx] =
+            else
-		(kctrl.autoRepeats[inx] & ~kmask) |
+                kctrl.autoRepeats[inx] &= ~kmask;
-		(defaultKeyboardControl.autoRepeats[inx] & kmask);
+            kctrl.autoRepeats[inx] =
-	} else {
+                (kctrl.autoRepeats[inx] & ~kmask) |
-	    client->errorValue = t;
+                (defaultKeyboardControl.autoRepeats[inx] & kmask);
-	    return BadValue;
+        }
-	}
+        else {
+            client->errorValue = t;
+            return BadValue;
+        }
     }
 
     k->ctrl = kctrl;
@@ -205,55 +208,58 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 
 static int
 ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
-		  PtrFeedbackPtr p, xPtrFeedbackCtl * f)
+                  PtrFeedbackPtr p, xPtrFeedbackCtl * f)
 {
-    PtrCtrl pctrl;	/* might get BadValue part way through */
+    PtrCtrl pctrl;              /* might get BadValue part way through */
 
     if (client->swapped) {
-	swaps(&f->length);
+        swaps(&f->length);
-	swaps(&f->num);
+        swaps(&f->num);
-	swaps(&f->denom);
+        swaps(&f->denom);
-	swaps(&f->thresh);
+        swaps(&f->thresh);
     }
 
     pctrl = p->ctrl;
     if (mask & DvAccelNum) {
-	int accelNum;
+        int accelNum;
 
-	accelNum = f->num;
+        accelNum = f->num;
-	if (accelNum == -1)
+        if (accelNum == -1)
-	    pctrl.num = defaultPointerControl.num;
+            pctrl.num = defaultPointerControl.num;
-	else if (accelNum < 0) {
+        else if (accelNum < 0) {
-	    client->errorValue = accelNum;
+            client->errorValue = accelNum;
-	    return BadValue;
+            return BadValue;
-	} else
+        }
-	    pctrl.num = accelNum;
+        else
+            pctrl.num = accelNum;
     }
 
     if (mask & DvAccelDenom) {
-	int accelDenom;
+        int accelDenom;
 
-	accelDenom = f->denom;
+        accelDenom = f->denom;
-	if (accelDenom == -1)
+        if (accelDenom == -1)
-	    pctrl.den = defaultPointerControl.den;
+            pctrl.den = defaultPointerControl.den;
-	else if (accelDenom <= 0) {
+        else if (accelDenom <= 0) {
-	    client->errorValue = accelDenom;
+            client->errorValue = accelDenom;
-	    return BadValue;
+            return BadValue;
-	} else
+        }
-	    pctrl.den = accelDenom;
+        else
+            pctrl.den = accelDenom;
     }
 
     if (mask & DvThreshold) {
-	int threshold;
+        int threshold;
 
-	threshold = f->thresh;
+        threshold = f->thresh;
-	if (threshold == -1)
+        if (threshold == -1)
-	    pctrl.threshold = defaultPointerControl.threshold;
+            pctrl.threshold = defaultPointerControl.threshold;
-	else if (threshold < 0) {
+        else if (threshold < 0) {
-	    client->errorValue = threshold;
+            client->errorValue = threshold;
-	    return BadValue;
+            return BadValue;
-	} else
+        }
-	    pctrl.threshold = threshold;
+        else
+            pctrl.threshold = threshold;
     }
 
     p->ctrl = pctrl;
@@ -269,12 +275,12 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 
 static int
 ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
-		      long unsigned int mask, IntegerFeedbackPtr i,
+                      long unsigned int mask, IntegerFeedbackPtr i,
-		      xIntegerFeedbackCtl * f)
+                      xIntegerFeedbackCtl * f)
 {
     if (client->swapped) {
-	swaps(&f->length);
+        swaps(&f->length);
-	swapl(&f->int_to_display);
+        swapl(&f->int_to_display);
     }
 
     i->ctrl.integer_displayed = f->int_to_display;
@@ -290,33 +296,33 @@ ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
 
 static int
 ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
-		     long unsigned int mask, StringFeedbackPtr s,
+                     long unsigned int mask, StringFeedbackPtr s,
-		     xStringFeedbackCtl * f)
+                     xStringFeedbackCtl * f)
 {
     int i, j;
     KeySym *syms, *sup_syms;
 
     syms = (KeySym *) (f + 1);
     if (client->swapped) {
-	swaps(&f->length);	/* swapped num_keysyms in calling proc */
+        swaps(&f->length);      /* swapped num_keysyms in calling proc */
-	SwapLongs((CARD32 *) syms, f->num_keysyms);
+        SwapLongs((CARD32 *) syms, f->num_keysyms);
     }
 
     if (f->num_keysyms > s->ctrl.max_symbols)
-	return BadValue;
+        return BadValue;
 
     sup_syms = s->ctrl.symbols_supported;
     for (i = 0; i < f->num_keysyms; i++) {
-	for (j = 0; j < s->ctrl.num_symbols_supported; j++)
+        for (j = 0; j < s->ctrl.num_symbols_supported; j++)
-	    if (*(syms + i) == *(sup_syms + j))
+            if (*(syms + i) == *(sup_syms + j))
-		break;
+                break;
-	if (j == s->ctrl.num_symbols_supported)
+        if (j == s->ctrl.num_symbols_supported)
-	    return BadMatch;
+            return BadMatch;
     }
 
     s->ctrl.num_symbols_displayed = f->num_keysyms;
     for (i = 0; i < f->num_keysyms; i++)
-	*(s->ctrl.symbols_displayed + i) = *(syms + i);
+        *(s->ctrl.symbols_displayed + i) = *(syms + i);
     (*s->CtrlProc) (dev, &s->ctrl);
     return Success;
 }
@@ -329,50 +335,50 @@ ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
 
 static int
 ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
-		   long unsigned int mask, BellFeedbackPtr b,
+                   long unsigned int mask, BellFeedbackPtr b,
-		   xBellFeedbackCtl * f)
+                   xBellFeedbackCtl * f)
 {
     int t;
-    BellCtrl bctrl;	/* might get BadValue part way through */
+    BellCtrl bctrl;             /* might get BadValue part way through */
 
     if (client->swapped) {
-	swaps(&f->length);
+        swaps(&f->length);
-	swaps(&f->pitch);
+        swaps(&f->pitch);
-	swaps(&f->duration);
+        swaps(&f->duration);
     }
 
     bctrl = b->ctrl;
     if (mask & DvPercent) {
-	t = f->percent;
+        t = f->percent;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell;
+            t = defaultKeyboardControl.bell;
-	else if (t < 0 || t > 100) {
+        else if (t < 0 || t > 100) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	bctrl.percent = t;
+        bctrl.percent = t;
     }
 
     if (mask & DvPitch) {
-	t = f->pitch;
+        t = f->pitch;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell_pitch;
+            t = defaultKeyboardControl.bell_pitch;
-	else if (t < 0) {
+        else if (t < 0) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	bctrl.pitch = t;
+        bctrl.pitch = t;
     }
 
     if (mask & DvDuration) {
-	t = f->duration;
+        t = f->duration;
-	if (t == -1)
+        if (t == -1)
-	    t = defaultKeyboardControl.bell_duration;
+            t = defaultKeyboardControl.bell_duration;
-	else if (t < 0) {
+        else if (t < 0) {
-	    client->errorValue = t;
+            client->errorValue = t;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	bctrl.duration = t;
+        bctrl.duration = t;
     }
     b->ctrl = bctrl;
     (*b->CtrlProc) (dev, &b->ctrl);
@@ -387,24 +393,24 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
 
 static int
 ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
-		  LedFeedbackPtr l, xLedFeedbackCtl * f)
+                  LedFeedbackPtr l, xLedFeedbackCtl * f)
 {
-    LedCtrl lctrl;	/* might get BadValue part way through */
+    LedCtrl lctrl;              /* might get BadValue part way through */
 
     if (client->swapped) {
-	swaps(&f->length);
+        swaps(&f->length);
-	swapl(&f->led_values);
+        swapl(&f->led_values);
-	swapl(&f->led_mask);
+        swapl(&f->led_mask);
     }
 
-    f->led_mask &= l->ctrl.led_mask;	/* set only supported leds */
+    f->led_mask &= l->ctrl.led_mask;    /* set only supported leds */
-    f->led_values &= l->ctrl.led_mask;	/* set only supported leds */
+    f->led_values &= l->ctrl.led_mask;  /* set only supported leds */
     if (mask & DvLed) {
-	lctrl.led_mask = f->led_mask;
+        lctrl.led_mask = f->led_mask;
-	lctrl.led_values = f->led_values;
+        lctrl.led_values = f->led_values;
-	(*l->CtrlProc) (dev, &lctrl);
+        (*l->CtrlProc) (dev, &lctrl);
-	l->ctrl.led_values &= ~(f->led_mask);	/* zero changed leds */
+        l->ctrl.led_values &= ~(f->led_mask);   /* zero changed leds */
-	l->ctrl.led_values |= (f->led_mask & f->led_values);	/* OR in set leds */
+        l->ctrl.led_values |= (f->led_mask & f->led_values);    /* OR in set leds */
     }
 
     return Success;
@@ -435,74 +441,75 @@ ProcXChangeFeedbackControl(ClientPtr client)
     len = stuff->length - bytes_to_int32(sizeof(xChangeFeedbackControlReq));
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     switch (stuff->feedbackid) {
     case KbdFeedbackClass:
-	if (len != bytes_to_int32(sizeof(xKbdFeedbackCtl)))
+        if (len != bytes_to_int32(sizeof(xKbdFeedbackCtl)))
-	    return BadLength;
+            return BadLength;
 
-	for (k = dev->kbdfeed; k; k = k->next)
+        for (k = dev->kbdfeed; k; k = k->next)
-	    if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id)
+            if (k->ctrl.id == ((xKbdFeedbackCtl *) &stuff[1])->id)
-		return ChangeKbdFeedback(client, dev, stuff->mask, k,
+                return ChangeKbdFeedback(client, dev, stuff->mask, k,
-					 (xKbdFeedbackCtl *) & stuff[1]);
+                                         (xKbdFeedbackCtl *) &stuff[1]);
-	break;
+        break;
     case PtrFeedbackClass:
-	if (len != bytes_to_int32(sizeof(xPtrFeedbackCtl)))
+        if (len != bytes_to_int32(sizeof(xPtrFeedbackCtl)))
-	    return BadLength;
+            return BadLength;
 
-	for (p = dev->ptrfeed; p; p = p->next)
+        for (p = dev->ptrfeed; p; p = p->next)
-	    if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id)
+            if (p->ctrl.id == ((xPtrFeedbackCtl *) &stuff[1])->id)
-		return ChangePtrFeedback(client, dev, stuff->mask, p,
+                return ChangePtrFeedback(client, dev, stuff->mask, p,
-					 (xPtrFeedbackCtl *) & stuff[1]);
+                                         (xPtrFeedbackCtl *) &stuff[1]);
-	break;
+        break;
     case StringFeedbackClass:
     {
-	xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]);
+        xStringFeedbackCtl *f = ((xStringFeedbackCtl *) &stuff[1]);
 
-	if (client->swapped) {
+        if (client->swapped) {
-	    swaps(&f->num_keysyms);
+            swaps(&f->num_keysyms);
-	}
+        }
-	if (len != (bytes_to_int32(sizeof(xStringFeedbackCtl)) + f->num_keysyms))
+        if (len !=
-	    return BadLength;
+            (bytes_to_int32(sizeof(xStringFeedbackCtl)) + f->num_keysyms))
+            return BadLength;
 
-	for (s = dev->stringfeed; s; s = s->next)
+        for (s = dev->stringfeed; s; s = s->next)
-	    if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id)
+            if (s->ctrl.id == ((xStringFeedbackCtl *) &stuff[1])->id)
-		return ChangeStringFeedback(client, dev, stuff->mask, s,
+                return ChangeStringFeedback(client, dev, stuff->mask, s,
-					    (xStringFeedbackCtl *) & stuff[1]);
+                                            (xStringFeedbackCtl *) &stuff[1]);
-	break;
+        break;
     }
     case IntegerFeedbackClass:
-	if (len != bytes_to_int32(sizeof(xIntegerFeedbackCtl)))
+        if (len != bytes_to_int32(sizeof(xIntegerFeedbackCtl)))
-	    return BadLength;
+            return BadLength;
 
-	for (i = dev->intfeed; i; i = i->next)
+        for (i = dev->intfeed; i; i = i->next)
-	    if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id)
+            if (i->ctrl.id == ((xIntegerFeedbackCtl *) &stuff[1])->id)
-		return ChangeIntegerFeedback(client, dev, stuff->mask, i,
+                return ChangeIntegerFeedback(client, dev, stuff->mask, i,
-					     (xIntegerFeedbackCtl *)&stuff[1]);
+                                             (xIntegerFeedbackCtl *) &
-	break;
+                                             stuff[1]);
+        break;
     case LedFeedbackClass:
-	if (len != bytes_to_int32(sizeof(xLedFeedbackCtl)))
+        if (len != bytes_to_int32(sizeof(xLedFeedbackCtl)))
-	    return BadLength;
+            return BadLength;
 
-	for (l = dev->leds; l; l = l->next)
+        for (l = dev->leds; l; l = l->next)
-	    if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id)
+            if (l->ctrl.id == ((xLedFeedbackCtl *) &stuff[1])->id)
-		return ChangeLedFeedback(client, dev, stuff->mask, l,
+                return ChangeLedFeedback(client, dev, stuff->mask, l,
-					 (xLedFeedbackCtl *) & stuff[1]);
+                                         (xLedFeedbackCtl *) &stuff[1]);
-	break;
+        break;
     case BellFeedbackClass:
-	if (len != bytes_to_int32(sizeof(xBellFeedbackCtl)))
+        if (len != bytes_to_int32(sizeof(xBellFeedbackCtl)))
-	    return BadLength;
+            return BadLength;
 
-	for (b = dev->bell; b; b = b->next)
+        for (b = dev->bell; b; b = b->next)
-	    if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id)
+            if (b->ctrl.id == ((xBellFeedbackCtl *) &stuff[1])->id)
-		return ChangeBellFeedback(client, dev, stuff->mask, b,
+                return ChangeBellFeedback(client, dev, stuff->mask, b,
-					  (xBellFeedbackCtl *) & stuff[1]);
+                                          (xBellFeedbackCtl *) &stuff[1]);
-	break;
+        break;
     default:
-	break;
+        break;
     }
 
     return BadMatch;
 }
-

Xi/chgfctl.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGFCTL_H
 #define CHGFCTL_H 1
 
-int SProcXChangeFeedbackControl(ClientPtr	/* client */
+int SProcXChangeFeedbackControl(ClientPtr       /* client */
     );
 
-int ProcXChangeFeedbackControl(ClientPtr	/* client */
+int ProcXChangeFeedbackControl(ClientPtr        /* client */
     );
 
-#endif /* CHGFCTL_H */
+#endif                          /* CHGFCTL_H */

Xi/chgkbd.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"

Xi/chgkbd.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGKBD_H
 #define CHGKBD_H 1
 
-int SProcXChangeKeyboardDevice(ClientPtr	/* client */
+int SProcXChangeKeyboardDevice(ClientPtr        /* client */
     );
 
-int ProcXChangeKeyboardDevice(ClientPtr	/* client */
+int ProcXChangeKeyboardDevice(ClientPtr /* client */
     );
 
-#endif /* CHGKBD_H */
+#endif                          /* CHGKBD_H */

Xi/chgkmap.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -105,12 +105,12 @@ ProcXChangeDeviceKeyMapping(ClientPtr client)
 
     ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
     if (ret != Success)
-	return ret;
+        return ret;
     len = stuff->length - bytes_to_int32(sizeof(xChangeDeviceKeyMappingReq));
 
     ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify,
-			   stuff->firstKeyCode, stuff->keyCodes,
+                           stuff->firstKeyCode, stuff->keyCodes,
-			   stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]);
+                           stuff->keySymsPerKeyCode, (KeySym *) &stuff[1]);
 
     return ret;
 }

Xi/chgkmap.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGKMAP_H
 #define CHGKMAP_H 1
 
-int SProcXChangeDeviceKeyMapping(ClientPtr	/* client */
+int SProcXChangeDeviceKeyMapping(ClientPtr      /* client */
     );
 
-int ProcXChangeDeviceKeyMapping(ClientPtr	/* client */
+int ProcXChangeDeviceKeyMapping(ClientPtr       /* client */
     );
 
-#endif /* CHGKMAP_H */
+#endif                          /* CHGKMAP_H */

Xi/chgprop.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include "windowstr.h"
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
@@ -80,7 +80,7 @@ SProcXChangeDeviceDontPropagateList(ClientPtr client)
     swapl(&stuff->window);
     swaps(&stuff->count);
     REQUEST_FIXED_SIZE(xChangeDeviceDontPropagateListReq,
-                      stuff->count * sizeof(CARD32));
+                       stuff->count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
     return (ProcXChangeDeviceDontPropagateList(client));
 }
@@ -102,39 +102,40 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
     REQUEST(xChangeDeviceDontPropagateListReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
 
-    if (stuff->length != bytes_to_int32(sizeof(xChangeDeviceDontPropagateListReq)) +
+    if (stuff->length !=
-	stuff->count)
+        bytes_to_int32(sizeof(xChangeDeviceDontPropagateListReq)) +
-	return BadLength;
+        stuff->count)
+        return BadLength;
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixSetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (stuff->mode != AddToList && stuff->mode != DeleteFromList) {
-	client->errorValue = stuff->window;
+        client->errorValue = stuff->window;
-	return BadMode;
+        return BadMode;
     }
 
-    if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
+    if ((rc = CreateMaskFromList(client, (XEventClass *) &stuff[1],
-				 stuff->count, tmp, NULL,
+                                 stuff->count, tmp, NULL,
-				 X_ChangeDeviceDontPropagateList)) != Success)
+                                 X_ChangeDeviceDontPropagateList)) != Success)
-	return rc;
+        return rc;
 
     others = wOtherInputMasks(pWin);
     if (!others && stuff->mode == DeleteFromList)
-	return Success;
+        return Success;
     for (i = 0; i < EMASKSIZE; i++) {
-	if (tmp[i].mask == 0)
+        if (tmp[i].mask == 0)
-	    continue;
+            continue;
 
-	if (stuff->mode == DeleteFromList)
+        if (stuff->mode == DeleteFromList)
-	    tmp[i].mask = (others->dontPropagateMask[i] & ~tmp[i].mask);
+            tmp[i].mask = (others->dontPropagateMask[i] & ~tmp[i].mask);
-	else if (others)
+        else if (others)
-	    tmp[i].mask |= others->dontPropagateMask[i];
+            tmp[i].mask |= others->dontPropagateMask[i];
 
-	if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
+        if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
-	    Success)
+            Success)
-	    return BadClass;
+            return BadClass;
     }
 
     return Success;

Xi/chgprop.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGPROP_H
 #define CHGPROP_H 1
 
-int SProcXChangeDeviceDontPropagateList(ClientPtr	/* client */
+int SProcXChangeDeviceDontPropagateList(ClientPtr       /* client */
     );
 
-int ProcXChangeDeviceDontPropagateList(ClientPtr	/* client */
+int ProcXChangeDeviceDontPropagateList(ClientPtr        /* client */
     );
 
-#endif /* CHGPROP_H */
+#endif                          /* CHGPROP_H */

Xi/chgptr.c

@@ -54,12 +54,12 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
-#include "scrnintstr.h"	/* screen structure  */
+#include "scrnintstr.h"         /* screen structure  */
 
 #include "dixevents.h"
 #include "exevents.h"

Xi/chgptr.h

@@ -30,19 +30,19 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGPTR_H
 #define CHGPTR_H 1
 
-int SProcXChangePointerDevice(ClientPtr	/* client */
+int SProcXChangePointerDevice(ClientPtr /* client */
     );
 
-int ProcXChangePointerDevice(ClientPtr	/* client */
+int ProcXChangePointerDevice(ClientPtr  /* client */
     );
 
-void DeleteFocusClassDeviceStruct(DeviceIntPtr	/* dev */
+void DeleteFocusClassDeviceStruct(DeviceIntPtr  /* dev */
     );
 
 void SendEventToAllWindows(DeviceIntPtr /* dev */ ,
-			   Mask /* mask */ ,
+                           Mask /* mask */ ,
-			   xEvent * /* ev */ ,
+                           xEvent * /* ev */ ,
-			   int	/* count */
+                           int  /* count */
     );
 
-#endif /* CHGPTR_H */
+#endif                          /* CHGPTR_H */

Xi/closedev.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
-#include "scrnintstr.h"	/* screen structure  */
+#include "scrnintstr.h"         /* screen structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
@@ -94,15 +94,15 @@ DeleteDeviceEvents(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
     GrabPtr grab, next;
 
     if ((pOthers = wOtherInputMasks(pWin)) != 0)
-	for (others = pOthers->inputClients; others; others = others->next)
+        for (others = pOthers->inputClients; others; others = others->next)
-	    if (SameClient(others, client))
+            if (SameClient(others, client))
-		others->mask[dev->id] = NoEventMask;
+                others->mask[dev->id] = NoEventMask;
 
     for (grab = wPassiveGrabs(pWin); grab; grab = next) {
-	next = grab->next;
+        next = grab->next;
-	if ((grab->device == dev) &&
+        if ((grab->device == dev) &&
-	    (client->clientAsMask == CLIENT_BITS(grab->resource)))
+            (client->clientAsMask == CLIENT_BITS(grab->resource)))
-	    FreeResource(grab->resource, RT_NONE);
+            FreeResource(grab->resource, RT_NONE);
     }
 }
 
@@ -119,10 +119,10 @@ DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
     WindowPtr p2;
 
     while (p1) {
-	p2 = p1->firstChild;
+        p2 = p1->firstChild;
-	DeleteDeviceEvents(dev, p1, client);
+        DeleteDeviceEvents(dev, p1, client);
-	DeleteEventsFromChildren(dev, p2, client);
+        DeleteEventsFromChildren(dev, p2, client);
-	p1 = p1->nextSib;
+        p1 = p1->nextSib;
     }
 }
 
@@ -144,20 +144,20 @@ ProcXCloseDevice(ClientPtr client)
 
     rc = dixLookupDevice(&d, stuff->deviceid, client, DixUseAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (d->deviceGrab.grab && SameClient(d->deviceGrab.grab, client))
-	(*d->deviceGrab.DeactivateGrab) (d);	/* release active grab */
+        (*d->deviceGrab.DeactivateGrab) (d);    /* release active grab */
 
     /* Remove event selections from all windows for events from this device
      * and selected by this client.
      * Delete passive grabs from all windows for this device.      */
 
     for (i = 0; i < screenInfo.numScreens; i++) {
-	pWin = screenInfo.screens[i]->root;
+        pWin = screenInfo.screens[i]->root;
-	DeleteDeviceEvents(d, pWin, client);
+        DeleteDeviceEvents(d, pWin, client);
-	p1 = pWin->firstChild;
+        p1 = pWin->firstChild;
-	DeleteEventsFromChildren(d, p1, client);
+        DeleteEventsFromChildren(d, p1, client);
     }
 
     return Success;

Xi/closedev.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CLOSEDEV_H
 #define CLOSEDEV_H 1
 
-int SProcXCloseDevice(ClientPtr	/* client */
+int SProcXCloseDevice(ClientPtr /* client */
     );
 
-int ProcXCloseDevice(ClientPtr	/* client */
+int ProcXCloseDevice(ClientPtr  /* client */
     );
 
-#endif /* CLOSEDEV_H */
+#endif                          /* CLOSEDEV_H */

Xi/devbell.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -99,47 +99,49 @@ ProcXDeviceBell(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixBellAccess);
     if (rc != Success) {
-	client->errorValue = stuff->deviceid;
+        client->errorValue = stuff->deviceid;
-	return rc;
+        return rc;
     }
 
     if (stuff->percent < -100 || stuff->percent > 100) {
-	client->errorValue = stuff->percent;
+        client->errorValue = stuff->percent;
-	return BadValue;
+        return BadValue;
     }
     if (stuff->feedbackclass == KbdFeedbackClass) {
-	for (k = dev->kbdfeed; k; k = k->next)
+        for (k = dev->kbdfeed; k; k = k->next)
-	    if (k->ctrl.id == stuff->feedbackid)
+            if (k->ctrl.id == stuff->feedbackid)
-		break;
+                break;
-	if (!k) {
+        if (!k) {
-	    client->errorValue = stuff->feedbackid;
+            client->errorValue = stuff->feedbackid;
-	    return BadValue;
+            return BadValue;
-	}
+        }
-	base = k->ctrl.bell;
+        base = k->ctrl.bell;
-	proc = k->BellProc;
+        proc = k->BellProc;
-	ctrl = (pointer) & (k->ctrl);
+        ctrl = (pointer) &(k->ctrl);
-	class = KbdFeedbackClass;
+        class = KbdFeedbackClass;
-    } else if (stuff->feedbackclass == BellFeedbackClass) {
+    }
-	for (b = dev->bell; b; b = b->next)
+    else if (stuff->feedbackclass == BellFeedbackClass) {
-	    if (b->ctrl.id == stuff->feedbackid)
+        for (b = dev->bell; b; b = b->next)
-		break;
+            if (b->ctrl.id == stuff->feedbackid)
-	if (!b) {
+                break;
-	    client->errorValue = stuff->feedbackid;
+        if (!b) {
-	    return BadValue;
+            client->errorValue = stuff->feedbackid;
-	}
+            return BadValue;
-	base = b->ctrl.percent;
+        }
-	proc = b->BellProc;
+        base = b->ctrl.percent;
-	ctrl = (pointer) & (b->ctrl);
+        proc = b->BellProc;
-	class = BellFeedbackClass;
+        ctrl = (pointer) &(b->ctrl);
-    } else {
+        class = BellFeedbackClass;
-	client->errorValue = stuff->feedbackclass;
+    }
-	return BadValue;
+    else {
+        client->errorValue = stuff->feedbackclass;
+        return BadValue;
     }
     newpercent = (base * stuff->percent) / 100;
     if (stuff->percent < 0)
-	newpercent = base + newpercent;
+        newpercent = base + newpercent;
     else
-	newpercent = base - newpercent + stuff->percent;
+        newpercent = base - newpercent + stuff->percent;
     (*proc) (newpercent, dev, ctrl, class);
 
     return Success;

Xi/devbell.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef DEVBELL_H
 #define DEVBELL_H 1
 
-int SProcXDeviceBell(ClientPtr	/* client */
+int SProcXDeviceBell(ClientPtr  /* client */
     );
 
-int ProcXDeviceBell(ClientPtr	/* client */
+int ProcXDeviceBell(ClientPtr   /* client */
     );
 
-#endif /* DEVBELL_H */
+#endif                          /* DEVBELL_H */

Xi/exglobals.h

@@ -79,6 +79,7 @@ extern int DevicePropertyNotify;
 extern RESTYPE RT_INPUTCLIENT;
 
 extern DevPrivateKeyRec XIClientPrivateKeyRec;
+
 #define XIClientPrivateKey (&XIClientPrivateKeyRec)
 
-#endif /* EXGLOBALS_H */
+#endif                          /* EXGLOBALS_H */

Xi/getbmap.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -100,16 +100,16 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     b = dev->button;
     if (b == NULL)
-	return BadMatch;
+        return BadMatch;
 
     rep.nElts = b->numButtons;
     rep.length = bytes_to_int32(rep.nElts);
     WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
-    (void)WriteToClient(client, rep.nElts, (char *)&b->map[1]);
+    (void) WriteToClient(client, rep.nElts, (char *) &b->map[1]);
     return Success;
 }
 
@@ -122,9 +122,9 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
 
 void
 SRepXGetDeviceButtonMapping(ClientPtr client, int size,
-			    xGetDeviceButtonMappingReply * rep)
+                            xGetDeviceButtonMappingReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getbmap.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETBMAP_H
 #define GETBMAP_H 1
 
-int SProcXGetDeviceButtonMapping(ClientPtr	/* client */
+int SProcXGetDeviceButtonMapping(ClientPtr      /* client */
     );
 
-int ProcXGetDeviceButtonMapping(ClientPtr	/* client */
+int ProcXGetDeviceButtonMapping(ClientPtr       /* client */
     );
 
 void SRepXGetDeviceButtonMapping(ClientPtr /* client */ ,
-				 int /* size */ ,
+                                 int /* size */ ,
-				 xGetDeviceButtonMappingReply *	/* rep */
+                                 xGetDeviceButtonMappingReply * /* rep */
     );
 
-#endif /* GETBMAP_H */
+#endif                          /* GETBMAP_H */

Xi/getdctl.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -86,7 +86,7 @@ SProcXGetDeviceControl(ClientPtr client)
 
 static void
 CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
-			 int length)
+                         int length)
 {
     AxisInfoPtr a;
     xDeviceResolutionState *r;
@@ -97,25 +97,26 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
     r->length = length;
     r->num_valuators = v->numAxes;
     buf += sizeof(xDeviceResolutionState);
-    iptr = (int *)buf;
+    iptr = (int *) buf;
     for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
-	*iptr++ = a->resolution;
+        *iptr++ = a->resolution;
     for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
-	*iptr++ = a->min_resolution;
+        *iptr++ = a->min_resolution;
     for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
-	*iptr++ = a->max_resolution;
+        *iptr++ = a->max_resolution;
     if (client->swapped) {
-	swaps(&r->control);
+        swaps(&r->control);
-	swaps(&r->length);
+        swaps(&r->length);
-	swapl(&r->num_valuators);
+        swapl(&r->num_valuators);
-	iptr = (int *)buf;
+        iptr = (int *) buf;
-	for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
+        for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
-	    swapl(iptr);
+            swapl(iptr);
-	}
+        }
     }
 }
 
-static void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
+static void
+CopySwapDeviceCore(ClientPtr client, DeviceIntPtr dev, char *buf)
 {
     xDeviceCoreState *c = (xDeviceCoreState *) buf;
 
@@ -130,7 +131,8 @@ static void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
     }
 }
 
-static void CopySwapDeviceEnable (ClientPtr client, DeviceIntPtr dev, char *buf)
+static void
+CopySwapDeviceEnable(ClientPtr client, DeviceIntPtr dev, char *buf)
 {
     xDeviceEnableState *e = (xDeviceEnableState *) buf;
 
@@ -156,7 +158,7 @@ SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }
 
 /***********************************************************************
@@ -178,7 +180,7 @@ ProcXGetDeviceControl(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceControl;
@@ -187,11 +189,11 @@ ProcXGetDeviceControl(ClientPtr client)
 
     switch (stuff->control) {
     case DEVICE_RESOLUTION:
-	if (!dev->valuator)
+        if (!dev->valuator)
-	    return BadMatch;
+            return BadMatch;
-	total_length = sizeof(xDeviceResolutionState) +
+        total_length = sizeof(xDeviceResolutionState) +
-	    (3 * sizeof(int) * dev->valuator->numAxes);
+            (3 * sizeof(int) * dev->valuator->numAxes);
-	break;
+        break;
     case DEVICE_ABS_CALIB:
     case DEVICE_ABS_AREA:
         return BadMatch;
@@ -202,18 +204,18 @@ ProcXGetDeviceControl(ClientPtr client)
         total_length = sizeof(xDeviceEnableState);
         break;
     default:
-	return BadValue;
+        return BadValue;
     }
 
-    buf = (char *)malloc(total_length);
+    buf = (char *) malloc(total_length);
     if (!buf)
-	return BadAlloc;
+        return BadAlloc;
     savbuf = buf;
 
     switch (stuff->control) {
     case DEVICE_RESOLUTION:
-	CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
+        CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
-	break;
+        break;
     case DEVICE_CORE:
         CopySwapDeviceCore(client, dev, buf);
         break;
@@ -221,7 +223,7 @@ ProcXGetDeviceControl(ClientPtr client)
         CopySwapDeviceEnable(client, dev, buf);
         break;
     default:
-	break;
+        break;
     }
 
     rep.length = bytes_to_int32(total_length);

Xi/getdctl.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETDCTL_H
 #define GETDCTL_H 1
 
-int SProcXGetDeviceControl(ClientPtr	/* client */
+int SProcXGetDeviceControl(ClientPtr    /* client */
     );
 
-int ProcXGetDeviceControl(ClientPtr	/* client */
+int ProcXGetDeviceControl(ClientPtr     /* client */
     );
 
 void SRepXGetDeviceControl(ClientPtr /* client */ ,
-			   int /* size */ ,
+                           int /* size */ ,
-			   xGetDeviceControlReply *	/* rep */
+                           xGetDeviceControlReply *     /* rep */
     );
 
-#endif /* GETDCTL_H */
+#endif                          /* GETDCTL_H */

Xi/getfctl.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -99,13 +99,13 @@ CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
     k2->led_mask = k->ctrl.leds;
     k2->global_auto_repeat = k->ctrl.autoRepeat;
     for (i = 0; i < 32; i++)
-	k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
+        k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
     if (client->swapped) {
-	swaps(&k2->length);
+        swaps(&k2->length);
-	swaps(&k2->pitch);
+        swaps(&k2->pitch);
-	swaps(&k2->duration);
+        swaps(&k2->duration);
-	swapl(&k2->led_mask);
+        swapl(&k2->led_mask);
-	swapl(&k2->led_values);
+        swapl(&k2->led_values);
     }
     *buf += sizeof(xKbdFeedbackState);
 }
@@ -129,10 +129,10 @@ CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
     p2->accelDenom = p->ctrl.den;
     p2->threshold = p->ctrl.threshold;
     if (client->swapped) {
-	swaps(&p2->length);
+        swaps(&p2->length);
-	swaps(&p2->accelNum);
+        swaps(&p2->accelNum);
-	swaps(&p2->accelDenom);
+        swaps(&p2->accelDenom);
-	swaps(&p2->threshold);
+        swaps(&p2->threshold);
     }
     *buf += sizeof(xPtrFeedbackState);
 }
@@ -156,10 +156,10 @@ CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
     i2->min_value = i->ctrl.min_value;
     i2->max_value = i->ctrl.max_value;
     if (client->swapped) {
-	swaps(&i2->length);
+        swaps(&i2->length);
-	swapl(&i2->resolution);
+        swapl(&i2->resolution);
-	swapl(&i2->min_value);
+        swapl(&i2->min_value);
-	swapl(&i2->max_value);
+        swapl(&i2->max_value);
     }
     *buf += sizeof(xIntegerFeedbackState);
 }
@@ -180,22 +180,22 @@ CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
     s2 = (xStringFeedbackState *) * buf;
     s2->class = StringFeedbackClass;
     s2->length = sizeof(xStringFeedbackState) +
-	s->ctrl.num_symbols_supported * sizeof(KeySym);
+        s->ctrl.num_symbols_supported * sizeof(KeySym);
     s2->id = s->ctrl.id;
     s2->max_symbols = s->ctrl.max_symbols;
     s2->num_syms_supported = s->ctrl.num_symbols_supported;
     *buf += sizeof(xStringFeedbackState);
     kptr = (KeySym *) (*buf);
     for (i = 0; i < s->ctrl.num_symbols_supported; i++)
-	*kptr++ = *(s->ctrl.symbols_supported + i);
+        *kptr++ = *(s->ctrl.symbols_supported + i);
     if (client->swapped) {
-	swaps(&s2->length);
+        swaps(&s2->length);
-	swaps(&s2->max_symbols);
+        swaps(&s2->max_symbols);
-	swaps(&s2->num_syms_supported);
+        swaps(&s2->num_syms_supported);
-	kptr = (KeySym *) (*buf);
+        kptr = (KeySym *) (*buf);
-	for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
+        for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
-	    swapl(kptr);
+            swapl(kptr);
-	}
+        }
     }
     *buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
 }
@@ -218,9 +218,9 @@ CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
     l2->led_values = l->ctrl.led_values;
     l2->led_mask = l->ctrl.led_mask;
     if (client->swapped) {
-	swaps(&l2->length);
+        swaps(&l2->length);
-	swapl(&l2->led_values);
+        swapl(&l2->led_values);
-	swapl(&l2->led_mask);
+        swapl(&l2->led_mask);
     }
     *buf += sizeof(xLedFeedbackState);
 }
@@ -244,9 +244,9 @@ CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
     b2->pitch = b->ctrl.pitch;
     b2->duration = b->ctrl.duration;
     if (client->swapped) {
-	swaps(&b2->length);
+        swaps(&b2->length);
-	swaps(&b2->pitch);
+        swaps(&b2->pitch);
-	swaps(&b2->duration);
+        swaps(&b2->duration);
     }
     *buf += sizeof(xBellFeedbackState);
 }
@@ -260,12 +260,12 @@ CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
 
 void
 SRepXGetFeedbackControl(ClientPtr client, int size,
-			xGetFeedbackControlReply * rep)
+                        xGetFeedbackControlReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
     swaps(&rep->num_feedbacks);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }
 
 /***********************************************************************
@@ -293,7 +293,7 @@ ProcXGetFeedbackControl(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.repType = X_Reply;
     rep.RepType = X_GetFeedbackControl;
@@ -302,51 +302,51 @@ ProcXGetFeedbackControl(ClientPtr client)
     rep.num_feedbacks = 0;
 
     for (k = dev->kbdfeed; k; k = k->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xKbdFeedbackState);
+        total_length += sizeof(xKbdFeedbackState);
     }
     for (p = dev->ptrfeed; p; p = p->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xPtrFeedbackState);
+        total_length += sizeof(xPtrFeedbackState);
     }
     for (s = dev->stringfeed; s; s = s->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xStringFeedbackState) +
+        total_length += sizeof(xStringFeedbackState) +
-	    (s->ctrl.num_symbols_supported * sizeof(KeySym));
+            (s->ctrl.num_symbols_supported * sizeof(KeySym));
     }
     for (i = dev->intfeed; i; i = i->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xIntegerFeedbackState);
+        total_length += sizeof(xIntegerFeedbackState);
     }
     for (l = dev->leds; l; l = l->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xLedFeedbackState);
+        total_length += sizeof(xLedFeedbackState);
     }
     for (b = dev->bell; b; b = b->next) {
-	rep.num_feedbacks++;
+        rep.num_feedbacks++;
-	total_length += sizeof(xBellFeedbackState);
+        total_length += sizeof(xBellFeedbackState);
     }
 
     if (total_length == 0)
-	return BadMatch;
+        return BadMatch;
 
-    buf = (char *)malloc(total_length);
+    buf = (char *) malloc(total_length);
     if (!buf)
-	return BadAlloc;
+        return BadAlloc;
     savbuf = buf;
 
     for (k = dev->kbdfeed; k; k = k->next)
-	CopySwapKbdFeedback(client, k, &buf);
+        CopySwapKbdFeedback(client, k, &buf);
     for (p = dev->ptrfeed; p; p = p->next)
-	CopySwapPtrFeedback(client, p, &buf);
+        CopySwapPtrFeedback(client, p, &buf);
     for (s = dev->stringfeed; s; s = s->next)
-	CopySwapStringFeedback(client, s, &buf);
+        CopySwapStringFeedback(client, s, &buf);
     for (i = dev->intfeed; i; i = i->next)
-	CopySwapIntegerFeedback(client, i, &buf);
+        CopySwapIntegerFeedback(client, i, &buf);
     for (l = dev->leds; l; l = l->next)
-	CopySwapLedFeedback(client, l, &buf);
+        CopySwapLedFeedback(client, l, &buf);
     for (b = dev->bell; b; b = b->next)
-	CopySwapBellFeedback(client, b, &buf);
+        CopySwapBellFeedback(client, b, &buf);
 
     rep.length = bytes_to_int32(total_length);
     WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep);

Xi/getfctl.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETFCTL_H
 #define GETFCTL_H 1
 
-int SProcXGetFeedbackControl(ClientPtr	/* client */
+int SProcXGetFeedbackControl(ClientPtr  /* client */
     );
 
-int ProcXGetFeedbackControl(ClientPtr	/* client */
+int ProcXGetFeedbackControl(ClientPtr   /* client */
     );
 
 void SRepXGetFeedbackControl(ClientPtr /* client */ ,
-			     int /* size */ ,
+                             int /* size */ ,
-			     xGetFeedbackControlReply *	/* rep */
+                             xGetFeedbackControlReply * /* rep */
     );
 
-#endif /* GETFCTL_H */
+#endif                          /* GETFCTL_H */

Xi/getfocus.c

@@ -54,8 +54,8 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "windowstr.h"	/* focus struct      */
+#include "windowstr.h"          /* focus struct      */
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -95,9 +95,9 @@ ProcXGetDeviceFocus(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetFocusAccess);
     if (rc != Success)
-	return rc;
+        return rc;
     if (!dev->focus)
-	return BadDevice;
+        return BadDevice;
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceFocus;
@@ -107,13 +107,13 @@ ProcXGetDeviceFocus(ClientPtr client)
     focus = dev->focus;
 
     if (focus->win == NoneWin)
-	rep.focus = None;
+        rep.focus = None;
     else if (focus->win == PointerRootWin)
-	rep.focus = PointerRoot;
+        rep.focus = PointerRoot;
     else if (focus->win == FollowKeyboardWin)
-	rep.focus = FollowKeyboard;
+        rep.focus = FollowKeyboard;
     else
-	rep.focus = focus->win->drawable.id;
+        rep.focus = focus->win->drawable.id;
 
     rep.time = focus->time.milliseconds;
     rep.revertTo = focus->revert;
@@ -135,5 +135,5 @@ SRepXGetDeviceFocus(ClientPtr client, int size, xGetDeviceFocusReply * rep)
     swapl(&rep->length);
     swapl(&rep->focus);
     swapl(&rep->time);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getfocus.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETFOCUS_H
 #define GETFOCUS_H 1
 
-int SProcXGetDeviceFocus(ClientPtr	/* client */
+int SProcXGetDeviceFocus(ClientPtr      /* client */
     );
 
-int ProcXGetDeviceFocus(ClientPtr	/* client */
+int ProcXGetDeviceFocus(ClientPtr       /* client */
     );
 
 void SRepXGetDeviceFocus(ClientPtr /* client */ ,
-			 int /* size */ ,
+                         int /* size */ ,
-			 xGetDeviceFocusReply *	/* rep */
+                         xGetDeviceFocusReply * /* rep */
     );
 
-#endif /* GETFOCUS_H */
+#endif                          /* GETFOCUS_H */

Xi/getkmap.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -99,20 +99,20 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
     if (dev->key == NULL)
-	return BadMatch;
+        return BadMatch;
     xkb = dev->key->xkbInfo->desc;
 
     if (stuff->firstKeyCode < xkb->min_key_code ||
-	stuff->firstKeyCode > xkb->max_key_code) {
+        stuff->firstKeyCode > xkb->max_key_code) {
-	client->errorValue = stuff->firstKeyCode;
+        client->errorValue = stuff->firstKeyCode;
-	return BadValue;
+        return BadValue;
     }
 
     if (stuff->firstKeyCode + stuff->count > xkb->max_key_code + 1) {
-	client->errorValue = stuff->count;
+        client->errorValue = stuff->count;
-	return BadValue;
+        return BadValue;
     }
 
     syms = XkbGetCoreMap(dev);
@@ -123,7 +123,7 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
     rep.RepType = X_GetDeviceKeyMapping;
     rep.sequenceNumber = client->sequence;
     rep.keySymsPerKeyCode = syms->mapWidth;
-    rep.length = (syms->mapWidth * stuff->count);	/* KeySyms are 4 bytes */
+    rep.length = (syms->mapWidth * stuff->count);       /* KeySyms are 4 bytes */
     WriteReplyToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep);
 
     client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write;
@@ -146,9 +146,9 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
 
 void
 SRepXGetDeviceKeyMapping(ClientPtr client, int size,
-			 xGetDeviceKeyMappingReply * rep)
+                         xGetDeviceKeyMappingReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getkmap.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETKMAP_H
 #define GETKMAP_H 1
 
-int SProcXGetDeviceKeyMapping(ClientPtr	/* client */
+int SProcXGetDeviceKeyMapping(ClientPtr /* client */
     );
 
-int ProcXGetDeviceKeyMapping(ClientPtr	/* client */
+int ProcXGetDeviceKeyMapping(ClientPtr  /* client */
     );
 
 void SRepXGetDeviceKeyMapping(ClientPtr /* client */ ,
-			      int /* size */ ,
+                              int /* size */ ,
-			      xGetDeviceKeyMappingReply *	/* rep */
+                              xGetDeviceKeyMappingReply *       /* rep */
     );
 
-#endif /* GETKMAP_H */
+#endif                          /* GETKMAP_H */

Xi/getmmap.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>	/* Request macro     */
+#include <X11/extensions/XIproto.h>     /* Request macro     */
 #include "exglobals.h"
 
 #include "getmmap.h"
@@ -95,7 +95,7 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
 
     ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (ret != Success)
-	return ret;
+        return ret;
 
     ret = generate_modkeymap(client, dev, &modkeymap, &max_keys_per_mod);
     if (ret != Success)
@@ -125,9 +125,9 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
 
 void
 SRepXGetDeviceModifierMapping(ClientPtr client, int size,
-			      xGetDeviceModifierMappingReply * rep)
+                              xGetDeviceModifierMappingReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getmmap.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETMMAP_H
 #define GETMMAP_H 1
 
-int SProcXGetDeviceModifierMapping(ClientPtr	/* client */
+int SProcXGetDeviceModifierMapping(ClientPtr    /* client */
     );
 
-int ProcXGetDeviceModifierMapping(ClientPtr	/* client */
+int ProcXGetDeviceModifierMapping(ClientPtr     /* client */
     );
 
 void SRepXGetDeviceModifierMapping(ClientPtr /* client */ ,
-				   int /* size */ ,
+                                   int /* size */ ,
-				   xGetDeviceModifierMappingReply *	/* rep */
+                                   xGetDeviceModifierMappingReply *     /* rep */
     );
 
-#endif /* GETMMAP_H */
+#endif                          /* GETMMAP_H */

Xi/getprop.c

@@ -54,8 +54,8 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structs    */
+#include "windowstr.h"          /* window structs    */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
@@ -109,30 +109,29 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if ((others = wOtherInputMasks(pWin)) != 0) {
-	for (i = 0; i < EMASKSIZE; i++)
+        for (i = 0; i < EMASKSIZE; i++)
-	    ClassFromMask(NULL, others->dontPropagateMask[i], i,
+            ClassFromMask(NULL, others->dontPropagateMask[i], i, &count, COUNT);
-				 &count, COUNT);
+        if (count) {
-	if (count) {
+            rep.count = count;
-	    rep.count = count;
+            buf = (XEventClass *) malloc(rep.count * sizeof(XEventClass));
-	    buf = (XEventClass *) malloc(rep.count * sizeof(XEventClass));
+            rep.length = bytes_to_int32(rep.count * sizeof(XEventClass));
-	    rep.length = bytes_to_int32(rep.count * sizeof(XEventClass));
 
-	    tbuf = buf;
+            tbuf = buf;
-	    for (i = 0; i < EMASKSIZE; i++)
+            for (i = 0; i < EMASKSIZE; i++)
-		tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i,
+                tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i,
-				     NULL, CREATE);
+                                     NULL, CREATE);
-	}
+        }
     }
 
     WriteReplyToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep);
 
     if (count) {
-	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+        client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf);
+        WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf);
-	free(buf);
+        free(buf);
     }
     return Success;
 }
@@ -145,23 +144,23 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
  */
 
 XEventClass
-    * ClassFromMask(XEventClass * buf, Mask mask, int maskndx, CARD16 * count,
+    * ClassFromMask(XEventClass * buf, Mask mask, int maskndx, CARD16 *count,
-		    int mode)
+                    int mode)
 {
     int i, j;
     int id = maskndx;
     Mask tmask = 0x80000000;
 
     for (i = 0; i < 32; i++, tmask >>= 1)
-	if (tmask & mask) {
+        if (tmask & mask) {
-	    for (j = 0; j < ExtEventIndex; j++)
+            for (j = 0; j < ExtEventIndex; j++)
-		if (EventInfo[j].mask == tmask) {
+                if (EventInfo[j].mask == tmask) {
-		    if (mode == COUNT)
+                    if (mode == COUNT)
-			(*count)++;
+                        (*count)++;
-		    else
+                    else
-			*buf++ = (id << 8) | EventInfo[j].type;
+                        *buf++ = (id << 8) | EventInfo[j].type;
-		}
+                }
-	}
+        }
     return buf;
 }
 
@@ -174,10 +173,10 @@ XEventClass
 
 void
 SRepXGetDeviceDontPropagateList(ClientPtr client, int size,
-				xGetDeviceDontPropagateListReply * rep)
+                                xGetDeviceDontPropagateListReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
     swaps(&rep->count);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getprop.h

@@ -30,22 +30,22 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETPROP_H
 #define GETPROP_H 1
 
-int SProcXGetDeviceDontPropagateList(ClientPtr	/* client */
+int SProcXGetDeviceDontPropagateList(ClientPtr  /* client */
     );
 
-int ProcXGetDeviceDontPropagateList(ClientPtr	/* client */
+int ProcXGetDeviceDontPropagateList(ClientPtr   /* client */
     );
 
 XEventClass *ClassFromMask(XEventClass * /* buf */ ,
-			   Mask /* mask */ ,
+                           Mask /* mask */ ,
-			   int /* maskndx */ ,
+                           int /* maskndx */ ,
-			   CARD16 * /* count */ ,
+                           CARD16 * /* count */ ,
-			   int	/* mode */
+                           int  /* mode */
     );
 
 void SRepXGetDeviceDontPropagateList(ClientPtr /* client */ ,
-				     int /* size */ ,
+                                     int /* size */ ,
-				     xGetDeviceDontPropagateListReply *	/* rep */
+                                     xGetDeviceDontPropagateListReply * /* rep */
     );
 
-#endif /* GETPROP_H */
+#endif                          /* GETPROP_H */

Xi/getselev.c

@@ -56,8 +56,8 @@ SOFTWARE.
 
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window struct     */
+#include "windowstr.h"          /* window struct     */
 #include "exglobals.h"
 #include "swaprep.h"
 
@@ -111,45 +111,45 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if ((pOthers = wOtherInputMasks(pWin)) != 0) {
-	for (others = pOthers->inputClients; others; others = others->next)
+        for (others = pOthers->inputClients; others; others = others->next)
-	    for (i = 0; i < EMASKSIZE; i++)
+            for (i = 0; i < EMASKSIZE; i++)
-		ClassFromMask(NULL, others->mask[i], i,
+                ClassFromMask(NULL, others->mask[i], i,
-					&rep.all_clients_count, COUNT);
+                              &rep.all_clients_count, COUNT);
 
-	for (others = pOthers->inputClients; others; others = others->next)
+        for (others = pOthers->inputClients; others; others = others->next)
-	    if (SameClient(others, client)) {
+            if (SameClient(others, client)) {
-		for (i = 0; i < EMASKSIZE; i++)
+                for (i = 0; i < EMASKSIZE; i++)
-		    ClassFromMask(NULL, others->mask[i], i,
+                    ClassFromMask(NULL, others->mask[i], i,
-					    &rep.this_client_count, COUNT);
+                                  &rep.this_client_count, COUNT);
-		break;
+                break;
-	    }
+            }
 
-	total_length = (rep.all_clients_count + rep.this_client_count) *
+        total_length = (rep.all_clients_count + rep.this_client_count) *
-	    sizeof(XEventClass);
+            sizeof(XEventClass);
-	rep.length = bytes_to_int32(total_length);
+        rep.length = bytes_to_int32(total_length);
-	buf = (XEventClass *) malloc(total_length);
+        buf = (XEventClass *) malloc(total_length);
 
-	tclient = buf;
+        tclient = buf;
-	aclient = buf + rep.this_client_count;
+        aclient = buf + rep.this_client_count;
-	if (others)
+        if (others)
-	    for (i = 0; i < EMASKSIZE; i++)
+            for (i = 0; i < EMASKSIZE; i++)
-		tclient =
+                tclient =
-		    ClassFromMask(tclient, others->mask[i], i, NULL, CREATE);
+                    ClassFromMask(tclient, others->mask[i], i, NULL, CREATE);
 
-	for (others = pOthers->inputClients; others; others = others->next)
+        for (others = pOthers->inputClients; others; others = others->next)
-	    for (i = 0; i < EMASKSIZE; i++)
+            for (i = 0; i < EMASKSIZE; i++)
-		aclient =
+                aclient =
-		    ClassFromMask(aclient, others->mask[i], i, NULL, CREATE);
+                    ClassFromMask(aclient, others->mask[i], i, NULL, CREATE);
     }
 
     WriteReplyToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep);
 
     if (total_length) {
-	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+        client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	WriteSwappedDataToClient(client, total_length, buf);
+        WriteSwappedDataToClient(client, total_length, buf);
     }
     free(buf);
     return Success;
@@ -164,11 +164,11 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
 
 void
 SRepXGetSelectedExtensionEvents(ClientPtr client, int size,
-				xGetSelectedExtensionEventsReply * rep)
+                                xGetSelectedExtensionEventsReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
     swaps(&rep->this_client_count);
     swaps(&rep->all_clients_count);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getselev.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETSELEV_H
 #define GETSELEV_H 1
 
-int SProcXGetSelectedExtensionEvents(ClientPtr	/* client */
+int SProcXGetSelectedExtensionEvents(ClientPtr  /* client */
     );
 
-int ProcXGetSelectedExtensionEvents(ClientPtr	/* client */
+int ProcXGetSelectedExtensionEvents(ClientPtr   /* client */
     );
 
 void SRepXGetSelectedExtensionEvents(ClientPtr /* client */ ,
-				     int /* size */ ,
+                                     int /* size */ ,
-				     xGetSelectedExtensionEventsReply *	/* rep */
+                                     xGetSelectedExtensionEventsReply * /* rep */
     );
 
-#endif /* GETSELEV_H */
+#endif                          /* GETSELEV_H */

Xi/getvers.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -95,8 +95,8 @@ ProcXGetExtensionVersion(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
 
     if (stuff->length != bytes_to_int32(sizeof(xGetExtensionVersionReq) +
-			  stuff->nbytes))
+                                        stuff->nbytes))
-	return BadLength;
+        return BadLength;
 
     memset(&rep, 0, sizeof(xGetExtensionVersionReply));
     rep.repType = X_Reply;
@@ -121,11 +121,11 @@ ProcXGetExtensionVersion(ClientPtr client)
 
 void
 SRepXGetExtensionVersion(ClientPtr client, int size,
-			 xGetExtensionVersionReply * rep)
+                         xGetExtensionVersionReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
     swaps(&rep->major_version);
     swaps(&rep->minor_version);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/getvers.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETVERS_H
 #define GETVERS_H 1
 
-int SProcXGetExtensionVersion(ClientPtr	/* client */
+int SProcXGetExtensionVersion(ClientPtr /* client */
     );
 
-int ProcXGetExtensionVersion(ClientPtr	/* client */
+int ProcXGetExtensionVersion(ClientPtr  /* client */
     );
 
 void SRepXGetExtensionVersion(ClientPtr /* client */ ,
-			      int /* size */ ,
+                              int /* size */ ,
-			      xGetExtensionVersionReply *	/* rep */
+                              xGetExtensionVersionReply *       /* rep */
     );
 
-#endif /* GETVERS_H */
+#endif                          /* GETVERS_H */

Xi/grabdev.c

@@ -54,12 +54,12 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exglobals.h"
-#include "dixevents.h"	/* GrabDevice */
+#include "dixevents.h"          /* GrabDevice */
 
 #include "grabdev.h"
 
@@ -82,8 +82,9 @@ SProcXGrabDevice(ClientPtr client)
     swapl(&stuff->time);
     swaps(&stuff->event_count);
 
-    if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
+    if (stuff->length !=
-       return BadLength;
+        bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
+        return BadLength;
 
     SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
 
@@ -108,8 +109,9 @@ ProcXGrabDevice(ClientPtr client)
     REQUEST(xGrabDeviceReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
 
-    if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
+    if (stuff->length !=
-	return BadLength;
+        bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
+        return BadLength;
 
     rep.repType = X_Reply;
     rep.RepType = X_GrabDevice;
@@ -118,23 +120,22 @@ ProcXGrabDevice(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
+    if ((rc = CreateMaskFromList(client, (XEventClass *) &stuff[1],
-				 stuff->event_count, tmp, dev,
+                                 stuff->event_count, tmp, dev,
-				 X_GrabDevice)) != Success)
+                                 X_GrabDevice)) != Success)
-	return rc;
+        return rc;
 
     mask.xi = tmp[stuff->deviceid].mask;
 
     rc = GrabDevice(client, dev, stuff->other_devices_mode,
                     stuff->this_device_mode, stuff->grabWindow,
-		    stuff->ownerEvents, stuff->time,
+                    stuff->ownerEvents, stuff->time,
-		    &mask, XI, None, None,
+                    &mask, XI, None, None, &rep.status);
-		    &rep.status);
 
     if (rc != Success)
-	return rc;
+        return rc;
 
     WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
     return Success;
@@ -166,34 +167,34 @@ ProcXGrabDevice(ClientPtr client)
 
 int
 CreateMaskFromList(ClientPtr client, XEventClass * list, int count,
-		   struct tmask *mask, DeviceIntPtr dev, int req)
+                   struct tmask *mask, DeviceIntPtr dev, int req)
 {
     int rc, i, j;
     int device;
     DeviceIntPtr tdev;
 
     for (i = 0; i < EMASKSIZE; i++) {
-	mask[i].mask = 0;
+        mask[i].mask = 0;
-	mask[i].dev = NULL;
+        mask[i].dev = NULL;
     }
 
     for (i = 0; i < count; i++, list++) {
-	device = *list >> 8;
+        device = *list >> 8;
-	if (device > 255)
+        if (device > 255)
-	    return BadClass;
+            return BadClass;
 
-	rc = dixLookupDevice(&tdev, device, client, DixUseAccess);
+        rc = dixLookupDevice(&tdev, device, client, DixUseAccess);
-	if (rc != BadDevice && rc != Success)
+        if (rc != BadDevice && rc != Success)
-	    return rc;
+            return rc;
-	if (rc == BadDevice || (dev != NULL && tdev != dev))
+        if (rc == BadDevice || (dev != NULL && tdev != dev))
-	    return BadClass;
+            return BadClass;
 
-	for (j = 0; j < ExtEventIndex; j++)
+        for (j = 0; j < ExtEventIndex; j++)
-	    if (EventInfo[j].type == (*list & 0xff)) {
+            if (EventInfo[j].type == (*list & 0xff)) {
-		mask[device].mask |= EventInfo[j].mask;
+                mask[device].mask |= EventInfo[j].mask;
-		mask[device].dev = (Pointer) tdev;
+                mask[device].dev = (Pointer) tdev;
-		break;
+                break;
-	    }
+            }
     }
     return Success;
 }
@@ -210,5 +211,5 @@ SRepXGrabDevice(ClientPtr client, int size, xGrabDeviceReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/grabdev.h

@@ -30,23 +30,23 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GRABDEV_H
 #define GRABDEV_H 1
 
-int SProcXGrabDevice(ClientPtr	/* client */
+int SProcXGrabDevice(ClientPtr  /* client */
     );
 
-int ProcXGrabDevice(ClientPtr	/* client */
+int ProcXGrabDevice(ClientPtr   /* client */
     );
 
 int CreateMaskFromList(ClientPtr /* client */ ,
-		       XEventClass * /* list */ ,
+                       XEventClass * /* list */ ,
-		       int /* count */ ,
+                       int /* count */ ,
-		       struct tmask /* mask */ [],
+                       struct tmask /* mask */ [],
-		       DeviceIntPtr /* dev */ ,
+                       DeviceIntPtr /* dev */ ,
-		       int	/* req */
+                       int      /* req */
     );
 
 void SRepXGrabDevice(ClientPtr /* client */ ,
-		     int /* size */ ,
+                     int /* size */ ,
-		     xGrabDeviceReply *	/* rep */
+                     xGrabDeviceReply * /* rep */
     );
 
-#endif /* GRABDEV_H */
+#endif                          /* GRABDEV_H */

Xi/grabdevb.c

@@ -54,8 +54,8 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -81,7 +81,7 @@ SProcXGrabDeviceButton(ClientPtr client)
     swaps(&stuff->modifiers);
     swaps(&stuff->event_count);
     REQUEST_FIXED_SIZE(xGrabDeviceButtonReq,
-                      stuff->event_count * sizeof(CARD32));
+                       stuff->event_count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
 
     return (ProcXGrabDeviceButton(client));
@@ -108,33 +108,34 @@ ProcXGrabDeviceButton(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
 
     if (stuff->length !=
-	bytes_to_int32(sizeof(xGrabDeviceButtonReq)) + stuff->event_count)
+        bytes_to_int32(sizeof(xGrabDeviceButtonReq)) + stuff->event_count)
-	return BadLength;
+        return BadLength;
 
     ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess);
     if (ret != Success)
-	return ret;
+        return ret;
 
     if (stuff->modifier_device != UseXKeyboard) {
-	ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
+        ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
-			      DixUseAccess);
+                              DixUseAccess);
-	if (ret != Success)
+        if (ret != Success)
-	    return ret;
+            return ret;
-	if (mdev->key == NULL)
+        if (mdev->key == NULL)
-	    return BadMatch;
+            return BadMatch;
-    } else {
+    }
-	mdev = PickKeyboard(client);
+    else {
-	ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
+        mdev = PickKeyboard(client);
-	if (ret != Success)
+        ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
-	    return ret;
+        if (ret != Success)
+            return ret;
     }
 
-    class = (XEventClass *) (&stuff[1]);	/* first word of values */
+    class = (XEventClass *) (&stuff[1]);        /* first word of values */
 
     if ((ret = CreateMaskFromList(client, class,
-				  stuff->event_count, tmp, dev,
+                                  stuff->event_count, tmp, dev,
-				  X_GrabDeviceButton)) != Success)
+                                  X_GrabDeviceButton)) != Success)
-	return ret;
+        return ret;
 
     memset(&param, 0, sizeof(param));
     param.grabtype = XI;
@@ -145,8 +146,7 @@ ProcXGrabDeviceButton(ClientPtr client)
     param.modifiers = stuff->modifiers;
     mask.xi = tmp[stuff->grabbed_device].mask;
 
-    ret = GrabButton(client, dev, mdev, stuff->button, &param,
+    ret = GrabButton(client, dev, mdev, stuff->button, &param, XI, &mask);
-                     XI, &mask);
 
     return ret;
 }

Xi/grabdevb.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GRABDEVB_H
 #define GRABDEVB_H 1
 
-int SProcXGrabDeviceButton(ClientPtr	/* client */
+int SProcXGrabDeviceButton(ClientPtr    /* client */
     );
 
-int ProcXGrabDeviceButton(ClientPtr	/* client */
+int ProcXGrabDeviceButton(ClientPtr     /* client */
     );
 
-#endif /* GRABDEVB_H */
+#endif                          /* GRABDEVB_H */

Xi/grabdevk.c

@@ -54,8 +54,8 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -105,34 +105,35 @@ ProcXGrabDeviceKey(ClientPtr client)
     REQUEST(xGrabDeviceKeyReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
 
-    if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceKeyReq)) + stuff->event_count)
+    if (stuff->length !=
-	return BadLength;
+        bytes_to_int32(sizeof(xGrabDeviceKeyReq)) + stuff->event_count)
+        return BadLength;
 
     ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess);
     if (ret != Success)
-	return ret;
+        return ret;
 
     if (stuff->modifier_device != UseXKeyboard) {
-	ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
+        ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
-			      DixUseAccess);
+                              DixUseAccess);
-	if (ret != Success)
+        if (ret != Success)
-	    return ret;
+            return ret;
-	if (mdev->key == NULL)
+        if (mdev->key == NULL)
-	    return BadMatch;
+            return BadMatch;
-    } else {
+    }
-	mdev = PickKeyboard(client);
+    else {
-	ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
+        mdev = PickKeyboard(client);
-	if (ret != Success)
+        ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
-	    return ret;
+        if (ret != Success)
+            return ret;
     }
 
-    class = (XEventClass *) (&stuff[1]);	/* first word of values */
+    class = (XEventClass *) (&stuff[1]);        /* first word of values */
 
     if ((ret = CreateMaskFromList(client, class,
-				  stuff->event_count, tmp, dev,
+                                  stuff->event_count, tmp, dev,
-				  X_GrabDeviceKey)) != Success)
+                                  X_GrabDeviceKey)) != Success)
-	return ret;
+        return ret;
-
 
     memset(&param, 0, sizeof(param));
     param.grabtype = XI;

Xi/grabdevk.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GRABDEVK_H
 #define GRABDEVK_H 1
 
-int SProcXGrabDeviceKey(ClientPtr	/* client */
+int SProcXGrabDeviceKey(ClientPtr       /* client */
     );
 
-int ProcXGrabDeviceKey(ClientPtr	/* client */
+int ProcXGrabDeviceKey(ClientPtr        /* client */
     );
 
-#endif /* GRABDEVK_H */
+#endif                          /* GRABDEVK_H */

Xi/gtmotion.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -103,51 +103,51 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
     v = dev->valuator;
     if (v == NULL || v->numAxes == 0)
-	return BadMatch;
+        return BadMatch;
     if (dev->valuator->motionHintWindow)
-	MaybeStopDeviceHint(dev, client);
+        MaybeStopDeviceHint(dev, client);
     axes = v->numAxes;
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceMotionEvents;
     rep.sequenceNumber = client->sequence;
     rep.nEvents = 0;
     rep.axes = axes;
-    rep.mode = Absolute; /* XXX we don't do relative at the moment */
+    rep.mode = Absolute;        /* XXX we don't do relative at the moment */
     rep.length = 0;
     start = ClientTimeToServerTime(stuff->start);
     stop = ClientTimeToServerTime(stuff->stop);
     if (CompareTimeStamps(start, stop) == LATER ||
-	CompareTimeStamps(start, currentTime) == LATER) {
+        CompareTimeStamps(start, currentTime) == LATER) {
-	WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
+        WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
-	return Success;
+        return Success;
     }
     if (CompareTimeStamps(stop, currentTime) == LATER)
-	stop = currentTime;
+        stop = currentTime;
     num_events = v->numMotionEvents;
     if (num_events) {
         size = sizeof(Time) + (axes * sizeof(INT32));
-	rep.nEvents = GetMotionHistory(dev, (xTimecoord **) &coords,/* XXX */
+        rep.nEvents = GetMotionHistory(dev, (xTimecoord **) & coords,   /* XXX */
-					start.milliseconds, stop.milliseconds,
+                                       start.milliseconds, stop.milliseconds,
-					(ScreenPtr) NULL, FALSE);
+                                       (ScreenPtr) NULL, FALSE);
     }
     if (rep.nEvents > 0) {
-	length = bytes_to_int32(rep.nEvents * size);
+        length = bytes_to_int32(rep.nEvents * size);
-	rep.length = length;
+        rep.length = length;
     }
     nEvents = rep.nEvents;
     WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
     if (nEvents) {
-	if (client->swapped) {
+        if (client->swapped) {
-	    bufptr = coords;
+            bufptr = coords;
-	    for (i = 0; i < nEvents * (axes + 1); i++) {
+            for (i = 0; i < nEvents * (axes + 1); i++) {
-		swapl(bufptr);
+                swapl(bufptr);
-		bufptr++;
+                bufptr++;
-	    }
+            }
-	}
+        }
-	WriteToClient(client, length * 4, (char *)coords);
+        WriteToClient(client, length * 4, (char *) coords);
     }
     free(coords);
     return Success;
@@ -162,10 +162,10 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
 
 void
 SRepXGetDeviceMotionEvents(ClientPtr client, int size,
-			   xGetDeviceMotionEventsReply * rep)
+                           xGetDeviceMotionEventsReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
     swapl(&rep->nEvents);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/gtmotion.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GTMOTION_H
 #define GTMOTION_H 1
 
-int SProcXGetDeviceMotionEvents(ClientPtr	/* client */
+int SProcXGetDeviceMotionEvents(ClientPtr       /* client */
     );
 
-int ProcXGetDeviceMotionEvents(ClientPtr	/* client */
+int ProcXGetDeviceMotionEvents(ClientPtr        /* client */
     );
 
 void SRepXGetDeviceMotionEvents(ClientPtr /* client */ ,
-				int /* size */ ,
+                                int /* size */ ,
-				xGetDeviceMotionEventsReply *	/* rep */
+                                xGetDeviceMotionEventsReply *   /* rep */
     );
 
-#endif /* GTMOTION_H */
+#endif                          /* GTMOTION_H */

Xi/listdev.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/X.h>              /* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
+#include <X11/Xproto.h>         /* Request macro     */
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
@@ -68,7 +68,6 @@ SOFTWARE.
 
 #include "listdev.h"
 
-
 /***********************************************************************
  *
  * This procedure lists the input devices available to the server.
@@ -97,15 +96,15 @@ SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
 
     *namesize += 1;
     if (d->name)
-	*namesize += strlen(d->name);
+        *namesize += strlen(d->name);
     if (d->key != NULL)
-	*size += sizeof(xKeyInfo);
+        *size += sizeof(xKeyInfo);
     if (d->button != NULL)
-	*size += sizeof(xButtonInfo);
+        *size += sizeof(xButtonInfo);
     if (d->valuator != NULL) {
-	chunks = ((int)d->valuator->numAxes + 19) / VPC;
+        chunks = ((int) d->valuator->numAxes + 19) / VPC;
-	*size += (chunks * sizeof(xValuatorInfo) +
+        *size += (chunks * sizeof(xValuatorInfo) +
-		  d->valuator->numAxes * sizeof(xAxisInfo));
+                  d->valuator->numAxes * sizeof(xAxisInfo));
     }
 }
 
@@ -122,15 +121,16 @@ SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
 static void
 CopyDeviceName(char **namebuf, char *name)
 {
-    char *nameptr = (char *)*namebuf;
+    char *nameptr = (char *) *namebuf;
 
     if (name) {
-	*nameptr++ = strlen(name);
+        *nameptr++ = strlen(name);
-	strcpy(nameptr, name);
+        strcpy(nameptr, name);
-	*namebuf += (strlen(name) + 1);
+        *namebuf += (strlen(name) + 1);
-    } else {
+    }
-	*nameptr++ = 0;
+    else {
-	*namebuf += 1;
+        *nameptr++ = 0;
+        *namebuf += 1;
     }
 }
 
@@ -150,7 +150,7 @@ CopySwapButtonClass(ClientPtr client, ButtonClassPtr b, char **buf)
     b2->length = sizeof(xButtonInfo);
     b2->num_buttons = b->numButtons;
     if (client && client->swapped) {
-	swaps(&b2->num_buttons);
+        swaps(&b2->num_buttons);
     }
     *buf += sizeof(xButtonInfo);
 }
@@ -162,8 +162,7 @@ CopySwapButtonClass(ClientPtr client, ButtonClassPtr b, char **buf)
  */
 
 static void
-CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes,
+CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes, char **buf)
-	       char **buf)
 {
     xDeviceInfoPtr dev;
 
@@ -173,18 +172,18 @@ CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes,
     dev->type = d->xinput_type;
     dev->num_classes = num_classes;
     if (IsMaster(d) && IsKeyboardDevice(d))
-	dev->use = IsXKeyboard;
+        dev->use = IsXKeyboard;
     else if (IsMaster(d) && IsPointerDevice(d))
-	dev->use = IsXPointer;
+        dev->use = IsXPointer;
     else if (d->valuator && d->button)
         dev->use = IsXExtensionPointer;
     else if (d->key && d->kbdfeed)
         dev->use = IsXExtensionKeyboard;
     else
-	dev->use = IsXExtensionDevice;
+        dev->use = IsXExtensionDevice;
 
     if (client->swapped) {
-	swapl(&dev->type);
+        swapl(&dev->type);
     }
     *buf += sizeof(xDeviceInfo);
 }
@@ -207,7 +206,7 @@ CopySwapKeyClass(ClientPtr client, KeyClassPtr k, char **buf)
     k2->max_keycode = k->xkbInfo->desc->max_key_code;
     k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
     if (client && client->swapped) {
-	swaps(&k2->num_keys);
+        swaps(&k2->num_keys);
     }
     *buf += sizeof(xKeyInfo);
 }
@@ -234,54 +233,53 @@ CopySwapValuatorClass(ClientPtr client, DeviceIntPtr dev, char **buf)
     xAxisInfoPtr a2;
 
     for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC);
-	 i++, axes -= VPC) {
+         i++, axes -= VPC) {
-	t_axes = axes < VPC ? axes : VPC;
+        t_axes = axes < VPC ? axes : VPC;
-	if (t_axes < 0)
+        if (t_axes < 0)
-	    t_axes = v->numAxes % VPC;
+            t_axes = v->numAxes % VPC;
-	v2 = (xValuatorInfoPtr) * buf;
+        v2 = (xValuatorInfoPtr) * buf;
-	v2->class = ValuatorClass;
+        v2->class = ValuatorClass;
-	v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
+        v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
-	v2->num_axes = t_axes;
+        v2->num_axes = t_axes;
-	v2->mode = valuator_get_mode(dev, 0);
+        v2->mode = valuator_get_mode(dev, 0);
-	v2->motion_buffer_size = v->numMotionEvents;
+        v2->motion_buffer_size = v->numMotionEvents;
-	if (client && client->swapped) {
+        if (client && client->swapped) {
-	    swapl(&v2->motion_buffer_size);
+            swapl(&v2->motion_buffer_size);
-	}
+        }
-	*buf += sizeof(xValuatorInfo);
+        *buf += sizeof(xValuatorInfo);
-	a = v->axes + (VPC * i);
+        a = v->axes + (VPC * i);
-	a2 = (xAxisInfoPtr) * buf;
+        a2 = (xAxisInfoPtr) * buf;
-	for (j = 0; j < t_axes; j++) {
+        for (j = 0; j < t_axes; j++) {
-	    a2->min_value = a->min_value;
+            a2->min_value = a->min_value;
-	    a2->max_value = a->max_value;
+            a2->max_value = a->max_value;
-	    a2->resolution = a->resolution;
+            a2->resolution = a->resolution;
-	    if (client && client->swapped) {
+            if (client && client->swapped) {
-		swapl(&a2->min_value);
+                swapl(&a2->min_value);
-		swapl(&a2->max_value);
+                swapl(&a2->max_value);
-		swapl(&a2->resolution);
+                swapl(&a2->resolution);
-	    }
+            }
-	    a2++;
+            a2++;
-	    a++;
+            a++;
-	    *buf += sizeof(xAxisInfo);
+            *buf += sizeof(xAxisInfo);
-	}
+        }
     }
     return i;
 }
 
 static void
 CopySwapClasses(ClientPtr client, DeviceIntPtr dev, CARD8 *num_classes,
-                char** classbuf)
+                char **classbuf)
 {
     if (dev->key != NULL) {
-	CopySwapKeyClass(client, dev->key, classbuf);
+        CopySwapKeyClass(client, dev->key, classbuf);
-	(*num_classes)++;
+        (*num_classes)++;
     }
     if (dev->button != NULL) {
-	CopySwapButtonClass(client, dev->button, classbuf);
+        CopySwapButtonClass(client, dev->button, classbuf);
-	(*num_classes)++;
+        (*num_classes)++;
     }
     if (dev->valuator != NULL) {
-	(*num_classes) +=
+        (*num_classes) += CopySwapValuatorClass(client, dev, classbuf);
-	    CopySwapValuatorClass(client, dev, classbuf);
     }
 }
 
@@ -293,7 +291,7 @@ CopySwapClasses(ClientPtr client, DeviceIntPtr dev, CARD8 *num_classes,
 
 static void
 ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev,
-	       char **devbuf, char **classbuf, char **namebuf)
+               char **devbuf, char **classbuf, char **namebuf)
 {
     CopyDeviceName(namebuf, d->name);
     CopySwapDevice(client, d, 0, devbuf);
@@ -310,16 +308,15 @@ static Bool
 ShouldSkipDevice(ClientPtr client, DeviceIntPtr d)
 {
     /* don't send master devices other than VCP/VCK */
-    if (!IsMaster(d) || d == inputInfo.pointer || d == inputInfo.keyboard)
+    if (!IsMaster(d) || d == inputInfo.pointer ||d == inputInfo.keyboard) {
-    {
         int rc = XaceHook(XACE_DEVICE_ACCESS, client, d, DixGetAttrAccess);
+
         if (rc == Success)
             return FALSE;
     }
     return TRUE;
 }
 
-
 /***********************************************************************
  *
  * This procedure lists the input devices available to the server.
@@ -335,7 +332,7 @@ ProcXListInputDevices(ClientPtr client)
 {
     xListInputDevicesReply rep;
     int numdevs = 0;
-    int namesize = 1;	/* need 1 extra byte for strcpy */
+    int namesize = 1;           /* need 1 extra byte for strcpy */
     int i = 0, size = 0;
     int total_length;
     char *devbuf, *classbuf, *namebuf, *savbuf;
@@ -378,7 +375,7 @@ ProcXListInputDevices(ClientPtr client)
 
     /* allocate space for reply */
     total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
-    devbuf = (char *)calloc(1, total_length);
+    devbuf = (char *) calloc(1, total_length);
     classbuf = devbuf + (numdevs * sizeof(xDeviceInfo));
     namebuf = classbuf + size;
     savbuf = devbuf;
@@ -420,5 +417,5 @@ SRepXListInputDevices(ClientPtr client, int size, xListInputDevicesReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/listdev.h

@@ -30,17 +30,17 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef LISTDEV_H
 #define LISTDEV_H 1
 
-#define VPC	20	/* Max # valuators per chunk */
+#define VPC	20              /* Max # valuators per chunk */
 
-int SProcXListInputDevices(ClientPtr	/* client */
+int SProcXListInputDevices(ClientPtr    /* client */
     );
 
-int ProcXListInputDevices(ClientPtr	/* client */
+int ProcXListInputDevices(ClientPtr     /* client */
     );
 
 void SRepXListInputDevices(ClientPtr /* client */ ,
-			   int /* size */ ,
+                           int /* size */ ,
-			   xListInputDevicesReply *	/* rep */
+                           xListInputDevicesReply *     /* rep */
     );
 
-#endif /* LISTDEV_H */
+#endif                          /* LISTDEV_H */

Xi/opendev.c

@@ -54,11 +54,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include "exglobals.h"
 #include "exevents.h"
 
@@ -102,55 +102,56 @@ ProcXOpenDevice(ClientPtr client)
     status = dixLookupDevice(&dev, stuff->deviceid, client, DixUseAccess);
 
     if (status == BadDevice) {  /* not open */
-	for (dev = inputInfo.off_devices; dev; dev = dev->next)
+        for (dev = inputInfo.off_devices; dev; dev = dev->next)
-	    if (dev->id == stuff->deviceid)
+            if (dev->id == stuff->deviceid)
-		break;
+                break;
-	if (dev == NULL)
+        if (dev == NULL)
-	    return BadDevice;
+            return BadDevice;
-    } else if (status != Success)
+    }
-	return status;
+    else if (status != Success)
+        return status;
 
     if (IsMaster(dev))
-            return BadDevice;
+        return BadDevice;
 
     if (status != Success)
-	return status;
+        return status;
 
     memset(&rep, 0, sizeof(xOpenDeviceReply));
     rep.repType = X_Reply;
     rep.RepType = X_OpenDevice;
     rep.sequenceNumber = client->sequence;
     if (dev->key != NULL) {
-	evbase[j].class = KeyClass;
+        evbase[j].class = KeyClass;
-	evbase[j++].event_type_base = event_base[KeyClass];
+        evbase[j++].event_type_base = event_base[KeyClass];
     }
     if (dev->button != NULL) {
-	evbase[j].class = ButtonClass;
+        evbase[j].class = ButtonClass;
-	evbase[j++].event_type_base = event_base[ButtonClass];
+        evbase[j++].event_type_base = event_base[ButtonClass];
     }
     if (dev->valuator != NULL) {
-	evbase[j].class = ValuatorClass;
+        evbase[j].class = ValuatorClass;
-	evbase[j++].event_type_base = event_base[ValuatorClass];
+        evbase[j++].event_type_base = event_base[ValuatorClass];
     }
     if (dev->kbdfeed != NULL || dev->ptrfeed != NULL || dev->leds != NULL ||
-	dev->intfeed != NULL || dev->bell != NULL || dev->stringfeed != NULL) {
+        dev->intfeed != NULL || dev->bell != NULL || dev->stringfeed != NULL) {
-	evbase[j].class = FeedbackClass;
+        evbase[j].class = FeedbackClass;
-	evbase[j++].event_type_base = event_base[FeedbackClass];
+        evbase[j++].event_type_base = event_base[FeedbackClass];
     }
     if (dev->focus != NULL) {
-	evbase[j].class = FocusClass;
+        evbase[j].class = FocusClass;
-	evbase[j++].event_type_base = event_base[FocusClass];
+        evbase[j++].event_type_base = event_base[FocusClass];
     }
     if (dev->proximity != NULL) {
-	evbase[j].class = ProximityClass;
+        evbase[j].class = ProximityClass;
-	evbase[j++].event_type_base = event_base[ProximityClass];
+        evbase[j++].event_type_base = event_base[ProximityClass];
     }
     evbase[j].class = OtherClass;
     evbase[j++].event_type_base = event_base[OtherClass];
     rep.length = bytes_to_int32(j * sizeof(xInputClassInfo));
     rep.num_classes = j;
     WriteReplyToClient(client, sizeof(xOpenDeviceReply), &rep);
-    WriteToClient(client, j * sizeof(xInputClassInfo), (char *)evbase);
+    WriteToClient(client, j * sizeof(xInputClassInfo), (char *) evbase);
     return Success;
 }
 
@@ -166,5 +167,5 @@ SRepXOpenDevice(ClientPtr client, int size, xOpenDeviceReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/opendev.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef OPENDEV_H
 #define OPENDEV_H 1
 
-int SProcXOpenDevice(ClientPtr	/* client */
+int SProcXOpenDevice(ClientPtr  /* client */
     );
 
-int ProcXOpenDevice(ClientPtr	/* client */
+int ProcXOpenDevice(ClientPtr   /* client */
     );
 
 void SRepXOpenDevice(ClientPtr /* client */ ,
-		     int /* size */ ,
+                     int /* size */ ,
-		     xOpenDeviceReply *	/* rep */
+                     xOpenDeviceReply * /* rep */
     );
 
-#endif /* OPENDEV_H */
+#endif                          /* OPENDEV_H */

Xi/queryst.c

@@ -36,8 +36,8 @@ from The Open Group.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -94,79 +94,80 @@ ProcXQueryDeviceState(ClientPtr client)
 
     rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess);
     if (rc != Success && rc != BadAccess)
-	return rc;
+        return rc;
 
     v = dev->valuator;
     if (v != NULL && v->motionHintWindow != NULL)
-	MaybeStopDeviceHint(dev, client);
+        MaybeStopDeviceHint(dev, client);
 
     k = dev->key;
     if (k != NULL) {
-	total_length += sizeof(xKeyState);
+        total_length += sizeof(xKeyState);
-	num_classes++;
+        num_classes++;
     }
 
     b = dev->button;
     if (b != NULL) {
-	total_length += sizeof(xButtonState);
+        total_length += sizeof(xButtonState);
-	num_classes++;
+        num_classes++;
     }
 
     if (v != NULL) {
-	total_length += (sizeof(xValuatorState) + (v->numAxes * sizeof(int)));
+        total_length += (sizeof(xValuatorState) + (v->numAxes * sizeof(int)));
-	num_classes++;
+        num_classes++;
     }
-    buf = (char *)calloc(total_length, 1);
+    buf = (char *) calloc(total_length, 1);
     if (!buf)
-	return BadAlloc;
+        return BadAlloc;
     savbuf = buf;
 
     if (k != NULL) {
-	tk = (xKeyState *) buf;
+        tk = (xKeyState *) buf;
-	tk->class = KeyClass;
+        tk->class = KeyClass;
-	tk->length = sizeof(xKeyState);
+        tk->length = sizeof(xKeyState);
-	tk->num_keys = k->xkbInfo->desc->max_key_code -
+        tk->num_keys = k->xkbInfo->desc->max_key_code -
-                       k->xkbInfo->desc->min_key_code + 1;
+            k->xkbInfo->desc->min_key_code + 1;
-	if (rc != BadAccess)
+        if (rc != BadAccess)
-	    for (i = 0; i < 32; i++)
+            for (i = 0; i < 32; i++)
-		tk->keys[i] = k->down[i];
+                tk->keys[i] = k->down[i];
-	buf += sizeof(xKeyState);
+        buf += sizeof(xKeyState);
     }
 
     if (b != NULL) {
-	tb = (xButtonState *) buf;
+        tb = (xButtonState *) buf;
-	tb->class = ButtonClass;
+        tb->class = ButtonClass;
-	tb->length = sizeof(xButtonState);
+        tb->length = sizeof(xButtonState);
-	tb->num_buttons = b->numButtons;
+        tb->num_buttons = b->numButtons;
-	if (rc != BadAccess)
+        if (rc != BadAccess)
-	    memcpy(tb->buttons, b->down, sizeof(b->down));
+            memcpy(tb->buttons, b->down, sizeof(b->down));
-	buf += sizeof(xButtonState);
+        buf += sizeof(xButtonState);
     }
 
     if (v != NULL) {
-	tv = (xValuatorState *) buf;
+        tv = (xValuatorState *) buf;
-	tv->class = ValuatorClass;
+        tv->class = ValuatorClass;
-	tv->length = sizeof(xValuatorState) + v->numAxes * 4;
+        tv->length = sizeof(xValuatorState) + v->numAxes * 4;
-	tv->num_valuators = v->numAxes;
+        tv->num_valuators = v->numAxes;
-	tv->mode = valuator_get_mode(dev, 0);
+        tv->mode = valuator_get_mode(dev, 0);
-	tv->mode |= (dev->proximity && !dev->proximity->in_proximity) ? OutOfProximity : 0;
+        tv->mode |= (dev->proximity &&
-	buf += sizeof(xValuatorState);
+                     !dev->proximity->in_proximity) ? OutOfProximity : 0;
-	for (i = 0, values = v->axisVal; i < v->numAxes; i++) {
+        buf += sizeof(xValuatorState);
-	    if (rc != BadAccess)
+        for (i = 0, values = v->axisVal; i < v->numAxes; i++) {
-		*((int *)buf) = *values;
+            if (rc != BadAccess)
-	    values++;
+                *((int *) buf) = *values;
-	    if (client->swapped) {
+            values++;
-		swapl((int *)buf);
+            if (client->swapped) {
-	    }
+                swapl((int *) buf);
-	    buf += sizeof(int);
+            }
-	}
+            buf += sizeof(int);
+        }
     }
 
     rep.num_classes = num_classes;
     rep.length = bytes_to_int32(total_length);
     WriteReplyToClient(client, sizeof(xQueryDeviceStateReply), &rep);
     if (total_length > 0)
-	WriteToClient(client, total_length, savbuf);
+        WriteToClient(client, total_length, savbuf);
     free(savbuf);
     return Success;
 }
@@ -183,5 +184,5 @@ SRepXQueryDeviceState(ClientPtr client, int size, xQueryDeviceStateReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/queryst.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef QUERYST_H
 #define QUERYST_H 1
 
-int SProcXQueryDeviceState(ClientPtr	/* client */
+int SProcXQueryDeviceState(ClientPtr    /* client */
     );
 
-int ProcXQueryDeviceState(ClientPtr	/* client */
+int ProcXQueryDeviceState(ClientPtr     /* client */
     );
 
 void SRepXQueryDeviceState(ClientPtr /* client */ ,
-			   int /* size */ ,
+                           int /* size */ ,
-			   xQueryDeviceStateReply *	/* rep */
+                           xQueryDeviceStateReply *     /* rep */
     );
 
-#endif /* QUERYST_H */
+#endif                          /* QUERYST_H */

Xi/selectev.c

@@ -50,13 +50,12 @@ SOFTWARE.
  *
  */
 
-
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* window structure  */
+#include "windowstr.h"          /* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XI2.h>
 #include <X11/extensions/XIproto.h>
@@ -70,7 +69,7 @@ extern Mask ExtExclusiveMasks[];
 
 static int
 HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
-                         XEventClass *cls, CARD16 *count)
+                         XEventClass * cls, CARD16 *count)
 {
     int i, j;
     Mask mask;
@@ -106,7 +105,7 @@ HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
 
     /* We always only use mksidx = AllDevices for events not bound to
      * devices */
-    if (AddExtensionClient (win, client, mask, XIAllDevices) != Success)
+    if (AddExtensionClient(win, client, mask, XIAllDevices) != Success)
         return BadAlloc;
 
     RecalculateDeviceDeliverableEvents(win);
@@ -128,8 +127,7 @@ SProcXSelectExtensionEvent(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
     swapl(&stuff->window);
     swaps(&stuff->count);
-    REQUEST_FIXED_SIZE(xSelectExtensionEventReq,
+    REQUEST_FIXED_SIZE(xSelectExtensionEventReq, stuff->count * sizeof(CARD32));
-                      stuff->count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
 
     return (ProcXSelectExtensionEvent(client));
@@ -152,33 +150,34 @@ ProcXSelectExtensionEvent(ClientPtr client)
     REQUEST(xSelectExtensionEventReq);
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
 
-    if (stuff->length != bytes_to_int32(sizeof(xSelectExtensionEventReq)) + stuff->count)
+    if (stuff->length !=
-	return BadLength;
+        bytes_to_int32(sizeof(xSelectExtensionEventReq)) + stuff->count)
+        return BadLength;
 
     ret = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
     if (ret != Success)
-	return ret;
+        return ret;
 
-    if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
+    if (HandleDevicePresenceMask(client, pWin, (XEventClass *) &stuff[1],
-                                &stuff->count) != Success)
+                                 &stuff->count) != Success)
-	return BadAlloc;
+        return BadAlloc;
 
-    if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
+    if ((ret = CreateMaskFromList(client, (XEventClass *) &stuff[1],
-				  stuff->count, tmp, NULL,
+                                  stuff->count, tmp, NULL,
-				  X_SelectExtensionEvent)) != Success)
+                                  X_SelectExtensionEvent)) != Success)
-	return ret;
+        return ret;
 
     for (i = 0; i < EMASKSIZE; i++)
-	if (tmp[i].dev != NULL) {
+        if (tmp[i].dev != NULL) {
             if (tmp[i].mask & ~XIAllMasks) {
                 client->errorValue = tmp[i].mask;
                 return BadValue;
             }
-	    if ((ret =
+            if ((ret =
-		 SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
+                 SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
-				 tmp[i].mask, ExtExclusiveMasks[i]))!= Success)
+                                 tmp[i].mask, ExtExclusiveMasks[i])) != Success)
-		return ret;
+                return ret;
-	}
+        }
 
     return Success;
 }

Xi/selectev.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SELECTEV_H
 #define SELECTEV_H 1
 
-int SProcXSelectExtensionEvent(ClientPtr	/* client */
+int SProcXSelectExtensionEvent(ClientPtr        /* client */
     );
 
-int ProcXSelectExtensionEvent(ClientPtr	/* client */
+int ProcXSelectExtensionEvent(ClientPtr /* client */
     );
 
-#endif /* SELECTEV_H */
+#endif                          /* SELECTEV_H */

Xi/sendexev.c

@@ -54,9 +54,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
-#include "windowstr.h"	/* Window            */
+#include "windowstr.h"          /* Window            */
-#include "extnsionst.h" /* EventSwapPtr      */
+#include "extnsionst.h"         /* EventSwapPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -65,7 +65,7 @@ SOFTWARE.
 #include "grabdev.h"
 #include "sendexev.h"
 
-extern int lastEvent;	/* Defined in extension.c */
+extern int lastEvent;           /* Defined in extension.c */
 
 /***********************************************************************
  *
@@ -88,20 +88,21 @@ SProcXSendExtensionEvent(ClientPtr client)
     swapl(&stuff->destination);
     swaps(&stuff->count);
 
-    if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
+    if (stuff->length !=
-       bytes_to_int32(stuff->num_events * sizeof(xEvent)))
+        bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
-       return BadLength;
+        bytes_to_int32(stuff->num_events * sizeof(xEvent)))
+        return BadLength;
 
-    eventP = (xEvent *) & stuff[1];
+    eventP = (xEvent *) &stuff[1];
     for (i = 0; i < stuff->num_events; i++, eventP++) {
-	proc = EventSwapVector[eventP->u.u.type & 0177];
+        proc = EventSwapVector[eventP->u.u.type & 0177];
-	if (proc == NotImplemented)	/* no swapping proc; invalid event type? */
+        if (proc == NotImplemented)     /* no swapping proc; invalid event type? */
-	    return BadValue;
+            return BadValue;
-	(*proc) (eventP, &eventT);
+        (*proc) (eventP, &eventT);
-	*eventP = eventT;
+        *eventP = eventT;
     }
 
-    p = (CARD32 *)(((xEvent *) & stuff[1]) + stuff->num_events);
+    p = (CARD32 *) (((xEvent *) &stuff[1]) + stuff->num_events);
     SwapLongs(p, stuff->count);
     return (ProcXSendExtensionEvent(client));
 }
@@ -125,31 +126,32 @@ ProcXSendExtensionEvent(ClientPtr client)
     REQUEST(xSendExtensionEventReq);
     REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
 
-    if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
+    if (stuff->length !=
-	(stuff->num_events * bytes_to_int32(sizeof(xEvent))))
+        bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
-	return BadLength;
+        (stuff->num_events * bytes_to_int32(sizeof(xEvent))))
+        return BadLength;
 
     ret = dixLookupDevice(&dev, stuff->deviceid, client, DixWriteAccess);
     if (ret != Success)
-	return ret;
+        return ret;
 
     /* The client's event type must be one defined by an extension. */
 
-    first = ((xEvent *) & stuff[1]);
+    first = ((xEvent *) &stuff[1]);
     if (!((EXTENSION_EVENT_BASE <= first->u.u.type) &&
-	  (first->u.u.type < lastEvent))) {
+          (first->u.u.type < lastEvent))) {
-	client->errorValue = first->u.u.type;
+        client->errorValue = first->u.u.type;
-	return BadValue;
+        return BadValue;
     }
 
     list = (XEventClass *) (first + stuff->num_events);
     if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev,
-				  X_SendExtensionEvent)) != Success)
+                                  X_SendExtensionEvent)) != Success)
-	return ret;
+        return ret;
 
     ret = (SendEvent(client, dev, stuff->destination,
-		     stuff->propagate, (xEvent *) & stuff[1],
+                     stuff->propagate, (xEvent *) &stuff[1],
-		     tmp[stuff->deviceid].mask, stuff->num_events));
+                     tmp[stuff->deviceid].mask, stuff->num_events));
 
     return ret;
 }

Xi/sendexev.h

@@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SENDEXEV_H
 #define SENDEXEV_H 1
 
-int SProcXSendExtensionEvent(ClientPtr	/* client */
+int SProcXSendExtensionEvent(ClientPtr  /* client */
     );
 
-int ProcXSendExtensionEvent(ClientPtr	/* client */
+int ProcXSendExtensionEvent(ClientPtr   /* client */
     );
 
-#endif /* SENDEXEV_H */
+#endif                          /* SENDEXEV_H */

Xi/setbmap.c

@@ -54,7 +54,7 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include "inputstr.h"	/* DeviceIntPtr      */
+#include "inputstr.h"           /* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
@@ -94,7 +94,7 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
 
     if (stuff->length !=
         bytes_to_int32(sizeof(xSetDeviceButtonMappingReq) + stuff->map_length))
-	return BadLength;
+        return BadLength;
 
     ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
     if (ret != Success)
@@ -106,7 +106,9 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.status = MappingSuccess;
 
-    ret = ApplyPointerMapping(dev, (CARD8 *) &stuff[1], stuff->map_length, client);
+    ret =
+        ApplyPointerMapping(dev, (CARD8 *) &stuff[1], stuff->map_length,
+                            client);
     if (ret == -1)
         return BadValue;
     else if (ret == MappingBusy)
@@ -128,9 +130,9 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
 
 void
 SRepXSetDeviceButtonMapping(ClientPtr client, int size,
-			    xSetDeviceButtonMappingReply * rep)
+                            xSetDeviceButtonMappingReply * rep)
 {
     swaps(&rep->sequenceNumber);
     swapl(&rep->length);
-    WriteToClient(client, size, (char *)rep);
+    WriteToClient(client, size, (char *) rep);
 }

Xi/setbmap.h

@@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SETBMAP_H
 #define SETBMAP_H 1
 
-int SProcXSetDeviceButtonMapping(ClientPtr	/* client */
+int SProcXSetDeviceButtonMapping(ClientPtr      /* client */
     );
 
-int ProcXSetDeviceButtonMapping(ClientPtr	/* client */
+int ProcXSetDeviceButtonMapping(ClientPtr       /* client */
     );
 
 void SRepXSetDeviceButtonMapping(ClientPtr /* client */ ,
-				 int /* size */ ,
+                                 int /* size */ ,
-				 xSetDeviceButtonMappingReply *	/* rep */
+                                 xSetDeviceButtonMappingReply * /* rep */
     );
 
-#endif /* SETBMAP_H */
+#endif                          /* SETBMAP_H */