indent fixes (OMG SO UGLY), and nuke old RCS keywords.

75 files changed, 3027 insertions, 3767 deletions

diff --git a/ChangeLog b/ChangeLog
index f0ecbfce5..2b079cba4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -40,6 +40,9 @@
 	* Xi/ungrdevk.c:
 	ANSIfy Xi/.  Mostly automated via protoize(1).
 
+	* Xi/*.[ch]:
+	indent fixes (OMG SO UGLY), and nuke old RCS keywords.
+
 2006-02-16  Eric Anholt  <anholt@FreeBSD.org>
 
 	* Xext/Makefile.am:
diff --git a/Xi/allowev.c b/Xi/allowev.c
index 83c664758..ea9c5de08 100644
--- a/Xi/allowev.c
+++ b/Xi/allowev.c
@@ -1,5 +1,3 @@
-/* $Xorg: allowev.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/allowev.c,v 3.3 2001/01/17 22:13:23 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "allowev.h"
@@ -87,8 +84,8 @@ SProcXAllowDeviceEvents(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
     swapl(&stuff->time, n);
-    return(ProcXAllowDeviceEvents(client));
-    }
+    return (ProcXAllowDeviceEvents(client));
+}
 
 /***********************************************************************
  *
@@ -99,45 +96,42 @@ SProcXAllowDeviceEvents(register ClientPtr client)
 int
 ProcXAllowDeviceEvents(register ClientPtr client)
 {
-    TimeStamp		time;
-    DeviceIntPtr	thisdev;
+    TimeStamp time;
+    DeviceIntPtr thisdev;
 
     REQUEST(xAllowDeviceEventsReq);
     REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
 
-    thisdev = LookupDeviceIntRec (stuff->deviceid);
-    if (thisdev == NULL)
-	{
+    thisdev = LookupDeviceIntRec(stuff->deviceid);
+    if (thisdev == NULL) {
 	SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadDevice);
 	return Success;
-	}
+    }
     time = ClientTimeToServerTime(stuff->time);
 
-    switch (stuff->mode)
-        {
-	case ReplayThisDevice:
-	    AllowSome(client, time, thisdev, NOT_GRABBED);
-	    break;
-	case SyncThisDevice: 
-	    AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
-	    break;
-	case AsyncThisDevice: 
-	    AllowSome(client, time, thisdev, THAWED);
-	    break;
-	case AsyncOtherDevices: 
-	    AllowSome(client, time, thisdev, THAW_OTHERS);
-	    break;
-	case SyncAll:
-	    AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
-	    break;
-	case AsyncAll:
-	    AllowSome(client, time, thisdev, THAWED_BOTH);
-	    break;
-	default: 
-	    SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, 
-		BadValue);
-	    client->errorValue = stuff->mode;
-	    return Success;
-        }
-    return Success;
+    switch (stuff->mode) {
+    case ReplayThisDevice:
+	AllowSome(client, time, thisdev, NOT_GRABBED);
+	break;
+    case SyncThisDevice:
+	AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
+	break;
+    case AsyncThisDevice:
+	AllowSome(client, time, thisdev, THAWED);
+	break;
+    case AsyncOtherDevices:
+	AllowSome(client, time, thisdev, THAW_OTHERS);
+	break;
+    case SyncAll:
+	AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
+	break;
+    case AsyncAll:
+	AllowSome(client, time, thisdev, THAWED_BOTH);
+	break;
+    default:
+	SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadValue);
+	client->errorValue = stuff->mode;
+	return Success;
     }
+    return Success;
+}
diff --git a/Xi/allowev.h b/Xi/allowev.h
index 2d1132d3a..199744fea 100644
--- a/Xi/allowev.h
+++ b/Xi/allowev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/allowev.h,v 3.1 1996/04/15 11:18:23 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/chgdctl.c b/Xi/chgdctl.c
index 004000360..d507513a9 100644
--- a/Xi/chgdctl.c
+++ b/Xi/chgdctl.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgdctl.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgdctl.c,v 3.3 2001/01/17 22:13:23 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,21 +50,21 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#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 "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "chgdctl.h"
@@ -88,8 +85,8 @@ SProcXChangeDeviceControl(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
     swaps(&stuff->control, n);
-    return(ProcXChangeDeviceControl(client));
-    }
+    return (ProcXChangeDeviceControl(client));
+}
 
 /***********************************************************************
  *
@@ -111,89 +108,73 @@ ProcXChangeDeviceControl(ClientPtr client)
     REQUEST(xChangeDeviceControlReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
 
-    len = stuff->length - (sizeof(xChangeDeviceControlReq) >>2);
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
-		BadDevice);
+    len = stuff->length - (sizeof(xChangeDeviceControlReq) >> 2);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_ChangeDeviceControl;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    switch (stuff->control) 
-	{
-	case DEVICE_RESOLUTION:
-    	    r = (xDeviceResolutionCtl *) &stuff[1];
-	    if ((len < (sizeof(xDeviceResolutionCtl)>>2)) ||
-	        (len != (sizeof(xDeviceResolutionCtl)>>2) +
-		 r->num_valuators))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 
-			0, BadLength);
-		return Success;
-		}
-	    if (!dev->valuator)
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
-		    BadMatch);
-		return Success;
-		}
-	    if ((dev->grab) && !SameClient(dev->grab, client))
-		{
-		rep.status = AlreadyGrabbed;
-		WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), 
-		    &rep);
-		return Success;
-		}
-	    resolution = (CARD32 *) (r + 1);
-	    if (r->first_valuator + r->num_valuators > dev->valuator->numAxes)
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
-		    BadValue);
-		return Success;
-		}
-	    status = ChangeDeviceControl(client, dev, (xDeviceCtl*) r);
-	    if (status == Success)
-		{
-	        a = &dev->valuator->axes[r->first_valuator];
-		for (i=0; i<r->num_valuators; i++)
-		    if (*(resolution+i) < (a+i)->min_resolution ||
-		        *(resolution+i) > (a+i)->max_resolution)
-			{
-			SendErrorToClient (client, IReqCode, 
-			    X_ChangeDeviceControl, 0, BadValue);
-			return Success;
-			}
-		for (i=0; i<r->num_valuators; i++)
-		    (a++)->resolution = *resolution++; 
-		}
-	    else if (status == DeviceBusy)
-		{
-		rep.status = DeviceBusy;
-		WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), 
-		    &rep);
-		return Success;
-		}
-	    else 
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
-		    BadMatch);
-		return Success;
+    switch (stuff->control) {
+    case DEVICE_RESOLUTION:
+	r = (xDeviceResolutionCtl *) & stuff[1];
+	if ((len < (sizeof(xDeviceResolutionCtl) >> 2)) ||
+	    (len != (sizeof(xDeviceResolutionCtl) >> 2) + r->num_valuators)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl,
+			      0, BadLength);
+	    return Success;
+	}
+	if (!dev->valuator) {
+	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+			      BadMatch);
+	    return Success;
+	}
+	if ((dev->grab) && !SameClient(dev->grab, client)) {
+	    rep.status = AlreadyGrabbed;
+	    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+	    return Success;
+	}
+	resolution = (CARD32 *) (r + 1);
+	if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
+	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+			      BadValue);
+	    return Success;
+	}
+	status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
+	if (status == Success) {
+	    a = &dev->valuator->axes[r->first_valuator];
+	    for (i = 0; i < r->num_valuators; i++)
+		if (*(resolution + i) < (a + i)->min_resolution ||
+		    *(resolution + i) > (a + i)->max_resolution) {
+		    SendErrorToClient(client, IReqCode,
+				      X_ChangeDeviceControl, 0, BadValue);
+		    return Success;
 		}
-	    break;
-	default:
-	    SendErrorToClient (client, IReqCode, X_ChangeDeviceControl, 0, 
-		BadValue);
+	    for (i = 0; i < r->num_valuators; i++)
+		(a++)->resolution = *resolution++;
+	} else if (status == DeviceBusy) {
+	    rep.status = DeviceBusy;
+	    WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
+	    return Success;
+	} else {
+	    SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
+			      BadMatch);
 	    return Success;
 	}
+	break;
+    default:
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, BadValue);
+	return Success;
+    }
     WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -203,12 +184,12 @@ ProcXChangeDeviceControl(ClientPtr client)
  */
 
 void
-SRepXChangeDeviceControl (ClientPtr client, int size, xChangeDeviceControlReply *rep)
+SRepXChangeDeviceControl(ClientPtr client, int size,
+			 xChangeDeviceControlReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
-
+}
diff --git a/Xi/chgdctl.h b/Xi/chgdctl.h
index a6a530f37..9cda225cb 100644
--- a/Xi/chgdctl.h
+++ b/Xi/chgdctl.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgdctl.h,v 3.1 1996/04/15 11:18:25 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXChangeDeviceControl(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXChangeDeviceControl (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xChangeDeviceControlReply * /* rep */
-	);
+int SProcXChangeDeviceControl(ClientPtr	/* client */
+    );
+
+int ProcXChangeDeviceControl(ClientPtr	/* client */
+    );
+
+void SRepXChangeDeviceControl(ClientPtr /* client */ ,
+			      int /* size */ ,
+			      xChangeDeviceControlReply *	/* rep */
+    );
 
 #endif /* CHGDCTL_H */
diff --git a/Xi/chgfctl.c b/Xi/chgfctl.c
index 09741507d..76914dcad 100644
--- a/Xi/chgfctl.c
+++ b/Xi/chgfctl.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgfctl.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgfctl.c,v 3.3 2001/01/17 22:13:23 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,20 +50,20 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>			/* control constants */
+#include <X11/extensions/XIproto.h>	/* control constants */
 
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "chgfctl.h"
@@ -89,8 +86,8 @@ SProcXChangeFeedbackControl(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
     swapl(&stuff->mask, n);
-    return(ProcXChangeFeedbackControl(client));
-    }
+    return (ProcXChangeFeedbackControl(client));
+}
 
 /***********************************************************************
  *
@@ -113,116 +110,108 @@ ProcXChangeFeedbackControl(ClientPtr client)
     REQUEST(xChangeFeedbackControlReq);
     REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
 
-    len = stuff->length - (sizeof(xChangeFeedbackControlReq) >>2);
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadDevice);
+    len = stuff->length - (sizeof(xChangeFeedbackControlReq) >> 2);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
-    switch (stuff->feedbackid)
-	{
-	case KbdFeedbackClass:
-	    if (len != (sizeof(xKbdFeedbackCtl)>>2))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
+    switch (stuff->feedbackid) {
+    case KbdFeedbackClass:
+	if (len != (sizeof(xKbdFeedbackCtl) >> 2)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+			      0, BadLength);
+	    return Success;
+	}
+	for (k = dev->kbdfeed; k; k = k->next)
+	    if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) {
+		ChangeKbdFeedback(client, dev, stuff->mask, k,
+				  (xKbdFeedbackCtl *) & stuff[1]);
 		return Success;
-		}
-	    for (k=dev->kbdfeed; k; k=k->next)
-		if (k->ctrl.id == ((xKbdFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangeKbdFeedback (client, dev, stuff->mask, k, (xKbdFeedbackCtl *)&stuff[1]);
-		    return Success;
-		    }
-	    break;
-	case PtrFeedbackClass:
-	    if (len != (sizeof(xPtrFeedbackCtl)>>2))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
+	    }
+	break;
+    case PtrFeedbackClass:
+	if (len != (sizeof(xPtrFeedbackCtl) >> 2)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+			      0, BadLength);
+	    return Success;
+	}
+	for (p = dev->ptrfeed; p; p = p->next)
+	    if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) {
+		ChangePtrFeedback(client, dev, stuff->mask, p,
+				  (xPtrFeedbackCtl *) & stuff[1]);
 		return Success;
-		}
-	    for (p=dev->ptrfeed; p; p=p->next)
-		if (p->ctrl.id == ((xPtrFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangePtrFeedback (client, dev, stuff->mask, p, (xPtrFeedbackCtl *)&stuff[1]);
-		    return Success;
-		    }
-	    break;
-	case StringFeedbackClass:
-	    {
+	    }
+	break;
+    case StringFeedbackClass:
+	{
 	    register char n;
-	    xStringFeedbackCtl *f = ((xStringFeedbackCtl *) &stuff[1]);
-	    if (client->swapped)
-		{
-		swaps(&f->num_keysyms,n);
-		}
-	    if (len != ((sizeof(xStringFeedbackCtl)>>2) + f->num_keysyms))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
-		return Success;
-		}
-	    for (s=dev->stringfeed; s; s=s->next)
-		if (s->ctrl.id == ((xStringFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangeStringFeedback (client, dev, stuff->mask,s,(xStringFeedbackCtl *)&stuff[1]);
-		    return Success;
-		    }
-	    break;
+	    xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]);
+
+	    if (client->swapped) {
+		swaps(&f->num_keysyms, n);
 	    }
-	case IntegerFeedbackClass:
-	    if (len != (sizeof(xIntegerFeedbackCtl)>>2))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
+	    if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms)) {
+		SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+				  0, BadLength);
 		return Success;
-		}
-	    for (i=dev->intfeed; i; i=i->next)
-		if (i->ctrl.id == ((xIntegerFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangeIntegerFeedback (client, dev,stuff->mask,i,(xIntegerFeedbackCtl *)&stuff[1]);
+	    }
+	    for (s = dev->stringfeed; s; s = s->next)
+		if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) {
+		    ChangeStringFeedback(client, dev, stuff->mask, s,
+					 (xStringFeedbackCtl *) & stuff[1]);
 		    return Success;
-		    }
-	    break;
-	case LedFeedbackClass:
-	    if (len != (sizeof(xLedFeedbackCtl)>>2))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
-		return Success;
 		}
-	    for (l=dev->leds; l; l=l->next)
-		if (l->ctrl.id == ((xLedFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangeLedFeedback (client, dev, stuff->mask, l, (xLedFeedbackCtl *)&stuff[1]);
-		    return Success;
-		    }
 	    break;
-	case BellFeedbackClass:
-	    if (len != (sizeof(xBellFeedbackCtl)>>2))
-		{
-		SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 
-			0, BadLength);
+	}
+    case IntegerFeedbackClass:
+	if (len != (sizeof(xIntegerFeedbackCtl) >> 2)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+			      0, BadLength);
+	    return Success;
+	}
+	for (i = dev->intfeed; i; i = i->next)
+	    if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) {
+		ChangeIntegerFeedback(client, dev, stuff->mask, i,
+				      (xIntegerFeedbackCtl *) & stuff[1]);
 		return Success;
-		}
-	    for (b=dev->bell; b; b=b->next)
-		if (b->ctrl.id == ((xBellFeedbackCtl *) &stuff[1])->id)
-		    {
-		    ChangeBellFeedback (client, dev, stuff->mask, b, (xBellFeedbackCtl *)&stuff[1]);
-		    return Success;
-		    }
-	    break;
-	default:
-	    break;
+	    }
+	break;
+    case LedFeedbackClass:
+	if (len != (sizeof(xLedFeedbackCtl) >> 2)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+			      0, BadLength);
+	    return Success;
+	}
+	for (l = dev->leds; l; l = l->next)
+	    if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) {
+		ChangeLedFeedback(client, dev, stuff->mask, l,
+				  (xLedFeedbackCtl *) & stuff[1]);
+		return Success;
+	    }
+	break;
+    case BellFeedbackClass:
+	if (len != (sizeof(xBellFeedbackCtl) >> 2)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+			      0, BadLength);
+	    return Success;
 	}
+	for (b = dev->bell; b; b = b->next)
+	    if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) {
+		ChangeBellFeedback(client, dev, stuff->mask, b,
+				   (xBellFeedbackCtl *) & stuff[1]);
+		return Success;
+	    }
+	break;
+    default:
+	break;
+    }
 
-    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
+    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
     return Success;
-    } 
+}
 
 /******************************************************************************
  *
@@ -231,149 +220,130 @@ ProcXChangeFeedbackControl(ClientPtr client)
  */
 
 int
-ChangeKbdFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, KbdFeedbackPtr k, xKbdFeedbackCtl *f)
+ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
+		  KbdFeedbackPtr k, xKbdFeedbackCtl * f)
 {
     register char n;
     KeybdCtrl kctrl;
     int t;
     int key = DO_ALL;
 
-    if (client->swapped)
-	{
-	swaps(&f->length,n);
-	swaps(&f->pitch,n);
-	swaps(&f->duration,n);
-	swapl(&f->led_mask,n);
-	swapl(&f->led_values,n);
-	}
+    if (client->swapped) {
+	swaps(&f->length, n);
+	swaps(&f->pitch, n);
+	swaps(&f->duration, n);
+	swapl(&f->led_mask, n);
+	swapl(&f->led_values, n);
+    }
 
     kctrl = k->ctrl;
-    if (mask & DvKeyClickPercent)
-	{
+    if (mask & DvKeyClickPercent) {
 	t = f->click;
 	if (t == -1)
 	    t = defaultKeyboardControl.click;
-	else if (t < 0 || t > 100)
-	    {
+	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
+	}
 	kctrl.click = t;
-        }
+    }
 
-    if (mask & DvPercent)
-	{
+    if (mask & DvPercent) {
 	t = f->percent;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell;
-	else if (t < 0 || t > 100)
-	    {
+	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	kctrl.bell = t;
 	}
+	kctrl.bell = t;
+    }
 
-    if (mask & DvPitch)
-	{
+    if (mask & DvPitch) {
 	t = f->pitch;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell_pitch;
-	else if (t < 0)
-	    {
+	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	kctrl.bell_pitch = t;
 	}
+	kctrl.bell_pitch = t;
+    }
 
-    if (mask & DvDuration)
-	{
+    if (mask & DvDuration) {
 	t = f->duration;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell_duration;
-	else if (t < 0)
-	    {
+	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
+	}
 	kctrl.bell_duration = t;
-        }
+    }
 
-    if (mask & DvLed)
-        {
+    if (mask & DvLed) {
 	kctrl.leds &= ~(f->led_mask);
 	kctrl.leds |= (f->led_mask & f->led_values);
-        }
+    }
 
-    if (mask & DvKey)
-	{
+    if (mask & DvKey) {
 	key = (KeyCode) f->key;
-	if (key < 8 || key > 255)
-	    {
+	if (key < 8 || key > 255) {
 	    client->errorValue = key;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	if (!(mask & DvAutoRepeatMode))
-	    {
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadMatch);
+	}
+	if (!(mask & DvAutoRepeatMode)) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadMatch);
 	    return Success;
-	    }
 	}
+    }
 
-    if (mask & DvAutoRepeatMode)
-	{
+    if (mask & DvAutoRepeatMode) {
 	int inx = (key >> 3);
 	int kmask = (1 << (key & 7));
+
 	t = (CARD8) f->auto_repeat_mode;
-	if (t == AutoRepeatModeOff)
-	    {
+	if (t == AutoRepeatModeOff) {
 	    if (key == DO_ALL)
 		kctrl.autoRepeat = FALSE;
 	    else
 		kctrl.autoRepeats[inx] &= ~kmask;
-	    }
-	else if (t == AutoRepeatModeOn)
-	    {
+	} else if (t == AutoRepeatModeOn) {
 	    if (key == DO_ALL)
 		kctrl.autoRepeat = TRUE;
 	    else
 		kctrl.autoRepeats[inx] |= kmask;
-	    }
-	else if (t == AutoRepeatModeDefault)
-	    {
+	} else if (t == AutoRepeatModeDefault) {
 	    if (key == DO_ALL)
 		kctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
 	    else
 		kctrl.autoRepeats[inx] &= ~kmask;
-		kctrl.autoRepeats[inx] =
-			(kctrl.autoRepeats[inx] & ~kmask) |
-			(defaultKeyboardControl.autoRepeats[inx] & kmask);
-	    }
-	else
-	    {
+	    kctrl.autoRepeats[inx] =
+		(kctrl.autoRepeats[inx] & ~kmask) |
+		(defaultKeyboardControl.autoRepeats[inx] & kmask);
+	} else {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-        }
+	}
+    }
 
     k->ctrl = kctrl;
-    (*k->CtrlProc)(dev, &k->ctrl);
+    (*k->CtrlProc) (dev, &k->ctrl);
     return Success;
-    }
+}
 
 /******************************************************************************
  *
@@ -382,75 +352,69 @@ ChangeKbdFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, K
  */
 
 int
-ChangePtrFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, PtrFeedbackPtr p, xPtrFeedbackCtl *f)
+ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
+		  PtrFeedbackPtr p, xPtrFeedbackCtl * f)
 {
     register char n;
-    PtrCtrl pctrl;		/* might get BadValue part way through */
+    PtrCtrl pctrl;	/* might get BadValue part way through */
 
-    if (client->swapped)
-	{
-	swaps(&f->length,n);
-	swaps(&f->num,n);
-	swaps(&f->denom,n);
-	swaps(&f->thresh,n);
-	}
+    if (client->swapped) {
+	swaps(&f->length, n);
+	swaps(&f->num, n);
+	swaps(&f->denom, n);
+	swaps(&f->thresh, n);
+    }
 
     pctrl = p->ctrl;
-    if (mask & DvAccelNum)
-	{
-	int	accelNum;
+    if (mask & DvAccelNum) {
+	int accelNum;
 
 	accelNum = f->num;
 	if (accelNum == -1)
 	    pctrl.num = defaultPointerControl.num;
-	else if (accelNum < 0)
-	    {
+	else if (accelNum < 0) {
 	    client->errorValue = accelNum;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	else pctrl.num = accelNum;
-	}
+	} else
+	    pctrl.num = accelNum;
+    }
 
-    if (mask & DvAccelDenom)
-	{
-	int	accelDenom;
+    if (mask & DvAccelDenom) {
+	int accelDenom;
 
 	accelDenom = f->denom;
 	if (accelDenom == -1)
 	    pctrl.den = defaultPointerControl.den;
-	else if (accelDenom <= 0)
-	    {
+	else if (accelDenom <= 0) {
 	    client->errorValue = accelDenom;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	else pctrl.den = accelDenom;
-        }
+	} else
+	    pctrl.den = accelDenom;
+    }
 
-    if (mask & DvThreshold)
-	{
-	int	threshold;
+    if (mask & DvThreshold) {
+	int threshold;
 
 	threshold = f->thresh;
 	if (threshold == -1)
 	    pctrl.threshold = defaultPointerControl.threshold;
-	else if (threshold < 0)
-	    {
+	else if (threshold < 0) {
 	    client->errorValue = threshold;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	else pctrl.threshold = threshold;
-        }
+	} else
+	    pctrl.threshold = threshold;
+    }
 
     p->ctrl = pctrl;
-    (*p->CtrlProc)(dev, &p->ctrl);
+    (*p->CtrlProc) (dev, &p->ctrl);
     return Success;
-    }
+}
 
 /******************************************************************************
  *
@@ -459,20 +423,21 @@ ChangePtrFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, P
  */
 
 int
-ChangeIntegerFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, IntegerFeedbackPtr i, xIntegerFeedbackCtl *f)
+ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
+		      long unsigned int mask, IntegerFeedbackPtr i,
+		      xIntegerFeedbackCtl * f)
 {
     register char n;
 
-    if (client->swapped)
-	{
-	swaps(&f->length,n);
-	swapl(&f->int_to_display,n);
-	}
+    if (client->swapped) {
+	swaps(&f->length, n);
+	swapl(&f->int_to_display, n);
+    }
 
     i->ctrl.integer_displayed = f->int_to_display;
-    (*i->CtrlProc)(dev, &i->ctrl);
+    (*i->CtrlProc) (dev, &i->ctrl);
     return Success;
-    }
+}
 
 /******************************************************************************
  *
@@ -481,51 +446,47 @@ ChangeIntegerFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mas
  */
 
 int
-ChangeStringFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, StringFeedbackPtr s, xStringFeedbackCtl *f)
+ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
+		     StringFeedbackPtr s, xStringFeedbackCtl * f)
 {
     register char n;
     register long *p;
-    int		i, j;
-    KeySym	*syms, *sup_syms;
-
-    syms = (KeySym *) (f+1);
-    if (client->swapped)
-	{
-	swaps(&f->length,n);	/* swapped num_keysyms in calling proc */
-	p = (long *) (syms);
-	for (i=0; i<f->num_keysyms; i++)
-	    {
+    int i, j;
+    KeySym *syms, *sup_syms;
+
+    syms = (KeySym *) (f + 1);
+    if (client->swapped) {
+	swaps(&f->length, n);	/* swapped num_keysyms in calling proc */
+	p = (long *)(syms);
+	for (i = 0; i < f->num_keysyms; i++) {
 	    swapl(p, n);
 	    p++;
-	    }
 	}
+    }
 
-    if (f->num_keysyms > s->ctrl.max_symbols)
-	{
-	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, 
-	    BadValue);
+    if (f->num_keysyms > s->ctrl.max_symbols) {
+	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			  BadValue);
 	return Success;
-	}
+    }
     sup_syms = s->ctrl.symbols_supported;
-    for (i=0; i<f->num_keysyms; i++)
-	{
-        for (j=0; j<s->ctrl.num_symbols_supported; j++)
-	    if (*(syms+i) == *(sup_syms+j))
+    for (i = 0; i < f->num_keysyms; i++) {
+	for (j = 0; j < s->ctrl.num_symbols_supported; j++)
+	    if (*(syms + i) == *(sup_syms + j))
 		break;
-	if (j==s->ctrl.num_symbols_supported)
-	    {
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadMatch);
+	if (j == s->ctrl.num_symbols_supported) {
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadMatch);
 	    return Success;
-	    }
 	}
+    }
 
-    s->ctrl.num_symbols_displayed  = f->num_keysyms;
-    for (i=0; i<f->num_keysyms; i++)
-	*(s->ctrl.symbols_displayed+i) = *(syms+i);
-    (*s->CtrlProc)(dev, &s->ctrl);
+    s->ctrl.num_symbols_displayed = f->num_keysyms;
+    for (i = 0; i < f->num_keysyms; i++)
+	*(s->ctrl.symbols_displayed + i) = *(syms + i);
+    (*s->CtrlProc) (dev, &s->ctrl);
     return Success;
-    }
+}
 
 /******************************************************************************
  *
@@ -534,68 +495,62 @@ ChangeStringFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask
  */
 
 int
-ChangeBellFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, BellFeedbackPtr b, xBellFeedbackCtl *f)
+ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
+		   BellFeedbackPtr b, xBellFeedbackCtl * f)
 {
     register char n;
     int t;
-    BellCtrl bctrl;		/* might get BadValue part way through */
+    BellCtrl bctrl;	/* might get BadValue part way through */
 
-    if (client->swapped)
-	{
-	swaps(&f->length,n);
-	swaps(&f->pitch,n);
-	swaps(&f->duration,n);
-	}
+    if (client->swapped) {
+	swaps(&f->length, n);
+	swaps(&f->pitch, n);
+	swaps(&f->duration, n);
+    }
 
     bctrl = b->ctrl;
-    if (mask & DvPercent)
-	{
+    if (mask & DvPercent) {
 	t = f->percent;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell;
-	else if (t < 0 || t > 100)
-	    {
+	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	bctrl.percent = t;
 	}
+	bctrl.percent = t;
+    }
 
-    if (mask & DvPitch)
-	{
+    if (mask & DvPitch) {
 	t = f->pitch;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell_pitch;
-	else if (t < 0)
-	    {
+	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
-	bctrl.pitch = t;
 	}
+	bctrl.pitch = t;
+    }
 
-    if (mask & DvDuration)
-	{
+    if (mask & DvDuration) {
 	t = f->duration;
 	if (t == -1)
 	    t = defaultKeyboardControl.bell_duration;
-	else if (t < 0)
-	    {
+	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient (client, IReqCode, X_ChangeFeedbackControl, 0, 
-		BadValue);
+	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+			      BadValue);
 	    return Success;
-	    }
+	}
 	bctrl.duration = t;
-        }
+    }
     b->ctrl = bctrl;
-    (*b->CtrlProc)(dev, &b->ctrl);
+    (*b->CtrlProc) (dev, &b->ctrl);
     return Success;
-    }
+}
 
 /******************************************************************************
  *
@@ -604,28 +559,27 @@ ChangeBellFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
  */
 
 int
-ChangeLedFeedback (ClientPtr client, DeviceIntPtr dev, long unsigned int mask, LedFeedbackPtr l, xLedFeedbackCtl *f)
+ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
+		  LedFeedbackPtr l, xLedFeedbackCtl * f)
 {
     register char n;
-    LedCtrl lctrl;		/* might get BadValue part way through */
+    LedCtrl lctrl;	/* might get BadValue part way through */
 
-    if (client->swapped)
-	{
-	swaps(&f->length,n);
-	swapl(&f->led_values,n);
-	swapl(&f->led_mask,n);
-	}
+    if (client->swapped) {
+	swaps(&f->length, n);
+	swapl(&f->led_values, n);
+	swapl(&f->led_mask, n);
+    }
 
     f->led_mask &= l->ctrl.led_mask;	/* set only supported leds */
     f->led_values &= l->ctrl.led_mask;	/* set only supported leds */
-    if (mask & DvLed)
-        {
+    if (mask & DvLed) {
 	lctrl.led_mask = f->led_mask;
 	lctrl.led_values = f->led_values;
-	(*l->CtrlProc)(dev, &lctrl);
-	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->CtrlProc) (dev, &lctrl);
+	l->ctrl.led_values &= ~(f->led_mask);	/* zero changed leds */
+	l->ctrl.led_values |= (f->led_mask & f->led_values);	/* OR in set leds */
+    }
 
     return Success;
-    }
+}
diff --git a/Xi/chgfctl.h b/Xi/chgfctl.h
index 94dab2814..81e1153ec 100644
--- a/Xi/chgfctl.h
+++ b/Xi/chgfctl.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgfctl.h,v 3.1 1996/04/15 11:18:26 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,68 +30,52 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGFCTL_H
 #define CHGFCTL_H 1
 
-int
-SProcXChangeFeedbackControl(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXChangeFeedbackControl(
-	ClientPtr              /* client */
-	);
-
-int
-ChangeKbdFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	KbdFeedbackPtr         /* k */,
-	xKbdFeedbackCtl *      /* f */
-	);
-
-int
-ChangePtrFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	PtrFeedbackPtr         /* p */,
-	xPtrFeedbackCtl *      /* f */
-	);
-
-int
-ChangeIntegerFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	IntegerFeedbackPtr     /* i */,
-	xIntegerFeedbackCtl *  /* f */
-	);
-
-int
-ChangeStringFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	StringFeedbackPtr      /* s */,
-	xStringFeedbackCtl *   /* f */
-	);
-
-int
-ChangeBellFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	BellFeedbackPtr        /* b */,
-	xBellFeedbackCtl *     /* f */
-	);
-
-int
-ChangeLedFeedback (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* dev */,
-	unsigned long          /* mask */,
-	LedFeedbackPtr         /* l */,
-	xLedFeedbackCtl *      /* f */
-	);
+int SProcXChangeFeedbackControl(ClientPtr	/* client */
+    );
+
+int ProcXChangeFeedbackControl(ClientPtr	/* client */
+    );
+
+int ChangeKbdFeedback(ClientPtr /* client */ ,
+		      DeviceIntPtr /* dev */ ,
+		      unsigned long /* mask */ ,
+		      KbdFeedbackPtr /* k */ ,
+		      xKbdFeedbackCtl *	/* f */
+    );
+
+int ChangePtrFeedback(ClientPtr /* client */ ,
+		      DeviceIntPtr /* dev */ ,
+		      unsigned long /* mask */ ,
+		      PtrFeedbackPtr /* p */ ,
+		      xPtrFeedbackCtl *	/* f */
+    );
+
+int ChangeIntegerFeedback(ClientPtr /* client */ ,
+			  DeviceIntPtr /* dev */ ,
+			  unsigned long /* mask */ ,
+			  IntegerFeedbackPtr /* i */ ,
+			  xIntegerFeedbackCtl *	/* f */
+    );
+
+int ChangeStringFeedback(ClientPtr /* client */ ,
+			 DeviceIntPtr /* dev */ ,
+			 unsigned long /* mask */ ,
+			 StringFeedbackPtr /* s */ ,
+			 xStringFeedbackCtl *	/* f */
+    );
+
+int ChangeBellFeedback(ClientPtr /* client */ ,
+		       DeviceIntPtr /* dev */ ,
+		       unsigned long /* mask */ ,
+		       BellFeedbackPtr /* b */ ,
+		       xBellFeedbackCtl *	/* f */
+    );
+
+int ChangeLedFeedback(ClientPtr /* client */ ,
+		      DeviceIntPtr /* dev */ ,
+		      unsigned long /* mask */ ,
+		      LedFeedbackPtr /* l */ ,
+		      xLedFeedbackCtl *	/* f */
+    );
 
 #endif /* CHGFCTL_H */
diff --git a/Xi/chgkbd.c b/Xi/chgkbd.c
index 6f3c63521..289bd85af 100644
--- a/Xi/chgkbd.c
+++ b/Xi/chgkbd.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgkbd.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgkbd.c,v 3.5 2001/08/23 14:56:19 alanh Exp $ */
 
 /***********************************************************************
  *
@@ -59,15 +56,15 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "globals.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "exevents.h"
 #include "exglobals.h"
@@ -89,8 +86,8 @@ SProcXChangeKeyboardDevice(register ClientPtr client)
     REQUEST(xChangeKeyboardDeviceReq);
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
-    return(ProcXChangeKeyboardDevice(client));
-    }
+    return (ProcXChangeKeyboardDevice(client));
+}
 
 /***********************************************************************
  *
@@ -100,16 +97,16 @@ SProcXChangeKeyboardDevice(register ClientPtr client)
  */
 
 int
-ProcXChangeKeyboardDevice (register ClientPtr client)
+ProcXChangeKeyboardDevice(register ClientPtr client)
 {
-    int				i;
-    DeviceIntPtr 		xkbd = inputInfo.keyboard;
-    DeviceIntPtr 		dev;
-    FocusClassPtr		xf = xkbd->focus;
-    FocusClassPtr		df;
-    KeyClassPtr 		k;
-    xChangeKeyboardDeviceReply	rep;
-    changeDeviceNotify		ev;
+    int i;
+    DeviceIntPtr xkbd = inputInfo.keyboard;
+    DeviceIntPtr dev;
+    FocusClassPtr xf = xkbd->focus;
+    FocusClassPtr df;
+    KeyClassPtr k;
+    xChangeKeyboardDeviceReply rep;
+    changeDeviceNotify ev;
 
     REQUEST(xChangeKeyboardDeviceReq);
     REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
@@ -119,79 +116,75 @@ ProcXChangeKeyboardDevice (register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
 	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
-		BadDevice);
+	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     k = dev->key;
-    if (k == NULL)
-	{
+    if (k == NULL) {
 	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
-		BadMatch);
+	SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
+			  BadMatch);
 	return Success;
-	}
+    }
 
     if (((dev->grab) && !SameClient(dev->grab, client)) ||
-        ((xkbd->grab) && !SameClient(xkbd->grab, client)))
+	((xkbd->grab) && !SameClient(xkbd->grab, client)))
 	rep.status = AlreadyGrabbed;
     else if ((dev->sync.frozen &&
-	     dev->sync.other && !SameClient(dev->sync.other, client)) ||
+	      dev->sync.other && !SameClient(dev->sync.other, client)) ||
 	     (xkbd->sync.frozen &&
 	      xkbd->sync.other && !SameClient(xkbd->sync.other, client)))
 	rep.status = GrabFrozen;
-    else
-	{
-	if (ChangeKeyboardDevice (xkbd, dev) != Success)
-	    {
-	    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0, 
-		BadDevice);
+    else {
+	if (ChangeKeyboardDevice(xkbd, dev) != Success) {
+	    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
+			      BadDevice);
 	    return Success;
-	    }
+	}
 	if (!dev->focus)
-	    InitFocusClassDeviceStruct (dev);
+	    InitFocusClassDeviceStruct(dev);
 	if (!dev->kbdfeed)
-	   InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr)NoopDDA,
-					    (KbdCtrlProcPtr)NoopDDA);
+	    InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr) NoopDDA,
+					     (KbdCtrlProcPtr) NoopDDA);
 	df = dev->focus;
 	df->win = xf->win;
 	df->revert = xf->revert;
 	df->time = xf->time;
 	df->traceGood = xf->traceGood;
-	if (df->traceSize != xf->traceSize)
-	    {
-	    Must_have_memory = TRUE; /* XXX */
-	    df->trace = (WindowPtr *) xrealloc(df->trace, 
-		xf->traceSize * sizeof(WindowPtr));
-	    Must_have_memory = FALSE; /* XXX */
-	    }
+	if (df->traceSize != xf->traceSize) {
+	    Must_have_memory = TRUE;	/* XXX */
+	    df->trace = (WindowPtr *) xrealloc(df->trace,
+					       xf->traceSize *
+					       sizeof(WindowPtr));
+	    Must_have_memory = FALSE;	/* XXX */
+	}
 	df->traceSize = xf->traceSize;
-	for (i=0; i<df->traceSize; i++)
+	for (i = 0; i < df->traceSize; i++)
 	    df->trace[i] = xf->trace[i];
-	RegisterOtherDevice (xkbd);
-	RegisterKeyboardDevice (dev);
+	RegisterOtherDevice(xkbd);
+	RegisterKeyboardDevice(dev);
 
 	ev.type = ChangeDeviceNotify;
 	ev.deviceid = stuff->deviceid;
 	ev.time = currentTime.milliseconds;
 	ev.request = NewKeyboard;
 
-	SendEventToAllWindows (dev, ChangeDeviceNotifyMask, (xEvent *)&ev, 1);
-	SendMappingNotify (MappingKeyboard, k->curKeySyms.minKeyCode, 
-	    k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode + 1,client);
+	SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
+	SendMappingNotify(MappingKeyboard, k->curKeySyms.minKeyCode,
+			  k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode +
+			  1, client);
 
 	rep.status = 0;
-	}
+    }
 
-    WriteReplyToClient (client, sizeof (xChangeKeyboardDeviceReply), 
-	&rep);
+    WriteReplyToClient(client, sizeof(xChangeKeyboardDeviceReply), &rep);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -201,11 +194,12 @@ ProcXChangeKeyboardDevice (register ClientPtr client)
  */
 
 void
-SRepXChangeKeyboardDevice (ClientPtr client, int size, xChangeKeyboardDeviceReply *rep)
+SRepXChangeKeyboardDevice(ClientPtr client, int size,
+			  xChangeKeyboardDeviceReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/chgkbd.h b/Xi/chgkbd.h
index ddb17e3c4..7a883b7f0 100644
--- a/Xi/chgkbd.h
+++ b/Xi/chgkbd.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgkbd.h,v 3.1 1996/04/15 11:18:27 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,22 +30,15 @@ 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 */
-	);
-
-void
-SRepXChangeKeyboardDevice (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xChangeKeyboardDeviceReply * /* rep */
-	);
+int ProcXChangeKeyboardDevice(ClientPtr	/* client */
+    );
 
+void SRepXChangeKeyboardDevice(ClientPtr /* client */ ,
+			       int /* size */ ,
+			       xChangeKeyboardDeviceReply *	/* rep */
+    );
 
 #endif /* CHGKBD_H */
diff --git a/Xi/chgkmap.c b/Xi/chgkmap.c
index 24d36432b..047b899ed 100644
--- a/Xi/chgkmap.c
+++ b/Xi/chgkmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgkmap.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgkmap.c,v 3.2 2001/01/17 22:13:24 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,19 +50,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
 
@@ -88,15 +85,14 @@ SProcXChangeDeviceKeyMapping(register ClientPtr client)
     REQUEST(xChangeDeviceKeyMappingReq);
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
-    p = (long *) &stuff[1];
+    p = (long *)&stuff[1];
     count = stuff->keyCodes * stuff->keySymsPerKeyCode;
-    for (i = 0; i < count; i++)
-        {
-        swapl(p, n);
+    for (i = 0; i < count; i++) {
+	swapl(p, n);
 	p++;
-        }
-    return(ProcXChangeDeviceKeyMapping(client));
     }
+    return (ProcXChangeDeviceKeyMapping(client));
+}
 
 /***********************************************************************
  *
@@ -107,28 +103,26 @@ SProcXChangeDeviceKeyMapping(register ClientPtr client)
 int
 ProcXChangeDeviceKeyMapping(register ClientPtr client)
 {
-    int	ret;
+    int ret;
     unsigned len;
     DeviceIntPtr dev;
 
     REQUEST(xChangeDeviceKeyMappingReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_ChangeDeviceKeyMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0,
+			  BadDevice);
 	return Success;
-	}
-    len = stuff->length - (sizeof(xChangeDeviceKeyMappingReq) >> 2);  
+    }
+    len = stuff->length - (sizeof(xChangeDeviceKeyMappingReq) >> 2);
 
-    ret = ChangeKeyMapping (client, dev, len, DeviceMappingNotify, 
-	stuff->firstKeyCode, stuff->keyCodes, stuff->keySymsPerKeyCode, 
-	(KeySym *)&stuff[1]);
+    ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify,
+			   stuff->firstKeyCode, stuff->keyCodes,
+			   stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]);
 
     if (ret != Success)
-	SendErrorToClient (client, IReqCode, X_ChangeDeviceKeyMapping, 0, 
-		ret);
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0, ret);
     return Success;
-    }
+}
diff --git a/Xi/chgkmap.h b/Xi/chgkmap.h
index 5e65a5b36..6ed6420fb 100644
--- a/Xi/chgkmap.h
+++ b/Xi/chgkmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgkmap.h,v 3.1 1996/04/15 11:18:28 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/chgprop.c b/Xi/chgprop.c
index f379048f5..0f1ab5152 100644
--- a/Xi/chgprop.c
+++ b/Xi/chgprop.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgprop.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgprop.c,v 3.2 2001/01/17 22:13:24 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "exevents.h"
 #include "exglobals.h"
@@ -92,14 +89,13 @@ SProcXChangeDeviceDontPropagateList(register ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
     swapl(&stuff->window, n);
     swaps(&stuff->count, n);
-    p = (long *) &stuff[1];
-    for (i=0; i<stuff->count; i++)
-        {
-        swapl(p, n);
+    p = (long *)&stuff[1];
+    for (i = 0; i < stuff->count; i++) {
+	swapl(p, n);
 	p++;
-        }
-    return(ProcXChangeDeviceDontPropagateList(client));
     }
+    return (ProcXChangeDeviceDontPropagateList(client));
+}
 
 /***********************************************************************
  *
@@ -108,50 +104,47 @@ SProcXChangeDeviceDontPropagateList(register ClientPtr client)
  */
 
 int
-ProcXChangeDeviceDontPropagateList (register ClientPtr client)
+ProcXChangeDeviceDontPropagateList(register ClientPtr client)
 {
-    int			i;
-    WindowPtr		pWin;
-    struct 		tmask tmp[EMASKSIZE];
-    OtherInputMasks	*others;
+    int i;
+    WindowPtr pWin;
+    struct tmask tmp[EMASKSIZE];
+    OtherInputMasks *others;
 
     REQUEST(xChangeDeviceDontPropagateListReq);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
 
-    if (stuff->length !=(sizeof(xChangeDeviceDontPropagateListReq)>>2) + 
-	stuff->count)
-	{
-	SendErrorToClient (client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
-	    BadLength);
+    if (stuff->length != (sizeof(xChangeDeviceDontPropagateListReq) >> 2) +
+	stuff->count) {
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+			  BadLength);
 	return Success;
-	}
+    }
 
-    pWin = (WindowPtr) LookupWindow (stuff->window, client);
-    if (!pWin)
-        {
+    pWin = (WindowPtr) LookupWindow(stuff->window, client);
+    if (!pWin) {
 	client->errorValue = stuff->window;
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
-		BadWindow);
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+			  BadWindow);
 	return Success;
-        }
+    }
 
-    if (stuff->mode != AddToList && stuff->mode != DeleteFromList)
-        {
+    if (stuff->mode != AddToList && stuff->mode != DeleteFromList) {
 	client->errorValue = stuff->window;
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
-		BadMode);
+	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+			  BadMode);
 	return Success;
-        }
+    }
 
-    if (CreateMaskFromList (client, (XEventClass *)&stuff[1], 
-	stuff->count, tmp, NULL, X_ChangeDeviceDontPropagateList) != Success)
-	    return Success;
+    if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
+			   stuff->count, tmp, NULL,
+			   X_ChangeDeviceDontPropagateList) != Success)
+	return Success;
 
     others = wOtherInputMasks(pWin);
     if (!others && stuff->mode == DeleteFromList)
 	return Success;
-    for (i=0; i<EMASKSIZE; i++)
-	{
+    for (i = 0; i < EMASKSIZE; i++) {
 	if (tmp[i].mask == 0)
 	    continue;
 
@@ -160,13 +153,13 @@ ProcXChangeDeviceDontPropagateList (register ClientPtr client)
 	else if (others)
 	    tmp[i].mask |= others->dontPropagateMask[i];
 
-	if (DeviceEventSuppressForWindow (pWin,client,tmp[i].mask,i) != Success)
-	    {
-	    SendErrorToClient ( client, IReqCode, X_ChangeDeviceDontPropagateList, 0, 
-		BadClass);
+	if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
+	    Success) {
+	    SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList,
+			      0, BadClass);
 	    return Success;
-	    }
 	}
+    }
 
     return Success;
-    }
+}
diff --git a/Xi/chgprop.h b/Xi/chgprop.h
index 7395bc25c..36716180a 100644
--- a/Xi/chgprop.h
+++ b/Xi/chgprop.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgprop.h,v 3.1 1996/04/15 11:18:29 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/chgptr.c b/Xi/chgptr.c
index 9fa5c2296..ef99e3a5b 100644
--- a/Xi/chgptr.c
+++ b/Xi/chgptr.c
@@ -1,5 +1,3 @@
-/* $Xorg: chgptr.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/chgptr.c,v 3.6 2001/08/23 14:56:19 alanh Exp $ */
 
 /***********************************************************************
  *
@@ -59,17 +56,17 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "windowstr.h"			/* window structure  */
-#include "scrnintstr.h"			/* screen structure  */
+#include "windowstr.h"	/* window structure  */
+#include "scrnintstr.h"	/* screen structure  */
 
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "dixevents.h"
 #include "exevents.h"
@@ -92,8 +89,8 @@ SProcXChangePointerDevice(register ClientPtr client)
     REQUEST(xChangePointerDeviceReq);
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
-    return(ProcXChangePointerDevice(client));
-    }
+    return (ProcXChangePointerDevice(client));
+}
 
 /***********************************************************************
  *
@@ -102,13 +99,13 @@ SProcXChangePointerDevice(register ClientPtr client)
  */
 
 int
-ProcXChangePointerDevice (register ClientPtr client)
+ProcXChangePointerDevice(register ClientPtr client)
 {
-    DeviceIntPtr 	xptr = inputInfo.pointer;
-    DeviceIntPtr 	dev;
-    ValuatorClassPtr 	v;
-    xChangePointerDeviceReply	rep;
-    changeDeviceNotify	ev;
+    DeviceIntPtr xptr = inputInfo.pointer;
+    DeviceIntPtr dev;
+    ValuatorClassPtr v;
+    xChangePointerDeviceReply rep;
+    changeDeviceNotify ev;
 
     REQUEST(xChangePointerDeviceReq);
     REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
@@ -118,66 +115,60 @@ ProcXChangePointerDevice (register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
 	rep.status = -1;
-	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, 
-	    BadDevice);
+	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     v = dev->valuator;
-    if (v == NULL || v->numAxes < 2 || 
-	stuff->xaxis >= v->numAxes ||
-	stuff->yaxis >= v->numAxes)
-	{
+    if (v == NULL || v->numAxes < 2 ||
+	stuff->xaxis >= v->numAxes || stuff->yaxis >= v->numAxes) {
 	rep.status = -1;
 	SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, BadMatch);
 	return Success;
-	}
+    }
 
     if (((dev->grab) && !SameClient(dev->grab, client)) ||
-        ((xptr->grab) && !SameClient(xptr->grab, client)))
+	((xptr->grab) && !SameClient(xptr->grab, client)))
 	rep.status = AlreadyGrabbed;
     else if ((dev->sync.frozen &&
-	     dev->sync.other && !SameClient(dev->sync.other, client)) ||
+	      dev->sync.other && !SameClient(dev->sync.other, client)) ||
 	     (xptr->sync.frozen &&
 	      xptr->sync.other && !SameClient(xptr->sync.other, client)))
 	rep.status = GrabFrozen;
-    else
-	{
-	if (ChangePointerDevice (
-	    xptr, dev, stuff->xaxis, stuff->yaxis) != Success)
-	    {
-	    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, 
-		BadDevice);
+    else {
+	if (ChangePointerDevice(xptr, dev, stuff->xaxis, stuff->yaxis) !=
+	    Success) {
+	    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
+			      BadDevice);
 	    return Success;
-	    }
+	}
 	if (dev->focus)
 	    DeleteFocusClassDeviceStruct(dev);
 	if (!dev->button)
-	    InitButtonClassDeviceStruct (dev, 0, NULL);
+	    InitButtonClassDeviceStruct(dev, 0, NULL);
 	if (!dev->ptrfeed)
-	   InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr)NoopDDA);
-	RegisterOtherDevice (xptr);
-	RegisterPointerDevice (dev);
+	    InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr) NoopDDA);
+	RegisterOtherDevice(xptr);
+	RegisterPointerDevice(dev);
 
 	ev.type = ChangeDeviceNotify;
 	ev.deviceid = stuff->deviceid;
 	ev.time = currentTime.milliseconds;
 	ev.request = NewPointer;
 
-	SendEventToAllWindows (dev, ChangeDeviceNotifyMask, (xEvent *)&ev, 1);
-	SendMappingNotify (MappingPointer, 0, 0, client);
+	SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
+	SendMappingNotify(MappingPointer, 0, 0, client);
 
 	rep.status = 0;
-	}
+    }
 
-    WriteReplyToClient (client, sizeof (xChangePointerDeviceReply), 
-	&rep);
+    WriteReplyToClient(client, sizeof(xChangePointerDeviceReply), &rep);
     return Success;
-    }
+}
 
 void
 DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
@@ -185,7 +176,7 @@ DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
     xfree(dev->focus->trace);
     xfree(dev->focus);
     dev->focus = NULL;
-    }
+}
 
 /***********************************************************************
  *
@@ -194,19 +185,18 @@ DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
  */
 
 void
-SendEventToAllWindows (DeviceIntPtr dev, Mask mask, xEvent *ev, int count)
+SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
 {
     int i;
     WindowPtr pWin, p1;
 
-    for (i=0; i<screenInfo.numScreens; i++)
-	{
+    for (i = 0; i < screenInfo.numScreens; i++) {
 	pWin = WindowTable[i];
 	(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
 	p1 = pWin->firstChild;
-	FindInterestedChildren (dev, p1, mask, ev, count);
-	}
+	FindInterestedChildren(dev, p1, mask, ev, count);
     }
+}
 
 /***********************************************************************
  *
@@ -216,18 +206,18 @@ SendEventToAllWindows (DeviceIntPtr dev, Mask mask, xEvent *ev, int count)
  */
 
 void
-FindInterestedChildren (DeviceIntPtr dev, WindowPtr p1, Mask mask, xEvent *ev, int count)
+FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask, xEvent * ev,
+		       int count)
 {
     WindowPtr p2;
 
-    while (p1)
-        {
-        p2 = p1->firstChild;
+    while (p1) {
+	p2 = p1->firstChild;
 	(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
-	FindInterestedChildren (dev, p2, mask, ev, count);
+	FindInterestedChildren(dev, p2, mask, ev, count);
 	p1 = p1->nextSib;
-        }
     }
+}
 
 /***********************************************************************
  *
@@ -237,11 +227,12 @@ FindInterestedChildren (DeviceIntPtr dev, WindowPtr p1, Mask mask, xEvent *ev, i
  */
 
 void
-SRepXChangePointerDevice (ClientPtr client, int size, xChangePointerDeviceReply *rep)
+SRepXChangePointerDevice(ClientPtr client, int size,
+			 xChangePointerDeviceReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/chgptr.h b/Xi/chgptr.h
index 5b85da13f..aeda822aa 100644
--- a/Xi/chgptr.h
+++ b/Xi/chgptr.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/chgptr.h,v 3.1 1996/04/15 11:18:31 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,43 +30,32 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CHGPTR_H
 #define CHGPTR_H 1
 
-int
-SProcXChangePointerDevice(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXChangePointerDevice (
-	ClientPtr              /* client */
-	);
-
-void
-DeleteFocusClassDeviceStruct(
-	DeviceIntPtr           /* dev */
-	);
-
-void
-SendEventToAllWindows (
-	DeviceIntPtr           /* dev */,
-	Mask                   /* mask */,
-	xEvent *               /* ev */,
-	int                    /* count */
-	);
-
-void
-FindInterestedChildren ( /* FIXME: could be static? */
-	DeviceIntPtr           /* dev */,
-	WindowPtr              /* p1 */,
-	Mask                   /* mask */,
-	xEvent *               /* ev */,
-	int                    /* count */
-	);
-
-void
-SRepXChangePointerDevice (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xChangePointerDeviceReply * /* rep */
-	);
+int SProcXChangePointerDevice(ClientPtr	/* client */
+    );
+
+int ProcXChangePointerDevice(ClientPtr	/* client */
+    );
+
+void DeleteFocusClassDeviceStruct(DeviceIntPtr	/* dev */
+    );
+
+void SendEventToAllWindows(DeviceIntPtr /* dev */ ,
+			   Mask /* mask */ ,
+			   xEvent * /* ev */ ,
+			   int	/* count */
+    );
+
+void FindInterestedChildren(	/* FIXME: could be static? */
+			       DeviceIntPtr /* dev */ ,
+			       WindowPtr /* p1 */ ,
+			       Mask /* mask */ ,
+			       xEvent * /* ev */ ,
+			       int	/* count */
+    );
+
+void SRepXChangePointerDevice(ClientPtr /* client */ ,
+			      int /* size */ ,
+			      xChangePointerDeviceReply *	/* rep */
+    );
 
 #endif /* CHGPTR_H */
diff --git a/Xi/closedev.c b/Xi/closedev.c
index dfd78005c..cc83e6a5b 100644
--- a/Xi/closedev.c
+++ b/Xi/closedev.c
@@ -1,5 +1,3 @@
-/* $Xorg: closedev.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/closedev.c,v 3.3 2001/08/23 14:56:19 alanh Exp $ */
 
 /***********************************************************************
  *
@@ -59,16 +56,16 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
-#include "scrnintstr.h"			/* screen structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
+#include "scrnintstr.h"	/* screen structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "closedev.h"
@@ -87,8 +84,8 @@ SProcXCloseDevice(register ClientPtr client)
     REQUEST(xCloseDeviceReq);
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xCloseDeviceReq);
-    return(ProcXCloseDevice(client));
-    }
+    return (ProcXCloseDevice(client));
+}
 
 /***********************************************************************
  *
@@ -99,38 +96,36 @@ SProcXCloseDevice(register ClientPtr client)
 int
 ProcXCloseDevice(register ClientPtr client)
 {
-    int			i;
-    WindowPtr 		pWin, p1;
-    DeviceIntPtr 	d;
+    int i;
+    WindowPtr pWin, p1;
+    DeviceIntPtr d;
 
     REQUEST(xCloseDeviceReq);
     REQUEST_SIZE_MATCH(xCloseDeviceReq);
 
-    d = LookupDeviceIntRec (stuff->deviceid);
-    if (d == NULL)
-	{
+    d = LookupDeviceIntRec(stuff->deviceid);
+    if (d == NULL) {
 	SendErrorToClient(client, IReqCode, X_CloseDevice, 0, BadDevice);
-        return Success;
-	}
+	return Success;
+    }
 
     if (d->grab && SameClient(d->grab, client))
-	(*d->DeactivateGrab)(d);		       /* release active grab */
+	(*d->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.	   */
+     * and selected by this client.
+     * Delete passive grabs from all windows for this device.      */
 
-    for (i=0; i<screenInfo.numScreens; i++)
-	{
+    for (i = 0; i < screenInfo.numScreens; i++) {
 	pWin = WindowTable[i];
-        DeleteDeviceEvents (d, pWin, client);
+	DeleteDeviceEvents(d, pWin, client);
 	p1 = pWin->firstChild;
-	DeleteEventsFromChildren (d, p1, client);
-	}
+	DeleteEventsFromChildren(d, p1, client);
+    }
 
-    CloseInputDevice (d, client);
+    CloseInputDevice(d, client);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -144,14 +139,13 @@ DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
 {
     WindowPtr p2;
 
-    while (p1)
-        {
-        p2 = p1->firstChild;
-	DeleteDeviceEvents (dev, p1, client);
+    while (p1) {
+	p2 = p1->firstChild;
+	DeleteDeviceEvents(dev, p1, client);
 	DeleteEventsFromChildren(dev, p2, client);
 	p1 = p1->nextSib;
-        }
     }
+}
 
 /***********************************************************************
  *
@@ -161,23 +155,21 @@ DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
  */
 
 void
-DeleteDeviceEvents (DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
+DeleteDeviceEvents(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
 {
-    InputClientsPtr	others;
-    OtherInputMasks	*pOthers;
-    GrabPtr		grab, next;
+    InputClientsPtr others;
+    OtherInputMasks *pOthers;
+    GrabPtr grab, next;
 
     if ((pOthers = wOtherInputMasks(pWin)) != 0)
-	for (others=pOthers->inputClients; others; 
-	    others = others->next)
-	    if (SameClient(others,client))
+	for (others = pOthers->inputClients; others; others = others->next)
+	    if (SameClient(others, client))
 		others->mask[dev->id] = NoEventMask;
 
-    for (grab = wPassiveGrabs(pWin); grab; grab=next)
-	{
+    for (grab = wPassiveGrabs(pWin); grab; grab = next) {
 	next = grab->next;
 	if ((grab->device == dev) &&
 	    (client->clientAsMask == CLIENT_BITS(grab->resource)))
-		FreeResource (grab->resource, RT_NONE);
-	}
+	    FreeResource(grab->resource, RT_NONE);
     }
+}
diff --git a/Xi/closedev.h b/Xi/closedev.h
index e4869c96c..6853d5002 100644
--- a/Xi/closedev.h
+++ b/Xi/closedev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/closedev.h,v 3.1 1996/04/15 11:18:32 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,28 +30,20 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef CLOSEDEV_H
 #define CLOSEDEV_H 1
 
-int
-SProcXCloseDevice(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXCloseDevice(
-	ClientPtr              /* client */
-	);
-
-void
-DeleteEventsFromChildren(
-	DeviceIntPtr           /* dev */,
-	WindowPtr              /* p1 */,
-	ClientPtr              /* client */
-	);
-
-void
-DeleteDeviceEvents (
-	DeviceIntPtr           /* dev */,
-	WindowPtr              /* pWin */,
-	ClientPtr              /* client */
-	);
+int SProcXCloseDevice(ClientPtr	/* client */
+    );
+
+int ProcXCloseDevice(ClientPtr	/* client */
+    );
+
+void DeleteEventsFromChildren(DeviceIntPtr /* dev */ ,
+			      WindowPtr /* p1 */ ,
+			      ClientPtr	/* client */
+    );
+
+void DeleteDeviceEvents(DeviceIntPtr /* dev */ ,
+			WindowPtr /* pWin */ ,
+			ClientPtr	/* client */
+    );
 
 #endif /* CLOSEDEV_H */
diff --git a/Xi/devbell.c b/Xi/devbell.c
index c451db948..b11238620 100644
--- a/Xi/devbell.c
+++ b/Xi/devbell.c
@@ -1,5 +1,3 @@
-/* $Xorg: devbell.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/devbell.c,v 3.2 2001/01/17 22:13:24 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,13 +56,13 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "devbell.h"
@@ -84,8 +81,8 @@ SProcXDeviceBell(register ClientPtr client)
 
     REQUEST(xDeviceBellReq);
     swaps(&stuff->length, n);
-    return(ProcXDeviceBell(client));
-    }
+    return (ProcXDeviceBell(client));
+}
 
 /***********************************************************************
  *
@@ -94,7 +91,7 @@ SProcXDeviceBell(register ClientPtr client)
  */
 
 int
-ProcXDeviceBell (register ClientPtr client)
+ProcXDeviceBell(register ClientPtr client)
 {
     DeviceIntPtr dev;
     KbdFeedbackPtr k;
@@ -108,64 +105,55 @@ ProcXDeviceBell (register ClientPtr client)
     REQUEST(xDeviceBellReq);
     REQUEST_SIZE_MATCH(xDeviceBellReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
 	client->errorValue = stuff->deviceid;
 	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadDevice);
 	return Success;
-	}
+    }
 
-    if (stuff->percent < -100 || stuff->percent > 100)
-	{
+    if (stuff->percent < -100 || stuff->percent > 100) {
 	client->errorValue = stuff->percent;
 	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
 	return Success;
-	}
-    if (stuff->feedbackclass == KbdFeedbackClass)
-	{
-	for (k=dev->kbdfeed; k; k=k->next)
+    }
+    if (stuff->feedbackclass == KbdFeedbackClass) {
+	for (k = dev->kbdfeed; k; k = k->next)
 	    if (k->ctrl.id == stuff->feedbackid)
 		break;
-	if (!k)
-	    {
+	if (!k) {
 	    client->errorValue = stuff->feedbackid;
 	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
 	    return Success;
-	    }
+	}
 	base = k->ctrl.bell;
 	proc = k->BellProc;
-	ctrl = (pointer) &(k->ctrl);
+	ctrl = (pointer) & (k->ctrl);
 	class = KbdFeedbackClass;
-	}
-    else if (stuff->feedbackclass == BellFeedbackClass)
-	{
-	for (b=dev->bell; b; b=b->next)
+    } else if (stuff->feedbackclass == BellFeedbackClass) {
+	for (b = dev->bell; b; b = b->next)
 	    if (b->ctrl.id == stuff->feedbackid)
 		break;
-	if (!b)
-	    {
+	if (!b) {
 	    client->errorValue = stuff->feedbackid;
 	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
 	    return Success;
-	    }
+	}
 	base = b->ctrl.percent;
 	proc = b->BellProc;
-	ctrl = (pointer) &(b->ctrl);
+	ctrl = (pointer) & (b->ctrl);
 	class = BellFeedbackClass;
-	}
-    else
-	{
+    } else {
 	client->errorValue = stuff->feedbackclass;
 	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
 	return Success;
-	}
+    }
     newpercent = (base * stuff->percent) / 100;
     if (stuff->percent < 0)
-        newpercent = base + newpercent;
+	newpercent = base + newpercent;
     else
-    	newpercent = base - newpercent + stuff->percent;
-    (*proc)(newpercent, dev, ctrl, class);
+	newpercent = base - newpercent + stuff->percent;
+    (*proc) (newpercent, dev, ctrl, class);
 
     return Success;
-    }
+}
diff --git a/Xi/devbell.h b/Xi/devbell.h
index 17cac6f7f..02a77a6b9 100644
--- a/Xi/devbell.h
+++ b/Xi/devbell.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/devbell.h,v 3.1 1996/04/15 11:18:32 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/exevents.c b/Xi/exevents.c
index 4bd57988a..9645934eb 100644
--- a/Xi/exevents.c
+++ b/Xi/exevents.c
@@ -1,4 +1,3 @@
-/* $Xorg: exevents.c,v 1.4 2001/02/09 02:04:33 xorgcvs Exp $ */
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -44,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/exevents.c,v 3.10 2001/12/14 19:58:55 dawes Exp $ */
 
 /********************************************************************
  *
@@ -69,10 +67,10 @@ SOFTWARE.
 #include "region.h"
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
-#include "dixevents.h"			/* DeliverFocusedEvent */
-#include "dixgrabs.h"			/* CreateGrab() */
+#include "dixevents.h"	/* DeliverFocusedEvent */
+#include "dixgrabs.h"	/* CreateGrab() */
 
 #include "chgptr.h"
 
@@ -85,13 +83,11 @@ SOFTWARE.
 #define Motion_Filter(class) (DevicePointerMotionMask | \
 			      (class)->state | (class)->motionMask)
 
-static Bool		ShouldFreeInputMasks(
-				WindowPtr /* pWin */,
-				Bool /* ignoreSelectedEvents */
-				);
-static Bool		MakeInputMasks (
-				WindowPtr /* pWin */
-				);
+static Bool ShouldFreeInputMasks(WindowPtr /* pWin */ ,
+				 Bool	/* ignoreSelectedEvents */
+    );
+static Bool MakeInputMasks(WindowPtr	/* pWin */
+    );
 
 /**************************************************************************
  *
@@ -100,149 +96,137 @@ static Bool		MakeInputMasks (
  */
 
 void
-RegisterOtherDevice (DeviceIntPtr device)
-    {
+RegisterOtherDevice(DeviceIntPtr device)
+{
     device->public.processInputProc = ProcessOtherEvent;
     device->public.realInputProc = ProcessOtherEvent;
     (device)->ActivateGrab = ActivateKeyboardGrab;
     (device)->DeactivateGrab = DeactivateKeyboardGrab;
-    }
+}
 
-/*ARGSUSED*/
-void
-ProcessOtherEvent (xEventPtr xE, register DeviceIntPtr other, int count)
-    {
-    register BYTE   	*kptr;
-    register int    	i;
-    register CARD16 	modifiers;
-    register CARD16 	mask;
-    GrabPtr         	grab = other->grab;
-    Bool            	deactivateDeviceGrab = FALSE;
-    int             	key = 0, bit = 0, rootX, rootY;
-    ButtonClassPtr	b = other->button;
-    KeyClassPtr		k = other->key;
-    ValuatorClassPtr	v = other->valuator;
-    deviceValuator	*xV = (deviceValuator *) xE;
+ /*ARGSUSED*/ void
+ProcessOtherEvent(xEventPtr xE, register DeviceIntPtr other, int count)
+{
+    register BYTE *kptr;
+    register int i;
+    register CARD16 modifiers;
+    register CARD16 mask;
+    GrabPtr grab = other->grab;
+    Bool deactivateDeviceGrab = FALSE;
+    int key = 0, bit = 0, rootX, rootY;
+    ButtonClassPtr b = other->button;
+    KeyClassPtr k = other->key;
+    ValuatorClassPtr v = other->valuator;
+    deviceValuator *xV = (deviceValuator *) xE;
 
     if (xE->u.u.type != DeviceValuator) {
-        GetSpritePosition(&rootX, &rootY);
-        xE->u.keyButtonPointer.rootX = rootX;
-        xE->u.keyButtonPointer.rootY = rootY;
-        key = xE->u.u.detail;
-        NoticeEventTime(xE);
-        xE->u.keyButtonPointer.state = inputInfo.keyboard->key->state | 
-		    inputInfo.pointer->button->state;
-        bit = 1 << (key & 7);
+	GetSpritePosition(&rootX, &rootY);
+	xE->u.keyButtonPointer.rootX = rootX;
+	xE->u.keyButtonPointer.rootY = rootY;
+	key = xE->u.u.detail;
+	NoticeEventTime(xE);
+	xE->u.keyButtonPointer.state = inputInfo.keyboard->key->state |
+	    inputInfo.pointer->button->state;
+	bit = 1 << (key & 7);
     }
-    if (DeviceEventCallback)
-    {
+    if (DeviceEventCallback) {
 	DeviceEventInfoRec eventinfo;
+
 	eventinfo.events = (xEventPtr) xE;
 	eventinfo.count = count;
-	CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	CallCallbacks(&DeviceEventCallback, (pointer) & eventinfo);
     }
-    for (i=1; i<count; i++)
-	if ((++xV)->type == DeviceValuator)
-	    {
+    for (i = 1; i < count; i++)
+	if ((++xV)->type == DeviceValuator) {
 	    int first = xV->first_valuator;
 	    int *axisvals;
 
-	    if (xV->num_valuators && (!v || (xV->num_valuators && (first + xV->num_valuators > v->numAxes))))
-		FatalError("Bad valuators reported for device %s\n",other->name);
+	    if (xV->num_valuators
+		&& (!v
+		    || (xV->num_valuators
+			&& (first + xV->num_valuators > v->numAxes))))
+		FatalError("Bad valuators reported for device %s\n",
+			   other->name);
 	    xV->device_state = 0;
 	    if (k)
 		xV->device_state |= k->state;
 	    if (b)
-	        xV->device_state |= b->state;
-	    if (v && v->axisVal)
-		{
-	        axisvals = v->axisVal;
-	        switch (xV->num_valuators) {
-		    case 6:
-		        *(axisvals+first+5) = xV->valuator5;
-		    case 5:
-		        *(axisvals+first+4) = xV->valuator4;
-		    case 4:
-		        *(axisvals+first+3) = xV->valuator3;
-		    case 3:
-		        *(axisvals+first+2) = xV->valuator2;
-		    case 2:
-		        *(axisvals+first+1) = xV->valuator1;
-		    case 1:
-		        *(axisvals+first) = xV->valuator0;
-		    case 0:
-		    default:
-		        break;
-		    }
+		xV->device_state |= b->state;
+	    if (v && v->axisVal) {
+		axisvals = v->axisVal;
+		switch (xV->num_valuators) {
+		case 6:
+		    *(axisvals + first + 5) = xV->valuator5;
+		case 5:
+		    *(axisvals + first + 4) = xV->valuator4;
+		case 4:
+		    *(axisvals + first + 3) = xV->valuator3;
+		case 3:
+		    *(axisvals + first + 2) = xV->valuator2;
+		case 2:
+		    *(axisvals + first + 1) = xV->valuator1;
+		case 1:
+		    *(axisvals + first) = xV->valuator0;
+		case 0:
+		default:
+		    break;
 		}
 	    }
-    
-    if (xE->u.u.type == DeviceKeyPress)
-	{
+	}
+
+    if (xE->u.u.type == DeviceKeyPress) {
 	modifiers = k->modifierMap[key];
-        kptr = &k->down[key >> 3];
-	if (*kptr & bit) /* allow ddx to generate multiple downs */
-	    {   
-	    if (!modifiers)
-		{
+	kptr = &k->down[key >> 3];
+	if (*kptr & bit) {	/* allow ddx to generate multiple downs */
+	    if (!modifiers) {
 		xE->u.u.type = DeviceKeyRelease;
 		ProcessOtherEvent(xE, other, count);
 		xE->u.u.type = DeviceKeyPress;
 		/* release can have side effects, don't fall through */
 		ProcessOtherEvent(xE, other, count);
-		}
-	    return;
 	    }
+	    return;
+	}
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	*kptr |= bit;
 	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
-	    {
-	    if (mask & modifiers) 
-	        {
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
+	    if (mask & modifiers) {
 		/* This key affects modifier "i" */
 		k->modifierKeyCount[i]++;
 		k->state |= mask;
 		modifiers &= ~mask;
-		}
 	    }
-	if (!grab && CheckDeviceGrabs(other, xE, 0, count))
-	    {
+	}
+	if (!grab && CheckDeviceGrabs(other, xE, 0, count)) {
 	    other->activatingKey = key;
 	    return;
-	    }
 	}
-    else if (xE->u.u.type == DeviceKeyRelease)
-	{
-        kptr = &k->down[key >> 3];
-	if (!(*kptr & bit)) /* guard against duplicates */
+    } else if (xE->u.u.type == DeviceKeyRelease) {
+	kptr = &k->down[key >> 3];
+	if (!(*kptr & bit))	/* guard against duplicates */
 	    return;
 	modifiers = k->modifierMap[key];
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	*kptr &= ~bit;
 	k->prev_state = k->state;
-	for (i = 0, mask = 1; modifiers; i++, mask <<= 1)
-	    {
-	    if (mask & modifiers) 
-	        {
+	for (i = 0, mask = 1; modifiers; i++, mask <<= 1) {
+	    if (mask & modifiers) {
 		/* This key affects modifier "i" */
-		if (--k->modifierKeyCount[i] <= 0) 
-		    {
+		if (--k->modifierKeyCount[i] <= 0) {
 		    k->modifierKeyCount[i] = 0;
 		    k->state &= ~mask;
-		    }
-		modifiers &= ~mask;
 		}
+		modifiers &= ~mask;
 	    }
+	}
 
 	if (other->fromPassiveGrab && (key == other->activatingKey))
 	    deactivateDeviceGrab = TRUE;
-	}
-    else if (xE->u.u.type == DeviceButtonPress)
-	{
-        kptr = &b->down[key >> 3];
+    } else if (xE->u.u.type == DeviceButtonPress) {
+	kptr = &b->down[key >> 3];
 	*kptr |= bit;
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
@@ -250,33 +234,30 @@ ProcessOtherEvent (xEventPtr xE, register DeviceIntPtr other, int count)
 	b->motionMask = DeviceButtonMotionMask;
 	xE->u.u.detail = b->map[key];
 	if (xE->u.u.detail == 0)
-	     return;
+	    return;
 	if (xE->u.u.detail <= 5)
 	    b->state |= (Button1Mask >> 1) << xE->u.u.detail;
-	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	SetMaskForEvent(Motion_Filter(b), DeviceMotionNotify);
 	if (!grab)
 	    if (CheckDeviceGrabs(other, xE, 0, count))
 		return;
 
-	}
-    else if (xE->u.u.type == DeviceButtonRelease)
-	{
-        kptr = &b->down[key >> 3];
+    } else if (xE->u.u.type == DeviceButtonRelease) {
+	kptr = &b->down[key >> 3];
 	*kptr &= ~bit;
 	if (other->valuator)
 	    other->valuator->motionHintWindow = NullWindow;
 	if (!--b->buttonsDown)
-		b->motionMask = 0;
+	    b->motionMask = 0;
 	xE->u.u.detail = b->map[key];
 	if (xE->u.u.detail == 0)
 	    return;
 	if (xE->u.u.detail <= 5)
 	    b->state &= ~((Button1Mask >> 1) << xE->u.u.detail);
-	SetMaskForEvent(Motion_Filter(b),DeviceMotionNotify);
+	SetMaskForEvent(Motion_Filter(b), DeviceMotionNotify);
 	if (!b->state && other->fromPassiveGrab)
 	    deactivateDeviceGrab = TRUE;
-	}
-    else if (xE->u.u.type == ProximityIn)
+    } else if (xE->u.u.type == ProximityIn)
 	other->valuator->mode &= ~OutOfProximity;
     else if (xE->u.u.type == ProximityOut)
 	other->valuator->mode |= OutOfProximity;
@@ -290,15 +271,15 @@ ProcessOtherEvent (xEventPtr xE, register DeviceIntPtr other, int count)
 			    other, count);
 
     if (deactivateDeviceGrab == TRUE)
-        (*other->DeactivateGrab)(other);
-    }
+	(*other->DeactivateGrab) (other);
+}
 
 _X_EXPORT int
 InitProximityClassDeviceStruct(DeviceIntPtr dev)
 {
     register ProximityClassPtr proxc;
 
-    proxc = (ProximityClassPtr)xalloc(sizeof(ProximityClassRec));
+    proxc = (ProximityClassPtr) xalloc(sizeof(ProximityClassRec));
     if (!proxc)
 	return FALSE;
     dev->proximity = proxc;
@@ -319,8 +300,8 @@ InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
 }
 
 static void
-FixDeviceStateNotify (DeviceIntPtr dev, deviceStateNotify *ev, KeyClassPtr k,
-		      ButtonClassPtr b, ValuatorClassPtr v, int first)
+FixDeviceStateNotify(DeviceIntPtr dev, deviceStateNotify * ev, KeyClassPtr k,
+		     ButtonClassPtr b, ValuatorClassPtr v, int first)
 {
     ev->type = DeviceStateNotify;
     ev->deviceid = dev->id;
@@ -333,33 +314,32 @@ FixDeviceStateNotify (DeviceIntPtr dev, deviceStateNotify *ev, KeyClassPtr k,
     if (b) {
 	ev->classes_reported |= (1 << ButtonClass);
 	ev->num_buttons = b->numButtons;
-	memmove((char *) &ev->buttons[0], (char *) b->down, 4);
-	}
-    else if (k) {
+	memmove((char *)&ev->buttons[0], (char *)b->down, 4);
+    } else if (k) {
 	ev->classes_reported |= (1 << KeyClass);
 	ev->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
-	memmove((char *) &ev->keys[0], (char *) k->down, 4);
-	}
+	memmove((char *)&ev->keys[0], (char *)k->down, 4);
+    }
     if (v) {
 	int nval = v->numAxes - first;
+
 	ev->classes_reported |= (1 << ValuatorClass);
 	ev->classes_reported |= (dev->valuator->mode << ModeBitsShift);
 	ev->num_valuators = nval < 3 ? nval : 3;
-	switch (ev->num_valuators) 
-	    {
-	    case 3:
-		ev->valuator2 = v->axisVal[first+2];
-	    case 2:
-		ev->valuator1 = v->axisVal[first+1];
-	    case 1:
-		ev->valuator0 = v->axisVal[first];
+	switch (ev->num_valuators) {
+	case 3:
+	    ev->valuator2 = v->axisVal[first + 2];
+	case 2:
+	    ev->valuator1 = v->axisVal[first + 1];
+	case 1:
+	    ev->valuator0 = v->axisVal[first];
 	    break;
-	    }
 	}
     }
+}
 
 static void
-FixDeviceValuator(DeviceIntPtr dev, deviceValuator *ev, ValuatorClassPtr v,
+FixDeviceValuator(DeviceIntPtr dev, deviceValuator * ev, ValuatorClassPtr v,
 		  int first)
 {
     int nval = v->numAxes - first;
@@ -369,22 +349,22 @@ FixDeviceValuator(DeviceIntPtr dev, deviceValuator *ev, ValuatorClassPtr v,
     ev->num_valuators = nval < 3 ? nval : 3;
     ev->first_valuator = first;
     switch (ev->num_valuators) {
-	case 3:
-	    ev->valuator2 = v->axisVal[first+2];
-	case 2:
-	    ev->valuator1 = v->axisVal[first+1];
-	case 1:
-	    ev->valuator0 = v->axisVal[first];
+    case 3:
+	ev->valuator2 = v->axisVal[first + 2];
+    case 2:
+	ev->valuator1 = v->axisVal[first + 1];
+    case 1:
+	ev->valuator0 = v->axisVal[first];
 	break;
-	}
-    first += ev->num_valuators;
     }
+    first += ev->num_valuators;
+}
 
 void
 DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 		 register WindowPtr pWin)
-    {
-    deviceFocus	event;
+{
+    deviceFocus event;
 
     if (type == FocusIn)
 	type = DeviceFocusIn;
@@ -398,29 +378,29 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
     event.window = pWin->drawable.id;
     event.time = currentTime.milliseconds;
 
-    (void) DeliverEventsToWindow(pWin, (xEvent *)&event, 1,
-    	DeviceFocusChangeMask, NullGrab, dev->id);
+    (void)DeliverEventsToWindow(pWin, (xEvent *) & event, 1,
+				DeviceFocusChangeMask, NullGrab, dev->id);
 
-    if ((type == DeviceFocusIn) && 
+    if ((type == DeviceFocusIn) &&
 	(wOtherInputMasks(pWin)) &&
 	(wOtherInputMasks(pWin)->inputEvents[dev->id] & DeviceStateNotifyMask))
-        {
-	int 			evcount = 1;
-	deviceStateNotify 	*ev, *sev;
-	deviceKeyStateNotify 	*kev;
+    {
+	int evcount = 1;
+	deviceStateNotify *ev, *sev;
+	deviceKeyStateNotify *kev;
 	deviceButtonStateNotify *bev;
 
 	KeyClassPtr k;
 	ButtonClassPtr b;
 	ValuatorClassPtr v;
-	int nval=0, nkeys=0, nbuttons=0, first=0;
+	int nval = 0, nkeys = 0, nbuttons = 0, first = 0;
 
-	if ((b=dev->button) != NULL) {
+	if ((b = dev->button) != NULL) {
 	    nbuttons = b->numButtons;
 	    if (nbuttons > 32)
 		evcount++;
 	}
-	if ((k=dev->key) != NULL) {
+	if ((k = dev->key) != NULL) {
 	    nkeys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode;
 	    if (nkeys > 32)
 		evcount++;
@@ -428,7 +408,7 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 		evcount++;
 	    }
 	}
-	if ((v=dev->valuator) != NULL) {
+	if ((v = dev->valuator) != NULL) {
 	    nval = v->numAxes;
 
 	    if (nval > 3)
@@ -442,63 +422,63 @@ DeviceFocusEvent(DeviceIntPtr dev, int type, int mode, int detail,
 	}
 
 	sev = ev = (deviceStateNotify *) xalloc(evcount * sizeof(xEvent));
-	FixDeviceStateNotify (dev, ev, NULL, NULL, NULL, first);
+	FixDeviceStateNotify(dev, ev, NULL, NULL, NULL, first);
 
 	if (b != NULL) {
-	    FixDeviceStateNotify (dev, ev++, NULL, b, v, first);
+	    FixDeviceStateNotify(dev, ev++, NULL, b, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nbuttons > 32) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		bev = (deviceButtonStateNotify *) ev++; 
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		bev = (deviceButtonStateNotify *) ev++;
 		bev->type = DeviceButtonStateNotify;
 		bev->deviceid = dev->id;
-		memmove((char *) &bev->buttons[0], (char *) &b->down[4], 28);
+		memmove((char *)&bev->buttons[0], (char *)&b->down[4], 28);
 	    }
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
 	if (k != NULL) {
-	    FixDeviceStateNotify (dev, ev++, k, NULL, v, first);
+	    FixDeviceStateNotify(dev, ev++, k, NULL, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nkeys > 32) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		kev = (deviceKeyStateNotify *) ev++; 
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		kev = (deviceKeyStateNotify *) ev++;
 		kev->type = DeviceKeyStateNotify;
 		kev->deviceid = dev->id;
-		memmove((char *) &kev->keys[0], (char *) &k->down[4], 28);
+		memmove((char *)&kev->keys[0], (char *)&k->down[4], 28);
 	    }
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
 	while (nval > 0) {
-	    FixDeviceStateNotify (dev, ev++, NULL, NULL, v, first);
+	    FixDeviceStateNotify(dev, ev++, NULL, NULL, v, first);
 	    first += 3;
 	    nval -= 3;
 	    if (nval > 0) {
-		(ev-1)->deviceid |= MORE_EVENTS;
-		FixDeviceValuator (dev, (deviceValuator *) ev++, v, first);
+		(ev - 1)->deviceid |= MORE_EVENTS;
+		FixDeviceValuator(dev, (deviceValuator *) ev++, v, first);
 		first += 3;
 		nval -= 3;
 	    }
 	}
 
-	(void) DeliverEventsToWindow(pWin, (xEvent *)sev, evcount,
-	    DeviceStateNotifyMask, NullGrab, dev->id);
-	xfree (sev);
-        }
+	(void)DeliverEventsToWindow(pWin, (xEvent *) sev, evcount,
+				    DeviceStateNotifyMask, NullGrab, dev->id);
+	xfree(sev);
     }
+}
 
 int
 GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
@@ -511,25 +491,20 @@ GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
     GrabPtr grab;
 
     if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync))
-    {
+	(this_device_mode != GrabModeAsync)) {
 	client->errorValue = this_device_mode;
-        return BadValue;
+	return BadValue;
     }
     if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync))
-    {
+	(other_devices_mode != GrabModeAsync)) {
 	client->errorValue = other_devices_mode;
-        return BadValue;
+	return BadValue;
     }
-    if ((modifiers != AnyModifier) &&
-	(modifiers & ~AllModifiersMask))
-    {
+    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
 	client->errorValue = modifiers;
 	return BadValue;
     }
-    if ((ownerEvents != xFalse) && (ownerEvents != xTrue))
-    {
+    if ((ownerEvents != xFalse) && (ownerEvents != xTrue)) {
 	client->errorValue = ownerEvents;
 	return BadValue;
     }
@@ -538,32 +513,29 @@ GrabButton(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
 	return BadWindow;
     if (rconfineTo == None)
 	confineTo = NullWindow;
-    else
-    {
+    else {
 	confineTo = LookupWindow(rconfineTo, client);
 	if (!confineTo)
 	    return BadWindow;
     }
     if (rcursor == None)
 	cursor = NullCursor;
-    else
-    {
-	cursor = (CursorPtr)LookupIDByType(rcursor, RT_CURSOR);
-	if (!cursor)
-	{
+    else {
+	cursor = (CursorPtr) LookupIDByType(rcursor, RT_CURSOR);
+	if (!cursor) {
 	    client->errorValue = rcursor;
 	    return BadCursor;
 	}
     }
 
     grab = CreateGrab(client->index, dev, pWin, eventMask,
-	(Bool)ownerEvents, (Bool) this_device_mode, (Bool)other_devices_mode,
-	modifier_device, modifiers, DeviceButtonPress, button, confineTo, 
-	cursor);
+		      (Bool) ownerEvents, (Bool) this_device_mode,
+		      (Bool) other_devices_mode, modifier_device, modifiers,
+		      DeviceButtonPress, button, confineTo, cursor);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(grab);
-    }
+}
 
 int
 GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
@@ -574,50 +546,43 @@ GrabKey(ClientPtr client, DeviceIntPtr dev, BYTE this_device_mode,
     GrabPtr grab;
     KeyClassPtr k = dev->key;
 
-    if (k==NULL)
+    if (k == NULL)
 	return BadMatch;
     if ((other_devices_mode != GrabModeSync) &&
-	(other_devices_mode != GrabModeAsync))
-    {
+	(other_devices_mode != GrabModeAsync)) {
 	client->errorValue = other_devices_mode;
-        return BadValue;
+	return BadValue;
     }
     if ((this_device_mode != GrabModeSync) &&
-	(this_device_mode != GrabModeAsync))
-    {
+	(this_device_mode != GrabModeAsync)) {
 	client->errorValue = this_device_mode;
-        return BadValue;
+	return BadValue;
     }
-    if (((key > k->curKeySyms.maxKeyCode) || 
-	 (key < k->curKeySyms.minKeyCode))
-	&& (key != AnyKey))
-    {
+    if (((key > k->curKeySyms.maxKeyCode) || (key < k->curKeySyms.minKeyCode))
+	&& (key != AnyKey)) {
 	client->errorValue = key;
-        return BadValue;
+	return BadValue;
     }
-    if ((modifiers != AnyModifier) &&
-	(modifiers & ~AllModifiersMask))
-    {
+    if ((modifiers != AnyModifier) && (modifiers & ~AllModifiersMask)) {
 	client->errorValue = modifiers;
 	return BadValue;
     }
-    if ((ownerEvents != xTrue) && (ownerEvents != xFalse))
-    {
+    if ((ownerEvents != xTrue) && (ownerEvents != xFalse)) {
 	client->errorValue = ownerEvents;
-        return BadValue;
+	return BadValue;
     }
     pWin = LookupWindow(grabWindow, client);
     if (!pWin)
 	return BadWindow;
 
-    grab = CreateGrab(client->index, dev, pWin, 
-	mask, ownerEvents, this_device_mode, other_devices_mode, 
-	modifier_device, modifiers, DeviceKeyPress, key, NullWindow, 
-	NullCursor);
+    grab = CreateGrab(client->index, dev, pWin,
+		      mask, ownerEvents, this_device_mode, other_devices_mode,
+		      modifier_device, modifiers, DeviceKeyPress, key,
+		      NullWindow, NullCursor);
     if (!grab)
 	return BadAlloc;
     return AddPassiveGrabToList(grab);
-    }
+}
 
 int
 SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client, Mask mask,
@@ -628,206 +593,184 @@ SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client, Mask mask,
     Mask check;
     InputClientsPtr others;
 
-    if (mask & ~validmasks)
-    {
+    if (mask & ~validmasks) {
 	client->errorValue = mask;
 	return BadValue;
     }
     check = (mask & exclusivemasks);
-    if (wOtherInputMasks(pWin))
-	{
-	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx])
-	    {			       /* It is illegal for two different
-				          clients to select on any of the
-				          events for maskcheck. However,
-				          it is OK, for some client to
-				          continue selecting on one of those
-				          events.  */
-	    for (others = wOtherInputMasks(pWin)->inputClients; others; 
-		others = others->next)
-	        {
-	        if (!SameClient(others, client) && (check & 
-		    others->mask[mskidx]))
+    if (wOtherInputMasks(pWin)) {
+	if (check & wOtherInputMasks(pWin)->inputEvents[mskidx]) {	/* It is illegal for two different
+									 * clients to select on any of the
+									 * events for maskcheck. However,
+									 * it is OK, for some client to
+									 * continue selecting on one of those
+									 * events.  */
+	    for (others = wOtherInputMasks(pWin)->inputClients; others;
+		 others = others->next) {
+		if (!SameClient(others, client) && (check &
+						    others->mask[mskidx]))
 		    return BadAccess;
-	        }
-            }
-	for (others = wOtherInputMasks(pWin)->inputClients; others; 
-		others = others->next)
-	    {
-	    if (SameClient(others, client))
-	        {
+	    }
+	}
+	for (others = wOtherInputMasks(pWin)->inputClients; others;
+	     others = others->next) {
+	    if (SameClient(others, client)) {
 		check = others->mask[mskidx];
 		others->mask[mskidx] = mask;
-		if (mask == 0)
-		    {
-		    for (i=0; i<EMASKSIZE; i++)
+		if (mask == 0) {
+		    for (i = 0; i < EMASKSIZE; i++)
 			if (i != mskidx && others->mask[i] != 0)
 			    break;
-		    if (i == EMASKSIZE)
-			{
+		    if (i == EMASKSIZE) {
 			RecalculateDeviceDeliverableEvents(pWin);
 			if (ShouldFreeInputMasks(pWin, FALSE))
 			    FreeResource(others->resource, RT_NONE);
-		        return Success;
-			}
+			return Success;
 		    }
+		}
 		goto maskSet;
-	        }
 	    }
 	}
+    }
     check = 0;
-    if ((ret = AddExtensionClient (pWin, client, mask, mskidx)) != Success)
+    if ((ret = AddExtensionClient(pWin, client, mask, mskidx)) != Success)
 	return ret;
-maskSet: 
+  maskSet:
     if (dev->valuator)
 	if ((dev->valuator->motionHintWindow == pWin) &&
 	    (mask & DevicePointerMotionHintMask) &&
-	    !(check & DevicePointerMotionHintMask) &&
-	    !dev->grab)
+	    !(check & DevicePointerMotionHintMask) && !dev->grab)
 	    dev->valuator->motionHintWindow = NullWindow;
     RecalculateDeviceDeliverableEvents(pWin);
     return Success;
 }
 
-int 
-AddExtensionClient (WindowPtr pWin, ClientPtr client, Mask mask, int mskidx)
-    {
+int
+AddExtensionClient(WindowPtr pWin, ClientPtr client, Mask mask, int mskidx)
+{
     InputClientsPtr others;
 
-    if (!pWin->optional && !MakeWindowOptional (pWin))
+    if (!pWin->optional && !MakeWindowOptional(pWin))
 	return BadAlloc;
     others = (InputClients *) xalloc(sizeof(InputClients));
     if (!others)
 	return BadAlloc;
-    if (!pWin->optional->inputMasks && !MakeInputMasks (pWin))
+    if (!pWin->optional->inputMasks && !MakeInputMasks(pWin))
 	return BadAlloc;
-    bzero((char *) &others->mask[0], sizeof(Mask)*EMASKSIZE);
+    bzero((char *)&others->mask[0], sizeof(Mask) * EMASKSIZE);
     others->mask[mskidx] = mask;
     others->resource = FakeClientID(client->index);
     others->next = pWin->optional->inputMasks->inputClients;
     pWin->optional->inputMasks->inputClients = others;
-    if (!AddResource(others->resource, RT_INPUTCLIENT, (pointer)pWin))
+    if (!AddResource(others->resource, RT_INPUTCLIENT, (pointer) pWin))
 	return BadAlloc;
     return Success;
-    }
+}
 
 static Bool
-MakeInputMasks (WindowPtr pWin)
-    {
+MakeInputMasks(WindowPtr pWin)
+{
     struct _OtherInputMasks *imasks;
 
-    imasks = (struct _OtherInputMasks *) 
-	xalloc (sizeof (struct _OtherInputMasks));
+    imasks = (struct _OtherInputMasks *)
+	xalloc(sizeof(struct _OtherInputMasks));
     if (!imasks)
 	return FALSE;
-    bzero((char *) imasks, sizeof (struct _OtherInputMasks));
+    bzero((char *)imasks, sizeof(struct _OtherInputMasks));
     pWin->optional->inputMasks = imasks;
     return TRUE;
-    }
+}
 
 void
 RecalculateDeviceDeliverableEvents(WindowPtr pWin)
-    {
+{
     register InputClientsPtr others;
-    struct _OtherInputMasks *inputMasks;   /* default: NULL */
+    struct _OtherInputMasks *inputMasks;	/* default: NULL */
     register WindowPtr pChild, tmp;
     int i;
 
     pChild = pWin;
-    while (1)
-	{
-	if ((inputMasks = wOtherInputMasks(pChild)) != 0)
-	    {
-	    for (others = inputMasks->inputClients; others; 
-		others = others->next)
-		{
-		for (i=0; i<EMASKSIZE; i++)
+    while (1) {
+	if ((inputMasks = wOtherInputMasks(pChild)) != 0) {
+	    for (others = inputMasks->inputClients; others;
+		 others = others->next) {
+		for (i = 0; i < EMASKSIZE; i++)
 		    inputMasks->inputEvents[i] |= others->mask[i];
-		}
-	    for (i=0; i<EMASKSIZE; i++)
+	    }
+	    for (i = 0; i < EMASKSIZE; i++)
 		inputMasks->deliverableEvents[i] = inputMasks->inputEvents[i];
-	    for (tmp = pChild->parent; tmp; tmp=tmp->parent)
+	    for (tmp = pChild->parent; tmp; tmp = tmp->parent)
 		if (wOtherInputMasks(tmp))
-		    for (i=0; i<EMASKSIZE; i++)
+		    for (i = 0; i < EMASKSIZE; i++)
 			inputMasks->deliverableEvents[i] |=
-			(wOtherInputMasks(tmp)->deliverableEvents[i] 
-			& ~inputMasks->dontPropagateMask[i] & PropagateMask[i]);
-	    }
-	if (pChild->firstChild)
-	    {
+			    (wOtherInputMasks(tmp)->deliverableEvents[i]
+			     & ~inputMasks->
+			     dontPropagateMask[i] & PropagateMask[i]);
+	}
+	if (pChild->firstChild) {
 	    pChild = pChild->firstChild;
 	    continue;
-	    }
+	}
 	while (!pChild->nextSib && (pChild != pWin))
 	    pChild = pChild->parent;
 	if (pChild == pWin)
 	    break;
 	pChild = pChild->nextSib;
-	}
     }
+}
 
 int
 InputClientGone(register WindowPtr pWin, XID id)
-    {
+{
     register InputClientsPtr other, prev;
+
     if (!wOtherInputMasks(pWin))
-	return(Success);
+	return (Success);
     prev = 0;
-    for (other = wOtherInputMasks(pWin)->inputClients; other; 
-	other = other->next)
-	{
-	if (other->resource == id)
-	    {
-	    if (prev)
-		{
+    for (other = wOtherInputMasks(pWin)->inputClients; other;
+	 other = other->next) {
+	if (other->resource == id) {
+	    if (prev) {
 		prev->next = other->next;
 		xfree(other);
-		}
-	    else if (!(other->next))
-		{
-	        if (ShouldFreeInputMasks(pWin, TRUE))
-		    {
+	    } else if (!(other->next)) {
+		if (ShouldFreeInputMasks(pWin, TRUE)) {
 		    wOtherInputMasks(pWin)->inputClients = other->next;
 		    xfree(wOtherInputMasks(pWin));
 		    pWin->optional->inputMasks = (OtherInputMasks *) NULL;
-		    CheckWindowOptionalNeed (pWin);
+		    CheckWindowOptionalNeed(pWin);
 		    xfree(other);
-		    }
-		else
-		    {
+		} else {
 		    other->resource = FakeClientID(0);
-		    if (!AddResource(other->resource, RT_INPUTCLIENT, 
-			(pointer)pWin))
+		    if (!AddResource(other->resource, RT_INPUTCLIENT,
+				     (pointer) pWin))
 			return BadAlloc;
-		    }
 		}
-	    else
-		{
+	    } else {
 		wOtherInputMasks(pWin)->inputClients = other->next;
 		xfree(other);
-		}
-	    RecalculateDeviceDeliverableEvents(pWin);
-	    return(Success);
 	    }
+	    RecalculateDeviceDeliverableEvents(pWin);
+	    return (Success);
+	}
 	prev = other;
-        }
-    FatalError("client not on device event list");
     }
+    FatalError("client not on device event list");
+}
 
 int
 SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
-	  xEvent *ev, Mask mask, int count)
-    {
+	  xEvent * ev, Mask mask, int count)
+{
     WindowPtr pWin;
-    WindowPtr effectiveFocus = NullWindow; /* only set if dest==InputFocus */
-    WindowPtr spriteWin=GetSpriteWindow();
+    WindowPtr effectiveFocus = NullWindow;	/* only set if dest==InputFocus */
+    WindowPtr spriteWin = GetSpriteWindow();
 
     if (dest == PointerWindow)
 	pWin = spriteWin;
-    else if (dest == InputFocus)
-    {
+    else if (dest == InputFocus) {
 	WindowPtr inputFocus;
-	
+
 	if (!d->focus)
 	    inputFocus = spriteWin;
 	else
@@ -840,33 +783,27 @@ SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
 	    return Success;
 
 	/* If the input focus is PointerRootWin, send the event to where
-	the pointer is if possible, then perhaps propogate up to root. */
-   	if (inputFocus == PointerRootWin)
+	 * the pointer is if possible, then perhaps propogate up to root. */
+	if (inputFocus == PointerRootWin)
 	    inputFocus = GetCurrentRootWindow();
 
-	if (IsParent(inputFocus, spriteWin))
-	{
+	if (IsParent(inputFocus, spriteWin)) {
 	    effectiveFocus = inputFocus;
 	    pWin = spriteWin;
-	}
-	else
+	} else
 	    effectiveFocus = pWin = inputFocus;
-    }
-    else
+    } else
 	pWin = LookupWindow(dest, client);
     if (!pWin)
 	return BadWindow;
-    if ((propagate != xFalse) && (propagate != xTrue))
-    {
+    if ((propagate != xFalse) && (propagate != xTrue)) {
 	client->errorValue = propagate;
 	return BadValue;
     }
     ev->u.u.type |= 0x80;
-    if (propagate)
-    {
-	for (;pWin; pWin = pWin->parent)
-	{
-	    if (DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id))
+    if (propagate) {
+	for (; pWin; pWin = pWin->parent) {
+	    if (DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, d->id))
 		return Success;
 	    if (pWin == effectiveFocus)
 		return Success;
@@ -875,148 +812,140 @@ SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
 	    if (!mask)
 		break;
 	}
-    }
-    else
-	(void)(DeliverEventsToWindow( pWin, ev, count, mask, NullGrab, d->id));
+    } else
+	(void)(DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, d->id));
     return Success;
-    }
+}
 
 int
-SetButtonMapping (ClientPtr client, DeviceIntPtr dev, int nElts, BYTE *map)
-    {
+SetButtonMapping(ClientPtr client, DeviceIntPtr dev, int nElts, BYTE * map)
+{
     register int i;
     ButtonClassPtr b = dev->button;
 
     if (b == NULL)
 	return BadMatch;
 
-    if (nElts != b->numButtons)
-    {
+    if (nElts != b->numButtons) {
 	client->errorValue = nElts;
 	return BadValue;
     }
     if (BadDeviceMap(&map[0], nElts, 1, 255, &client->errorValue))
 	return BadValue;
-    for (i=0; i < nElts; i++)
-	if ((b->map[i + 1] != map[i]) &&
-		BitIsOn(b->down, i + 1))
-    	    return MappingBusy;
+    for (i = 0; i < nElts; i++)
+	if ((b->map[i + 1] != map[i]) && BitIsOn(b->down, i + 1))
+	    return MappingBusy;
     for (i = 0; i < nElts; i++)
 	b->map[i + 1] = map[i];
     return Success;
-    }
+}
 
-int 
+int
 SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
-		   int numKeyPerModifier, KeyCode *inputMap, KeyClassPtr *k)
+		   int numKeyPerModifier, KeyCode * inputMap, KeyClassPtr * k)
 {
     KeyCode *map = NULL;
     int inputMapLen;
     register int i;
-    
+
     *k = dev->key;
     if (*k == NULL)
 	return BadMatch;
-    if (len != ((numKeyPerModifier<<1) + rlen))
+    if (len != ((numKeyPerModifier << 1) + rlen))
 	return BadLength;
 
-    inputMapLen = 8*numKeyPerModifier;
+    inputMapLen = 8 * numKeyPerModifier;
 
     /*
-     *	Now enforce the restriction that "all of the non-zero keycodes must be
-     *	in the range specified by min-keycode and max-keycode in the
-     *	connection setup (else a Value error)"
+     *  Now enforce the restriction that "all of the non-zero keycodes must be
+     *  in the range specified by min-keycode and max-keycode in the
+     *  connection setup (else a Value error)"
      */
     i = inputMapLen;
     while (i--) {
 	if (inputMap[i]
 	    && (inputMap[i] < (*k)->curKeySyms.minKeyCode
 		|| inputMap[i] > (*k)->curKeySyms.maxKeyCode)) {
-		client->errorValue = inputMap[i];
-		return -1; /* BadValue collides with MappingFailed */
-		}
+	    client->errorValue = inputMap[i];
+	    return -1;	/* BadValue collides with MappingFailed */
+	}
     }
 
     /*
-     *	Now enforce the restriction that none of the old or new
-     *	modifier keys may be down while we change the mapping,  and
-     *	that the DDX layer likes the choice.
+     *  Now enforce the restriction that none of the old or new
+     *  modifier keys may be down while we change the mapping,  and
+     *  that the DDX layer likes the choice.
      */
-    if (!AllModifierKeysAreUp (dev, (*k)->modifierKeyMap, 
-	(int)(*k)->maxKeysPerModifier, inputMap, (int)numKeyPerModifier)
-	    ||
-	!AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
-	      (*k)->modifierKeyMap, (int)(*k)->maxKeysPerModifier)) {
+    if (!AllModifierKeysAreUp(dev, (*k)->modifierKeyMap,
+			      (int)(*k)->maxKeysPerModifier, inputMap,
+			      (int)numKeyPerModifier)
+	|| !AllModifierKeysAreUp(dev, inputMap, (int)numKeyPerModifier,
+				 (*k)->modifierKeyMap,
+				 (int)(*k)->maxKeysPerModifier)) {
 	return MappingBusy;
     } else {
 	for (i = 0; i < inputMapLen; i++) {
-	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr)dev)) {
+	    if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr) dev)) {
 		return MappingFailed;
 	    }
 	}
     }
 
     /*
-     *	Now build the keyboard's modifier bitmap from the
-     *	list of keycodes.
+     *  Now build the keyboard's modifier bitmap from the
+     *  list of keycodes.
      */
     if (inputMapLen) {
-	map = (KeyCode *)xalloc(inputMapLen);
-        if (!map)
-            return BadAlloc;
+	map = (KeyCode *) xalloc(inputMapLen);
+	if (!map)
+	    return BadAlloc;
     }
     if ((*k)->modifierKeyMap)
-        xfree((*k)->modifierKeyMap);
+	xfree((*k)->modifierKeyMap);
     if (inputMapLen) {
-        (*k)->modifierKeyMap = map;
-        memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
+	(*k)->modifierKeyMap = map;
+	memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
     } else
 	(*k)->modifierKeyMap = NULL;
 
     (*k)->maxKeysPerModifier = numKeyPerModifier;
     for (i = 0; i < MAP_LENGTH; i++)
-        (*k)->modifierMap[i] = 0;
-    for (i = 0; i < inputMapLen; i++) if (inputMap[i]) {
-        (*k)->modifierMap[inputMap[i]]
-          |= (1<<(i/ (*k)->maxKeysPerModifier));
-    }
+	(*k)->modifierMap[i] = 0;
+    for (i = 0; i < inputMapLen; i++)
+	if (inputMap[i]) {
+	    (*k)->modifierMap[inputMap[i]]
+		|= (1 << (i / (*k)->maxKeysPerModifier));
+	}
 
-    return(MappingSuccess);
-    }
+    return (MappingSuccess);
+}
 
 void
-SendDeviceMappingNotify(
-    CARD8 request,
-    KeyCode firstKeyCode,
-    CARD8 count,
-    DeviceIntPtr dev)
+SendDeviceMappingNotify(CARD8 request,
+			KeyCode firstKeyCode, CARD8 count, DeviceIntPtr dev)
 {
     xEvent event;
-    deviceMappingNotify         *ev = (deviceMappingNotify *) &event;
+    deviceMappingNotify *ev = (deviceMappingNotify *) & event;
 
     ev->type = DeviceMappingNotify;
     ev->request = request;
     ev->deviceid = dev->id;
     ev->time = currentTime.milliseconds;
-    if (request == MappingKeyboard)
-	{
+    if (request == MappingKeyboard) {
 	ev->firstKeyCode = firstKeyCode;
 	ev->count = count;
-	}
-
-    SendEventToAllWindows (dev, DeviceMappingNotifyMask, (xEvent *)ev, 1);
     }
 
+    SendEventToAllWindows(dev, DeviceMappingNotifyMask, (xEvent *) ev, 1);
+}
+
 int
-ChangeKeyMapping(
-    ClientPtr 	client,
-    DeviceIntPtr dev,
-    unsigned 	len,
-    int 	type,
-    KeyCode 	firstKeyCode,
-    CARD8 	keyCodes,
-    CARD8 	keySymsPerKeyCode,
-    KeySym	*map)
+ChangeKeyMapping(ClientPtr client,
+		 DeviceIntPtr dev,
+		 unsigned len,
+		 int type,
+		 KeyCode firstKeyCode,
+		 CARD8 keyCodes, CARD8 keySymsPerKeyCode, KeySym * map)
 {
     KeySymsRec keysyms;
     KeyClassPtr k = dev->key;
@@ -1025,18 +954,16 @@ ChangeKeyMapping(
 	return (BadMatch);
 
     if (len != (keyCodes * keySymsPerKeyCode))
-            return BadLength;
+	return BadLength;
 
     if ((firstKeyCode < k->curKeySyms.minKeyCode) ||
-	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode))
-    {
-	    client->errorValue = firstKeyCode;
-	    return BadValue;
+	(firstKeyCode + keyCodes - 1 > k->curKeySyms.maxKeyCode)) {
+	client->errorValue = firstKeyCode;
+	return BadValue;
     }
-    if (keySymsPerKeyCode == 0)
-    {
-	    client->errorValue = 0;
-            return BadValue;
+    if (keySymsPerKeyCode == 0) {
+	client->errorValue = 0;
+	return BadValue;
     }
     keysyms.minKeyCode = firstKeyCode;
     keysyms.maxKeyCode = firstKeyCode + keyCodes - 1;
@@ -1044,180 +971,168 @@ ChangeKeyMapping(
     keysyms.map = map;
     if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
 	return BadAlloc;
-    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes,
-	dev);
+    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes, dev);
     return client->noClientException;
-    }
+}
 
 void
 DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
-    {
-    int			i;
-    DeviceIntPtr	dev;
-    InputClientsPtr	ic;
+{
+    int i;
+    DeviceIntPtr dev;
+    InputClientsPtr ic;
     struct _OtherInputMasks *inputMasks;
 
-    for (dev=inputInfo.devices; dev; dev=dev->next)
-	{
-	if (dev == inputInfo.pointer ||
-	    dev == inputInfo.keyboard)
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+	if (dev == inputInfo.pointer || dev == inputInfo.keyboard)
 	    continue;
 	DeleteDeviceFromAnyExtEvents(pWin, dev);
-	}
+    }
 
-    for (dev=inputInfo.off_devices; dev; dev=dev->next)
+    for (dev = inputInfo.off_devices; dev; dev = dev->next)
 	DeleteDeviceFromAnyExtEvents(pWin, dev);
 
     if (freeResources)
-	while ((inputMasks = wOtherInputMasks(pWin)) != 0)
-	    {
+	while ((inputMasks = wOtherInputMasks(pWin)) != 0) {
 	    ic = inputMasks->inputClients;
-	    for (i=0; i<EMASKSIZE; i++)
+	    for (i = 0; i < EMASKSIZE; i++)
 		inputMasks->dontPropagateMask[i] = 0;
 	    FreeResource(ic->resource, RT_NONE);
-	    }
-    }
+	}
+}
 
 void
 DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
-    {
-    WindowPtr		parent;
+{
+    WindowPtr parent;
 
     /* Deactivate any grabs performed on this window, before making
-	any input focus changes.
-        Deactivating a device grab should cause focus events. */
+     * any input focus changes.
+     * Deactivating a device grab should cause focus events. */
 
     if (dev->grab && (dev->grab->window == pWin))
-	(*dev->DeactivateGrab)(dev);
+	(*dev->DeactivateGrab) (dev);
 
     /* If the focus window is a root window (ie. has no parent) 
-	then don't delete the focus from it. */
-    
-    if (dev->focus && (pWin==dev->focus->win) && (pWin->parent != NullWindow))
-	{
+     * then don't delete the focus from it. */
+
+    if (dev->focus && (pWin == dev->focus->win) && (pWin->parent != NullWindow)) {
 	int focusEventMode = NotifyNormal;
 
- 	/* If a grab is in progress, then alter the mode of focus events. */
+	/* If a grab is in progress, then alter the mode of focus events. */
 
 	if (dev->grab)
 	    focusEventMode = NotifyWhileGrabbed;
 
-	switch (dev->focus->revert)
-	    {
-	    case RevertToNone:
+	switch (dev->focus->revert) {
+	case RevertToNone:
+	    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
+	    dev->focus->win = NoneWin;
+	    dev->focus->traceGood = 0;
+	    break;
+	case RevertToParent:
+	    parent = pWin;
+	    do {
+		parent = parent->parent;
+		dev->focus->traceGood--;
+	    } while (!parent->realized);
+	    DoFocusEvents(dev, pWin, parent, focusEventMode);
+	    dev->focus->win = parent;
+	    dev->focus->revert = RevertToNone;
+	    break;
+	case RevertToPointerRoot:
+	    DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
+	    dev->focus->win = PointerRootWin;
+	    dev->focus->traceGood = 0;
+	    break;
+	case RevertToFollowKeyboard:
+	    if (inputInfo.keyboard->focus->win) {
+		DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
+			      focusEventMode);
+		dev->focus->win = FollowKeyboardWin;
+		dev->focus->traceGood = 0;
+	    } else {
 		DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
 		dev->focus->win = NoneWin;
 		dev->focus->traceGood = 0;
-		break;
-	    case RevertToParent:
-		parent = pWin;
-		do
-		    {
-		    parent = parent->parent;
-		    dev->focus->traceGood--;
-		    } while (!parent->realized);
-		DoFocusEvents(dev, pWin, parent, focusEventMode);
-		dev->focus->win = parent;
-		dev->focus->revert = RevertToNone;
-		break;
-	    case RevertToPointerRoot:
-		DoFocusEvents(dev, pWin, PointerRootWin, focusEventMode);
-		dev->focus->win = PointerRootWin;
-		dev->focus->traceGood = 0;
-		break;
-	    case RevertToFollowKeyboard:
-		if (inputInfo.keyboard->focus->win) {
-		    DoFocusEvents(dev, pWin, inputInfo.keyboard->focus->win,
-				  focusEventMode);
-		    dev->focus->win = FollowKeyboardWin;
-		    dev->focus->traceGood = 0;
-		} else {
-		    DoFocusEvents(dev, pWin, NoneWin, focusEventMode);
-		    dev->focus->win = NoneWin;
-		    dev->focus->traceGood = 0;
-		}
-		break;
 	    }
+	    break;
 	}
+    }
 
     if (dev->valuator)
 	if (dev->valuator->motionHintWindow == pWin)
 	    dev->valuator->motionHintWindow = NullWindow;
-    }
+}
 
 int
-MaybeSendDeviceMotionNotifyHint (deviceKeyButtonPointer *pEvents, Mask mask)
-    {
+MaybeSendDeviceMotionNotifyHint(deviceKeyButtonPointer * pEvents, Mask mask)
+{
     DeviceIntPtr dev;
 
-    dev = LookupDeviceIntRec (pEvents->deviceid & DEVICE_BITS);
-    if (pEvents->type == DeviceMotionNotify)
-	{
-	if (mask & DevicePointerMotionHintMask)
-	    {
-	    if (WID(dev->valuator->motionHintWindow) == pEvents->event)
-		{
-		return 1; /* don't send, but pretend we did */
-		}
-	    pEvents->detail = NotifyHint;
+    dev = LookupDeviceIntRec(pEvents->deviceid & DEVICE_BITS);
+    if (pEvents->type == DeviceMotionNotify) {
+	if (mask & DevicePointerMotionHintMask) {
+	    if (WID(dev->valuator->motionHintWindow) == pEvents->event) {
+		return 1;	/* don't send, but pretend we did */
 	    }
-	 else
-	    {
+	    pEvents->detail = NotifyHint;
+	} else {
 	    pEvents->detail = NotifyNormal;
-	    }
 	}
-    return (0);
     }
+    return (0);
+}
 
 void
-CheckDeviceGrabAndHintWindow (WindowPtr pWin, int type,
-			      deviceKeyButtonPointer *xE, GrabPtr grab,
-			      ClientPtr client, Mask deliveryMask)
-    {
+CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
+			     deviceKeyButtonPointer * xE, GrabPtr grab,
+			     ClientPtr client, Mask deliveryMask)
+{
     DeviceIntPtr dev;
 
-    dev = LookupDeviceIntRec (xE->deviceid & DEVICE_BITS);
+    dev = LookupDeviceIntRec(xE->deviceid & DEVICE_BITS);
     if (type == DeviceMotionNotify)
 	dev->valuator->motionHintWindow = pWin;
-    else if ((type == DeviceButtonPress) && (!grab) && 
-	(deliveryMask & DeviceButtonGrabMask))
-        {
+    else if ((type == DeviceButtonPress) && (!grab) &&
+	     (deliveryMask & DeviceButtonGrabMask)) {
 	GrabRec tempGrab;
 
 	tempGrab.device = dev;
 	tempGrab.resource = client->clientAsMask;
 	tempGrab.window = pWin;
-	tempGrab.ownerEvents = (deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
+	tempGrab.ownerEvents =
+	    (deliveryMask & DeviceOwnerGrabButtonMask) ? TRUE : FALSE;
 	tempGrab.eventMask = deliveryMask;
 	tempGrab.keyboardMode = GrabModeAsync;
 	tempGrab.pointerMode = GrabModeAsync;
 	tempGrab.confineTo = NullWindow;
 	tempGrab.cursor = NullCursor;
-	(*dev->ActivateGrab)(dev, &tempGrab, currentTime, TRUE);
-        }
+	(*dev->ActivateGrab) (dev, &tempGrab, currentTime, TRUE);
     }
+}
 
 Mask
 DeviceEventMaskForClient(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
-    {
+{
     register InputClientsPtr other;
 
     if (!wOtherInputMasks(pWin))
 	return 0;
-    for (other = wOtherInputMasks(pWin)->inputClients; other; 
-	other = other->next)
-	{
+    for (other = wOtherInputMasks(pWin)->inputClients; other;
+	 other = other->next) {
 	if (SameClient(other, client))
 	    return other->mask[dev->id];
-	}
-    return 0;
     }
+    return 0;
+}
 
 void
 MaybeStopDeviceHint(register DeviceIntPtr dev, ClientPtr client)
 {
     WindowPtr pWin;
     GrabPtr grab = dev->grab;
+
     pWin = dev->valuator->motionHintWindow;
 
     if ((grab && SameClient(grab, client) &&
@@ -1232,48 +1147,45 @@ MaybeStopDeviceHint(register DeviceIntPtr dev, ClientPtr client)
 }
 
 int
-DeviceEventSuppressForWindow(WindowPtr pWin, ClientPtr client, Mask mask, int maskndx)
-    {
-    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+DeviceEventSuppressForWindow(WindowPtr pWin, ClientPtr client, Mask mask,
+			     int maskndx)
+{
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
 
-    if (mask & ~PropagateMask[maskndx])
-	{
+    if (mask & ~PropagateMask[maskndx]) {
 	client->errorValue = mask;
 	return BadValue;
-	}
+    }
 
-    if (mask == 0) 
-	{
+    if (mask == 0) {
 	if (inputMasks)
 	    inputMasks->dontPropagateMask[maskndx] = mask;
-	} 
-    else 
-	{
+    } else {
 	if (!inputMasks)
-	    AddExtensionClient (pWin, client, 0, 0);
+	    AddExtensionClient(pWin, client, 0, 0);
 	inputMasks = wOtherInputMasks(pWin);
 	inputMasks->dontPropagateMask[maskndx] = mask;
-	}
+    }
     RecalculateDeviceDeliverableEvents(pWin);
     if (ShouldFreeInputMasks(pWin, FALSE))
-        FreeResource(inputMasks->inputClients->resource, RT_NONE);
+	FreeResource(inputMasks->inputClients->resource, RT_NONE);
     return Success;
-    }
+}
 
 static Bool
-ShouldFreeInputMasks (WindowPtr pWin, Bool ignoreSelectedEvents)
-    {
+ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
+{
     int i;
     Mask allInputEventMasks = 0;
-    struct _OtherInputMasks *inputMasks = wOtherInputMasks (pWin);
+    struct _OtherInputMasks *inputMasks = wOtherInputMasks(pWin);
 
-    for (i=0; i<EMASKSIZE; i++)
+    for (i = 0; i < EMASKSIZE; i++)
 	allInputEventMasks |= inputMasks->dontPropagateMask[i];
     if (!ignoreSelectedEvents)
-	for (i=0; i<EMASKSIZE; i++)
+	for (i = 0; i < EMASKSIZE; i++)
 	    allInputEventMasks |= inputMasks->inputEvents[i];
     if (allInputEventMasks == 0)
 	return TRUE;
     else
 	return FALSE;
-    }
+}
diff --git a/Xi/exglobals.h b/Xi/exglobals.h
index cba6310f4..c64b84875 100644
--- a/Xi/exglobals.h
+++ b/Xi/exglobals.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/exglobals.h,v 3.2 1996/05/06 05:56:03 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -36,45 +35,45 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef EXGLOBALS_H
 #define EXGLOBALS_H 1
 
-extern	int 	IReqCode;
-extern	int	BadDevice;
-extern	int	BadEvent;
-extern	int	BadMode;
-extern	int	DeviceBusy;
-extern	int	BadClass;
+extern int IReqCode;
+extern int BadDevice;
+extern int BadEvent;
+extern int BadMode;
+extern int DeviceBusy;
+extern int BadClass;
 
-extern	Mask	DevicePointerMotionMask;
-extern	Mask	DevicePointerMotionHintMask;
-extern	Mask	DeviceFocusChangeMask;
-extern	Mask	DeviceStateNotifyMask;
-extern	Mask	ChangeDeviceNotifyMask;
-extern	Mask	DeviceMappingNotifyMask;
-extern	Mask	DeviceOwnerGrabButtonMask;
-extern	Mask	DeviceButtonGrabMask;
-extern	Mask	DeviceButtonMotionMask;
-extern	Mask	PropagateMask[];
+extern Mask DevicePointerMotionMask;
+extern Mask DevicePointerMotionHintMask;
+extern Mask DeviceFocusChangeMask;
+extern Mask DeviceStateNotifyMask;
+extern Mask ChangeDeviceNotifyMask;
+extern Mask DeviceMappingNotifyMask;
+extern Mask DeviceOwnerGrabButtonMask;
+extern Mask DeviceButtonGrabMask;
+extern Mask DeviceButtonMotionMask;
+extern Mask PropagateMask[];
 
-extern	int	DeviceValuator;
-extern	int	DeviceKeyPress;
-extern	int	DeviceKeyRelease;
-extern	int	DeviceButtonPress;
-extern	int	DeviceButtonRelease;
-extern	int	DeviceMotionNotify;
-extern	int	DeviceFocusIn;
-extern	int	DeviceFocusOut;
-extern	int	ProximityIn;
-extern	int	ProximityOut;
-extern	int	DeviceStateNotify;
-extern	int	DeviceKeyStateNotify;
-extern	int	DeviceButtonStateNotify;
-extern	int	DeviceMappingNotify;
-extern	int	ChangeDeviceNotify;
+extern int DeviceValuator;
+extern int DeviceKeyPress;
+extern int DeviceKeyRelease;
+extern int DeviceButtonPress;
+extern int DeviceButtonRelease;
+extern int DeviceMotionNotify;
+extern int DeviceFocusIn;
+extern int DeviceFocusOut;
+extern int ProximityIn;
+extern int ProximityOut;
+extern int DeviceStateNotify;
+extern int DeviceKeyStateNotify;
+extern int DeviceButtonStateNotify;
+extern int DeviceMappingNotify;
+extern int ChangeDeviceNotify;
 
-extern	int	RT_INPUTCLIENT;
+extern int RT_INPUTCLIENT;
 
 #if 0
 /* FIXME: in dix */
-extern	InputInfo inputInfo;
+extern InputInfo inputInfo;
 #endif
 
 #endif /* EXGLOBALS_H */
diff --git a/Xi/extinit.c b/Xi/extinit.c
index dceb6192c..c8d4db1fc 100644
--- a/Xi/extinit.c
+++ b/Xi/extinit.c
@@ -1,5 +1,3 @@
-/* $Xorg: extinit.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/extinit.c,v 3.6 2001/12/14 19:58:55 dawes Exp $ */
 
 /********************************************************************
  *
@@ -64,8 +61,8 @@ SOFTWARE.
 #include <X11/X.h>
 #include <X11/Xproto.h>
 #include "inputstr.h"
-#include "gcstruct.h"   		/* pointer for extnsionst.h*/
-#include "extnsionst.h"			/* extension entry   */
+#include "gcstruct.h"	/* pointer for extnsionst.h */
+#include "extnsionst.h"	/* extension entry   */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 
@@ -114,35 +111,36 @@ SOFTWARE.
 #include "ungrdevb.h"
 #include "ungrdevk.h"
 
-static Mask 	lastExtEventMask = 1;
-int  		ExtEventIndex;
-Mask		ExtValidMasks[EMASKSIZE];
-Mask		ExtExclusiveMasks[EMASKSIZE];
-
-struct  dev_type
-    {
-    Atom	type;
-    char	*name;
-    }dev_type [] = {{0,XI_KEYBOARD},
-	    {0,XI_MOUSE},
-	    {0,XI_TABLET},
-	    {0,XI_TOUCHSCREEN},
-	    {0,XI_TOUCHPAD},
-	    {0,XI_BARCODE},
-	    {0,XI_BUTTONBOX},
-	    {0,XI_KNOB_BOX},
-	    {0,XI_ONE_KNOB},
-	    {0,XI_NINE_KNOB},
-	    {0,XI_TRACKBALL},
-	    {0,XI_QUADRATURE},
-	    {0,XI_ID_MODULE},
-	    {0,XI_SPACEBALL},
-	    {0,XI_DATAGLOVE},
-	    {0,XI_EYETRACKER},
-	    {0,XI_CURSORKEYS},
-	    {0,XI_FOOTMOUSE}};
-
-CARD8  event_base [numInputClasses];
+static Mask lastExtEventMask = 1;
+int ExtEventIndex;
+Mask ExtValidMasks[EMASKSIZE];
+Mask ExtExclusiveMasks[EMASKSIZE];
+
+struct dev_type
+{
+    Atom type;
+    char *name;
+} dev_type[] = { {
+0, XI_KEYBOARD}, {
+0, XI_MOUSE}, {
+0, XI_TABLET}, {
+0, XI_TOUCHSCREEN}, {
+0, XI_TOUCHPAD}, {
+0, XI_BARCODE}, {
+0, XI_BUTTONBOX}, {
+0, XI_KNOB_BOX}, {
+0, XI_ONE_KNOB}, {
+0, XI_NINE_KNOB}, {
+0, XI_TRACKBALL}, {
+0, XI_QUADRATURE}, {
+0, XI_ID_MODULE}, {
+0, XI_SPACEBALL}, {
+0, XI_DATAGLOVE}, {
+0, XI_EYETRACKER}, {
+0, XI_CURSORKEYS}, {
+0, XI_FOOTMOUSE}};
+
+CARD8 event_base[numInputClasses];
 XExtEventInfo EventInfo[32];
 
 /*****************************************************************
@@ -151,40 +149,40 @@ XExtEventInfo EventInfo[32];
  *
  */
 
-int 	IReqCode = 0;
-int	BadDevice = 0;
-int	BadEvent = 1;
-int	BadMode = 2;
-int	DeviceBusy = 3;
-int	BadClass = 4;
-
-Mask	DevicePointerMotionMask;
-Mask	DevicePointerMotionHintMask;
-Mask	DeviceFocusChangeMask;
-Mask	DeviceStateNotifyMask;
-Mask	ChangeDeviceNotifyMask;
-Mask	DeviceMappingNotifyMask;
-Mask	DeviceOwnerGrabButtonMask;
-Mask	DeviceButtonGrabMask;
-Mask	DeviceButtonMotionMask;
-
-int	DeviceValuator;
-int	DeviceKeyPress;
-int	DeviceKeyRelease;
-int	DeviceButtonPress;
-int	DeviceButtonRelease;
-int	DeviceMotionNotify;
-int	DeviceFocusIn;
-int	DeviceFocusOut;
-int	ProximityIn;
-int	ProximityOut;
-int	DeviceStateNotify;
-int	DeviceKeyStateNotify;
-int	DeviceButtonStateNotify;
-int	DeviceMappingNotify;
-int	ChangeDeviceNotify;
-
-int	RT_INPUTCLIENT;
+int IReqCode = 0;
+int BadDevice = 0;
+int BadEvent = 1;
+int BadMode = 2;
+int DeviceBusy = 3;
+int BadClass = 4;
+
+Mask DevicePointerMotionMask;
+Mask DevicePointerMotionHintMask;
+Mask DeviceFocusChangeMask;
+Mask DeviceStateNotifyMask;
+Mask ChangeDeviceNotifyMask;
+Mask DeviceMappingNotifyMask;
+Mask DeviceOwnerGrabButtonMask;
+Mask DeviceButtonGrabMask;
+Mask DeviceButtonMotionMask;
+
+int DeviceValuator;
+int DeviceKeyPress;
+int DeviceKeyRelease;
+int DeviceButtonPress;
+int DeviceButtonRelease;
+int DeviceMotionNotify;
+int DeviceFocusIn;
+int DeviceFocusOut;
+int ProximityIn;
+int ProximityOut;
+int DeviceStateNotify;
+int DeviceKeyStateNotify;
+int DeviceButtonStateNotify;
+int DeviceMappingNotify;
+int ChangeDeviceNotify;
+
+int RT_INPUTCLIENT;
 
 /*****************************************************************
  *
@@ -192,9 +190,9 @@ int	RT_INPUTCLIENT;
  *
  */
 
-extern	XExtensionVersion	AllExtensionVersions[];
+extern XExtensionVersion AllExtensionVersions[];
 
-Mask	PropagateMask[MAX_DEVICES];
+Mask PropagateMask[MAX_DEVICES];
 
 /*****************************************************************
  *
@@ -202,10 +200,10 @@ Mask	PropagateMask[MAX_DEVICES];
  *
  */
 
-static	XExtensionVersion	thisversion = 
-					{XI_Present, 
-					 XI_Add_XChangeDeviceControl_Major, 
-					 XI_Add_XChangeDeviceControl_Minor};
+static XExtensionVersion thisversion = { XI_Present,
+    XI_Add_XChangeDeviceControl_Major,
+    XI_Add_XChangeDeviceControl_Minor
+};
 
 /**********************************************************************
  *
@@ -224,15 +222,14 @@ XInputExtensionInit(void)
     ExtensionEntry *extEntry;
 
     extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
-		   SProcIDispatch, IResetProc, StandardMinorOpcode);
-    if (extEntry)
-        {
+			    SProcIDispatch, IResetProc, StandardMinorOpcode);
+    if (extEntry) {
 	IReqCode = extEntry->base;
-	AllExtensionVersions[IReqCode-128] = thisversion;
-	MakeDeviceTypeAtoms ();
-	RT_INPUTCLIENT = CreateNewResourceType((DeleteType)InputClientGone);
-	FixExtensionEvents (extEntry);
-	ReplySwapVector[IReqCode] = (ReplySwapPtr)SReplyIDispatch;
+	AllExtensionVersions[IReqCode - 128] = thisversion;
+	MakeDeviceTypeAtoms();
+	RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone);
+	FixExtensionEvents(extEntry);
+	ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;
 	EventSwapVector[DeviceValuator] = SEventIDispatch;
 	EventSwapVector[DeviceKeyPress] = SEventIDispatch;
 	EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
@@ -248,12 +245,10 @@ XInputExtensionInit(void)
 	EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
 	EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
 	EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
-	}
-    else 
-	{
+    } else {
 	FatalError("IExtensionInit: AddExtensions failed\n");
-	}
     }
+}
 
 /*************************************************************************
  *
@@ -263,85 +258,84 @@ XInputExtensionInit(void)
  */
 
 int
-ProcIDispatch (register ClientPtr client)
+ProcIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
     if (stuff->data == X_GetExtensionVersion)
-	return(ProcXGetExtensionVersion(client));
+	return (ProcXGetExtensionVersion(client));
     if (stuff->data == X_ListInputDevices)
-	return(ProcXListInputDevices(client));
+	return (ProcXListInputDevices(client));
     else if (stuff->data == X_OpenDevice)
-        return(ProcXOpenDevice(client));
+	return (ProcXOpenDevice(client));
     else if (stuff->data == X_CloseDevice)
-        return(ProcXCloseDevice(client));
+	return (ProcXCloseDevice(client));
     else if (stuff->data == X_SetDeviceMode)
-	return(ProcXSetDeviceMode(client));
+	return (ProcXSetDeviceMode(client));
     else if (stuff->data == X_SelectExtensionEvent)
-	return(ProcXSelectExtensionEvent(client));
+	return (ProcXSelectExtensionEvent(client));
     else if (stuff->data == X_GetSelectedExtensionEvents)
-        return(ProcXGetSelectedExtensionEvents(client));
+	return (ProcXGetSelectedExtensionEvents(client));
     else if (stuff->data == X_ChangeDeviceDontPropagateList)
-        return(ProcXChangeDeviceDontPropagateList(client));
+	return (ProcXChangeDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceDontPropagateList)
-        return(ProcXGetDeviceDontPropagateList(client));
+	return (ProcXGetDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceMotionEvents)
-	return(ProcXGetDeviceMotionEvents(client));
+	return (ProcXGetDeviceMotionEvents(client));
     else if (stuff->data == X_ChangeKeyboardDevice)
-	return(ProcXChangeKeyboardDevice(client));
+	return (ProcXChangeKeyboardDevice(client));
     else if (stuff->data == X_ChangePointerDevice)
-	return(ProcXChangePointerDevice(client));
+	return (ProcXChangePointerDevice(client));
     else if (stuff->data == X_GrabDevice)
-	return(ProcXGrabDevice(client));
+	return (ProcXGrabDevice(client));
     else if (stuff->data == X_UngrabDevice)
-	return(ProcXUngrabDevice(client));
+	return (ProcXUngrabDevice(client));
     else if (stuff->data == X_GrabDeviceKey)
-	return(ProcXGrabDeviceKey(client));
+	return (ProcXGrabDeviceKey(client));
     else if (stuff->data == X_UngrabDeviceKey)
-	return(ProcXUngrabDeviceKey(client));
+	return (ProcXUngrabDeviceKey(client));
     else if (stuff->data == X_GrabDeviceButton)
-	return(ProcXGrabDeviceButton(client));
+	return (ProcXGrabDeviceButton(client));
     else if (stuff->data == X_UngrabDeviceButton)
-	return(ProcXUngrabDeviceButton(client));
+	return (ProcXUngrabDeviceButton(client));
     else if (stuff->data == X_AllowDeviceEvents)
-        return(ProcXAllowDeviceEvents(client));
+	return (ProcXAllowDeviceEvents(client));
     else if (stuff->data == X_GetDeviceFocus)
-	return(ProcXGetDeviceFocus(client));
+	return (ProcXGetDeviceFocus(client));
     else if (stuff->data == X_SetDeviceFocus)
-	return(ProcXSetDeviceFocus(client));
+	return (ProcXSetDeviceFocus(client));
     else if (stuff->data == X_GetFeedbackControl)
-	return(ProcXGetFeedbackControl(client));
+	return (ProcXGetFeedbackControl(client));
     else if (stuff->data == X_ChangeFeedbackControl)
-	return(ProcXChangeFeedbackControl(client));
+	return (ProcXChangeFeedbackControl(client));
     else if (stuff->data == X_GetDeviceKeyMapping)
-        return(ProcXGetDeviceKeyMapping(client));
+	return (ProcXGetDeviceKeyMapping(client));
     else if (stuff->data == X_ChangeDeviceKeyMapping)
-        return(ProcXChangeDeviceKeyMapping(client));
+	return (ProcXChangeDeviceKeyMapping(client));
     else if (stuff->data == X_GetDeviceModifierMapping)
-        return(ProcXGetDeviceModifierMapping(client));
+	return (ProcXGetDeviceModifierMapping(client));
     else if (stuff->data == X_SetDeviceModifierMapping)
-        return(ProcXSetDeviceModifierMapping(client));
+	return (ProcXSetDeviceModifierMapping(client));
     else if (stuff->data == X_GetDeviceButtonMapping)
-        return(ProcXGetDeviceButtonMapping(client));
+	return (ProcXGetDeviceButtonMapping(client));
     else if (stuff->data == X_SetDeviceButtonMapping)
-        return(ProcXSetDeviceButtonMapping(client));
+	return (ProcXSetDeviceButtonMapping(client));
     else if (stuff->data == X_QueryDeviceState)
-        return(ProcXQueryDeviceState(client));
+	return (ProcXQueryDeviceState(client));
     else if (stuff->data == X_SendExtensionEvent)
-        return(ProcXSendExtensionEvent(client));
+	return (ProcXSendExtensionEvent(client));
     else if (stuff->data == X_DeviceBell)
-        return(ProcXDeviceBell(client));
+	return (ProcXDeviceBell(client));
     else if (stuff->data == X_SetDeviceValuators)
-        return(ProcXSetDeviceValuators(client));
+	return (ProcXSetDeviceValuators(client));
     else if (stuff->data == X_GetDeviceControl)
-        return(ProcXGetDeviceControl(client));
+	return (ProcXGetDeviceControl(client));
     else if (stuff->data == X_ChangeDeviceControl)
-        return(ProcXChangeDeviceControl(client));
-    else
-        {
+	return (ProcXChangeDeviceControl(client));
+    else {
 	SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
-        }
-    return(BadRequest);
     }
+    return (BadRequest);
+}
 
 /*******************************************************************************
  *
@@ -357,81 +351,80 @@ SProcIDispatch(register ClientPtr client)
 {
     REQUEST(xReq);
     if (stuff->data == X_GetExtensionVersion)
-	return(SProcXGetExtensionVersion(client));
+	return (SProcXGetExtensionVersion(client));
     if (stuff->data == X_ListInputDevices)
-	return(SProcXListInputDevices(client));
+	return (SProcXListInputDevices(client));
     else if (stuff->data == X_OpenDevice)
-        return(SProcXOpenDevice(client));
+	return (SProcXOpenDevice(client));
     else if (stuff->data == X_CloseDevice)
-        return(SProcXCloseDevice(client));
+	return (SProcXCloseDevice(client));
     else if (stuff->data == X_SetDeviceMode)
-	return(SProcXSetDeviceMode(client));
+	return (SProcXSetDeviceMode(client));
     else if (stuff->data == X_SelectExtensionEvent)
-	return(SProcXSelectExtensionEvent(client));
+	return (SProcXSelectExtensionEvent(client));
     else if (stuff->data == X_GetSelectedExtensionEvents)
-        return(SProcXGetSelectedExtensionEvents(client));
+	return (SProcXGetSelectedExtensionEvents(client));
     else if (stuff->data == X_ChangeDeviceDontPropagateList)
-        return(SProcXChangeDeviceDontPropagateList(client));
+	return (SProcXChangeDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceDontPropagateList)
-        return(SProcXGetDeviceDontPropagateList(client));
+	return (SProcXGetDeviceDontPropagateList(client));
     else if (stuff->data == X_GetDeviceMotionEvents)
-	return(SProcXGetDeviceMotionEvents(client));
+	return (SProcXGetDeviceMotionEvents(client));
     else if (stuff->data == X_ChangeKeyboardDevice)
-	return(SProcXChangeKeyboardDevice(client));
+	return (SProcXChangeKeyboardDevice(client));
     else if (stuff->data == X_ChangePointerDevice)
-	return(SProcXChangePointerDevice(client));
+	return (SProcXChangePointerDevice(client));
     else if (stuff->data == X_GrabDevice)
-	return(SProcXGrabDevice(client));
+	return (SProcXGrabDevice(client));
     else if (stuff->data == X_UngrabDevice)
-	return(SProcXUngrabDevice(client));
+	return (SProcXUngrabDevice(client));
     else if (stuff->data == X_GrabDeviceKey)
-	return(SProcXGrabDeviceKey(client));
+	return (SProcXGrabDeviceKey(client));
     else if (stuff->data == X_UngrabDeviceKey)
-	return(SProcXUngrabDeviceKey(client));
+	return (SProcXUngrabDeviceKey(client));
     else if (stuff->data == X_GrabDeviceButton)
-	return(SProcXGrabDeviceButton(client));
+	return (SProcXGrabDeviceButton(client));
     else if (stuff->data == X_UngrabDeviceButton)
-	return(SProcXUngrabDeviceButton(client));
+	return (SProcXUngrabDeviceButton(client));
     else if (stuff->data == X_AllowDeviceEvents)
-        return(SProcXAllowDeviceEvents(client));
+	return (SProcXAllowDeviceEvents(client));
     else if (stuff->data == X_GetDeviceFocus)
-	return(SProcXGetDeviceFocus(client));
+	return (SProcXGetDeviceFocus(client));
     else if (stuff->data == X_SetDeviceFocus)
-	return(SProcXSetDeviceFocus(client));
+	return (SProcXSetDeviceFocus(client));
     else if (stuff->data == X_GetFeedbackControl)
-	return(SProcXGetFeedbackControl(client));
+	return (SProcXGetFeedbackControl(client));
     else if (stuff->data == X_ChangeFeedbackControl)
-	return(SProcXChangeFeedbackControl(client));
+	return (SProcXChangeFeedbackControl(client));
     else if (stuff->data == X_GetDeviceKeyMapping)
-        return(SProcXGetDeviceKeyMapping(client));
+	return (SProcXGetDeviceKeyMapping(client));
     else if (stuff->data == X_ChangeDeviceKeyMapping)
-        return(SProcXChangeDeviceKeyMapping(client));
+	return (SProcXChangeDeviceKeyMapping(client));
     else if (stuff->data == X_GetDeviceModifierMapping)
-        return(SProcXGetDeviceModifierMapping(client));
+	return (SProcXGetDeviceModifierMapping(client));
     else if (stuff->data == X_SetDeviceModifierMapping)
-        return(SProcXSetDeviceModifierMapping(client));
+	return (SProcXSetDeviceModifierMapping(client));
     else if (stuff->data == X_GetDeviceButtonMapping)
-        return(SProcXGetDeviceButtonMapping(client));
+	return (SProcXGetDeviceButtonMapping(client));
     else if (stuff->data == X_SetDeviceButtonMapping)
-        return(SProcXSetDeviceButtonMapping(client));
+	return (SProcXSetDeviceButtonMapping(client));
     else if (stuff->data == X_QueryDeviceState)
-        return(SProcXQueryDeviceState(client));
+	return (SProcXQueryDeviceState(client));
     else if (stuff->data == X_SendExtensionEvent)
-        return(SProcXSendExtensionEvent(client));
+	return (SProcXSendExtensionEvent(client));
     else if (stuff->data == X_DeviceBell)
-        return(SProcXDeviceBell(client));
+	return (SProcXDeviceBell(client));
     else if (stuff->data == X_SetDeviceValuators)
-        return(SProcXSetDeviceValuators(client));
+	return (SProcXSetDeviceValuators(client));
     else if (stuff->data == X_GetDeviceControl)
-        return(SProcXGetDeviceControl(client));
+	return (SProcXGetDeviceControl(client));
     else if (stuff->data == X_ChangeDeviceControl)
-        return(SProcXChangeDeviceControl(client));
-    else
-        {
+	return (SProcXChangeDeviceControl(client));
+    else {
 	SendErrorToClient(client, IReqCode, stuff->data, 0, BadRequest);
-        }
-    return(BadRequest);
     }
+    return (BadRequest);
+}
 
 /**********************************************************************
  *
@@ -446,58 +439,70 @@ SProcIDispatch(register ClientPtr client)
 	SRepX##code (client, len, (x##code##Reply *) rep)
 
 void
-SReplyIDispatch (ClientPtr client, int len, xGrabDeviceReply *rep)
-             		       
-       			    
-                    	     		/* All we look at is the type field */
-{					/* This is common to all replies    */
+SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
+
+					/* All we look at is the type field */
+{	/* This is common to all replies    */
     if (rep->RepType == X_GetExtensionVersion)
-	SRepXGetExtensionVersion (client, len, (xGetExtensionVersionReply *)rep);
+	SRepXGetExtensionVersion(client, len,
+				 (xGetExtensionVersionReply *) rep);
     else if (rep->RepType == X_ListInputDevices)
-	SRepXListInputDevices (client, len, (xListInputDevicesReply *)rep);
+	SRepXListInputDevices(client, len, (xListInputDevicesReply *) rep);
     else if (rep->RepType == X_OpenDevice)
-	SRepXOpenDevice (client, len, (xOpenDeviceReply *)rep);
+	SRepXOpenDevice(client, len, (xOpenDeviceReply *) rep);
     else if (rep->RepType == X_SetDeviceMode)
-	SRepXSetDeviceMode (client, len, (xSetDeviceModeReply *) rep);
+	SRepXSetDeviceMode(client, len, (xSetDeviceModeReply *) rep);
     else if (rep->RepType == X_GetSelectedExtensionEvents)
-	SRepXGetSelectedExtensionEvents (client, len, (xGetSelectedExtensionEventsReply *) rep);
+	SRepXGetSelectedExtensionEvents(client, len,
+					(xGetSelectedExtensionEventsReply *)
+					rep);
     else if (rep->RepType == X_GetDeviceDontPropagateList)
-	SRepXGetDeviceDontPropagateList (client, len, (xGetDeviceDontPropagateListReply *)rep);
+	SRepXGetDeviceDontPropagateList(client, len,
+					(xGetDeviceDontPropagateListReply *)
+					rep);
     else if (rep->RepType == X_GetDeviceMotionEvents)
-	SRepXGetDeviceMotionEvents (client, len, (xGetDeviceMotionEventsReply *) rep);
+	SRepXGetDeviceMotionEvents(client, len,
+				   (xGetDeviceMotionEventsReply *) rep);
     else if (rep->RepType == X_ChangeKeyboardDevice)
-	SRepXChangeKeyboardDevice (client, len, (xChangeKeyboardDeviceReply *) rep);
+	SRepXChangeKeyboardDevice(client, len,
+				  (xChangeKeyboardDeviceReply *) rep);
     else if (rep->RepType == X_ChangePointerDevice)
-	SRepXChangePointerDevice (client, len, (xChangePointerDeviceReply *)rep);
+	SRepXChangePointerDevice(client, len,
+				 (xChangePointerDeviceReply *) rep);
     else if (rep->RepType == X_GrabDevice)
-	SRepXGrabDevice (client, len, (xGrabDeviceReply *)rep);
+	SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
     else if (rep->RepType == X_GetDeviceFocus)
-	SRepXGetDeviceFocus (client, len, (xGetDeviceFocusReply *)rep);
+	SRepXGetDeviceFocus(client, len, (xGetDeviceFocusReply *) rep);
     else if (rep->RepType == X_GetFeedbackControl)
-	SRepXGetFeedbackControl (client, len, (xGetFeedbackControlReply *)rep);
+	SRepXGetFeedbackControl(client, len, (xGetFeedbackControlReply *) rep);
     else if (rep->RepType == X_GetDeviceKeyMapping)
-	SRepXGetDeviceKeyMapping (client, len, (xGetDeviceKeyMappingReply *)rep);
+	SRepXGetDeviceKeyMapping(client, len,
+				 (xGetDeviceKeyMappingReply *) rep);
     else if (rep->RepType == X_GetDeviceModifierMapping)
-	SRepXGetDeviceModifierMapping (client, len, (xGetDeviceModifierMappingReply *)rep);
+	SRepXGetDeviceModifierMapping(client, len,
+				      (xGetDeviceModifierMappingReply *) rep);
     else if (rep->RepType == X_SetDeviceModifierMapping)
-	SRepXSetDeviceModifierMapping (client, len, (xSetDeviceModifierMappingReply *)rep);
+	SRepXSetDeviceModifierMapping(client, len,
+				      (xSetDeviceModifierMappingReply *) rep);
     else if (rep->RepType == X_GetDeviceButtonMapping)
-	SRepXGetDeviceButtonMapping (client, len, (xGetDeviceButtonMappingReply *)rep);
+	SRepXGetDeviceButtonMapping(client, len,
+				    (xGetDeviceButtonMappingReply *) rep);
     else if (rep->RepType == X_SetDeviceButtonMapping)
-	SRepXSetDeviceButtonMapping (client, len, (xSetDeviceButtonMappingReply *)rep);
+	SRepXSetDeviceButtonMapping(client, len,
+				    (xSetDeviceButtonMappingReply *) rep);
     else if (rep->RepType == X_QueryDeviceState)
-	SRepXQueryDeviceState (client, len, (xQueryDeviceStateReply *)rep);
+	SRepXQueryDeviceState(client, len, (xQueryDeviceStateReply *) rep);
     else if (rep->RepType == X_SetDeviceValuators)
-	SRepXSetDeviceValuators (client, len, (xSetDeviceValuatorsReply *)rep);
+	SRepXSetDeviceValuators(client, len, (xSetDeviceValuatorsReply *) rep);
     else if (rep->RepType == X_GetDeviceControl)
-	SRepXGetDeviceControl (client, len, (xGetDeviceControlReply *)rep);
+	SRepXGetDeviceControl(client, len, (xGetDeviceControlReply *) rep);
     else if (rep->RepType == X_ChangeDeviceControl)
-	SRepXChangeDeviceControl (client, len, (xChangeDeviceControlReply *)rep);
-    else
-	{
-	    FatalError("XINPUT confused sending swapped reply");
-	}
+	SRepXChangeDeviceControl(client, len,
+				 (xChangeDeviceControlReply *) rep);
+    else {
+	FatalError("XINPUT confused sending swapped reply");
     }
+}
 
 /*****************************************************************************
  *
@@ -508,66 +513,51 @@ SReplyIDispatch (ClientPtr client, int len, xGrabDeviceReply *rep)
 #define DO_SWAP(func,type) func ((type *)from, (type *)to)
 
 void
-SEventIDispatch (xEvent *from, xEvent *to)
+SEventIDispatch(xEvent * from, xEvent * to)
 {
-    int		type = from->u.u.type & 0177;
+    int type = from->u.u.type & 0177;
 
     if (type == DeviceValuator)
 	DO_SWAP(SEventDeviceValuator, deviceValuator);
-    else if (type == DeviceKeyPress)
-	{
-        SKeyButtonPtrEvent (from, to);
+    else if (type == DeviceKeyPress) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceKeyRelease)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceKeyRelease) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceButtonPress)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceButtonPress) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceButtonRelease)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceButtonRelease) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceMotionNotify)
-	{
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == DeviceMotionNotify) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceFocusIn)
-        DO_SWAP(SEventFocus, deviceFocus);
+    } else if (type == DeviceFocusIn)
+	DO_SWAP(SEventFocus, deviceFocus);
     else if (type == DeviceFocusOut)
-        DO_SWAP(SEventFocus, deviceFocus);
-    else if (type == ProximityIn)
-	{
-        SKeyButtonPtrEvent (from, to);
+	DO_SWAP(SEventFocus, deviceFocus);
+    else if (type == ProximityIn) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == ProximityOut)
-	{ 
-        SKeyButtonPtrEvent (from, to);
+    } else if (type == ProximityOut) {
+	SKeyButtonPtrEvent(from, to);
 	to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
-	}
-    else if (type == DeviceStateNotify)
-        DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
+    } else if (type == DeviceStateNotify)
+	DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
     else if (type == DeviceKeyStateNotify)
-        DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
+	DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
     else if (type == DeviceButtonStateNotify)
-        DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
+	DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
     else if (type == DeviceMappingNotify)
-        DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
+	DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
     else if (type == ChangeDeviceNotify)
-        DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
-    else
-	{
+	DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
+    else {
 	FatalError("XInputExtension: Impossible event!\n");
-	}
     }
+}
 
 /************************************************************************
  *
@@ -576,87 +566,87 @@ SEventIDispatch (xEvent *from, xEvent *to)
  */
 
 void
-SEventDeviceValuator (deviceValuator *from, deviceValuator *to)
+SEventDeviceValuator(deviceValuator * from, deviceValuator * to)
 {
-    register char	n;
-    register int	i;
+    register char n;
+    register int i;
     INT32 *ip B32;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swaps(&to->device_state,n);
+    swaps(&to->sequenceNumber, n);
+    swaps(&to->device_state, n);
     ip = &to->valuator0;
-    for (i=0; i<6; i++)
-	{
-        swapl((ip+i),n);	/* macro - braces are required	    */
-	}
+    for (i = 0; i < 6; i++) {
+	swapl((ip + i), n);	/* macro - braces are required      */
     }
+}
 
 void
-SEventFocus (deviceFocus *from, deviceFocus *to)
+SEventFocus(deviceFocus * from, deviceFocus * to)
 {
-    register char	n;
+    register char n;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber, n);
     swapl(&to->time, n);
     swapl(&to->window, n);
-    }
+}
 
 void
-SDeviceStateNotifyEvent (deviceStateNotify *from, deviceStateNotify *to)
+SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)
 {
-    register int	i;
-    register char	n;
+    register int i;
+    register char n;
     INT32 *ip B32;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber, n);
     swapl(&to->time, n);
     ip = &to->valuator0;
-    for (i=0; i<3; i++)
-	{
-        swapl((ip+i),n);	/* macro - braces are required	    */
-	}
+    for (i = 0; i < 3; i++) {
+	swapl((ip + i), n);	/* macro - braces are required      */
     }
+}
 
 void
-SDeviceKeyStateNotifyEvent (deviceKeyStateNotify *from, deviceKeyStateNotify *to)
+SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,
+			   deviceKeyStateNotify * to)
 {
-    register char	n;
+    register char n;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    }
+    swaps(&to->sequenceNumber, n);
+}
 
 void
-SDeviceButtonStateNotifyEvent (deviceButtonStateNotify *from, deviceButtonStateNotify *to)
+SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,
+			      deviceButtonStateNotify * to)
 {
-    register char	n;
+    register char n;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    }
+    swaps(&to->sequenceNumber, n);
+}
 
 void
-SChangeDeviceNotifyEvent (changeDeviceNotify *from, changeDeviceNotify *to)
+SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)
 {
-    register char	n;
+    register char n;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber, n);
     swapl(&to->time, n);
-    }
+}
 
 void
-SDeviceMappingNotifyEvent (deviceMappingNotify *from, deviceMappingNotify *to)
+SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
 {
-    register char	n;
+    register char n;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber, n);
     swapl(&to->time, n);
-    }
+}
 
 /************************************************************************
  *
@@ -665,24 +655,24 @@ SDeviceMappingNotifyEvent (deviceMappingNotify *from, deviceMappingNotify *to)
  */
 
 void
-FixExtensionEvents (ExtensionEntry *extEntry)
+FixExtensionEvents(ExtensionEntry * extEntry)
 {
-    Mask		mask;
-
-    DeviceValuator  	    = extEntry->eventBase;
-    DeviceKeyPress   	    = DeviceValuator + 1;
-    DeviceKeyRelease 	    = DeviceKeyPress + 1;
-    DeviceButtonPress       = DeviceKeyRelease + 1;
-    DeviceButtonRelease     = DeviceButtonPress + 1;
-    DeviceMotionNotify      = DeviceButtonRelease + 1;
-    DeviceFocusIn  	    = DeviceMotionNotify + 1;
-    DeviceFocusOut	    = DeviceFocusIn + 1;
-    ProximityIn  	    = DeviceFocusOut + 1;
-    ProximityOut  	    = ProximityIn + 1;
-    DeviceStateNotify  	    = ProximityOut + 1;
-    DeviceMappingNotify     = DeviceStateNotify + 1;
-    ChangeDeviceNotify      = DeviceMappingNotify + 1;
-    DeviceKeyStateNotify    = ChangeDeviceNotify + 1;
+    Mask mask;
+
+    DeviceValuator = extEntry->eventBase;
+    DeviceKeyPress = DeviceValuator + 1;
+    DeviceKeyRelease = DeviceKeyPress + 1;
+    DeviceButtonPress = DeviceKeyRelease + 1;
+    DeviceButtonRelease = DeviceButtonPress + 1;
+    DeviceMotionNotify = DeviceButtonRelease + 1;
+    DeviceFocusIn = DeviceMotionNotify + 1;
+    DeviceFocusOut = DeviceFocusIn + 1;
+    ProximityIn = DeviceFocusOut + 1;
+    ProximityOut = ProximityIn + 1;
+    DeviceStateNotify = ProximityOut + 1;
+    DeviceMappingNotify = DeviceStateNotify + 1;
+    ChangeDeviceNotify = DeviceMappingNotify + 1;
+    DeviceKeyStateNotify = ChangeDeviceNotify + 1;
     DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
 
     event_base[KeyClass] = DeviceKeyPress;
@@ -698,66 +688,66 @@ FixExtensionEvents (ExtensionEntry *extEntry)
     DeviceBusy += extEntry->errorBase;
     BadClass += extEntry->errorBase;
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceKeyPress);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceKeyPress);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceKeyRelease);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceKeyRelease);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceButtonPress);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceButtonPress);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceButtonRelease);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceButtonRelease);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, ProximityIn);
-    SetMaskForExtEvent (mask, ProximityOut);
-    AllowPropagateSuppress (mask);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, ProximityIn);
+    SetMaskForExtEvent(mask, ProximityOut);
+    AllowPropagateSuppress(mask);
 
-    mask = GetNextExtEventMask ();
+    mask = GetNextExtEventMask();
     DeviceStateNotifyMask = mask;
-    SetMaskForExtEvent (mask, DeviceStateNotify);
+    SetMaskForExtEvent(mask, DeviceStateNotify);
 
-    mask = GetNextExtEventMask ();
+    mask = GetNextExtEventMask();
     DevicePointerMotionMask = mask;
-    SetMaskForExtEvent (mask, DeviceMotionNotify);
-    AllowPropagateSuppress (mask);
+    SetMaskForExtEvent(mask, DeviceMotionNotify);
+    AllowPropagateSuppress(mask);
 
     DevicePointerMotionHintMask = GetNextExtEventMask();
-    SetEventInfo (DevicePointerMotionHintMask, _devicePointerMotionHint);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton1Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton2Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton3Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton4Motion);
-    SetEventInfo (GetNextExtEventMask(), _deviceButton5Motion);
+    SetEventInfo(DevicePointerMotionHintMask, _devicePointerMotionHint);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton1Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton2Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton3Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton4Motion);
+    SetEventInfo(GetNextExtEventMask(), _deviceButton5Motion);
     DeviceButtonMotionMask = GetNextExtEventMask();
-    SetEventInfo (DeviceButtonMotionMask, _deviceButtonMotion);
+    SetEventInfo(DeviceButtonMotionMask, _deviceButtonMotion);
 
-    DeviceFocusChangeMask = GetNextExtEventMask ();
-    SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusIn);
-    SetMaskForExtEvent (DeviceFocusChangeMask, DeviceFocusOut);
+    DeviceFocusChangeMask = GetNextExtEventMask();
+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusIn);
+    SetMaskForExtEvent(DeviceFocusChangeMask, DeviceFocusOut);
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, DeviceMappingNotify);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, DeviceMappingNotify);
     DeviceMappingNotifyMask = mask;
 
-    mask = GetNextExtEventMask ();
-    SetMaskForExtEvent (mask, ChangeDeviceNotify);
+    mask = GetNextExtEventMask();
+    SetMaskForExtEvent(mask, ChangeDeviceNotify);
     ChangeDeviceNotifyMask = mask;
 
     DeviceButtonGrabMask = GetNextExtEventMask();
-    SetEventInfo (DeviceButtonGrabMask, _deviceButtonGrab);
-    SetExclusiveAccess (DeviceButtonGrabMask);
+    SetEventInfo(DeviceButtonGrabMask, _deviceButtonGrab);
+    SetExclusiveAccess(DeviceButtonGrabMask);
 
     DeviceOwnerGrabButtonMask = GetNextExtEventMask();
-    SetEventInfo (DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
-    SetEventInfo (0, _noExtensionEvent);
-    }
+    SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
+    SetEventInfo(0, _noExtensionEvent);
+}
 
 /************************************************************************
  *
@@ -767,19 +757,18 @@ FixExtensionEvents (ExtensionEntry *extEntry)
  */
 
 void
-RestoreExtensionEvents (void)
+RestoreExtensionEvents(void)
 {
-    int	i;
+    int i;
 
     IReqCode = 0;
 
-    for (i=0; i<ExtEventIndex-1; i++)
-	{
+    for (i = 0; i < ExtEventIndex - 1; i++) {
 	if ((EventInfo[i].type >= LASTEvent) && (EventInfo[i].type < 128))
-	    SetMaskForEvent(0,EventInfo[i].type);
-        EventInfo[i].mask = 0;
-        EventInfo[i].type = 0;
-	}
+	    SetMaskForEvent(0, EventInfo[i].type);
+	EventInfo[i].mask = 0;
+	EventInfo[i].type = 0;
+    }
     ExtEventIndex = 0;
     lastExtEventMask = 1;
     DeviceValuator = 0;
@@ -804,7 +793,7 @@ RestoreExtensionEvents (void)
     DeviceBusy = 3;
     BadClass = 4;
 
-    }
+}
 
 /***********************************************************************
  *
@@ -815,7 +804,7 @@ RestoreExtensionEvents (void)
  */
 
 void
-IResetProc(ExtensionEntry *unused)
+IResetProc(ExtensionEntry * unused)
 {
 
     ReplySwapVector[IReqCode] = ReplyNotSwappd;
@@ -834,8 +823,8 @@ IResetProc(ExtensionEntry *unused)
     EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
     EventSwapVector[DeviceMappingNotify] = NotImplemented;
     EventSwapVector[ChangeDeviceNotify] = NotImplemented;
-    RestoreExtensionEvents ();
-    }
+    RestoreExtensionEvents();
+}
 
 /***********************************************************************
  *
@@ -844,12 +833,12 @@ IResetProc(ExtensionEntry *unused)
  */
 
 _X_EXPORT void
-AssignTypeAndName (DeviceIntPtr dev, Atom type, char *name)
+AssignTypeAndName(DeviceIntPtr dev, Atom type, char *name)
 {
     dev->type = type;
-    dev->name = (char *) xalloc(strlen(name)+1);
-    strcpy (dev->name, name);
-    }
+    dev->name = (char *)xalloc(strlen(name) + 1);
+    strcpy(dev->name, name);
+}
 
 /***********************************************************************
  *
@@ -858,14 +847,14 @@ AssignTypeAndName (DeviceIntPtr dev, Atom type, char *name)
  */
 
 void
-MakeDeviceTypeAtoms (void)
+MakeDeviceTypeAtoms(void)
 {
     int i;
 
-    for (i=0; i<NUMTYPES; i++)
-	dev_type[i].type = 
-		MakeAtom (dev_type[i].name, strlen(dev_type[i].name), 1);
-    }
+    for (i = 0; i < NUMTYPES; i++)
+	dev_type[i].type =
+	    MakeAtom(dev_type[i].name, strlen(dev_type[i].name), 1);
+}
 
 /**************************************************************************
  *
@@ -875,22 +864,19 @@ MakeDeviceTypeAtoms (void)
  */
 
 DeviceIntPtr
-LookupDeviceIntRec (
-    CARD8 id)
+LookupDeviceIntRec(CARD8 id)
 {
     DeviceIntPtr dev;
 
-    for (dev=inputInfo.devices; dev; dev=dev->next)
-	{
-	if (dev->id == id)
-	    {
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+	if (dev->id == id) {
 	    if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
 		return (NULL);
 	    return (dev);
-	    }
 	}
-    return (NULL);
     }
+    return (NULL);
+}
 
 /**************************************************************************
  *
@@ -901,13 +887,13 @@ LookupDeviceIntRec (
  */
 
 void
-SetExclusiveAccess (Mask mask)
+SetExclusiveAccess(Mask mask)
 {
     int i;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	ExtExclusiveMasks[i] |= mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -917,13 +903,13 @@ SetExclusiveAccess (Mask mask)
  */
 
 void
-AllowPropagateSuppress (Mask mask)
+AllowPropagateSuppress(Mask mask)
 {
     int i;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	PropagateMask[i] |= mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -931,22 +917,21 @@ AllowPropagateSuppress (Mask mask)
  *
  */
 
-Mask 
-GetNextExtEventMask (void)
+Mask
+GetNextExtEventMask(void)
 {
     int i;
     Mask mask = lastExtEventMask;
 
-    if (lastExtEventMask == 0)
-	{
+    if (lastExtEventMask == 0) {
 	FatalError("GetNextExtEventMask: no more events are available.");
-	}
+    }
     lastExtEventMask <<= 1;
 
-    for (i=0; i<MAX_DEVICES; i++)
+    for (i = 0; i < MAX_DEVICES; i++)
 	ExtValidMasks[i] |= mask;
     return mask;
-    }
+}
 
 /**************************************************************************
  *
@@ -963,8 +948,8 @@ SetMaskForExtEvent(Mask mask, int event)
 
     if ((event < LASTEvent) || (event >= 128))
 	FatalError("MaskForExtensionEvent: bogus event number");
-    SetMaskForEvent(mask,event);
-    }
+    SetMaskForEvent(mask, event);
+}
 
 /**************************************************************************
  *
@@ -984,4 +969,4 @@ SetEventInfo(Mask mask, int constant)
 {
     EventInfo[ExtEventIndex].mask = mask;
     EventInfo[ExtEventIndex++].type = constant;
-    }
+}
diff --git a/Xi/getbmap.c b/Xi/getbmap.c
index c4a411b24..32874764b 100644
--- a/Xi/getbmap.c
+++ b/Xi/getbmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: getbmap.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getbmap.c,v 3.2 2001/01/17 22:13:24 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,13 +56,13 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getbmap.h"
@@ -83,8 +80,8 @@ SProcXGetDeviceButtonMapping(register ClientPtr client)
 
     REQUEST(xGetDeviceButtonMappingReq);
     swaps(&stuff->length, n);
-    return(ProcXGetDeviceButtonMapping(client));
-    }
+    return (ProcXGetDeviceButtonMapping(client));
+}
 
 /***********************************************************************
  *
@@ -93,11 +90,11 @@ SProcXGetDeviceButtonMapping(register ClientPtr client)
  */
 
 int
-ProcXGetDeviceButtonMapping (register ClientPtr client)
+ProcXGetDeviceButtonMapping(register ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    xGetDeviceButtonMappingReply	rep;
-    ButtonClassPtr	b;
+    DeviceIntPtr dev;
+    xGetDeviceButtonMappingReply rep;
+    ButtonClassPtr b;
 
     REQUEST(xGetDeviceButtonMappingReq);
     REQUEST_SIZE_MATCH(xGetDeviceButtonMappingReq);
@@ -108,28 +105,25 @@ ProcXGetDeviceButtonMapping (register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     b = dev->button;
-    if (b == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0, 
-		BadMatch);
+    if (b == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
+			  BadMatch);
 	return Success;
-	}
+    }
     rep.nElts = b->numButtons;
-    rep.length = (rep.nElts + (4-1))/4;
-    WriteReplyToClient (client, sizeof (xGetDeviceButtonMappingReply), &rep);
-    (void)WriteToClient(client, rep.nElts,
-			(char *)&b->map[1]);
+    rep.length = (rep.nElts + (4 - 1)) / 4;
+    WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
+    (void)WriteToClient(client, rep.nElts, (char *)&b->map[1]);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -139,11 +133,12 @@ ProcXGetDeviceButtonMapping (register ClientPtr client)
  */
 
 void
-SRepXGetDeviceButtonMapping (ClientPtr client, int size, xGetDeviceButtonMappingReply *rep)
+SRepXGetDeviceButtonMapping(ClientPtr client, int size,
+			    xGetDeviceButtonMappingReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getbmap.h b/Xi/getbmap.h
index 01cc3780a..d95b3c67c 100644
--- a/Xi/getbmap.h
+++ b/Xi/getbmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getbmap.h,v 3.1 1996/04/15 11:18:37 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetDeviceButtonMapping (
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetDeviceButtonMapping (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceButtonMappingReply * /* rep */
-	);
+int SProcXGetDeviceButtonMapping(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceButtonMapping(ClientPtr	/* client */
+    );
+
+void SRepXGetDeviceButtonMapping(ClientPtr /* client */ ,
+				 int /* size */ ,
+				 xGetDeviceButtonMappingReply *	/* rep */
+    );
 
 #endif /* GETBMAP_H */
diff --git a/Xi/getdctl.c b/Xi/getdctl.c
index 672824985..c2b69fd71 100644
--- a/Xi/getdctl.c
+++ b/Xi/getdctl.c
@@ -1,5 +1,3 @@
-/* $Xorg: getdctl.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getdctl.c,v 3.3 2001/01/17 22:13:24 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,19 +50,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getdctl.h"
@@ -86,8 +83,8 @@ SProcXGetDeviceControl(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetDeviceControlReq);
     swaps(&stuff->control, n);
-    return(ProcXGetDeviceControl(client));
-    }
+    return (ProcXGetDeviceControl(client));
+}
 
 /***********************************************************************
  *
@@ -98,7 +95,7 @@ SProcXGetDeviceControl(register ClientPtr client)
 int
 ProcXGetDeviceControl(ClientPtr client)
 {
-    int	total_length = 0;
+    int total_length = 0;
     char *buf, *savbuf;
     register DeviceIntPtr dev;
     xGetDeviceControlReply rep;
@@ -106,62 +103,53 @@ ProcXGetDeviceControl(ClientPtr client)
     REQUEST(xGetDeviceControlReq);
     REQUEST_SIZE_MATCH(xGetDeviceControlReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadDevice);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceControl;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    switch (stuff->control)
-	{
-	case DEVICE_RESOLUTION:
-	    if (!dev->valuator)
-		{
-		SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
-		    BadMatch);
-		return Success;
-		}
-	    total_length = sizeof (xDeviceResolutionState) +
-		(3 * sizeof(int) * dev->valuator->numAxes);
-	    break;
-	default:
-	    SendErrorToClient (client, IReqCode, X_GetDeviceControl, 0, 
-		BadValue);
+    switch (stuff->control) {
+    case DEVICE_RESOLUTION:
+	if (!dev->valuator) {
+	    SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+			      BadMatch);
 	    return Success;
 	}
+	total_length = sizeof(xDeviceResolutionState) +
+	    (3 * sizeof(int) * dev->valuator->numAxes);
+	break;
+    default:
+	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
+	return Success;
+    }
 
-    buf = (char *) xalloc (total_length);
-    if (!buf)
-	{
-	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, 
-		BadAlloc);
+    buf = (char *)xalloc(total_length);
+    if (!buf) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadAlloc);
 	return Success;
-	}
-    savbuf=buf;
-
-    switch (stuff->control)
-	{
-	case DEVICE_RESOLUTION:
-	    CopySwapDeviceResolution(client, dev->valuator, buf,
-		total_length);
-	    break;
-	default:
-	    break;
-	}
+    }
+    savbuf = buf;
+
+    switch (stuff->control) {
+    case DEVICE_RESOLUTION:
+	CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
+	break;
+    default:
+	break;
+    }
 
-    rep.length = (total_length+3) >> 2;
+    rep.length = (total_length + 3) >> 2;
     WriteReplyToClient(client, sizeof(xGetDeviceControlReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    xfree(savbuf);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -170,37 +158,36 @@ ProcXGetDeviceControl(ClientPtr client)
  */
 
 void
-CopySwapDeviceResolution (ClientPtr client, ValuatorClassPtr v, char *buf, int length)
+CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
+			 int length)
 {
-    register char 	n;
-    AxisInfoPtr	a;
+    register char n;
+    AxisInfoPtr a;
     xDeviceResolutionState *r;
     int i, *iptr;
 
     r = (xDeviceResolutionState *) buf;
     r->control = DEVICE_RESOLUTION;
-    r->length =  length;
-    r->num_valuators =  v->numAxes;
-    buf += sizeof (xDeviceResolutionState);
-    iptr = (int *) buf;
-    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+    r->length = length;
+    r->num_valuators = v->numAxes;
+    buf += sizeof(xDeviceResolutionState);
+    iptr = (int *)buf;
+    for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
 	*iptr++ = a->resolution;
-    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+    for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
 	*iptr++ = a->min_resolution;
-    for (i=0,a=v->axes; i<v->numAxes; i++,a++)
+    for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
 	*iptr++ = a->max_resolution;
-    if (client->swapped)
-	{
-	swaps (&r->control,n);
-	swaps (&r->length,n);
-	swapl (&r->num_valuators,n);
-	iptr = (int *) buf;
-	for (i=0; i < (3 * v->numAxes); i++,iptr++)
-	    {
-	    swapl (iptr,n);
-	    }
+    if (client->swapped) {
+	swaps(&r->control, n);
+	swaps(&r->length, n);
+	swapl(&r->num_valuators, n);
+	iptr = (int *)buf;
+	for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
+	    swapl(iptr, n);
 	}
     }
+}
 
 /***********************************************************************
  *
@@ -210,12 +197,11 @@ CopySwapDeviceResolution (ClientPtr client, ValuatorClassPtr v, char *buf, int l
  */
 
 void
-SRepXGetDeviceControl (ClientPtr client, int size, xGetDeviceControlReply *rep)
+SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
-
+}
diff --git a/Xi/getdctl.h b/Xi/getdctl.h
index 168620eca..c7cfb19d2 100644
--- a/Xi/getdctl.h
+++ b/Xi/getdctl.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getdctl.h,v 3.1 1996/04/15 11:18:38 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,29 +30,21 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETDCTL_H
 #define GETDCTL_H 1
 
-int
-SProcXGetDeviceControl (
-	ClientPtr              /* client */
-	);
-
-int
-ProcXGetDeviceControl (
-	ClientPtr              /* client */
-	);
-
-void
-CopySwapDeviceResolution (
-	ClientPtr              /* client */,
-	ValuatorClassPtr       /* v */,
-	char *                 /* buf */,
-	int                    /* length */
-	);
-
-void
-SRepXGetDeviceControl (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceControlReply * /* rep */
-	);
+int SProcXGetDeviceControl(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceControl(ClientPtr	/* client */
+    );
+
+void CopySwapDeviceResolution(ClientPtr /* client */ ,
+			      ValuatorClassPtr /* v */ ,
+			      char * /* buf */ ,
+			      int	/* length */
+    );
+
+void SRepXGetDeviceControl(ClientPtr /* client */ ,
+			   int /* size */ ,
+			   xGetDeviceControlReply *	/* rep */
+    );
 
 #endif /* GETDCTL_H */
diff --git a/Xi/getfctl.c b/Xi/getfctl.c
index 308b7ebf3..870348fbb 100644
--- a/Xi/getfctl.c
+++ b/Xi/getfctl.c
@@ -1,5 +1,3 @@
-/* $Xorg: getfctl.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getfctl.c,v 3.3 2001/01/17 22:13:24 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,19 +50,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getfctl.h"
@@ -84,8 +81,8 @@ SProcXGetFeedbackControl(register ClientPtr client)
 
     REQUEST(xGetFeedbackControlReq);
     swaps(&stuff->length, n);
-    return(ProcXGetFeedbackControl(client));
-    }
+    return (ProcXGetFeedbackControl(client));
+}
 
 /***********************************************************************
  *
@@ -96,7 +93,7 @@ SProcXGetFeedbackControl(register ClientPtr client)
 int
 ProcXGetFeedbackControl(ClientPtr client)
 {
-    int	total_length = 0;
+    int total_length = 0;
     char *buf, *savbuf;
     register DeviceIntPtr dev;
     KbdFeedbackPtr k;
@@ -110,13 +107,11 @@ ProcXGetFeedbackControl(ClientPtr client)
     REQUEST(xGetFeedbackControlReq);
     REQUEST_SIZE_MATCH(xGetFeedbackControlReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetFeedbackControl, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadDevice);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetFeedbackControl;
@@ -124,73 +119,63 @@ ProcXGetFeedbackControl(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.num_feedbacks = 0;
 
-    for (k=dev->kbdfeed; k; k=k->next)
-	{
+    for (k = dev->kbdfeed; k; k = k->next) {
 	rep.num_feedbacks++;
 	total_length += sizeof(xKbdFeedbackState);
-	}
-    for (p=dev->ptrfeed; p; p=p->next)
-	{
+    }
+    for (p = dev->ptrfeed; p; p = p->next) {
 	rep.num_feedbacks++;
 	total_length += sizeof(xPtrFeedbackState);
-	}
-    for (s=dev->stringfeed; s; s=s->next)
-	{
+    }
+    for (s = dev->stringfeed; s; s = s->next) {
 	rep.num_feedbacks++;
-	total_length += sizeof(xStringFeedbackState) + 
-	    (s->ctrl.num_symbols_supported * sizeof (KeySym));
-	}
-    for (i=dev->intfeed; i; i=i->next)
-	{
+	total_length += sizeof(xStringFeedbackState) +
+	    (s->ctrl.num_symbols_supported * sizeof(KeySym));
+    }
+    for (i = dev->intfeed; i; i = i->next) {
 	rep.num_feedbacks++;
 	total_length += sizeof(xIntegerFeedbackState);
-	}
-    for (l=dev->leds; l; l=l->next)
-	{
+    }
+    for (l = dev->leds; l; l = l->next) {
 	rep.num_feedbacks++;
 	total_length += sizeof(xLedFeedbackState);
-	}
-    for (b=dev->bell; b; b=b->next)
-	{
+    }
+    for (b = dev->bell; b; b = b->next) {
 	rep.num_feedbacks++;
 	total_length += sizeof(xBellFeedbackState);
-	}
+    }
 
-    if (total_length == 0)
-	{
-	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, 
-		BadMatch);
+    if (total_length == 0) {
+	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadMatch);
 	return Success;
-	}
+    }
 
-    buf = (char *) xalloc (total_length);
-    if (!buf)
-	{
-	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, 
-		BadAlloc);
+    buf = (char *)xalloc(total_length);
+    if (!buf) {
+	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadAlloc);
 	return Success;
-	}
-    savbuf=buf;
-
-    for (k=dev->kbdfeed; k; k=k->next)
-	CopySwapKbdFeedback (client, k, &buf);
-    for (p=dev->ptrfeed; p; p=p->next)
-	CopySwapPtrFeedback (client, p, &buf);
-    for (s=dev->stringfeed; s; s=s->next)
-	CopySwapStringFeedback (client, s, &buf);
-    for (i=dev->intfeed; i; i=i->next)
-	CopySwapIntegerFeedback (client, i, &buf);
-    for (l=dev->leds; l; l=l->next)
-	CopySwapLedFeedback (client, l, &buf);
-    for (b=dev->bell; b; b=b->next)
-	CopySwapBellFeedback (client, b, &buf);
-
-    rep.length = (total_length+3) >> 2;
+    }
+    savbuf = buf;
+
+    for (k = dev->kbdfeed; k; k = k->next)
+	CopySwapKbdFeedback(client, k, &buf);
+    for (p = dev->ptrfeed; p; p = p->next)
+	CopySwapPtrFeedback(client, p, &buf);
+    for (s = dev->stringfeed; s; s = s->next)
+	CopySwapStringFeedback(client, s, &buf);
+    for (i = dev->intfeed; i; i = i->next)
+	CopySwapIntegerFeedback(client, i, &buf);
+    for (l = dev->leds; l; l = l->next)
+	CopySwapLedFeedback(client, l, &buf);
+    for (b = dev->bell; b; b = b->next)
+	CopySwapBellFeedback(client, b, &buf);
+
+    rep.length = (total_length + 3) >> 2;
     WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    xfree(savbuf);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -199,15 +184,15 @@ ProcXGetFeedbackControl(ClientPtr client)
  */
 
 void
-CopySwapKbdFeedback (ClientPtr client, KbdFeedbackPtr k, char **buf)
+CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
 {
-    int	i;
-    register char 	n;
-    xKbdFeedbackState	*k2;
+    int i;
+    register char n;
+    xKbdFeedbackState *k2;
 
-    k2 = (xKbdFeedbackState *) *buf;
+    k2 = (xKbdFeedbackState *) * buf;
     k2->class = KbdFeedbackClass;
-    k2->length = sizeof (xKbdFeedbackState);
+    k2->length = sizeof(xKbdFeedbackState);
     k2->id = k->ctrl.id;
     k2->click = k->ctrl.click;
     k2->percent = k->ctrl.bell;
@@ -215,18 +200,17 @@ CopySwapKbdFeedback (ClientPtr client, KbdFeedbackPtr k, char **buf)
     k2->duration = k->ctrl.bell_duration;
     k2->led_mask = k->ctrl.leds;
     k2->global_auto_repeat = k->ctrl.autoRepeat;
-    for (i=0; i<32; i++)
+    for (i = 0; i < 32; i++)
 	k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
-    if (client->swapped)
-	{
-	swaps(&k2->length,n);
-	swaps(&k2->pitch,n);
-	swaps(&k2->duration,n);
-	swapl(&k2->led_mask,n);
-	swapl(&k2->led_values,n);
-	}
-    *buf += sizeof (xKbdFeedbackState);
+    if (client->swapped) {
+	swaps(&k2->length, n);
+	swaps(&k2->pitch, n);
+	swaps(&k2->duration, n);
+	swapl(&k2->led_mask, n);
+	swapl(&k2->led_values, n);
     }
+    *buf += sizeof(xKbdFeedbackState);
+}
 
 /***********************************************************************
  *
@@ -235,27 +219,26 @@ CopySwapKbdFeedback (ClientPtr client, KbdFeedbackPtr k, char **buf)
  */
 
 void
-CopySwapPtrFeedback (ClientPtr client, PtrFeedbackPtr p, char **buf)
+CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
 {
-    register char 	n;
-    xPtrFeedbackState	*p2;
+    register char n;
+    xPtrFeedbackState *p2;
 
-    p2 = (xPtrFeedbackState *) *buf;
+    p2 = (xPtrFeedbackState *) * buf;
     p2->class = PtrFeedbackClass;
-    p2->length = sizeof (xPtrFeedbackState);
+    p2->length = sizeof(xPtrFeedbackState);
     p2->id = p->ctrl.id;
     p2->accelNum = p->ctrl.num;
     p2->accelDenom = p->ctrl.den;
     p2->threshold = p->ctrl.threshold;
-    if (client->swapped)
-	{
-	swaps(&p2->length,n);
-	swaps(&p2->accelNum,n);
-	swaps(&p2->accelDenom,n);
-	swaps(&p2->threshold,n);
-	}
-    *buf += sizeof (xPtrFeedbackState);
+    if (client->swapped) {
+	swaps(&p2->length, n);
+	swaps(&p2->accelNum, n);
+	swaps(&p2->accelDenom, n);
+	swaps(&p2->threshold, n);
     }
+    *buf += sizeof(xPtrFeedbackState);
+}
 
 /***********************************************************************
  *
@@ -264,27 +247,26 @@ CopySwapPtrFeedback (ClientPtr client, PtrFeedbackPtr p, char **buf)
  */
 
 void
-CopySwapIntegerFeedback (ClientPtr client, IntegerFeedbackPtr i, char **buf)
+CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
 {
-    register char 		n;
-    xIntegerFeedbackState	*i2;
+    register char n;
+    xIntegerFeedbackState *i2;
 
-    i2 = (xIntegerFeedbackState *) *buf;
+    i2 = (xIntegerFeedbackState *) * buf;
     i2->class = IntegerFeedbackClass;
-    i2->length = sizeof (xIntegerFeedbackState);
+    i2->length = sizeof(xIntegerFeedbackState);
     i2->id = i->ctrl.id;
     i2->resolution = i->ctrl.resolution;
     i2->min_value = i->ctrl.min_value;
     i2->max_value = i->ctrl.max_value;
-    if (client->swapped)
-	{
-	swaps(&i2->length,n);
-	swapl(&i2->resolution,n);
-	swapl(&i2->min_value,n);
-	swapl(&i2->max_value,n);
-	}
-    *buf += sizeof (xIntegerFeedbackState);
+    if (client->swapped) {
+	swaps(&i2->length, n);
+	swapl(&i2->resolution, n);
+	swapl(&i2->min_value, n);
+	swapl(&i2->max_value, n);
     }
+    *buf += sizeof(xIntegerFeedbackState);
+}
 
 /***********************************************************************
  *
@@ -293,37 +275,35 @@ CopySwapIntegerFeedback (ClientPtr client, IntegerFeedbackPtr i, char **buf)
  */
 
 void
-CopySwapStringFeedback (ClientPtr client, StringFeedbackPtr s, char **buf)
+CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
 {
     int i;
-    register char 		n;
-    xStringFeedbackState	*s2;
-    KeySym			*kptr;
+    register char n;
+    xStringFeedbackState *s2;
+    KeySym *kptr;
 
-    s2 = (xStringFeedbackState *) *buf;
+    s2 = (xStringFeedbackState *) * buf;
     s2->class = StringFeedbackClass;
-    s2->length = sizeof (xStringFeedbackState) + 
-        s->ctrl.num_symbols_supported * sizeof (KeySym);
+    s2->length = sizeof(xStringFeedbackState) +
+	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);
+    *buf += sizeof(xStringFeedbackState);
     kptr = (KeySym *) (*buf);
-    for (i=0; i<s->ctrl.num_symbols_supported; i++)
-	*kptr++ = *(s->ctrl.symbols_supported+i);
-    if (client->swapped)
-	{
-	swaps(&s2->length,n);
-	swaps(&s2->max_symbols,n);
-	swaps(&s2->num_syms_supported,n);
-        kptr = (KeySym *) (*buf);
-	for (i=0; i<s->ctrl.num_symbols_supported; i++,kptr++)
-	    {
-	    swapl(kptr,n);
-	    }
+    for (i = 0; i < s->ctrl.num_symbols_supported; i++)
+	*kptr++ = *(s->ctrl.symbols_supported + i);
+    if (client->swapped) {
+	swaps(&s2->length, n);
+	swaps(&s2->max_symbols, n);
+	swaps(&s2->num_syms_supported, n);
+	kptr = (KeySym *) (*buf);
+	for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
+	    swapl(kptr, n);
 	}
-    *buf += (s->ctrl.num_symbols_supported * sizeof (KeySym));
     }
+    *buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
+}
 
 /***********************************************************************
  *
@@ -332,25 +312,24 @@ CopySwapStringFeedback (ClientPtr client, StringFeedbackPtr s, char **buf)
  */
 
 void
-CopySwapLedFeedback (ClientPtr client, LedFeedbackPtr l, char **buf)
+CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
 {
-    register char 	n;
-    xLedFeedbackState	*l2;
+    register char n;
+    xLedFeedbackState *l2;
 
-    l2 = (xLedFeedbackState *) *buf;
+    l2 = (xLedFeedbackState *) * buf;
     l2->class = LedFeedbackClass;
-    l2->length = sizeof (xLedFeedbackState);
+    l2->length = sizeof(xLedFeedbackState);
     l2->id = l->ctrl.id;
     l2->led_values = l->ctrl.led_values;
     l2->led_mask = l->ctrl.led_mask;
-    if (client->swapped)
-	{
-	swaps(&l2->length,n);
-	swapl(&l2->led_values,n);
-	swapl(&l2->led_mask,n);
-	}
-    *buf += sizeof (xLedFeedbackState);
+    if (client->swapped) {
+	swaps(&l2->length, n);
+	swapl(&l2->led_values, n);
+	swapl(&l2->led_mask, n);
     }
+    *buf += sizeof(xLedFeedbackState);
+}
 
 /***********************************************************************
  *
@@ -359,26 +338,25 @@ CopySwapLedFeedback (ClientPtr client, LedFeedbackPtr l, char **buf)
  */
 
 void
-CopySwapBellFeedback (ClientPtr client, BellFeedbackPtr b, char **buf)
+CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
 {
-    register char 	n;
-    xBellFeedbackState	*b2;
+    register char n;
+    xBellFeedbackState *b2;
 
-    b2 = (xBellFeedbackState *) *buf;
+    b2 = (xBellFeedbackState *) * buf;
     b2->class = BellFeedbackClass;
-    b2->length = sizeof (xBellFeedbackState);
+    b2->length = sizeof(xBellFeedbackState);
     b2->id = b->ctrl.id;
     b2->percent = b->ctrl.percent;
     b2->pitch = b->ctrl.pitch;
     b2->duration = b->ctrl.duration;
-    if (client->swapped)
-	{
-	swaps(&b2->length,n);
-	swaps(&b2->pitch,n);
-	swaps(&b2->duration,n);
-	}
-    *buf += sizeof (xBellFeedbackState);
+    if (client->swapped) {
+	swaps(&b2->length, n);
+	swaps(&b2->pitch, n);
+	swaps(&b2->duration, n);
     }
+    *buf += sizeof(xBellFeedbackState);
+}
 
 /***********************************************************************
  *
@@ -388,7 +366,8 @@ CopySwapBellFeedback (ClientPtr client, BellFeedbackPtr b, char **buf)
  */
 
 void
-SRepXGetFeedbackControl (ClientPtr client, int size, xGetFeedbackControlReply *rep)
+SRepXGetFeedbackControl(ClientPtr client, int size,
+			xGetFeedbackControlReply * rep)
 {
     register char n;
 
@@ -396,4 +375,4 @@ SRepXGetFeedbackControl (ClientPtr client, int size, xGetFeedbackControlReply *r
     swapl(&rep->length, n);
     swaps(&rep->num_feedbacks, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getfctl.h b/Xi/getfctl.h
index 97805d9af..7d2d17ab1 100644
--- a/Xi/getfctl.h
+++ b/Xi/getfctl.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getfctl.h,v 3.1 1996/04/15 11:18:39 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,63 +30,45 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef GETFCTL_H
 #define GETFCTL_H 1
 
-int
-SProcXGetFeedbackControl(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXGetFeedbackControl(
-	ClientPtr              /* client */
-	);
-
-void
-CopySwapKbdFeedback (
-	ClientPtr              /* client */,
-	KbdFeedbackPtr         /* k */,
-	char **                /* buf */
-	);
-
-void
-CopySwapPtrFeedback (
-	ClientPtr              /* client */,
-	PtrFeedbackPtr         /* p */,
-	char **                /* buf */
-	);
-
-void
-CopySwapIntegerFeedback (
-	ClientPtr              /* client */,
-	IntegerFeedbackPtr     /* i */,
-	char **                /* buf */
-	);
-
-void
-CopySwapStringFeedback (
-	ClientPtr              /* client */,
-	StringFeedbackPtr      /* s */,
-	char **                /* buf */
-	);
-
-void
-CopySwapLedFeedback (
-	ClientPtr              /* client */,
-	LedFeedbackPtr         /* l */,
-	char **                /* buf */
-	);
-
-void
-CopySwapBellFeedback (
-	ClientPtr              /* client */,
-	BellFeedbackPtr        /* b */,
-	char **                /* buf */
-	);
-
-void
-SRepXGetFeedbackControl (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetFeedbackControlReply * /* rep */
-	);
+int SProcXGetFeedbackControl(ClientPtr	/* client */
+    );
+
+int ProcXGetFeedbackControl(ClientPtr	/* client */
+    );
+
+void CopySwapKbdFeedback(ClientPtr /* client */ ,
+			 KbdFeedbackPtr /* k */ ,
+			 char **	/* buf */
+    );
+
+void CopySwapPtrFeedback(ClientPtr /* client */ ,
+			 PtrFeedbackPtr /* p */ ,
+			 char **	/* buf */
+    );
+
+void CopySwapIntegerFeedback(ClientPtr /* client */ ,
+			     IntegerFeedbackPtr /* i */ ,
+			     char **	/* buf */
+    );
+
+void CopySwapStringFeedback(ClientPtr /* client */ ,
+			    StringFeedbackPtr /* s */ ,
+			    char **	/* buf */
+    );
+
+void CopySwapLedFeedback(ClientPtr /* client */ ,
+			 LedFeedbackPtr /* l */ ,
+			 char **	/* buf */
+    );
+
+void CopySwapBellFeedback(ClientPtr /* client */ ,
+			  BellFeedbackPtr /* b */ ,
+			  char **	/* buf */
+    );
+
+void SRepXGetFeedbackControl(ClientPtr /* client */ ,
+			     int /* size */ ,
+			     xGetFeedbackControlReply *	/* rep */
+    );
 
 #endif /* GETFCTL_H */
diff --git a/Xi/getfocus.c b/Xi/getfocus.c
index 9cac93b0e..1bcb67321 100644
--- a/Xi/getfocus.c
+++ b/Xi/getfocus.c
@@ -1,5 +1,3 @@
-/* $Xorg: getfocus.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getfocus.c,v 3.2 2001/01/17 22:13:24 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "windowstr.h"			/* focus struct      */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "windowstr.h"	/* focus struct      */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getfocus.h"
@@ -84,8 +81,8 @@ SProcXGetDeviceFocus(register ClientPtr client)
 
     REQUEST(xGetDeviceFocusReq);
     swaps(&stuff->length, n);
-    return(ProcXGetDeviceFocus(client));
-    }
+    return (ProcXGetDeviceFocus(client));
+}
 
 /***********************************************************************
  *
@@ -96,19 +93,18 @@ SProcXGetDeviceFocus(register ClientPtr client)
 int
 ProcXGetDeviceFocus(ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    FocusClassPtr 	focus;
+    DeviceIntPtr dev;
+    FocusClassPtr focus;
     xGetDeviceFocusReply rep;
 
     REQUEST(xGetDeviceFocusReq);
     REQUEST_SIZE_MATCH(xGetDeviceFocusReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL || !dev->focus)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL || !dev->focus) {
 	SendErrorToClient(client, IReqCode, X_GetDeviceFocus, 0, BadDevice);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceFocus;
@@ -123,14 +119,14 @@ ProcXGetDeviceFocus(ClientPtr client)
 	rep.focus = PointerRoot;
     else if (focus->win == FollowKeyboardWin)
 	rep.focus = FollowKeyboard;
-    else 
+    else
 	rep.focus = focus->win->drawable.id;
 
     rep.time = focus->time.milliseconds;
     rep.revertTo = focus->revert;
-    WriteReplyToClient (client, sizeof(xGetDeviceFocusReply), &rep);
+    WriteReplyToClient(client, sizeof(xGetDeviceFocusReply), &rep);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -140,7 +136,7 @@ ProcXGetDeviceFocus(ClientPtr client)
  */
 
 void
-SRepXGetDeviceFocus (ClientPtr client, int size, xGetDeviceFocusReply *rep)
+SRepXGetDeviceFocus(ClientPtr client, int size, xGetDeviceFocusReply * rep)
 {
     register char n;
 
@@ -149,4 +145,4 @@ SRepXGetDeviceFocus (ClientPtr client, int size, xGetDeviceFocusReply *rep)
     swapl(&rep->focus, n);
     swapl(&rep->time, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getfocus.h b/Xi/getfocus.h
index 5d6438e1d..c3f2d67b6 100644
--- a/Xi/getfocus.h
+++ b/Xi/getfocus.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getfocus.h,v 3.1 1996/04/15 11:18:40 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetDeviceFocus(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetDeviceFocus (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceFocusReply * /* rep */
-	);
+int SProcXGetDeviceFocus(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceFocus(ClientPtr	/* client */
+    );
+
+void SRepXGetDeviceFocus(ClientPtr /* client */ ,
+			 int /* size */ ,
+			 xGetDeviceFocusReply *	/* rep */
+    );
 
 #endif /* GETFOCUS_H */
diff --git a/Xi/getkmap.c b/Xi/getkmap.c
index 5de044677..041e2c69f 100644
--- a/Xi/getkmap.c
+++ b/Xi/getkmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: getkmap.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getkmap.c,v 3.3 2001/01/17 22:13:24 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,19 +50,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
 
@@ -85,8 +82,8 @@ SProcXGetDeviceKeyMapping(register ClientPtr client)
 
     REQUEST(xGetDeviceKeyMappingReq);
     swaps(&stuff->length, n);
-    return(ProcXGetDeviceKeyMapping(client));
-    }
+    return (ProcXGetDeviceKeyMapping(client));
+}
 
 /***********************************************************************
  *
@@ -99,60 +96,52 @@ ProcXGetDeviceKeyMapping(register ClientPtr client)
 {
     xGetDeviceKeyMappingReply rep;
     DeviceIntPtr dev;
-    KeySymsPtr	k;
+    KeySymsPtr k;
 
     REQUEST(xGetDeviceKeyMappingReq);
     REQUEST_SIZE_MATCH(xGetDeviceKeyMappingReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
-    if (dev->key == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
-		BadMatch);
+    if (dev->key == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadMatch);
 	return Success;
-	}
-    k =  &dev->key->curKeySyms;
+    }
+    k = &dev->key->curKeySyms;
 
     if ((stuff->firstKeyCode < k->minKeyCode) ||
-        (stuff->firstKeyCode > k->maxKeyCode))
-        {
+	(stuff->firstKeyCode > k->maxKeyCode)) {
 	client->errorValue = stuff->firstKeyCode;
-	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
-		BadValue);
+	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
 	return Success;
-        }
+    }
 
-    if (stuff->firstKeyCode + stuff->count > k->maxKeyCode + 1)
-        {
+    if (stuff->firstKeyCode + stuff->count > k->maxKeyCode + 1) {
 	client->errorValue = stuff->count;
-	SendErrorToClient (client, IReqCode, X_GetDeviceKeyMapping, 0, 
-		BadValue);
+	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
 	return Success;
-        }
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceKeyMapping;
     rep.sequenceNumber = client->sequence;
     rep.keySymsPerKeyCode = k->mapWidth;
-    rep.length = (k->mapWidth * stuff->count); /* KeySyms are 4 bytes */
+    rep.length = (k->mapWidth * stuff->count);	/* KeySyms are 4 bytes */
     WriteReplyToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep);
 
-    client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write;
-    WriteSwappedDataToClient(
-	client,
-	k->mapWidth * stuff->count * sizeof(KeySym),
-	&k->map[(stuff->firstKeyCode - k->minKeyCode) *
-	k->mapWidth]);
+    client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write;
+    WriteSwappedDataToClient(client,
+			     k->mapWidth * stuff->count * sizeof(KeySym),
+			     &k->map[(stuff->firstKeyCode - k->minKeyCode) *
+				     k->mapWidth]);
 
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -162,12 +151,12 @@ ProcXGetDeviceKeyMapping(register ClientPtr client)
  */
 
 void
-SRepXGetDeviceKeyMapping (ClientPtr client, int size, xGetDeviceKeyMappingReply *rep)
+SRepXGetDeviceKeyMapping(ClientPtr client, int size,
+			 xGetDeviceKeyMappingReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
-
+}
diff --git a/Xi/getkmap.h b/Xi/getkmap.h
index 5c2e3b189..58c8f12e6 100644
--- a/Xi/getkmap.h
+++ b/Xi/getkmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getkmap.h,v 3.1 1996/04/15 11:18:41 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetDeviceKeyMapping(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetDeviceKeyMapping (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceKeyMappingReply * /* rep */
-	);
+int SProcXGetDeviceKeyMapping(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceKeyMapping(ClientPtr	/* client */
+    );
+
+void SRepXGetDeviceKeyMapping(ClientPtr /* client */ ,
+			      int /* size */ ,
+			      xGetDeviceKeyMappingReply *	/* rep */
+    );
 
 #endif /* GETKMAP_H */
diff --git a/Xi/getmmap.c b/Xi/getmmap.c
index 310452a14..e664dc910 100644
--- a/Xi/getmmap.c
+++ b/Xi/getmmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: getmmap.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getmmap.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,19 +50,19 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
-#include <X11/extensions/XIproto.h>			/* Request macro     */
+#include <X11/extensions/XIproto.h>	/* Request macro     */
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getmmap.h"
@@ -84,8 +81,8 @@ SProcXGetDeviceModifierMapping(register ClientPtr client)
 
     REQUEST(xGetDeviceModifierMappingReq);
     swaps(&stuff->length, n);
-    return(ProcXGetDeviceModifierMapping(client));
-    }
+    return (ProcXGetDeviceModifierMapping(client));
+}
 
 /***********************************************************************
  *
@@ -96,44 +93,42 @@ SProcXGetDeviceModifierMapping(register ClientPtr client)
 int
 ProcXGetDeviceModifierMapping(ClientPtr client)
 {
-    CARD8				maxkeys;
-    DeviceIntPtr			dev;
-    xGetDeviceModifierMappingReply 	rep;
-    KeyClassPtr 			kp;
-    
+    CARD8 maxkeys;
+    DeviceIntPtr dev;
+    xGetDeviceModifierMappingReply rep;
+    KeyClassPtr kp;
+
     REQUEST(xGetDeviceModifierMappingReq);
     REQUEST_SIZE_MATCH(xGetDeviceModifierMappingReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetDeviceModifierMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     kp = dev->key;
-    if (kp == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_GetDeviceModifierMapping, 0, 
-		BadMatch);
+    if (kp == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
+			  BadMatch);
 	return Success;
-	}
-    maxkeys =  kp->maxKeysPerModifier;
+    }
+    maxkeys = kp->maxKeysPerModifier;
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceModifierMapping;
     rep.numKeyPerModifier = maxkeys;
     rep.sequenceNumber = client->sequence;
     /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
-    rep.length = 2*maxkeys;
+    rep.length = 2 * maxkeys;
 
     WriteReplyToClient(client, sizeof(xGetDeviceModifierMappingReply), &rep);
 
     /* Reply with the (modified by DDX) map that SetModifierMapping passed in */
-    WriteToClient(client, 8*maxkeys, (char *)kp->modifierKeyMap);
+    WriteToClient(client, 8 * maxkeys, (char *)kp->modifierKeyMap);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -143,11 +138,12 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
  */
 
 void
-SRepXGetDeviceModifierMapping (ClientPtr client, int size, xGetDeviceModifierMappingReply *rep)
+SRepXGetDeviceModifierMapping(ClientPtr client, int size,
+			      xGetDeviceModifierMappingReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getmmap.h b/Xi/getmmap.h
index 88e4af427..9a93bb8c5 100644
--- a/Xi/getmmap.h
+++ b/Xi/getmmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getmmap.h,v 3.1 1996/04/15 11:18:42 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetDeviceModifierMapping(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetDeviceModifierMapping (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceModifierMappingReply * /* rep */
-	);
+int SProcXGetDeviceModifierMapping(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceModifierMapping(ClientPtr	/* client */
+    );
+
+void SRepXGetDeviceModifierMapping(ClientPtr /* client */ ,
+				   int /* size */ ,
+				   xGetDeviceModifierMappingReply *	/* rep */
+    );
 
 #endif /* GETMMAP_H */
diff --git a/Xi/getprop.c b/Xi/getprop.c
index bbca24574..530841032 100644
--- a/Xi/getprop.c
+++ b/Xi/getprop.c
@@ -1,5 +1,3 @@
-/* $Xorg: getprop.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getprop.c,v 3.5 2001/08/23 14:56:19 alanh Exp $ */
 
 /***********************************************************************
  *
@@ -59,21 +56,21 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structs    */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structs    */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
 
 #include "getprop.h"
 
-extern			XExtEventInfo EventInfo[];
-extern int	ExtEventIndex;
+extern XExtEventInfo EventInfo[];
+extern int ExtEventIndex;
 
 /***********************************************************************
  *
@@ -90,8 +87,8 @@ SProcXGetDeviceDontPropagateList(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq);
     swapl(&stuff->window, n);
-    return(ProcXGetDeviceDontPropagateList(client));
-    }
+    return (ProcXGetDeviceDontPropagateList(client));
+}
 
 /***********************************************************************
  *
@@ -100,14 +97,14 @@ SProcXGetDeviceDontPropagateList(register ClientPtr client)
  */
 
 int
-ProcXGetDeviceDontPropagateList (register ClientPtr client)
+ProcXGetDeviceDontPropagateList(register ClientPtr client)
 {
-    CARD16				count = 0;
-    int					i;
-    XEventClass				*buf = NULL, *tbuf;
-    WindowPtr 				pWin;
-    xGetDeviceDontPropagateListReply	rep;
-    OtherInputMasks			*others;
+    CARD16 count = 0;
+    int i;
+    XEventClass *buf = NULL, *tbuf;
+    WindowPtr pWin;
+    xGetDeviceDontPropagateListReply rep;
+    OtherInputMasks *others;
 
     REQUEST(xGetDeviceDontPropagateListReq);
     REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq);
@@ -118,44 +115,39 @@ ProcXGetDeviceDontPropagateList (register ClientPtr client)
     rep.length = 0;
     rep.count = 0;
 
-    pWin = (WindowPtr) LookupWindow (stuff->window, client);
-    if (!pWin)
-        {
+    pWin = (WindowPtr) LookupWindow(stuff->window, client);
+    if (!pWin) {
 	client->errorValue = stuff->window;
-	SendErrorToClient(client, IReqCode, X_GetDeviceDontPropagateList, 0, 
-		BadWindow);
+	SendErrorToClient(client, IReqCode, X_GetDeviceDontPropagateList, 0,
+			  BadWindow);
 	return Success;
-        }
-
-    if ((others = wOtherInputMasks(pWin)) != 0)
-	{
-	for (i=0; i<EMASKSIZE; i++)
-	    tbuf = ClassFromMask (NULL, others->dontPropagateMask[i], i, 
-		&count, COUNT);
-	if (count)
-	    {
+    }
+
+    if ((others = wOtherInputMasks(pWin)) != 0) {
+	for (i = 0; i < EMASKSIZE; i++)
+	    tbuf = ClassFromMask(NULL, others->dontPropagateMask[i], i,
+				 &count, COUNT);
+	if (count) {
 	    rep.count = count;
-	    buf = (XEventClass *) xalloc (rep.count * sizeof(XEventClass));
-	    rep.length = (rep.count * sizeof (XEventClass) + 3) >> 2;
+	    buf = (XEventClass *) xalloc(rep.count * sizeof(XEventClass));
+	    rep.length = (rep.count * sizeof(XEventClass) + 3) >> 2;
 
 	    tbuf = buf;
-	    for (i=0; i<EMASKSIZE; i++)
-		tbuf = ClassFromMask (tbuf, others->dontPropagateMask[i], i, 
-		    NULL, CREATE);
-	    }
+	    for (i = 0; i < EMASKSIZE; i++)
+		tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i,
+				     NULL, CREATE);
 	}
+    }
 
-    WriteReplyToClient (client, sizeof (xGetDeviceDontPropagateListReply), 
-	&rep);
+    WriteReplyToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep);
 
-    if (count)
-	{
-	client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
-	WriteSwappedDataToClient( client, count * sizeof(XEventClass), buf);
-	xfree (buf);
-	}
-    return Success;
+    if (count) {
+	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
+	WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf);
+	xfree(buf);
     }
+    return Success;
+}
 
 /***********************************************************************
  *
@@ -165,26 +157,25 @@ ProcXGetDeviceDontPropagateList (register ClientPtr client)
  */
 
 XEventClass
-*ClassFromMask (XEventClass *buf, Mask mask, int maskndx, CARD16 *count, int mode)
+    * ClassFromMask(XEventClass * buf, Mask mask, int maskndx, CARD16 * count,
+		    int mode)
 {
-    int		i,j;
-    int		id = maskndx;
-    Mask	tmask = 0x80000000;
-
-    for (i=0; i<32; i++,tmask>>=1)
-	if (tmask & mask)
-	    {
-	    for (j=0; j<ExtEventIndex; j++)
-		if (EventInfo[j].mask == tmask)
-		    {
+    int i, j;
+    int id = maskndx;
+    Mask tmask = 0x80000000;
+
+    for (i = 0; i < 32; i++, tmask >>= 1)
+	if (tmask & mask) {
+	    for (j = 0; j < ExtEventIndex; j++)
+		if (EventInfo[j].mask == tmask) {
 		    if (mode == COUNT)
 			(*count)++;
 		    else
-		        *buf++ = (id << 8) | EventInfo[j].type;
-		    }
-	    }
+			*buf++ = (id << 8) | EventInfo[j].type;
+		}
+	}
     return (buf);
-    }
+}
 
 /***********************************************************************
  *
@@ -194,7 +185,8 @@ XEventClass
  */
 
 void
-SRepXGetDeviceDontPropagateList (ClientPtr client, int size, xGetDeviceDontPropagateListReply *rep)
+SRepXGetDeviceDontPropagateList(ClientPtr client, int size,
+				xGetDeviceDontPropagateListReply * rep)
 {
     register char n;
 
@@ -202,4 +194,4 @@ SRepXGetDeviceDontPropagateList (ClientPtr client, int size, xGetDeviceDontPropa
     swapl(&rep->length, n);
     swaps(&rep->count, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getprop.h b/Xi/getprop.h
index a8dcc3ab2..1a7b128b2 100644
--- a/Xi/getprop.h
+++ b/Xi/getprop.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getprop.h,v 3.1 1996/04/15 11:18:44 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,30 +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
-ProcXGetDeviceDontPropagateList (
-	ClientPtr              /* client */
-	);
-
-XEventClass *
-ClassFromMask (
-	XEventClass *          /* buf */,
-	Mask                   /* mask */,
-	int                    /* maskndx */,
-	CARD16 *               /* count */,
-	int                    /* mode */
-	);
-
-void
-SRepXGetDeviceDontPropagateList (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceDontPropagateListReply * /* rep */
-	);
+int SProcXGetDeviceDontPropagateList(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceDontPropagateList(ClientPtr	/* client */
+    );
+
+XEventClass *ClassFromMask(XEventClass * /* buf */ ,
+			   Mask /* mask */ ,
+			   int /* maskndx */ ,
+			   CARD16 * /* count */ ,
+			   int	/* mode */
+    );
+
+void SRepXGetDeviceDontPropagateList(ClientPtr /* client */ ,
+				     int /* size */ ,
+				     xGetDeviceDontPropagateListReply *	/* rep */
+    );
 
 #endif /* GETPROP_H */
diff --git a/Xi/getselev.c b/Xi/getselev.c
index 41d321304..a84c33d23 100644
--- a/Xi/getselev.c
+++ b/Xi/getselev.c
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getselev.c,v 3.5 2001/10/28 03:32:53 tsi Exp $ */
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,8 +44,6 @@ SOFTWARE.
 
 ********************************************************/
 
-/* $Xorg: getselev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /***********************************************************************
  *
  * Extension function to get the current selected events for a given window.
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window struct     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window struct     */
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
 
@@ -88,8 +85,8 @@ SProcXGetSelectedExtensionEvents(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq);
     swapl(&stuff->window, n);
-    return(ProcXGetSelectedExtensionEvents(client));
-    }
+    return (ProcXGetSelectedExtensionEvents(client));
+}
 
 /***********************************************************************
  *
@@ -101,15 +98,15 @@ SProcXGetSelectedExtensionEvents(register ClientPtr client)
 int
 ProcXGetSelectedExtensionEvents(register ClientPtr client)
 {
-    int					i;
-    int					total_length = 0;
-    xGetSelectedExtensionEventsReply	rep;
-    WindowPtr				pWin;
-    XEventClass				*buf = NULL;
-    XEventClass				*tclient;
-    XEventClass				*aclient;
-    OtherInputMasks			*pOthers;
-    InputClientsPtr			others;
+    int i;
+    int total_length = 0;
+    xGetSelectedExtensionEventsReply rep;
+    WindowPtr pWin;
+    XEventClass *buf = NULL;
+    XEventClass *tclient;
+    XEventClass *aclient;
+    OtherInputMasks *pOthers;
+    InputClientsPtr others;
 
     REQUEST(xGetSelectedExtensionEventsReq);
     REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq);
@@ -121,55 +118,53 @@ ProcXGetSelectedExtensionEvents(register ClientPtr client)
     rep.this_client_count = 0;
     rep.all_clients_count = 0;
 
-    if (!(pWin = LookupWindow(stuff->window, client)))
-        {
-	SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0, 
-		BadWindow);
+    if (!(pWin = LookupWindow(stuff->window, client))) {
+	SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0,
+			  BadWindow);
 	return Success;
-        }
-
-    if ((pOthers = wOtherInputMasks(pWin)) != 0)
-	{
-	for (others = pOthers->inputClients; others; others=others->next)
-	    for (i=0; i<EMASKSIZE; i++)
-		tclient = ClassFromMask (NULL, others->mask[i], i, 
-		    &rep.all_clients_count, COUNT);
-
-	for (others = pOthers->inputClients; others; others=others->next)
-	    if (SameClient(others, client))
-		{
-		for (i=0; i<EMASKSIZE; i++)
-		    tclient = ClassFromMask (NULL, others->mask[i], i, 
-			&rep.this_client_count, COUNT);
+    }
+
+    if ((pOthers = wOtherInputMasks(pWin)) != 0) {
+	for (others = pOthers->inputClients; others; others = others->next)
+	    for (i = 0; i < EMASKSIZE; i++)
+		tclient = ClassFromMask(NULL, others->mask[i], i,
+					&rep.all_clients_count, COUNT);
+
+	for (others = pOthers->inputClients; others; others = others->next)
+	    if (SameClient(others, client)) {
+		for (i = 0; i < EMASKSIZE; i++)
+		    tclient = ClassFromMask(NULL, others->mask[i], i,
+					    &rep.this_client_count, COUNT);
 		break;
-		}
+	    }
 
-	total_length = (rep.all_clients_count + rep.this_client_count) * 
-	    sizeof (XEventClass);
+	total_length = (rep.all_clients_count + rep.this_client_count) *
+	    sizeof(XEventClass);
 	rep.length = (total_length + 3) >> 2;
-	buf = (XEventClass *) xalloc (total_length);
+	buf = (XEventClass *) xalloc(total_length);
 
 	tclient = buf;
 	aclient = buf + rep.this_client_count;
 	if (others)
-	    for (i=0; i<EMASKSIZE; i++)
-		tclient = ClassFromMask (tclient, others->mask[i], i, NULL, CREATE);
-
-	for (others = pOthers->inputClients; others; others=others->next)
-	    for (i=0; i<EMASKSIZE; i++)
-		aclient = ClassFromMask (aclient, others->mask[i], i, NULL, CREATE);
-	}
+	    for (i = 0; i < EMASKSIZE; i++)
+		tclient =
+		    ClassFromMask(tclient, others->mask[i], i, NULL, CREATE);
+
+	for (others = pOthers->inputClients; others; others = others->next)
+	    for (i = 0; i < EMASKSIZE; i++)
+		aclient =
+		    ClassFromMask(aclient, others->mask[i], i, NULL, CREATE);
+    }
 
-    WriteReplyToClient (client, sizeof(xGetSelectedExtensionEventsReply), &rep);
+    WriteReplyToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep);
 
-    if (total_length)
-	{
+    if (total_length) {
 	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
-	WriteSwappedDataToClient( client, total_length, buf);
-	xfree (buf);
-	}
-    return Success;
+	WriteSwappedDataToClient(client, total_length, buf);
+	xfree(buf);
     }
+    return Success;
+}
 
 /***********************************************************************
  *
@@ -179,7 +174,8 @@ ProcXGetSelectedExtensionEvents(register ClientPtr client)
  */
 
 void
-SRepXGetSelectedExtensionEvents (ClientPtr client, int size, xGetSelectedExtensionEventsReply *rep)
+SRepXGetSelectedExtensionEvents(ClientPtr client, int size,
+				xGetSelectedExtensionEventsReply * rep)
 {
     register char n;
 
@@ -188,4 +184,4 @@ SRepXGetSelectedExtensionEvents (ClientPtr client, int size, xGetSelectedExtensi
     swaps(&rep->this_client_count, n);
     swaps(&rep->all_clients_count, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getselev.h b/Xi/getselev.h
index bb0e71a11..5e7a65914 100644
--- a/Xi/getselev.h
+++ b/Xi/getselev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getselev.h,v 3.1 1996/04/15 11:18:49 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetSelectedExtensionEvents(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetSelectedExtensionEvents (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetSelectedExtensionEventsReply * /* rep */
-	);
+int SProcXGetSelectedExtensionEvents(ClientPtr	/* client */
+    );
+
+int ProcXGetSelectedExtensionEvents(ClientPtr	/* client */
+    );
+
+void SRepXGetSelectedExtensionEvents(ClientPtr /* client */ ,
+				     int /* size */ ,
+				     xGetSelectedExtensionEventsReply *	/* rep */
+    );
 
 #endif /* GETSELEV_H */
diff --git a/Xi/getvers.c b/Xi/getvers.c
index efd2683e9..c5f1750be 100644
--- a/Xi/getvers.c
+++ b/Xi/getvers.c
@@ -1,5 +1,3 @@
-/* $Xorg: getvers.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/getvers.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,18 +56,18 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "getvers.h"
 
-XExtensionVersion	AllExtensionVersions[128];
+XExtensionVersion AllExtensionVersions[128];
 
 /***********************************************************************
  *
@@ -87,8 +84,8 @@ SProcXGetExtensionVersion(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
     swaps(&stuff->nbytes, n);
-    return(ProcXGetExtensionVersion(client));
-    }
+    return (ProcXGetExtensionVersion(client));
+}
 
 /***********************************************************************
  *
@@ -97,20 +94,19 @@ SProcXGetExtensionVersion(register ClientPtr client)
  */
 
 int
-ProcXGetExtensionVersion (register ClientPtr client)
+ProcXGetExtensionVersion(register ClientPtr client)
 {
-    xGetExtensionVersionReply	rep;
+    xGetExtensionVersionReply rep;
 
     REQUEST(xGetExtensionVersionReq);
     REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
 
-    if (stuff->length != (sizeof(xGetExtensionVersionReq) + 
-	stuff->nbytes + 3)>>2)
-	{
-	SendErrorToClient(client, IReqCode, X_GetExtensionVersion, 0, 
-		BadLength);
+    if (stuff->length != (sizeof(xGetExtensionVersionReq) +
+			  stuff->nbytes + 3) >> 2) {
+	SendErrorToClient(client, IReqCode, X_GetExtensionVersion, 0,
+			  BadLength);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetExtensionVersion;
@@ -120,17 +116,14 @@ ProcXGetExtensionVersion (register ClientPtr client)
     rep.minor_version = 0;
 
     rep.present = TRUE;
-    if (rep.present)
-	{
-	rep.major_version = 
-	    AllExtensionVersions[IReqCode-128].major_version;
-	rep.minor_version = 
-	    AllExtensionVersions[IReqCode-128].minor_version;
-	}
-    WriteReplyToClient (client, sizeof (xGetExtensionVersionReply), &rep);
+    if (rep.present) {
+	rep.major_version = AllExtensionVersions[IReqCode - 128].major_version;
+	rep.minor_version = AllExtensionVersions[IReqCode - 128].minor_version;
+    }
+    WriteReplyToClient(client, sizeof(xGetExtensionVersionReply), &rep);
 
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -140,7 +133,8 @@ ProcXGetExtensionVersion (register ClientPtr client)
  */
 
 void
-SRepXGetExtensionVersion (ClientPtr client, int size, xGetExtensionVersionReply *rep)
+SRepXGetExtensionVersion(ClientPtr client, int size,
+			 xGetExtensionVersionReply * rep)
 {
     register char n;
 
@@ -149,4 +143,4 @@ SRepXGetExtensionVersion (ClientPtr client, int size, xGetExtensionVersionReply
     swaps(&rep->major_version, n);
     swaps(&rep->minor_version, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/getvers.h b/Xi/getvers.h
index 93b7bfbec..c67e77a0f 100644
--- a/Xi/getvers.h
+++ b/Xi/getvers.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/getvers.h,v 3.1 1996/04/15 11:18:50 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetExtensionVersion (
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetExtensionVersion (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetExtensionVersionReply * /* rep */
-	);
+int SProcXGetExtensionVersion(ClientPtr	/* client */
+    );
+
+int ProcXGetExtensionVersion(ClientPtr	/* client */
+    );
+
+void SRepXGetExtensionVersion(ClientPtr /* client */ ,
+			      int /* size */ ,
+			      xGetExtensionVersionReply *	/* rep */
+    );
 
 #endif /* GETVERS_H */
diff --git a/Xi/grabdev.c b/Xi/grabdev.c
index 02071ac2c..3af2346e3 100644
--- a/Xi/grabdev.c
+++ b/Xi/grabdev.c
@@ -1,5 +1,3 @@
-/* $Xorg: grabdev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/grabdev.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -53,28 +50,27 @@ SOFTWARE.
  *
  */
 
-
 #define	 NEED_EVENTS
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
-#include "dixevents.h"			/* GrabDevice */
+#include "dixevents.h"	/* GrabDevice */
 
 #include "grabdev.h"
 
-extern	XExtEventInfo	EventInfo[];
-extern int		ExtEventIndex;
+extern XExtEventInfo EventInfo[];
+extern int ExtEventIndex;
 
 /***********************************************************************
  *
@@ -95,16 +91,15 @@ SProcXGrabDevice(register ClientPtr client)
     swapl(&stuff->grabWindow, n);
     swapl(&stuff->time, n);
     swaps(&stuff->event_count, n);
-    p = (long *) &stuff[1];
-    for (i=0; i<stuff->event_count; i++)
-        {
-        swapl(p, n);
+    p = (long *)&stuff[1];
+    for (i = 0; i < stuff->event_count; i++) {
+	swapl(p, n);
 	p++;
-        }
-
-    return(ProcXGrabDevice(client));
     }
 
+    return (ProcXGrabDevice(client));
+}
+
 /***********************************************************************
  *
  * Grab an extension device.
@@ -114,49 +109,47 @@ SProcXGrabDevice(register ClientPtr client)
 int
 ProcXGrabDevice(ClientPtr client)
 {
-    int			error;
-    xGrabDeviceReply 	rep;
-    DeviceIntPtr 	dev;
-    struct tmask	tmp[EMASKSIZE];
+    int error;
+    xGrabDeviceReply rep;
+    DeviceIntPtr dev;
+    struct tmask tmp[EMASKSIZE];
 
     REQUEST(xGrabDeviceReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
 
-    if (stuff->length !=(sizeof(xGrabDeviceReq)>>2) + stuff->event_count)
-	{
-	SendErrorToClient (client, IReqCode, X_GrabDevice, 0, BadLength);
+    if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count) {
+	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadLength);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GrabDevice;
     rep.sequenceNumber = client->sequence;
     rep.length = 0;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
 	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadDevice);
 	return Success;
-	}
+    }
 
-    if (CreateMaskFromList (client, (XEventClass *)&stuff[1], 
-	stuff->event_count, tmp, dev, X_GrabDevice) != Success)
+    if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
+			   stuff->event_count, tmp, dev,
+			   X_GrabDevice) != Success)
 	return Success;
 
-    error = GrabDevice (client, dev, stuff->this_device_mode, 
-	stuff->other_devices_mode, stuff->grabWindow, stuff->ownerEvents, 
-	stuff->time, tmp[stuff->deviceid].mask, &rep.status);
+    error = GrabDevice(client, dev, stuff->this_device_mode,
+		       stuff->other_devices_mode, stuff->grabWindow,
+		       stuff->ownerEvents, stuff->time,
+		       tmp[stuff->deviceid].mask, &rep.status);
 
-    if (error != Success)
-	{
+    if (error != Success) {
 	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, error);
 	return Success;
-	}
+    }
     WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
     return Success;
-    }
-
+}
 
 /***********************************************************************
  *
@@ -165,43 +158,39 @@ ProcXGrabDevice(ClientPtr client)
  */
 
 int
-CreateMaskFromList (ClientPtr client, XEventClass *list, int count, struct tmask *mask, DeviceIntPtr dev, int req)
+CreateMaskFromList(ClientPtr client, XEventClass * list, int count,
+		   struct tmask *mask, DeviceIntPtr dev, int req)
 {
-    int			i,j;
-    int			device;
-    DeviceIntPtr	tdev;
+    int i, j;
+    int device;
+    DeviceIntPtr tdev;
 
-    for (i=0; i<EMASKSIZE; i++)
-	{
+    for (i = 0; i < EMASKSIZE; i++) {
 	mask[i].mask = 0;
 	mask[i].dev = NULL;
-	}
+    }
 
-    for (i=0; i<count; i++, list++)
-	{
+    for (i = 0; i < count; i++, list++) {
 	device = *list >> 8;
-	if (device > 255)
-	    {
+	if (device > 255) {
 	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
 	    return BadClass;
-	    }
-	tdev = LookupDeviceIntRec (device);
-	if (tdev==NULL || (dev != NULL && tdev != dev))
-	    {
+	}
+	tdev = LookupDeviceIntRec(device);
+	if (tdev == NULL || (dev != NULL && tdev != dev)) {
 	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
 	    return BadClass;
-	    }
+	}
 
-	for (j=0; j<ExtEventIndex; j++)
-	    if (EventInfo[j].type == (*list & 0xff))
-		{
+	for (j = 0; j < ExtEventIndex; j++)
+	    if (EventInfo[j].type == (*list & 0xff)) {
 		mask[device].mask |= EventInfo[j].mask;
 		mask[device].dev = (Pointer) tdev;
 		break;
-		}
-	}
-    return Success;
+	    }
     }
+    return Success;
+}
 
 /***********************************************************************
  *
@@ -211,11 +200,11 @@ CreateMaskFromList (ClientPtr client, XEventClass *list, int count, struct tmask
  */
 
 void
-SRepXGrabDevice (ClientPtr client, int size, xGrabDeviceReply *rep)
+SRepXGrabDevice(ClientPtr client, int size, xGrabDeviceReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/grabdev.h b/Xi/grabdev.h
index d149da5d9..881982fd2 100644
--- a/Xi/grabdev.h
+++ b/Xi/grabdev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/grabdev.h,v 3.1 1996/04/15 11:18:51 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,31 +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
-ProcXGrabDevice(
-	ClientPtr              /* client */
-	);
-
-int
-CreateMaskFromList (
-	ClientPtr              /* client */,
-	XEventClass *          /* list */,
-	int                    /* count */,
-	struct tmask           /* mask */[],
-	DeviceIntPtr           /* dev */,
-	int                    /* req */
-	);
-
-void
-SRepXGrabDevice (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGrabDeviceReply *     /* rep */
-	);
+int SProcXGrabDevice(ClientPtr	/* client */
+    );
+
+int ProcXGrabDevice(ClientPtr	/* client */
+    );
+
+int CreateMaskFromList(ClientPtr /* client */ ,
+		       XEventClass * /* list */ ,
+		       int /* count */ ,
+		       struct tmask /* mask */ [],
+		       DeviceIntPtr /* dev */ ,
+		       int	/* req */
+    );
+
+void SRepXGrabDevice(ClientPtr /* client */ ,
+		     int /* size */ ,
+		     xGrabDeviceReply *	/* rep */
+    );
 
 #endif /* GRABDEV_H */
diff --git a/Xi/grabdevb.c b/Xi/grabdevb.c
index b976244ef..4333550f1 100644
--- a/Xi/grabdevb.c
+++ b/Xi/grabdevb.c
@@ -1,5 +1,3 @@
-/* $Xorg: grabdevb.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/grabdevb.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,15 +56,15 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "grabdev.h"
@@ -92,16 +89,15 @@ SProcXGrabDeviceButton(register ClientPtr client)
     swapl(&stuff->grabWindow, n);
     swaps(&stuff->modifiers, n);
     swaps(&stuff->event_count, n);
-    p = (long *) &stuff[1];
-    for (i=0; i<stuff->event_count; i++)
-        {
-        swapl(p, n);
+    p = (long *)&stuff[1];
+    for (i = 0; i < stuff->event_count; i++) {
+	swapl(p, n);
 	p++;
-        }
-
-    return(ProcXGrabDeviceButton(client));
     }
 
+    return (ProcXGrabDeviceButton(client));
+}
+
 /***********************************************************************
  *
  * Grab a button on an extension device.
@@ -111,58 +107,53 @@ SProcXGrabDeviceButton(register ClientPtr client)
 int
 ProcXGrabDeviceButton(ClientPtr client)
 {
-    int			ret;
-    DeviceIntPtr	dev;
-    DeviceIntPtr	mdev;
-    XEventClass		*class;
-    struct tmask	tmp[EMASKSIZE];
+    int ret;
+    DeviceIntPtr dev;
+    DeviceIntPtr mdev;
+    XEventClass *class;
+    struct tmask tmp[EMASKSIZE];
 
     REQUEST(xGrabDeviceButtonReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
 
-    if (stuff->length !=(sizeof(xGrabDeviceButtonReq)>>2) + stuff->event_count)
-	{
-	SendErrorToClient (client, IReqCode, X_GrabDeviceButton, 0, BadLength);
+    if (stuff->length !=
+	(sizeof(xGrabDeviceButtonReq) >> 2) + stuff->event_count) {
+	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadLength);
 	return Success;
-	}
+    }
 
-    dev = LookupDeviceIntRec (stuff->grabbed_device);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
-	    BadDevice);
+    dev = LookupDeviceIntRec(stuff->grabbed_device);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadDevice);
 	return Success;
-	}
-    if (stuff->modifier_device != UseXKeyboard)
-	{
-	mdev = LookupDeviceIntRec (stuff->modifier_device);
-	if (mdev == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
-	        BadDevice);
+    }
+    if (stuff->modifier_device != UseXKeyboard) {
+	mdev = LookupDeviceIntRec(stuff->modifier_device);
+	if (mdev == NULL) {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
+			      BadDevice);
 	    return Success;
-	    }
-	if (mdev->key == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, 
-		BadMatch);
+	}
+	if (mdev->key == NULL) {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
+			      BadMatch);
 	    return Success;
-	    }
 	}
-    else
+    } else
 	mdev = (DeviceIntPtr) LookupKeyboardDevice();
 
     class = (XEventClass *) (&stuff[1]);	/* first word of values */
 
-    if ((ret = CreateMaskFromList (client, class,
-	stuff->event_count, tmp, dev, X_GrabDeviceButton)) != Success)
-	    return Success;
-    ret = GrabButton(client, dev, stuff->this_device_mode, 
-	stuff->other_devices_mode, stuff->modifiers, mdev, stuff->button, 
-	stuff->grabWindow, stuff->ownerEvents, (Cursor)0, (Window)0, 
-	tmp[stuff->grabbed_device].mask);
+    if ((ret = CreateMaskFromList(client, class,
+				  stuff->event_count, tmp, dev,
+				  X_GrabDeviceButton)) != Success)
+	return Success;
+    ret = GrabButton(client, dev, stuff->this_device_mode,
+		     stuff->other_devices_mode, stuff->modifiers, mdev,
+		     stuff->button, stuff->grabWindow, stuff->ownerEvents,
+		     (Cursor) 0, (Window) 0, tmp[stuff->grabbed_device].mask);
 
     if (ret != Success)
 	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, ret);
-    return(Success);
-    }
+    return (Success);
+}
diff --git a/Xi/grabdevb.h b/Xi/grabdevb.h
index 50929a32b..84a27b3d9 100644
--- a/Xi/grabdevb.h
+++ b/Xi/grabdevb.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/grabdevb.h,v 3.1 1996/04/15 11:18:52 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/grabdevk.c b/Xi/grabdevk.c
index b0a40788e..1767d4002 100644
--- a/Xi/grabdevk.c
+++ b/Xi/grabdevk.c
@@ -1,5 +1,3 @@
-/* $Xorg: grabdevk.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/grabdevk.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,15 +56,15 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "grabdev.h"
@@ -92,14 +89,13 @@ SProcXGrabDeviceKey(register ClientPtr client)
     swapl(&stuff->grabWindow, n);
     swaps(&stuff->modifiers, n);
     swaps(&stuff->event_count, n);
-    p = (long *) &stuff[1];
-    for (i=0; i<stuff->event_count; i++)
-        {
-        swapl(p, n);
+    p = (long *)&stuff[1];
+    for (i = 0; i < stuff->event_count; i++) {
+	swapl(p, n);
 	p++;
-        }
-    return(ProcXGrabDeviceKey(client));
     }
+    return (ProcXGrabDeviceKey(client));
+}
 
 /***********************************************************************
  *
@@ -110,63 +106,55 @@ SProcXGrabDeviceKey(register ClientPtr client)
 int
 ProcXGrabDeviceKey(ClientPtr client)
 {
-    int			ret;
-    DeviceIntPtr 	dev;
-    DeviceIntPtr 	mdev;
-    XEventClass		*class;
-    struct tmask	tmp[EMASKSIZE];
+    int ret;
+    DeviceIntPtr dev;
+    DeviceIntPtr mdev;
+    XEventClass *class;
+    struct tmask tmp[EMASKSIZE];
 
     REQUEST(xGrabDeviceKeyReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
 
-    if (stuff->length !=(sizeof(xGrabDeviceKeyReq)>>2) + stuff->event_count)
-	{
-	SendErrorToClient (client, IReqCode, X_GrabDeviceKey, 0, BadLength);
+    if (stuff->length != (sizeof(xGrabDeviceKeyReq) >> 2) + stuff->event_count) {
+	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadLength);
 	return Success;
-	}
+    }
 
-    dev = LookupDeviceIntRec (stuff->grabbed_device);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
-	    BadDevice);
+    dev = LookupDeviceIntRec(stuff->grabbed_device);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
 	return Success;
-	}
+    }
 
-    if (stuff->modifier_device != UseXKeyboard)
-	{
-	mdev = LookupDeviceIntRec (stuff->modifier_device);
-	if (mdev == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
-	        BadDevice);
+    if (stuff->modifier_device != UseXKeyboard) {
+	mdev = LookupDeviceIntRec(stuff->modifier_device);
+	if (mdev == NULL) {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
 	    return Success;
-	    }
-	if (mdev->key == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, 
-		BadMatch);
+	}
+	if (mdev->key == NULL) {
+	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadMatch);
 	    return Success;
-	    }
 	}
-    else
+    } else
 	mdev = (DeviceIntPtr) LookupKeyboardDevice();
 
     class = (XEventClass *) (&stuff[1]);	/* first word of values */
 
-    if ((ret = CreateMaskFromList (client, class, 
-	stuff->event_count, tmp, dev, X_GrabDeviceKey)) != Success)
-	    return Success;
+    if ((ret = CreateMaskFromList(client, class,
+				  stuff->event_count, tmp, dev,
+				  X_GrabDeviceKey)) != Success)
+	return Success;
 
-    ret = GrabKey(client, dev, stuff->this_device_mode, 
-	stuff->other_devices_mode, stuff->modifiers, mdev, stuff->key, 
-	stuff->grabWindow, stuff->ownerEvents, tmp[stuff->grabbed_device].mask);
+    ret = GrabKey(client, dev, stuff->this_device_mode,
+		  stuff->other_devices_mode, stuff->modifiers, mdev, stuff->key,
+		  stuff->grabWindow, stuff->ownerEvents,
+		  tmp[stuff->grabbed_device].mask);
 
-    if (ret != Success)
-        {
+    if (ret != Success) {
 	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, ret);
-        return Success;
-        }
+	return Success;
+    }
 
     return Success;
-    }
+}
diff --git a/Xi/grabdevk.h b/Xi/grabdevk.h
index 230461937..e34913628 100644
--- a/Xi/grabdevk.h
+++ b/Xi/grabdevk.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/grabdevk.h,v 3.1 1996/04/15 11:18:53 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/gtmotion.c b/Xi/gtmotion.c
index 60de64e74..435ab0bfd 100644
--- a/Xi/gtmotion.c
+++ b/Xi/gtmotion.c
@@ -1,5 +1,3 @@
-/* $Xorg: gtmotion.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/gtmotion.c,v 3.6 2001/10/28 03:32:53 tsi Exp $ */
 
 /***********************************************************************
  *
@@ -59,13 +56,13 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
 
@@ -87,8 +84,8 @@ SProcXGetDeviceMotionEvents(register ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
     swapl(&stuff->start, n);
     swapl(&stuff->stop, n);
-    return(ProcXGetDeviceMotionEvents(client));
-    }
+    return (ProcXGetDeviceMotionEvents(client));
+}
 
 /****************************************************************************
  *
@@ -102,30 +99,28 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
     INT32 *coords = NULL, *bufptr;
     xGetDeviceMotionEventsReply rep;
     unsigned long i;
-    int     num_events, axes, size = 0, tsize;
+    int num_events, axes, size = 0, tsize;
     unsigned long nEvents;
     DeviceIntPtr dev;
     TimeStamp start, stop;
-    int	length = 0;
-    ValuatorClassPtr 	v;
+    int length = 0;
+    ValuatorClassPtr v;
 
     REQUEST(xGetDeviceMotionEventsReq);
 
     REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
-	    BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
     v = dev->valuator;
-    if (v==NULL || v->numAxes == 0)
-	{
-	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
-	    BadMatch);
+    if (v == NULL || v->numAxes == 0) {
+	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+			  BadMatch);
 	return Success;
-	}
+    }
     if (dev->valuator->motionHintWindow)
 	MaybeStopDeviceHint(dev, client);
     axes = v->numAxes;
@@ -139,51 +134,44 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
     start = ClientTimeToServerTime(stuff->start);
     stop = ClientTimeToServerTime(stuff->stop);
     if (CompareTimeStamps(start, stop) == LATER ||
-	CompareTimeStamps(start, currentTime) == LATER)
-	{
-    	WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
-        return Success;
-	}
+	CompareTimeStamps(start, currentTime) == LATER) {
+	WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
+	return Success;
+    }
     if (CompareTimeStamps(stop, currentTime) == LATER)
-        stop = currentTime;
+	stop = currentTime;
     num_events = v->numMotionEvents;
-    if (num_events)
-    {
-	size = sizeof(Time) + (axes * sizeof (INT32));
+    if (num_events) {
+	size = sizeof(Time) + (axes * sizeof(INT32));
 	tsize = num_events * size;
 	coords = (INT32 *) ALLOCATE_LOCAL(tsize);
-	if (!coords)
-	    {
-	    SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0, 
-	        BadAlloc);
+	if (!coords) {
+	    SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+			      BadAlloc);
 	    return Success;
-	    }
-	rep.nEvents = (v->GetMotionProc) (
-		dev, (xTimecoord *)coords, /* XXX */
-		start.milliseconds, stop.milliseconds, (ScreenPtr)NULL);
-    }
-    if (rep.nEvents > 0)
-	{
-        length = (rep.nEvents * size +3) >> 2;
-        rep.length = length;
 	}
+	rep.nEvents = (v->GetMotionProc) (dev, (xTimecoord *) coords,	/* XXX */
+					  start.milliseconds, stop.milliseconds,
+					  (ScreenPtr) NULL);
+    }
+    if (rep.nEvents > 0) {
+	length = (rep.nEvents * size + 3) >> 2;
+	rep.length = length;
+    }
     nEvents = rep.nEvents;
     WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
-    if (nEvents)
-        {
-	if (client->swapped)
-	    {
-    	    register 	char n;
+    if (nEvents) {
+	if (client->swapped) {
+	    register char n;
 
 	    bufptr = coords;
-	    for (i=0; i<nEvents * (axes+1); i++)
-		{
-    		swapl(bufptr, n);
+	    for (i = 0; i < nEvents * (axes + 1); i++) {
+		swapl(bufptr, n);
 		bufptr++;
-		}
 	    }
+	}
 	WriteToClient(client, length * 4, (char *)coords);
-        }
+    }
     if (coords)
 	DEALLOCATE_LOCAL(coords);
     return Success;
@@ -197,7 +185,8 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
  */
 
 void
-SRepXGetDeviceMotionEvents (ClientPtr client, int size, xGetDeviceMotionEventsReply *rep)
+SRepXGetDeviceMotionEvents(ClientPtr client, int size,
+			   xGetDeviceMotionEventsReply * rep)
 {
     register char n;
 
@@ -205,4 +194,4 @@ SRepXGetDeviceMotionEvents (ClientPtr client, int size, xGetDeviceMotionEventsRe
     swapl(&rep->length, n);
     swapl(&rep->nEvents, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/gtmotion.h b/Xi/gtmotion.h
index 205b19958..cdd8825cc 100644
--- a/Xi/gtmotion.h
+++ b/Xi/gtmotion.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/gtmotion.h,v 3.1 1996/04/15 11:18:56 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXGetDeviceMotionEvents(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXGetDeviceMotionEvents (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xGetDeviceMotionEventsReply * /* rep */
-	);
+int SProcXGetDeviceMotionEvents(ClientPtr	/* client */
+    );
+
+int ProcXGetDeviceMotionEvents(ClientPtr	/* client */
+    );
+
+void SRepXGetDeviceMotionEvents(ClientPtr /* client */ ,
+				int /* size */ ,
+				xGetDeviceMotionEventsReply *	/* rep */
+    );
 
 #endif /* GTMOTION_H */
diff --git a/Xi/listdev.c b/Xi/listdev.c
index e8d47c1a4..13e5ca729 100644
--- a/Xi/listdev.c
+++ b/Xi/listdev.c
@@ -1,5 +1,3 @@
-/* $Xorg: listdev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/listdev.c,v 3.3 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,19 +56,19 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
-#include "exglobals.h"			/* FIXME */
+#include "extinit.h"	/* LookupDeviceIntRec */
+#include "exglobals.h"	/* FIXME */
 
 #include "listdev.h"
 
-#define VPC	20			/* Max # valuators per chunk */
+#define VPC	20	/* Max # valuators per chunk */
 
 /***********************************************************************
  *
@@ -86,8 +83,8 @@ SProcXListInputDevices(register ClientPtr client)
 
     REQUEST(xListInputDevicesReq);
     swaps(&stuff->length, n);
-    return(ProcXListInputDevices(client));
-    }
+    return (ProcXListInputDevices(client));
+}
 
 /***********************************************************************
  *
@@ -96,19 +93,19 @@ SProcXListInputDevices(register ClientPtr client)
  */
 
 int
-ProcXListInputDevices (register ClientPtr client)
+ProcXListInputDevices(register ClientPtr client)
 {
-    xListInputDevicesReply	rep;
-    int			numdevs;
-    int 		namesize = 1;	/* need 1 extra byte for strcpy */
-    int 		size = 0;
-    int 		total_length;
-    char		*devbuf;
-    char		*classbuf;
-    char		*namebuf;
-    char		*savbuf;
-    xDeviceInfo 	*dev;
-    DeviceIntPtr 	d;
+    xListInputDevicesReply rep;
+    int numdevs;
+    int namesize = 1;	/* need 1 extra byte for strcpy */
+    int size = 0;
+    int total_length;
+    char *devbuf;
+    char *classbuf;
+    char *namebuf;
+    char *savbuf;
+    xDeviceInfo *dev;
+    DeviceIntPtr d;
 
     REQUEST_SIZE_MATCH(xListInputDevicesReq);
 
@@ -117,33 +114,33 @@ ProcXListInputDevices (register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    AddOtherInputDevices ();
+    AddOtherInputDevices();
     numdevs = inputInfo.numDevices;
 
-    for (d=inputInfo.devices; d; d=d->next)
-	SizeDeviceInfo (d, &namesize, &size);
-    for (d=inputInfo.off_devices; d; d=d->next)
-	SizeDeviceInfo (d, &namesize, &size);
+    for (d = inputInfo.devices; d; d = d->next)
+	SizeDeviceInfo(d, &namesize, &size);
+    for (d = inputInfo.off_devices; d; d = d->next)
+	SizeDeviceInfo(d, &namesize, &size);
 
-    total_length = numdevs * sizeof (xDeviceInfo) + size + namesize;
-    devbuf = (char *) xalloc (total_length);
-    classbuf = devbuf + (numdevs * sizeof (xDeviceInfo));
+    total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
+    devbuf = (char *)xalloc(total_length);
+    classbuf = devbuf + (numdevs * sizeof(xDeviceInfo));
     namebuf = classbuf + size;
     savbuf = devbuf;
 
     dev = (xDeviceInfoPtr) devbuf;
-    for (d=inputInfo.devices; d; d=d->next,dev++)
-        ListDeviceInfo (client, d, dev, &devbuf, &classbuf, &namebuf);
-    for (d=inputInfo.off_devices; d; d=d->next,dev++)
-        ListDeviceInfo (client, d, dev, &devbuf, &classbuf, &namebuf);
+    for (d = inputInfo.devices; d; d = d->next, dev++)
+	ListDeviceInfo(client, d, dev, &devbuf, &classbuf, &namebuf);
+    for (d = inputInfo.off_devices; d; d = d->next, dev++)
+	ListDeviceInfo(client, d, dev, &devbuf, &classbuf, &namebuf);
 
     rep.ndevices = numdevs;
     rep.length = (total_length + 3) >> 2;
-    WriteReplyToClient (client, sizeof (xListInputDevicesReply), &rep);
+    WriteReplyToClient(client, sizeof(xListInputDevicesReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    xfree(savbuf);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -153,24 +150,23 @@ ProcXListInputDevices (register ClientPtr client)
  */
 
 void
-SizeDeviceInfo (DeviceIntPtr d, int *namesize, int *size)
+SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
 {
     int chunks;
 
     *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);
-    if (d->valuator != NULL)
-	{
-	chunks = ((int) d->valuator->numAxes + 19) / VPC;
-	*size += (chunks * sizeof(xValuatorInfo) + 
-		d->valuator->numAxes * sizeof(xAxisInfo));
-	}
+	*size += sizeof(xButtonInfo);
+    if (d->valuator != NULL) {
+	chunks = ((int)d->valuator->numAxes + 19) / VPC;
+	*size += (chunks * sizeof(xValuatorInfo) +
+		  d->valuator->numAxes * sizeof(xAxisInfo));
     }
+}
 
 /***********************************************************************
  *
@@ -179,25 +175,24 @@ SizeDeviceInfo (DeviceIntPtr d, int *namesize, int *size)
  */
 
 void
-ListDeviceInfo (ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev, char **devbuf, char **classbuf, char **namebuf)
+ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev,
+	       char **devbuf, char **classbuf, char **namebuf)
 {
-    CopyDeviceName (namebuf, d->name);
-    CopySwapDevice (client, d, 0, devbuf);
-    if (d->key != NULL)
-	{
+    CopyDeviceName(namebuf, d->name);
+    CopySwapDevice(client, d, 0, devbuf);
+    if (d->key != NULL) {
 	CopySwapKeyClass(client, d->key, classbuf);
 	dev->num_classes++;
-	}
-    if (d->button != NULL)
-	{
+    }
+    if (d->button != NULL) {
 	CopySwapButtonClass(client, d->button, classbuf);
 	dev->num_classes++;
-	}
-    if (d->valuator != NULL)
-	{
-	dev->num_classes += CopySwapValuatorClass(client, d->valuator, classbuf);
-	}
     }
+    if (d->valuator != NULL) {
+	dev->num_classes +=
+	    CopySwapValuatorClass(client, d->valuator, classbuf);
+    }
+}
 
 /***********************************************************************
  *
@@ -210,22 +205,19 @@ ListDeviceInfo (ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev, char **dev
  */
 
 void
-CopyDeviceName (char **namebuf, char *name)
+CopyDeviceName(char **namebuf, char *name)
 {
-    char *nameptr = (char *) *namebuf;
+    char *nameptr = (char *)*namebuf;
 
-    if (name)
-	{
-	*nameptr++ = strlen (name);
-	strcpy (nameptr, name);
-	*namebuf += (strlen (name)+1);
-	}
-    else
-	{
+    if (name) {
+	*nameptr++ = strlen(name);
+	strcpy(nameptr, name);
+	*namebuf += (strlen(name) + 1);
+    } else {
 	*nameptr++ = 0;
 	*namebuf += 1;
-	}
     }
+}
 
 /***********************************************************************
  *
@@ -234,12 +226,13 @@ CopyDeviceName (char **namebuf, char *name)
  */
 
 void
-CopySwapDevice (register ClientPtr client, DeviceIntPtr d, int num_classes, char **buf)
+CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
+	       char **buf)
 {
-    register char 	n;
+    register char n;
     xDeviceInfoPtr dev;
 
-    dev = (xDeviceInfoPtr) *buf;
+    dev = (xDeviceInfoPtr) * buf;
 
     dev->id = d->id;
     dev->type = d->type;
@@ -250,12 +243,11 @@ CopySwapDevice (register ClientPtr client, DeviceIntPtr d, int num_classes, char
 	dev->use = IsXPointer;
     else
 	dev->use = IsXExtensionDevice;
-    if (client->swapped)
-	{
+    if (client->swapped) {
 	swapl(&dev->type, n);	/* macro - braces are required */
-	}
-    *buf += sizeof (xDeviceInfo);
     }
+    *buf += sizeof(xDeviceInfo);
+}
 
 /***********************************************************************
  *
@@ -264,23 +256,22 @@ CopySwapDevice (register ClientPtr client, DeviceIntPtr d, int num_classes, char
  */
 
 void
-CopySwapKeyClass (register ClientPtr client, KeyClassPtr k, char **buf)
+CopySwapKeyClass(register ClientPtr client, KeyClassPtr k, char **buf)
 {
-    register char 	n;
-    xKeyInfoPtr 	k2;
+    register char n;
+    xKeyInfoPtr k2;
 
-    k2 = (xKeyInfoPtr) *buf;
+    k2 = (xKeyInfoPtr) * buf;
     k2->class = KeyClass;
-    k2->length = sizeof (xKeyInfo);
+    k2->length = sizeof(xKeyInfo);
     k2->min_keycode = k->curKeySyms.minKeyCode;
     k2->max_keycode = k->curKeySyms.maxKeyCode;
     k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
-    if (client->swapped)
-	{
-	swaps(&k2->num_keys,n);
-	}
-    *buf += sizeof (xKeyInfo);
+    if (client->swapped) {
+	swaps(&k2->num_keys, n);
     }
+    *buf += sizeof(xKeyInfo);
+}
 
 /***********************************************************************
  *
@@ -289,21 +280,20 @@ CopySwapKeyClass (register ClientPtr client, KeyClassPtr k, char **buf)
  */
 
 void
-CopySwapButtonClass (register ClientPtr client, ButtonClassPtr b, char **buf)
+CopySwapButtonClass(register ClientPtr client, ButtonClassPtr b, char **buf)
 {
-    register char 	n;
-    xButtonInfoPtr 	b2;
+    register char n;
+    xButtonInfoPtr b2;
 
-    b2 = (xButtonInfoPtr) *buf;
+    b2 = (xButtonInfoPtr) * buf;
     b2->class = ButtonClass;
-    b2->length = sizeof (xButtonInfo);
+    b2->length = sizeof(xButtonInfo);
     b2->num_buttons = b->numButtons;
-    if (client->swapped)
-	{
-	swaps(&b2->num_buttons,n);	/* macro - braces are required */
-	}
-    *buf += sizeof (xButtonInfo);
+    if (client->swapped) {
+	swaps(&b2->num_buttons, n);	/* macro - braces are required */
     }
+    *buf += sizeof(xButtonInfo);
+}
 
 /***********************************************************************
  *
@@ -318,43 +308,43 @@ CopySwapButtonClass (register ClientPtr client, ButtonClassPtr b, char **buf)
  */
 
 int
-CopySwapValuatorClass (register ClientPtr client, ValuatorClassPtr v, char **buf)
+CopySwapValuatorClass(register ClientPtr client, ValuatorClassPtr v, char **buf)
 {
-    int			i, j, axes, t_axes;
-    register char 	n;
-    xValuatorInfoPtr 	v2;
-    AxisInfo 		*a;
-    xAxisInfoPtr 	a2;
+    int i, j, axes, t_axes;
+    register char n;
+    xValuatorInfoPtr v2;
+    AxisInfo *a;
+    xAxisInfoPtr a2;
 
-    for (i=0,axes=v->numAxes; i < ((v->numAxes+19)/VPC);  i++, axes-=VPC) {
+    for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC);
+	 i++, axes -= VPC) {
 	t_axes = axes < VPC ? axes : VPC;
 	if (t_axes < 0)
 	    t_axes = v->numAxes % VPC;
-	v2 = (xValuatorInfoPtr) *buf;
+	v2 = (xValuatorInfoPtr) * buf;
 	v2->class = ValuatorClass;
-	v2->length = sizeof (xValuatorInfo) + t_axes * sizeof (xAxisInfo);
-	v2->num_axes  = t_axes;
-	v2->mode  = v->mode & DeviceMode;
-	v2->motion_buffer_size  = v->numMotionEvents;
-	if (client->swapped)
-	    {
-	    swapl(&v2->motion_buffer_size,n);
-	    }
-	*buf += sizeof (xValuatorInfo);
+	v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
+	v2->num_axes = t_axes;
+	v2->mode = v->mode & DeviceMode;
+	v2->motion_buffer_size = v->numMotionEvents;
+	if (client->swapped) {
+	    swapl(&v2->motion_buffer_size, n);
+	}
+	*buf += sizeof(xValuatorInfo);
 	a = v->axes + (VPC * i);
-	a2 = (xAxisInfoPtr) *buf;
-	for (j=0; j<t_axes; j++) {
+	a2 = (xAxisInfoPtr) * buf;
+	for (j = 0; j < t_axes; j++) {
 	    a2->min_value = a->min_value;
 	    a2->max_value = a->max_value;
 	    a2->resolution = a->resolution;
 	    if (client->swapped) {
-		swapl(&a2->min_value,n);
-		swapl(&a2->max_value,n);
-		swapl(&a2->resolution,n);
+		swapl(&a2->min_value, n);
+		swapl(&a2->max_value, n);
+		swapl(&a2->resolution, n);
 	    }
 	    a2++;
 	    a++;
-	    *buf += sizeof (xAxisInfo);
+	    *buf += sizeof(xAxisInfo);
 	}
     }
     return (i);
@@ -368,11 +358,11 @@ CopySwapValuatorClass (register ClientPtr client, ValuatorClassPtr v, char **buf
  */
 
 void
-SRepXListInputDevices (ClientPtr client, int size, xListInputDevicesReply *rep)
+SRepXListInputDevices(ClientPtr client, int size, xListInputDevicesReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/listdev.h b/Xi/listdev.h
index 125ea3580..bdd67ce70 100644
--- a/Xi/listdev.h
+++ b/Xi/listdev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/listdev.h,v 3.1 1996/04/15 11:18:57 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,73 +30,53 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef LISTDEV_H
 #define LISTDEV_H 1
 
-int
-SProcXListInputDevices(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXListInputDevices (
-	ClientPtr              /* client */
-	);
-
-void
-SizeDeviceInfo (
-	DeviceIntPtr           /* d */,
-	int *                  /* namesize */,
-	int *                  /* size */
-	);
-
-void
-ListDeviceInfo (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* d */,
-	xDeviceInfoPtr         /* dev */,
-	char **                /* devbuf */,
-	char **                /* classbuf */,
-	char **                /* namebuf */
-	);
-
-void
-CopyDeviceName (
-	char **                /* namebuf */,
-	char *                 /* name */
-	);
-
-void
-CopySwapDevice (
-	ClientPtr              /* client */,
-	DeviceIntPtr           /* d */,
-	int                    /* num_classes */,
-	char **                /* buf */
-	);
-
-void
-CopySwapKeyClass (
-	ClientPtr              /* client */,
-	KeyClassPtr            /* k */,
-	char **                /* buf */
-	);
-
-void
-CopySwapButtonClass (
-	ClientPtr              /* client */,
-	ButtonClassPtr         /* b */,
-	char **                /* buf */
-	);
-
-int
-CopySwapValuatorClass (
-	ClientPtr              /* client */,
-	ValuatorClassPtr       /* v */,
-	char **                /* buf */
-	);
-
-void
-SRepXListInputDevices (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xListInputDevicesReply * /* rep */
-	);
+int SProcXListInputDevices(ClientPtr	/* client */
+    );
+
+int ProcXListInputDevices(ClientPtr	/* client */
+    );
+
+void SizeDeviceInfo(DeviceIntPtr /* d */ ,
+		    int * /* namesize */ ,
+		    int *	/* size */
+    );
+
+void ListDeviceInfo(ClientPtr /* client */ ,
+		    DeviceIntPtr /* d */ ,
+		    xDeviceInfoPtr /* dev */ ,
+		    char ** /* devbuf */ ,
+		    char ** /* classbuf */ ,
+		    char **	/* namebuf */
+    );
+
+void CopyDeviceName(char ** /* namebuf */ ,
+		    char *	/* name */
+    );
+
+void CopySwapDevice(ClientPtr /* client */ ,
+		    DeviceIntPtr /* d */ ,
+		    int /* num_classes */ ,
+		    char **	/* buf */
+    );
+
+void CopySwapKeyClass(ClientPtr /* client */ ,
+		      KeyClassPtr /* k */ ,
+		      char **	/* buf */
+    );
+
+void CopySwapButtonClass(ClientPtr /* client */ ,
+			 ButtonClassPtr /* b */ ,
+			 char **	/* buf */
+    );
+
+int CopySwapValuatorClass(ClientPtr /* client */ ,
+			  ValuatorClassPtr /* v */ ,
+			  char **	/* buf */
+    );
+
+void SRepXListInputDevices(ClientPtr /* client */ ,
+			   int /* size */ ,
+			   xListInputDevicesReply *	/* rep */
+    );
 
 #endif /* LISTDEV_H */
diff --git a/Xi/opendev.c b/Xi/opendev.c
index 54a6dda46..636106815 100644
--- a/Xi/opendev.c
+++ b/Xi/opendev.c
@@ -1,5 +1,3 @@
-/* $Xorg: opendev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/opendev.c,v 3.2 2001/01/17 22:13:25 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,20 +56,20 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#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 "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "opendev.h"
 
-extern	CARD8		event_base [];
+extern CARD8 event_base[];
 
 /***********************************************************************
  *
@@ -88,8 +85,8 @@ SProcXOpenDevice(register ClientPtr client)
 
     REQUEST(xOpenDeviceReq);
     swaps(&stuff->length, n);
-    return(ProcXOpenDevice(client));
-    }
+    return (ProcXOpenDevice(client));
+}
 
 /***********************************************************************
  *
@@ -100,87 +97,77 @@ SProcXOpenDevice(register ClientPtr client)
 int
 ProcXOpenDevice(register ClientPtr client)
 {
-    xInputClassInfo evbase [numInputClasses];
+    xInputClassInfo evbase[numInputClasses];
     Bool enableit = FALSE;
-    int j=0;
+    int j = 0;
     int status = Success;
-    xOpenDeviceReply	rep;
+    xOpenDeviceReply rep;
     DeviceIntPtr dev;
 
     REQUEST(xOpenDeviceReq);
     REQUEST_SIZE_MATCH(xOpenDeviceReq);
 
-    if (stuff->deviceid == inputInfo.pointer->id || 
-	stuff->deviceid == inputInfo.keyboard->id)
-	{
+    if (stuff->deviceid == inputInfo.pointer->id ||
+	stuff->deviceid == inputInfo.keyboard->id) {
 	SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
-        return Success;
-	}
+	return Success;
+    }
 
-    if ((dev = LookupDeviceIntRec(stuff->deviceid)) == NULL) /* not open */
-	{
-        for (dev=inputInfo.off_devices; dev; dev=dev->next)
+    if ((dev = LookupDeviceIntRec(stuff->deviceid)) == NULL) {	/* not open */
+	for (dev = inputInfo.off_devices; dev; dev = dev->next)
 	    if (dev->id == stuff->deviceid)
 		break;
-	if (dev == NULL)
-	    {
+	if (dev == NULL) {
 	    SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
 	    return Success;
-	    }
-	enableit = TRUE;
 	}
+	enableit = TRUE;
+    }
 
-    OpenInputDevice (dev, client, &status);
-    if (status != Success)
-	{
+    OpenInputDevice(dev, client, &status);
+    if (status != Success) {
 	SendErrorToClient(client, IReqCode, X_OpenDevice, 0, status);
 	return Success;
-	}
+    }
     if (enableit && dev->inited && dev->startup)
 	(void)EnableDevice(dev);
 
     rep.repType = X_Reply;
     rep.RepType = X_OpenDevice;
     rep.sequenceNumber = client->sequence;
-    if (dev->key != NULL)
-	{
+    if (dev->key != NULL) {
 	evbase[j].class = KeyClass;
 	evbase[j++].event_type_base = event_base[KeyClass];
-	}
-    if (dev->button != NULL)
-	{
+    }
+    if (dev->button != NULL) {
 	evbase[j].class = ButtonClass;
 	evbase[j++].event_type_base = event_base[ButtonClass];
-	}
-    if (dev->valuator != NULL)
-	{
+    }
+    if (dev->valuator != NULL) {
 	evbase[j].class = 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++].event_type_base = event_base[FeedbackClass];
-	}
-    if (dev->focus != NULL)
-	{
+    }
+    if (dev->focus != NULL) {
 	evbase[j].class = FocusClass;
 	evbase[j++].event_type_base = event_base[FocusClass];
-	}
-    if (dev->proximity != NULL)
-	{
+    }
+    if (dev->proximity != NULL) {
 	evbase[j].class = ProximityClass;
 	evbase[j++].event_type_base = event_base[ProximityClass];
-	}
+    }
     evbase[j].class = OtherClass;
     evbase[j++].event_type_base = event_base[OtherClass];
-    rep.length = (j * sizeof (xInputClassInfo) + 3) >> 2;
+    rep.length = (j * sizeof(xInputClassInfo) + 3) >> 2;
     rep.num_classes = j;
-    WriteReplyToClient (client, sizeof (xOpenDeviceReply), &rep);
-    WriteToClient(client, j * sizeof (xInputClassInfo), (char *)evbase);
+    WriteReplyToClient(client, sizeof(xOpenDeviceReply), &rep);
+    WriteToClient(client, j * sizeof(xInputClassInfo), (char *)evbase);
     return (Success);
-    }
+}
 
 /***********************************************************************
  *
@@ -190,11 +177,11 @@ ProcXOpenDevice(register ClientPtr client)
  */
 
 void
-SRepXOpenDevice (ClientPtr client, int size, xOpenDeviceReply *rep)
+SRepXOpenDevice(ClientPtr client, int size, xOpenDeviceReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/opendev.h b/Xi/opendev.h
index 94ed6f6bd..9665fe9cb 100644
--- a/Xi/opendev.h
+++ b/Xi/opendev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/opendev.h,v 3.1 1996/04/15 11:18:58 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXOpenDevice(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXOpenDevice (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xOpenDeviceReply *     /* rep */
-	);
+int SProcXOpenDevice(ClientPtr	/* client */
+    );
+
+int ProcXOpenDevice(ClientPtr	/* client */
+    );
+
+void SRepXOpenDevice(ClientPtr /* client */ ,
+		     int /* size */ ,
+		     xOpenDeviceReply *	/* rep */
+    );
 
 #endif /* OPENDEV_H */
diff --git a/Xi/queryst.c b/Xi/queryst.c
index d125e2de3..c4cc5a2e6 100644
--- a/Xi/queryst.c
+++ b/Xi/queryst.c
@@ -1,4 +1,3 @@
-/* $Xorg: queryst.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
 /*
 
 Copyright 1998, 1998  The Open Group
@@ -26,7 +25,6 @@ other dealings in this Software without prior written authorization
 from The Open Group.
 
 */
-/* $XFree86: xc/programs/Xserver/Xi/queryst.c,v 3.4 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -40,14 +38,14 @@ from The Open Group.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
 
@@ -66,8 +64,8 @@ SProcXQueryDeviceState(register ClientPtr client)
 
     REQUEST(xQueryDeviceStateReq);
     swaps(&stuff->length, n);
-    return(ProcXQueryDeviceState(client));
-    }
+    return (ProcXQueryDeviceState(client));
+}
 
 /***********************************************************************
  *
@@ -78,20 +76,20 @@ SProcXQueryDeviceState(register ClientPtr client)
 int
 ProcXQueryDeviceState(register ClientPtr client)
 {
-    register char 		n;
-    int 			i;
-    int 			num_classes = 0;
-    int 			total_length = 0;
-    char			*buf, *savbuf;
-    KeyClassPtr 		k;
-    xKeyState			*tk;
-    ButtonClassPtr 		b;
-    xButtonState		*tb;
-    ValuatorClassPtr 		v;
-    xValuatorState		*tv;
-    xQueryDeviceStateReply	rep;
-    DeviceIntPtr		dev;
-    int				*values;
+    register char n;
+    int i;
+    int num_classes = 0;
+    int total_length = 0;
+    char *buf, *savbuf;
+    KeyClassPtr k;
+    xKeyState *tk;
+    ButtonClassPtr b;
+    xButtonState *tb;
+    ValuatorClassPtr v;
+    xValuatorState *tv;
+    xQueryDeviceStateReply rep;
+    DeviceIntPtr dev;
+    int *values;
 
     REQUEST(xQueryDeviceStateReq);
     REQUEST_SIZE_MATCH(xQueryDeviceStateReq);
@@ -101,96 +99,83 @@ ProcXQueryDeviceState(register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadDevice);
 	return Success;
-	}
+    }
 
     v = dev->valuator;
     if (v != NULL && v->motionHintWindow != NULL)
 	MaybeStopDeviceHint(dev, client);
 
     k = dev->key;
-    if (k != NULL)
-	{
-	total_length += sizeof (xKeyState);
+    if (k != NULL) {
+	total_length += sizeof(xKeyState);
 	num_classes++;
-	}
+    }
 
     b = dev->button;
-    if (b != NULL)
-	{
-	total_length += sizeof (xButtonState);
+    if (b != NULL) {
+	total_length += sizeof(xButtonState);
 	num_classes++;
-	}
+    }
 
-    if (v != NULL)
-	{
-	total_length += (sizeof(xValuatorState) + 
-			(v->numAxes * sizeof(int)));
+    if (v != NULL) {
+	total_length += (sizeof(xValuatorState) + (v->numAxes * sizeof(int)));
 	num_classes++;
-	}
-    buf = (char *) xalloc (total_length);
-    if (!buf)
-	{
-	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, 
-		BadAlloc);
+    }
+    buf = (char *)xalloc(total_length);
+    if (!buf) {
+	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadAlloc);
 	return Success;
-	}
+    }
     savbuf = buf;
 
-    if (k != NULL)
-	{
+    if (k != NULL) {
 	tk = (xKeyState *) buf;
 	tk->class = KeyClass;
-	tk->length = sizeof (xKeyState);
+	tk->length = sizeof(xKeyState);
 	tk->num_keys = k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode + 1;
-	for (i = 0; i<32; i++)
+	for (i = 0; i < 32; i++)
 	    tk->keys[i] = k->down[i];
-	buf += sizeof (xKeyState);
-	}
+	buf += sizeof(xKeyState);
+    }
 
-    if (b != NULL)
-	{
+    if (b != NULL) {
 	tb = (xButtonState *) buf;
 	tb->class = ButtonClass;
-	tb->length = sizeof (xButtonState);
+	tb->length = sizeof(xButtonState);
 	tb->num_buttons = b->numButtons;
-	for (i = 0; i<32; i++)
+	for (i = 0; i < 32; i++)
 	    tb->buttons[i] = b->down[i];
-	buf += sizeof (xButtonState);
-	}
+	buf += sizeof(xButtonState);
+    }
 
-    if (v != NULL)
-	{
+    if (v != NULL) {
 	tv = (xValuatorState *) buf;
 	tv->class = ValuatorClass;
-	tv->length = sizeof (xValuatorState);
+	tv->length = sizeof(xValuatorState);
 	tv->num_valuators = v->numAxes;
 	tv->mode = v->mode;
 	buf += sizeof(xValuatorState);
-	for (i=0, values=v->axisVal; i<v->numAxes; i++)
-	    {
-	    *((int *) buf) = *values++;
-	    if (client->swapped)
-		{
-		swapl ((int *) buf, n);/* macro - braces needed */
-		}
-	    buf += sizeof(int);
+	for (i = 0, values = v->axisVal; i < v->numAxes; i++) {
+	    *((int *)buf) = *values++;
+	    if (client->swapped) {
+		swapl((int *)buf, n);	/* macro - braces needed */
 	    }
+	    buf += sizeof(int);
 	}
+    }
 
     rep.num_classes = num_classes;
     rep.length = (total_length + 3) >> 2;
-    WriteReplyToClient (client, sizeof(xQueryDeviceStateReply), &rep);
+    WriteReplyToClient(client, sizeof(xQueryDeviceStateReply), &rep);
     if (total_length > 0)
-	WriteToClient (client, total_length, savbuf);
-    xfree (savbuf);
+	WriteToClient(client, total_length, savbuf);
+    xfree(savbuf);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -200,11 +185,11 @@ ProcXQueryDeviceState(register ClientPtr client)
  */
 
 void
-SRepXQueryDeviceState (ClientPtr client, int size, xQueryDeviceStateReply *rep)
+SRepXQueryDeviceState(ClientPtr client, int size, xQueryDeviceStateReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/queryst.h b/Xi/queryst.h
index bf651b4bd..9232ff666 100644
--- a/Xi/queryst.h
+++ b/Xi/queryst.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/queryst.h,v 3.1 1996/04/15 11:19:00 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXQueryDeviceState(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXQueryDeviceState (
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xQueryDeviceStateReply * /* rep */
-	);
+int SProcXQueryDeviceState(ClientPtr	/* client */
+    );
+
+int ProcXQueryDeviceState(ClientPtr	/* client */
+    );
+
+void SRepXQueryDeviceState(ClientPtr /* client */ ,
+			   int /* size */ ,
+			   xQueryDeviceStateReply *	/* rep */
+    );
 
 #endif /* QUERYST_H */
diff --git a/Xi/selectev.c b/Xi/selectev.c
index 057050c66..3483804b1 100644
--- a/Xi/selectev.c
+++ b/Xi/selectev.c
@@ -1,5 +1,3 @@
-/* $Xorg: selectev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/selectev.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -60,22 +57,22 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
 
 #include "grabdev.h"
 #include "selectev.h"
 
-extern	Mask		ExtExclusiveMasks[];
-extern	Mask		ExtValidMasks[];
+extern Mask ExtExclusiveMasks[];
+extern Mask ExtValidMasks[];
 
 /***********************************************************************
  *
@@ -84,7 +81,7 @@ extern	Mask		ExtValidMasks[];
  */
 
 int
-SProcXSelectExtensionEvent (register ClientPtr client)
+SProcXSelectExtensionEvent(register ClientPtr client)
 {
     register char n;
     register long *p;
@@ -95,14 +92,13 @@ SProcXSelectExtensionEvent (register ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
     swapl(&stuff->window, n);
     swaps(&stuff->count, n);
-    p = (long *) &stuff[1];
-    for (i=0; i<stuff->count; i++)
-        {
-        swapl(p, n);
+    p = (long *)&stuff[1];
+    for (i = 0; i < stuff->count; i++) {
+	swapl(p, n);
 	p++;
-        }
-    return(ProcXSelectExtensionEvent(client));
     }
+    return (ProcXSelectExtensionEvent(client));
+}
 
 /***********************************************************************
  *
@@ -111,47 +107,46 @@ SProcXSelectExtensionEvent (register ClientPtr client)
  */
 
 int
-ProcXSelectExtensionEvent (register ClientPtr client)
+ProcXSelectExtensionEvent(register ClientPtr client)
 {
-    int			ret;
-    int			i;
-    WindowPtr 		pWin;
-    struct tmask	tmp[EMASKSIZE];
+    int ret;
+    int i;
+    WindowPtr pWin;
+    struct tmask tmp[EMASKSIZE];
 
     REQUEST(xSelectExtensionEventReq);
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
 
-    if (stuff->length !=(sizeof(xSelectExtensionEventReq)>>2) + stuff->count)
-	{
-	SendErrorToClient (client, IReqCode, X_SelectExtensionEvent, 0, 
-		BadLength);
+    if (stuff->length != (sizeof(xSelectExtensionEventReq) >> 2) + stuff->count) {
+	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+			  BadLength);
 	return Success;
-	}
+    }
 
-    pWin = (WindowPtr) LookupWindow (stuff->window, client);
-    if (!pWin)
-        {
+    pWin = (WindowPtr) LookupWindow(stuff->window, client);
+    if (!pWin) {
 	client->errorValue = stuff->window;
-	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, 
-		BadWindow);
+	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+			  BadWindow);
 	return Success;
-        }
+    }
 
-    if ((ret = CreateMaskFromList (client, (XEventClass *)&stuff[1], 
-	stuff->count, tmp, NULL, X_SelectExtensionEvent)) != Success)
+    if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
+				  stuff->count, tmp, NULL,
+				  X_SelectExtensionEvent)) != Success)
 	return Success;
 
-    for (i=0; i<EMASKSIZE; i++)
-	if (tmp[i].dev != NULL)
-	    {
-	    if ((ret = SelectForWindow((DeviceIntPtr)tmp[i].dev, pWin, client, tmp[i].mask, 
-		ExtExclusiveMasks[i], ExtValidMasks[i])) != Success)
-		{
-		SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, 
-			ret);
+    for (i = 0; i < EMASKSIZE; i++)
+	if (tmp[i].dev != NULL) {
+	    if ((ret =
+		 SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
+				 tmp[i].mask, ExtExclusiveMasks[i],
+				 ExtValidMasks[i])) != Success) {
+		SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+				  ret);
 		return Success;
-		}
 	    }
+	}
 
     return Success;
-    }
+}
diff --git a/Xi/selectev.h b/Xi/selectev.h
index 82bdbc6c0..60fb4476b 100644
--- a/Xi/selectev.h
+++ b/Xi/selectev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/selectev.h,v 3.1 1996/04/15 11:19:01 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/sendexev.c b/Xi/sendexev.c
index 50c1c584d..c2763bb22 100644
--- a/Xi/sendexev.c
+++ b/Xi/sendexev.c
@@ -1,5 +1,3 @@
-/* $Xorg: sendexev.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/sendexev.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -60,21 +57,21 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* Window      	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* Window            */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
 
 #include "grabdev.h"
 #include "sendexev.h"
 
-extern int 		lastEvent; 		/* Defined in extension.c */
+extern int lastEvent;	/* Defined in extension.c */
 
 /***********************************************************************
  *
@@ -97,24 +94,22 @@ SProcXSendExtensionEvent(register ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
     swapl(&stuff->destination, n);
     swaps(&stuff->count, n);
-    eventP = (xEvent *) &stuff[1];
-    for (i=0; i<stuff->num_events; i++,eventP++)
-        {
+    eventP = (xEvent *) & stuff[1];
+    for (i = 0; i < stuff->num_events; i++, eventP++) {
 	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);
-	(*proc)(eventP, &eventT);
+	(*proc) (eventP, &eventT);
 	*eventP = eventT;
-	}
+    }
 
-    p = (long *) (((xEvent *) &stuff[1]) + stuff->num_events);
-    for (i=0; i<stuff->count; i++)
-        {
-        swapl(p, n);
+    p = (long *)(((xEvent *) & stuff[1]) + stuff->num_events);
+    for (i = 0; i < stuff->count; i++) {
+	swapl(p, n);
 	p++;
-        }
-    return(ProcXSendExtensionEvent(client));
     }
+    return (ProcXSendExtensionEvent(client));
+}
 
 /***********************************************************************
  *
@@ -124,56 +119,50 @@ SProcXSendExtensionEvent(register ClientPtr client)
  */
 
 int
-ProcXSendExtensionEvent (register ClientPtr client)
+ProcXSendExtensionEvent(register ClientPtr client)
 {
-    int			ret;
-    DeviceIntPtr	dev;
-    xEvent		*first;
-    XEventClass		*list;
-    struct tmask	tmp[EMASKSIZE];
+    int ret;
+    DeviceIntPtr dev;
+    xEvent *first;
+    XEventClass *list;
+    struct tmask tmp[EMASKSIZE];
 
     REQUEST(xSendExtensionEventReq);
     REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
 
-    if (stuff->length !=(sizeof(xSendExtensionEventReq)>>2) + stuff->count +
-	(stuff->num_events * (sizeof (xEvent) >> 2)))
-	{
-	SendErrorToClient (client, IReqCode, X_SendExtensionEvent, 0, 
-		BadLength);
+    if (stuff->length != (sizeof(xSendExtensionEventReq) >> 2) + stuff->count +
+	(stuff->num_events * (sizeof(xEvent) >> 2))) {
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadLength);
 	return Success;
-	}
+    }
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadDevice);
 	return Success;
-	}
+    }
 
     /* The client's event type must be one defined by an extension. */
 
-    first = ((xEvent *) &stuff[1]);
-    if ( ! ((EXTENSION_EVENT_BASE  <= first->u.u.type) &&
-	(first->u.u.type < lastEvent)) )
-	{
+    first = ((xEvent *) & stuff[1]);
+    if (!((EXTENSION_EVENT_BASE <= first->u.u.type) &&
+	  (first->u.u.type < lastEvent))) {
 	client->errorValue = first->u.u.type;
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, 
-		BadValue);
+	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadValue);
 	return Success;
-	}
+    }
 
     list = (XEventClass *) (first + stuff->num_events);
-    if ((ret = CreateMaskFromList (client, list, stuff->count, tmp, dev, 
-	X_SendExtensionEvent)) != Success)
+    if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev,
+				  X_SendExtensionEvent)) != Success)
 	return Success;
 
-    ret =  (SendEvent (client, dev, stuff->destination,
-	stuff->propagate, (xEvent *)&stuff[1], tmp[stuff->deviceid].mask, 
-	stuff->num_events));
+    ret = (SendEvent(client, dev, stuff->destination,
+		     stuff->propagate, (xEvent *) & stuff[1],
+		     tmp[stuff->deviceid].mask, stuff->num_events));
 
     if (ret != Success)
 	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, ret);
 
     return Success;
-    }
+}
diff --git a/Xi/sendexev.h b/Xi/sendexev.h
index e5bc185a8..e156f1ba2 100644
--- a/Xi/sendexev.h
+++ b/Xi/sendexev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/sendexev.h,v 3.1 1996/04/15 11:19:02 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +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 */
diff --git a/Xi/setbmap.c b/Xi/setbmap.c
index 8dfeeea30..14b1689f5 100644
--- a/Xi/setbmap.c
+++ b/Xi/setbmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: setbmap.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/setbmap.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -62,14 +59,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "setbmap.h"
@@ -87,8 +84,8 @@ SProcXSetDeviceButtonMapping(register ClientPtr client)
 
     REQUEST(xSetDeviceButtonMappingReq);
     swaps(&stuff->length, n);
-    return(ProcXSetDeviceButtonMapping(client));
-    }
+    return (ProcXSetDeviceButtonMapping(client));
+}
 
 /***********************************************************************
  *
@@ -97,22 +94,21 @@ SProcXSetDeviceButtonMapping(register ClientPtr client)
  */
 
 int
-ProcXSetDeviceButtonMapping (register ClientPtr client)
+ProcXSetDeviceButtonMapping(register ClientPtr client)
 {
-    int					ret;
-    xSetDeviceButtonMappingReply	rep;
+    int ret;
+    xSetDeviceButtonMappingReply rep;
     DeviceIntPtr dev;
 
     REQUEST(xSetDeviceButtonMappingReq);
     REQUEST_AT_LEAST_SIZE(xSetDeviceButtonMappingReq);
 
-    if (stuff->length != (sizeof(xSetDeviceButtonMappingReq) + 
-	stuff->map_length + 3)>>2)
-	{
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
-		BadLength);
+    if (stuff->length != (sizeof(xSetDeviceButtonMappingReq) +
+			  stuff->map_length + 3) >> 2) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
+			  BadLength);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_SetDeviceButtonMapping;
@@ -120,32 +116,27 @@ ProcXSetDeviceButtonMapping (register ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.status = MappingSuccess;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
-    ret = SetButtonMapping (client, dev, stuff->map_length, (BYTE *)&stuff[1]);
+    ret = SetButtonMapping(client, dev, stuff->map_length, (BYTE *) & stuff[1]);
 
-    if (ret == BadValue || ret == BadMatch)
-	{
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, 
-		ret);
+    if (ret == BadValue || ret == BadMatch) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, ret);
 	return Success;
-	}
-    else
-	{
+    } else {
 	rep.status = ret;
 	WriteReplyToClient(client, sizeof(xSetDeviceButtonMappingReply), &rep);
-	}
+    }
 
     if (ret != MappingBusy)
-        SendDeviceMappingNotify(MappingPointer, 0, 0, dev);
+	SendDeviceMappingNotify(MappingPointer, 0, 0, dev);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -155,11 +146,12 @@ ProcXSetDeviceButtonMapping (register ClientPtr client)
  */
 
 void
-SRepXSetDeviceButtonMapping (ClientPtr client, int size, xSetDeviceButtonMappingReply *rep)
+SRepXSetDeviceButtonMapping(ClientPtr client, int size,
+			    xSetDeviceButtonMappingReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/setbmap.h b/Xi/setbmap.h
index dab5fcbde..20ad8e077 100644
--- a/Xi/setbmap.h
+++ b/Xi/setbmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/setbmap.h,v 3.1 1996/04/15 11:19:03 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +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
-ProcXSetDeviceButtonMapping(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXSetDeviceButtonMapping(
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xSetDeviceButtonMappingReply * /* rep */
-	);
+int SProcXSetDeviceButtonMapping(ClientPtr	/* client */
+    );
+
+int ProcXSetDeviceButtonMapping(ClientPtr	/* client */
+    );
+
+void SRepXSetDeviceButtonMapping(ClientPtr /* client */ ,
+				 int /* size */ ,
+				 xSetDeviceButtonMappingReply *	/* rep */
+    );
 
 #endif /* SETBMAP_H */
diff --git a/Xi/setdval.c b/Xi/setdval.c
index 0c40acbec..958b2ac21 100644
--- a/Xi/setdval.c
+++ b/Xi/setdval.c
@@ -1,5 +1,3 @@
-/* $Xorg: setdval.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/setdval.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "setdval.h"
@@ -84,8 +81,8 @@ SProcXSetDeviceValuators(register ClientPtr client)
 
     REQUEST(xSetDeviceValuatorsReq);
     swaps(&stuff->length, n);
-    return(ProcXSetDeviceValuators(client));
-    }
+    return (ProcXSetDeviceValuators(client));
+}
 
 /***********************************************************************
  *
@@ -97,7 +94,7 @@ int
 ProcXSetDeviceValuators(register ClientPtr client)
 {
     DeviceIntPtr dev;
-    xSetDeviceValuatorsReply	rep;
+    xSetDeviceValuatorsReply rep;
 
     REQUEST(xSetDeviceValuatorsReq);
     REQUEST_AT_LEAST_SIZE(xSetDeviceValuatorsReq);
@@ -108,48 +105,41 @@ ProcXSetDeviceValuators(register ClientPtr client)
     rep.status = Success;
     rep.sequenceNumber = client->sequence;
 
-    if (stuff->length !=(sizeof(xSetDeviceValuatorsReq)>>2) + 
-	stuff->num_valuators)
-	{
-	SendErrorToClient (client, IReqCode, X_SetDeviceValuators, 0, 
-		BadLength);
+    if (stuff->length != (sizeof(xSetDeviceValuatorsReq) >> 2) +
+	stuff->num_valuators) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadLength);
 	return Success;
-	}
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_SetDeviceValuators, 0, 
-	    BadDevice);
+    }
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadDevice);
 	return Success;
-	}
-    if (dev->valuator == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
-		BadMatch);
+    }
+    if (dev->valuator == NULL) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadMatch);
 	return Success;
-	}
+    }
 
-    if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes)
-	{
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
-		BadValue);
+    if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadValue);
 	return Success;
-	}
+    }
 
     if ((dev->grab) && !SameClient(dev->grab, client))
 	rep.status = AlreadyGrabbed;
     else
-	rep.status = SetDeviceValuators (client, dev, (int *) &stuff[1],
-	    stuff->first_valuator, stuff->num_valuators);
+	rep.status = SetDeviceValuators(client, dev, (int *)&stuff[1],
+					stuff->first_valuator,
+					stuff->num_valuators);
 
     if (rep.status != Success && rep.status != AlreadyGrabbed)
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, 
-	    rep.status);
+	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0,
+			  rep.status);
     else
-	WriteReplyToClient (client, sizeof (xSetDeviceValuatorsReply), &rep);
+	WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
 
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -159,11 +149,12 @@ ProcXSetDeviceValuators(register ClientPtr client)
  */
 
 void
-SRepXSetDeviceValuators (ClientPtr client, int size, xSetDeviceValuatorsReply *rep)
+SRepXSetDeviceValuators(ClientPtr client, int size,
+			xSetDeviceValuatorsReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/setdval.h b/Xi/setdval.h
index d475c7cc6..40b431784 100644
--- a/Xi/setdval.h
+++ b/Xi/setdval.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/setdval.h,v 3.1 1996/04/15 11:19:04 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SETDVAL_H
 #define SETDVAL_H 1
 
-int
-SProcXSetDeviceValuators(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXSetDeviceValuators(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXSetDeviceValuators(
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xSetDeviceValuatorsReply * /* rep */
-	);
+int SProcXSetDeviceValuators(ClientPtr	/* client */
+    );
+
+int ProcXSetDeviceValuators(ClientPtr	/* client */
+    );
+
+void SRepXSetDeviceValuators(ClientPtr /* client */ ,
+			     int /* size */ ,
+			     xSetDeviceValuatorsReply *	/* rep */
+    );
 
 #endif /* SETDVAL_H */
diff --git a/Xi/setfocus.c b/Xi/setfocus.c
index 184dd7a7f..59fe0768c 100644
--- a/Xi/setfocus.c
+++ b/Xi/setfocus.c
@@ -1,5 +1,3 @@
-/* $Xorg: setfocus.c,v 1.4 2001/02/09 02:04:34 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/setfocus.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,17 +56,17 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "windowstr.h"			/* focus struct      */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "windowstr.h"	/* focus struct      */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 
 #include "dixevents.h"
 
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "setfocus.h"
@@ -90,8 +87,8 @@ SProcXSetDeviceFocus(register ClientPtr client)
     REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
     swapl(&stuff->focus, n);
     swapl(&stuff->time, n);
-    return(ProcXSetDeviceFocus(client));
-    }
+    return (ProcXSetDeviceFocus(client));
+}
 
 /***********************************************************************
  *
@@ -102,23 +99,22 @@ SProcXSetDeviceFocus(register ClientPtr client)
 int
 ProcXSetDeviceFocus(register ClientPtr client)
 {
-    int				ret;
-    register DeviceIntPtr	dev;
+    int ret;
+    register DeviceIntPtr dev;
 
     REQUEST(xSetDeviceFocusReq);
     REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
 
-    dev = LookupDeviceIntRec (stuff->device);
-    if (dev==NULL || !dev->focus)
-	{
+    dev = LookupDeviceIntRec(stuff->device);
+    if (dev == NULL || !dev->focus) {
 	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, BadDevice);
 	return Success;
-	}
+    }
 
-    ret = SetInputFocus (client, dev, stuff->focus, stuff->revertTo, 
-	stuff->time, TRUE);
+    ret = SetInputFocus(client, dev, stuff->focus, stuff->revertTo,
+			stuff->time, TRUE);
     if (ret != Success)
 	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, ret);
 
     return Success;
-    }
+}
diff --git a/Xi/setfocus.h b/Xi/setfocus.h
index 62ff181d2..3a49f8440 100644
--- a/Xi/setfocus.h
+++ b/Xi/setfocus.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/setfocus.h,v 3.1 1996/04/15 11:19:05 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SETFOCUS_H
 #define SETFOCUS_H 1
 
-int
-SProcXSetDeviceFocus(
-	ClientPtr              /* client */
-	);
+int SProcXSetDeviceFocus(ClientPtr	/* client */
+    );
 
-int
-ProcXSetDeviceFocus(
-	ClientPtr              /* client */
-	);
+int ProcXSetDeviceFocus(ClientPtr	/* client */
+    );
 
 #endif /* SETFOCUS_H */
diff --git a/Xi/setmmap.c b/Xi/setmmap.c
index 430a7e395..645f246bd 100644
--- a/Xi/setmmap.c
+++ b/Xi/setmmap.c
@@ -1,5 +1,3 @@
-/* $Xorg: setmmap.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/setmmap.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /********************************************************************
  *
@@ -53,20 +50,20 @@ SOFTWARE.
  *
  */
 
-#define	 NEED_EVENTS			/* for inputstr.h    */
+#define	 NEED_EVENTS	/* for inputstr.h    */
 #define	 NEED_REPLIES
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "setmmap.h"
@@ -85,8 +82,8 @@ SProcXSetDeviceModifierMapping(register ClientPtr client)
 
     REQUEST(xSetDeviceModifierMappingReq);
     swaps(&stuff->length, n);
-    return(ProcXSetDeviceModifierMapping(client));
-    }
+    return (ProcXSetDeviceModifierMapping(client));
+}
 
 /***********************************************************************
  *
@@ -97,21 +94,20 @@ SProcXSetDeviceModifierMapping(register ClientPtr client)
 int
 ProcXSetDeviceModifierMapping(ClientPtr client)
 {
-    int					ret;
-    xSetDeviceModifierMappingReply	rep;
-    DeviceIntPtr			dev;
-    KeyClassPtr 			kp;
-    
+    int ret;
+    xSetDeviceModifierMappingReply rep;
+    DeviceIntPtr dev;
+    KeyClassPtr kp;
+
     REQUEST(xSetDeviceModifierMappingReq);
     REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_SetDeviceModifierMapping, 0, 
-		BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0,
+			  BadDevice);
 	return Success;
-	}
+    }
 
     rep.repType = X_Reply;
     rep.RepType = X_SetDeviceModifierMapping;
@@ -119,26 +115,24 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     ret = SetModifierMapping(client, dev, stuff->length,
-	(sizeof (xSetDeviceModifierMappingReq)>>2), stuff->numKeyPerModifier, 
-	(BYTE *)&stuff[1], &kp);
+			     (sizeof(xSetDeviceModifierMappingReq) >> 2),
+			     stuff->numKeyPerModifier, (BYTE *) & stuff[1],
+			     &kp);
 
-    if (ret==MappingSuccess || ret==MappingBusy || ret==MappingFailed)
-        {
+    if (ret == MappingSuccess || ret == MappingBusy || ret == MappingFailed) {
 	rep.success = ret;
 	if (ret == MappingSuccess)
-            SendDeviceMappingNotify(MappingModifier, 0, 0, dev);
-        WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply),&rep);
-        }
-    else
-	{
-	if (ret==-1)
-	    ret=BadValue;
-	SendErrorToClient (client, IReqCode, X_SetDeviceModifierMapping, 0,ret);
-	}
-
+	    SendDeviceMappingNotify(MappingModifier, 0, 0, dev);
+	WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply),
+			   &rep);
+    } else {
+	if (ret == -1)
+	    ret = BadValue;
+	SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0, ret);
+    }
 
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -148,12 +142,12 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
  */
 
 void
-SRepXSetDeviceModifierMapping (ClientPtr client, int size, xSetDeviceModifierMappingReply *rep)
+SRepXSetDeviceModifierMapping(ClientPtr client, int size,
+			      xSetDeviceModifierMappingReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
-
+}
diff --git a/Xi/setmmap.h b/Xi/setmmap.h
index c859095f8..9b345da7c 100644
--- a/Xi/setmmap.h
+++ b/Xi/setmmap.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/setmmap.h,v 3.1 1996/04/15 11:19:06 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SETMMAP_H
 #define SETMMAP_H 1
 
-int
-SProcXSetDeviceModifierMapping(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXSetDeviceModifierMapping(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXSetDeviceModifierMapping(
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xSetDeviceModifierMappingReply * /* rep */
-	);
+int SProcXSetDeviceModifierMapping(ClientPtr	/* client */
+    );
+
+int ProcXSetDeviceModifierMapping(ClientPtr	/* client */
+    );
+
+void SRepXSetDeviceModifierMapping(ClientPtr /* client */ ,
+				   int /* size */ ,
+				   xSetDeviceModifierMappingReply *	/* rep */
+    );
 
 #endif /* SETMMAP_H */
diff --git a/Xi/setmode.c b/Xi/setmode.c
index a6ea6f8ed..11feb6d32 100644
--- a/Xi/setmode.c
+++ b/Xi/setmode.c
@@ -1,5 +1,3 @@
-/* $Xorg: setmode.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/setmode.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "setmode.h"
@@ -84,8 +81,8 @@ SProcXSetDeviceMode(register ClientPtr client)
 
     REQUEST(xSetDeviceModeReq);
     swaps(&stuff->length, n);
-    return(ProcXSetDeviceMode(client));
-    }
+    return (ProcXSetDeviceMode(client));
+}
 
 /***********************************************************************
  *
@@ -97,7 +94,7 @@ int
 ProcXSetDeviceMode(register ClientPtr client)
 {
     DeviceIntPtr dev;
-    xSetDeviceModeReply	rep;
+    xSetDeviceModeReply rep;
 
     REQUEST(xSetDeviceModeReq);
     REQUEST_SIZE_MATCH(xSetDeviceModeReq);
@@ -107,33 +104,30 @@ ProcXSetDeviceMode(register ClientPtr client)
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
-	SendErrorToClient (client, IReqCode, X_SetDeviceMode, 0, BadDevice);
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadDevice);
 	return Success;
-	}
-    if (dev->valuator == NULL)
-	{
+    }
+    if (dev->valuator == NULL) {
 	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadMatch);
 	return Success;
-	}
+    }
     if ((dev->grab) && !SameClient(dev->grab, client))
 	rep.status = AlreadyGrabbed;
     else
-	rep.status = SetDeviceMode (client, dev, stuff->mode);
+	rep.status = SetDeviceMode(client, dev, stuff->mode);
 
-    if (rep.status == Success) 
-  	dev->valuator->mode = stuff->mode;
-    else if (rep.status != AlreadyGrabbed)
-	{
+    if (rep.status == Success)
+	dev->valuator->mode = stuff->mode;
+    else if (rep.status != AlreadyGrabbed) {
 	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, rep.status);
-        return Success;
-	}
+	return Success;
+    }
 
-    WriteReplyToClient (client, sizeof (xSetDeviceModeReply), &rep);
+    WriteReplyToClient(client, sizeof(xSetDeviceModeReply), &rep);
     return Success;
-    }
+}
 
 /***********************************************************************
  *
@@ -143,11 +137,11 @@ ProcXSetDeviceMode(register ClientPtr client)
  */
 
 void
-SRepXSetDeviceMode (ClientPtr client, int size, xSetDeviceModeReply *rep)
+SRepXSetDeviceMode(ClientPtr client, int size, xSetDeviceModeReply * rep)
 {
     register char n;
 
     swaps(&rep->sequenceNumber, n);
     swapl(&rep->length, n);
     WriteToClient(client, size, (char *)rep);
-    }
+}
diff --git a/Xi/setmode.h b/Xi/setmode.h
index d570af7bd..021bfa02d 100644
--- a/Xi/setmode.h
+++ b/Xi/setmode.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/setmode.h,v 3.1 1996/04/15 11:19:07 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,21 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef SETMODE_H
 #define SETMODE_H 1
 
-int
-SProcXSetDeviceMode(
-	ClientPtr              /* client */
-	);
-
-int
-ProcXSetDeviceMode(
-	ClientPtr              /* client */
-	);
-
-void
-SRepXSetDeviceMode(
-	ClientPtr              /* client */,
-	int                    /* size */,
-	xSetDeviceModeReply *  /* rep */
-	);
+int SProcXSetDeviceMode(ClientPtr	/* client */
+    );
+
+int ProcXSetDeviceMode(ClientPtr	/* client */
+    );
+
+void SRepXSetDeviceMode(ClientPtr /* client */ ,
+			int /* size */ ,
+			xSetDeviceModeReply *	/* rep */
+    );
 
 #endif /* SETMODE_H */
diff --git a/Xi/stubs.c b/Xi/stubs.c
index 547a4cc5d..f7b0fe984 100644
--- a/Xi/stubs.c
+++ b/Xi/stubs.c
@@ -1,5 +1,3 @@
-/* $Xorg: stubs.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/stubs.c,v 3.4 2001/12/14 19:58:59 dawes Exp $ */
 
 /*
  * stubs.c -- stub routines for the X server side of the XINPUT
@@ -94,14 +91,13 @@ SOFTWARE.
  */
 
 int
-ChangeKeyboardDevice (DeviceIntPtr old_dev, DeviceIntPtr new_dev)
+ChangeKeyboardDevice(DeviceIntPtr old_dev, DeviceIntPtr new_dev)
 {
     /***********************************************************************
      DeleteFocusClassDeviceStruct(old_dev);	 * defined in xchgptr.c *
     **********************************************************************/
     return BadMatch;
-    }
-
+}
 
 /***********************************************************************
  *
@@ -134,12 +130,9 @@ ChangeKeyboardDevice (DeviceIntPtr old_dev, DeviceIntPtr new_dev)
  */
 
 int
-ChangePointerDevice (
-    DeviceIntPtr	old_dev,
-    DeviceIntPtr	new_dev,
-    unsigned char	x,
-    unsigned char	y)
-    {
+ChangePointerDevice(DeviceIntPtr old_dev,
+		    DeviceIntPtr new_dev, unsigned char x, unsigned char y)
+{
     /***********************************************************************
     InitFocusClassDeviceStruct(old_dev);	* allow focusing old ptr*
 
@@ -151,7 +144,7 @@ ChangePointerDevice (
 	axes_changed = FALSE;
     *************************************************************************/
     return BadMatch;
-    }
+}
 
 /***********************************************************************
  *
@@ -167,9 +160,9 @@ ChangePointerDevice (
  */
 
 void
-CloseInputDevice (DeviceIntPtr d, ClientPtr client)
+CloseInputDevice(DeviceIntPtr d, ClientPtr client)
 {
-    }
+}
 
 /***********************************************************************
  *
@@ -198,7 +191,7 @@ CloseInputDevice (DeviceIntPtr d, ClientPtr client)
  */
 
 void
-AddOtherInputDevices (void)
+AddOtherInputDevices(void)
 {
     /**********************************************************************
      for each uninitialized device, do something like: 
@@ -213,7 +206,7 @@ AddOtherInputDevices (void)
     dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
     ************************************************************************/
 
-    }
+}
 
 /***********************************************************************
  *
@@ -238,9 +231,9 @@ AddOtherInputDevices (void)
  */
 
 void
-OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)
+OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
 {
-    }
+}
 
 /****************************************************************************
  *
@@ -255,10 +248,10 @@ OpenInputDevice (DeviceIntPtr dev, ClientPtr client, int *status)
  */
 
 int
-SetDeviceMode (register ClientPtr client, DeviceIntPtr dev, int mode)
+SetDeviceMode(register ClientPtr client, DeviceIntPtr dev, int mode)
 {
     return BadMatch;
-    }
+}
 
 /****************************************************************************
  *
@@ -273,10 +266,11 @@ SetDeviceMode (register ClientPtr client, DeviceIntPtr dev, int mode)
  */
 
 int
-SetDeviceValuators (register ClientPtr client, DeviceIntPtr dev, int *valuators, int first_valuator, int num_valuators)
+SetDeviceValuators(register ClientPtr client, DeviceIntPtr dev, int *valuators,
+		   int first_valuator, int num_valuators)
 {
     return BadMatch;
-    }
+}
 
 /****************************************************************************
  *
@@ -287,13 +281,13 @@ SetDeviceValuators (register ClientPtr client, DeviceIntPtr dev, int *valuators,
  */
 
 int
-ChangeDeviceControl (register ClientPtr client, DeviceIntPtr dev, xDeviceCtl *control)
+ChangeDeviceControl(register ClientPtr client, DeviceIntPtr dev,
+		    xDeviceCtl * control)
 {
-    switch (control->control)
-	{
-	case DEVICE_RESOLUTION:
-	    return (BadMatch);
-	default:
-	    return (BadMatch);
-	}
+    switch (control->control) {
+    case DEVICE_RESOLUTION:
+	return (BadMatch);
+    default:
+	return (BadMatch);
     }
+}
diff --git a/Xi/ungrdev.c b/Xi/ungrdev.c
index d8c9f2039..980fa9339 100644
--- a/Xi/ungrdev.c
+++ b/Xi/ungrdev.c
@@ -1,5 +1,3 @@
-/* $Xorg: ungrdev.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/ungrdev.c,v 3.2 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,13 +56,13 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
 #include "ungrdev.h"
@@ -85,8 +82,8 @@ SProcXUngrabDevice(register ClientPtr client)
     swaps(&stuff->length, n);
     REQUEST_SIZE_MATCH(xUngrabDeviceReq);
     swapl(&stuff->time, n);
-    return(ProcXUngrabDevice(client));
-    }
+    return (ProcXUngrabDevice(client));
+}
 
 /***********************************************************************
  *
@@ -97,25 +94,24 @@ SProcXUngrabDevice(register ClientPtr client)
 int
 ProcXUngrabDevice(register ClientPtr client)
 {
-    DeviceIntPtr 	dev;
-    GrabPtr 		grab;
-    TimeStamp 		time;
+    DeviceIntPtr dev;
+    GrabPtr grab;
+    TimeStamp time;
 
     REQUEST(xUngrabDeviceReq);
     REQUEST_SIZE_MATCH(xUngrabDeviceReq);
 
-    dev = LookupDeviceIntRec (stuff->deviceid);
-    if (dev == NULL)
-	{
+    dev = LookupDeviceIntRec(stuff->deviceid);
+    if (dev == NULL) {
 	SendErrorToClient(client, IReqCode, X_UngrabDevice, 0, BadDevice);
 	return Success;
-	}
-    grab =  dev->grab;
+    }
+    grab = dev->grab;
 
     time = ClientTimeToServerTime(stuff->time);
     if ((CompareTimeStamps(time, currentTime) != LATER) &&
 	(CompareTimeStamps(time, dev->grabTime) != EARLIER) &&
 	(grab) && SameClient(grab, client))
-	(*dev->DeactivateGrab)(dev);
+	(*dev->DeactivateGrab) (dev);
     return Success;
-    }
+}
diff --git a/Xi/ungrdev.h b/Xi/ungrdev.h
index e8e866bc9..8e3c210a3 100644
--- a/Xi/ungrdev.h
+++ b/Xi/ungrdev.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/ungrdev.h,v 3.1 1996/04/15 11:19:08 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef UNGRDEV_H
 #define UNGRDEV_H 1
 
-int
-SProcXUngrabDevice(
-	ClientPtr /* client */
-	);
+int SProcXUngrabDevice(ClientPtr	/* client */
+    );
 
-int
-ProcXUngrabDevice(
-	ClientPtr /* client */
-	);
+int ProcXUngrabDevice(ClientPtr	/* client */
+    );
 
 #endif /* UNGRDEV_H */
diff --git a/Xi/ungrdevb.c b/Xi/ungrdevb.c
index 6851930b7..64bb213f5 100644
--- a/Xi/ungrdevb.c
+++ b/Xi/ungrdevb.c
@@ -1,5 +1,3 @@
-/* $Xorg: ungrdevb.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/ungrdevb.c,v 3.3 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "dixgrabs.h"
 
@@ -92,8 +89,8 @@ SProcXUngrabDeviceButton(register ClientPtr client)
     REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
     swapl(&stuff->grabWindow, n);
     swaps(&stuff->modifiers, n);
-    return(ProcXUngrabDeviceButton(client));
-    }
+    return (ProcXUngrabDeviceButton(client));
+}
 
 /***********************************************************************
  *
@@ -104,62 +101,50 @@ SProcXUngrabDeviceButton(register ClientPtr client)
 int
 ProcXUngrabDeviceButton(ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    DeviceIntPtr	mdev;
-    WindowPtr		pWin;
-    GrabRec		temporaryGrab;
+    DeviceIntPtr dev;
+    DeviceIntPtr mdev;
+    WindowPtr pWin;
+    GrabRec temporaryGrab;
 
     REQUEST(xUngrabDeviceButtonReq);
     REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
 
-    dev = LookupDeviceIntRec (stuff->grabbed_device);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-	    BadDevice);
+    dev = LookupDeviceIntRec(stuff->grabbed_device);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadDevice);
 	return Success;
-	}
-    if (dev->button == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-		BadMatch);
+    }
+    if (dev->button == NULL) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadMatch);
 	return Success;
-	}
+    }
 
-    if (stuff->modifier_device != UseXKeyboard)
-	{
-	mdev = LookupDeviceIntRec (stuff->modifier_device);
-	if (mdev == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-	        BadDevice);
+    if (stuff->modifier_device != UseXKeyboard) {
+	mdev = LookupDeviceIntRec(stuff->modifier_device);
+	if (mdev == NULL) {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
+			      BadDevice);
 	    return Success;
-	    }
-	if (mdev->key == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-		BadMatch);
+	}
+	if (mdev->key == NULL) {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
+			      BadMatch);
 	    return Success;
-	    }
 	}
-    else
+    } else
 	mdev = (DeviceIntPtr) LookupKeyboardDevice();
 
     pWin = LookupWindow(stuff->grabWindow, client);
-    if (!pWin)
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-	    BadWindow);
+    if (!pWin) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadWindow);
 	return Success;
-	}
+    }
 
     if ((stuff->modifiers != AnyModifier) &&
-	(stuff->modifiers & ~AllModifiersMask))
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, 
-	    BadValue);
+	(stuff->modifiers & ~AllModifiersMask)) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadValue);
 	return Success;
-	}
+    }
 
     temporaryGrab.resource = client->clientAsMask;
     temporaryGrab.device = dev;
@@ -173,4 +158,4 @@ ProcXUngrabDeviceButton(ClientPtr client)
 
     DeletePassiveGrabFromList(&temporaryGrab);
     return Success;
-    }
+}
diff --git a/Xi/ungrdevb.h b/Xi/ungrdevb.h
index 238e56954..400d61d9e 100644
--- a/Xi/ungrdevb.h
+++ b/Xi/ungrdevb.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/ungrdevb.h,v 3.1 1996/04/15 11:19:10 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef UNGRDEVB_H
 #define UNGRDEVB_H 1
 
-int
-SProcXUngrabDeviceButton(
-	ClientPtr              /* client */
-	);
+int SProcXUngrabDeviceButton(ClientPtr	/* client */
+    );
 
-int
-ProcXUngrabDeviceButton(
-	ClientPtr              /* client */
-	);
+int ProcXUngrabDeviceButton(ClientPtr	/* client */
+    );
 
 #endif /* UNGRDEVB_H */
diff --git a/Xi/ungrdevk.c b/Xi/ungrdevk.c
index 87551ede2..0a6b3b619 100644
--- a/Xi/ungrdevk.c
+++ b/Xi/ungrdevk.c
@@ -1,5 +1,3 @@
-/* $Xorg: ungrdevk.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
-
 /************************************************************
 
 Copyright 1989, 1998  The Open Group
@@ -45,7 +43,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ********************************************************/
-/* $XFree86: xc/programs/Xserver/Xi/ungrdevk.c,v 3.3 2001/01/17 22:13:26 dawes Exp $ */
 
 /***********************************************************************
  *
@@ -59,14 +56,14 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>				/* for inputstr.h    */
-#include <X11/Xproto.h>			/* Request macro     */
-#include "inputstr.h"			/* DeviceIntPtr	     */
-#include "windowstr.h"			/* window structure  */
+#include <X11/X.h>	/* for inputstr.h    */
+#include <X11/Xproto.h>	/* Request macro     */
+#include "inputstr.h"	/* DeviceIntPtr      */
+#include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "extnsionst.h"
-#include "extinit.h"			/* LookupDeviceIntRec */
+#include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "dixgrabs.h"
 
@@ -92,8 +89,8 @@ SProcXUngrabDeviceKey(register ClientPtr client)
     REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
     swapl(&stuff->grabWindow, n);
     swaps(&stuff->modifiers, n);
-    return(ProcXUngrabDeviceKey(client));
-    }
+    return (ProcXUngrabDeviceKey(client));
+}
 
 /***********************************************************************
  *
@@ -104,73 +101,59 @@ SProcXUngrabDeviceKey(register ClientPtr client)
 int
 ProcXUngrabDeviceKey(ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    DeviceIntPtr	mdev;
-    WindowPtr 		pWin;
-    GrabRec 		temporaryGrab;
+    DeviceIntPtr dev;
+    DeviceIntPtr mdev;
+    WindowPtr pWin;
+    GrabRec temporaryGrab;
 
     REQUEST(xUngrabDeviceKeyReq);
     REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
 
-    dev = LookupDeviceIntRec (stuff->grabbed_device);
-    if (dev == NULL)
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-	    BadDevice);
+    dev = LookupDeviceIntRec(stuff->grabbed_device);
+    if (dev == NULL) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadDevice);
 	return Success;
-	}
-    if (dev->key == NULL)
-	{
+    }
+    if (dev->key == NULL) {
 	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
 	return Success;
-	}
+    }
 
-    if (stuff->modifier_device != UseXKeyboard)
-	{
-	mdev = LookupDeviceIntRec (stuff->modifier_device);
-	if (mdev == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-	        BadDevice);
+    if (stuff->modifier_device != UseXKeyboard) {
+	mdev = LookupDeviceIntRec(stuff->modifier_device);
+	if (mdev == NULL) {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0,
+			      BadDevice);
 	    return Success;
-	    }
-	if (mdev->key == NULL)
-	    {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-		BadMatch);
+	}
+	if (mdev->key == NULL) {
+	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
 	    return Success;
-	    }
 	}
-    else
+    } else
 	mdev = (DeviceIntPtr) LookupKeyboardDevice();
 
     pWin = LookupWindow(stuff->grabWindow, client);
-    if (!pWin)
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-	    BadWindow);
+    if (!pWin) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadWindow);
 	return Success;
-	}
+    }
     if (((stuff->key > dev->key->curKeySyms.maxKeyCode) ||
 	 (stuff->key < dev->key->curKeySyms.minKeyCode))
-	&& (stuff->key != AnyKey))
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-	    BadValue);
+	&& (stuff->key != AnyKey)) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
 	return Success;
-	}
+    }
     if ((stuff->modifiers != AnyModifier) &&
-	(stuff->modifiers & ~AllModifiersMask))
-	{
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, 
-	    BadValue);
+	(stuff->modifiers & ~AllModifiersMask)) {
+	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
 	return Success;
-	}
+    }
 
     temporaryGrab.resource = client->clientAsMask;
     temporaryGrab.device = dev;
     temporaryGrab.window = pWin;
-    temporaryGrab.type  = DeviceKeyPress;
+    temporaryGrab.type = DeviceKeyPress;
     temporaryGrab.modifierDevice = mdev;
     temporaryGrab.modifiersDetail.exact = stuff->modifiers;
     temporaryGrab.modifiersDetail.pMask = NULL;
@@ -179,4 +162,4 @@ ProcXUngrabDeviceKey(ClientPtr client)
 
     DeletePassiveGrabFromList(&temporaryGrab);
     return Success;
-    }
+}
diff --git a/Xi/ungrdevk.h b/Xi/ungrdevk.h
index ba3455882..9dec17a10 100644
--- a/Xi/ungrdevk.h
+++ b/Xi/ungrdevk.h
@@ -1,4 +1,3 @@
-/* $XFree86: xc/programs/Xserver/Xi/ungrdevk.h,v 3.1 1996/04/15 11:19:12 dawes Exp $ */
 /************************************************************
 
 Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
@@ -31,14 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifndef UNGRDEVK_H
 #define UNGRDEVK_H 1
 
-int
-SProcXUngrabDeviceKey(
-	ClientPtr              /* client */
-	);
+int SProcXUngrabDeviceKey(ClientPtr	/* client */
+    );
 
-int
-ProcXUngrabDeviceKey(
-	ClientPtr              /* client */
-	);
+int ProcXUngrabDeviceKey(ClientPtr	/* client */
+    );
 
 #endif /* UNGRDEVK_H */