Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 4593 insertions, 4440 deletions

diff --git a/xorg-server/xkb/xkb.c b/xorg-server/xkb/xkb.c
index 260f4a067..dc15e5de3 100644
--- a/xorg-server/xkb/xkb.c
+++ b/xorg-server/xkb/xkb.c
@@ -43,14 +43,14 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XKMformat.h>
 
-int		XkbEventBase;
-static	int	XkbErrorBase;
-int		XkbReqCode;
-int		XkbKeyboardErrorCode;
-CARD32		xkbDebugFlags = 0;
-static CARD32	xkbDebugCtrls = 0;
+int XkbEventBase;
+static int XkbErrorBase;
+int XkbReqCode;
+int XkbKeyboardErrorCode;
+CARD32 xkbDebugFlags = 0;
+static CARD32 xkbDebugCtrls = 0;
 
-static RESTYPE	RT_XKBCLIENT;
+static RESTYPE RT_XKBCLIENT;
 
 /***====================================================================***/
 
@@ -157,28 +157,29 @@ int
 ProcXkbUseExtension(ClientPtr client)
 {
     REQUEST(xkbUseExtensionReq);
-    xkbUseExtensionReply	rep;
-    int	supported;
+    xkbUseExtensionReply rep;
+    int supported;
 
     REQUEST_SIZE_MATCH(xkbUseExtensionReq);
     if (stuff->wantedMajor != SERVER_XKB_MAJOR_VERSION) {
-	/* pre-release version 0.65 is compatible with 1.00 */
-	supported= ((SERVER_XKB_MAJOR_VERSION==1)&&
-		    (stuff->wantedMajor==0)&&(stuff->wantedMinor==65));
+        /* pre-release version 0.65 is compatible with 1.00 */
+        supported = ((SERVER_XKB_MAJOR_VERSION == 1) &&
+                     (stuff->wantedMajor == 0) && (stuff->wantedMinor == 65));
     }
-    else supported = 1;
+    else
+        supported = 1;
 
-    if ((supported) && (!(client->xkbClientFlags&_XkbClientInitialized))) {
-	client->xkbClientFlags= _XkbClientInitialized;
-	client->vMajor= stuff->wantedMajor;
-	client->vMinor= stuff->wantedMinor;
+    if ((supported) && (!(client->xkbClientFlags & _XkbClientInitialized))) {
+        client->xkbClientFlags = _XkbClientInitialized;
+        client->vMajor = stuff->wantedMajor;
+        client->vMinor = stuff->wantedMinor;
     }
-    else if (xkbDebugFlags&0x1) {
-	ErrorF("[xkb] Rejecting client %d (0x%lx) (wants %d.%02d, have %d.%02d)\n",
-					client->index,
-					(long)client->clientAsMask,
-					stuff->wantedMajor,stuff->wantedMinor,
-					SERVER_XKB_MAJOR_VERSION,SERVER_XKB_MINOR_VERSION);
+    else if (xkbDebugFlags & 0x1) {
+        ErrorF
+            ("[xkb] Rejecting client %d (0x%lx) (wants %d.%02d, have %d.%02d)\n",
+             client->index, (long) client->clientAsMask, stuff->wantedMajor,
+             stuff->wantedMinor, SERVER_XKB_MAJOR_VERSION,
+             SERVER_XKB_MINOR_VERSION);
     }
     memset(&rep, 0, sizeof(xkbUseExtensionReply));
     rep.type = X_Reply;
@@ -187,12 +188,12 @@ ProcXkbUseExtension(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.serverMajor = SERVER_XKB_MAJOR_VERSION;
     rep.serverMinor = SERVER_XKB_MINOR_VERSION;
-    if ( client->swapped ) {
-	swaps(&rep.sequenceNumber);
-	swaps(&rep.serverMajor);
-	swaps(&rep.serverMinor);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swaps(&rep.serverMajor);
+        swaps(&rep.serverMinor);
     }
-    WriteToClient(client,SIZEOF(xkbUseExtensionReply), (char *)&rep);
+    WriteToClient(client, SIZEOF(xkbUseExtensionReply), (char *) &rep);
     return Success;
 }
 
@@ -201,149 +202,158 @@ ProcXkbUseExtension(ClientPtr client)
 int
 ProcXkbSelectEvents(ClientPtr client)
 {
-    unsigned		legal;
-    DeviceIntPtr 	dev;
-    XkbInterestPtr	masks;
+    unsigned legal;
+    DeviceIntPtr dev;
+    XkbInterestPtr masks;
+
     REQUEST(xkbSelectEventsReq);
 
     REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixUseAccess);
 
-    if (((stuff->affectWhich&XkbMapNotifyMask)!=0)&&(stuff->affectMap)) {
-	client->mapNotifyMask&= ~stuff->affectMap;
-	client->mapNotifyMask|= (stuff->affectMap&stuff->map);
+    if (((stuff->affectWhich & XkbMapNotifyMask) != 0) && (stuff->affectMap)) {
+        client->mapNotifyMask &= ~stuff->affectMap;
+        client->mapNotifyMask |= (stuff->affectMap & stuff->map);
     }
-    if ((stuff->affectWhich&(~XkbMapNotifyMask))==0) 
-	return Success;
+    if ((stuff->affectWhich & (~XkbMapNotifyMask)) == 0)
+        return Success;
+
+    masks = XkbFindClientResource((DevicePtr) dev, client);
+    if (!masks) {
+        XID id = FakeClientID(client->index);
 
-    masks = XkbFindClientResource((DevicePtr)dev,client);
-    if (!masks){
-	XID id = FakeClientID(client->index);
-	if (!AddResource(id,RT_XKBCLIENT,dev))
-	    return BadAlloc;
-	masks= XkbAddClientResource((DevicePtr)dev,client,id);
+        if (!AddResource(id, RT_XKBCLIENT, dev))
+            return BadAlloc;
+        masks = XkbAddClientResource((DevicePtr) dev, client, id);
     }
     if (masks) {
-	union {
-	    CARD8	*c8;
-	    CARD16	*c16;
-	    CARD32	*c32;
-	} from,to;
-	register unsigned bit,ndx,maskLeft,dataLeft,size;
-
-	from.c8= (CARD8 *)&stuff[1];
-	dataLeft= (stuff->length*4)-SIZEOF(xkbSelectEventsReq);
-	maskLeft= (stuff->affectWhich&(~XkbMapNotifyMask));
-	for (ndx=0,bit=1; (maskLeft!=0); ndx++, bit<<=1) {
-	    if ((bit&maskLeft)==0)
-		continue;
-	    maskLeft&= ~bit;
-	    switch (ndx) {
-		case XkbNewKeyboardNotify:
-		    to.c16= &client->newKeyboardNotifyMask;
-		    legal= XkbAllNewKeyboardEventsMask;
-		    size= 2;
-		    break;
-		case XkbStateNotify:
-		    to.c16= &masks->stateNotifyMask;
-		    legal= XkbAllStateEventsMask;
-		    size= 2;
-		    break;
-		case XkbControlsNotify:
-		    to.c32= &masks->ctrlsNotifyMask;
-		    legal= XkbAllControlEventsMask;
-		    size= 4;
-		    break;
-		case XkbIndicatorStateNotify:
-		    to.c32= &masks->iStateNotifyMask;
-		    legal= XkbAllIndicatorEventsMask;
-		    size= 4;
-		    break;
-		case XkbIndicatorMapNotify:
-		    to.c32= &masks->iMapNotifyMask;
-		    legal= XkbAllIndicatorEventsMask;
-		    size= 4;
-		    break;
-		case XkbNamesNotify:
-		    to.c16= &masks->namesNotifyMask;
-		    legal= XkbAllNameEventsMask;
-		    size= 2;
-		    break;
-		case XkbCompatMapNotify:
-		    to.c8= &masks->compatNotifyMask;
-		    legal= XkbAllCompatMapEventsMask;
-		    size= 1;
-		    break;
-		case XkbBellNotify:
-		    to.c8= &masks->bellNotifyMask;
-		    legal= XkbAllBellEventsMask;
-		    size= 1;
-		    break;
-		case XkbActionMessage:
-		    to.c8= &masks->actionMessageMask;
-		    legal= XkbAllActionMessagesMask;
-		    size= 1;
-		    break;
-		case XkbAccessXNotify:
-		    to.c16= &masks->accessXNotifyMask;
-		    legal= XkbAllAccessXEventsMask;
-		    size= 2;
-		    break;
-		case XkbExtensionDeviceNotify:
-		    to.c16= &masks->extDevNotifyMask;
-		    legal= XkbAllExtensionDeviceEventsMask;
-		    size= 2;
-		    break;
-		default:
-		    client->errorValue = _XkbErrCode2(33,bit);
-		    return BadValue;
-	    }
-
-	    if (stuff->clear&bit) {
-		if (size==2)		to.c16[0]= 0;
-		else if (size==4)	to.c32[0]= 0;
-		else			to.c8[0]=  0;
-	    }
-	    else if (stuff->selectAll&bit) {
-		if (size==2)		to.c16[0]= ~0;
-		else if (size==4)	to.c32[0]= ~0;
-		else			to.c8[0]=  ~0;
-	    }
-	    else {
-		if (dataLeft<(size*2))
-		    return BadLength;
-		if (size==2) {
-		    CHK_MASK_MATCH(ndx,from.c16[0],from.c16[1]);
-		    CHK_MASK_LEGAL(ndx,from.c16[0],legal);
-		    to.c16[0]&= ~from.c16[0];
-		    to.c16[0]|= (from.c16[0]&from.c16[1]);
-		}
-		else if (size==4) {
-		    CHK_MASK_MATCH(ndx,from.c32[0],from.c32[1]);
-		    CHK_MASK_LEGAL(ndx,from.c32[0],legal);
-		    to.c32[0]&= ~from.c32[0];
-		    to.c32[0]|= (from.c32[0]&from.c32[1]);
-		}
-		else  {
-		    CHK_MASK_MATCH(ndx,from.c8[0],from.c8[1]);
-		    CHK_MASK_LEGAL(ndx,from.c8[0],legal);
-		    to.c8[0]&= ~from.c8[0];
-		    to.c8[0]|= (from.c8[0]&from.c8[1]);
-		    size= 2;
-		}
-		from.c8+= (size*2);
-		dataLeft-= (size*2);
-	    }
-	}
-	if (dataLeft>2) {
-	    ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",dataLeft);
-	    return BadLength;
-	}
-	return Success;
+        union {
+            CARD8 *c8;
+            CARD16 *c16;
+            CARD32 *c32;
+        } from, to;
+        register unsigned bit, ndx, maskLeft, dataLeft, size;
+
+        from.c8 = (CARD8 *) &stuff[1];
+        dataLeft = (stuff->length * 4) - SIZEOF(xkbSelectEventsReq);
+        maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask));
+        for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) {
+            if ((bit & maskLeft) == 0)
+                continue;
+            maskLeft &= ~bit;
+            switch (ndx) {
+            case XkbNewKeyboardNotify:
+                to.c16 = &client->newKeyboardNotifyMask;
+                legal = XkbAllNewKeyboardEventsMask;
+                size = 2;
+                break;
+            case XkbStateNotify:
+                to.c16 = &masks->stateNotifyMask;
+                legal = XkbAllStateEventsMask;
+                size = 2;
+                break;
+            case XkbControlsNotify:
+                to.c32 = &masks->ctrlsNotifyMask;
+                legal = XkbAllControlEventsMask;
+                size = 4;
+                break;
+            case XkbIndicatorStateNotify:
+                to.c32 = &masks->iStateNotifyMask;
+                legal = XkbAllIndicatorEventsMask;
+                size = 4;
+                break;
+            case XkbIndicatorMapNotify:
+                to.c32 = &masks->iMapNotifyMask;
+                legal = XkbAllIndicatorEventsMask;
+                size = 4;
+                break;
+            case XkbNamesNotify:
+                to.c16 = &masks->namesNotifyMask;
+                legal = XkbAllNameEventsMask;
+                size = 2;
+                break;
+            case XkbCompatMapNotify:
+                to.c8 = &masks->compatNotifyMask;
+                legal = XkbAllCompatMapEventsMask;
+                size = 1;
+                break;
+            case XkbBellNotify:
+                to.c8 = &masks->bellNotifyMask;
+                legal = XkbAllBellEventsMask;
+                size = 1;
+                break;
+            case XkbActionMessage:
+                to.c8 = &masks->actionMessageMask;
+                legal = XkbAllActionMessagesMask;
+                size = 1;
+                break;
+            case XkbAccessXNotify:
+                to.c16 = &masks->accessXNotifyMask;
+                legal = XkbAllAccessXEventsMask;
+                size = 2;
+                break;
+            case XkbExtensionDeviceNotify:
+                to.c16 = &masks->extDevNotifyMask;
+                legal = XkbAllExtensionDeviceEventsMask;
+                size = 2;
+                break;
+            default:
+                client->errorValue = _XkbErrCode2(33, bit);
+                return BadValue;
+            }
+
+            if (stuff->clear & bit) {
+                if (size == 2)
+                    to.c16[0] = 0;
+                else if (size == 4)
+                    to.c32[0] = 0;
+                else
+                    to.c8[0] = 0;
+            }
+            else if (stuff->selectAll & bit) {
+                if (size == 2)
+                    to.c16[0] = ~0;
+                else if (size == 4)
+                    to.c32[0] = ~0;
+                else
+                    to.c8[0] = ~0;
+            }
+            else {
+                if (dataLeft < (size * 2))
+                    return BadLength;
+                if (size == 2) {
+                    CHK_MASK_MATCH(ndx, from.c16[0], from.c16[1]);
+                    CHK_MASK_LEGAL(ndx, from.c16[0], legal);
+                    to.c16[0] &= ~from.c16[0];
+                    to.c16[0] |= (from.c16[0] & from.c16[1]);
+                }
+                else if (size == 4) {
+                    CHK_MASK_MATCH(ndx, from.c32[0], from.c32[1]);
+                    CHK_MASK_LEGAL(ndx, from.c32[0], legal);
+                    to.c32[0] &= ~from.c32[0];
+                    to.c32[0] |= (from.c32[0] & from.c32[1]);
+                }
+                else {
+                    CHK_MASK_MATCH(ndx, from.c8[0], from.c8[1]);
+                    CHK_MASK_LEGAL(ndx, from.c8[0], legal);
+                    to.c8[0] &= ~from.c8[0];
+                    to.c8[0] |= (from.c8[0] & from.c8[1]);
+                    size = 2;
+                }
+                from.c8 += (size * 2);
+                dataLeft -= (size * 2);
+            }
+        }
+        if (dataLeft > 2) {
+            ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",
+                   dataLeft);
+            return BadLength;
+        }
+        return Success;
     }
     return BadAlloc;
 }
@@ -357,67 +367,73 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
          int bellClass, int bellID, int pitch, int duration,
          int percent, int forceSound, int eventOnly, Atom name)
 {
-    int         base;
-    pointer     ctrl;
-    int         oldPitch, oldDuration;
-    int         newPercent;
+    int base;
+    pointer ctrl;
+    int oldPitch, oldDuration;
+    int newPercent;
 
     if (bellClass == KbdFeedbackClass) {
-        KbdFeedbackPtr	k;
-        if (bellID==XkbDfltXIId)
-            k= dev->kbdfeed;
+        KbdFeedbackPtr k;
+
+        if (bellID == XkbDfltXIId)
+            k = dev->kbdfeed;
         else {
-            for (k=dev->kbdfeed; k; k=k->next) {
+            for (k = dev->kbdfeed; k; k = k->next) {
                 if (k->ctrl.id == bellID)
                     break;
             }
         }
         if (!k) {
-            client->errorValue = _XkbErrCode2(0x5,bellID);
+            client->errorValue = _XkbErrCode2(0x5, bellID);
             return BadValue;
         }
         base = k->ctrl.bell;
         ctrl = (pointer) &(k->ctrl);
-        oldPitch= k->ctrl.bell_pitch;
-        oldDuration= k->ctrl.bell_duration;
-        if (pitch!=0) {
-            if (pitch==-1)
-                k->ctrl.bell_pitch= defaultKeyboardControl.bell_pitch;
-            else k->ctrl.bell_pitch= pitch;
+        oldPitch = k->ctrl.bell_pitch;
+        oldDuration = k->ctrl.bell_duration;
+        if (pitch != 0) {
+            if (pitch == -1)
+                k->ctrl.bell_pitch = defaultKeyboardControl.bell_pitch;
+            else
+                k->ctrl.bell_pitch = pitch;
         }
-        if (duration!=0) {
-            if (duration==-1)
-                k->ctrl.bell_duration= defaultKeyboardControl.bell_duration;
-            else k->ctrl.bell_duration= duration;
+        if (duration != 0) {
+            if (duration == -1)
+                k->ctrl.bell_duration = defaultKeyboardControl.bell_duration;
+            else
+                k->ctrl.bell_duration = duration;
         }
     }
     else if (bellClass == BellFeedbackClass) {
-        BellFeedbackPtr	b;
-        if (bellID==XkbDfltXIId)
-            b= dev->bell;
+        BellFeedbackPtr b;
+
+        if (bellID == XkbDfltXIId)
+            b = dev->bell;
         else {
-            for (b=dev->bell; b; b=b->next) {
+            for (b = dev->bell; b; b = b->next) {
                 if (b->ctrl.id == bellID)
                     break;
             }
         }
         if (!b) {
-            client->errorValue = _XkbErrCode2(0x6,bellID);
+            client->errorValue = _XkbErrCode2(0x6, bellID);
             return BadValue;
         }
         base = b->ctrl.percent;
         ctrl = (pointer) &(b->ctrl);
-        oldPitch= b->ctrl.pitch;
-        oldDuration= b->ctrl.duration;
-        if (pitch!=0) {
-            if (pitch==-1)
-                b->ctrl.pitch= defaultKeyboardControl.bell_pitch;
-            else b->ctrl.pitch= pitch;
+        oldPitch = b->ctrl.pitch;
+        oldDuration = b->ctrl.duration;
+        if (pitch != 0) {
+            if (pitch == -1)
+                b->ctrl.pitch = defaultKeyboardControl.bell_pitch;
+            else
+                b->ctrl.pitch = pitch;
         }
-        if (duration!=0) {
-            if (duration==-1)
-                b->ctrl.duration= defaultKeyboardControl.bell_duration;
-            else b->ctrl.duration= duration;
+        if (duration != 0) {
+            if (duration == -1)
+                b->ctrl.duration = defaultKeyboardControl.bell_duration;
+            else
+                b->ctrl.duration = duration;
         }
     }
     else {
@@ -425,30 +441,32 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
         return BadValue;
     }
 
-    newPercent = (base * percent)/100;
+    newPercent = (base * percent) / 100;
     if (percent < 0)
-         newPercent = base + newPercent;
-    else newPercent = base - newPercent + percent;
+        newPercent = base + newPercent;
+    else
+        newPercent = base - newPercent + percent;
 
     XkbHandleBell(forceSound, eventOnly,
-                  dev, newPercent, ctrl, bellClass,
-                  name, pWin, client);
-    if ((pitch!=0)||(duration!=0)) {
+                  dev, newPercent, ctrl, bellClass, name, pWin, client);
+    if ((pitch != 0) || (duration != 0)) {
         if (bellClass == KbdFeedbackClass) {
-            KbdFeedbackPtr      k;
-            k= (KbdFeedbackPtr)ctrl;
-            if (pitch!=0)
-                k->ctrl.bell_pitch= oldPitch;
-            if (duration!=0)
-                k->ctrl.bell_duration= oldDuration;
+            KbdFeedbackPtr k;
+
+            k = (KbdFeedbackPtr) ctrl;
+            if (pitch != 0)
+                k->ctrl.bell_pitch = oldPitch;
+            if (duration != 0)
+                k->ctrl.bell_duration = oldDuration;
         }
         else {
-            BellFeedbackPtr     b;
-            b= (BellFeedbackPtr)ctrl;
-            if (pitch!=0)
-                b->ctrl.pitch= oldPitch;
-            if (duration!=0)
-                b->ctrl.duration= oldDuration;
+            BellFeedbackPtr b;
+
+            b = (BellFeedbackPtr) ctrl;
+            if (pitch != 0)
+                b->ctrl.pitch = oldPitch;
+            if (duration != 0)
+                b->ctrl.duration = oldDuration;
         }
     }
 
@@ -460,49 +478,52 @@ ProcXkbBell(ClientPtr client)
 {
     REQUEST(xkbBellReq);
     DeviceIntPtr dev;
-    WindowPtr	 pWin;
+    WindowPtr pWin;
     int rc;
 
     REQUEST_SIZE_MATCH(xkbBellReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_BELL_DEVICE(dev, stuff->deviceSpec, client, DixBellAccess);
     CHK_ATOM_OR_NONE(stuff->name);
 
     /* device-independent checks request for sane values */
-    if ((stuff->forceSound)&&(stuff->eventOnly)) {
-	client->errorValue=_XkbErrCode3(0x1,stuff->forceSound,stuff->eventOnly);
-	return BadMatch;
+    if ((stuff->forceSound) && (stuff->eventOnly)) {
+        client->errorValue =
+            _XkbErrCode3(0x1, stuff->forceSound, stuff->eventOnly);
+        return BadMatch;
     }
     if (stuff->percent < -100 || stuff->percent > 100) {
-	client->errorValue = _XkbErrCode2(0x2,stuff->percent);
-	return BadValue;
+        client->errorValue = _XkbErrCode2(0x2, stuff->percent);
+        return BadValue;
     }
-    if (stuff->duration<-1) {
-	client->errorValue = _XkbErrCode2(0x3,stuff->duration);
-	return BadValue;
+    if (stuff->duration < -1) {
+        client->errorValue = _XkbErrCode2(0x3, stuff->duration);
+        return BadValue;
     }
-    if (stuff->pitch<-1) {
-	client->errorValue = _XkbErrCode2(0x4,stuff->pitch);
-	return BadValue;
+    if (stuff->pitch < -1) {
+        client->errorValue = _XkbErrCode2(0x4, stuff->pitch);
+        return BadValue;
     }
 
     if (stuff->bellClass == XkbDfltXIClass) {
-	if (dev->kbdfeed!=NULL)
-	     stuff->bellClass= KbdFeedbackClass;
-	else stuff->bellClass= BellFeedbackClass;
+        if (dev->kbdfeed != NULL)
+            stuff->bellClass = KbdFeedbackClass;
+        else
+            stuff->bellClass = BellFeedbackClass;
     }
 
-    if (stuff->window!=None) {
-	rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
-	if (rc != Success) {
-	    client->errorValue= stuff->window;
-	    return rc;
-	}
+    if (stuff->window != None) {
+        rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
+        if (rc != Success) {
+            client->errorValue = stuff->window;
+            return rc;
+        }
     }
-    else pWin= NULL;
+    else
+        pWin = NULL;
 
     /* Client wants to ring a bell on the core keyboard?
        Ring the bell on the core keyboard (which does nothing, but if that
@@ -518,13 +539,12 @@ ProcXkbBell(ClientPtr client)
                   stuff->forceSound, stuff->eventOnly, stuff->name);
 
     if ((rc == Success) && ((stuff->deviceSpec == XkbUseCoreKbd) ||
-                            (stuff->deviceSpec == XkbUseCorePtr)))
-    {
+                            (stuff->deviceSpec == XkbUseCorePtr))) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
                 rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixBellAccess);
                 if (rc == Success)
                     _XkbBell(client, other, pWin, stuff->bellClass,
@@ -533,7 +553,7 @@ ProcXkbBell(ClientPtr client)
                              stuff->eventOnly, stuff->name);
             }
         }
-        rc = Success; /* reset to success, that's what we got for the VCK */
+        rc = Success;           /* reset to success, that's what we got for the VCK */
     }
 
     return rc;
@@ -545,21 +565,21 @@ int
 ProcXkbGetState(ClientPtr client)
 {
     REQUEST(xkbGetStateReq);
-    DeviceIntPtr	dev;
-    xkbGetStateReply	 rep;
-    XkbStateRec		*xkb;
+    DeviceIntPtr dev;
+    xkbGetStateReply rep;
+    XkbStateRec *xkb;
 
     REQUEST_SIZE_MATCH(xkbGetStateReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
 
-    xkb= &dev->key->xkbInfo->state;
+    xkb = &dev->key->xkbInfo->state;
     memset(&rep, 0, sizeof(xkbGetStateReply));
-    rep.type= X_Reply;
-    rep.sequenceNumber= client->sequence;
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
     rep.length = 0;
     rep.deviceID = dev->id;
     rep.mods = XkbStateFieldFromRec(xkb) & 0xff;
@@ -573,10 +593,10 @@ ProcXkbGetState(ClientPtr client)
     rep.compatState = xkb->compat_state;
     rep.ptrBtnState = xkb->ptr_buttons;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swaps(&rep.ptrBtnState);
+        swaps(&rep.sequenceNumber);
+        swaps(&rep.ptrBtnState);
     }
-    WriteToClient(client, SIZEOF(xkbGetStateReply), (char *)&rep);
+    WriteToClient(client, SIZEOF(xkbGetStateReply), (char *) &rep);
     return Success;
 }
 
@@ -587,7 +607,7 @@ ProcXkbLatchLockState(ClientPtr client)
 {
     int status;
     DeviceIntPtr dev, tmpd;
-    XkbStateRec	oldState,*newState;
+    XkbStateRec oldState, *newState;
     CARD16 changed;
     xkbStateNotify sn;
     XkbEventCauseRec cause;
@@ -596,7 +616,7 @@ ProcXkbLatchLockState(ClientPtr client)
     REQUEST_SIZE_MATCH(xkbLatchLockStateReq);
 
     if (!(client->xkbClientFlags & _XkbClientInitialized))
-	return BadAccess;
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
     CHK_MASK_MATCH(0x01, stuff->affectModLocks, stuff->modLocks);
@@ -605,7 +625,8 @@ ProcXkbLatchLockState(ClientPtr client)
     status = Success;
 
     for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
-        if ((tmpd == dev) || (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
+        if ((tmpd == dev) ||
+            (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
             if (!tmpd->key || !tmpd->key->xkbInfo)
                 continue;
 
@@ -613,7 +634,8 @@ ProcXkbLatchLockState(ClientPtr client)
             newState = &tmpd->key->xkbInfo->state;
             if (stuff->affectModLocks) {
                 newState->locked_mods &= ~stuff->affectModLocks;
-                newState->locked_mods |= (stuff->affectModLocks & stuff->modLocks);
+                newState->locked_mods |=
+                    (stuff->affectModLocks & stuff->modLocks);
             }
             if (status == Success && stuff->lockGroup)
                 newState->locked_group = stuff->groupLock;
@@ -640,7 +662,7 @@ ProcXkbLatchLockState(ClientPtr client)
                 if (changed) {
                     XkbSetCauseXkbReq(&cause, X_kbLatchLockState, client);
                     XkbUpdateIndicators(tmpd, changed, TRUE, NULL, &cause);
-	        }
+                }
             }
         }
     }
@@ -654,23 +676,23 @@ int
 ProcXkbGetControls(ClientPtr client)
 {
     xkbGetControlsReply rep;
-    XkbControlsPtr	xkb;
-    DeviceIntPtr 	dev;
+    XkbControlsPtr xkb;
+    DeviceIntPtr dev;
 
     REQUEST(xkbGetControlsReq);
     REQUEST_SIZE_MATCH(xkbGetControlsReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
-    
+
     xkb = dev->key->xkbInfo->desc->ctrls;
     rep.type = X_Reply;
-    rep.length = bytes_to_int32(SIZEOF(xkbGetControlsReply)-
-		  SIZEOF(xGenericReply));
+    rep.length = bytes_to_int32(SIZEOF(xkbGetControlsReply) -
+                                SIZEOF(xGenericReply));
     rep.sequenceNumber = client->sequence;
-    rep.deviceID = ((DeviceIntPtr)dev)->id;
+    rep.deviceID = ((DeviceIntPtr) dev)->id;
     rep.numGroups = xkb->num_groups;
     rep.groupsWrap = xkb->groups_wrap;
     rep.internalMods = xkb->internal.mask;
@@ -696,49 +718,49 @@ ProcXkbGetControls(ClientPtr client)
     rep.axtOptsMask = xkb->axt_opts_mask;
     rep.axtOptsValues = xkb->axt_opts_values;
     rep.axOptions = xkb->ax_options;
-    memcpy(rep.perKeyRepeat,xkb->per_key_repeat,XkbPerKeyBitArraySize);
+    memcpy(rep.perKeyRepeat, xkb->per_key_repeat, XkbPerKeyBitArraySize);
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swaps(&rep.internalVMods);
-	swaps(&rep.ignoreLockVMods);
-	swapl(&rep.enabledCtrls);
-	swaps(&rep.repeatDelay);
-	swaps(&rep.repeatInterval);
-	swaps(&rep.slowKeysDelay);
-	swaps(&rep.debounceDelay);
-	swaps(&rep.mkDelay);
-	swaps(&rep.mkInterval);
-	swaps(&rep.mkTimeToMax);
-	swaps(&rep.mkMaxSpeed);
-	swaps(&rep.mkCurve);
-	swaps(&rep.axTimeout);
-	swapl(&rep.axtCtrlsMask);
-	swapl(&rep.axtCtrlsValues);
-	swaps(&rep.axtOptsMask);
-	swaps(&rep.axtOptsValues);
-	swaps(&rep.axOptions);
-    }
-    WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *)&rep);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.internalVMods);
+        swaps(&rep.ignoreLockVMods);
+        swapl(&rep.enabledCtrls);
+        swaps(&rep.repeatDelay);
+        swaps(&rep.repeatInterval);
+        swaps(&rep.slowKeysDelay);
+        swaps(&rep.debounceDelay);
+        swaps(&rep.mkDelay);
+        swaps(&rep.mkInterval);
+        swaps(&rep.mkTimeToMax);
+        swaps(&rep.mkMaxSpeed);
+        swaps(&rep.mkCurve);
+        swaps(&rep.axTimeout);
+        swapl(&rep.axtCtrlsMask);
+        swapl(&rep.axtCtrlsValues);
+        swaps(&rep.axtOptsMask);
+        swaps(&rep.axtOptsValues);
+        swaps(&rep.axOptions);
+    }
+    WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *) &rep);
     return Success;
 }
 
 int
 ProcXkbSetControls(ClientPtr client)
 {
-    DeviceIntPtr 	dev, tmpd;
-    XkbSrvInfoPtr	xkbi;
-    XkbControlsPtr	ctrl;
-    XkbControlsRec	new,old;
-    xkbControlsNotify	cn;
-    XkbEventCauseRec	cause;
-    XkbSrvLedInfoPtr	sli;
+    DeviceIntPtr dev, tmpd;
+    XkbSrvInfoPtr xkbi;
+    XkbControlsPtr ctrl;
+    XkbControlsRec new, old;
+    xkbControlsNotify cn;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
 
     REQUEST(xkbSetControlsReq);
     REQUEST_SIZE_MATCH(xkbSetControlsReq);
 
     if (!(client->xkbClientFlags & _XkbClientInitialized))
-	return BadAccess;
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
     CHK_MASK_LEGAL(0x01, stuff->changeCtrls, XkbAllControlsMask);
@@ -746,7 +768,8 @@ ProcXkbSetControls(ClientPtr client)
     for (tmpd = inputInfo.devices; tmpd; tmpd = tmpd->next) {
         if (!tmpd->key || !tmpd->key->xkbInfo)
             continue;
-        if ((tmpd == dev) || (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
+        if ((tmpd == dev) ||
+            (!IsMaster(tmpd) && GetMaster(tmpd, MASTER_KEYBOARD) == dev)) {
             xkbi = tmpd->key->xkbInfo;
             ctrl = xkbi->desc->ctrls;
             new = *ctrl;
@@ -765,8 +788,7 @@ ProcXkbSetControls(ClientPtr client)
                 new.internal.vmods |= (stuff->affectInternalVMods &
                                        stuff->internalVMods);
                 new.internal.mask = new.internal.real_mods |
-                                    XkbMaskForVMask(xkbi->desc,
-                                                    new.internal.vmods);
+                    XkbMaskForVMask(xkbi->desc, new.internal.vmods);
             }
 
             if (stuff->changeCtrls & XkbIgnoreLockModsMask) {
@@ -782,8 +804,7 @@ ProcXkbSetControls(ClientPtr client)
                 new.ignore_lock.vmods |= (stuff->affectIgnoreLockVMods &
                                           stuff->ignoreLockVMods);
                 new.ignore_lock.mask = new.ignore_lock.real_mods |
-                                       XkbMaskForVMask(xkbi->desc,
-                                                       new.ignore_lock.vmods);
+                    XkbMaskForVMask(xkbi->desc, new.ignore_lock.vmods);
             }
 
             CHK_MASK_MATCH(0x06, stuff->affectEnabledCtrls,
@@ -841,7 +862,7 @@ ProcXkbSetControls(ClientPtr client)
                 if (stuff->mkDelay < 1 || stuff->mkInterval < 1 ||
                     stuff->mkTimeToMax < 1 || stuff->mkMaxSpeed < 1 ||
                     stuff->mkCurve < -1000) {
-                    client->errorValue = _XkbErrCode2(0x0C,0);
+                    client->errorValue = _XkbErrCode2(0x0C, 0);
                     return BadValue;
                 }
 
@@ -873,7 +894,7 @@ ProcXkbSetControls(ClientPtr client)
                     return BadValue;
                 }
 
-                new.groups_wrap= stuff->groupsWrap;
+                new.groups_wrap = stuff->groupsWrap;
             }
 
             CHK_MASK_LEGAL(0x0F, stuff->axOptions, XkbAX_AllOptionsMask);
@@ -885,7 +906,7 @@ ProcXkbSetControls(ClientPtr client)
                     new.ax_options &= ~(XkbAX_SKOptionsMask);
                     new.ax_options |= (stuff->axOptions & XkbAX_SKOptionsMask);
                 }
-            
+
                 if (stuff->changeCtrls & XkbAccessXFeedbackMask) {
                     new.ax_options &= ~(XkbAX_FBOptionsMask);
                     new.ax_options |= (stuff->axOptions & XkbAX_FBOptionsMask);
@@ -921,8 +942,8 @@ ProcXkbSetControls(ClientPtr client)
                 }
             }
 
-            old= *ctrl;
-            *ctrl= new;
+            old = *ctrl;
+            *ctrl = new;
             XkbDDXChangeControls(tmpd, &old, ctrl);
 
             if (XkbComputeControlsNotify(tmpd, &old, ctrl, &cn, FALSE)) {
@@ -951,704 +972,725 @@ ProcXkbSetControls(ClientPtr client)
 /***====================================================================***/
 
 static int
-XkbSizeKeyTypes(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyTypes(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    XkbKeyTypeRec 	*type;
-    unsigned		i,len;
-
-    len= 0;
-    if (((rep->present&XkbKeyTypesMask)==0)||(rep->nTypes<1)||
-	(!xkb)||(!xkb->map)||(!xkb->map->types)) {
-	rep->present&= ~XkbKeyTypesMask;
-	rep->firstType= rep->nTypes= 0;
-	return 0;
-    }
-    type= &xkb->map->types[rep->firstType];
-    for (i=0;i<rep->nTypes;i++,type++){
-	len+= SIZEOF(xkbKeyTypeWireDesc);
-	if (type->map_count>0) {
-	    len+= (type->map_count*SIZEOF(xkbKTMapEntryWireDesc));
-	    if (type->preserve)
-		len+= (type->map_count*SIZEOF(xkbModsWireDesc));
-	}
+    XkbKeyTypeRec *type;
+    unsigned i, len;
+
+    len = 0;
+    if (((rep->present & XkbKeyTypesMask) == 0) || (rep->nTypes < 1) ||
+        (!xkb) || (!xkb->map) || (!xkb->map->types)) {
+        rep->present &= ~XkbKeyTypesMask;
+        rep->firstType = rep->nTypes = 0;
+        return 0;
+    }
+    type = &xkb->map->types[rep->firstType];
+    for (i = 0; i < rep->nTypes; i++, type++) {
+        len += SIZEOF(xkbKeyTypeWireDesc);
+        if (type->map_count > 0) {
+            len += (type->map_count * SIZEOF(xkbKTMapEntryWireDesc));
+            if (type->preserve)
+                len += (type->map_count * SIZEOF(xkbModsWireDesc));
+        }
     }
     return len;
 }
 
 static char *
-XkbWriteKeyTypes(	XkbDescPtr		xkb,
-			xkbGetMapReply *	rep,
-			char *			buf,
-			ClientPtr 		client)
+XkbWriteKeyTypes(XkbDescPtr xkb,
+                 xkbGetMapReply * rep, char *buf, ClientPtr client)
 {
-    XkbKeyTypePtr	type;
-    unsigned		i;
+    XkbKeyTypePtr type;
+    unsigned i;
     xkbKeyTypeWireDesc *wire;
 
-    type= &xkb->map->types[rep->firstType];
-    for (i=0;i<rep->nTypes;i++,type++) {
-	register unsigned n;
-	wire= (xkbKeyTypeWireDesc *)buf;
-	wire->mask = type->mods.mask;
-	wire->realMods = type->mods.real_mods;
-	wire->virtualMods = type->mods.vmods;
-	wire->numLevels = type->num_levels;
-	wire->nMapEntries = type->map_count;
-	wire->preserve = (type->preserve!=NULL);
-	if (client->swapped) {
-	    swaps(&wire->virtualMods);
-	}	
-
-	buf= (char *)&wire[1];
-	if (wire->nMapEntries>0) {
-	    xkbKTMapEntryWireDesc *	wire;
-	    XkbKTMapEntryPtr		entry;
-	    wire= (xkbKTMapEntryWireDesc *)buf;
-	    entry= type->map;
-	    for (n=0;n<type->map_count;n++,wire++,entry++) {
-		wire->active= entry->active;
-		wire->mask= entry->mods.mask;
-		wire->level= entry->level;
-		wire->realMods= entry->mods.real_mods;
-		wire->virtualMods= entry->mods.vmods;
-		if (client->swapped) {
-		    swaps(&wire->virtualMods);
-		}
-	    }
-	    buf= (char *)wire;
-	    if (type->preserve!=NULL) {
-		xkbModsWireDesc *	pwire;
-		XkbModsPtr		preserve;
-		pwire= (xkbModsWireDesc *)buf;
-		preserve= type->preserve;
-		for (n=0;n<type->map_count;n++,pwire++,preserve++) {
-		    pwire->mask= preserve->mask;
-		    pwire->realMods= preserve->real_mods;
-		    pwire->virtualMods= preserve->vmods;
-		    if (client->swapped) {
-			swaps(&pwire->virtualMods);
-		    }
-		}
-		buf= (char *)pwire;
-	    }
-	}
+    type = &xkb->map->types[rep->firstType];
+    for (i = 0; i < rep->nTypes; i++, type++) {
+        register unsigned n;
+
+        wire = (xkbKeyTypeWireDesc *) buf;
+        wire->mask = type->mods.mask;
+        wire->realMods = type->mods.real_mods;
+        wire->virtualMods = type->mods.vmods;
+        wire->numLevels = type->num_levels;
+        wire->nMapEntries = type->map_count;
+        wire->preserve = (type->preserve != NULL);
+        if (client->swapped) {
+            swaps(&wire->virtualMods);
+        }
+
+        buf = (char *) &wire[1];
+        if (wire->nMapEntries > 0) {
+            xkbKTMapEntryWireDesc *wire;
+            XkbKTMapEntryPtr entry;
+
+            wire = (xkbKTMapEntryWireDesc *) buf;
+            entry = type->map;
+            for (n = 0; n < type->map_count; n++, wire++, entry++) {
+                wire->active = entry->active;
+                wire->mask = entry->mods.mask;
+                wire->level = entry->level;
+                wire->realMods = entry->mods.real_mods;
+                wire->virtualMods = entry->mods.vmods;
+                if (client->swapped) {
+                    swaps(&wire->virtualMods);
+                }
+            }
+            buf = (char *) wire;
+            if (type->preserve != NULL) {
+                xkbModsWireDesc *pwire;
+                XkbModsPtr preserve;
+
+                pwire = (xkbModsWireDesc *) buf;
+                preserve = type->preserve;
+                for (n = 0; n < type->map_count; n++, pwire++, preserve++) {
+                    pwire->mask = preserve->mask;
+                    pwire->realMods = preserve->real_mods;
+                    pwire->virtualMods = preserve->vmods;
+                    if (client->swapped) {
+                        swaps(&pwire->virtualMods);
+                    }
+                }
+                buf = (char *) pwire;
+            }
+        }
     }
     return buf;
 }
 
 static int
-XkbSizeKeySyms(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    XkbSymMapPtr	symMap;
-    unsigned		i,len;
-    unsigned		nSyms,nSymsThisKey;
-
-    if (((rep->present&XkbKeySymsMask)==0)||(rep->nKeySyms<1)||
-	(!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)) {
-	rep->present&= ~XkbKeySymsMask;
-	rep->firstKeySym= rep->nKeySyms= 0;
-	rep->totalSyms= 0;
-	return 0;
-    }
-    len= rep->nKeySyms*SIZEOF(xkbSymMapWireDesc);
+    XkbSymMapPtr symMap;
+    unsigned i, len;
+    unsigned nSyms, nSymsThisKey;
+
+    if (((rep->present & XkbKeySymsMask) == 0) || (rep->nKeySyms < 1) ||
+        (!xkb) || (!xkb->map) || (!xkb->map->key_sym_map)) {
+        rep->present &= ~XkbKeySymsMask;
+        rep->firstKeySym = rep->nKeySyms = 0;
+        rep->totalSyms = 0;
+        return 0;
+    }
+    len = rep->nKeySyms * SIZEOF(xkbSymMapWireDesc);
     symMap = &xkb->map->key_sym_map[rep->firstKeySym];
-    for (i=nSyms=0;i<rep->nKeySyms;i++,symMap++) {
-	if (symMap->offset!=0) {
-	    nSymsThisKey= XkbNumGroups(symMap->group_info)*symMap->width;
-	    nSyms+= nSymsThisKey;
-	}
-    }
-    len+= nSyms*4;
-    rep->totalSyms= nSyms;
+    for (i = nSyms = 0; i < rep->nKeySyms; i++, symMap++) {
+        if (symMap->offset != 0) {
+            nSymsThisKey = XkbNumGroups(symMap->group_info) * symMap->width;
+            nSyms += nSymsThisKey;
+        }
+    }
+    len += nSyms * 4;
+    rep->totalSyms = nSyms;
     return len;
 }
 
 static int
-XkbSizeVirtualMods(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeVirtualMods(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-register unsigned i,nMods,bit;
+    register unsigned i, nMods, bit;
 
-    if (((rep->present&XkbVirtualModsMask)==0)||(rep->virtualMods==0)||
-	(!xkb)||(!xkb->server)) {
-	rep->present&= ~XkbVirtualModsMask;
-	rep->virtualMods= 0;
-	return 0;
+    if (((rep->present & XkbVirtualModsMask) == 0) || (rep->virtualMods == 0) ||
+        (!xkb) || (!xkb->server)) {
+        rep->present &= ~XkbVirtualModsMask;
+        rep->virtualMods = 0;
+        return 0;
     }
-    for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-        if (rep->virtualMods&bit)
-	    nMods++;
+    for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (rep->virtualMods & bit)
+            nMods++;
     }
     return XkbPaddedSize(nMods);
 }
 
 static char *
-XkbWriteKeySyms(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,ClientPtr client)
+XkbWriteKeySyms(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                ClientPtr client)
 {
-register KeySym *	pSym;
-XkbSymMapPtr		symMap;
-xkbSymMapWireDesc *	outMap;
-register unsigned	i;
+    register KeySym *pSym;
+    XkbSymMapPtr symMap;
+    xkbSymMapWireDesc *outMap;
+    register unsigned i;
 
     symMap = &xkb->map->key_sym_map[rep->firstKeySym];
-    for (i=0;i<rep->nKeySyms;i++,symMap++) {
-	outMap = (xkbSymMapWireDesc *)buf;
-	outMap->ktIndex[0] = symMap->kt_index[0];
-	outMap->ktIndex[1] = symMap->kt_index[1];
-	outMap->ktIndex[2] = symMap->kt_index[2];
-	outMap->ktIndex[3] = symMap->kt_index[3];
-	outMap->groupInfo = symMap->group_info;
-	outMap->width= symMap->width;
-	outMap->nSyms = symMap->width*XkbNumGroups(symMap->group_info);
-	buf= (char *)&outMap[1];
-	if (outMap->nSyms==0)
-	    continue;
-
-	pSym = &xkb->map->syms[symMap->offset];
-	memcpy((char *)buf,(char *)pSym,outMap->nSyms*4);
-	if (client->swapped) {
-	    register int nSyms= outMap->nSyms;
-	    swaps(&outMap->nSyms);
-	    while (nSyms-->0) {
-		swapl((int *)buf);
-		buf+= 4;
-	    }
-	}
-	else buf+= outMap->nSyms*4;
+    for (i = 0; i < rep->nKeySyms; i++, symMap++) {
+        outMap = (xkbSymMapWireDesc *) buf;
+        outMap->ktIndex[0] = symMap->kt_index[0];
+        outMap->ktIndex[1] = symMap->kt_index[1];
+        outMap->ktIndex[2] = symMap->kt_index[2];
+        outMap->ktIndex[3] = symMap->kt_index[3];
+        outMap->groupInfo = symMap->group_info;
+        outMap->width = symMap->width;
+        outMap->nSyms = symMap->width * XkbNumGroups(symMap->group_info);
+        buf = (char *) &outMap[1];
+        if (outMap->nSyms == 0)
+            continue;
+
+        pSym = &xkb->map->syms[symMap->offset];
+        memcpy((char *) buf, (char *) pSym, outMap->nSyms * 4);
+        if (client->swapped) {
+            register int nSyms = outMap->nSyms;
+
+            swaps(&outMap->nSyms);
+            while (nSyms-- > 0) {
+                swapl((int *) buf);
+                buf += 4;
+            }
+        }
+        else
+            buf += outMap->nSyms * 4;
     }
     return buf;
 }
 
 static int
-XkbSizeKeyActions(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    unsigned		i,len,nActs;
-    register KeyCode	firstKey;
-
-    if (((rep->present&XkbKeyActionsMask)==0)||(rep->nKeyActs<1)||
-	(!xkb)||(!xkb->server)||(!xkb->server->key_acts)) {
-	rep->present&= ~XkbKeyActionsMask;
-	rep->firstKeyAct= rep->nKeyActs= 0;
-	rep->totalActs= 0;
-	return 0;
-    }
-    firstKey= rep->firstKeyAct;
-    for (nActs=i=0;i<rep->nKeyActs;i++) {
-	if (xkb->server->key_acts[i+firstKey]!=0)
-	    nActs+= XkbKeyNumActions(xkb,i+firstKey);
-    }
-    len= XkbPaddedSize(rep->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
-    rep->totalActs= nActs;
+    unsigned i, len, nActs;
+    register KeyCode firstKey;
+
+    if (((rep->present & XkbKeyActionsMask) == 0) || (rep->nKeyActs < 1) ||
+        (!xkb) || (!xkb->server) || (!xkb->server->key_acts)) {
+        rep->present &= ~XkbKeyActionsMask;
+        rep->firstKeyAct = rep->nKeyActs = 0;
+        rep->totalActs = 0;
+        return 0;
+    }
+    firstKey = rep->firstKeyAct;
+    for (nActs = i = 0; i < rep->nKeyActs; i++) {
+        if (xkb->server->key_acts[i + firstKey] != 0)
+            nActs += XkbKeyNumActions(xkb, i + firstKey);
+    }
+    len = XkbPaddedSize(rep->nKeyActs) + (nActs * SIZEOF(xkbActionWireDesc));
+    rep->totalActs = nActs;
     return len;
 }
 
 static char *
-XkbWriteKeyActions(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
-							ClientPtr client)
+XkbWriteKeyActions(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                   ClientPtr client)
 {
-    unsigned		i;
-    CARD8 *		numDesc;
-    XkbAnyAction *	actDesc;
-
-    numDesc = (CARD8 *)buf;
-    for (i=0;i<rep->nKeyActs;i++) {
-	if (xkb->server->key_acts[i+rep->firstKeyAct]==0)
-	     numDesc[i] = 0;
-	else numDesc[i] = XkbKeyNumActions(xkb,(i+rep->firstKeyAct));
-    }
-    buf+= XkbPaddedSize(rep->nKeyActs);
-
-    actDesc = (XkbAnyAction *)buf;
-    for (i=0;i<rep->nKeyActs;i++) {
-	if (xkb->server->key_acts[i+rep->firstKeyAct]!=0) {
-	    unsigned int num;
-	    num = XkbKeyNumActions(xkb,(i+rep->firstKeyAct));
-	    memcpy((char *)actDesc,
-		   (char*)XkbKeyActionsPtr(xkb,(i+rep->firstKeyAct)),
-		   num*SIZEOF(xkbActionWireDesc));
-	    actDesc+= num;
-	}
-    }
-    buf = (char *)actDesc;
+    unsigned i;
+    CARD8 *numDesc;
+    XkbAnyAction *actDesc;
+
+    numDesc = (CARD8 *) buf;
+    for (i = 0; i < rep->nKeyActs; i++) {
+        if (xkb->server->key_acts[i + rep->firstKeyAct] == 0)
+            numDesc[i] = 0;
+        else
+            numDesc[i] = XkbKeyNumActions(xkb, (i + rep->firstKeyAct));
+    }
+    buf += XkbPaddedSize(rep->nKeyActs);
+
+    actDesc = (XkbAnyAction *) buf;
+    for (i = 0; i < rep->nKeyActs; i++) {
+        if (xkb->server->key_acts[i + rep->firstKeyAct] != 0) {
+            unsigned int num;
+
+            num = XkbKeyNumActions(xkb, (i + rep->firstKeyAct));
+            memcpy((char *) actDesc,
+                   (char *) XkbKeyActionsPtr(xkb, (i + rep->firstKeyAct)),
+                   num * SIZEOF(xkbActionWireDesc));
+            actDesc += num;
+        }
+    }
+    buf = (char *) actDesc;
     return buf;
 }
 
 static int
-XkbSizeKeyBehaviors(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    unsigned		i,len,nBhvr;
-    XkbBehavior *	bhv;
-
-    if (((rep->present&XkbKeyBehaviorsMask)==0)||(rep->nKeyBehaviors<1)||
-	(!xkb)||(!xkb->server)||(!xkb->server->behaviors)) {
-	rep->present&= ~XkbKeyBehaviorsMask;
-	rep->firstKeyBehavior= rep->nKeyBehaviors= 0;
-	rep->totalKeyBehaviors= 0;
-	return 0;
-    }
-    bhv= &xkb->server->behaviors[rep->firstKeyBehavior];
-    for (nBhvr=i=0;i<rep->nKeyBehaviors;i++,bhv++) {
-	if (bhv->type!=XkbKB_Default)
-	    nBhvr++;
-    }
-    len= nBhvr*SIZEOF(xkbBehaviorWireDesc);
-    rep->totalKeyBehaviors= nBhvr;
+    unsigned i, len, nBhvr;
+    XkbBehavior *bhv;
+
+    if (((rep->present & XkbKeyBehaviorsMask) == 0) || (rep->nKeyBehaviors < 1)
+        || (!xkb) || (!xkb->server) || (!xkb->server->behaviors)) {
+        rep->present &= ~XkbKeyBehaviorsMask;
+        rep->firstKeyBehavior = rep->nKeyBehaviors = 0;
+        rep->totalKeyBehaviors = 0;
+        return 0;
+    }
+    bhv = &xkb->server->behaviors[rep->firstKeyBehavior];
+    for (nBhvr = i = 0; i < rep->nKeyBehaviors; i++, bhv++) {
+        if (bhv->type != XkbKB_Default)
+            nBhvr++;
+    }
+    len = nBhvr * SIZEOF(xkbBehaviorWireDesc);
+    rep->totalKeyBehaviors = nBhvr;
     return len;
 }
 
 static char *
-XkbWriteKeyBehaviors(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
-							ClientPtr client)
+XkbWriteKeyBehaviors(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                     ClientPtr client)
 {
-    unsigned		i;
-    xkbBehaviorWireDesc	*wire;
-    XkbBehavior		*pBhvr;
-
-    wire = (xkbBehaviorWireDesc *)buf;
-    pBhvr= &xkb->server->behaviors[rep->firstKeyBehavior];
-    for (i=0;i<rep->nKeyBehaviors;i++,pBhvr++) {
-	if (pBhvr->type!=XkbKB_Default) {
-	    wire->key=  i+rep->firstKeyBehavior;
-	    wire->type= pBhvr->type;
-	    wire->data= pBhvr->data;
-	    wire++;
-	}
-    }
-    buf = (char *)wire;
+    unsigned i;
+    xkbBehaviorWireDesc *wire;
+    XkbBehavior *pBhvr;
+
+    wire = (xkbBehaviorWireDesc *) buf;
+    pBhvr = &xkb->server->behaviors[rep->firstKeyBehavior];
+    for (i = 0; i < rep->nKeyBehaviors; i++, pBhvr++) {
+        if (pBhvr->type != XkbKB_Default) {
+            wire->key = i + rep->firstKeyBehavior;
+            wire->type = pBhvr->type;
+            wire->data = pBhvr->data;
+            wire++;
+        }
+    }
+    buf = (char *) wire;
     return buf;
 }
 
 static int
-XkbSizeExplicit(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeExplicit(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    unsigned	i,len,nRtrn;
-
-    if (((rep->present&XkbExplicitComponentsMask)==0)||(rep->nKeyExplicit<1)||
-	(!xkb)||(!xkb->server)||(!xkb->server->explicit)) {
-	rep->present&= ~XkbExplicitComponentsMask;
-	rep->firstKeyExplicit= rep->nKeyExplicit= 0;
-	rep->totalKeyExplicit= 0;
-	return 0;
-    }
-    for (nRtrn=i=0;i<rep->nKeyExplicit;i++) {
-	if (xkb->server->explicit[i+rep->firstKeyExplicit]!=0)
-	    nRtrn++;
-    }
-    rep->totalKeyExplicit= nRtrn;
-    len= XkbPaddedSize(nRtrn*2); /* two bytes per non-zero explicit component */
+    unsigned i, len, nRtrn;
+
+    if (((rep->present & XkbExplicitComponentsMask) == 0) ||
+        (rep->nKeyExplicit < 1) || (!xkb) || (!xkb->server) ||
+        (!xkb->server->explicit)) {
+        rep->present &= ~XkbExplicitComponentsMask;
+        rep->firstKeyExplicit = rep->nKeyExplicit = 0;
+        rep->totalKeyExplicit = 0;
+        return 0;
+    }
+    for (nRtrn = i = 0; i < rep->nKeyExplicit; i++) {
+        if (xkb->server->explicit[i + rep->firstKeyExplicit] != 0)
+            nRtrn++;
+    }
+    rep->totalKeyExplicit = nRtrn;
+    len = XkbPaddedSize(nRtrn * 2);     /* two bytes per non-zero explicit component */
     return len;
 }
 
 static char *
-XkbWriteExplicit(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,ClientPtr client)
+XkbWriteExplicit(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                 ClientPtr client)
 {
-unsigned	i;
-char *		start;
-unsigned char *	pExp;
-
-    start= buf;
-    pExp= &xkb->server->explicit[rep->firstKeyExplicit];
-    for (i=0;i<rep->nKeyExplicit;i++,pExp++) {
-	if (*pExp!=0) {
-	    *buf++= i+rep->firstKeyExplicit;
-	    *buf++= *pExp;
-	}
-    }
-    i= XkbPaddedSize(buf-start)-(buf-start); /* pad to word boundary */
-    return buf+i;
+    unsigned i;
+    char *start;
+    unsigned char *pExp;
+
+    start = buf;
+    pExp = &xkb->server->explicit[rep->firstKeyExplicit];
+    for (i = 0; i < rep->nKeyExplicit; i++, pExp++) {
+        if (*pExp != 0) {
+            *buf++ = i + rep->firstKeyExplicit;
+            *buf++ = *pExp;
+        }
+    }
+    i = XkbPaddedSize(buf - start) - (buf - start);     /* pad to word boundary */
+    return buf + i;
 }
 
 static int
-XkbSizeModifierMap(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    unsigned	i,len,nRtrn;
+    unsigned i, len, nRtrn;
 
-    if (((rep->present&XkbModifierMapMask)==0)||(rep->nModMapKeys<1)||
-	(!xkb)||(!xkb->map)||(!xkb->map->modmap)) {
-	rep->present&= ~XkbModifierMapMask;
-	rep->firstModMapKey= rep->nModMapKeys= 0;
-	rep->totalModMapKeys= 0;
-	return 0;
+    if (((rep->present & XkbModifierMapMask) == 0) || (rep->nModMapKeys < 1) ||
+        (!xkb) || (!xkb->map) || (!xkb->map->modmap)) {
+        rep->present &= ~XkbModifierMapMask;
+        rep->firstModMapKey = rep->nModMapKeys = 0;
+        rep->totalModMapKeys = 0;
+        return 0;
     }
-    for (nRtrn=i=0;i<rep->nModMapKeys;i++) {
-	if (xkb->map->modmap[i+rep->firstModMapKey]!=0)
-	    nRtrn++;
+    for (nRtrn = i = 0; i < rep->nModMapKeys; i++) {
+        if (xkb->map->modmap[i + rep->firstModMapKey] != 0)
+            nRtrn++;
     }
-    rep->totalModMapKeys= nRtrn;
-    len= XkbPaddedSize(nRtrn*2); /* two bytes per non-zero modmap component */
+    rep->totalModMapKeys = nRtrn;
+    len = XkbPaddedSize(nRtrn * 2);     /* two bytes per non-zero modmap component */
     return len;
 }
 
 static char *
-XkbWriteModifierMap(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
-							ClientPtr client)
+XkbWriteModifierMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                    ClientPtr client)
 {
-unsigned	i;
-char *		start;
-unsigned char *	pMap;
-
-    start= buf;
-    pMap= &xkb->map->modmap[rep->firstModMapKey];
-    for (i=0;i<rep->nModMapKeys;i++,pMap++) {
-	if (*pMap!=0) {
-	    *buf++= i+rep->firstModMapKey;
-	    *buf++= *pMap;
-	}
-    }
-    i= XkbPaddedSize(buf-start)-(buf-start); /* pad to word boundary */
-    return buf+i;
+    unsigned i;
+    char *start;
+    unsigned char *pMap;
+
+    start = buf;
+    pMap = &xkb->map->modmap[rep->firstModMapKey];
+    for (i = 0; i < rep->nModMapKeys; i++, pMap++) {
+        if (*pMap != 0) {
+            *buf++ = i + rep->firstModMapKey;
+            *buf++ = *pMap;
+        }
+    }
+    i = XkbPaddedSize(buf - start) - (buf - start);     /* pad to word boundary */
+    return buf + i;
 }
 
 static int
-XkbSizeVirtualModMap(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSizeVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-    unsigned	i,len,nRtrn;
+    unsigned i, len, nRtrn;
 
-    if (((rep->present&XkbVirtualModMapMask)==0)||(rep->nVModMapKeys<1)||
-	(!xkb)||(!xkb->server)||(!xkb->server->vmodmap)) {
-	rep->present&= ~XkbVirtualModMapMask;
-	rep->firstVModMapKey= rep->nVModMapKeys= 0;
-	rep->totalVModMapKeys= 0;
-	return 0;
+    if (((rep->present & XkbVirtualModMapMask) == 0) || (rep->nVModMapKeys < 1)
+        || (!xkb) || (!xkb->server) || (!xkb->server->vmodmap)) {
+        rep->present &= ~XkbVirtualModMapMask;
+        rep->firstVModMapKey = rep->nVModMapKeys = 0;
+        rep->totalVModMapKeys = 0;
+        return 0;
     }
-    for (nRtrn=i=0;i<rep->nVModMapKeys;i++) {
-	if (xkb->server->vmodmap[i+rep->firstVModMapKey]!=0)
-	    nRtrn++;
+    for (nRtrn = i = 0; i < rep->nVModMapKeys; i++) {
+        if (xkb->server->vmodmap[i + rep->firstVModMapKey] != 0)
+            nRtrn++;
     }
-    rep->totalVModMapKeys= nRtrn;
-    len= nRtrn*SIZEOF(xkbVModMapWireDesc);
+    rep->totalVModMapKeys = nRtrn;
+    len = nRtrn * SIZEOF(xkbVModMapWireDesc);
     return len;
 }
 
 static char *
-XkbWriteVirtualModMap(XkbDescPtr xkb,xkbGetMapReply *rep,char *buf,
-							ClientPtr client)
+XkbWriteVirtualModMap(XkbDescPtr xkb, xkbGetMapReply * rep, char *buf,
+                      ClientPtr client)
 {
-unsigned		i;
-xkbVModMapWireDesc *	wire;
-unsigned short *	pMap;
-
-    wire= (xkbVModMapWireDesc *)buf;
-    pMap= &xkb->server->vmodmap[rep->firstVModMapKey];
-    for (i=0;i<rep->nVModMapKeys;i++,pMap++) {
-	if (*pMap!=0) {
-	    wire->key= i+rep->firstVModMapKey;
-	    wire->vmods= *pMap;
-	    wire++;
-	}
-    }
-    return (char *)wire;
+    unsigned i;
+    xkbVModMapWireDesc *wire;
+    unsigned short *pMap;
+
+    wire = (xkbVModMapWireDesc *) buf;
+    pMap = &xkb->server->vmodmap[rep->firstVModMapKey];
+    for (i = 0; i < rep->nVModMapKeys; i++, pMap++) {
+        if (*pMap != 0) {
+            wire->key = i + rep->firstVModMapKey;
+            wire->vmods = *pMap;
+            wire++;
+        }
+    }
+    return (char *) wire;
 }
 
 static Status
-XkbComputeGetMapReplySize(XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbComputeGetMapReplySize(XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-int	len;
-
-    rep->minKeyCode= xkb->min_key_code;
-    rep->maxKeyCode= xkb->max_key_code;
-    len= XkbSizeKeyTypes(xkb,rep);
-    len+= XkbSizeKeySyms(xkb,rep);
-    len+= XkbSizeKeyActions(xkb,rep);
-    len+= XkbSizeKeyBehaviors(xkb,rep);
-    len+= XkbSizeVirtualMods(xkb,rep);
-    len+= XkbSizeExplicit(xkb,rep);
-    len+= XkbSizeModifierMap(xkb,rep);
-    len+= XkbSizeVirtualModMap(xkb,rep);
-    rep->length+= (len/4);
+    int len;
+
+    rep->minKeyCode = xkb->min_key_code;
+    rep->maxKeyCode = xkb->max_key_code;
+    len = XkbSizeKeyTypes(xkb, rep);
+    len += XkbSizeKeySyms(xkb, rep);
+    len += XkbSizeKeyActions(xkb, rep);
+    len += XkbSizeKeyBehaviors(xkb, rep);
+    len += XkbSizeVirtualMods(xkb, rep);
+    len += XkbSizeExplicit(xkb, rep);
+    len += XkbSizeModifierMap(xkb, rep);
+    len += XkbSizeVirtualModMap(xkb, rep);
+    rep->length += (len / 4);
     return Success;
 }
 
 static int
-XkbSendMap(ClientPtr client,XkbDescPtr xkb,xkbGetMapReply *rep)
+XkbSendMap(ClientPtr client, XkbDescPtr xkb, xkbGetMapReply * rep)
 {
-unsigned	i,len;
-char		*desc,*start;
+    unsigned i, len;
+    char *desc, *start;
 
-    len= (rep->length*4)-(SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply));
-    start= desc= calloc(1, len);
+    len = (rep->length * 4) - (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply));
+    start = desc = calloc(1, len);
     if (!start)
-	return BadAlloc;
-    if ( rep->nTypes>0 )
-	desc = XkbWriteKeyTypes(xkb,rep,desc,client);
-    if ( rep->nKeySyms>0 )
-	desc = XkbWriteKeySyms(xkb,rep,desc,client);
-    if ( rep->nKeyActs>0 )
-	desc = XkbWriteKeyActions(xkb,rep,desc,client);
-    if ( rep->totalKeyBehaviors>0 )
-	desc = XkbWriteKeyBehaviors(xkb,rep,desc,client);
-    if ( rep->virtualMods ) {
-	register int sz,bit;
-	for (i=sz=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	    if (rep->virtualMods&bit) {
-		desc[sz++]= xkb->server->vmods[i];
-	    }
-	}
-	desc+= XkbPaddedSize(sz);
-    }
-    if ( rep->totalKeyExplicit>0 )
-	desc= XkbWriteExplicit(xkb,rep,desc,client);
-    if ( rep->totalModMapKeys>0 )
-	desc= XkbWriteModifierMap(xkb,rep,desc,client);
-    if ( rep->totalVModMapKeys>0 )
-	desc= XkbWriteVirtualModMap(xkb,rep,desc,client);
-    if ((desc-start)!=(len)) {
-	ErrorF("[xkb] BOGUS LENGTH in write keyboard desc, expected %d, got %ld\n",
-					len, (unsigned long)(desc-start));
+        return BadAlloc;
+    if (rep->nTypes > 0)
+        desc = XkbWriteKeyTypes(xkb, rep, desc, client);
+    if (rep->nKeySyms > 0)
+        desc = XkbWriteKeySyms(xkb, rep, desc, client);
+    if (rep->nKeyActs > 0)
+        desc = XkbWriteKeyActions(xkb, rep, desc, client);
+    if (rep->totalKeyBehaviors > 0)
+        desc = XkbWriteKeyBehaviors(xkb, rep, desc, client);
+    if (rep->virtualMods) {
+        register int sz, bit;
+
+        for (i = sz = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+            if (rep->virtualMods & bit) {
+                desc[sz++] = xkb->server->vmods[i];
+            }
+        }
+        desc += XkbPaddedSize(sz);
+    }
+    if (rep->totalKeyExplicit > 0)
+        desc = XkbWriteExplicit(xkb, rep, desc, client);
+    if (rep->totalModMapKeys > 0)
+        desc = XkbWriteModifierMap(xkb, rep, desc, client);
+    if (rep->totalVModMapKeys > 0)
+        desc = XkbWriteVirtualModMap(xkb, rep, desc, client);
+    if ((desc - start) != (len)) {
+        ErrorF
+            ("[xkb] BOGUS LENGTH in write keyboard desc, expected %d, got %ld\n",
+             len, (unsigned long) (desc - start));
     }
     if (client->swapped) {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swaps(&rep->present);
-	swaps(&rep->totalSyms);
-	swaps(&rep->totalActs);
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swaps(&rep->present);
+        swaps(&rep->totalSyms);
+        swaps(&rep->totalActs);
     }
-    WriteToClient(client, (i=SIZEOF(xkbGetMapReply)), (char *)rep);
+    WriteToClient(client, (i = SIZEOF(xkbGetMapReply)), (char *) rep);
     WriteToClient(client, len, start);
-    free((char *)start);
+    free((char *) start);
     return Success;
 }
 
 int
 ProcXkbGetMap(ClientPtr client)
 {
-    DeviceIntPtr	 dev;
-    xkbGetMapReply	 rep;
-    XkbDescRec		*xkb;
-    int			 n,status;
+    DeviceIntPtr dev;
+    xkbGetMapReply rep;
+    XkbDescRec *xkb;
+    int n, status;
 
     REQUEST(xkbGetMapReq);
     REQUEST_SIZE_MATCH(xkbGetMapReq);
-    
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
-    CHK_MASK_OVERLAP(0x01,stuff->full,stuff->partial);
-    CHK_MASK_LEGAL(0x02,stuff->full,XkbAllMapComponentsMask);
-    CHK_MASK_LEGAL(0x03,stuff->partial,XkbAllMapComponentsMask);
+    CHK_MASK_OVERLAP(0x01, stuff->full, stuff->partial);
+    CHK_MASK_LEGAL(0x02, stuff->full, XkbAllMapComponentsMask);
+    CHK_MASK_LEGAL(0x03, stuff->partial, XkbAllMapComponentsMask);
 
-    xkb= dev->key->xkbInfo->desc;
+    xkb = dev->key->xkbInfo->desc;
     memset(&rep, 0, sizeof(xkbGetMapReply));
-    rep.type= X_Reply;
-    rep.sequenceNumber= client->sequence;
-    rep.length = (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply))>>2;
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
+    rep.length = (SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2;
     rep.deviceID = dev->id;
-    rep.present = stuff->partial|stuff->full;
+    rep.present = stuff->partial | stuff->full;
     rep.minKeyCode = xkb->min_key_code;
     rep.maxKeyCode = xkb->max_key_code;
-    if ( stuff->full&XkbKeyTypesMask ) {
-	rep.firstType = 0;
-	rep.nTypes = xkb->map->num_types;
-    }
-    else if (stuff->partial&XkbKeyTypesMask) {
-	if (((unsigned)stuff->firstType+stuff->nTypes)>xkb->map->num_types) {
-	    client->errorValue = _XkbErrCode4(0x04,xkb->map->num_types,
-					stuff->firstType,stuff->nTypes);
-	    return BadValue;
-	}
-	rep.firstType = stuff->firstType;
-	rep.nTypes = stuff->nTypes;
-    }
-    else rep.nTypes = 0;
-    rep.totalTypes = xkb->map->num_types;
-
-    n= XkbNumKeys(xkb);
-    if ( stuff->full&XkbKeySymsMask ) {
-	rep.firstKeySym = xkb->min_key_code;
-	rep.nKeySyms = n;
-    }
-    else if (stuff->partial&XkbKeySymsMask) {
-	CHK_KEY_RANGE(0x05,stuff->firstKeySym,stuff->nKeySyms,xkb);
-	rep.firstKeySym = stuff->firstKeySym;
-	rep.nKeySyms = stuff->nKeySyms;
+    if (stuff->full & XkbKeyTypesMask) {
+        rep.firstType = 0;
+        rep.nTypes = xkb->map->num_types;
+    }
+    else if (stuff->partial & XkbKeyTypesMask) {
+        if (((unsigned) stuff->firstType + stuff->nTypes) > xkb->map->num_types) {
+            client->errorValue = _XkbErrCode4(0x04, xkb->map->num_types,
+                                              stuff->firstType, stuff->nTypes);
+            return BadValue;
+        }
+        rep.firstType = stuff->firstType;
+        rep.nTypes = stuff->nTypes;
     }
-    else rep.nKeySyms = 0;
-    rep.totalSyms= 0;
+    else
+        rep.nTypes = 0;
+    rep.totalTypes = xkb->map->num_types;
 
-    if ( stuff->full&XkbKeyActionsMask ) {
-	rep.firstKeyAct= xkb->min_key_code;
-	rep.nKeyActs= n;
-    }
-    else if (stuff->partial&XkbKeyActionsMask) {
-	CHK_KEY_RANGE(0x07,stuff->firstKeyAct,stuff->nKeyActs,xkb);
-	rep.firstKeyAct= stuff->firstKeyAct;
-	rep.nKeyActs= stuff->nKeyActs;
-    }
-    else rep.nKeyActs= 0;
-    rep.totalActs= 0;
+    n = XkbNumKeys(xkb);
+    if (stuff->full & XkbKeySymsMask) {
+        rep.firstKeySym = xkb->min_key_code;
+        rep.nKeySyms = n;
+    }
+    else if (stuff->partial & XkbKeySymsMask) {
+        CHK_KEY_RANGE(0x05, stuff->firstKeySym, stuff->nKeySyms, xkb);
+        rep.firstKeySym = stuff->firstKeySym;
+        rep.nKeySyms = stuff->nKeySyms;
+    }
+    else
+        rep.nKeySyms = 0;
+    rep.totalSyms = 0;
+
+    if (stuff->full & XkbKeyActionsMask) {
+        rep.firstKeyAct = xkb->min_key_code;
+        rep.nKeyActs = n;
+    }
+    else if (stuff->partial & XkbKeyActionsMask) {
+        CHK_KEY_RANGE(0x07, stuff->firstKeyAct, stuff->nKeyActs, xkb);
+        rep.firstKeyAct = stuff->firstKeyAct;
+        rep.nKeyActs = stuff->nKeyActs;
+    }
+    else
+        rep.nKeyActs = 0;
+    rep.totalActs = 0;
+
+    if (stuff->full & XkbKeyBehaviorsMask) {
+        rep.firstKeyBehavior = xkb->min_key_code;
+        rep.nKeyBehaviors = n;
+    }
+    else if (stuff->partial & XkbKeyBehaviorsMask) {
+        CHK_KEY_RANGE(0x09, stuff->firstKeyBehavior, stuff->nKeyBehaviors, xkb);
+        rep.firstKeyBehavior = stuff->firstKeyBehavior;
+        rep.nKeyBehaviors = stuff->nKeyBehaviors;
+    }
+    else
+        rep.nKeyBehaviors = 0;
+    rep.totalKeyBehaviors = 0;
+
+    if (stuff->full & XkbVirtualModsMask)
+        rep.virtualMods = ~0;
+    else if (stuff->partial & XkbVirtualModsMask)
+        rep.virtualMods = stuff->virtualMods;
+
+    if (stuff->full & XkbExplicitComponentsMask) {
+        rep.firstKeyExplicit = xkb->min_key_code;
+        rep.nKeyExplicit = n;
+    }
+    else if (stuff->partial & XkbExplicitComponentsMask) {
+        CHK_KEY_RANGE(0x0B, stuff->firstKeyExplicit, stuff->nKeyExplicit, xkb);
+        rep.firstKeyExplicit = stuff->firstKeyExplicit;
+        rep.nKeyExplicit = stuff->nKeyExplicit;
+    }
+    else
+        rep.nKeyExplicit = 0;
+    rep.totalKeyExplicit = 0;
+
+    if (stuff->full & XkbModifierMapMask) {
+        rep.firstModMapKey = xkb->min_key_code;
+        rep.nModMapKeys = n;
+    }
+    else if (stuff->partial & XkbModifierMapMask) {
+        CHK_KEY_RANGE(0x0D, stuff->firstModMapKey, stuff->nModMapKeys, xkb);
+        rep.firstModMapKey = stuff->firstModMapKey;
+        rep.nModMapKeys = stuff->nModMapKeys;
+    }
+    else
+        rep.nModMapKeys = 0;
+    rep.totalModMapKeys = 0;
+
+    if (stuff->full & XkbVirtualModMapMask) {
+        rep.firstVModMapKey = xkb->min_key_code;
+        rep.nVModMapKeys = n;
+    }
+    else if (stuff->partial & XkbVirtualModMapMask) {
+        CHK_KEY_RANGE(0x0F, stuff->firstVModMapKey, stuff->nVModMapKeys, xkb);
+        rep.firstVModMapKey = stuff->firstVModMapKey;
+        rep.nVModMapKeys = stuff->nVModMapKeys;
+    }
+    else
+        rep.nVModMapKeys = 0;
+    rep.totalVModMapKeys = 0;
+
+    if ((status = XkbComputeGetMapReplySize(xkb, &rep)) != Success)
+        return status;
+    return XkbSendMap(client, xkb, &rep);
+}
 
-    if ( stuff->full&XkbKeyBehaviorsMask ) {
-	rep.firstKeyBehavior = xkb->min_key_code;
-	rep.nKeyBehaviors = n;
-    }
-    else if (stuff->partial&XkbKeyBehaviorsMask) {
-	CHK_KEY_RANGE(0x09,stuff->firstKeyBehavior,stuff->nKeyBehaviors,xkb);
-	rep.firstKeyBehavior= stuff->firstKeyBehavior;
-	rep.nKeyBehaviors= stuff->nKeyBehaviors;
-    }
-    else rep.nKeyBehaviors = 0;
-    rep.totalKeyBehaviors= 0;
+/***====================================================================***/
 
-    if (stuff->full&XkbVirtualModsMask)
-	rep.virtualMods= ~0;
-    else if (stuff->partial&XkbVirtualModsMask)
-	rep.virtualMods= stuff->virtualMods;
-    
-    if (stuff->full&XkbExplicitComponentsMask) {
-	rep.firstKeyExplicit= xkb->min_key_code;
-	rep.nKeyExplicit= n;
-    }
-    else if (stuff->partial&XkbExplicitComponentsMask) {
-	CHK_KEY_RANGE(0x0B,stuff->firstKeyExplicit,stuff->nKeyExplicit,xkb);
-	rep.firstKeyExplicit= stuff->firstKeyExplicit;
-	rep.nKeyExplicit= stuff->nKeyExplicit;
+static int
+CheckKeyTypes(ClientPtr client,
+              XkbDescPtr xkb,
+              xkbSetMapReq * req,
+              xkbKeyTypeWireDesc ** wireRtrn,
+              int *nMapsRtrn, CARD8 *mapWidthRtrn)
+{
+    unsigned nMaps;
+    register unsigned i, n;
+    register CARD8 *map;
+    register xkbKeyTypeWireDesc *wire = *wireRtrn;
+
+    if (req->firstType > ((unsigned) xkb->map->num_types)) {
+        *nMapsRtrn = _XkbErrCode3(0x01, req->firstType, xkb->map->num_types);
+        return 0;
+    }
+    if (req->flags & XkbSetMapResizeTypes) {
+        nMaps = req->firstType + req->nTypes;
+        if (nMaps < XkbNumRequiredTypes) {      /* canonical types must be there */
+            *nMapsRtrn = _XkbErrCode4(0x02, req->firstType, req->nTypes, 4);
+            return 0;
+        }
     }
-    else rep.nKeyExplicit = 0;
-    rep.totalKeyExplicit=  0;
-
-    if (stuff->full&XkbModifierMapMask) {
-	rep.firstModMapKey= xkb->min_key_code;
-	rep.nModMapKeys= n;
+    else if (req->present & XkbKeyTypesMask) {
+        nMaps = xkb->map->num_types;
+        if ((req->firstType + req->nTypes) > nMaps) {
+            *nMapsRtrn = req->firstType + req->nTypes;
+            return 0;
+        }
     }
-    else if (stuff->partial&XkbModifierMapMask) {
-	CHK_KEY_RANGE(0x0D,stuff->firstModMapKey,stuff->nModMapKeys,xkb);
-	rep.firstModMapKey= stuff->firstModMapKey;
-	rep.nModMapKeys= stuff->nModMapKeys;
+    else {
+        *nMapsRtrn = xkb->map->num_types;
+        for (i = 0; i < xkb->map->num_types; i++) {
+            mapWidthRtrn[i] = xkb->map->types[i].num_levels;
+        }
+        return 1;
     }
-    else rep.nModMapKeys = 0;
-    rep.totalModMapKeys= 0;
 
-    if (stuff->full&XkbVirtualModMapMask) {
-	rep.firstVModMapKey= xkb->min_key_code;
-	rep.nVModMapKeys= n;
-    }
-    else if (stuff->partial&XkbVirtualModMapMask) {
-	CHK_KEY_RANGE(0x0F,stuff->firstVModMapKey,stuff->nVModMapKeys,xkb);
-	rep.firstVModMapKey= stuff->firstVModMapKey;
-	rep.nVModMapKeys= stuff->nVModMapKeys;
+    for (i = 0; i < req->firstType; i++) {
+        mapWidthRtrn[i] = xkb->map->types[i].num_levels;
     }
-    else rep.nVModMapKeys = 0;
-    rep.totalVModMapKeys= 0;
+    for (i = 0; i < req->nTypes; i++) {
+        unsigned width;
 
-    if ((status=XkbComputeGetMapReplySize(xkb,&rep))!=Success)
-	return status;
-    return XkbSendMap(client,xkb,&rep);
-}
-
-/***====================================================================***/
+        if (client->swapped) {
+            swaps(&wire->virtualMods);
+        }
+        n = i + req->firstType;
+        width = wire->numLevels;
+        if (width < 1) {
+            *nMapsRtrn = _XkbErrCode3(0x04, n, width);
+            return 0;
+        }
+        else if ((n == XkbOneLevelIndex) && (width != 1)) {     /* must be width 1 */
+            *nMapsRtrn = _XkbErrCode3(0x05, n, width);
+            return 0;
+        }
+        else if ((width != 2) &&
+                 ((n == XkbTwoLevelIndex) || (n == XkbKeypadIndex) ||
+                  (n == XkbAlphabeticIndex))) {
+            /* TWO_LEVEL, ALPHABETIC and KEYPAD must be width 2 */
+            *nMapsRtrn = _XkbErrCode3(0x05, n, width);
+            return 0;
+        }
+        if (wire->nMapEntries > 0) {
+            xkbKTSetMapEntryWireDesc *mapWire;
+            xkbModsWireDesc *preWire;
 
-static int
-CheckKeyTypes(	ClientPtr	client,
-		XkbDescPtr	xkb,
-		xkbSetMapReq *	req,
-		xkbKeyTypeWireDesc **wireRtrn,
-		int	 *	nMapsRtrn,
-		CARD8 *		mapWidthRtrn)
-{
-unsigned		nMaps;
-register unsigned	i,n;
-register CARD8 *	map;
-register xkbKeyTypeWireDesc	*wire = *wireRtrn;
-
-    if (req->firstType>((unsigned)xkb->map->num_types)) {
-	*nMapsRtrn = _XkbErrCode3(0x01,req->firstType,xkb->map->num_types);
-	return 0;
-    }
-    if (req->flags&XkbSetMapResizeTypes) {
-	nMaps = req->firstType+req->nTypes;
-	if (nMaps<XkbNumRequiredTypes) {  /* canonical types must be there */
-	    *nMapsRtrn= _XkbErrCode4(0x02,req->firstType,req->nTypes,4);
-	    return 0;
-	}
-    }
-    else if (req->present&XkbKeyTypesMask) {
-	nMaps = xkb->map->num_types;
-	if ((req->firstType+req->nTypes)>nMaps) {
-	    *nMapsRtrn = req->firstType+req->nTypes;
-	    return 0;
-	}
+            mapWire = (xkbKTSetMapEntryWireDesc *) & wire[1];
+            preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries];
+            for (n = 0; n < wire->nMapEntries; n++) {
+                if (client->swapped) {
+                    swaps(&mapWire[n].virtualMods);
+                }
+                if (mapWire[n].realMods & (~wire->realMods)) {
+                    *nMapsRtrn = _XkbErrCode4(0x06, n, mapWire[n].realMods,
+                                              wire->realMods);
+                    return 0;
+                }
+                if (mapWire[n].virtualMods & (~wire->virtualMods)) {
+                    *nMapsRtrn = _XkbErrCode3(0x07, n, mapWire[n].virtualMods);
+                    return 0;
+                }
+                if (mapWire[n].level >= wire->numLevels) {
+                    *nMapsRtrn = _XkbErrCode4(0x08, n, wire->numLevels,
+                                              mapWire[n].level);
+                    return 0;
+                }
+                if (wire->preserve) {
+                    if (client->swapped) {
+                        swaps(&preWire[n].virtualMods);
+                    }
+                    if (preWire[n].realMods & (~mapWire[n].realMods)) {
+                        *nMapsRtrn = _XkbErrCode4(0x09, n, preWire[n].realMods,
+                                                  mapWire[n].realMods);
+                        return 0;
+                    }
+                    if (preWire[n].virtualMods & (~mapWire[n].virtualMods)) {
+                        *nMapsRtrn =
+                            _XkbErrCode3(0x0a, n, preWire[n].virtualMods);
+                        return 0;
+                    }
+                }
+            }
+            if (wire->preserve)
+                map = (CARD8 *) &preWire[wire->nMapEntries];
+            else
+                map = (CARD8 *) &mapWire[wire->nMapEntries];
+        }
+        else
+            map = (CARD8 *) &wire[1];
+        mapWidthRtrn[i + req->firstType] = wire->numLevels;
+        wire = (xkbKeyTypeWireDesc *) map;
     }
-    else {
-	*nMapsRtrn = xkb->map->num_types;
-	for (i=0;i<xkb->map->num_types;i++) {
-	    mapWidthRtrn[i] = xkb->map->types[i].num_levels;
-	}
-	return 1;
-    }
-
-    for (i=0;i<req->firstType;i++) {
-	mapWidthRtrn[i] = xkb->map->types[i].num_levels;
-    }
-    for (i=0;i<req->nTypes;i++) {
-	unsigned	width;
-	if (client->swapped) {
-	    swaps(&wire->virtualMods);
-	}
-	n= i+req->firstType;
-	width= wire->numLevels;
-	if (width<1) {
-	    *nMapsRtrn= _XkbErrCode3(0x04,n,width);
-	    return 0;
-	}
-	else if ((n==XkbOneLevelIndex)&&(width!=1)) { /* must be width 1 */
-	    *nMapsRtrn= _XkbErrCode3(0x05,n,width);
-	    return 0;
-	}
-	else if ((width!=2)&&
-		 ((n==XkbTwoLevelIndex)||(n==XkbKeypadIndex)||
-		  (n==XkbAlphabeticIndex))) {
-	    /* TWO_LEVEL, ALPHABETIC and KEYPAD must be width 2 */
-	    *nMapsRtrn= _XkbErrCode3(0x05,n,width);
-	    return 0;
-	}
-	if (wire->nMapEntries>0) {
-	    xkbKTSetMapEntryWireDesc *	mapWire;
-	    xkbModsWireDesc *		preWire;
-	    mapWire= (xkbKTSetMapEntryWireDesc *)&wire[1];
-	    preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
-	    for (n=0;n<wire->nMapEntries;n++) {
-		if (client->swapped) {
-		    swaps(&mapWire[n].virtualMods);
-		}
-		if (mapWire[n].realMods&(~wire->realMods)) {
-		    *nMapsRtrn= _XkbErrCode4(0x06,n,mapWire[n].realMods,
-						 wire->realMods);
-		    return 0;
-		}
-		if (mapWire[n].virtualMods&(~wire->virtualMods)) {
-		    *nMapsRtrn= _XkbErrCode3(0x07,n,mapWire[n].virtualMods);
-		    return 0;
-		}
-		if (mapWire[n].level>=wire->numLevels) {
-		    *nMapsRtrn= _XkbErrCode4(0x08,n,wire->numLevels,
-						 mapWire[n].level);
-		    return 0;
-		}
-		if (wire->preserve) {
-		    if (client->swapped) {
-			swaps(&preWire[n].virtualMods);
-		    }
-		    if (preWire[n].realMods&(~mapWire[n].realMods)) {
-			*nMapsRtrn= _XkbErrCode4(0x09,n,preWire[n].realMods,
-							mapWire[n].realMods);
-			return 0;
-		    }
-		    if (preWire[n].virtualMods&(~mapWire[n].virtualMods)) {
-			*nMapsRtrn=_XkbErrCode3(0x0a,n,preWire[n].virtualMods);
-			return 0;
-		    }
-		}
-	    }
-	    if (wire->preserve)
-		 map= (CARD8 *)&preWire[wire->nMapEntries];
-	    else map= (CARD8 *)&mapWire[wire->nMapEntries];
-	}
-	else map= (CARD8 *)&wire[1];
-	mapWidthRtrn[i+req->firstType] = wire->numLevels;
-	wire= (xkbKeyTypeWireDesc *)map;
-    }
-    for (i=req->firstType+req->nTypes;i<nMaps;i++) {
-	mapWidthRtrn[i] = xkb->map->types[i].num_levels;
+    for (i = req->firstType + req->nTypes; i < nMaps; i++) {
+        mapWidthRtrn[i] = xkb->map->types[i].num_levels;
     }
     *nMapsRtrn = nMaps;
     *wireRtrn = wire;
@@ -1656,660 +1698,666 @@ register xkbKeyTypeWireDesc	*wire = *wireRtrn;
 }
 
 static int
-CheckKeySyms(	ClientPtr		client,
-		XkbDescPtr		xkb,
-		xkbSetMapReq *		req,
-		int			nTypes,
-		CARD8 *	 		mapWidths,
-		CARD16 *	 	symsPerKey,
-		xkbSymMapWireDesc **	wireRtrn,
-		int *			errorRtrn)
+CheckKeySyms(ClientPtr client,
+             XkbDescPtr xkb,
+             xkbSetMapReq * req,
+             int nTypes,
+             CARD8 *mapWidths,
+             CARD16 *symsPerKey, xkbSymMapWireDesc ** wireRtrn, int *errorRtrn)
 {
-register unsigned	i;
-XkbSymMapPtr		map;
-xkbSymMapWireDesc*	wire = *wireRtrn;
-
-    if (!(XkbKeySymsMask&req->present))
-	return 1;
-    CHK_REQ_KEY_RANGE2(0x11,req->firstKeySym,req->nKeySyms,req,(*errorRtrn),0);
-    for (i=0;i<req->nKeySyms;i++) {
-	KeySym *pSyms;
-	register unsigned nG;
-	if (client->swapped) {
-	    swaps(&wire->nSyms);
-	}
-	nG = XkbNumGroups(wire->groupInfo);
-	if (nG>XkbNumKbdGroups) {
-	    *errorRtrn = _XkbErrCode3(0x14,i+req->firstKeySym,nG);
-	    return 0;
-	}
-	if (nG>0) {
-	    register int g,w;
-	    for (g=w=0;g<nG;g++) {
-		if (wire->ktIndex[g]>=(unsigned)nTypes) {
-		    *errorRtrn= _XkbErrCode4(0x15,i+req->firstKeySym,g,
-		    					   wire->ktIndex[g]);
-		    return 0;
-		}
-		if (mapWidths[wire->ktIndex[g]]>w)
-		    w= mapWidths[wire->ktIndex[g]];
-	    }
-	    if (wire->width!=w) {
-		*errorRtrn= _XkbErrCode3(0x16,i+req->firstKeySym,wire->width);
-		return 0;
-	    }
-	    w*= nG;
-	    symsPerKey[i+req->firstKeySym] = w;
-	    if (w!=wire->nSyms) {
-		*errorRtrn=_XkbErrCode4(0x16,i+req->firstKeySym,wire->nSyms,w);
-		return 0;
-	    }
-	}
-	else if (wire->nSyms!=0) {
-	    *errorRtrn = _XkbErrCode3(0x17,i+req->firstKeySym,wire->nSyms);
-	    return 0;
-	}
-	pSyms = (KeySym *)&wire[1];
-	wire = (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
+    register unsigned i;
+    XkbSymMapPtr map;
+    xkbSymMapWireDesc *wire = *wireRtrn;
+
+    if (!(XkbKeySymsMask & req->present))
+        return 1;
+    CHK_REQ_KEY_RANGE2(0x11, req->firstKeySym, req->nKeySyms, req, (*errorRtrn),
+                       0);
+    for (i = 0; i < req->nKeySyms; i++) {
+        KeySym *pSyms;
+        register unsigned nG;
+
+        if (client->swapped) {
+            swaps(&wire->nSyms);
+        }
+        nG = XkbNumGroups(wire->groupInfo);
+        if (nG > XkbNumKbdGroups) {
+            *errorRtrn = _XkbErrCode3(0x14, i + req->firstKeySym, nG);
+            return 0;
+        }
+        if (nG > 0) {
+            register int g, w;
+
+            for (g = w = 0; g < nG; g++) {
+                if (wire->ktIndex[g] >= (unsigned) nTypes) {
+                    *errorRtrn = _XkbErrCode4(0x15, i + req->firstKeySym, g,
+                                              wire->ktIndex[g]);
+                    return 0;
+                }
+                if (mapWidths[wire->ktIndex[g]] > w)
+                    w = mapWidths[wire->ktIndex[g]];
+            }
+            if (wire->width != w) {
+                *errorRtrn =
+                    _XkbErrCode3(0x16, i + req->firstKeySym, wire->width);
+                return 0;
+            }
+            w *= nG;
+            symsPerKey[i + req->firstKeySym] = w;
+            if (w != wire->nSyms) {
+                *errorRtrn =
+                    _XkbErrCode4(0x16, i + req->firstKeySym, wire->nSyms, w);
+                return 0;
+            }
+        }
+        else if (wire->nSyms != 0) {
+            *errorRtrn = _XkbErrCode3(0x17, i + req->firstKeySym, wire->nSyms);
+            return 0;
+        }
+        pSyms = (KeySym *) & wire[1];
+        wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms];
     }
 
     map = &xkb->map->key_sym_map[i];
-    for (;i<=(unsigned)xkb->max_key_code;i++,map++) {
-	register int g,nG,w;
-	nG= XkbKeyNumGroups(xkb,i);
-	for (w=g=0;g<nG;g++)  {
-	    if (map->kt_index[g]>=(unsigned)nTypes) {
-		*errorRtrn = _XkbErrCode4(0x18,i,g,map->kt_index[g]);
-		return 0;
-	    }
-	    if (mapWidths[map->kt_index[g]]>w)
-		    w= mapWidths[map->kt_index[g]];
-	}
-	symsPerKey[i] = w*nG;
+    for (; i <= (unsigned) xkb->max_key_code; i++, map++) {
+        register int g, nG, w;
+
+        nG = XkbKeyNumGroups(xkb, i);
+        for (w = g = 0; g < nG; g++) {
+            if (map->kt_index[g] >= (unsigned) nTypes) {
+                *errorRtrn = _XkbErrCode4(0x18, i, g, map->kt_index[g]);
+                return 0;
+            }
+            if (mapWidths[map->kt_index[g]] > w)
+                w = mapWidths[map->kt_index[g]];
+        }
+        symsPerKey[i] = w * nG;
     }
     *wireRtrn = wire;
     return 1;
 }
 
 static int
-CheckKeyActions(	XkbDescPtr	xkb,
-			xkbSetMapReq *	req,
-			int		nTypes,
-			CARD8 *		mapWidths,
-			CARD16 *	symsPerKey,
-			CARD8 **	wireRtrn,
-			int *		nActsRtrn)
+CheckKeyActions(XkbDescPtr xkb,
+                xkbSetMapReq * req,
+                int nTypes,
+                CARD8 *mapWidths,
+                CARD16 *symsPerKey, CARD8 **wireRtrn, int *nActsRtrn)
 {
-int			 nActs;
-CARD8 *			 wire = *wireRtrn;
-register unsigned	 i;
-
-    if (!(XkbKeyActionsMask&req->present))
-	return 1;
-    CHK_REQ_KEY_RANGE2(0x21,req->firstKeyAct,req->nKeyActs,req,(*nActsRtrn),0);
-    for (nActs=i=0;i<req->nKeyActs;i++) {
-	if (wire[0]!=0) {
-	    if (wire[0]==symsPerKey[i+req->firstKeyAct])
-		nActs+= wire[0];
-	    else {
-		*nActsRtrn= _XkbErrCode3(0x23,i+req->firstKeyAct,wire[0]);
-		return 0;
-	    }
-	}
-	wire++;
-    }
-    if (req->nKeyActs%4)
-	wire+= 4-(req->nKeyActs%4);
-    *wireRtrn = (CARD8 *)(((XkbAnyAction *)wire)+nActs);
+    int nActs;
+    CARD8 *wire = *wireRtrn;
+    register unsigned i;
+
+    if (!(XkbKeyActionsMask & req->present))
+        return 1;
+    CHK_REQ_KEY_RANGE2(0x21, req->firstKeyAct, req->nKeyActs, req, (*nActsRtrn),
+                       0);
+    for (nActs = i = 0; i < req->nKeyActs; i++) {
+        if (wire[0] != 0) {
+            if (wire[0] == symsPerKey[i + req->firstKeyAct])
+                nActs += wire[0];
+            else {
+                *nActsRtrn = _XkbErrCode3(0x23, i + req->firstKeyAct, wire[0]);
+                return 0;
+            }
+        }
+        wire++;
+    }
+    if (req->nKeyActs % 4)
+        wire += 4 - (req->nKeyActs % 4);
+    *wireRtrn = (CARD8 *) (((XkbAnyAction *) wire) + nActs);
     *nActsRtrn = nActs;
     return 1;
 }
 
 static int
-CheckKeyBehaviors(	XkbDescPtr 		xkb,
-			xkbSetMapReq *		req,
-			xkbBehaviorWireDesc **	wireRtrn,
-			int *			errorRtrn)
+CheckKeyBehaviors(XkbDescPtr xkb,
+                  xkbSetMapReq * req,
+                  xkbBehaviorWireDesc ** wireRtrn, int *errorRtrn)
 {
-register xkbBehaviorWireDesc *	wire = *wireRtrn;
-register XkbServerMapPtr	server = xkb->server;
-register unsigned	 	i;
-unsigned			first,last;
-
-    if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
-	req->present&= ~XkbKeyBehaviorsMask;
-	req->nKeyBehaviors= 0;
-	return 1;
-    }
-    first= req->firstKeyBehavior;
-    last=  req->firstKeyBehavior+req->nKeyBehaviors-1;
-    if (first<req->minKeyCode) {
-	*errorRtrn = _XkbErrCode3(0x31,first,req->minKeyCode);
-	return 0;
-    }
-    if (last>req->maxKeyCode) {
-	*errorRtrn = _XkbErrCode3(0x32,last,req->maxKeyCode);
-	return 0;
-    }
-	
-    for (i=0;i<req->totalKeyBehaviors;i++,wire++) {
-	if ((wire->key<first)||(wire->key>last)) {
-	    *errorRtrn = _XkbErrCode4(0x33,first,last,wire->key);
-	    return 0;
-	}
-	if ((wire->type&XkbKB_Permanent)&&
-	    ((server->behaviors[wire->key].type!=wire->type)||
-	     (server->behaviors[wire->key].data!=wire->data))) {
-	    *errorRtrn = _XkbErrCode3(0x33,wire->key,wire->type);
-	    return 0;
-	}
-	if ((wire->type==XkbKB_RadioGroup)&&
-		((wire->data&(~XkbKB_RGAllowNone))>XkbMaxRadioGroups)) {
-	    *errorRtrn= _XkbErrCode4(0x34,wire->key,wire->data,
-							XkbMaxRadioGroups);
-	    return 0;
-	}
-	if ((wire->type==XkbKB_Overlay1)||(wire->type==XkbKB_Overlay2)) {
-	    CHK_KEY_RANGE2(0x35,wire->key,1,xkb,*errorRtrn,0);
-	}
+    register xkbBehaviorWireDesc *wire = *wireRtrn;
+    register XkbServerMapPtr server = xkb->server;
+    register unsigned i;
+    unsigned first, last;
+
+    if (((req->present & XkbKeyBehaviorsMask) == 0) || (req->nKeyBehaviors < 1)) {
+        req->present &= ~XkbKeyBehaviorsMask;
+        req->nKeyBehaviors = 0;
+        return 1;
+    }
+    first = req->firstKeyBehavior;
+    last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
+    if (first < req->minKeyCode) {
+        *errorRtrn = _XkbErrCode3(0x31, first, req->minKeyCode);
+        return 0;
+    }
+    if (last > req->maxKeyCode) {
+        *errorRtrn = _XkbErrCode3(0x32, last, req->maxKeyCode);
+        return 0;
+    }
+
+    for (i = 0; i < req->totalKeyBehaviors; i++, wire++) {
+        if ((wire->key < first) || (wire->key > last)) {
+            *errorRtrn = _XkbErrCode4(0x33, first, last, wire->key);
+            return 0;
+        }
+        if ((wire->type & XkbKB_Permanent) &&
+            ((server->behaviors[wire->key].type != wire->type) ||
+             (server->behaviors[wire->key].data != wire->data))) {
+            *errorRtrn = _XkbErrCode3(0x33, wire->key, wire->type);
+            return 0;
+        }
+        if ((wire->type == XkbKB_RadioGroup) &&
+            ((wire->data & (~XkbKB_RGAllowNone)) > XkbMaxRadioGroups)) {
+            *errorRtrn = _XkbErrCode4(0x34, wire->key, wire->data,
+                                      XkbMaxRadioGroups);
+            return 0;
+        }
+        if ((wire->type == XkbKB_Overlay1) || (wire->type == XkbKB_Overlay2)) {
+            CHK_KEY_RANGE2(0x35, wire->key, 1, xkb, *errorRtrn, 0);
+        }
     }
     *wireRtrn = wire;
     return 1;
 }
 
 static int
-CheckVirtualMods(	XkbDescRec *	xkb,
-			xkbSetMapReq *	req,
-			CARD8 **	wireRtrn,
-			int *		errorRtrn)
+CheckVirtualMods(XkbDescRec * xkb,
+                 xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
 {
-register CARD8		*wire = *wireRtrn;
-register unsigned 	 i,nMods,bit;
+    register CARD8 *wire = *wireRtrn;
+    register unsigned i, nMods, bit;
 
-    if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0))
-	return 1;
-    for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (req->virtualMods&bit)
-	    nMods++;
+    if (((req->present & XkbVirtualModsMask) == 0) || (req->virtualMods == 0))
+        return 1;
+    for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (req->virtualMods & bit)
+            nMods++;
     }
-    *wireRtrn= (wire+XkbPaddedSize(nMods));
+    *wireRtrn = (wire + XkbPaddedSize(nMods));
     return 1;
 }
 
 static int
-CheckKeyExplicit(	XkbDescPtr	xkb,
-			xkbSetMapReq *	req,
-			CARD8 **	wireRtrn,
-			int	*	errorRtrn)
+CheckKeyExplicit(XkbDescPtr xkb,
+                 xkbSetMapReq * req, CARD8 **wireRtrn, int *errorRtrn)
 {
-register CARD8 *	wire = *wireRtrn;
-CARD8	*		start;
-register unsigned 	i;
-int			first,last;
-
-    if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit<1)) {
-	req->present&= ~XkbExplicitComponentsMask;
-	req->nKeyExplicit= 0;
-	return 1;
-    }
-    first= req->firstKeyExplicit;
-    last=  first+req->nKeyExplicit-1;
-    if (first<req->minKeyCode) {
-	*errorRtrn = _XkbErrCode3(0x51,first,req->minKeyCode);
-	return 0;
-    }
-    if (last>req->maxKeyCode) {
-	*errorRtrn = _XkbErrCode3(0x52,last,req->maxKeyCode);
-	return 0;
-    }
-    start= wire; 
-    for (i=0;i<req->totalKeyExplicit;i++,wire+=2) {
-	if ((wire[0]<first)||(wire[0]>last)) {
-	    *errorRtrn = _XkbErrCode4(0x53,first,last,wire[0]);
-	    return 0;
-	}
-	if (wire[1]&(~XkbAllExplicitMask)) {
-	     *errorRtrn= _XkbErrCode3(0x52,~XkbAllExplicitMask,wire[1]);
-	     return 0;
-	}
-    }
-    wire+= XkbPaddedSize(wire-start)-(wire-start);
-    *wireRtrn= wire;
+    register CARD8 *wire = *wireRtrn;
+    CARD8 *start;
+    register unsigned i;
+    int first, last;
+
+    if (((req->present & XkbExplicitComponentsMask) == 0) ||
+        (req->nKeyExplicit < 1)) {
+        req->present &= ~XkbExplicitComponentsMask;
+        req->nKeyExplicit = 0;
+        return 1;
+    }
+    first = req->firstKeyExplicit;
+    last = first + req->nKeyExplicit - 1;
+    if (first < req->minKeyCode) {
+        *errorRtrn = _XkbErrCode3(0x51, first, req->minKeyCode);
+        return 0;
+    }
+    if (last > req->maxKeyCode) {
+        *errorRtrn = _XkbErrCode3(0x52, last, req->maxKeyCode);
+        return 0;
+    }
+    start = wire;
+    for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
+        if ((wire[0] < first) || (wire[0] > last)) {
+            *errorRtrn = _XkbErrCode4(0x53, first, last, wire[0]);
+            return 0;
+        }
+        if (wire[1] & (~XkbAllExplicitMask)) {
+            *errorRtrn = _XkbErrCode3(0x52, ~XkbAllExplicitMask, wire[1]);
+            return 0;
+        }
+    }
+    wire += XkbPaddedSize(wire - start) - (wire - start);
+    *wireRtrn = wire;
     return 1;
 }
 
 static int
-CheckModifierMap(XkbDescPtr xkb,xkbSetMapReq *req,CARD8 **wireRtrn,int *errRtrn)
+CheckModifierMap(XkbDescPtr xkb, xkbSetMapReq * req, CARD8 **wireRtrn,
+                 int *errRtrn)
 {
-register CARD8 *	wire = *wireRtrn;
-CARD8	*		start;
-register unsigned 	i;
-int			first,last;
-
-    if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys<1)) {
-	req->present&= ~XkbModifierMapMask;
-	req->nModMapKeys= 0;
-	return 1;
-    }
-    first= req->firstModMapKey;
-    last=  first+req->nModMapKeys-1;
-    if (first<req->minKeyCode) {
-	*errRtrn = _XkbErrCode3(0x61,first,req->minKeyCode);
-	return 0;
-    }
-    if (last>req->maxKeyCode) {
-	*errRtrn = _XkbErrCode3(0x62,last,req->maxKeyCode);
-	return 0;
-    }
-    start= wire; 
-    for (i=0;i<req->totalModMapKeys;i++,wire+=2) {
-	if ((wire[0]<first)||(wire[0]>last)) {
-	    *errRtrn = _XkbErrCode4(0x63,first,last,wire[0]);
-	    return 0;
-	}
-    }
-    wire+= XkbPaddedSize(wire-start)-(wire-start);
-    *wireRtrn= wire;
+    register CARD8 *wire = *wireRtrn;
+    CARD8 *start;
+    register unsigned i;
+    int first, last;
+
+    if (((req->present & XkbModifierMapMask) == 0) || (req->nModMapKeys < 1)) {
+        req->present &= ~XkbModifierMapMask;
+        req->nModMapKeys = 0;
+        return 1;
+    }
+    first = req->firstModMapKey;
+    last = first + req->nModMapKeys - 1;
+    if (first < req->minKeyCode) {
+        *errRtrn = _XkbErrCode3(0x61, first, req->minKeyCode);
+        return 0;
+    }
+    if (last > req->maxKeyCode) {
+        *errRtrn = _XkbErrCode3(0x62, last, req->maxKeyCode);
+        return 0;
+    }
+    start = wire;
+    for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
+        if ((wire[0] < first) || (wire[0] > last)) {
+            *errRtrn = _XkbErrCode4(0x63, first, last, wire[0]);
+            return 0;
+        }
+    }
+    wire += XkbPaddedSize(wire - start) - (wire - start);
+    *wireRtrn = wire;
     return 1;
 }
 
 static int
-CheckVirtualModMap(	XkbDescPtr xkb,
-			xkbSetMapReq *req,
-			xkbVModMapWireDesc **wireRtrn,
-			int *errRtrn)
+CheckVirtualModMap(XkbDescPtr xkb,
+                   xkbSetMapReq * req,
+                   xkbVModMapWireDesc ** wireRtrn, int *errRtrn)
 {
-register xkbVModMapWireDesc *	wire = *wireRtrn;
-register unsigned 		i;
-int				first,last;
-
-    if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys<1)) {
-	req->present&= ~XkbVirtualModMapMask;
-	req->nVModMapKeys= 0;
-	return 1;
-    }
-    first= req->firstVModMapKey;
-    last=  first+req->nVModMapKeys-1;
-    if (first<req->minKeyCode) {
-	*errRtrn = _XkbErrCode3(0x71,first,req->minKeyCode);
-	return 0;
-    }
-    if (last>req->maxKeyCode) {
-	*errRtrn = _XkbErrCode3(0x72,last,req->maxKeyCode);
-	return 0;
-    }
-    for (i=0;i<req->totalVModMapKeys;i++,wire++) {
-	if ((wire->key<first)||(wire->key>last)) {
-	    *errRtrn = _XkbErrCode4(0x73,first,last,wire->key);
-	    return 0;
-	}
-    }
-    *wireRtrn= wire;
+    register xkbVModMapWireDesc *wire = *wireRtrn;
+    register unsigned i;
+    int first, last;
+
+    if (((req->present & XkbVirtualModMapMask) == 0) || (req->nVModMapKeys < 1)) {
+        req->present &= ~XkbVirtualModMapMask;
+        req->nVModMapKeys = 0;
+        return 1;
+    }
+    first = req->firstVModMapKey;
+    last = first + req->nVModMapKeys - 1;
+    if (first < req->minKeyCode) {
+        *errRtrn = _XkbErrCode3(0x71, first, req->minKeyCode);
+        return 0;
+    }
+    if (last > req->maxKeyCode) {
+        *errRtrn = _XkbErrCode3(0x72, last, req->maxKeyCode);
+        return 0;
+    }
+    for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
+        if ((wire->key < first) || (wire->key > last)) {
+            *errRtrn = _XkbErrCode4(0x73, first, last, wire->key);
+            return 0;
+        }
+    }
+    *wireRtrn = wire;
     return 1;
 }
 
 static char *
-SetKeyTypes(	XkbDescPtr		xkb,
-		xkbSetMapReq *		req,
-		xkbKeyTypeWireDesc *	wire,
-		XkbChangesPtr		changes)
+SetKeyTypes(XkbDescPtr xkb,
+            xkbSetMapReq * req,
+            xkbKeyTypeWireDesc * wire, XkbChangesPtr changes)
 {
-register unsigned	i;
-unsigned		first,last;
-CARD8			*map;
-
-    if ((unsigned)(req->firstType+req->nTypes)>xkb->map->size_types) {
-	i= req->firstType+req->nTypes;
-	if (XkbAllocClientMap(xkb,XkbKeyTypesMask,i)!=Success) {
-	    return NULL;
-	}
-    }
-    if ((unsigned)(req->firstType+req->nTypes)>xkb->map->num_types)
-	xkb->map->num_types= req->firstType+req->nTypes;
-
-    for (i=0;i<req->nTypes;i++) {
-	XkbKeyTypePtr		pOld;
-	register unsigned 	n;
-
-	if (XkbResizeKeyType(xkb,i+req->firstType,wire->nMapEntries,
-				wire->preserve,wire->numLevels)!=Success) {
-	    return NULL;
-	}
-	pOld = &xkb->map->types[i+req->firstType];
-	map = (CARD8 *)&wire[1];
-
-	pOld->mods.real_mods = wire->realMods;
-	pOld->mods.vmods= wire->virtualMods;
-	pOld->num_levels = wire->numLevels;
-	pOld->map_count= wire->nMapEntries;
-
-	pOld->mods.mask= pOld->mods.real_mods|
-					XkbMaskForVMask(xkb,pOld->mods.vmods);
-
-	if (wire->nMapEntries) {
-	    xkbKTSetMapEntryWireDesc *mapWire;
-	    xkbModsWireDesc *preWire;
-	    unsigned tmp;
-	    mapWire= (xkbKTSetMapEntryWireDesc *)map;
-	    preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
-	    for (n=0;n<wire->nMapEntries;n++) {
-		pOld->map[n].active= 1;
-		pOld->map[n].mods.mask= mapWire[n].realMods;
-		pOld->map[n].mods.real_mods= mapWire[n].realMods;
-		pOld->map[n].mods.vmods= mapWire[n].virtualMods;
-		pOld->map[n].level= mapWire[n].level;
-		if (mapWire[n].virtualMods!=0) {
-		    tmp= XkbMaskForVMask(xkb,mapWire[n].virtualMods);
-		    pOld->map[n].active= (tmp!=0);
-		    pOld->map[n].mods.mask|= tmp;
-		}
-		if (wire->preserve) {
-		    pOld->preserve[n].real_mods= preWire[n].realMods;
-		    pOld->preserve[n].vmods= preWire[n].virtualMods;
-		    tmp= XkbMaskForVMask(xkb,preWire[n].virtualMods);
-		    pOld->preserve[n].mask= preWire[n].realMods|tmp;
-		}
-	    }
-	    if (wire->preserve)
-		 map= (CARD8 *)&preWire[wire->nMapEntries];
-	    else map= (CARD8 *)&mapWire[wire->nMapEntries];
-	}
-	else map= (CARD8 *)&wire[1];
-	wire = (xkbKeyTypeWireDesc *)map;
-    }
-    first= req->firstType;
-    last= first+req->nTypes-1; /* last changed type */
-    if (changes->map.changed&XkbKeyTypesMask) {
-	int oldLast;
-	oldLast= changes->map.first_type+changes->map.num_types-1;
-	if (changes->map.first_type<first)
-	    first= changes->map.first_type;
-	if (oldLast>last)
-	    last= oldLast;
-    }
-    changes->map.changed|= XkbKeyTypesMask;
+    register unsigned i;
+    unsigned first, last;
+    CARD8 *map;
+
+    if ((unsigned) (req->firstType + req->nTypes) > xkb->map->size_types) {
+        i = req->firstType + req->nTypes;
+        if (XkbAllocClientMap(xkb, XkbKeyTypesMask, i) != Success) {
+            return NULL;
+        }
+    }
+    if ((unsigned) (req->firstType + req->nTypes) > xkb->map->num_types)
+        xkb->map->num_types = req->firstType + req->nTypes;
+
+    for (i = 0; i < req->nTypes; i++) {
+        XkbKeyTypePtr pOld;
+        register unsigned n;
+
+        if (XkbResizeKeyType(xkb, i + req->firstType, wire->nMapEntries,
+                             wire->preserve, wire->numLevels) != Success) {
+            return NULL;
+        }
+        pOld = &xkb->map->types[i + req->firstType];
+        map = (CARD8 *) &wire[1];
+
+        pOld->mods.real_mods = wire->realMods;
+        pOld->mods.vmods = wire->virtualMods;
+        pOld->num_levels = wire->numLevels;
+        pOld->map_count = wire->nMapEntries;
+
+        pOld->mods.mask = pOld->mods.real_mods |
+            XkbMaskForVMask(xkb, pOld->mods.vmods);
+
+        if (wire->nMapEntries) {
+            xkbKTSetMapEntryWireDesc *mapWire;
+            xkbModsWireDesc *preWire;
+            unsigned tmp;
+
+            mapWire = (xkbKTSetMapEntryWireDesc *) map;
+            preWire = (xkbModsWireDesc *) & mapWire[wire->nMapEntries];
+            for (n = 0; n < wire->nMapEntries; n++) {
+                pOld->map[n].active = 1;
+                pOld->map[n].mods.mask = mapWire[n].realMods;
+                pOld->map[n].mods.real_mods = mapWire[n].realMods;
+                pOld->map[n].mods.vmods = mapWire[n].virtualMods;
+                pOld->map[n].level = mapWire[n].level;
+                if (mapWire[n].virtualMods != 0) {
+                    tmp = XkbMaskForVMask(xkb, mapWire[n].virtualMods);
+                    pOld->map[n].active = (tmp != 0);
+                    pOld->map[n].mods.mask |= tmp;
+                }
+                if (wire->preserve) {
+                    pOld->preserve[n].real_mods = preWire[n].realMods;
+                    pOld->preserve[n].vmods = preWire[n].virtualMods;
+                    tmp = XkbMaskForVMask(xkb, preWire[n].virtualMods);
+                    pOld->preserve[n].mask = preWire[n].realMods | tmp;
+                }
+            }
+            if (wire->preserve)
+                map = (CARD8 *) &preWire[wire->nMapEntries];
+            else
+                map = (CARD8 *) &mapWire[wire->nMapEntries];
+        }
+        else
+            map = (CARD8 *) &wire[1];
+        wire = (xkbKeyTypeWireDesc *) map;
+    }
+    first = req->firstType;
+    last = first + req->nTypes - 1;     /* last changed type */
+    if (changes->map.changed & XkbKeyTypesMask) {
+        int oldLast;
+
+        oldLast = changes->map.first_type + changes->map.num_types - 1;
+        if (changes->map.first_type < first)
+            first = changes->map.first_type;
+        if (oldLast > last)
+            last = oldLast;
+    }
+    changes->map.changed |= XkbKeyTypesMask;
     changes->map.first_type = first;
-    changes->map.num_types = (last-first)+1;
-    return (char *)wire;
+    changes->map.num_types = (last - first) + 1;
+    return (char *) wire;
 }
 
 static char *
-SetKeySyms(	ClientPtr		client,
-		XkbDescPtr		xkb,
-		xkbSetMapReq *		req,
-		xkbSymMapWireDesc *	wire,
-		XkbChangesPtr 		changes,
-		DeviceIntPtr		dev)
+SetKeySyms(ClientPtr client,
+           XkbDescPtr xkb,
+           xkbSetMapReq * req,
+           xkbSymMapWireDesc * wire, XkbChangesPtr changes, DeviceIntPtr dev)
 {
-register unsigned 	i,s;
-XkbSymMapPtr		oldMap;
-KeySym *		newSyms;
-KeySym *		pSyms;
-unsigned		first,last;
+    register unsigned i, s;
+    XkbSymMapPtr oldMap;
+    KeySym *newSyms;
+    KeySym *pSyms;
+    unsigned first, last;
 
     oldMap = &xkb->map->key_sym_map[req->firstKeySym];
-    for (i=0;i<req->nKeySyms;i++,oldMap++) {
-	pSyms = (KeySym *)&wire[1];
-	if (wire->nSyms>0) {
-	    newSyms = XkbResizeKeySyms(xkb,i+req->firstKeySym,wire->nSyms);
-	    for (s=0;s<wire->nSyms;s++) {
-		newSyms[s]= pSyms[s];
-	    }
-	    if (client->swapped) {
-		for (s=0;s<wire->nSyms;s++) {
-		    swapl(&newSyms[s]);
-		}
-	    }
-	}
-	oldMap->kt_index[0] = wire->ktIndex[0];
-	oldMap->kt_index[1] = wire->ktIndex[1];
-	oldMap->kt_index[2] = wire->ktIndex[2];
-	oldMap->kt_index[3] = wire->ktIndex[3];
-	oldMap->group_info = wire->groupInfo;
-	oldMap->width = wire->width;
-	wire= (xkbSymMapWireDesc *)&pSyms[wire->nSyms];
-    }
-    first= req->firstKeySym;
-    last= first+req->nKeySyms-1;
-    if (changes->map.changed&XkbKeySymsMask) {
-	int oldLast= (changes->map.first_key_sym+changes->map.num_key_syms-1);
-	if (changes->map.first_key_sym<first)
-	    first= changes->map.first_key_sym;
-	if (oldLast>last)
-	    last= oldLast;
-    }
-    changes->map.changed|= XkbKeySymsMask;
+    for (i = 0; i < req->nKeySyms; i++, oldMap++) {
+        pSyms = (KeySym *) & wire[1];
+        if (wire->nSyms > 0) {
+            newSyms = XkbResizeKeySyms(xkb, i + req->firstKeySym, wire->nSyms);
+            for (s = 0; s < wire->nSyms; s++) {
+                newSyms[s] = pSyms[s];
+            }
+            if (client->swapped) {
+                for (s = 0; s < wire->nSyms; s++) {
+                    swapl(&newSyms[s]);
+                }
+            }
+        }
+        oldMap->kt_index[0] = wire->ktIndex[0];
+        oldMap->kt_index[1] = wire->ktIndex[1];
+        oldMap->kt_index[2] = wire->ktIndex[2];
+        oldMap->kt_index[3] = wire->ktIndex[3];
+        oldMap->group_info = wire->groupInfo;
+        oldMap->width = wire->width;
+        wire = (xkbSymMapWireDesc *) & pSyms[wire->nSyms];
+    }
+    first = req->firstKeySym;
+    last = first + req->nKeySyms - 1;
+    if (changes->map.changed & XkbKeySymsMask) {
+        int oldLast =
+            (changes->map.first_key_sym + changes->map.num_key_syms - 1);
+        if (changes->map.first_key_sym < first)
+            first = changes->map.first_key_sym;
+        if (oldLast > last)
+            last = oldLast;
+    }
+    changes->map.changed |= XkbKeySymsMask;
     changes->map.first_key_sym = first;
-    changes->map.num_key_syms = (last-first+1);
-
-    s= 0;
-    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	if (XkbKeyNumGroups(xkb,i)>s)
-	    s= XkbKeyNumGroups(xkb,i);
-    }
-    if (s!=xkb->ctrls->num_groups) {
-	xkbControlsNotify	cn;
-	XkbControlsRec		old;
-	cn.keycode= 0;
-	cn.eventType= 0;
-	cn.requestMajor= XkbReqCode;
-	cn.requestMinor= X_kbSetMap;
-	old= *xkb->ctrls;
-	xkb->ctrls->num_groups= s;
-	if (XkbComputeControlsNotify(dev,&old,xkb->ctrls,&cn,FALSE))
-	    XkbSendControlsNotify(dev,&cn);
-    }
-    return (char *)wire;
+    changes->map.num_key_syms = (last - first + 1);
+
+    s = 0;
+    for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+        if (XkbKeyNumGroups(xkb, i) > s)
+            s = XkbKeyNumGroups(xkb, i);
+    }
+    if (s != xkb->ctrls->num_groups) {
+        xkbControlsNotify cn;
+        XkbControlsRec old;
+
+        cn.keycode = 0;
+        cn.eventType = 0;
+        cn.requestMajor = XkbReqCode;
+        cn.requestMinor = X_kbSetMap;
+        old = *xkb->ctrls;
+        xkb->ctrls->num_groups = s;
+        if (XkbComputeControlsNotify(dev, &old, xkb->ctrls, &cn, FALSE))
+            XkbSendControlsNotify(dev, &cn);
+    }
+    return (char *) wire;
 }
 
 static char *
-SetKeyActions(	XkbDescPtr	xkb,
-		xkbSetMapReq *	req,
-		CARD8 *		wire,
-		XkbChangesPtr	changes)
+SetKeyActions(XkbDescPtr xkb,
+              xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
 {
-register unsigned	i,first,last;
-CARD8 *			nActs = wire;
-XkbAction *		newActs;
-    
-    wire+= XkbPaddedSize(req->nKeyActs);
-    for (i=0;i<req->nKeyActs;i++) {
-	if (nActs[i]==0)
-	    xkb->server->key_acts[i+req->firstKeyAct]= 0;
-	else {
-	    newActs= XkbResizeKeyActions(xkb,i+req->firstKeyAct,nActs[i]);
-	    memcpy((char *)newActs,(char *)wire,
-					nActs[i]*SIZEOF(xkbActionWireDesc));
-	    wire+= nActs[i]*SIZEOF(xkbActionWireDesc);
-	}
-    }
-    first= req->firstKeyAct;
-    last= (first+req->nKeyActs-1);
-    if (changes->map.changed&XkbKeyActionsMask) {
-	int oldLast;
-	oldLast= changes->map.first_key_act+changes->map.num_key_acts-1;
-	if (changes->map.first_key_act<first)
-	    first= changes->map.first_key_act;
-	if (oldLast>last)
-	    last= oldLast;
-    }
-    changes->map.changed|= XkbKeyActionsMask;
-    changes->map.first_key_act= first;
-    changes->map.num_key_acts= (last-first+1);
-    return (char *)wire;
+    register unsigned i, first, last;
+    CARD8 *nActs = wire;
+    XkbAction *newActs;
+
+    wire += XkbPaddedSize(req->nKeyActs);
+    for (i = 0; i < req->nKeyActs; i++) {
+        if (nActs[i] == 0)
+            xkb->server->key_acts[i + req->firstKeyAct] = 0;
+        else {
+            newActs = XkbResizeKeyActions(xkb, i + req->firstKeyAct, nActs[i]);
+            memcpy((char *) newActs, (char *) wire,
+                   nActs[i] * SIZEOF(xkbActionWireDesc));
+            wire += nActs[i] * SIZEOF(xkbActionWireDesc);
+        }
+    }
+    first = req->firstKeyAct;
+    last = (first + req->nKeyActs - 1);
+    if (changes->map.changed & XkbKeyActionsMask) {
+        int oldLast;
+
+        oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1;
+        if (changes->map.first_key_act < first)
+            first = changes->map.first_key_act;
+        if (oldLast > last)
+            last = oldLast;
+    }
+    changes->map.changed |= XkbKeyActionsMask;
+    changes->map.first_key_act = first;
+    changes->map.num_key_acts = (last - first + 1);
+    return (char *) wire;
 }
 
 static char *
-SetKeyBehaviors(	XkbSrvInfoPtr	 xkbi,
-    			xkbSetMapReq	*req,
-    			xkbBehaviorWireDesc	*wire,
-    			XkbChangesPtr	 changes)
+SetKeyBehaviors(XkbSrvInfoPtr xkbi,
+                xkbSetMapReq * req,
+                xkbBehaviorWireDesc * wire, XkbChangesPtr changes)
 {
-register unsigned i;
-int maxRG = -1;
-XkbDescPtr       xkb = xkbi->desc;
-XkbServerMapPtr	 server = xkb->server;
-unsigned	 first,last;
-
-    first= req->firstKeyBehavior;
-    last= req->firstKeyBehavior+req->nKeyBehaviors-1;
-    memset(&server->behaviors[first], 0, req->nKeyBehaviors*sizeof(XkbBehavior));
-    for (i=0;i<req->totalKeyBehaviors;i++) {
-	if ((server->behaviors[wire->key].type&XkbKB_Permanent)==0) {
-	    server->behaviors[wire->key].type= wire->type;
-	    server->behaviors[wire->key].data= wire->data;
-	    if ((wire->type==XkbKB_RadioGroup)&&(((int)wire->data)>maxRG))
-		maxRG= wire->data + 1;
-	}
-	wire++;
-    }
-
-    if (maxRG>(int)xkbi->nRadioGroups) {
-        int sz = maxRG*sizeof(XkbRadioGroupRec);
+    register unsigned i;
+    int maxRG = -1;
+    XkbDescPtr xkb = xkbi->desc;
+    XkbServerMapPtr server = xkb->server;
+    unsigned first, last;
+
+    first = req->firstKeyBehavior;
+    last = req->firstKeyBehavior + req->nKeyBehaviors - 1;
+    memset(&server->behaviors[first], 0,
+           req->nKeyBehaviors * sizeof(XkbBehavior));
+    for (i = 0; i < req->totalKeyBehaviors; i++) {
+        if ((server->behaviors[wire->key].type & XkbKB_Permanent) == 0) {
+            server->behaviors[wire->key].type = wire->type;
+            server->behaviors[wire->key].data = wire->data;
+            if ((wire->type == XkbKB_RadioGroup) &&
+                (((int) wire->data) > maxRG))
+                maxRG = wire->data + 1;
+        }
+        wire++;
+    }
+
+    if (maxRG > (int) xkbi->nRadioGroups) {
+        int sz = maxRG * sizeof(XkbRadioGroupRec);
+
         if (xkbi->radioGroups)
-             xkbi->radioGroups= realloc(xkbi->radioGroups,sz);
-        else xkbi->radioGroups= calloc(1, sz);
+            xkbi->radioGroups = realloc(xkbi->radioGroups, sz);
+        else
+            xkbi->radioGroups = calloc(1, sz);
         if (xkbi->radioGroups) {
-             if (xkbi->nRadioGroups)
-                 memset(&xkbi->radioGroups[xkbi->nRadioGroups], 0,
-                        (maxRG-xkbi->nRadioGroups)*sizeof(XkbRadioGroupRec));
-             xkbi->nRadioGroups= maxRG;
+            if (xkbi->nRadioGroups)
+                memset(&xkbi->radioGroups[xkbi->nRadioGroups], 0,
+                       (maxRG - xkbi->nRadioGroups) * sizeof(XkbRadioGroupRec));
+            xkbi->nRadioGroups = maxRG;
         }
-        else xkbi->nRadioGroups= 0;
+        else
+            xkbi->nRadioGroups = 0;
         /* should compute members here */
     }
-    if (changes->map.changed&XkbKeyBehaviorsMask) {
-	unsigned oldLast;
-	oldLast= changes->map.first_key_behavior+
-					changes->map.num_key_behaviors-1;
-        if (changes->map.first_key_behavior<req->firstKeyBehavior)
-             first= changes->map.first_key_behavior;
-        if (oldLast>last)
-            last= oldLast;
+    if (changes->map.changed & XkbKeyBehaviorsMask) {
+        unsigned oldLast;
+
+        oldLast = changes->map.first_key_behavior +
+            changes->map.num_key_behaviors - 1;
+        if (changes->map.first_key_behavior < req->firstKeyBehavior)
+            first = changes->map.first_key_behavior;
+        if (oldLast > last)
+            last = oldLast;
     }
-    changes->map.changed|= XkbKeyBehaviorsMask;
+    changes->map.changed |= XkbKeyBehaviorsMask;
     changes->map.first_key_behavior = first;
-    changes->map.num_key_behaviors = (last-first+1);
-    return (char *)wire;
+    changes->map.num_key_behaviors = (last - first + 1);
+    return (char *) wire;
 }
 
 static char *
-SetVirtualMods(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
-						XkbChangesPtr changes)
+SetVirtualMods(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
+               XkbChangesPtr changes)
 {
-register int 		i,bit,nMods;
-XkbServerMapPtr		srv = xkbi->desc->server;
-
-    if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0))
-	return (char *)wire;
-    for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (req->virtualMods&bit) {
-	    if (srv->vmods[i]!=wire[nMods]) {
-		changes->map.changed|= XkbVirtualModsMask;
-		changes->map.vmods|= bit;
-		srv->vmods[i]= wire[nMods];
-	    }
-	    nMods++;
-	}
-    }
-    return (char *)(wire+XkbPaddedSize(nMods));
+    register int i, bit, nMods;
+    XkbServerMapPtr srv = xkbi->desc->server;
+
+    if (((req->present & XkbVirtualModsMask) == 0) || (req->virtualMods == 0))
+        return (char *) wire;
+    for (i = nMods = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (req->virtualMods & bit) {
+            if (srv->vmods[i] != wire[nMods]) {
+                changes->map.changed |= XkbVirtualModsMask;
+                changes->map.vmods |= bit;
+                srv->vmods[i] = wire[nMods];
+            }
+            nMods++;
+        }
+    }
+    return (char *) (wire + XkbPaddedSize(nMods));
 }
 
 static char *
-SetKeyExplicit(XkbSrvInfoPtr xkbi,xkbSetMapReq *req,CARD8 *wire,
-							XkbChangesPtr changes)
+SetKeyExplicit(XkbSrvInfoPtr xkbi, xkbSetMapReq * req, CARD8 *wire,
+               XkbChangesPtr changes)
 {
-register unsigned	i,first,last;
-XkbServerMapPtr		xkb = xkbi->desc->server;
-CARD8 *			start;
+    register unsigned i, first, last;
+    XkbServerMapPtr xkb = xkbi->desc->server;
+    CARD8 *start;
 
-    start= wire;
-    first= req->firstKeyExplicit;
-    last=  req->firstKeyExplicit+req->nKeyExplicit-1;
+    start = wire;
+    first = req->firstKeyExplicit;
+    last = req->firstKeyExplicit + req->nKeyExplicit - 1;
     memset(&xkb->explicit[first], 0, req->nKeyExplicit);
-    for (i=0;i<req->totalKeyExplicit;i++,wire+= 2) {
-	xkb->explicit[wire[0]]= wire[1];
-    }
-    if (first>0) {
-	if (changes->map.changed&XkbExplicitComponentsMask) {
-	    int oldLast;
-	    oldLast= changes->map.first_key_explicit+
-					changes->map.num_key_explicit-1;
-	    if (changes->map.first_key_explicit<first)
-		first= changes->map.first_key_explicit;
-	    if (oldLast>last)
-		last= oldLast;
-	}
-	changes->map.first_key_explicit= first;
-	changes->map.num_key_explicit= (last-first)+1;
-    }
-    wire+= XkbPaddedSize(wire-start)-(wire-start);
-    return (char *)wire;
+    for (i = 0; i < req->totalKeyExplicit; i++, wire += 2) {
+        xkb->explicit[wire[0]] = wire[1];
+    }
+    if (first > 0) {
+        if (changes->map.changed & XkbExplicitComponentsMask) {
+            int oldLast;
+
+            oldLast = changes->map.first_key_explicit +
+                changes->map.num_key_explicit - 1;
+            if (changes->map.first_key_explicit < first)
+                first = changes->map.first_key_explicit;
+            if (oldLast > last)
+                last = oldLast;
+        }
+        changes->map.first_key_explicit = first;
+        changes->map.num_key_explicit = (last - first) + 1;
+    }
+    wire += XkbPaddedSize(wire - start) - (wire - start);
+    return (char *) wire;
 }
 
 static char *
-SetModifierMap(	XkbSrvInfoPtr	xkbi,
-		xkbSetMapReq *	req,
-		CARD8 *		wire,
-		XkbChangesPtr	changes)
+SetModifierMap(XkbSrvInfoPtr xkbi,
+               xkbSetMapReq * req, CARD8 *wire, XkbChangesPtr changes)
 {
-register unsigned	i,first,last;
-XkbClientMapPtr		xkb = xkbi->desc->map;
-CARD8 *			start;
+    register unsigned i, first, last;
+    XkbClientMapPtr xkb = xkbi->desc->map;
+    CARD8 *start;
 
-    start= wire;
-    first= req->firstModMapKey;
-    last=  req->firstModMapKey+req->nModMapKeys-1;
+    start = wire;
+    first = req->firstModMapKey;
+    last = req->firstModMapKey + req->nModMapKeys - 1;
     memset(&xkb->modmap[first], 0, req->nModMapKeys);
-    for (i=0;i<req->totalModMapKeys;i++,wire+= 2) {
-	xkb->modmap[wire[0]]= wire[1];
-    }
-    if (first>0) {
-	if (changes->map.changed&XkbModifierMapMask) {
-	    int oldLast;
-	    oldLast= changes->map.first_modmap_key+
-						changes->map.num_modmap_keys-1;
-	    if (changes->map.first_modmap_key<first)
-		first= changes->map.first_modmap_key;
-	    if (oldLast>last)
-		last= oldLast;
-	}
-	changes->map.first_modmap_key= first;
-	changes->map.num_modmap_keys= (last-first)+1;
-    }
-    wire+= XkbPaddedSize(wire-start)-(wire-start);
-    return (char *)wire;
+    for (i = 0; i < req->totalModMapKeys; i++, wire += 2) {
+        xkb->modmap[wire[0]] = wire[1];
+    }
+    if (first > 0) {
+        if (changes->map.changed & XkbModifierMapMask) {
+            int oldLast;
+
+            oldLast = changes->map.first_modmap_key +
+                changes->map.num_modmap_keys - 1;
+            if (changes->map.first_modmap_key < first)
+                first = changes->map.first_modmap_key;
+            if (oldLast > last)
+                last = oldLast;
+        }
+        changes->map.first_modmap_key = first;
+        changes->map.num_modmap_keys = (last - first) + 1;
+    }
+    wire += XkbPaddedSize(wire - start) - (wire - start);
+    return (char *) wire;
 }
 
 static char *
-SetVirtualModMap(	XkbSrvInfoPtr		xkbi,
-			xkbSetMapReq *		req,
-			xkbVModMapWireDesc *	wire,
-			XkbChangesPtr 		changes)
+SetVirtualModMap(XkbSrvInfoPtr xkbi,
+                 xkbSetMapReq * req,
+                 xkbVModMapWireDesc * wire, XkbChangesPtr changes)
 {
-register unsigned	i,first,last;
-XkbServerMapPtr		srv = xkbi->desc->server;
-
-    first= req->firstVModMapKey;
-    last=  req->firstVModMapKey+req->nVModMapKeys-1;
-    memset(&srv->vmodmap[first], 0, req->nVModMapKeys*sizeof(unsigned short));
-    for (i=0;i<req->totalVModMapKeys;i++,wire++) {
-	srv->vmodmap[wire->key]= wire->vmods;
-    }
-    if (first>0) {
-	if (changes->map.changed&XkbVirtualModMapMask) {
-	    int oldLast;
-	    oldLast= changes->map.first_vmodmap_key+
-					changes->map.num_vmodmap_keys-1;
-	    if (changes->map.first_vmodmap_key<first)
-		first= changes->map.first_vmodmap_key;
-	    if (oldLast>last)
-		last= oldLast;
-	}
-	changes->map.first_vmodmap_key= first;
-	changes->map.num_vmodmap_keys= (last-first)+1;
-    }
-    return (char *)wire;
+    register unsigned i, first, last;
+    XkbServerMapPtr srv = xkbi->desc->server;
+
+    first = req->firstVModMapKey;
+    last = req->firstVModMapKey + req->nVModMapKeys - 1;
+    memset(&srv->vmodmap[first], 0, req->nVModMapKeys * sizeof(unsigned short));
+    for (i = 0; i < req->totalVModMapKeys; i++, wire++) {
+        srv->vmodmap[wire->key] = wire->vmods;
+    }
+    if (first > 0) {
+        if (changes->map.changed & XkbVirtualModMapMask) {
+            int oldLast;
+
+            oldLast = changes->map.first_vmodmap_key +
+                changes->map.num_vmodmap_keys - 1;
+            if (changes->map.first_vmodmap_key < first)
+                first = changes->map.first_vmodmap_key;
+            if (oldLast > last)
+                last = oldLast;
+        }
+        changes->map.first_vmodmap_key = first;
+        changes->map.num_vmodmap_keys = (last - first) + 1;
+    }
+    return (char *) wire;
 }
 
 /**
@@ -2317,106 +2365,112 @@ XkbServerMapPtr		srv = xkbi->desc->server;
  * actually do anything..
  */
 static int
-_XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char* values)
+_XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req,
+                 char *values)
 {
-    XkbSrvInfoPtr       xkbi;
-    XkbDescPtr          xkb;
-    int                 error;
-    int                 nTypes = 0, nActions;
-    CARD8               mapWidths[XkbMaxLegalKeyCode + 1] = {0};
-    CARD16              symsPerKey[XkbMaxLegalKeyCode + 1] = {0};
-    XkbSymMapPtr        map;
-    int                 i;
-
-    xkbi= dev->key->xkbInfo;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
+    int error;
+    int nTypes = 0, nActions;
+    CARD8 mapWidths[XkbMaxLegalKeyCode + 1] = { 0 };
+    CARD16 symsPerKey[XkbMaxLegalKeyCode + 1] = { 0 };
+    XkbSymMapPtr map;
+    int i;
+
+    xkbi = dev->key->xkbInfo;
     xkb = xkbi->desc;
 
-    if ((xkb->min_key_code != req->minKeyCode)||
+    if ((xkb->min_key_code != req->minKeyCode) ||
         (xkb->max_key_code != req->maxKeyCode)) {
-	if (client->vMajor!=1) { /* pre 1.0 versions of Xlib have a bug */
-	    req->minKeyCode= xkb->min_key_code;
-	    req->maxKeyCode= xkb->max_key_code;
-	}
-	else {
-	    if (!XkbIsLegalKeycode(req->minKeyCode)) {
-		client->errorValue = _XkbErrCode3(2, req->minKeyCode, req->maxKeyCode);
-		return BadValue;
-	    }
-	    if (req->minKeyCode > req->maxKeyCode) {
-		client->errorValue = _XkbErrCode3(3, req->minKeyCode, req->maxKeyCode);
-		return BadMatch;
-	    }
-	}
+        if (client->vMajor != 1) {      /* pre 1.0 versions of Xlib have a bug */
+            req->minKeyCode = xkb->min_key_code;
+            req->maxKeyCode = xkb->max_key_code;
+        }
+        else {
+            if (!XkbIsLegalKeycode(req->minKeyCode)) {
+                client->errorValue =
+                    _XkbErrCode3(2, req->minKeyCode, req->maxKeyCode);
+                return BadValue;
+            }
+            if (req->minKeyCode > req->maxKeyCode) {
+                client->errorValue =
+                    _XkbErrCode3(3, req->minKeyCode, req->maxKeyCode);
+                return BadMatch;
+            }
+        }
     }
 
     if ((req->present & XkbKeyTypesMask) &&
-	(!CheckKeyTypes(client,xkb,req,(xkbKeyTypeWireDesc **)&values,
-						&nTypes,mapWidths))) {
-	client->errorValue = nTypes;
-	return BadValue;
+        (!CheckKeyTypes(client, xkb, req, (xkbKeyTypeWireDesc **) & values,
+                        &nTypes, mapWidths))) {
+        client->errorValue = nTypes;
+        return BadValue;
     }
 
     /* symsPerKey/mapWidths must be filled regardless of client-side flags */
     map = &xkb->map->key_sym_map[xkb->min_key_code];
-    for (i=xkb->min_key_code;i<xkb->max_key_code;i++,map++) {
-	register int g,ng,w;
-	ng= XkbNumGroups(map->group_info);
-	for (w=g=0;g<ng;g++) {
-	    if (map->kt_index[g]>=(unsigned)nTypes) {
-		client->errorValue = _XkbErrCode4(0x13,i,g,map->kt_index[g]);
-		return 0;
-	    }
-	    if (mapWidths[map->kt_index[g]]>w)
-		w= mapWidths[map->kt_index[g]];
-	}
-	symsPerKey[i] = w*ng;
+    for (i = xkb->min_key_code; i < xkb->max_key_code; i++, map++) {
+        register int g, ng, w;
+
+        ng = XkbNumGroups(map->group_info);
+        for (w = g = 0; g < ng; g++) {
+            if (map->kt_index[g] >= (unsigned) nTypes) {
+                client->errorValue = _XkbErrCode4(0x13, i, g, map->kt_index[g]);
+                return 0;
+            }
+            if (mapWidths[map->kt_index[g]] > w)
+                w = mapWidths[map->kt_index[g]];
+        }
+        symsPerKey[i] = w * ng;
     }
 
     if ((req->present & XkbKeySymsMask) &&
-	(!CheckKeySyms(client,xkb,req,nTypes,mapWidths,symsPerKey,
-					(xkbSymMapWireDesc **)&values,&error))) {
-	client->errorValue = error;
-	return BadValue;
+        (!CheckKeySyms(client, xkb, req, nTypes, mapWidths, symsPerKey,
+                       (xkbSymMapWireDesc **) & values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
 
     if ((req->present & XkbKeyActionsMask) &&
-	(!CheckKeyActions(xkb,req,nTypes,mapWidths,symsPerKey,
-						(CARD8 **)&values,&nActions))) {
-	client->errorValue = nActions;
-	return BadValue;
+        (!CheckKeyActions(xkb, req, nTypes, mapWidths, symsPerKey,
+                          (CARD8 **) &values, &nActions))) {
+        client->errorValue = nActions;
+        return BadValue;
     }
 
     if ((req->present & XkbKeyBehaviorsMask) &&
-	(!CheckKeyBehaviors(xkb,req,(xkbBehaviorWireDesc**)&values,&error))) {
-	client->errorValue = error;
-	return BadValue;
+        (!CheckKeyBehaviors
+         (xkb, req, (xkbBehaviorWireDesc **) & values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
 
     if ((req->present & XkbVirtualModsMask) &&
-	(!CheckVirtualMods(xkb,req,(CARD8 **)&values,&error))) {
-	client->errorValue= error;
-	return BadValue;
+        (!CheckVirtualMods(xkb, req, (CARD8 **) &values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
-    if ((req->present&XkbExplicitComponentsMask) &&
-	(!CheckKeyExplicit(xkb,req,(CARD8 **)&values,&error))) {
-	client->errorValue= error;
-	return BadValue;
+    if ((req->present & XkbExplicitComponentsMask) &&
+        (!CheckKeyExplicit(xkb, req, (CARD8 **) &values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
-    if ((req->present&XkbModifierMapMask) &&
-	(!CheckModifierMap(xkb,req,(CARD8 **)&values,&error))) {
-	client->errorValue= error;
-	return BadValue;
+    if ((req->present & XkbModifierMapMask) &&
+        (!CheckModifierMap(xkb, req, (CARD8 **) &values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
-    if ((req->present&XkbVirtualModMapMask) &&
-	(!CheckVirtualModMap(xkb,req,(xkbVModMapWireDesc **)&values,&error))) {
-	client->errorValue= error;
-	return BadValue;
+    if ((req->present & XkbVirtualModMapMask) &&
+        (!CheckVirtualModMap
+         (xkb, req, (xkbVModMapWireDesc **) & values, &error))) {
+        client->errorValue = error;
+        return BadValue;
     }
 
-    if (((values-((char *)req))/4)!= req->length) {
-	ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after check)\n");
-	client->errorValue = values-((char *)&req[1]);
-	return BadLength;
+    if (((values - ((char *) req)) / 4) != req->length) {
+        ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after check)\n");
+        client->errorValue = values - ((char *) &req[1]);
+        return BadLength;
     }
 
     return Success;
@@ -2426,124 +2480,137 @@ _XkbSetMapChecks(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char* va
  * Apply the given request on the given device.
  */
 static int
-_XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq *req, char *values)
+_XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, char *values)
 {
-    XkbEventCauseRec	cause;
-    XkbChangesRec	change;
-    Bool		sentNKN;
-    XkbSrvInfoPtr       xkbi;
-    XkbDescPtr          xkb;
+    XkbEventCauseRec cause;
+    XkbChangesRec change;
+    Bool sentNKN;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
 
-    xkbi= dev->key->xkbInfo;
+    xkbi = dev->key->xkbInfo;
     xkb = xkbi->desc;
 
-    XkbSetCauseXkbReq(&cause,X_kbSetMap,client);
+    XkbSetCauseXkbReq(&cause, X_kbSetMap, client);
     memset(&change, 0, sizeof(change));
     sentNKN = FALSE;
-    if ((xkb->min_key_code!=req->minKeyCode)||
-        (xkb->max_key_code!=req->maxKeyCode)) {
-	Status			status;
-	xkbNewKeyboardNotify	nkn;
-	nkn.deviceID = nkn.oldDeviceID = dev->id;
-	nkn.oldMinKeyCode = xkb->min_key_code;
-	nkn.oldMaxKeyCode = xkb->max_key_code;
-	status= XkbChangeKeycodeRange(xkb, req->minKeyCode,
-                                      req->maxKeyCode, &change);
-	if (status != Success)
-	    return status; /* oh-oh. what about the other keyboards? */
-	nkn.minKeyCode = xkb->min_key_code;
-	nkn.maxKeyCode = xkb->max_key_code;
-	nkn.requestMajor = XkbReqCode;
-	nkn.requestMinor = X_kbSetMap;
-	nkn.changed = XkbNKN_KeycodesMask;
-	XkbSendNewKeyboardNotify(dev,&nkn);
-	sentNKN = TRUE;
-    }
-
-    if (req->present&XkbKeyTypesMask) {
-	values = SetKeyTypes(xkb,req,(xkbKeyTypeWireDesc *)values,&change);
-	if (!values)	goto allocFailure;
-    }
-    if (req->present&XkbKeySymsMask) {
-	values = SetKeySyms(client,xkb,req,(xkbSymMapWireDesc *)values,&change,dev);
-	if (!values)	goto allocFailure;
-    }
-    if (req->present&XkbKeyActionsMask) {
-	values = SetKeyActions(xkb,req,(CARD8 *)values,&change);
-	if (!values)	goto allocFailure;
-    }
-    if (req->present&XkbKeyBehaviorsMask) {
-	values= SetKeyBehaviors(xkbi,req,(xkbBehaviorWireDesc *)values,&change);
-	if (!values)	goto allocFailure;
-    }
-    if (req->present&XkbVirtualModsMask)
-	values= SetVirtualMods(xkbi,req,(CARD8 *)values,&change);
-    if (req->present&XkbExplicitComponentsMask)
-	values= SetKeyExplicit(xkbi,req,(CARD8 *)values,&change);
-    if (req->present&XkbModifierMapMask)
-	values= SetModifierMap(xkbi,req,(CARD8 *)values,&change);
-    if (req->present&XkbVirtualModMapMask)
-	values= SetVirtualModMap(xkbi,req,(xkbVModMapWireDesc *)values,&change);
-    if (((values-((char *)req))/4)!=req->length) {
-	ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after set)\n");
-	client->errorValue = values-((char *)&req[1]);
-	return BadLength;
-    }
-    if (req->flags&XkbSetMapRecomputeActions) {
-	KeyCode		first,last,firstMM,lastMM;
-	if (change.map.num_key_syms>0) {
-	    first= change.map.first_key_sym;
-	    last= first+change.map.num_key_syms-1;
-	}
-	else first= last= 0;
-	if (change.map.num_modmap_keys>0) {
-	    firstMM= change.map.first_modmap_key;
-	    lastMM= first+change.map.num_modmap_keys-1;
-	}
-	else firstMM= lastMM= 0;
-	if ((last>0) && (lastMM>0)) {
-	    if (firstMM<first)
-		first= firstMM;
-	    if (lastMM>last)
-		last= lastMM;
-	}
-	else if (lastMM>0) {
-	    first= firstMM;
-	    last= lastMM;
-	}
-	if (last>0) {
-	    unsigned check= 0;
-	    XkbUpdateActions(dev,first,(last-first+1),&change,&check,&cause);
-	    if (check)
-		XkbCheckSecondaryEffects(xkbi,check,&change,&cause);
-	}
+    if ((xkb->min_key_code != req->minKeyCode) ||
+        (xkb->max_key_code != req->maxKeyCode)) {
+        Status status;
+        xkbNewKeyboardNotify nkn;
+
+        nkn.deviceID = nkn.oldDeviceID = dev->id;
+        nkn.oldMinKeyCode = xkb->min_key_code;
+        nkn.oldMaxKeyCode = xkb->max_key_code;
+        status = XkbChangeKeycodeRange(xkb, req->minKeyCode,
+                                       req->maxKeyCode, &change);
+        if (status != Success)
+            return status;      /* oh-oh. what about the other keyboards? */
+        nkn.minKeyCode = xkb->min_key_code;
+        nkn.maxKeyCode = xkb->max_key_code;
+        nkn.requestMajor = XkbReqCode;
+        nkn.requestMinor = X_kbSetMap;
+        nkn.changed = XkbNKN_KeycodesMask;
+        XkbSendNewKeyboardNotify(dev, &nkn);
+        sentNKN = TRUE;
+    }
+
+    if (req->present & XkbKeyTypesMask) {
+        values = SetKeyTypes(xkb, req, (xkbKeyTypeWireDesc *) values, &change);
+        if (!values)
+            goto allocFailure;
+    }
+    if (req->present & XkbKeySymsMask) {
+        values =
+            SetKeySyms(client, xkb, req, (xkbSymMapWireDesc *) values, &change,
+                       dev);
+        if (!values)
+            goto allocFailure;
+    }
+    if (req->present & XkbKeyActionsMask) {
+        values = SetKeyActions(xkb, req, (CARD8 *) values, &change);
+        if (!values)
+            goto allocFailure;
+    }
+    if (req->present & XkbKeyBehaviorsMask) {
+        values =
+            SetKeyBehaviors(xkbi, req, (xkbBehaviorWireDesc *) values, &change);
+        if (!values)
+            goto allocFailure;
+    }
+    if (req->present & XkbVirtualModsMask)
+        values = SetVirtualMods(xkbi, req, (CARD8 *) values, &change);
+    if (req->present & XkbExplicitComponentsMask)
+        values = SetKeyExplicit(xkbi, req, (CARD8 *) values, &change);
+    if (req->present & XkbModifierMapMask)
+        values = SetModifierMap(xkbi, req, (CARD8 *) values, &change);
+    if (req->present & XkbVirtualModMapMask)
+        values =
+            SetVirtualModMap(xkbi, req, (xkbVModMapWireDesc *) values, &change);
+    if (((values - ((char *) req)) / 4) != req->length) {
+        ErrorF("[xkb] Internal error! Bad length in XkbSetMap (after set)\n");
+        client->errorValue = values - ((char *) &req[1]);
+        return BadLength;
+    }
+    if (req->flags & XkbSetMapRecomputeActions) {
+        KeyCode first, last, firstMM, lastMM;
+
+        if (change.map.num_key_syms > 0) {
+            first = change.map.first_key_sym;
+            last = first + change.map.num_key_syms - 1;
+        }
+        else
+            first = last = 0;
+        if (change.map.num_modmap_keys > 0) {
+            firstMM = change.map.first_modmap_key;
+            lastMM = first + change.map.num_modmap_keys - 1;
+        }
+        else
+            firstMM = lastMM = 0;
+        if ((last > 0) && (lastMM > 0)) {
+            if (firstMM < first)
+                first = firstMM;
+            if (lastMM > last)
+                last = lastMM;
+        }
+        else if (lastMM > 0) {
+            first = firstMM;
+            last = lastMM;
+        }
+        if (last > 0) {
+            unsigned check = 0;
+
+            XkbUpdateActions(dev, first, (last - first + 1), &change, &check,
+                             &cause);
+            if (check)
+                XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
+        }
     }
     if (!sentNKN)
-	XkbSendNotification(dev,&change,&cause);
+        XkbSendNotification(dev, &change, &cause);
 
     return Success;
-allocFailure:
+ allocFailure:
     return BadAlloc;
 }
 
-
 int
 ProcXkbSetMap(ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    char *		tmp;
-    int                 rc;
+    DeviceIntPtr dev;
+    char *tmp;
+    int rc;
 
     REQUEST(xkbSetMapReq);
     REQUEST_AT_LEAST_SIZE(xkbSetMapReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
-    CHK_MASK_LEGAL(0x01,stuff->present,XkbAllMapComponentsMask);
+    CHK_MASK_LEGAL(0x01, stuff->present, XkbAllMapComponentsMask);
 
-    tmp = (char *)&stuff[1];
+    tmp = (char *) &stuff[1];
 
     /* Check if we can to the SetMap on the requested device. If this
        succeeds, do the same thing for all extension devices (if needed).
@@ -2553,16 +2620,15 @@ ProcXkbSetMap(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     rc = _XkbSetMapChecks(client, other, stuff, tmp);
                     if (rc != Success)
                         return rc;
@@ -2576,14 +2642,14 @@ ProcXkbSetMap(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
                 if (rc == Success)
                     _XkbSetMap(client, other, stuff, tmp);
                 /* ignore rc. if the SetMap failed although the check above
@@ -2600,84 +2666,88 @@ ProcXkbSetMap(ClientPtr client)
 /***====================================================================***/
 
 static Status
-XkbComputeGetCompatMapReplySize(	XkbCompatMapPtr 	compat,
-					xkbGetCompatMapReply *	rep)
+XkbComputeGetCompatMapReplySize(XkbCompatMapPtr compat,
+                                xkbGetCompatMapReply * rep)
 {
-unsigned	 size,nGroups;
-
-    nGroups= 0;
-    if (rep->groups!=0) {
-	register int i,bit;
-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-	    if (rep->groups&bit)
-		nGroups++;
-	}
-    }
-    size= nGroups*SIZEOF(xkbModsWireDesc);
-    size+= (rep->nSI*SIZEOF(xkbSymInterpretWireDesc));
-    rep->length= size/4;
+    unsigned size, nGroups;
+
+    nGroups = 0;
+    if (rep->groups != 0) {
+        register int i, bit;
+
+        for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+            if (rep->groups & bit)
+                nGroups++;
+        }
+    }
+    size = nGroups * SIZEOF(xkbModsWireDesc);
+    size += (rep->nSI * SIZEOF(xkbSymInterpretWireDesc));
+    rep->length = size / 4;
     return Success;
 }
 
 static int
-XkbSendCompatMap(	ClientPtr 		client,
-			XkbCompatMapPtr 	compat,
-			xkbGetCompatMapReply *	rep)
+XkbSendCompatMap(ClientPtr client,
+                 XkbCompatMapPtr compat, xkbGetCompatMapReply * rep)
 {
-char	*	data;
-int		size;
-
-    size= rep->length*4;
-    if (size>0) {
-	data = malloc(size);
-	if (data) {
-	    register unsigned i,bit;
-	    xkbModsWireDesc *	grp;
-	    XkbSymInterpretPtr	sym= &compat->sym_interpret[rep->firstSI];
-	    xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
-	    for (i=0;i<rep->nSI;i++,sym++,wire++) {
-		wire->sym= sym->sym;
-		wire->mods= sym->mods;
-		wire->match= sym->match;
-		wire->virtualMod= sym->virtual_mod;
-		wire->flags= sym->flags;
-		memcpy((char*)&wire->act,(char*)&sym->act,sz_xkbActionWireDesc);
-		if (client->swapped) {
-		    swapl(&wire->sym);
-		}
-	    }
-	    if (rep->groups) {
-		grp = (xkbModsWireDesc *)wire;
-		for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-		    if (rep->groups&bit) {
-			grp->mask= compat->groups[i].mask;
-			grp->realMods= compat->groups[i].real_mods;
-			grp->virtualMods= compat->groups[i].vmods;
-			if (client->swapped) {
-			    swaps(&grp->virtualMods);
-			}
-			grp++;
-		    }
-		}
-		wire= (xkbSymInterpretWireDesc*)grp;
-	    }
-	}
-	else return BadAlloc;
-    }
-    else data= NULL;
+    char *data;
+    int size;
+
+    size = rep->length * 4;
+    if (size > 0) {
+        data = malloc(size);
+        if (data) {
+            register unsigned i, bit;
+            xkbModsWireDesc *grp;
+            XkbSymInterpretPtr sym = &compat->sym_interpret[rep->firstSI];
+            xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
+
+            for (i = 0; i < rep->nSI; i++, sym++, wire++) {
+                wire->sym = sym->sym;
+                wire->mods = sym->mods;
+                wire->match = sym->match;
+                wire->virtualMod = sym->virtual_mod;
+                wire->flags = sym->flags;
+                memcpy((char *) &wire->act, (char *) &sym->act,
+                       sz_xkbActionWireDesc);
+                if (client->swapped) {
+                    swapl(&wire->sym);
+                }
+            }
+            if (rep->groups) {
+                grp = (xkbModsWireDesc *) wire;
+                for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+                    if (rep->groups & bit) {
+                        grp->mask = compat->groups[i].mask;
+                        grp->realMods = compat->groups[i].real_mods;
+                        grp->virtualMods = compat->groups[i].vmods;
+                        if (client->swapped) {
+                            swaps(&grp->virtualMods);
+                        }
+                        grp++;
+                    }
+                }
+                wire = (xkbSymInterpretWireDesc *) grp;
+            }
+        }
+        else
+            return BadAlloc;
+    }
+    else
+        data = NULL;
 
     if (client->swapped) {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swaps(&rep->firstSI);
-	swaps(&rep->nSI);
-	swaps(&rep->nTotalSI);
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swaps(&rep->firstSI);
+        swaps(&rep->nSI);
+        swaps(&rep->nTotalSI);
     }
 
-    WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *)rep);
+    WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *) rep);
     if (data) {
-	WriteToClient(client, size, data);
-	free((char *)data);
+        WriteToClient(client, size, data);
+        free((char *) data);
     }
     return Success;
 }
@@ -2685,21 +2755,21 @@ int		size;
 int
 ProcXkbGetCompatMap(ClientPtr client)
 {
-    xkbGetCompatMapReply 	rep;
-    DeviceIntPtr 		dev;
-    XkbDescPtr			xkb;
-    XkbCompatMapPtr		compat;
+    xkbGetCompatMapReply rep;
+    DeviceIntPtr dev;
+    XkbDescPtr xkb;
+    XkbCompatMapPtr compat;
 
     REQUEST(xkbGetCompatMapReq);
     REQUEST_SIZE_MATCH(xkbGetCompatMapReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
 
     xkb = dev->key->xkbInfo->desc;
-    compat= xkb->compat;
+    compat = xkb->compat;
 
     rep.type = X_Reply;
     rep.deviceID = dev->id;
@@ -2708,18 +2778,18 @@ ProcXkbGetCompatMap(ClientPtr client)
     rep.firstSI = stuff->firstSI;
     rep.nSI = stuff->nSI;
     if (stuff->getAllSI) {
-	rep.firstSI = 0;
-	rep.nSI = compat->num_si;
+        rep.firstSI = 0;
+        rep.nSI = compat->num_si;
     }
-    else if ((((unsigned)stuff->nSI)>0)&&
-		((unsigned)(stuff->firstSI+stuff->nSI-1)>=compat->num_si)) {
-	client->errorValue = _XkbErrCode2(0x05,compat->num_si);
-	return BadValue;
+    else if ((((unsigned) stuff->nSI) > 0) &&
+             ((unsigned) (stuff->firstSI + stuff->nSI - 1) >= compat->num_si)) {
+        client->errorValue = _XkbErrCode2(0x05, compat->num_si);
+        return BadValue;
     }
     rep.nTotalSI = compat->num_si;
-    rep.groups= stuff->groups;
-    XkbComputeGetCompatMapReplySize(compat,&rep);
-    return XkbSendCompatMap(client,compat,&rep);
+    rep.groups = stuff->groups;
+    XkbComputeGetCompatMapReplySize(compat, &rep);
+    return XkbSendCompatMap(client, compat, &rep);
 }
 
 /**
@@ -2729,146 +2799,152 @@ ProcXkbGetCompatMap(ClientPtr client)
  */
 static int
 _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
-                 xkbSetCompatMapReq *req, char* data, BOOL dryRun)
+                 xkbSetCompatMapReq * req, char *data, BOOL dryRun)
 {
-    XkbSrvInfoPtr       xkbi;
-    XkbDescPtr          xkb;
-    XkbCompatMapPtr     compat;
-    int                 nGroups;
-    unsigned            i,bit;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
+    XkbCompatMapPtr compat;
+    int nGroups;
+    unsigned i, bit;
 
     xkbi = dev->key->xkbInfo;
     xkb = xkbi->desc;
     compat = xkb->compat;
 
-    if ((req->nSI>0)||(req->truncateSI)) {
-	xkbSymInterpretWireDesc *wire;
-	if (req->firstSI>compat->num_si) {
-	    client->errorValue = _XkbErrCode2(0x02,compat->num_si);
-	    return BadValue;
-	}
-	wire= (xkbSymInterpretWireDesc *)data;
-	wire+= req->nSI;
-	data = (char *)wire;
+    if ((req->nSI > 0) || (req->truncateSI)) {
+        xkbSymInterpretWireDesc *wire;
+
+        if (req->firstSI > compat->num_si) {
+            client->errorValue = _XkbErrCode2(0x02, compat->num_si);
+            return BadValue;
+        }
+        wire = (xkbSymInterpretWireDesc *) data;
+        wire += req->nSI;
+        data = (char *) wire;
     }
 
-    nGroups= 0;
-    if (req->groups!=0) {
-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-	    if ( req->groups&bit )
-		nGroups++;
-	}
+    nGroups = 0;
+    if (req->groups != 0) {
+        for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+            if (req->groups & bit)
+                nGroups++;
+        }
     }
-    data+= nGroups*SIZEOF(xkbModsWireDesc);
-    if (((data-((char *)req))/4)!=req->length) {
-	return BadLength;
+    data += nGroups * SIZEOF(xkbModsWireDesc);
+    if (((data - ((char *) req)) / 4) != req->length) {
+        return BadLength;
     }
 
     /* Done all the checks we can do */
     if (dryRun)
         return Success;
 
-    data = (char *)&req[1];
-    if (req->nSI>0) {
-	xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *)data;
-	XkbSymInterpretPtr	sym;
-	unsigned int		skipped = 0;
-	if ((unsigned)(req->firstSI+req->nSI)>compat->num_si) {
-	    compat->num_si= req->firstSI+req->nSI;
-	    compat->sym_interpret= realloc(compat->sym_interpret,
-					    compat->num_si * sizeof(XkbSymInterpretRec));
-	    if (!compat->sym_interpret) {
-		compat->num_si= 0;
-		return BadAlloc;
-	    }
-	}
-	else if (req->truncateSI) {
-	    compat->num_si = req->firstSI+req->nSI;
-	}
-	sym = &compat->sym_interpret[req->firstSI];
-	for (i=0;i<req->nSI;i++,wire++) {
-	    if (client->swapped) {
-		swapl(&wire->sym);
-	    }
-	    if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
-		(wire->mods & 0xff) == 0xff &&
-		wire->act.type == XkbSA_XFree86Private) {
-		ErrorF("XKB: Skipping broken Any+AnyOfOrNone(All) -> Private "
-		       "action from client\n");
-		skipped++;
-		continue;
-	    }
-	    sym->sym= wire->sym;
-	    sym->mods= wire->mods;
-	    sym->match= wire->match;
-	    sym->flags= wire->flags;
-	    sym->virtual_mod= wire->virtualMod;
-	    memcpy((char *)&sym->act,(char *)&wire->act,
+    data = (char *) &req[1];
+    if (req->nSI > 0) {
+        xkbSymInterpretWireDesc *wire = (xkbSymInterpretWireDesc *) data;
+        XkbSymInterpretPtr sym;
+        unsigned int skipped = 0;
+
+        if ((unsigned) (req->firstSI + req->nSI) > compat->num_si) {
+            compat->num_si = req->firstSI + req->nSI;
+            compat->sym_interpret = realloc(compat->sym_interpret,
+                                            compat->num_si *
+                                            sizeof(XkbSymInterpretRec));
+            if (!compat->sym_interpret) {
+                compat->num_si = 0;
+                return BadAlloc;
+            }
+        }
+        else if (req->truncateSI) {
+            compat->num_si = req->firstSI + req->nSI;
+        }
+        sym = &compat->sym_interpret[req->firstSI];
+        for (i = 0; i < req->nSI; i++, wire++) {
+            if (client->swapped) {
+                swapl(&wire->sym);
+            }
+            if (wire->sym == NoSymbol && wire->match == XkbSI_AnyOfOrNone &&
+                (wire->mods & 0xff) == 0xff &&
+                wire->act.type == XkbSA_XFree86Private) {
+                ErrorF("XKB: Skipping broken Any+AnyOfOrNone(All) -> Private "
+                       "action from client\n");
+                skipped++;
+                continue;
+            }
+            sym->sym = wire->sym;
+            sym->mods = wire->mods;
+            sym->match = wire->match;
+            sym->flags = wire->flags;
+            sym->virtual_mod = wire->virtualMod;
+            memcpy((char *) &sym->act, (char *) &wire->act,
                    SIZEOF(xkbActionWireDesc));
             sym++;
-	}
-	if (skipped) {
-	    if (req->firstSI + req->nSI < compat->num_si)
-		memmove(sym, sym + skipped,
-	                (compat->num_si - req->firstSI - req->nSI) *
-			 sizeof(*sym));
-	    compat->num_si -= skipped;
-	}
-	data = (char *)wire;
+        }
+        if (skipped) {
+            if (req->firstSI + req->nSI < compat->num_si)
+                memmove(sym, sym + skipped,
+                        (compat->num_si - req->firstSI - req->nSI) *
+                        sizeof(*sym));
+            compat->num_si -= skipped;
+        }
+        data = (char *) wire;
     }
     else if (req->truncateSI) {
-	compat->num_si = req->firstSI;
-    }
-
-    if (req->groups!=0) {
-	unsigned i, bit;
-	xkbModsWireDesc *wire = (xkbModsWireDesc *)data;
-	for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
-	    if (req->groups & bit) {
-		if (client->swapped) {
-		    swaps(&wire->virtualMods);
-		}
-		compat->groups[i].mask= wire->realMods;
-		compat->groups[i].real_mods= wire->realMods;
-		compat->groups[i].vmods= wire->virtualMods;
-		if (wire->virtualMods!=0) {
-		    unsigned tmp;
-		    tmp= XkbMaskForVMask(xkb,wire->virtualMods);
-		    compat->groups[i].mask|= tmp;
-		}
-		data+= SIZEOF(xkbModsWireDesc);
-		wire= (xkbModsWireDesc *)data;
-	    }
-	}
-    }
-    i= XkbPaddedSize((data-((char *)req)));
-    if ((i/4)!=req->length) {
-	ErrorF("[xkb] Internal length error on read in _XkbSetCompatMap\n");
-	return BadLength;
+        compat->num_si = req->firstSI;
+    }
+
+    if (req->groups != 0) {
+        unsigned i, bit;
+        xkbModsWireDesc *wire = (xkbModsWireDesc *) data;
+
+        for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+            if (req->groups & bit) {
+                if (client->swapped) {
+                    swaps(&wire->virtualMods);
+                }
+                compat->groups[i].mask = wire->realMods;
+                compat->groups[i].real_mods = wire->realMods;
+                compat->groups[i].vmods = wire->virtualMods;
+                if (wire->virtualMods != 0) {
+                    unsigned tmp;
+
+                    tmp = XkbMaskForVMask(xkb, wire->virtualMods);
+                    compat->groups[i].mask |= tmp;
+                }
+                data += SIZEOF(xkbModsWireDesc);
+                wire = (xkbModsWireDesc *) data;
+            }
+        }
+    }
+    i = XkbPaddedSize((data - ((char *) req)));
+    if ((i / 4) != req->length) {
+        ErrorF("[xkb] Internal length error on read in _XkbSetCompatMap\n");
+        return BadLength;
     }
 
     if (dev->xkb_interest) {
-	xkbCompatMapNotify ev;
-	ev.deviceID = dev->id;
-	ev.changedGroups = req->groups;
-	ev.firstSI = req->firstSI;
-	ev.nSI = req->nSI;
-	ev.nTotalSI = compat->num_si;
-	XkbSendCompatMapNotify(dev,&ev);
+        xkbCompatMapNotify ev;
+
+        ev.deviceID = dev->id;
+        ev.changedGroups = req->groups;
+        ev.firstSI = req->firstSI;
+        ev.nSI = req->nSI;
+        ev.nTotalSI = compat->num_si;
+        XkbSendCompatMapNotify(dev, &ev);
     }
 
     if (req->recomputeActions) {
-	XkbChangesRec		change;
-	unsigned		check;
-	XkbEventCauseRec	cause;
-
-	XkbSetCauseXkbReq(&cause,X_kbSetCompatMap,client);
-	memset(&change, 0, sizeof(XkbChangesRec));
-	XkbUpdateActions(dev,xkb->min_key_code,XkbNumKeys(xkb),&change,&check,
-									&cause);
-	if (check)
-	    XkbCheckSecondaryEffects(xkbi,check,&change,&cause);
-	XkbSendNotification(dev,&change,&cause);
+        XkbChangesRec change;
+        unsigned check;
+        XkbEventCauseRec cause;
+
+        XkbSetCauseXkbReq(&cause, X_kbSetCompatMap, client);
+        memset(&change, 0, sizeof(XkbChangesRec));
+        XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &change,
+                         &check, &cause);
+        if (check)
+            XkbCheckSecondaryEffects(xkbi, check, &change, &cause);
+        XkbSendNotification(dev, &change, &cause);
     }
     return Success;
 }
@@ -2876,34 +2952,33 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetCompatMap(ClientPtr client)
 {
-    DeviceIntPtr        dev;
-    char                *data;
-    int                 rc;
+    DeviceIntPtr dev;
+    char *data;
+    int rc;
 
     REQUEST(xkbSetCompatMapReq);
     REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
 
-    data = (char *)&stuff[1];
+    data = (char *) &stuff[1];
 
     /* check first using a dry-run */
     rc = _XkbSetCompatMap(client, dev, stuff, data, TRUE);
     if (rc != Success)
         return rc;
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     /* dry-run */
                     rc = _XkbSetCompatMap(client, other, stuff, data, TRUE);
                     if (rc != Success)
@@ -2917,16 +2992,15 @@ ProcXkbSetCompatMap(ClientPtr client)
     rc = _XkbSetCompatMap(client, dev, stuff, data, FALSE);
     if (rc != Success)
         return rc;
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     rc = _XkbSetCompatMap(client, other, stuff, data, FALSE);
                     if (rc != Success)
                         return rc;
@@ -2943,22 +3017,22 @@ ProcXkbSetCompatMap(ClientPtr client)
 int
 ProcXkbGetIndicatorState(ClientPtr client)
 {
-    xkbGetIndicatorStateReply 	rep;
-    XkbSrvLedInfoPtr		sli;
-    DeviceIntPtr 		dev;
+    xkbGetIndicatorStateReply rep;
+    XkbSrvLedInfoPtr sli;
+    DeviceIntPtr dev;
 
     REQUEST(xkbGetIndicatorStateReq);
     REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess);
 
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,
-						XkbXI_IndicatorStateMask);
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+                            XkbXI_IndicatorStateMask);
     if (!sli)
-	return BadAlloc;
+        return BadAlloc;
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
@@ -2967,85 +3041,87 @@ ProcXkbGetIndicatorState(ClientPtr client)
     rep.state = sli->effectiveState;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.state);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.state);
     }
-    WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *)&rep);
+    WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *) &rep);
     return Success;
 }
 
 /***====================================================================***/
 
 static Status
-XkbComputeGetIndicatorMapReplySize(
-    XkbIndicatorPtr		indicators,
-    xkbGetIndicatorMapReply	*rep)
+XkbComputeGetIndicatorMapReplySize(XkbIndicatorPtr indicators,
+                                   xkbGetIndicatorMapReply * rep)
 {
-register int 	i,bit;
-int		nIndicators;
+    register int i, bit;
+    int nIndicators;
 
     rep->realIndicators = indicators->phys_indicators;
-    for (i=nIndicators=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-	if (rep->which&bit)
-	    nIndicators++;
+    for (i = nIndicators = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+        if (rep->which & bit)
+            nIndicators++;
     }
-    rep->length = (nIndicators*SIZEOF(xkbIndicatorMapWireDesc))/4;
+    rep->length = (nIndicators * SIZEOF(xkbIndicatorMapWireDesc)) / 4;
     return Success;
 }
 
 static int
-XkbSendIndicatorMap(	ClientPtr			client,
-			XkbIndicatorPtr			indicators,
-			xkbGetIndicatorMapReply *	rep)
+XkbSendIndicatorMap(ClientPtr client,
+                    XkbIndicatorPtr indicators, xkbGetIndicatorMapReply * rep)
 {
-int 			length;
-CARD8 *			map;
-register int		i;
-register unsigned	bit;
-
-    length = rep->length*4;
-    if (length>0) {
-	CARD8 *to;
-	to= map= malloc(length);
-	if (map) {
-	    xkbIndicatorMapWireDesc  *wire = (xkbIndicatorMapWireDesc *)to;
-	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-		if (rep->which&bit) {
-		    wire->flags= indicators->maps[i].flags;
-		    wire->whichGroups= indicators->maps[i].which_groups;
-		    wire->groups= indicators->maps[i].groups;
-		    wire->whichMods= indicators->maps[i].which_mods;
-		    wire->mods= indicators->maps[i].mods.mask;
-		    wire->realMods= indicators->maps[i].mods.real_mods;
-		    wire->virtualMods= indicators->maps[i].mods.vmods;
-		    wire->ctrls= indicators->maps[i].ctrls;
-		    if (client->swapped) {
-			swaps(&wire->virtualMods);
-			swapl(&wire->ctrls);
-		    }
-		    wire++;
-		}
-	    }
-	    to = (CARD8 *)wire;
-	    if ((to-map)!=length) {
-		client->errorValue = _XkbErrCode2(0xff,length);
-		free(map);
-		return BadLength;
-	    }
-	}
-	else return BadAlloc;
-    }
-    else map = NULL;
+    int length;
+    CARD8 *map;
+    register int i;
+    register unsigned bit;
+
+    length = rep->length * 4;
+    if (length > 0) {
+        CARD8 *to;
+
+        to = map = malloc(length);
+        if (map) {
+            xkbIndicatorMapWireDesc *wire = (xkbIndicatorMapWireDesc *) to;
+
+            for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+                if (rep->which & bit) {
+                    wire->flags = indicators->maps[i].flags;
+                    wire->whichGroups = indicators->maps[i].which_groups;
+                    wire->groups = indicators->maps[i].groups;
+                    wire->whichMods = indicators->maps[i].which_mods;
+                    wire->mods = indicators->maps[i].mods.mask;
+                    wire->realMods = indicators->maps[i].mods.real_mods;
+                    wire->virtualMods = indicators->maps[i].mods.vmods;
+                    wire->ctrls = indicators->maps[i].ctrls;
+                    if (client->swapped) {
+                        swaps(&wire->virtualMods);
+                        swapl(&wire->ctrls);
+                    }
+                    wire++;
+                }
+            }
+            to = (CARD8 *) wire;
+            if ((to - map) != length) {
+                client->errorValue = _XkbErrCode2(0xff, length);
+                free(map);
+                return BadLength;
+            }
+        }
+        else
+            return BadAlloc;
+    }
+    else
+        map = NULL;
     if (client->swapped) {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swapl(&rep->which);
-	swapl(&rep->realIndicators);
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swapl(&rep->which);
+        swapl(&rep->realIndicators);
     }
-    WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *)rep);
+    WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *) rep);
     if (map) {
-	WriteToClient(client, length, (char *)map);
-	free((char *)map);
+        WriteToClient(client, length, (char *) map);
+        free((char *) map);
     }
     return Success;
 }
@@ -3053,29 +3129,29 @@ register unsigned	bit;
 int
 ProcXkbGetIndicatorMap(ClientPtr client)
 {
-xkbGetIndicatorMapReply rep;
-DeviceIntPtr		dev;
-XkbDescPtr		xkb;
-XkbIndicatorPtr		leds;
+    xkbGetIndicatorMapReply rep;
+    DeviceIntPtr dev;
+    XkbDescPtr xkb;
+    XkbIndicatorPtr leds;
 
     REQUEST(xkbGetIndicatorMapReq);
     REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
 
-    xkb= dev->key->xkbInfo->desc;
-    leds= xkb->indicators;
+    xkb = dev->key->xkbInfo->desc;
+    leds = xkb->indicators;
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.length = 0;
     rep.deviceID = dev->id;
     rep.which = stuff->which;
-    XkbComputeGetIndicatorMapReplySize(leds,&rep);
-    return XkbSendIndicatorMap(client,leds,&rep);
+    XkbComputeGetIndicatorMapReplySize(leds, &rep);
+    return XkbSendIndicatorMap(client, leds, &rep);
 }
 
 /**
@@ -3084,41 +3160,42 @@ XkbIndicatorPtr		leds;
  */
 static int
 _XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
-                    int which, xkbIndicatorMapWireDesc *desc)
+                    int which, xkbIndicatorMapWireDesc * desc)
 {
-    XkbSrvInfoPtr       xkbi;
-    XkbSrvLedInfoPtr    sli;
-    XkbEventCauseRec    cause;
-    int                 i, bit;
+    XkbSrvInfoPtr xkbi;
+    XkbSrvLedInfoPtr sli;
+    XkbEventCauseRec cause;
+    int i, bit;
 
     xkbi = dev->key->xkbInfo;
 
-    sli= XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
-						XkbXI_IndicatorMapsMask);
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+                            XkbXI_IndicatorMapsMask);
     if (!sli)
-	return BadAlloc;
+        return BadAlloc;
 
     for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
-	if (which & bit) {
-	    sli->maps[i].flags = desc->flags;
-	    sli->maps[i].which_groups = desc->whichGroups;
-	    sli->maps[i].groups = desc->groups;
-	    sli->maps[i].which_mods = desc->whichMods;
-	    sli->maps[i].mods.mask = desc->mods;
-	    sli->maps[i].mods.real_mods = desc->mods;
-	    sli->maps[i].mods.vmods= desc->virtualMods;
-	    sli->maps[i].ctrls = desc->ctrls;
-	    if (desc->virtualMods!=0) {
-		unsigned tmp;
-		tmp= XkbMaskForVMask(xkbi->desc,desc->virtualMods);
-		sli->maps[i].mods.mask= desc->mods|tmp;
-	    }
-	    desc++;
-	}
-    }
-
-    XkbSetCauseXkbReq(&cause,X_kbSetIndicatorMap,client);
-    XkbApplyLedMapChanges(dev,sli,which,NULL,NULL,&cause);
+        if (which & bit) {
+            sli->maps[i].flags = desc->flags;
+            sli->maps[i].which_groups = desc->whichGroups;
+            sli->maps[i].groups = desc->groups;
+            sli->maps[i].which_mods = desc->whichMods;
+            sli->maps[i].mods.mask = desc->mods;
+            sli->maps[i].mods.real_mods = desc->mods;
+            sli->maps[i].mods.vmods = desc->virtualMods;
+            sli->maps[i].ctrls = desc->ctrls;
+            if (desc->virtualMods != 0) {
+                unsigned tmp;
+
+                tmp = XkbMaskForVMask(xkbi->desc, desc->virtualMods);
+                sli->maps[i].mods.mask = desc->mods | tmp;
+            }
+            desc++;
+        }
+    }
+
+    XkbSetCauseXkbReq(&cause, X_kbSetIndicatorMap, client);
+    XkbApplyLedMapChanges(dev, sli, which, NULL, NULL, &cause);
 
     return Success;
 }
@@ -3126,58 +3203,59 @@ _XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetIndicatorMap(ClientPtr client)
 {
-    int                 i, bit;
-    int                 nIndicators;
-    DeviceIntPtr        dev;
-    xkbIndicatorMapWireDesc     *from;
-    int                 rc;
+    int i, bit;
+    int nIndicators;
+    DeviceIntPtr dev;
+    xkbIndicatorMapWireDesc *from;
+    int rc;
 
     REQUEST(xkbSetIndicatorMapReq);
     REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
 
-    if (stuff->which==0)
-	return Success;
+    if (stuff->which == 0)
+        return Success;
 
-    for (nIndicators=i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-	if (stuff->which&bit)
-	    nIndicators++;
+    for (nIndicators = i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+        if (stuff->which & bit)
+            nIndicators++;
     }
-    if (stuff->length!=((SIZEOF(xkbSetIndicatorMapReq)+
-			(nIndicators*SIZEOF(xkbIndicatorMapWireDesc)))/4)) {
-	return BadLength;
+    if (stuff->length != ((SIZEOF(xkbSetIndicatorMapReq) +
+                           (nIndicators * SIZEOF(xkbIndicatorMapWireDesc))) /
+                          4)) {
+        return BadLength;
     }
 
-    from = (xkbIndicatorMapWireDesc *)&stuff[1];
-    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-	if (stuff->which&bit) {
-	    if (client->swapped) {
-		swaps(&from->virtualMods);
-		swapl(&from->ctrls);
-	    }
-	    CHK_MASK_LEGAL(i,from->whichGroups,XkbIM_UseAnyGroup);
-	    CHK_MASK_LEGAL(i,from->whichMods,XkbIM_UseAnyMods);
-	    from++;
-	}
+    from = (xkbIndicatorMapWireDesc *) &stuff[1];
+    for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+        if (stuff->which & bit) {
+            if (client->swapped) {
+                swaps(&from->virtualMods);
+                swapl(&from->ctrls);
+            }
+            CHK_MASK_LEGAL(i, from->whichGroups, XkbIM_UseAnyGroup);
+            CHK_MASK_LEGAL(i, from->whichMods, XkbIM_UseAnyMods);
+            from++;
+        }
     }
 
-    from = (xkbIndicatorMapWireDesc *)&stuff[1];
+    from = (xkbIndicatorMapWireDesc *) &stuff[1];
     rc = _XkbSetIndicatorMap(client, dev, stuff->which, from);
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess);
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixSetAttrAccess);
                 if (rc == Success)
                     _XkbSetIndicatorMap(client, other, stuff->which, from);
             }
@@ -3192,84 +3270,83 @@ ProcXkbSetIndicatorMap(ClientPtr client)
 int
 ProcXkbGetNamedIndicator(ClientPtr client)
 {
-    DeviceIntPtr 		dev;
-    xkbGetNamedIndicatorReply 	rep;
-    register int		i = 0;
-    XkbSrvLedInfoPtr		sli;
-    XkbIndicatorMapPtr		map = NULL;
+    DeviceIntPtr dev;
+    xkbGetNamedIndicatorReply rep;
+    register int i = 0;
+    XkbSrvLedInfoPtr sli;
+    XkbIndicatorMapPtr map = NULL;
 
     REQUEST(xkbGetNamedIndicatorReq);
     REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixReadAccess);
     CHK_ATOM_ONLY(stuff->indicator);
 
-    sli= XkbFindSrvLedInfo(dev,stuff->ledClass,stuff->ledID,0);
+    sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID, 0);
     if (!sli)
-	return BadAlloc;
-
-    i= 0;
-    map= NULL;
-    if ((sli->names)&&(sli->maps)) {
-        for (i=0;i<XkbNumIndicators;i++) {
-            if (stuff->indicator==sli->names[i]) {
-                map= &sli->maps[i];
+        return BadAlloc;
+
+    i = 0;
+    map = NULL;
+    if ((sli->names) && (sli->maps)) {
+        for (i = 0; i < XkbNumIndicators; i++) {
+            if (stuff->indicator == sli->names[i]) {
+                map = &sli->maps[i];
                 break;
             }
         }
     }
 
-    rep.type= X_Reply;
+    rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     rep.deviceID = dev->id;
-    rep.indicator= stuff->indicator;
-    if (map!=NULL) {
-	rep.found= 		TRUE;
-	rep.on=			((sli->effectiveState&(1<<i))!=0);
-	rep.realIndicator=	((sli->physIndicators&(1<<i))!=0);
-	rep.ndx= 		i;
-	rep.flags= 		map->flags;
-	rep.whichGroups= 	map->which_groups;
-	rep.groups= 		map->groups;
-	rep.whichMods= 		map->which_mods;
-	rep.mods= 		map->mods.mask;
-	rep.realMods= 		map->mods.real_mods;
-	rep.virtualMods= 	map->mods.vmods;
-	rep.ctrls= 		map->ctrls;
-	rep.supported= 		TRUE;
-    }
-    else  {
-	rep.found= 		FALSE;
-	rep.on= 		FALSE;
-	rep.realIndicator= 	FALSE;
-	rep.ndx= 		XkbNoIndicator;
-	rep.flags= 		0;
-	rep.whichGroups= 	0;
-	rep.groups= 		0;
-	rep.whichMods= 		0;
-	rep.mods=		0;
-	rep.realMods= 		0;
-	rep.virtualMods= 	0;
-	rep.ctrls= 		0;
-	rep.supported= 		TRUE;
-    }
-    if ( client->swapped ) {
-	swapl(&rep.length);
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.indicator);
-	swaps(&rep.virtualMods);
-	swapl(&rep.ctrls);
-    }
-
-    WriteToClient(client,SIZEOF(xkbGetNamedIndicatorReply), (char *)&rep);
+    rep.indicator = stuff->indicator;
+    if (map != NULL) {
+        rep.found = TRUE;
+        rep.on = ((sli->effectiveState & (1 << i)) != 0);
+        rep.realIndicator = ((sli->physIndicators & (1 << i)) != 0);
+        rep.ndx = i;
+        rep.flags = map->flags;
+        rep.whichGroups = map->which_groups;
+        rep.groups = map->groups;
+        rep.whichMods = map->which_mods;
+        rep.mods = map->mods.mask;
+        rep.realMods = map->mods.real_mods;
+        rep.virtualMods = map->mods.vmods;
+        rep.ctrls = map->ctrls;
+        rep.supported = TRUE;
+    }
+    else {
+        rep.found = FALSE;
+        rep.on = FALSE;
+        rep.realIndicator = FALSE;
+        rep.ndx = XkbNoIndicator;
+        rep.flags = 0;
+        rep.whichGroups = 0;
+        rep.groups = 0;
+        rep.whichMods = 0;
+        rep.mods = 0;
+        rep.realMods = 0;
+        rep.virtualMods = 0;
+        rep.ctrls = 0;
+        rep.supported = TRUE;
+    }
+    if (client->swapped) {
+        swapl(&rep.length);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.indicator);
+        swaps(&rep.virtualMods);
+        swapl(&rep.ctrls);
+    }
+
+    WriteToClient(client, SIZEOF(xkbGetNamedIndicatorReply), (char *) &rep);
     return Success;
 }
 
-
 /**
  * Find the IM on the device.
  * Returns the map, or NULL if the map doesn't exist.
@@ -3277,23 +3354,22 @@ ProcXkbGetNamedIndicator(ClientPtr client)
  * is set to the led index of the map.
  */
 static XkbIndicatorMapPtr
-_XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator,
-                          int *led_return)
+_XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator, int *led_return)
 {
-    XkbIndicatorMapPtr  map;
+    XkbIndicatorMapPtr map;
 
     /* search for the right indicator */
     map = NULL;
     if (sli->names && sli->maps) {
-	int led;
+        int led;
 
-	for (led = 0; (led < XkbNumIndicators) && (map == NULL); led++) {
-	    if (sli->names[led] == indicator) {
-		map= &sli->maps[led];
-		*led_return = led;
-		break;
-	    }
-	}
+        for (led = 0; (led < XkbNumIndicators) && (map == NULL); led++) {
+            if (sli->names[led] == indicator) {
+                map = &sli->maps[led];
+                *led_return = led;
+                break;
+            }
+        }
     }
 
     return map;
@@ -3306,12 +3382,12 @@ _XkbFindNamedIndicatorMap(XkbSrvLedInfoPtr sli, Atom indicator,
 static int
 _XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
                        int ledClass, int ledID,
-                       XkbIndicatorMapPtr *map_return, int *led_return,
+                       XkbIndicatorMapPtr * map_return, int *led_return,
                        Bool dryRun)
 {
-    XkbSrvLedInfoPtr    sli;
-    XkbIndicatorMapPtr  map;
-    int                 led;
+    XkbSrvLedInfoPtr sli;
+    XkbIndicatorMapPtr map;
+    int led;
 
     sli = XkbFindSrvLedInfo(dev, ledClass, ledID, XkbXI_IndicatorsMask);
     if (!sli)
@@ -3319,13 +3395,12 @@ _XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
 
     map = _XkbFindNamedIndicatorMap(sli, indicator, &led);
 
-    if (!map)
-    {
+    if (!map) {
         /* find first unused indicator maps and assign the name to it */
-        for (led = 0, map = NULL; (led < XkbNumIndicators) && (map == NULL); led++) {
+        for (led = 0, map = NULL; (led < XkbNumIndicators) && (map == NULL);
+             led++) {
             if ((sli->names) && (sli->maps) && (sli->names[led] == None) &&
-                    (!XkbIM_InUse(&sli->maps[led])))
-            {
+                (!XkbIM_InUse(&sli->maps[led]))) {
                 map = &sli->maps[led];
                 if (!dryRun)
                     sli->names[led] = indicator;
@@ -3344,22 +3419,22 @@ _XkbCreateIndicatorMap(DeviceIntPtr dev, Atom indicator,
 
 static int
 _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
-                      xkbSetNamedIndicatorReq *stuff)
+                      xkbSetNamedIndicatorReq * stuff)
 {
-    unsigned int                extDevReason;
-    unsigned int                statec, namec, mapc;
-    XkbSrvLedInfoPtr            sli;
-    int                         led = 0;
-    XkbIndicatorMapPtr          map;
-    DeviceIntPtr                kbd;
-    XkbEventCauseRec            cause;
-    xkbExtensionDeviceNotify    ed;
-    XkbChangesRec               changes;
-    int                         rc;
+    unsigned int extDevReason;
+    unsigned int statec, namec, mapc;
+    XkbSrvLedInfoPtr sli;
+    int led = 0;
+    XkbIndicatorMapPtr map;
+    DeviceIntPtr kbd;
+    XkbEventCauseRec cause;
+    xkbExtensionDeviceNotify ed;
+    XkbChangesRec changes;
+    int rc;
 
     rc = _XkbCreateIndicatorMap(dev, stuff->indicator, stuff->ledClass,
                                 stuff->ledID, &map, &led, FALSE);
-    if (rc != Success || !map) /* oh-oh */
+    if (rc != Success || !map)  /* oh-oh */
         return rc;
 
     sli = XkbFindSrvLedInfo(dev, stuff->ledClass, stuff->ledID,
@@ -3370,7 +3445,7 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
     namec = mapc = statec = 0;
     extDevReason = 0;
 
-    namec |= (1<<led);
+    namec |= (1 << led);
     sli->namesPresent |= ((stuff->indicator != None) ? (1 << led) : 0);
     extDevReason |= XkbXI_IndicatorNamesMask;
 
@@ -3381,30 +3456,31 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
         map->which_mods = stuff->whichMods;
         map->mods.mask = stuff->realMods;
         map->mods.real_mods = stuff->realMods;
-        map->mods.vmods= stuff->virtualMods;
+        map->mods.vmods = stuff->virtualMods;
         map->ctrls = stuff->ctrls;
-        mapc|= (1<<led);
+        mapc |= (1 << led);
     }
 
-    if ((stuff->setState) && ((map->flags & XkbIM_NoExplicit) == 0))
-    {
-        if (stuff->on)	sli->explicitState |=  (1<<led);
-        else		sli->explicitState &= ~(1<<led);
+    if ((stuff->setState) && ((map->flags & XkbIM_NoExplicit) == 0)) {
+        if (stuff->on)
+            sli->explicitState |= (1 << led);
+        else
+            sli->explicitState &= ~(1 << led);
         statec |= ((sli->effectiveState ^ sli->explicitState) & (1 << led));
     }
 
-    memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
-    memset((char *)&changes, 0, sizeof(XkbChangesRec));
-    XkbSetCauseXkbReq(&cause,X_kbSetNamedIndicator,client);
+    memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+    memset((char *) &changes, 0, sizeof(XkbChangesRec));
+    XkbSetCauseXkbReq(&cause, X_kbSetNamedIndicator, client);
     if (namec)
-        XkbApplyLedNameChanges(dev,sli,namec,&ed,&changes,&cause);
+        XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
     if (mapc)
-        XkbApplyLedMapChanges(dev,sli,mapc,&ed,&changes,&cause);
+        XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
     if (statec)
-        XkbApplyLedStateChanges(dev,sli,statec,&ed,&changes,&cause);
+        XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
 
     kbd = dev;
-    if ((sli->flags&XkbSLI_HasOwnState)==0)
+    if ((sli->flags & XkbSLI_HasOwnState) == 0)
         kbd = inputInfo.keyboard;
     XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
 
@@ -3414,42 +3490,42 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetNamedIndicator(ClientPtr client)
 {
-    int                         rc;
-    DeviceIntPtr                dev;
-    int                         led = 0;
-    XkbIndicatorMapPtr          map;
+    int rc;
+    DeviceIntPtr dev;
+    int led = 0;
+    XkbIndicatorMapPtr map;
 
     REQUEST(xkbSetNamedIndicatorReq);
     REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_LED_DEVICE(dev, stuff->deviceSpec, client, DixSetAttrAccess);
     CHK_ATOM_ONLY(stuff->indicator);
-    CHK_MASK_LEGAL(0x10,stuff->whichGroups,XkbIM_UseAnyGroup);
-    CHK_MASK_LEGAL(0x11,stuff->whichMods,XkbIM_UseAnyMods);
+    CHK_MASK_LEGAL(0x10, stuff->whichGroups, XkbIM_UseAnyGroup);
+    CHK_MASK_LEGAL(0x11, stuff->whichMods, XkbIM_UseAnyMods);
 
     /* Dry-run for checks */
     rc = _XkbCreateIndicatorMap(dev, stuff->indicator,
                                 stuff->ledClass, stuff->ledID,
                                 &map, &led, TRUE);
-    if (rc != Success || !map) /* couldn't be created or didn't exist */
+    if (rc != Success || !map)  /* couldn't be created or didn't exist */
         return rc;
 
     if (stuff->deviceSpec == XkbUseCoreKbd ||
-        stuff->deviceSpec == XkbUseCorePtr)
-    {
+        stuff->deviceSpec == XkbUseCorePtr) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev &&
-                (other->kbdfeed || other->leds) &&
-                (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess) == Success))
-            {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev && (other->kbdfeed ||
+                                                             other->leds) &&
+                (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess)
+                 == Success)) {
                 rc = _XkbCreateIndicatorMap(other, stuff->indicator,
-                                            stuff->ledClass, stuff->ledID,
-                                            &map, &led, TRUE);
+                                            stuff->ledClass, stuff->ledID, &map,
+                                            &led, TRUE);
                 if (rc != Success || !map)
                     return rc;
             }
@@ -3462,15 +3538,15 @@ ProcXkbSetNamedIndicator(ClientPtr client)
         return rc;
 
     if (stuff->deviceSpec == XkbUseCoreKbd ||
-        stuff->deviceSpec == XkbUseCorePtr)
-    {
+        stuff->deviceSpec == XkbUseCorePtr) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev &&
-                (other->kbdfeed || other->leds) &&
-                (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess) == Success))
-            {
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev && (other->kbdfeed ||
+                                                             other->leds) &&
+                (XaceHook(XACE_DEVICE_ACCESS, client, other, DixSetAttrAccess)
+                 == Success)) {
                 _XkbSetNamedIndicator(client, other, stuff);
             }
         }
@@ -3482,393 +3558,410 @@ ProcXkbSetNamedIndicator(ClientPtr client)
 /***====================================================================***/
 
 static CARD32
-_XkbCountAtoms(Atom *atoms,int maxAtoms,int *count)
+_XkbCountAtoms(Atom *atoms, int maxAtoms, int *count)
 {
-register unsigned int i,bit,nAtoms;
-register CARD32 atomsPresent;
+    register unsigned int i, bit, nAtoms;
+    register CARD32 atomsPresent;
 
-    for (i=nAtoms=atomsPresent=0,bit=1;i<maxAtoms;i++,bit<<=1) {
-	if (atoms[i]!=None) {
-	    atomsPresent|= bit;
-	    nAtoms++;
-	}
+    for (i = nAtoms = atomsPresent = 0, bit = 1; i < maxAtoms; i++, bit <<= 1) {
+        if (atoms[i] != None) {
+            atomsPresent |= bit;
+            nAtoms++;
+        }
     }
     if (count)
-	*count= nAtoms;
+        *count = nAtoms;
     return atomsPresent;
 }
 
 static char *
-_XkbWriteAtoms(char *wire,Atom *atoms,int maxAtoms,int swap)
+_XkbWriteAtoms(char *wire, Atom *atoms, int maxAtoms, int swap)
 {
-register unsigned int i;
-Atom *atm;
-
-    atm = (Atom *)wire;
-    for (i=0;i<maxAtoms;i++) {
-	if (atoms[i]!=None) {
-	    *atm= atoms[i];
-	    if (swap) {
-		swapl(atm);
-	    }
-	    atm++;
-	}
-    }
-    return (char *)atm;
+    register unsigned int i;
+    Atom *atm;
+
+    atm = (Atom *) wire;
+    for (i = 0; i < maxAtoms; i++) {
+        if (atoms[i] != None) {
+            *atm = atoms[i];
+            if (swap) {
+                swapl(atm);
+            }
+            atm++;
+        }
+    }
+    return (char *) atm;
 }
 
 static Status
-XkbComputeGetNamesReplySize(XkbDescPtr xkb,xkbGetNamesReply *rep)
+XkbComputeGetNamesReplySize(XkbDescPtr xkb, xkbGetNamesReply * rep)
 {
-register unsigned	which,length;
-register int		i;
-
-    rep->minKeyCode= xkb->min_key_code;
-    rep->maxKeyCode= xkb->max_key_code;
-    which= rep->which;
-    length= 0;
-    if (xkb->names!=NULL) {
-	 if (which&XkbKeycodesNameMask)		length++;
-	 if (which&XkbGeometryNameMask)		length++;
-	 if (which&XkbSymbolsNameMask)		length++;
-	 if (which&XkbPhysSymbolsNameMask)	length++;
-	 if (which&XkbTypesNameMask)		length++;
-	 if (which&XkbCompatNameMask)		length++;
-    }
-    else which&= ~XkbComponentNamesMask;
-
-    if (xkb->map!=NULL) {
-	if (which&XkbKeyTypeNamesMask)
-	    length+= xkb->map->num_types;
-	rep->nTypes= xkb->map->num_types;
-	if (which&XkbKTLevelNamesMask) {
-	    XkbKeyTypePtr	pType = xkb->map->types;
-	    int			nKTLevels = 0;
-
-	    length+= XkbPaddedSize(xkb->map->num_types)/4;
-	    for (i=0;i<xkb->map->num_types;i++,pType++) {
-		if (pType->level_names!=NULL)
-		    nKTLevels+= pType->num_levels;
-	    }
-	    rep->nKTLevels= nKTLevels;
-	    length+= nKTLevels;
-	}
+    register unsigned which, length;
+    register int i;
+
+    rep->minKeyCode = xkb->min_key_code;
+    rep->maxKeyCode = xkb->max_key_code;
+    which = rep->which;
+    length = 0;
+    if (xkb->names != NULL) {
+        if (which & XkbKeycodesNameMask)
+            length++;
+        if (which & XkbGeometryNameMask)
+            length++;
+        if (which & XkbSymbolsNameMask)
+            length++;
+        if (which & XkbPhysSymbolsNameMask)
+            length++;
+        if (which & XkbTypesNameMask)
+            length++;
+        if (which & XkbCompatNameMask)
+            length++;
+    }
+    else
+        which &= ~XkbComponentNamesMask;
+
+    if (xkb->map != NULL) {
+        if (which & XkbKeyTypeNamesMask)
+            length += xkb->map->num_types;
+        rep->nTypes = xkb->map->num_types;
+        if (which & XkbKTLevelNamesMask) {
+            XkbKeyTypePtr pType = xkb->map->types;
+            int nKTLevels = 0;
+
+            length += XkbPaddedSize(xkb->map->num_types) / 4;
+            for (i = 0; i < xkb->map->num_types; i++, pType++) {
+                if (pType->level_names != NULL)
+                    nKTLevels += pType->num_levels;
+            }
+            rep->nKTLevels = nKTLevels;
+            length += nKTLevels;
+        }
     }
     else {
-	rep->nTypes=    0;
-	rep->nKTLevels= 0;
-	which&= ~(XkbKeyTypeNamesMask|XkbKTLevelNamesMask);
-    }
-
-    rep->minKeyCode= xkb->min_key_code;
-    rep->maxKeyCode= xkb->max_key_code;
-    rep->indicators= 0;
-    rep->virtualMods= 0;
-    rep->groupNames= 0;
-    if (xkb->names!=NULL) {
-	if (which&XkbIndicatorNamesMask) {
-	    int nLeds;
-	    rep->indicators= 
-		_XkbCountAtoms(xkb->names->indicators,XkbNumIndicators,&nLeds);
-	    length+= nLeds;
-	    if (nLeds==0)
-		which&= ~XkbIndicatorNamesMask;
-	}
-
-	if (which&XkbVirtualModNamesMask) {
-	    int nVMods;
-	    rep->virtualMods= 
-		_XkbCountAtoms(xkb->names->vmods,XkbNumVirtualMods,&nVMods);
-	    length+= nVMods;
-	    if (nVMods==0)
-		which&= ~XkbVirtualModNamesMask;
-	}
-
-	if (which&XkbGroupNamesMask) {
-	    int nGroups;
-	    rep->groupNames=
-		_XkbCountAtoms(xkb->names->groups,XkbNumKbdGroups,&nGroups);
-	    length+= nGroups;
-	    if (nGroups==0)
-		which&= ~XkbGroupNamesMask;
-	}
-
-	if ((which&XkbKeyNamesMask)&&(xkb->names->keys))
-	     length+= rep->nKeys;
-	else which&= ~XkbKeyNamesMask;
-
-	if ((which&XkbKeyAliasesMask)&&
-	    (xkb->names->key_aliases)&&(xkb->names->num_key_aliases>0)) {
-	    rep->nKeyAliases= xkb->names->num_key_aliases;
-	    length+= rep->nKeyAliases*2;
-	} 
-	else {
-	    which&= ~XkbKeyAliasesMask;
-	    rep->nKeyAliases= 0;
-	}
-
-	if ((which&XkbRGNamesMask)&&(xkb->names->num_rg>0))
-	     length+= xkb->names->num_rg;
-	else which&= ~XkbRGNamesMask;
+        rep->nTypes = 0;
+        rep->nKTLevels = 0;
+        which &= ~(XkbKeyTypeNamesMask | XkbKTLevelNamesMask);
+    }
+
+    rep->minKeyCode = xkb->min_key_code;
+    rep->maxKeyCode = xkb->max_key_code;
+    rep->indicators = 0;
+    rep->virtualMods = 0;
+    rep->groupNames = 0;
+    if (xkb->names != NULL) {
+        if (which & XkbIndicatorNamesMask) {
+            int nLeds;
+
+            rep->indicators =
+                _XkbCountAtoms(xkb->names->indicators, XkbNumIndicators,
+                               &nLeds);
+            length += nLeds;
+            if (nLeds == 0)
+                which &= ~XkbIndicatorNamesMask;
+        }
+
+        if (which & XkbVirtualModNamesMask) {
+            int nVMods;
+
+            rep->virtualMods =
+                _XkbCountAtoms(xkb->names->vmods, XkbNumVirtualMods, &nVMods);
+            length += nVMods;
+            if (nVMods == 0)
+                which &= ~XkbVirtualModNamesMask;
+        }
+
+        if (which & XkbGroupNamesMask) {
+            int nGroups;
+
+            rep->groupNames =
+                _XkbCountAtoms(xkb->names->groups, XkbNumKbdGroups, &nGroups);
+            length += nGroups;
+            if (nGroups == 0)
+                which &= ~XkbGroupNamesMask;
+        }
+
+        if ((which & XkbKeyNamesMask) && (xkb->names->keys))
+            length += rep->nKeys;
+        else
+            which &= ~XkbKeyNamesMask;
+
+        if ((which & XkbKeyAliasesMask) &&
+            (xkb->names->key_aliases) && (xkb->names->num_key_aliases > 0)) {
+            rep->nKeyAliases = xkb->names->num_key_aliases;
+            length += rep->nKeyAliases * 2;
+        }
+        else {
+            which &= ~XkbKeyAliasesMask;
+            rep->nKeyAliases = 0;
+        }
+
+        if ((which & XkbRGNamesMask) && (xkb->names->num_rg > 0))
+            length += xkb->names->num_rg;
+        else
+            which &= ~XkbRGNamesMask;
     }
     else {
-	which&= ~(XkbIndicatorNamesMask|XkbVirtualModNamesMask);
-	which&= ~(XkbGroupNamesMask|XkbKeyNamesMask|XkbKeyAliasesMask);
-	which&= ~XkbRGNamesMask;
+        which &= ~(XkbIndicatorNamesMask | XkbVirtualModNamesMask);
+        which &= ~(XkbGroupNamesMask | XkbKeyNamesMask | XkbKeyAliasesMask);
+        which &= ~XkbRGNamesMask;
     }
 
-    rep->length= length;
-    rep->which= which;
+    rep->length = length;
+    rep->which = which;
     return Success;
 }
 
 static int
-XkbSendNames(ClientPtr client,XkbDescPtr xkb,xkbGetNamesReply *rep)
+XkbSendNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply * rep)
 {
-register unsigned 	i,length,which;
-char *			start;
-char *			desc;
+    register unsigned i, length, which;
+    char *start;
+    char *desc;
 
-    length= rep->length*4;
-    which= rep->which;
+    length = rep->length * 4;
+    which = rep->which;
     if (client->swapped) {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swapl(&rep->which);
-	swaps(&rep->virtualMods);
-	swapl(&rep->indicators);
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swapl(&rep->which);
+        swaps(&rep->virtualMods);
+        swapl(&rep->indicators);
     }
 
     start = desc = calloc(1, length);
-    if ( !start )
-	return BadAlloc;
+    if (!start)
+        return BadAlloc;
     if (xkb->names) {
-        if (which&XkbKeycodesNameMask) {
-            *((CARD32 *)desc)= xkb->names->keycodes;
+        if (which & XkbKeycodesNameMask) {
+            *((CARD32 *) desc) = xkb->names->keycodes;
             if (client->swapped) {
-                swapl((int *)desc);
+                swapl((int *) desc);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbGeometryNameMask)  {
-            *((CARD32 *)desc)= xkb->names->geometry;
+        if (which & XkbGeometryNameMask) {
+            *((CARD32 *) desc) = xkb->names->geometry;
             if (client->swapped) {
-                swapl((int *)desc);
+                swapl((int *) desc);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbSymbolsNameMask) {
-            *((CARD32 *)desc)= xkb->names->symbols;
+        if (which & XkbSymbolsNameMask) {
+            *((CARD32 *) desc) = xkb->names->symbols;
             if (client->swapped) {
-                swapl((int *)desc);
+                swapl((int *) desc);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbPhysSymbolsNameMask) {
-            register CARD32 *atm= (CARD32 *)desc;
-            atm[0]= (CARD32)xkb->names->phys_symbols;
+        if (which & XkbPhysSymbolsNameMask) {
+            register CARD32 *atm = (CARD32 *) desc;
+
+            atm[0] = (CARD32) xkb->names->phys_symbols;
             if (client->swapped) {
                 swapl(&atm[0]);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbTypesNameMask) {
-            *((CARD32 *)desc)= (CARD32)xkb->names->types;
+        if (which & XkbTypesNameMask) {
+            *((CARD32 *) desc) = (CARD32) xkb->names->types;
             if (client->swapped) {
-                swapl((int *)desc);
+                swapl((int *) desc);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbCompatNameMask) {
-            *((CARD32 *)desc)= (CARD32)xkb->names->compat;
+        if (which & XkbCompatNameMask) {
+            *((CARD32 *) desc) = (CARD32) xkb->names->compat;
             if (client->swapped) {
-                swapl((int *)desc);
+                swapl((int *) desc);
             }
-            desc+= 4;
+            desc += 4;
         }
-        if (which&XkbKeyTypeNamesMask) {
-            register CARD32 *atm= (CARD32 *)desc;
-            register XkbKeyTypePtr type= xkb->map->types;
+        if (which & XkbKeyTypeNamesMask) {
+            register CARD32 *atm = (CARD32 *) desc;
+            register XkbKeyTypePtr type = xkb->map->types;
 
-            for (i=0;i<xkb->map->num_types;i++,atm++,type++) {
-                *atm= (CARD32)type->name;
+            for (i = 0; i < xkb->map->num_types; i++, atm++, type++) {
+                *atm = (CARD32) type->name;
                 if (client->swapped) {
                     swapl(atm);
                 }
             }
-            desc= (char *)atm;
+            desc = (char *) atm;
         }
-        if (which&XkbKTLevelNamesMask && xkb->map) {
+        if (which & XkbKTLevelNamesMask && xkb->map) {
             XkbKeyTypePtr type = xkb->map->types;
             register CARD32 *atm;
-            for (i=0;i<rep->nTypes;i++,type++) {
+
+            for (i = 0; i < rep->nTypes; i++, type++) {
                 *desc++ = type->num_levels;
             }
-            desc+= XkbPaddedSize(rep->nTypes)-rep->nTypes;
+            desc += XkbPaddedSize(rep->nTypes) - rep->nTypes;
 
-            atm= (CARD32 *)desc;
+            atm = (CARD32 *) desc;
             type = xkb->map->types;
-            for (i=0;i<xkb->map->num_types;i++,type++) {
+            for (i = 0; i < xkb->map->num_types; i++, type++) {
                 register unsigned l;
+
                 if (type->level_names) {
-                    for (l=0;l<type->num_levels;l++,atm++) {
-                        *atm= type->level_names[l];
+                    for (l = 0; l < type->num_levels; l++, atm++) {
+                        *atm = type->level_names[l];
                         if (client->swapped) {
                             swapl(atm);
                         }
                     }
-                    desc+= type->num_levels*4;
+                    desc += type->num_levels * 4;
                 }
             }
         }
-        if (which&XkbIndicatorNamesMask) {
-            desc= _XkbWriteAtoms(desc,xkb->names->indicators,XkbNumIndicators,
-                                 client->swapped);
+        if (which & XkbIndicatorNamesMask) {
+            desc =
+                _XkbWriteAtoms(desc, xkb->names->indicators, XkbNumIndicators,
+                               client->swapped);
         }
-        if (which&XkbVirtualModNamesMask) {
-            desc= _XkbWriteAtoms(desc,xkb->names->vmods,XkbNumVirtualMods,
-                                 client->swapped);
+        if (which & XkbVirtualModNamesMask) {
+            desc = _XkbWriteAtoms(desc, xkb->names->vmods, XkbNumVirtualMods,
+                                  client->swapped);
         }
-        if (which&XkbGroupNamesMask) {
-            desc= _XkbWriteAtoms(desc,xkb->names->groups,XkbNumKbdGroups,
-                                 client->swapped);
+        if (which & XkbGroupNamesMask) {
+            desc = _XkbWriteAtoms(desc, xkb->names->groups, XkbNumKbdGroups,
+                                  client->swapped);
         }
-        if (which&XkbKeyNamesMask) {
-            for (i=0;i<rep->nKeys;i++,desc+= sizeof(XkbKeyNameRec)) {
-                *((XkbKeyNamePtr)desc)= xkb->names->keys[i+rep->firstKey];
+        if (which & XkbKeyNamesMask) {
+            for (i = 0; i < rep->nKeys; i++, desc += sizeof(XkbKeyNameRec)) {
+                *((XkbKeyNamePtr) desc) = xkb->names->keys[i + rep->firstKey];
             }
         }
-        if (which&XkbKeyAliasesMask) {
-            XkbKeyAliasPtr	pAl;
-            pAl= xkb->names->key_aliases;
-            for (i=0;i<rep->nKeyAliases;i++,pAl++,desc+=2*XkbKeyNameLength) {
-                *((XkbKeyAliasPtr)desc)= *pAl;
+        if (which & XkbKeyAliasesMask) {
+            XkbKeyAliasPtr pAl;
+
+            pAl = xkb->names->key_aliases;
+            for (i = 0; i < rep->nKeyAliases;
+                 i++, pAl++, desc += 2 * XkbKeyNameLength) {
+                *((XkbKeyAliasPtr) desc) = *pAl;
             }
         }
-        if ((which&XkbRGNamesMask)&&(rep->nRadioGroups>0)) {
-            register CARD32	*atm= (CARD32 *)desc;
-            for (i=0;i<rep->nRadioGroups;i++,atm++) {
-                *atm= (CARD32)xkb->names->radio_groups[i];
+        if ((which & XkbRGNamesMask) && (rep->nRadioGroups > 0)) {
+            register CARD32 *atm = (CARD32 *) desc;
+
+            for (i = 0; i < rep->nRadioGroups; i++, atm++) {
+                *atm = (CARD32) xkb->names->radio_groups[i];
                 if (client->swapped) {
                     swapl(atm);
                 }
             }
-            desc+= rep->nRadioGroups*4;
+            desc += rep->nRadioGroups * 4;
         }
     }
 
-    if ((desc-start)!=(length)) {
-	ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
-					length, (unsigned long)(desc-start));
+    if ((desc - start) != (length)) {
+        ErrorF("[xkb] BOGUS LENGTH in write names, expected %d, got %ld\n",
+               length, (unsigned long) (desc - start));
     }
-    WriteToClient(client, SIZEOF(xkbGetNamesReply), (char *)rep);
+    WriteToClient(client, SIZEOF(xkbGetNamesReply), (char *) rep);
     WriteToClient(client, length, start);
-    free((char *)start);
+    free((char *) start);
     return Success;
 }
 
 int
 ProcXkbGetNames(ClientPtr client)
 {
-    DeviceIntPtr	dev;
-    XkbDescPtr		xkb;
-    xkbGetNamesReply 	rep;
+    DeviceIntPtr dev;
+    XkbDescPtr xkb;
+    xkbGetNamesReply rep;
 
     REQUEST(xkbGetNamesReq);
     REQUEST_SIZE_MATCH(xkbGetNamesReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
-    CHK_MASK_LEGAL(0x01,stuff->which,XkbAllNamesMask);
+    CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask);
 
     xkb = dev->key->xkbInfo->desc;
     memset(&rep, 0, sizeof(xkbGetNamesReply));
-    rep.type= X_Reply;
-    rep.sequenceNumber= client->sequence;
+    rep.type = X_Reply;
+    rep.sequenceNumber = client->sequence;
     rep.length = 0;
     rep.deviceID = dev->id;
     rep.which = stuff->which;
     rep.nTypes = xkb->map->num_types;
     rep.firstKey = xkb->min_key_code;
     rep.nKeys = XkbNumKeys(xkb);
-    if (xkb->names!=NULL) {
-	rep.nKeyAliases= xkb->names->num_key_aliases;
-	rep.nRadioGroups = xkb->names->num_rg;
+    if (xkb->names != NULL) {
+        rep.nKeyAliases = xkb->names->num_key_aliases;
+        rep.nRadioGroups = xkb->names->num_rg;
     }
     else {
-	rep.nKeyAliases= rep.nRadioGroups= 0;
+        rep.nKeyAliases = rep.nRadioGroups = 0;
     }
-    XkbComputeGetNamesReplySize(xkb,&rep);
-    return XkbSendNames(client,xkb,&rep);
+    XkbComputeGetNamesReplySize(xkb, &rep);
+    return XkbSendNames(client, xkb, &rep);
 }
 
 /***====================================================================***/
 
 static CARD32 *
-_XkbCheckAtoms(CARD32 *wire,int nAtoms,int swapped,Atom *pError)
+_XkbCheckAtoms(CARD32 *wire, int nAtoms, int swapped, Atom *pError)
 {
-register int i;
+    register int i;
 
-    for (i=0;i<nAtoms;i++,wire++) {
-	if (swapped) {
-	    swapl(wire);
-	}
-	if ((((Atom)*wire)!=None)&&(!ValidAtom((Atom)*wire))) {
-	    *pError= ((Atom)*wire);
-	    return NULL;
-	}
+    for (i = 0; i < nAtoms; i++, wire++) {
+        if (swapped) {
+            swapl(wire);
+        }
+        if ((((Atom) *wire) != None) && (!ValidAtom((Atom) *wire))) {
+            *pError = ((Atom) *wire);
+            return NULL;
+        }
     }
     return wire;
 }
 
 static CARD32 *
-_XkbCheckMaskedAtoms(CARD32 *wire,int nAtoms,CARD32 present,int swapped,
-								Atom *pError)
+_XkbCheckMaskedAtoms(CARD32 *wire, int nAtoms, CARD32 present, int swapped,
+                     Atom *pError)
 {
-register unsigned i,bit;
-
-    for (i=0,bit=1;(i<nAtoms)&&(present);i++,bit<<=1) {
-	if ((present&bit)==0)
-	    continue;
-	if (swapped) {
-	    swapl(wire);
-	}
-	if ((((Atom)*wire)!=None)&&(!ValidAtom(((Atom)*wire)))) {
-	    *pError= (Atom)*wire;
-	    return NULL;
-	}
-	wire++;
+    register unsigned i, bit;
+
+    for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
+        if ((present & bit) == 0)
+            continue;
+        if (swapped) {
+            swapl(wire);
+        }
+        if ((((Atom) *wire) != None) && (!ValidAtom(((Atom) *wire)))) {
+            *pError = (Atom) *wire;
+            return NULL;
+        }
+        wire++;
     }
     return wire;
 }
 
 static Atom *
-_XkbCopyMaskedAtoms(	Atom	*wire,
-    			Atom	*dest,
-			int   	 nAtoms,
-			CARD32	 present)
+_XkbCopyMaskedAtoms(Atom *wire, Atom *dest, int nAtoms, CARD32 present)
 {
-register int i,bit;
+    register int i, bit;
 
-    for (i=0,bit=1;(i<nAtoms)&&(present);i++,bit<<=1) {
-	if ((present&bit)==0)
-	    continue;
-	dest[i]= *wire++;
+    for (i = 0, bit = 1; (i < nAtoms) && (present); i++, bit <<= 1) {
+        if ((present & bit) == 0)
+            continue;
+        dest[i] = *wire++;
     }
     return wire;
 }
 
 static Bool
-_XkbCheckTypeName(Atom name,int typeNdx)
+_XkbCheckTypeName(Atom name, int typeNdx)
 {
-const char *	str;
+    const char *str;
 
-    str= NameForAtom(name);
-    if ((strcmp(str,"ONE_LEVEL")==0)||(strcmp(str,"TWO_LEVEL")==0)||
-	(strcmp(str,"ALPHABETIC")==0)||(strcmp(str,"KEYPAD")==0))
-	return FALSE;
+    str = NameForAtom(name);
+    if ((strcmp(str, "ONE_LEVEL") == 0) || (strcmp(str, "TWO_LEVEL") == 0) ||
+        (strcmp(str, "ALPHABETIC") == 0) || (strcmp(str, "KEYPAD") == 0))
+        return FALSE;
     return TRUE;
 }
 
@@ -3878,304 +3971,310 @@ const char *	str;
  */
 static int
 _XkbSetNamesCheck(ClientPtr client, DeviceIntPtr dev,
-                  xkbSetNamesReq *stuff, CARD32 *data)
+                  xkbSetNamesReq * stuff, CARD32 *data)
 {
-    XkbDescRec		*xkb;
-    XkbNamesRec		*names;
-    CARD32		*tmp;
-    Atom		 bad;
+    XkbDescRec *xkb;
+    XkbNamesRec *names;
+    CARD32 *tmp;
+    Atom bad;
 
     tmp = data;
     xkb = dev->key->xkbInfo->desc;
     names = xkb->names;
 
-
     if (stuff->which & XkbKeyTypeNamesMask) {
         int i;
-        CARD32	*old;
-        if ( stuff->nTypes<1 ) {
-            client->errorValue = _XkbErrCode2(0x02,stuff->nTypes);
+        CARD32 *old;
+
+        if (stuff->nTypes < 1) {
+            client->errorValue = _XkbErrCode2(0x02, stuff->nTypes);
             return BadValue;
         }
-        if ((unsigned)(stuff->firstType+stuff->nTypes-1)>=xkb->map->num_types) {
-            client->errorValue = _XkbErrCode4(0x03,stuff->firstType,
-                    stuff->nTypes,
-                    xkb->map->num_types);
+        if ((unsigned) (stuff->firstType + stuff->nTypes - 1) >=
+            xkb->map->num_types) {
+            client->errorValue =
+                _XkbErrCode4(0x03, stuff->firstType, stuff->nTypes,
+                             xkb->map->num_types);
             return BadValue;
         }
-        if (((unsigned)stuff->firstType)<=XkbLastRequiredType) {
-            client->errorValue = _XkbErrCode2(0x04,stuff->firstType);
+        if (((unsigned) stuff->firstType) <= XkbLastRequiredType) {
+            client->errorValue = _XkbErrCode2(0x04, stuff->firstType);
             return BadAccess;
         }
-        old= tmp;
-        tmp= _XkbCheckAtoms(tmp,stuff->nTypes,client->swapped,&bad);
+        old = tmp;
+        tmp = _XkbCheckAtoms(tmp, stuff->nTypes, client->swapped, &bad);
         if (!tmp) {
-            client->errorValue= bad;
+            client->errorValue = bad;
             return BadAtom;
         }
-        for (i=0;i<stuff->nTypes;i++,old++) {
-            if (!_XkbCheckTypeName((Atom)*old,stuff->firstType+i))
-                client->errorValue= _XkbErrCode2(0x05,i);
+        for (i = 0; i < stuff->nTypes; i++, old++) {
+            if (!_XkbCheckTypeName((Atom) *old, stuff->firstType + i))
+                client->errorValue = _XkbErrCode2(0x05, i);
         }
     }
-    if (stuff->which&XkbKTLevelNamesMask) {
+    if (stuff->which & XkbKTLevelNamesMask) {
         unsigned i;
-        XkbKeyTypePtr	type;
-        CARD8 *		width;
-        if ( stuff->nKTLevels<1 ) {
-            client->errorValue = _XkbErrCode2(0x05,stuff->nKTLevels);
+        XkbKeyTypePtr type;
+        CARD8 *width;
+
+        if (stuff->nKTLevels < 1) {
+            client->errorValue = _XkbErrCode2(0x05, stuff->nKTLevels);
             return BadValue;
         }
-        if ((unsigned)(stuff->firstKTLevel+stuff->nKTLevels-1)>=
-                xkb->map->num_types) {
-            client->errorValue = _XkbErrCode4(0x06,stuff->firstKTLevel,
-                    stuff->nKTLevels,xkb->map->num_types);
+        if ((unsigned) (stuff->firstKTLevel + stuff->nKTLevels - 1) >=
+            xkb->map->num_types) {
+            client->errorValue = _XkbErrCode4(0x06, stuff->firstKTLevel,
+                                              stuff->nKTLevels,
+                                              xkb->map->num_types);
             return BadValue;
         }
-        width = (CARD8 *)tmp;
-        tmp= (CARD32 *)(((char *)tmp)+XkbPaddedSize(stuff->nKTLevels));
+        width = (CARD8 *) tmp;
+        tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels));
         type = &xkb->map->types[stuff->firstKTLevel];
-        for (i=0;i<stuff->nKTLevels;i++,type++) {
-            if (width[i]==0)
+        for (i = 0; i < stuff->nKTLevels; i++, type++) {
+            if (width[i] == 0)
                 continue;
-            else if (width[i]!=type->num_levels) {
-                client->errorValue= _XkbErrCode4(0x07,i+stuff->firstKTLevel,
-                        type->num_levels,width[i]);
+            else if (width[i] != type->num_levels) {
+                client->errorValue = _XkbErrCode4(0x07, i + stuff->firstKTLevel,
+                                                  type->num_levels, width[i]);
                 return BadMatch;
             }
-            tmp= _XkbCheckAtoms(tmp,width[i],client->swapped,&bad);
+            tmp = _XkbCheckAtoms(tmp, width[i], client->swapped, &bad);
             if (!tmp) {
-                client->errorValue= bad;
+                client->errorValue = bad;
                 return BadAtom;
             }
         }
     }
-    if (stuff->which&XkbIndicatorNamesMask) {
-        if (stuff->indicators==0) {
-            client->errorValue= 0x08;
+    if (stuff->which & XkbIndicatorNamesMask) {
+        if (stuff->indicators == 0) {
+            client->errorValue = 0x08;
             return BadMatch;
         }
-        tmp= _XkbCheckMaskedAtoms(tmp,XkbNumIndicators,stuff->indicators,
-                client->swapped,&bad);
+        tmp = _XkbCheckMaskedAtoms(tmp, XkbNumIndicators, stuff->indicators,
+                                   client->swapped, &bad);
         if (!tmp) {
-            client->errorValue= bad;
+            client->errorValue = bad;
             return BadAtom;
         }
     }
-    if (stuff->which&XkbVirtualModNamesMask) {
-        if (stuff->virtualMods==0) {
-            client->errorValue= 0x09;
+    if (stuff->which & XkbVirtualModNamesMask) {
+        if (stuff->virtualMods == 0) {
+            client->errorValue = 0x09;
             return BadMatch;
         }
-        tmp= _XkbCheckMaskedAtoms(tmp,XkbNumVirtualMods,
-                (CARD32)stuff->virtualMods,
-                client->swapped,&bad);
+        tmp = _XkbCheckMaskedAtoms(tmp, XkbNumVirtualMods,
+                                   (CARD32) stuff->virtualMods,
+                                   client->swapped, &bad);
         if (!tmp) {
             client->errorValue = bad;
             return BadAtom;
         }
     }
-    if (stuff->which&XkbGroupNamesMask) {
-        if (stuff->groupNames==0) {
-            client->errorValue= 0x0a;
+    if (stuff->which & XkbGroupNamesMask) {
+        if (stuff->groupNames == 0) {
+            client->errorValue = 0x0a;
             return BadMatch;
         }
-        tmp= _XkbCheckMaskedAtoms(tmp,XkbNumKbdGroups,
-                (CARD32)stuff->groupNames,
-                client->swapped,&bad);
+        tmp = _XkbCheckMaskedAtoms(tmp, XkbNumKbdGroups,
+                                   (CARD32) stuff->groupNames,
+                                   client->swapped, &bad);
         if (!tmp) {
             client->errorValue = bad;
             return BadAtom;
         }
     }
-    if (stuff->which&XkbKeyNamesMask) {
-        if (stuff->firstKey<(unsigned)xkb->min_key_code) {
-            client->errorValue= _XkbErrCode3(0x0b,xkb->min_key_code,
-                    stuff->firstKey);
+    if (stuff->which & XkbKeyNamesMask) {
+        if (stuff->firstKey < (unsigned) xkb->min_key_code) {
+            client->errorValue = _XkbErrCode3(0x0b, xkb->min_key_code,
+                                              stuff->firstKey);
             return BadValue;
         }
-        if (((unsigned)(stuff->firstKey+stuff->nKeys-1)>xkb->max_key_code)||
-                (stuff->nKeys<1)) {
-            client->errorValue= _XkbErrCode4(0x0c,xkb->max_key_code,
-                    stuff->firstKey,stuff->nKeys);
+        if (((unsigned) (stuff->firstKey + stuff->nKeys - 1) >
+             xkb->max_key_code) || (stuff->nKeys < 1)) {
+            client->errorValue =
+                _XkbErrCode4(0x0c, xkb->max_key_code, stuff->firstKey,
+                             stuff->nKeys);
             return BadValue;
         }
-        tmp+= stuff->nKeys;
+        tmp += stuff->nKeys;
     }
-    if ((stuff->which&XkbKeyAliasesMask)&&(stuff->nKeyAliases>0)) {
-        tmp+= stuff->nKeyAliases*2;
+    if ((stuff->which & XkbKeyAliasesMask) && (stuff->nKeyAliases > 0)) {
+        tmp += stuff->nKeyAliases * 2;
     }
-    if (stuff->which&XkbRGNamesMask) {
-        if ( stuff->nRadioGroups<1 ) {
-            client->errorValue= _XkbErrCode2(0x0d,stuff->nRadioGroups);
+    if (stuff->which & XkbRGNamesMask) {
+        if (stuff->nRadioGroups < 1) {
+            client->errorValue = _XkbErrCode2(0x0d, stuff->nRadioGroups);
             return BadValue;
         }
-        tmp= _XkbCheckAtoms(tmp,stuff->nRadioGroups,client->swapped,&bad);
+        tmp = _XkbCheckAtoms(tmp, stuff->nRadioGroups, client->swapped, &bad);
         if (!tmp) {
-            client->errorValue= bad;
+            client->errorValue = bad;
             return BadAtom;
         }
     }
-    if ((tmp-((CARD32 *)stuff))!=stuff->length) {
+    if ((tmp - ((CARD32 *) stuff)) != stuff->length) {
         client->errorValue = stuff->length;
         return BadLength;
     }
 
-
-
     return Success;
 }
 
 static int
-_XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
+_XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq * stuff)
 {
-    XkbDescRec		*xkb;
-    XkbNamesRec		*names;
-    CARD32		*tmp;
-    xkbNamesNotify	 nn;
+    XkbDescRec *xkb;
+    XkbNamesRec *names;
+    CARD32 *tmp;
+    xkbNamesNotify nn;
 
-    tmp = (CARD32 *)&stuff[1];
+    tmp = (CARD32 *) &stuff[1];
     xkb = dev->key->xkbInfo->desc;
     names = xkb->names;
 
-    if (XkbAllocNames(xkb,stuff->which,stuff->nRadioGroups,
-                stuff->nKeyAliases)!=Success) {
+    if (XkbAllocNames(xkb, stuff->which, stuff->nRadioGroups,
+                      stuff->nKeyAliases) != Success) {
         return BadAlloc;
     }
 
     memset(&nn, 0, sizeof(xkbNamesNotify));
-    nn.changed= stuff->which;
-    tmp = (CARD32 *)&stuff[1];
-    if (stuff->which&XkbKeycodesNameMask)
-        names->keycodes= *tmp++;
-    if (stuff->which&XkbGeometryNameMask)
-        names->geometry= *tmp++;
-    if (stuff->which&XkbSymbolsNameMask)
-        names->symbols= *tmp++;
-    if (stuff->which&XkbPhysSymbolsNameMask)
-        names->phys_symbols= *tmp++;
-    if (stuff->which&XkbTypesNameMask)
-        names->types= *tmp++;
-    if (stuff->which&XkbCompatNameMask)
-        names->compat= *tmp++;
-    if ((stuff->which&XkbKeyTypeNamesMask)&&(stuff->nTypes>0)) {
+    nn.changed = stuff->which;
+    tmp = (CARD32 *) &stuff[1];
+    if (stuff->which & XkbKeycodesNameMask)
+        names->keycodes = *tmp++;
+    if (stuff->which & XkbGeometryNameMask)
+        names->geometry = *tmp++;
+    if (stuff->which & XkbSymbolsNameMask)
+        names->symbols = *tmp++;
+    if (stuff->which & XkbPhysSymbolsNameMask)
+        names->phys_symbols = *tmp++;
+    if (stuff->which & XkbTypesNameMask)
+        names->types = *tmp++;
+    if (stuff->which & XkbCompatNameMask)
+        names->compat = *tmp++;
+    if ((stuff->which & XkbKeyTypeNamesMask) && (stuff->nTypes > 0)) {
         register unsigned i;
         register XkbKeyTypePtr type;
 
-        type= &xkb->map->types[stuff->firstType];
-        for (i=0;i<stuff->nTypes;i++,type++) {
-            type->name= *tmp++;
+        type = &xkb->map->types[stuff->firstType];
+        for (i = 0; i < stuff->nTypes; i++, type++) {
+            type->name = *tmp++;
         }
-        nn.firstType= stuff->firstType;
-        nn.nTypes= stuff->nTypes;
+        nn.firstType = stuff->firstType;
+        nn.nTypes = stuff->nTypes;
     }
-    if (stuff->which&XkbKTLevelNamesMask) {
-        register XkbKeyTypePtr	type;
+    if (stuff->which & XkbKTLevelNamesMask) {
+        register XkbKeyTypePtr type;
         register unsigned i;
         CARD8 *width;
 
-        width = (CARD8 *)tmp;
-        tmp= (CARD32 *)(((char *)tmp)+XkbPaddedSize(stuff->nKTLevels));
-        type= &xkb->map->types[stuff->firstKTLevel];
-        for (i=0;i<stuff->nKTLevels;i++,type++) {
-            if (width[i]>0) {
+        width = (CARD8 *) tmp;
+        tmp = (CARD32 *) (((char *) tmp) + XkbPaddedSize(stuff->nKTLevels));
+        type = &xkb->map->types[stuff->firstKTLevel];
+        for (i = 0; i < stuff->nKTLevels; i++, type++) {
+            if (width[i] > 0) {
                 if (type->level_names) {
                     register unsigned n;
-                    for (n=0;n<width[i];n++) {
-                        type->level_names[n]= tmp[n];
+
+                    for (n = 0; n < width[i]; n++) {
+                        type->level_names[n] = tmp[n];
                     }
                 }
-                tmp+= width[i];
+                tmp += width[i];
             }
         }
-        nn.firstLevelName= 0;
-        nn.nLevelNames= stuff->nTypes;
-    }
-    if (stuff->which&XkbIndicatorNamesMask) {
-        tmp= _XkbCopyMaskedAtoms(tmp,names->indicators,XkbNumIndicators,
-                stuff->indicators);
-        nn.changedIndicators= stuff->indicators;
-    }
-    if (stuff->which&XkbVirtualModNamesMask) {
-        tmp= _XkbCopyMaskedAtoms(tmp,names->vmods,XkbNumVirtualMods,
-                stuff->virtualMods);
-        nn.changedVirtualMods= stuff->virtualMods;
-    }
-    if (stuff->which&XkbGroupNamesMask) {
-        tmp= _XkbCopyMaskedAtoms(tmp,names->groups,XkbNumKbdGroups,
-                stuff->groupNames);
-        nn.changedVirtualMods= stuff->groupNames;
-    }
-    if (stuff->which&XkbKeyNamesMask) {
-        memcpy((char*)&names->keys[stuff->firstKey],(char *)tmp,
-                stuff->nKeys*XkbKeyNameLength);
-        tmp+= stuff->nKeys;
-        nn.firstKey= stuff->firstKey;
-        nn.nKeys= stuff->nKeys;
-    }
-    if (stuff->which&XkbKeyAliasesMask) {
-        if (stuff->nKeyAliases>0) {
-            register int na= stuff->nKeyAliases;	
-            if (XkbAllocNames(xkb,XkbKeyAliasesMask,0,na)!=Success)
+        nn.firstLevelName = 0;
+        nn.nLevelNames = stuff->nTypes;
+    }
+    if (stuff->which & XkbIndicatorNamesMask) {
+        tmp = _XkbCopyMaskedAtoms(tmp, names->indicators, XkbNumIndicators,
+                                  stuff->indicators);
+        nn.changedIndicators = stuff->indicators;
+    }
+    if (stuff->which & XkbVirtualModNamesMask) {
+        tmp = _XkbCopyMaskedAtoms(tmp, names->vmods, XkbNumVirtualMods,
+                                  stuff->virtualMods);
+        nn.changedVirtualMods = stuff->virtualMods;
+    }
+    if (stuff->which & XkbGroupNamesMask) {
+        tmp = _XkbCopyMaskedAtoms(tmp, names->groups, XkbNumKbdGroups,
+                                  stuff->groupNames);
+        nn.changedVirtualMods = stuff->groupNames;
+    }
+    if (stuff->which & XkbKeyNamesMask) {
+        memcpy((char *) &names->keys[stuff->firstKey], (char *) tmp,
+               stuff->nKeys * XkbKeyNameLength);
+        tmp += stuff->nKeys;
+        nn.firstKey = stuff->firstKey;
+        nn.nKeys = stuff->nKeys;
+    }
+    if (stuff->which & XkbKeyAliasesMask) {
+        if (stuff->nKeyAliases > 0) {
+            register int na = stuff->nKeyAliases;
+
+            if (XkbAllocNames(xkb, XkbKeyAliasesMask, 0, na) != Success)
                 return BadAlloc;
-            memcpy((char *)names->key_aliases,(char *)tmp,
-                    stuff->nKeyAliases*sizeof(XkbKeyAliasRec));
-            tmp+= stuff->nKeyAliases*2;
+            memcpy((char *) names->key_aliases, (char *) tmp,
+                   stuff->nKeyAliases * sizeof(XkbKeyAliasRec));
+            tmp += stuff->nKeyAliases * 2;
         }
-        else if (names->key_aliases!=NULL) {
+        else if (names->key_aliases != NULL) {
             free(names->key_aliases);
-            names->key_aliases= NULL;
-            names->num_key_aliases= 0;
+            names->key_aliases = NULL;
+            names->num_key_aliases = 0;
         }
-        nn.nAliases= names->num_key_aliases;
+        nn.nAliases = names->num_key_aliases;
     }
-    if (stuff->which&XkbRGNamesMask) {
-        if (stuff->nRadioGroups>0) {
-            register unsigned i,nrg;
-            nrg= stuff->nRadioGroups;
-            if (XkbAllocNames(xkb,XkbRGNamesMask,nrg,0)!=Success)
+    if (stuff->which & XkbRGNamesMask) {
+        if (stuff->nRadioGroups > 0) {
+            register unsigned i, nrg;
+
+            nrg = stuff->nRadioGroups;
+            if (XkbAllocNames(xkb, XkbRGNamesMask, nrg, 0) != Success)
                 return BadAlloc;
 
-            for (i=0;i<stuff->nRadioGroups;i++) {
-                names->radio_groups[i]= tmp[i];
+            for (i = 0; i < stuff->nRadioGroups; i++) {
+                names->radio_groups[i] = tmp[i];
             }
-            tmp+= stuff->nRadioGroups;
+            tmp += stuff->nRadioGroups;
         }
         else if (names->radio_groups) {
             free(names->radio_groups);
-            names->radio_groups= NULL;
-            names->num_rg= 0;
+            names->radio_groups = NULL;
+            names->num_rg = 0;
         }
-        nn.nRadioGroups= names->num_rg;
+        nn.nRadioGroups = names->num_rg;
     }
     if (nn.changed) {
         Bool needExtEvent;
-        needExtEvent= (nn.changed&XkbIndicatorNamesMask)!=0;
-        XkbSendNamesNotify(dev,&nn);
+
+        needExtEvent = (nn.changed & XkbIndicatorNamesMask) != 0;
+        XkbSendNamesNotify(dev, &nn);
         if (needExtEvent) {
-            XkbSrvLedInfoPtr		sli;
-            xkbExtensionDeviceNotify	edev;
-            register int		i;
-            register unsigned		bit;
-
-            sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,
-                    XkbXI_IndicatorsMask);
-            sli->namesPresent= 0;
-            for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-                if (names->indicators[i]!=None)
-                    sli->namesPresent|= bit;
+            XkbSrvLedInfoPtr sli;
+            xkbExtensionDeviceNotify edev;
+            register int i;
+            register unsigned bit;
+
+            sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId,
+                                    XkbXI_IndicatorsMask);
+            sli->namesPresent = 0;
+            for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+                if (names->indicators[i] != None)
+                    sli->namesPresent |= bit;
             }
             memset(&edev, 0, sizeof(xkbExtensionDeviceNotify));
-            edev.reason=	XkbXI_IndicatorNamesMask;
-            edev.ledClass=	KbdFeedbackClass;
-            edev.ledID=		dev->kbdfeed->ctrl.id;
-            edev.ledsDefined= 	sli->namesPresent|sli->mapsPresent;
-            edev.ledState=	sli->effectiveState;
-            edev.firstBtn=	0;
-            edev.nBtns=		0;
-            edev.supported=	XkbXI_AllFeaturesMask;
-            edev.unsupported=	0;
-            XkbSendExtensionDeviceNotify(dev,client,&edev);
+            edev.reason = XkbXI_IndicatorNamesMask;
+            edev.ledClass = KbdFeedbackClass;
+            edev.ledID = dev->kbdfeed->ctrl.id;
+            edev.ledsDefined = sli->namesPresent | sli->mapsPresent;
+            edev.ledState = sli->effectiveState;
+            edev.firstBtn = 0;
+            edev.nBtns = 0;
+            edev.supported = XkbXI_AllFeaturesMask;
+            edev.unsupported = 0;
+            XkbSendExtensionDeviceNotify(dev, client, &edev);
         }
     }
     return Success;
@@ -4184,64 +4283,64 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq *stuff)
 int
 ProcXkbSetNames(ClientPtr client)
 {
-    DeviceIntPtr	 dev;
-    CARD32		*tmp;
-    Atom                 bad;
-    int                  rc;
+    DeviceIntPtr dev;
+    CARD32 *tmp;
+    Atom bad;
+    int rc;
 
     REQUEST(xkbSetNamesReq);
     REQUEST_AT_LEAST_SIZE(xkbSetNamesReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
-    CHK_MASK_LEGAL(0x01,stuff->which,XkbAllNamesMask);
+    CHK_MASK_LEGAL(0x01, stuff->which, XkbAllNamesMask);
 
     /* check device-independent stuff */
-    tmp = (CARD32 *)&stuff[1];
-
-    if (stuff->which&XkbKeycodesNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue = bad;
-	    return BadAtom;
-	}
-    }
-    if (stuff->which&XkbGeometryNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue = bad;
-	    return BadAtom;
-	}
-    }
-    if (stuff->which&XkbSymbolsNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue = bad;
-	    return BadAtom;
-	}
-    }
-    if (stuff->which&XkbPhysSymbolsNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue= bad;
-	    return BadAtom;
-	}
-    }
-    if (stuff->which&XkbTypesNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue = bad;
-	    return BadAtom;
-	}
-    }
-    if (stuff->which&XkbCompatNameMask) {
-	tmp= _XkbCheckAtoms(tmp,1,client->swapped,&bad);
-	if (!tmp) {
-	    client->errorValue = bad;
-	    return BadAtom;
-	}
+    tmp = (CARD32 *) &stuff[1];
+
+    if (stuff->which & XkbKeycodesNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
+    }
+    if (stuff->which & XkbGeometryNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
+    }
+    if (stuff->which & XkbSymbolsNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
+    }
+    if (stuff->which & XkbPhysSymbolsNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
+    }
+    if (stuff->which & XkbTypesNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
+    }
+    if (stuff->which & XkbCompatNameMask) {
+        tmp = _XkbCheckAtoms(tmp, 1, client->swapped, &bad);
+        if (!tmp) {
+            client->errorValue = bad;
+            return BadAtom;
+        }
     }
 
     /* start of device-dependent tests */
@@ -4249,17 +4348,16 @@ ProcXkbSetNames(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
 
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     rc = _XkbSetNamesCheck(client, other, stuff, tmp);
                     if (rc != Success)
                         return rc;
@@ -4274,15 +4372,15 @@ ProcXkbSetNames(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
 
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
                 if (rc == Success)
                     _XkbSetNames(client, other, stuff);
             }
@@ -4312,47 +4410,48 @@ ProcXkbSetNames(ClientPtr client)
  * (swapped) 16 bit string length, non-zero terminated.
  */
 static char *
-XkbWriteCountedString(char *wire,char *str,Bool swap)
+XkbWriteCountedString(char *wire, char *str, Bool swap)
 {
-    CARD16 len,*pLen, paddedLen;
+    CARD16 len, *pLen, paddedLen;
 
     if (!str)
         return wire;
 
-    len= strlen(str);
-    pLen= (CARD16 *)wire;
-    *pLen= len;
+    len = strlen(str);
+    pLen = (CARD16 *) wire;
+    *pLen = len;
     if (swap) {
-	swaps(pLen);
+        swaps(pLen);
     }
-    paddedLen= pad_to_int32(sizeof(len)+len)-sizeof(len);
-    strncpy(&wire[sizeof(len)],str,paddedLen);
-    wire+= sizeof(len)+paddedLen;
+    paddedLen = pad_to_int32(sizeof(len) + len) - sizeof(len);
+    strncpy(&wire[sizeof(len)], str, paddedLen);
+    wire += sizeof(len) + paddedLen;
     return wire;
 }
 
 static int
 XkbSizeGeomProperties(XkbGeometryPtr geom)
 {
-register int 	i,size;
-XkbPropertyPtr	prop;
-    
-    for (size=i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
-	size+= XkbSizeCountedString(prop->name);
-	size+= XkbSizeCountedString(prop->value);
+    register int i, size;
+    XkbPropertyPtr prop;
+
+    for (size = i = 0, prop = geom->properties; i < geom->num_properties;
+         i++, prop++) {
+        size += XkbSizeCountedString(prop->name);
+        size += XkbSizeCountedString(prop->value);
     }
     return size;
 }
 
 static char *
-XkbWriteGeomProperties(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomProperties(char *wire, XkbGeometryPtr geom, Bool swap)
 {
-register int 	i;
-register XkbPropertyPtr	prop;
-    
-    for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
-	wire= XkbWriteCountedString(wire,prop->name,swap);
-	wire= XkbWriteCountedString(wire,prop->value,swap);
+    register int i;
+    register XkbPropertyPtr prop;
+
+    for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
+        wire = XkbWriteCountedString(wire, prop->name, swap);
+        wire = XkbWriteCountedString(wire, prop->value, swap);
     }
     return wire;
 }
@@ -4360,18 +4459,18 @@ register XkbPropertyPtr	prop;
 static int
 XkbSizeGeomKeyAliases(XkbGeometryPtr geom)
 {
-    return geom->num_key_aliases*(2*XkbKeyNameLength);
+    return geom->num_key_aliases * (2 * XkbKeyNameLength);
 }
 
 static char *
-XkbWriteGeomKeyAliases(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomKeyAliases(char *wire, XkbGeometryPtr geom, Bool swap)
 {
-register int sz;
-    
-    sz= geom->num_key_aliases*(XkbKeyNameLength*2);
-    if (sz>0) {
-	memcpy(wire,(char *)geom->key_aliases,sz);
-	wire+= sz;
+    register int sz;
+
+    sz = geom->num_key_aliases * (XkbKeyNameLength * 2);
+    if (sz > 0) {
+        memcpy(wire, (char *) geom->key_aliases, sz);
+        wire += sz;
     }
     return wire;
 }
@@ -4379,23 +4478,23 @@ register int sz;
 static int
 XkbSizeGeomColors(XkbGeometryPtr geom)
 {
-register int 		i,size;
-register XkbColorPtr	color;
+    register int i, size;
+    register XkbColorPtr color;
 
-    for (i=size=0,color=geom->colors;i<geom->num_colors;i++,color++) {
-	size+= XkbSizeCountedString(color->spec);
+    for (i = size = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+        size += XkbSizeCountedString(color->spec);
     }
     return size;
 }
 
 static char *
-XkbWriteGeomColors(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomColors(char *wire, XkbGeometryPtr geom, Bool swap)
 {
-register int		i;
-register XkbColorPtr	color;
+    register int i;
+    register XkbColorPtr color;
 
-    for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
-	wire= XkbWriteCountedString(wire,color->spec,swap);
+    for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+        wire = XkbWriteCountedString(wire, color->spec, swap);
     }
     return wire;
 }
@@ -4403,922 +4502,941 @@ register XkbColorPtr	color;
 static int
 XkbSizeGeomShapes(XkbGeometryPtr geom)
 {
-register int		i,size;
-register XkbShapePtr	shape;
-
-    for (i=size=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
-	register int		n;
-	register XkbOutlinePtr	ol;
-	size+= SIZEOF(xkbShapeWireDesc);
-	for (n=0,ol=shape->outlines;n<shape->num_outlines;n++,ol++) {
-	    size+= SIZEOF(xkbOutlineWireDesc);
-	    size+= ol->num_points*SIZEOF(xkbPointWireDesc);
-	}
+    register int i, size;
+    register XkbShapePtr shape;
+
+    for (i = size = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
+        register int n;
+        register XkbOutlinePtr ol;
+
+        size += SIZEOF(xkbShapeWireDesc);
+        for (n = 0, ol = shape->outlines; n < shape->num_outlines; n++, ol++) {
+            size += SIZEOF(xkbOutlineWireDesc);
+            size += ol->num_points * SIZEOF(xkbPointWireDesc);
+        }
     }
     return size;
 }
 
 static char *
-XkbWriteGeomShapes(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomShapes(char *wire, XkbGeometryPtr geom, Bool swap)
 {
-int			i;
-XkbShapePtr		shape;
-xkbShapeWireDesc *	shapeWire;
-
-    for (i=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
-	register int 		o;
-	XkbOutlinePtr		ol;
-	xkbOutlineWireDesc *	olWire;
-	shapeWire= (xkbShapeWireDesc *)wire;
-	shapeWire->name= shape->name;
-	shapeWire->nOutlines= shape->num_outlines;
-	if (shape->primary!=NULL)
-	     shapeWire->primaryNdx= XkbOutlineIndex(shape,shape->primary);
-	else shapeWire->primaryNdx= XkbNoShape;
-	if (shape->approx!=NULL)
-	     shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);
-	else shapeWire->approxNdx= XkbNoShape;
-	shapeWire->pad= 0;
-	if (swap) {
-	    swapl(&shapeWire->name);
-	}
-	wire= (char *)&shapeWire[1];
-	for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
-	    register int	p;
-	    XkbPointPtr		pt;
-	    xkbPointWireDesc *	ptWire;
-	    olWire= (xkbOutlineWireDesc *)wire;
-	    olWire->nPoints= ol->num_points;
-	    olWire->cornerRadius= ol->corner_radius;
-	    olWire->pad= 0;
-	    wire= (char *)&olWire[1];
-	    ptWire= (xkbPointWireDesc *)wire;
-	    for (p=0,pt=ol->points;p<ol->num_points;p++,pt++) {
-		ptWire[p].x= pt->x;
-		ptWire[p].y= pt->y;
-		if (swap) {
-		    swaps(&ptWire[p].x);
-		    swaps(&ptWire[p].y);
-		}
-	    }
-	    wire= (char *)&ptWire[ol->num_points];
-	}
+    int i;
+    XkbShapePtr shape;
+    xkbShapeWireDesc *shapeWire;
+
+    for (i = 0, shape = geom->shapes; i < geom->num_shapes; i++, shape++) {
+        register int o;
+        XkbOutlinePtr ol;
+        xkbOutlineWireDesc *olWire;
+
+        shapeWire = (xkbShapeWireDesc *) wire;
+        shapeWire->name = shape->name;
+        shapeWire->nOutlines = shape->num_outlines;
+        if (shape->primary != NULL)
+            shapeWire->primaryNdx = XkbOutlineIndex(shape, shape->primary);
+        else
+            shapeWire->primaryNdx = XkbNoShape;
+        if (shape->approx != NULL)
+            shapeWire->approxNdx = XkbOutlineIndex(shape, shape->approx);
+        else
+            shapeWire->approxNdx = XkbNoShape;
+        shapeWire->pad = 0;
+        if (swap) {
+            swapl(&shapeWire->name);
+        }
+        wire = (char *) &shapeWire[1];
+        for (o = 0, ol = shape->outlines; o < shape->num_outlines; o++, ol++) {
+            register int p;
+            XkbPointPtr pt;
+            xkbPointWireDesc *ptWire;
+
+            olWire = (xkbOutlineWireDesc *) wire;
+            olWire->nPoints = ol->num_points;
+            olWire->cornerRadius = ol->corner_radius;
+            olWire->pad = 0;
+            wire = (char *) &olWire[1];
+            ptWire = (xkbPointWireDesc *) wire;
+            for (p = 0, pt = ol->points; p < ol->num_points; p++, pt++) {
+                ptWire[p].x = pt->x;
+                ptWire[p].y = pt->y;
+                if (swap) {
+                    swaps(&ptWire[p].x);
+                    swaps(&ptWire[p].y);
+                }
+            }
+            wire = (char *) &ptWire[ol->num_points];
+        }
     }
     return wire;
 }
 
 static int
-XkbSizeGeomDoodads(int num_doodads,XkbDoodadPtr doodad)
+XkbSizeGeomDoodads(int num_doodads, XkbDoodadPtr doodad)
 {
-register int	i,size;
-
-    for (i=size=0;i<num_doodads;i++,doodad++) {
-	size+= SIZEOF(xkbAnyDoodadWireDesc);
-	if (doodad->any.type==XkbTextDoodad) {
-	    size+= XkbSizeCountedString(doodad->text.text);
-	    size+= XkbSizeCountedString(doodad->text.font);
-	}
-	else if (doodad->any.type==XkbLogoDoodad) {
-	    size+= XkbSizeCountedString(doodad->logo.logo_name);
-	}
+    register int i, size;
+
+    for (i = size = 0; i < num_doodads; i++, doodad++) {
+        size += SIZEOF(xkbAnyDoodadWireDesc);
+        if (doodad->any.type == XkbTextDoodad) {
+            size += XkbSizeCountedString(doodad->text.text);
+            size += XkbSizeCountedString(doodad->text.font);
+        }
+        else if (doodad->any.type == XkbLogoDoodad) {
+            size += XkbSizeCountedString(doodad->logo.logo_name);
+        }
     }
     return size;
 }
 
 static char *
-XkbWriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad,Bool swap)
+XkbWriteGeomDoodads(char *wire, int num_doodads, XkbDoodadPtr doodad, Bool swap)
 {
-register int		i;
-xkbDoodadWireDesc *	doodadWire;
-
-    for (i=0;i<num_doodads;i++,doodad++) {
-	doodadWire= (xkbDoodadWireDesc *)wire;
-	wire= (char *)&doodadWire[1];
-	memset(doodadWire, 0, SIZEOF(xkbDoodadWireDesc));
-	doodadWire->any.name= doodad->any.name;
-	doodadWire->any.type= doodad->any.type;
-	doodadWire->any.priority= doodad->any.priority;
-	doodadWire->any.top= doodad->any.top;
-	doodadWire->any.left= doodad->any.left;
-	if (swap) {
-	    swapl(&doodadWire->any.name);
-	    swaps(&doodadWire->any.top);
-	    swaps(&doodadWire->any.left);
-	}
-	switch (doodad->any.type) {
-	    case XkbOutlineDoodad:
-	    case XkbSolidDoodad:
-		doodadWire->shape.angle= doodad->shape.angle;
-		doodadWire->shape.colorNdx= doodad->shape.color_ndx;
-		doodadWire->shape.shapeNdx= doodad->shape.shape_ndx;
-		if (swap) {
-		    swaps(&doodadWire->shape.angle);
-		}
-		break;
-	    case XkbTextDoodad:
-		doodadWire->text.angle= doodad->text.angle;
-		doodadWire->text.width= doodad->text.width;
-		doodadWire->text.height= doodad->text.height;
-		doodadWire->text.colorNdx= doodad->text.color_ndx;
-		if (swap) {
-		    swaps(&doodadWire->text.angle);
-		    swaps(&doodadWire->text.width);
-		    swaps(&doodadWire->text.height);
-		}
-		wire= XkbWriteCountedString(wire,doodad->text.text,swap);
-		wire= XkbWriteCountedString(wire,doodad->text.font,swap);
-		break;
-	    case XkbIndicatorDoodad:
-		doodadWire->indicator.shapeNdx= doodad->indicator.shape_ndx;
-		doodadWire->indicator.onColorNdx=doodad->indicator.on_color_ndx;
-		doodadWire->indicator.offColorNdx=
-						doodad->indicator.off_color_ndx;
-		break;
-	    case XkbLogoDoodad:
-		doodadWire->logo.angle= doodad->logo.angle;
-		doodadWire->logo.colorNdx= doodad->logo.color_ndx;
-		doodadWire->logo.shapeNdx= doodad->logo.shape_ndx;
-		wire= XkbWriteCountedString(wire,doodad->logo.logo_name,swap);
-		break;
-	    default:
-		ErrorF("[xkb] Unknown doodad type %d in XkbWriteGeomDoodads\n",
-			doodad->any.type);
-		ErrorF("[xkb] Ignored\n");
-		break;
-	}
+    register int i;
+    xkbDoodadWireDesc *doodadWire;
+
+    for (i = 0; i < num_doodads; i++, doodad++) {
+        doodadWire = (xkbDoodadWireDesc *) wire;
+        wire = (char *) &doodadWire[1];
+        memset(doodadWire, 0, SIZEOF(xkbDoodadWireDesc));
+        doodadWire->any.name = doodad->any.name;
+        doodadWire->any.type = doodad->any.type;
+        doodadWire->any.priority = doodad->any.priority;
+        doodadWire->any.top = doodad->any.top;
+        doodadWire->any.left = doodad->any.left;
+        if (swap) {
+            swapl(&doodadWire->any.name);
+            swaps(&doodadWire->any.top);
+            swaps(&doodadWire->any.left);
+        }
+        switch (doodad->any.type) {
+        case XkbOutlineDoodad:
+        case XkbSolidDoodad:
+            doodadWire->shape.angle = doodad->shape.angle;
+            doodadWire->shape.colorNdx = doodad->shape.color_ndx;
+            doodadWire->shape.shapeNdx = doodad->shape.shape_ndx;
+            if (swap) {
+                swaps(&doodadWire->shape.angle);
+            }
+            break;
+        case XkbTextDoodad:
+            doodadWire->text.angle = doodad->text.angle;
+            doodadWire->text.width = doodad->text.width;
+            doodadWire->text.height = doodad->text.height;
+            doodadWire->text.colorNdx = doodad->text.color_ndx;
+            if (swap) {
+                swaps(&doodadWire->text.angle);
+                swaps(&doodadWire->text.width);
+                swaps(&doodadWire->text.height);
+            }
+            wire = XkbWriteCountedString(wire, doodad->text.text, swap);
+            wire = XkbWriteCountedString(wire, doodad->text.font, swap);
+            break;
+        case XkbIndicatorDoodad:
+            doodadWire->indicator.shapeNdx = doodad->indicator.shape_ndx;
+            doodadWire->indicator.onColorNdx = doodad->indicator.on_color_ndx;
+            doodadWire->indicator.offColorNdx = doodad->indicator.off_color_ndx;
+            break;
+        case XkbLogoDoodad:
+            doodadWire->logo.angle = doodad->logo.angle;
+            doodadWire->logo.colorNdx = doodad->logo.color_ndx;
+            doodadWire->logo.shapeNdx = doodad->logo.shape_ndx;
+            wire = XkbWriteCountedString(wire, doodad->logo.logo_name, swap);
+            break;
+        default:
+            ErrorF("[xkb] Unknown doodad type %d in XkbWriteGeomDoodads\n",
+                   doodad->any.type);
+            ErrorF("[xkb] Ignored\n");
+            break;
+        }
     }
     return wire;
 }
 
 static char *
-XkbWriteGeomOverlay(char *wire,XkbOverlayPtr ol,Bool swap)
+XkbWriteGeomOverlay(char *wire, XkbOverlayPtr ol, Bool swap)
 {
-register int		r;
-XkbOverlayRowPtr	row;
-xkbOverlayWireDesc *	olWire;
-
-   olWire= (xkbOverlayWireDesc *)wire;
-   olWire->name= ol->name;
-   olWire->nRows= ol->num_rows;
-   olWire->pad1= 0;
-   olWire->pad2= 0;
-   if (swap) {
-	swapl(&olWire->name);
-   }
-   wire= (char *)&olWire[1];
-   for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
-   	unsigned int		k;
-	XkbOverlayKeyPtr	key;
-	xkbOverlayRowWireDesc *	rowWire;
-	rowWire= (xkbOverlayRowWireDesc *)wire;
-	rowWire->rowUnder= row->row_under;
-	rowWire->nKeys= row->num_keys;
-	rowWire->pad1= 0;
-	wire= (char *)&rowWire[1];
-	for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
-	    xkbOverlayKeyWireDesc *	keyWire;
-	    keyWire= (xkbOverlayKeyWireDesc *)wire;
-	    memcpy(keyWire->over,key->over.name,XkbKeyNameLength);
-	    memcpy(keyWire->under,key->under.name,XkbKeyNameLength);
-	    wire= (char *)&keyWire[1];
-	}
-   }
-   return wire;
+    register int r;
+    XkbOverlayRowPtr row;
+    xkbOverlayWireDesc *olWire;
+
+    olWire = (xkbOverlayWireDesc *) wire;
+    olWire->name = ol->name;
+    olWire->nRows = ol->num_rows;
+    olWire->pad1 = 0;
+    olWire->pad2 = 0;
+    if (swap) {
+        swapl(&olWire->name);
+    }
+    wire = (char *) &olWire[1];
+    for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+        unsigned int k;
+        XkbOverlayKeyPtr key;
+        xkbOverlayRowWireDesc *rowWire;
+
+        rowWire = (xkbOverlayRowWireDesc *) wire;
+        rowWire->rowUnder = row->row_under;
+        rowWire->nKeys = row->num_keys;
+        rowWire->pad1 = 0;
+        wire = (char *) &rowWire[1];
+        for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+            xkbOverlayKeyWireDesc *keyWire;
+
+            keyWire = (xkbOverlayKeyWireDesc *) wire;
+            memcpy(keyWire->over, key->over.name, XkbKeyNameLength);
+            memcpy(keyWire->under, key->under.name, XkbKeyNameLength);
+            wire = (char *) &keyWire[1];
+        }
+    }
+    return wire;
 }
 
 static int
 XkbSizeGeomSections(XkbGeometryPtr geom)
 {
-register int 	i,size;
-XkbSectionPtr	section;
-
-    for (i=size=0,section=geom->sections;i<geom->num_sections;i++,section++) {
-	size+= SIZEOF(xkbSectionWireDesc);
-	if (section->rows) {
-	    int		r;
-	    XkbRowPtr	row;
-	    for (r=0,row=section->rows;r<section->num_rows;row++,r++) {
-		size+= SIZEOF(xkbRowWireDesc);
-		size+= row->num_keys*SIZEOF(xkbKeyWireDesc);
-	    }
-	}
-	if (section->doodads)
-	    size+= XkbSizeGeomDoodads(section->num_doodads,section->doodads);
-	if (section->overlays) {
-	    int			o;
-	    XkbOverlayPtr	ol;
-	    for (o=0,ol=section->overlays;o<section->num_overlays;o++,ol++) {
-		int			r;
-		XkbOverlayRowPtr	row;
-		size+= SIZEOF(xkbOverlayWireDesc);
-		for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
-		   size+= SIZEOF(xkbOverlayRowWireDesc);
-		   size+= row->num_keys*SIZEOF(xkbOverlayKeyWireDesc);
-		}
-	    }
-	}
+    register int i, size;
+    XkbSectionPtr section;
+
+    for (i = size = 0, section = geom->sections; i < geom->num_sections;
+         i++, section++) {
+        size += SIZEOF(xkbSectionWireDesc);
+        if (section->rows) {
+            int r;
+            XkbRowPtr row;
+
+            for (r = 0, row = section->rows; r < section->num_rows; row++, r++) {
+                size += SIZEOF(xkbRowWireDesc);
+                size += row->num_keys * SIZEOF(xkbKeyWireDesc);
+            }
+        }
+        if (section->doodads)
+            size += XkbSizeGeomDoodads(section->num_doodads, section->doodads);
+        if (section->overlays) {
+            int o;
+            XkbOverlayPtr ol;
+
+            for (o = 0, ol = section->overlays; o < section->num_overlays;
+                 o++, ol++) {
+                int r;
+                XkbOverlayRowPtr row;
+
+                size += SIZEOF(xkbOverlayWireDesc);
+                for (r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+                    size += SIZEOF(xkbOverlayRowWireDesc);
+                    size += row->num_keys * SIZEOF(xkbOverlayKeyWireDesc);
+                }
+            }
+        }
     }
     return size;
 }
 
 static char *
-XkbWriteGeomSections(char *wire,XkbGeometryPtr geom,Bool swap)
+XkbWriteGeomSections(char *wire, XkbGeometryPtr geom, Bool swap)
 {
-register int		i;
-XkbSectionPtr		section;
-xkbSectionWireDesc *	sectionWire;
-
-    for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
-	sectionWire= (xkbSectionWireDesc *)wire;
-	sectionWire->name= section->name;
-	sectionWire->top= section->top;
-	sectionWire->left= section->left;
-	sectionWire->width= section->width;
-	sectionWire->height= section->height;
-	sectionWire->angle= section->angle;
-	sectionWire->priority= section->priority;
-	sectionWire->nRows= section->num_rows;
-	sectionWire->nDoodads= section->num_doodads;
-	sectionWire->nOverlays= section->num_overlays;
-	sectionWire->pad= 0;
-	if (swap) {
-	    swapl(&sectionWire->name);
-	    swaps(&sectionWire->top);
-	    swaps(&sectionWire->left);
-	    swaps(&sectionWire->width);
-	    swaps(&sectionWire->height);
-	    swaps(&sectionWire->angle);
-	}
-	wire= (char *)&sectionWire[1];
-	if (section->rows) {
-	    int			r;
-	    XkbRowPtr		row;
-	    xkbRowWireDesc *	rowWire;
-	    for (r=0,row=section->rows;r<section->num_rows;r++,row++) {
-		rowWire= (xkbRowWireDesc *)wire;
-		rowWire->top= row->top;
-		rowWire->left= row->left;
-		rowWire->nKeys= row->num_keys;
-		rowWire->vertical= row->vertical;
-		rowWire->pad= 0;
-		if (swap) {
-		    swaps(&rowWire->top);
-		    swaps(&rowWire->left);
-		}
-		wire= (char *)&rowWire[1];
-		if (row->keys) {
-		    int			k;
-		    XkbKeyPtr		key;
-		    xkbKeyWireDesc *	keyWire;
-		    keyWire= (xkbKeyWireDesc *)wire;
-		    for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
-			memcpy(keyWire[k].name,key->name.name,XkbKeyNameLength);
-			keyWire[k].gap= key->gap;
-			keyWire[k].shapeNdx= key->shape_ndx;
-			keyWire[k].colorNdx= key->color_ndx;
-			if (swap) {
-			    swaps(&keyWire[k].gap);
-			}
-		    }
-		    wire= (char *)&keyWire[row->num_keys];
-		}
-	    }
-	}
-	if (section->doodads) {
-	    wire= XkbWriteGeomDoodads(wire,
-	    			      section->num_doodads,section->doodads,
-				      swap);
-	}
-	if (section->overlays) {
-	    register int o;
-	    for (o=0;o<section->num_overlays;o++) {
-		wire= XkbWriteGeomOverlay(wire,&section->overlays[o],swap);
-	    }
-	}
+    register int i;
+    XkbSectionPtr section;
+    xkbSectionWireDesc *sectionWire;
+
+    for (i = 0, section = geom->sections; i < geom->num_sections;
+         i++, section++) {
+        sectionWire = (xkbSectionWireDesc *) wire;
+        sectionWire->name = section->name;
+        sectionWire->top = section->top;
+        sectionWire->left = section->left;
+        sectionWire->width = section->width;
+        sectionWire->height = section->height;
+        sectionWire->angle = section->angle;
+        sectionWire->priority = section->priority;
+        sectionWire->nRows = section->num_rows;
+        sectionWire->nDoodads = section->num_doodads;
+        sectionWire->nOverlays = section->num_overlays;
+        sectionWire->pad = 0;
+        if (swap) {
+            swapl(&sectionWire->name);
+            swaps(&sectionWire->top);
+            swaps(&sectionWire->left);
+            swaps(&sectionWire->width);
+            swaps(&sectionWire->height);
+            swaps(&sectionWire->angle);
+        }
+        wire = (char *) &sectionWire[1];
+        if (section->rows) {
+            int r;
+            XkbRowPtr row;
+            xkbRowWireDesc *rowWire;
+
+            for (r = 0, row = section->rows; r < section->num_rows; r++, row++) {
+                rowWire = (xkbRowWireDesc *) wire;
+                rowWire->top = row->top;
+                rowWire->left = row->left;
+                rowWire->nKeys = row->num_keys;
+                rowWire->vertical = row->vertical;
+                rowWire->pad = 0;
+                if (swap) {
+                    swaps(&rowWire->top);
+                    swaps(&rowWire->left);
+                }
+                wire = (char *) &rowWire[1];
+                if (row->keys) {
+                    int k;
+                    XkbKeyPtr key;
+                    xkbKeyWireDesc *keyWire;
+
+                    keyWire = (xkbKeyWireDesc *) wire;
+                    for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+                        memcpy(keyWire[k].name, key->name.name,
+                               XkbKeyNameLength);
+                        keyWire[k].gap = key->gap;
+                        keyWire[k].shapeNdx = key->shape_ndx;
+                        keyWire[k].colorNdx = key->color_ndx;
+                        if (swap) {
+                            swaps(&keyWire[k].gap);
+                        }
+                    }
+                    wire = (char *) &keyWire[row->num_keys];
+                }
+            }
+        }
+        if (section->doodads) {
+            wire = XkbWriteGeomDoodads(wire,
+                                       section->num_doodads, section->doodads,
+                                       swap);
+        }
+        if (section->overlays) {
+            register int o;
+
+            for (o = 0; o < section->num_overlays; o++) {
+                wire = XkbWriteGeomOverlay(wire, &section->overlays[o], swap);
+            }
+        }
     }
     return wire;
 }
 
 static Status
-XkbComputeGetGeometryReplySize(	XkbGeometryPtr		geom,
-				xkbGetGeometryReply *	rep,
-				Atom			name)
+XkbComputeGetGeometryReplySize(XkbGeometryPtr geom,
+                               xkbGetGeometryReply * rep, Atom name)
 {
-int	len;
-
-    if (geom!=NULL) {
-	len= XkbSizeCountedString(geom->label_font);
-	len+= XkbSizeGeomProperties(geom);
-	len+= XkbSizeGeomColors(geom);
-	len+= XkbSizeGeomShapes(geom);
-	len+= XkbSizeGeomSections(geom);
-	len+= XkbSizeGeomDoodads(geom->num_doodads,geom->doodads);
-	len+= XkbSizeGeomKeyAliases(geom);
-	rep->length= len/4;
-	rep->found= TRUE;
-	rep->name= geom->name;
-	rep->widthMM= geom->width_mm;
-	rep->heightMM= geom->height_mm;
-	rep->nProperties= geom->num_properties;
-	rep->nColors= geom->num_colors;
-	rep->nShapes= geom->num_shapes;
-	rep->nSections= geom->num_sections;
-	rep->nDoodads= geom->num_doodads;
-	rep->nKeyAliases= geom->num_key_aliases;
-	rep->baseColorNdx= XkbGeomColorIndex(geom,geom->base_color);
-	rep->labelColorNdx= XkbGeomColorIndex(geom,geom->label_color);
+    int len;
+
+    if (geom != NULL) {
+        len = XkbSizeCountedString(geom->label_font);
+        len += XkbSizeGeomProperties(geom);
+        len += XkbSizeGeomColors(geom);
+        len += XkbSizeGeomShapes(geom);
+        len += XkbSizeGeomSections(geom);
+        len += XkbSizeGeomDoodads(geom->num_doodads, geom->doodads);
+        len += XkbSizeGeomKeyAliases(geom);
+        rep->length = len / 4;
+        rep->found = TRUE;
+        rep->name = geom->name;
+        rep->widthMM = geom->width_mm;
+        rep->heightMM = geom->height_mm;
+        rep->nProperties = geom->num_properties;
+        rep->nColors = geom->num_colors;
+        rep->nShapes = geom->num_shapes;
+        rep->nSections = geom->num_sections;
+        rep->nDoodads = geom->num_doodads;
+        rep->nKeyAliases = geom->num_key_aliases;
+        rep->baseColorNdx = XkbGeomColorIndex(geom, geom->base_color);
+        rep->labelColorNdx = XkbGeomColorIndex(geom, geom->label_color);
     }
     else {
-	rep->length= 0;
-	rep->found= FALSE;
-	rep->name= name;
-	rep->widthMM= rep->heightMM= 0;
-	rep->nProperties= rep->nColors= rep->nShapes= 0;
-	rep->nSections= rep->nDoodads= 0;
-	rep->nKeyAliases= 0;
-	rep->labelColorNdx= rep->baseColorNdx= 0;
+        rep->length = 0;
+        rep->found = FALSE;
+        rep->name = name;
+        rep->widthMM = rep->heightMM = 0;
+        rep->nProperties = rep->nColors = rep->nShapes = 0;
+        rep->nSections = rep->nDoodads = 0;
+        rep->nKeyAliases = 0;
+        rep->labelColorNdx = rep->baseColorNdx = 0;
     }
     return Success;
 }
 
 static int
-XkbSendGeometry(	ClientPtr		client,
-			XkbGeometryPtr		geom,
-			xkbGetGeometryReply *	rep,
-			Bool			freeGeom)
+XkbSendGeometry(ClientPtr client,
+                XkbGeometryPtr geom, xkbGetGeometryReply * rep, Bool freeGeom)
 {
-    char	*desc,*start;
-    int		 len;
-
-    if (geom!=NULL) {
-	len= rep->length*4;
-	start= desc= malloc(len);
-	if (!start)
-	    return BadAlloc;
-	desc=  XkbWriteCountedString(desc,geom->label_font,client->swapped);
-	if ( rep->nProperties>0 )
-	    desc = XkbWriteGeomProperties(desc,geom,client->swapped);
-	if ( rep->nColors>0 )
-	    desc = XkbWriteGeomColors(desc,geom,client->swapped);
-	if ( rep->nShapes>0 )
-	    desc = XkbWriteGeomShapes(desc,geom,client->swapped);
-	if ( rep->nSections>0 )
-	    desc = XkbWriteGeomSections(desc,geom,client->swapped);
-	if ( rep->nDoodads>0 )
-	    desc = XkbWriteGeomDoodads(desc,geom->num_doodads,geom->doodads,
-							  client->swapped);
-	if ( rep->nKeyAliases>0 )
-	    desc = XkbWriteGeomKeyAliases(desc,geom,client->swapped);
-	if ((desc-start)!=(len)) {
-	    ErrorF("[xkb] BOGUS LENGTH in XkbSendGeometry, expected %d, got %ld\n",
-			len, (unsigned long)(desc-start));
-	}
+    char *desc, *start;
+    int len;
+
+    if (geom != NULL) {
+        len = rep->length * 4;
+        start = desc = malloc(len);
+        if (!start)
+            return BadAlloc;
+        desc = XkbWriteCountedString(desc, geom->label_font, client->swapped);
+        if (rep->nProperties > 0)
+            desc = XkbWriteGeomProperties(desc, geom, client->swapped);
+        if (rep->nColors > 0)
+            desc = XkbWriteGeomColors(desc, geom, client->swapped);
+        if (rep->nShapes > 0)
+            desc = XkbWriteGeomShapes(desc, geom, client->swapped);
+        if (rep->nSections > 0)
+            desc = XkbWriteGeomSections(desc, geom, client->swapped);
+        if (rep->nDoodads > 0)
+            desc = XkbWriteGeomDoodads(desc, geom->num_doodads, geom->doodads,
+                                       client->swapped);
+        if (rep->nKeyAliases > 0)
+            desc = XkbWriteGeomKeyAliases(desc, geom, client->swapped);
+        if ((desc - start) != (len)) {
+            ErrorF
+                ("[xkb] BOGUS LENGTH in XkbSendGeometry, expected %d, got %ld\n",
+                 len, (unsigned long) (desc - start));
+        }
     }
     else {
-	len= 0;
-	start= NULL;
+        len = 0;
+        start = NULL;
     }
     if (client->swapped) {
-	swaps(&rep->sequenceNumber);
-	swapl(&rep->length);
-	swapl(&rep->name);
-	swaps(&rep->widthMM);
-	swaps(&rep->heightMM);
-	swaps(&rep->nProperties);
-	swaps(&rep->nColors);
-	swaps(&rep->nShapes);
-	swaps(&rep->nSections);
-	swaps(&rep->nDoodads);
-	swaps(&rep->nKeyAliases);
-    }
-    WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *)rep);
-    if (len>0)
-	WriteToClient(client, len, start);
-    if (start!=NULL)
-	free((char *)start);
+        swaps(&rep->sequenceNumber);
+        swapl(&rep->length);
+        swapl(&rep->name);
+        swaps(&rep->widthMM);
+        swaps(&rep->heightMM);
+        swaps(&rep->nProperties);
+        swaps(&rep->nColors);
+        swaps(&rep->nShapes);
+        swaps(&rep->nSections);
+        swaps(&rep->nDoodads);
+        swaps(&rep->nKeyAliases);
+    }
+    WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *) rep);
+    if (len > 0)
+        WriteToClient(client, len, start);
+    if (start != NULL)
+        free((char *) start);
     if (freeGeom)
-	XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
+        XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
     return Success;
 }
 
 int
 ProcXkbGetGeometry(ClientPtr client)
 {
-    DeviceIntPtr 	dev;
+    DeviceIntPtr dev;
     xkbGetGeometryReply rep;
-    XkbGeometryPtr	geom;
-    Bool		shouldFree;
-    Status		status;
+    XkbGeometryPtr geom;
+    Bool shouldFree;
+    Status status;
 
     REQUEST(xkbGetGeometryReq);
     REQUEST_SIZE_MATCH(xkbGetGeometryReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
     CHK_ATOM_OR_NONE(stuff->name);
 
-    geom= XkbLookupNamedGeometry(dev,stuff->name,&shouldFree);
-    rep.type= X_Reply;
-    rep.deviceID= dev->id;
-    rep.sequenceNumber= client->sequence;
-    rep.length= 0;
-    status= XkbComputeGetGeometryReplySize(geom,&rep,stuff->name);
-    if (status!=Success)
-	 return status;
-    else return XkbSendGeometry(client,geom,&rep,shouldFree);
+    geom = XkbLookupNamedGeometry(dev, stuff->name, &shouldFree);
+    rep.type = X_Reply;
+    rep.deviceID = dev->id;
+    rep.sequenceNumber = client->sequence;
+    rep.length = 0;
+    status = XkbComputeGetGeometryReplySize(geom, &rep, stuff->name);
+    if (status != Success)
+        return status;
+    else
+        return XkbSendGeometry(client, geom, &rep, shouldFree);
 }
 
 /***====================================================================***/
 
 static char *
-_GetCountedString(char **wire_inout,Bool swap)
+_GetCountedString(char **wire_inout, Bool swap)
 {
-char *	wire,*str;
-CARD16	len,*plen;
+    char *wire, *str;
+    CARD16 len, *plen;
 
-    wire= *wire_inout;
-    plen= (CARD16 *)wire;
+    wire = *wire_inout;
+    plen = (CARD16 *) wire;
     if (swap) {
-	swaps(plen);
+        swaps(plen);
     }
-    len= *plen;
-    str= malloc(len+1);
+    len = *plen;
+    str = malloc(len + 1);
     if (str) {
-	memcpy(str,&wire[2],len);
-	str[len]= '\0';
+        memcpy(str, &wire[2], len);
+        str[len] = '\0';
     }
-    wire+= XkbPaddedSize(len+2);
-    *wire_inout= wire;
+    wire += XkbPaddedSize(len + 2);
+    *wire_inout = wire;
     return str;
 }
 
 static Status
-_CheckSetDoodad(	char **		wire_inout,
-			XkbGeometryPtr	geom,
-			XkbSectionPtr	section,
-			ClientPtr	client)
+_CheckSetDoodad(char **wire_inout,
+                XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
 {
-char *			wire;
-xkbDoodadWireDesc *	dWire;
-XkbDoodadPtr		doodad;
+    char *wire;
+    xkbDoodadWireDesc *dWire;
+    XkbDoodadPtr doodad;
 
-    dWire= (xkbDoodadWireDesc *)(*wire_inout);
-    wire= (char *)&dWire[1];
+    dWire = (xkbDoodadWireDesc *) (*wire_inout);
+    wire = (char *) &dWire[1];
     if (client->swapped) {
-	swapl(&dWire->any.name);
-	swaps(&dWire->any.top);
-	swaps(&dWire->any.left);
-	swaps(&dWire->any.angle);
+        swapl(&dWire->any.name);
+        swaps(&dWire->any.top);
+        swaps(&dWire->any.left);
+        swaps(&dWire->any.angle);
     }
     CHK_ATOM_ONLY(dWire->any.name);
-    doodad= XkbAddGeomDoodad(geom,section,dWire->any.name);
+    doodad = XkbAddGeomDoodad(geom, section, dWire->any.name);
     if (!doodad)
-	return BadAlloc;
-    doodad->any.type= dWire->any.type;
-    doodad->any.priority= dWire->any.priority;
-    doodad->any.top= dWire->any.top;
-    doodad->any.left= dWire->any.left;
-    doodad->any.angle= dWire->any.angle;
+        return BadAlloc;
+    doodad->any.type = dWire->any.type;
+    doodad->any.priority = dWire->any.priority;
+    doodad->any.top = dWire->any.top;
+    doodad->any.left = dWire->any.left;
+    doodad->any.angle = dWire->any.angle;
     switch (doodad->any.type) {
-	case XkbOutlineDoodad:
-	case XkbSolidDoodad:
-	    if (dWire->shape.colorNdx>=geom->num_colors) {
-		client->errorValue= _XkbErrCode3(0x40,geom->num_colors,
-							dWire->shape.colorNdx);
-		return BadMatch;
-	    }
-	    if (dWire->shape.shapeNdx>=geom->num_shapes) {
-		client->errorValue= _XkbErrCode3(0x41,geom->num_shapes,
-							dWire->shape.shapeNdx);
-		return BadMatch;
-	    }
-	    doodad->shape.color_ndx= dWire->shape.colorNdx;
-	    doodad->shape.shape_ndx= dWire->shape.shapeNdx;
-	    break;
-	case XkbTextDoodad:
-	    if (dWire->text.colorNdx>=geom->num_colors) {
-		client->errorValue= _XkbErrCode3(0x42,geom->num_colors,
-							dWire->text.colorNdx);
-		return BadMatch;
-	    }
-	    if (client->swapped) {
-		swaps(&dWire->text.width);
-		swaps(&dWire->text.height);
-	    }
-	    doodad->text.width= dWire->text.width;
-	    doodad->text.height= dWire->text.height;
-	    doodad->text.color_ndx= dWire->text.colorNdx;
-	    doodad->text.text= _GetCountedString(&wire,client->swapped);
-	    doodad->text.font= _GetCountedString(&wire,client->swapped);
-	    break;
-	case XkbIndicatorDoodad:
-	    if (dWire->indicator.onColorNdx>=geom->num_colors) {
-		client->errorValue= _XkbErrCode3(0x43,geom->num_colors,
-						dWire->indicator.onColorNdx);
-		return BadMatch;
-	    }
-	    if (dWire->indicator.offColorNdx>=geom->num_colors) {
-		client->errorValue= _XkbErrCode3(0x44,geom->num_colors,
-						dWire->indicator.offColorNdx);
-		return BadMatch;
-	    }
-	    if (dWire->indicator.shapeNdx>=geom->num_shapes) {
-		client->errorValue= _XkbErrCode3(0x45,geom->num_shapes,
-						dWire->indicator.shapeNdx);
-		return BadMatch;
-	    }
-	    doodad->indicator.shape_ndx= dWire->indicator.shapeNdx;
-	    doodad->indicator.on_color_ndx= dWire->indicator.onColorNdx;
-	    doodad->indicator.off_color_ndx= dWire->indicator.offColorNdx;
-	    break;
-	case XkbLogoDoodad:
-	    if (dWire->logo.colorNdx>=geom->num_colors) {
-		client->errorValue= _XkbErrCode3(0x46,geom->num_colors,
-							dWire->logo.colorNdx);
-		return BadMatch;
-	    }
-	    if (dWire->logo.shapeNdx>=geom->num_shapes) {
-		client->errorValue= _XkbErrCode3(0x47,geom->num_shapes,
-							dWire->logo.shapeNdx);
-		return BadMatch;
-	    }
-	    doodad->logo.color_ndx= dWire->logo.colorNdx;
-	    doodad->logo.shape_ndx= dWire->logo.shapeNdx;
-	    doodad->logo.logo_name= _GetCountedString(&wire,client->swapped);
-	    break;
-	default:
-	    client->errorValue= _XkbErrCode2(0x4F,dWire->any.type);
-	    return BadValue;
-    }
-    *wire_inout= wire;
+    case XkbOutlineDoodad:
+    case XkbSolidDoodad:
+        if (dWire->shape.colorNdx >= geom->num_colors) {
+            client->errorValue = _XkbErrCode3(0x40, geom->num_colors,
+                                              dWire->shape.colorNdx);
+            return BadMatch;
+        }
+        if (dWire->shape.shapeNdx >= geom->num_shapes) {
+            client->errorValue = _XkbErrCode3(0x41, geom->num_shapes,
+                                              dWire->shape.shapeNdx);
+            return BadMatch;
+        }
+        doodad->shape.color_ndx = dWire->shape.colorNdx;
+        doodad->shape.shape_ndx = dWire->shape.shapeNdx;
+        break;
+    case XkbTextDoodad:
+        if (dWire->text.colorNdx >= geom->num_colors) {
+            client->errorValue = _XkbErrCode3(0x42, geom->num_colors,
+                                              dWire->text.colorNdx);
+            return BadMatch;
+        }
+        if (client->swapped) {
+            swaps(&dWire->text.width);
+            swaps(&dWire->text.height);
+        }
+        doodad->text.width = dWire->text.width;
+        doodad->text.height = dWire->text.height;
+        doodad->text.color_ndx = dWire->text.colorNdx;
+        doodad->text.text = _GetCountedString(&wire, client->swapped);
+        doodad->text.font = _GetCountedString(&wire, client->swapped);
+        break;
+    case XkbIndicatorDoodad:
+        if (dWire->indicator.onColorNdx >= geom->num_colors) {
+            client->errorValue = _XkbErrCode3(0x43, geom->num_colors,
+                                              dWire->indicator.onColorNdx);
+            return BadMatch;
+        }
+        if (dWire->indicator.offColorNdx >= geom->num_colors) {
+            client->errorValue = _XkbErrCode3(0x44, geom->num_colors,
+                                              dWire->indicator.offColorNdx);
+            return BadMatch;
+        }
+        if (dWire->indicator.shapeNdx >= geom->num_shapes) {
+            client->errorValue = _XkbErrCode3(0x45, geom->num_shapes,
+                                              dWire->indicator.shapeNdx);
+            return BadMatch;
+        }
+        doodad->indicator.shape_ndx = dWire->indicator.shapeNdx;
+        doodad->indicator.on_color_ndx = dWire->indicator.onColorNdx;
+        doodad->indicator.off_color_ndx = dWire->indicator.offColorNdx;
+        break;
+    case XkbLogoDoodad:
+        if (dWire->logo.colorNdx >= geom->num_colors) {
+            client->errorValue = _XkbErrCode3(0x46, geom->num_colors,
+                                              dWire->logo.colorNdx);
+            return BadMatch;
+        }
+        if (dWire->logo.shapeNdx >= geom->num_shapes) {
+            client->errorValue = _XkbErrCode3(0x47, geom->num_shapes,
+                                              dWire->logo.shapeNdx);
+            return BadMatch;
+        }
+        doodad->logo.color_ndx = dWire->logo.colorNdx;
+        doodad->logo.shape_ndx = dWire->logo.shapeNdx;
+        doodad->logo.logo_name = _GetCountedString(&wire, client->swapped);
+        break;
+    default:
+        client->errorValue = _XkbErrCode2(0x4F, dWire->any.type);
+        return BadValue;
+    }
+    *wire_inout = wire;
     return Success;
 }
 
 static Status
-_CheckSetOverlay(	char **		wire_inout,
-			XkbGeometryPtr	geom,
-			XkbSectionPtr	section,
-			ClientPtr	client)
+_CheckSetOverlay(char **wire_inout,
+                 XkbGeometryPtr geom, XkbSectionPtr section, ClientPtr client)
 {
-register int		r;
-char *			wire;
-XkbOverlayPtr		ol;
-xkbOverlayWireDesc *	olWire;
-xkbOverlayRowWireDesc *	rWire;
-
-    wire= *wire_inout;
-    olWire= (xkbOverlayWireDesc *)wire;
+    register int r;
+    char *wire;
+    XkbOverlayPtr ol;
+    xkbOverlayWireDesc *olWire;
+    xkbOverlayRowWireDesc *rWire;
+
+    wire = *wire_inout;
+    olWire = (xkbOverlayWireDesc *) wire;
     if (client->swapped) {
-	swapl(&olWire->name);
+        swapl(&olWire->name);
     }
     CHK_ATOM_ONLY(olWire->name);
-    ol= XkbAddGeomOverlay(section,olWire->name,olWire->nRows);
-    rWire= (xkbOverlayRowWireDesc *)&olWire[1];
-    for (r=0;r<olWire->nRows;r++) {
-	register int		k;
-	xkbOverlayKeyWireDesc *	kWire;
-	XkbOverlayRowPtr	row;
-
-	if (rWire->rowUnder>section->num_rows) {
-	    client->errorValue= _XkbErrCode4(0x20,r,section->num_rows,
-							rWire->rowUnder);
-	    return BadMatch;
-	}
-	row= XkbAddGeomOverlayRow(ol,rWire->rowUnder,rWire->nKeys);
-	kWire= (xkbOverlayKeyWireDesc *)&rWire[1];
-	for (k=0;k<rWire->nKeys;k++,kWire++) {
-	    if (XkbAddGeomOverlayKey(ol,row,
-	    		(char *)kWire->over,(char *)kWire->under)==NULL) {
-		client->errorValue= _XkbErrCode3(0x21,r,k);
-		return BadMatch;
-	    }	
-	}
-	rWire= (xkbOverlayRowWireDesc *)kWire;
-    }
-    olWire= (xkbOverlayWireDesc *)rWire;
-    wire= (char *)olWire;
-    *wire_inout= wire;
+    ol = XkbAddGeomOverlay(section, olWire->name, olWire->nRows);
+    rWire = (xkbOverlayRowWireDesc *) & olWire[1];
+    for (r = 0; r < olWire->nRows; r++) {
+        register int k;
+        xkbOverlayKeyWireDesc *kWire;
+        XkbOverlayRowPtr row;
+
+        if (rWire->rowUnder > section->num_rows) {
+            client->errorValue = _XkbErrCode4(0x20, r, section->num_rows,
+                                              rWire->rowUnder);
+            return BadMatch;
+        }
+        row = XkbAddGeomOverlayRow(ol, rWire->rowUnder, rWire->nKeys);
+        kWire = (xkbOverlayKeyWireDesc *) & rWire[1];
+        for (k = 0; k < rWire->nKeys; k++, kWire++) {
+            if (XkbAddGeomOverlayKey(ol, row,
+                                     (char *) kWire->over,
+                                     (char *) kWire->under) == NULL) {
+                client->errorValue = _XkbErrCode3(0x21, r, k);
+                return BadMatch;
+            }
+        }
+        rWire = (xkbOverlayRowWireDesc *) kWire;
+    }
+    olWire = (xkbOverlayWireDesc *) rWire;
+    wire = (char *) olWire;
+    *wire_inout = wire;
     return Success;
 }
 
 static Status
-_CheckSetSections( 	XkbGeometryPtr		geom,
-			xkbSetGeometryReq *	req,
-			char **			wire_inout,
-			ClientPtr		client)
+_CheckSetSections(XkbGeometryPtr geom,
+                  xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
 {
-Status			status;
-register int		s;
-char *			wire;
-xkbSectionWireDesc *	sWire;
-XkbSectionPtr		section;
-
-    wire= *wire_inout;
-    if (req->nSections<1)
-	return Success;
-    sWire= (xkbSectionWireDesc *)wire;
-    for (s=0;s<req->nSections;s++) {
-	register int		r;
-	xkbRowWireDesc *	rWire;
-	if (client->swapped) {
-	    swapl(&sWire->name);
-	    swaps(&sWire->top);
-	    swaps(&sWire->left);
-	    swaps(&sWire->width);
-	    swaps(&sWire->height);
-	    swaps(&sWire->angle);
-	}
-	CHK_ATOM_ONLY(sWire->name);
-	section= XkbAddGeomSection(geom,sWire->name,sWire->nRows,
-					sWire->nDoodads,sWire->nOverlays);
-	if (!section)
-	    return BadAlloc;
-	section->priority=	sWire->priority;
-	section->top=		sWire->top;
-	section->left=		sWire->left;
-	section->width=		sWire->width;
-	section->height=	sWire->height;
-	section->angle=		sWire->angle;
-	rWire= (xkbRowWireDesc *)&sWire[1];
-	for (r=0;r<sWire->nRows;r++) {
-	    register int	k;
-	    XkbRowPtr		row;
-	    xkbKeyWireDesc *	kWire;
-	    if (client->swapped) {
-		swaps(&rWire->top);
-		swaps(&rWire->left);
-	    }
-	    row= XkbAddGeomRow(section,rWire->nKeys);
-	    if (!row)
-		return BadAlloc;
-	    row->top= rWire->top;
-	    row->left= rWire->left;
-	    row->vertical= rWire->vertical;
-	    kWire= (xkbKeyWireDesc *)&rWire[1];
-	    for (k=0;k<rWire->nKeys;k++) {
-		XkbKeyPtr	key;
-		key= XkbAddGeomKey(row);
-		if (!key)
-		    return BadAlloc;
-		memcpy(key->name.name,kWire[k].name,XkbKeyNameLength);
-		key->gap= kWire[k].gap;
-		key->shape_ndx= kWire[k].shapeNdx;
-		key->color_ndx= kWire[k].colorNdx;
-		if (key->shape_ndx>=geom->num_shapes) {
-		    client->errorValue= _XkbErrCode3(0x10,key->shape_ndx,
-							  geom->num_shapes);
-		    return BadMatch;
-		}
-		if (key->color_ndx>=geom->num_colors) {
-		    client->errorValue= _XkbErrCode3(0x11,key->color_ndx,
-							  geom->num_colors);
-		    return BadMatch;
-		}
-	    }
-	    rWire= (xkbRowWireDesc *)&kWire[rWire->nKeys];
-	}
-	wire= (char *)rWire;
-	if (sWire->nDoodads>0) {
-	    register int d;
-	    for (d=0;d<sWire->nDoodads;d++) {
-		status=_CheckSetDoodad(&wire,geom,section,client);
-		if (status!=Success)
-		    return status;
-	    }
-	}
-	if (sWire->nOverlays>0) {
-	    register int o;
-	    for (o=0;o<sWire->nOverlays;o++) {
-		status= _CheckSetOverlay(&wire,geom,section,client);
-		if (status!=Success)
-		    return status;
-	    }
-	}
-	sWire= (xkbSectionWireDesc *)wire;
-    }
-    wire= (char *)sWire;
-    *wire_inout= wire;
+    Status status;
+    register int s;
+    char *wire;
+    xkbSectionWireDesc *sWire;
+    XkbSectionPtr section;
+
+    wire = *wire_inout;
+    if (req->nSections < 1)
+        return Success;
+    sWire = (xkbSectionWireDesc *) wire;
+    for (s = 0; s < req->nSections; s++) {
+        register int r;
+        xkbRowWireDesc *rWire;
+
+        if (client->swapped) {
+            swapl(&sWire->name);
+            swaps(&sWire->top);
+            swaps(&sWire->left);
+            swaps(&sWire->width);
+            swaps(&sWire->height);
+            swaps(&sWire->angle);
+        }
+        CHK_ATOM_ONLY(sWire->name);
+        section = XkbAddGeomSection(geom, sWire->name, sWire->nRows,
+                                    sWire->nDoodads, sWire->nOverlays);
+        if (!section)
+            return BadAlloc;
+        section->priority = sWire->priority;
+        section->top = sWire->top;
+        section->left = sWire->left;
+        section->width = sWire->width;
+        section->height = sWire->height;
+        section->angle = sWire->angle;
+        rWire = (xkbRowWireDesc *) & sWire[1];
+        for (r = 0; r < sWire->nRows; r++) {
+            register int k;
+            XkbRowPtr row;
+            xkbKeyWireDesc *kWire;
+
+            if (client->swapped) {
+                swaps(&rWire->top);
+                swaps(&rWire->left);
+            }
+            row = XkbAddGeomRow(section, rWire->nKeys);
+            if (!row)
+                return BadAlloc;
+            row->top = rWire->top;
+            row->left = rWire->left;
+            row->vertical = rWire->vertical;
+            kWire = (xkbKeyWireDesc *) & rWire[1];
+            for (k = 0; k < rWire->nKeys; k++) {
+                XkbKeyPtr key;
+
+                key = XkbAddGeomKey(row);
+                if (!key)
+                    return BadAlloc;
+                memcpy(key->name.name, kWire[k].name, XkbKeyNameLength);
+                key->gap = kWire[k].gap;
+                key->shape_ndx = kWire[k].shapeNdx;
+                key->color_ndx = kWire[k].colorNdx;
+                if (key->shape_ndx >= geom->num_shapes) {
+                    client->errorValue = _XkbErrCode3(0x10, key->shape_ndx,
+                                                      geom->num_shapes);
+                    return BadMatch;
+                }
+                if (key->color_ndx >= geom->num_colors) {
+                    client->errorValue = _XkbErrCode3(0x11, key->color_ndx,
+                                                      geom->num_colors);
+                    return BadMatch;
+                }
+            }
+            rWire = (xkbRowWireDesc *) & kWire[rWire->nKeys];
+        }
+        wire = (char *) rWire;
+        if (sWire->nDoodads > 0) {
+            register int d;
+
+            for (d = 0; d < sWire->nDoodads; d++) {
+                status = _CheckSetDoodad(&wire, geom, section, client);
+                if (status != Success)
+                    return status;
+            }
+        }
+        if (sWire->nOverlays > 0) {
+            register int o;
+
+            for (o = 0; o < sWire->nOverlays; o++) {
+                status = _CheckSetOverlay(&wire, geom, section, client);
+                if (status != Success)
+                    return status;
+            }
+        }
+        sWire = (xkbSectionWireDesc *) wire;
+    }
+    wire = (char *) sWire;
+    *wire_inout = wire;
     return Success;
 }
 
 static Status
-_CheckSetShapes( 	XkbGeometryPtr		geom,
-			xkbSetGeometryReq *	req,
-			char **			wire_inout,
-			ClientPtr		client)
+_CheckSetShapes(XkbGeometryPtr geom,
+                xkbSetGeometryReq * req, char **wire_inout, ClientPtr client)
 {
-register int	i;
-char *		wire;
+    register int i;
+    char *wire;
 
-    wire= *wire_inout;
-    if (req->nShapes<1) {
-	client->errorValue= _XkbErrCode2(0x06,req->nShapes);
-	return BadValue;
+    wire = *wire_inout;
+    if (req->nShapes < 1) {
+        client->errorValue = _XkbErrCode2(0x06, req->nShapes);
+        return BadValue;
     }
     else {
-	xkbShapeWireDesc *	shapeWire;
-	XkbShapePtr		shape;
-	register int		o;
-	shapeWire= (xkbShapeWireDesc *)wire;
-	for (i=0;i<req->nShapes;i++) {
-	    xkbOutlineWireDesc *	olWire;
-	    XkbOutlinePtr		ol;
-	    shape= XkbAddGeomShape(geom,shapeWire->name,shapeWire->nOutlines);
-	    if (!shape)
-		return BadAlloc;
-	    olWire= (xkbOutlineWireDesc *)(&shapeWire[1]);
-	    for (o=0;o<shapeWire->nOutlines;o++) {
-		register int		p;
-		XkbPointPtr		pt;
-		xkbPointWireDesc *	ptWire;
-
-		ol= XkbAddGeomOutline(shape,olWire->nPoints);
-		if (!ol)
-		    return BadAlloc;
-		ol->corner_radius=	olWire->cornerRadius;
-		ptWire= (xkbPointWireDesc *)&olWire[1];
-		for (p=0,pt=ol->points;p<olWire->nPoints;p++,pt++) {
-		    pt->x= ptWire[p].x;
-		    pt->y= ptWire[p].y;
-		    if (client->swapped) {
-			swaps(&pt->x);
-			swaps(&pt->y);
-		    }
-		}
-		ol->num_points= olWire->nPoints;
-		olWire= (xkbOutlineWireDesc *)(&ptWire[olWire->nPoints]);
-	    }
-	    if (shapeWire->primaryNdx!=XkbNoShape)
-		shape->primary= &shape->outlines[shapeWire->primaryNdx];
-	    if (shapeWire->approxNdx!=XkbNoShape)
-		shape->approx= &shape->outlines[shapeWire->approxNdx];
-	    shapeWire= (xkbShapeWireDesc *)olWire;
-	}
-	wire= (char *)shapeWire;
-    }
-    if (geom->num_shapes!=req->nShapes) {
-	client->errorValue= _XkbErrCode3(0x07,geom->num_shapes,req->nShapes);
-	return BadMatch;
-    }
-
-    *wire_inout= wire;
+        xkbShapeWireDesc *shapeWire;
+        XkbShapePtr shape;
+        register int o;
+
+        shapeWire = (xkbShapeWireDesc *) wire;
+        for (i = 0; i < req->nShapes; i++) {
+            xkbOutlineWireDesc *olWire;
+            XkbOutlinePtr ol;
+
+            shape =
+                XkbAddGeomShape(geom, shapeWire->name, shapeWire->nOutlines);
+            if (!shape)
+                return BadAlloc;
+            olWire = (xkbOutlineWireDesc *) (&shapeWire[1]);
+            for (o = 0; o < shapeWire->nOutlines; o++) {
+                register int p;
+                XkbPointPtr pt;
+                xkbPointWireDesc *ptWire;
+
+                ol = XkbAddGeomOutline(shape, olWire->nPoints);
+                if (!ol)
+                    return BadAlloc;
+                ol->corner_radius = olWire->cornerRadius;
+                ptWire = (xkbPointWireDesc *) & olWire[1];
+                for (p = 0, pt = ol->points; p < olWire->nPoints; p++, pt++) {
+                    pt->x = ptWire[p].x;
+                    pt->y = ptWire[p].y;
+                    if (client->swapped) {
+                        swaps(&pt->x);
+                        swaps(&pt->y);
+                    }
+                }
+                ol->num_points = olWire->nPoints;
+                olWire = (xkbOutlineWireDesc *) (&ptWire[olWire->nPoints]);
+            }
+            if (shapeWire->primaryNdx != XkbNoShape)
+                shape->primary = &shape->outlines[shapeWire->primaryNdx];
+            if (shapeWire->approxNdx != XkbNoShape)
+                shape->approx = &shape->outlines[shapeWire->approxNdx];
+            shapeWire = (xkbShapeWireDesc *) olWire;
+        }
+        wire = (char *) shapeWire;
+    }
+    if (geom->num_shapes != req->nShapes) {
+        client->errorValue = _XkbErrCode3(0x07, geom->num_shapes, req->nShapes);
+        return BadMatch;
+    }
+
+    *wire_inout = wire;
     return Success;
 }
 
 static Status
-_CheckSetGeom(	XkbGeometryPtr		geom,
-		xkbSetGeometryReq *	req,
-		ClientPtr 		client)
+_CheckSetGeom(XkbGeometryPtr geom, xkbSetGeometryReq * req, ClientPtr client)
 {
-register int	i;
-Status		status;
-char *		wire;
+    register int i;
+    Status status;
+    char *wire;
+
+    wire = (char *) &req[1];
+    geom->label_font = _GetCountedString(&wire, client->swapped);
 
-    wire= (char *)&req[1];
-    geom->label_font= _GetCountedString(&wire,client->swapped);
+    for (i = 0; i < req->nProperties; i++) {
+        char *name, *val;
 
-    for (i=0;i<req->nProperties;i++) {
-	char *name,*val;
-	name= _GetCountedString(&wire,client->swapped);
+        name = _GetCountedString(&wire, client->swapped);
         if (!name)
             return BadAlloc;
-	val= _GetCountedString(&wire,client->swapped);
+        val = _GetCountedString(&wire, client->swapped);
         if (!val) {
             free(name);
             return BadAlloc;
         }
-	if (XkbAddGeomProperty(geom,name,val)==NULL) {
+        if (XkbAddGeomProperty(geom, name, val) == NULL) {
             free(name);
             free(val);
-	    return BadAlloc;
+            return BadAlloc;
         }
         free(name);
         free(val);
     }
 
-    if (req->nColors<2) {
-	client->errorValue= _XkbErrCode3(0x01,2,req->nColors);
-	return BadValue;
+    if (req->nColors < 2) {
+        client->errorValue = _XkbErrCode3(0x01, 2, req->nColors);
+        return BadValue;
     }
-    if (req->baseColorNdx>req->nColors) {
-	client->errorValue=_XkbErrCode3(0x03,req->nColors,req->baseColorNdx);
-	return BadMatch;
+    if (req->baseColorNdx > req->nColors) {
+        client->errorValue =
+            _XkbErrCode3(0x03, req->nColors, req->baseColorNdx);
+        return BadMatch;
     }
-    if (req->labelColorNdx>req->nColors) {
-	client->errorValue= _XkbErrCode3(0x03,req->nColors,req->labelColorNdx);
-	return BadMatch;
+    if (req->labelColorNdx > req->nColors) {
+        client->errorValue =
+            _XkbErrCode3(0x03, req->nColors, req->labelColorNdx);
+        return BadMatch;
     }
-    if (req->labelColorNdx==req->baseColorNdx) {
-	client->errorValue= _XkbErrCode3(0x04,req->baseColorNdx,
-                                         req->labelColorNdx);
-	return BadMatch;
+    if (req->labelColorNdx == req->baseColorNdx) {
+        client->errorValue = _XkbErrCode3(0x04, req->baseColorNdx,
+                                          req->labelColorNdx);
+        return BadMatch;
     }
 
-    for (i=0;i<req->nColors;i++) {
-	char *name;
-	name= _GetCountedString(&wire,client->swapped);
-	if (!name)
+    for (i = 0; i < req->nColors; i++) {
+        char *name;
+
+        name = _GetCountedString(&wire, client->swapped);
+        if (!name)
             return BadAlloc;
-        if (!XkbAddGeomColor(geom,name,geom->num_colors)) {
+        if (!XkbAddGeomColor(geom, name, geom->num_colors)) {
             free(name);
-	    return BadAlloc;
+            return BadAlloc;
         }
         free(name);
     }
-    if (req->nColors!=geom->num_colors) {
-	client->errorValue= _XkbErrCode3(0x05,req->nColors,geom->num_colors);
-	return BadMatch;
+    if (req->nColors != geom->num_colors) {
+        client->errorValue = _XkbErrCode3(0x05, req->nColors, geom->num_colors);
+        return BadMatch;
     }
-    geom->label_color= &geom->colors[req->labelColorNdx];
-    geom->base_color= &geom->colors[req->baseColorNdx];
+    geom->label_color = &geom->colors[req->labelColorNdx];
+    geom->base_color = &geom->colors[req->baseColorNdx];
 
-    if ((status=_CheckSetShapes(geom,req,&wire,client))!=Success)
-	return status;
+    if ((status = _CheckSetShapes(geom, req, &wire, client)) != Success)
+        return status;
 
-    if ((status=_CheckSetSections(geom,req,&wire,client))!=Success)
-	return status;
+    if ((status = _CheckSetSections(geom, req, &wire, client)) != Success)
+        return status;
 
-    for (i=0;i<req->nDoodads;i++) {
-	status=_CheckSetDoodad(&wire,geom,NULL,client);
-	if (status!=Success)
-	    return status;
+    for (i = 0; i < req->nDoodads; i++) {
+        status = _CheckSetDoodad(&wire, geom, NULL, client);
+        if (status != Success)
+            return status;
     }
 
-    for (i=0;i<req->nKeyAliases;i++) {
-	if (XkbAddGeomKeyAlias(geom,&wire[XkbKeyNameLength],wire)==NULL)
-	    return BadAlloc;
-	wire+= 2*XkbKeyNameLength;
+    for (i = 0; i < req->nKeyAliases; i++) {
+        if (XkbAddGeomKeyAlias(geom, &wire[XkbKeyNameLength], wire) == NULL)
+            return BadAlloc;
+        wire += 2 * XkbKeyNameLength;
     }
     return Success;
 }
 
 static int
-_XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq *stuff)
+_XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
 {
-    XkbDescPtr		xkb;
-    Bool		new_name;
-    xkbNewKeyboardNotify	nkn;
-    XkbGeometryPtr	geom,old;
-    XkbGeometrySizesRec	sizes;
-    Status		status;
-
-    xkb= dev->key->xkbInfo->desc;
-    old= xkb->geom;
-    xkb->geom= NULL;
-
-    sizes.which=		XkbGeomAllMask;
-    sizes.num_properties=	stuff->nProperties;
-    sizes.num_colors=	stuff->nColors;
-    sizes.num_shapes=	stuff->nShapes;
-    sizes.num_sections=	stuff->nSections;
-    sizes.num_doodads=	stuff->nDoodads;
-    sizes.num_key_aliases=	stuff->nKeyAliases;
-    if ((status= XkbAllocGeometry(xkb,&sizes))!=Success) {
-        xkb->geom= old;
+    XkbDescPtr xkb;
+    Bool new_name;
+    xkbNewKeyboardNotify nkn;
+    XkbGeometryPtr geom, old;
+    XkbGeometrySizesRec sizes;
+    Status status;
+
+    xkb = dev->key->xkbInfo->desc;
+    old = xkb->geom;
+    xkb->geom = NULL;
+
+    sizes.which = XkbGeomAllMask;
+    sizes.num_properties = stuff->nProperties;
+    sizes.num_colors = stuff->nColors;
+    sizes.num_shapes = stuff->nShapes;
+    sizes.num_sections = stuff->nSections;
+    sizes.num_doodads = stuff->nDoodads;
+    sizes.num_key_aliases = stuff->nKeyAliases;
+    if ((status = XkbAllocGeometry(xkb, &sizes)) != Success) {
+        xkb->geom = old;
         return status;
     }
-    geom= xkb->geom;
-    geom->name= stuff->name;
-    geom->width_mm= stuff->widthMM;
-    geom->height_mm= stuff->heightMM;
-    if ((status= _CheckSetGeom(geom,stuff,client))!=Success) {
-        XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
-        xkb->geom= old;
+    geom = xkb->geom;
+    geom->name = stuff->name;
+    geom->width_mm = stuff->widthMM;
+    geom->height_mm = stuff->heightMM;
+    if ((status = _CheckSetGeom(geom, stuff, client)) != Success) {
+        XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
+        xkb->geom = old;
         return status;
     }
-    new_name= (xkb->names->geometry!=geom->name);
-    xkb->names->geometry= geom->name;
+    new_name = (xkb->names->geometry != geom->name);
+    xkb->names->geometry = geom->name;
     if (old)
-        XkbFreeGeometry(old,XkbGeomAllMask,TRUE);
+        XkbFreeGeometry(old, XkbGeomAllMask, TRUE);
     if (new_name) {
-        xkbNamesNotify	nn;
+        xkbNamesNotify nn;
+
         memset(&nn, 0, sizeof(xkbNamesNotify));
-        nn.changed= XkbGeometryNameMask;
-        XkbSendNamesNotify(dev,&nn);
-    }
-    nkn.deviceID= nkn.oldDeviceID= dev->id;
-    nkn.minKeyCode= nkn.oldMinKeyCode= xkb->min_key_code;
-    nkn.maxKeyCode= nkn.oldMaxKeyCode= xkb->max_key_code;
-    nkn.requestMajor=	XkbReqCode;
-    nkn.requestMinor=	X_kbSetGeometry;
-    nkn.changed=	XkbNKN_GeometryMask;
-    XkbSendNewKeyboardNotify(dev,&nkn);
+        nn.changed = XkbGeometryNameMask;
+        XkbSendNamesNotify(dev, &nn);
+    }
+    nkn.deviceID = nkn.oldDeviceID = dev->id;
+    nkn.minKeyCode = nkn.oldMinKeyCode = xkb->min_key_code;
+    nkn.maxKeyCode = nkn.oldMaxKeyCode = xkb->max_key_code;
+    nkn.requestMajor = XkbReqCode;
+    nkn.requestMinor = X_kbSetGeometry;
+    nkn.changed = XkbNKN_GeometryMask;
+    XkbSendNewKeyboardNotify(dev, &nkn);
     return Success;
 }
 
 int
 ProcXkbSetGeometry(ClientPtr client)
 {
-    DeviceIntPtr        dev;
-    int                 rc;
+    DeviceIntPtr dev;
+    int rc;
 
     REQUEST(xkbSetGeometryReq);
     REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
     CHK_ATOM_OR_NONE(stuff->name);
@@ -5327,14 +5445,14 @@ ProcXkbSetGeometry(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if ((other != dev) && other->key && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev)
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if ((other != dev) && other->key && !IsMaster(other) &&
+                GetMaster(other, MASTER_KEYBOARD) == dev) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
                 if (rc == Success)
                     _XkbSetGeometry(client, other, stuff);
             }
@@ -5349,75 +5467,78 @@ ProcXkbSetGeometry(ClientPtr client)
 int
 ProcXkbPerClientFlags(ClientPtr client)
 {
-    DeviceIntPtr 		dev;
-    xkbPerClientFlagsReply 	rep;
-    XkbInterestPtr		interest;
+    DeviceIntPtr dev;
+    xkbPerClientFlagsReply rep;
+    XkbInterestPtr interest;
     Mask access_mode = DixGetAttrAccess | DixSetAttrAccess;
 
     REQUEST(xkbPerClientFlagsReq);
     REQUEST_SIZE_MATCH(xkbPerClientFlagsReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode);
-    CHK_MASK_LEGAL(0x01,stuff->change,XkbPCF_AllFlagsMask);
-    CHK_MASK_MATCH(0x02,stuff->change,stuff->value);
+    CHK_MASK_LEGAL(0x01, stuff->change, XkbPCF_AllFlagsMask);
+    CHK_MASK_MATCH(0x02, stuff->change, stuff->value);
 
-    interest = XkbFindClientResource((DevicePtr)dev,client);
+    interest = XkbFindClientResource((DevicePtr) dev, client);
     memset(&rep, 0, sizeof(xkbPerClientFlagsReply));
-    rep.type= X_Reply;
+    rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     if (stuff->change) {
-	client->xkbClientFlags&= ~stuff->change;
-	client->xkbClientFlags|= stuff->value;
-    }
-    if (stuff->change&XkbPCF_AutoResetControlsMask) {
-	Bool	want;
-	want= stuff->value&XkbPCF_AutoResetControlsMask;
-	if (interest && !want) {
-	    interest->autoCtrls= interest->autoCtrlValues= 0;
-	}
-	else if (want && (!interest)) {
-	    XID id = FakeClientID(client->index);
-	    if (!AddResource(id,RT_XKBCLIENT,dev))
-		return BadAlloc;
-	    interest= XkbAddClientResource((DevicePtr)dev,client,id);
-	    if (!interest)
-		return BadAlloc;
-	}
-	if (interest && want ) {
-	    register unsigned affect;
-	    affect= stuff->ctrlsToChange;
-
-	    CHK_MASK_LEGAL(0x03,affect,XkbAllBooleanCtrlsMask);
-	    CHK_MASK_MATCH(0x04,affect,stuff->autoCtrls);
-	    CHK_MASK_MATCH(0x05,stuff->autoCtrls,stuff->autoCtrlValues);
-
-	    interest->autoCtrls&= ~affect;
-	    interest->autoCtrlValues&= ~affect;
-	    interest->autoCtrls|= stuff->autoCtrls&affect;
-	    interest->autoCtrlValues|= stuff->autoCtrlValues&affect;
-	}
+        client->xkbClientFlags &= ~stuff->change;
+        client->xkbClientFlags |= stuff->value;
+    }
+    if (stuff->change & XkbPCF_AutoResetControlsMask) {
+        Bool want;
+
+        want = stuff->value & XkbPCF_AutoResetControlsMask;
+        if (interest && !want) {
+            interest->autoCtrls = interest->autoCtrlValues = 0;
+        }
+        else if (want && (!interest)) {
+            XID id = FakeClientID(client->index);
+
+            if (!AddResource(id, RT_XKBCLIENT, dev))
+                return BadAlloc;
+            interest = XkbAddClientResource((DevicePtr) dev, client, id);
+            if (!interest)
+                return BadAlloc;
+        }
+        if (interest && want) {
+            register unsigned affect;
+
+            affect = stuff->ctrlsToChange;
+
+            CHK_MASK_LEGAL(0x03, affect, XkbAllBooleanCtrlsMask);
+            CHK_MASK_MATCH(0x04, affect, stuff->autoCtrls);
+            CHK_MASK_MATCH(0x05, stuff->autoCtrls, stuff->autoCtrlValues);
+
+            interest->autoCtrls &= ~affect;
+            interest->autoCtrlValues &= ~affect;
+            interest->autoCtrls |= stuff->autoCtrls & affect;
+            interest->autoCtrlValues |= stuff->autoCtrlValues & affect;
+        }
     }
     rep.supported = XkbPCF_AllFlagsMask;
-    rep.value= client->xkbClientFlags&XkbPCF_AllFlagsMask;
+    rep.value = client->xkbClientFlags & XkbPCF_AllFlagsMask;
     if (interest) {
-	rep.autoCtrls= interest->autoCtrls;
-	rep.autoCtrlValues= interest->autoCtrlValues;
+        rep.autoCtrls = interest->autoCtrls;
+        rep.autoCtrlValues = interest->autoCtrlValues;
     }
     else {
-	rep.autoCtrls= rep.autoCtrlValues= 0;
+        rep.autoCtrls = rep.autoCtrlValues = 0;
     }
-    if ( client->swapped ) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.supported);
-	swapl(&rep.value);
-	swapl(&rep.autoCtrls);
-	swapl(&rep.autoCtrlValues);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.supported);
+        swapl(&rep.value);
+        swapl(&rep.autoCtrls);
+        swapl(&rep.autoCtrlValues);
     }
-    WriteToClient(client,SIZEOF(xkbPerClientFlagsReply), (char *)&rep);
+    WriteToClient(client, SIZEOF(xkbPerClientFlagsReply), (char *) &rep);
     return Success;
 }
 
@@ -5426,57 +5547,60 @@ ProcXkbPerClientFlags(ClientPtr client)
 /* all latin-1 alphanumerics, plus parens, minus, underscore, slash */
 /* and wildcards */
 static unsigned char componentSpecLegal[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x87,
-        0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x87,
+    0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
 };
 
 /* same as above but accepts percent, plus and bar too */
 static unsigned char componentExprLegal[] = {
-        0x00, 0x00, 0x00, 0x00, 0x20, 0xaf, 0xff, 0x87,
-        0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x17,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
+    0x00, 0x00, 0x00, 0x00, 0x20, 0xaf, 0xff, 0x87,
+    0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x17,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
 };
 
 static char *
-GetComponentSpec(unsigned char **pWire,Bool allowExpr,int *errRtrn)
+GetComponentSpec(unsigned char **pWire, Bool allowExpr, int *errRtrn)
 {
-int		len;
-register int	i;
-unsigned char	*wire,*str,*tmp,*legal;
-
-    if (allowExpr)	legal= &componentExprLegal[0];
-    else		legal= &componentSpecLegal[0];
-
-    wire= *pWire;
-    len= (*(unsigned char *)wire++);
-    if (len>0) {
-	str= calloc(1, len+1);
-	if (str) {
-	    tmp= str;
-	    for (i=0;i<len;i++) {
-		if (legal[(*wire)/8]&(1<<((*wire)%8)))
-		    *tmp++= *wire++;
-		else wire++;
-	    }
-	    if (tmp!=str)
-		*tmp++= '\0';
-	    else {
-		free(str);
-		str= NULL;
-	    }
-	}
-	else {
-	    *errRtrn= BadAlloc;
-	}
+    int len;
+    register int i;
+    unsigned char *wire, *str, *tmp, *legal;
+
+    if (allowExpr)
+        legal = &componentExprLegal[0];
+    else
+        legal = &componentSpecLegal[0];
+
+    wire = *pWire;
+    len = (*(unsigned char *) wire++);
+    if (len > 0) {
+        str = calloc(1, len + 1);
+        if (str) {
+            tmp = str;
+            for (i = 0; i < len; i++) {
+                if (legal[(*wire) / 8] & (1 << ((*wire) % 8)))
+                    *tmp++ = *wire++;
+                else
+                    wire++;
+            }
+            if (tmp != str)
+                *tmp++ = '\0';
+            else {
+                free(str);
+                str = NULL;
+            }
+        }
+        else {
+            *errRtrn = BadAlloc;
+        }
     }
     else {
-	str= NULL;
+        str = NULL;
     }
-    *pWire= wire;
-    return (char *)str;
+    *pWire = wire;
+    return (char *) str;
 }
 
 /***====================================================================***/
@@ -5484,70 +5608,70 @@ unsigned char	*wire,*str,*tmp,*legal;
 int
 ProcXkbListComponents(ClientPtr client)
 {
-    DeviceIntPtr 		dev;
-    xkbListComponentsReply 	rep;
-    unsigned			len;
-    int				status;
-    unsigned char *		str;
-    XkbSrvListInfoRec		list;
+    DeviceIntPtr dev;
+    xkbListComponentsReply rep;
+    unsigned len;
+    int status;
+    unsigned char *str;
+    XkbSrvListInfoRec list;
 
     REQUEST(xkbListComponentsReq);
     REQUEST_AT_LEAST_SIZE(xkbListComponentsReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
 
-    status= Success;
-    str= (unsigned char *)&stuff[1];
+    status = Success;
+    str = (unsigned char *) &stuff[1];
     memset(&list, 0, sizeof(XkbSrvListInfoRec));
-    list.maxRtrn= stuff->maxNames;
-    list.pattern[_XkbListKeycodes]= GetComponentSpec(&str,FALSE,&status);
-    list.pattern[_XkbListTypes]= GetComponentSpec(&str,FALSE,&status);
-    list.pattern[_XkbListCompat]= GetComponentSpec(&str,FALSE,&status);
-    list.pattern[_XkbListSymbols]= GetComponentSpec(&str,FALSE,&status);
-    list.pattern[_XkbListGeometry]= GetComponentSpec(&str,FALSE,&status);
-    if (status!=Success)
-	return status;
-    len= str-((unsigned char *)stuff);
-    if ((XkbPaddedSize(len)/4)!=stuff->length)
-	return BadLength;
-    if ((status=XkbDDXList(dev,&list,client))!=Success) {
-	free(list.pool);
-	list.pool = NULL;
-	return status;
+    list.maxRtrn = stuff->maxNames;
+    list.pattern[_XkbListKeycodes] = GetComponentSpec(&str, FALSE, &status);
+    list.pattern[_XkbListTypes] = GetComponentSpec(&str, FALSE, &status);
+    list.pattern[_XkbListCompat] = GetComponentSpec(&str, FALSE, &status);
+    list.pattern[_XkbListSymbols] = GetComponentSpec(&str, FALSE, &status);
+    list.pattern[_XkbListGeometry] = GetComponentSpec(&str, FALSE, &status);
+    if (status != Success)
+        return status;
+    len = str - ((unsigned char *) stuff);
+    if ((XkbPaddedSize(len) / 4) != stuff->length)
+        return BadLength;
+    if ((status = XkbDDXList(dev, &list, client)) != Success) {
+        free(list.pool);
+        list.pool = NULL;
+        return status;
     }
     memset(&rep, 0, sizeof(xkbListComponentsReply));
-    rep.type= X_Reply;
+    rep.type = X_Reply;
     rep.deviceID = dev->id;
     rep.sequenceNumber = client->sequence;
-    rep.length = XkbPaddedSize(list.nPool)/4;
+    rep.length = XkbPaddedSize(list.nPool) / 4;
     rep.nKeymaps = 0;
     rep.nKeycodes = list.nFound[_XkbListKeycodes];
     rep.nTypes = list.nFound[_XkbListTypes];
     rep.nCompatMaps = list.nFound[_XkbListCompat];
     rep.nSymbols = list.nFound[_XkbListSymbols];
     rep.nGeometries = list.nFound[_XkbListGeometry];
-    rep.extra=	0;
-    if (list.nTotal>list.maxRtrn)
-	rep.extra = (list.nTotal-list.maxRtrn);
+    rep.extra = 0;
+    if (list.nTotal > list.maxRtrn)
+        rep.extra = (list.nTotal - list.maxRtrn);
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swaps(&rep.nKeymaps);
-	swaps(&rep.nKeycodes);
-	swaps(&rep.nTypes);
-	swaps(&rep.nCompatMaps);
-	swaps(&rep.nSymbols);
-	swaps(&rep.nGeometries);
-	swaps(&rep.extra);
-    }
-    WriteToClient(client,SIZEOF(xkbListComponentsReply),(char *)&rep);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.nKeymaps);
+        swaps(&rep.nKeycodes);
+        swaps(&rep.nTypes);
+        swaps(&rep.nCompatMaps);
+        swaps(&rep.nSymbols);
+        swaps(&rep.nGeometries);
+        swaps(&rep.extra);
+    }
+    WriteToClient(client, SIZEOF(xkbListComponentsReply), (char *) &rep);
     if (list.nPool && list.pool) {
-	WriteToClient(client,XkbPaddedSize(list.nPool), (char *)list.pool);
-	free(list.pool);
-	list.pool= NULL;
+        WriteToClient(client, XkbPaddedSize(list.nPool), (char *) list.pool);
+        free(list.pool);
+        list.pool = NULL;
     }
     return Success;
 }
@@ -5557,32 +5681,32 @@ ProcXkbListComponents(ClientPtr client)
 int
 ProcXkbGetKbdByName(ClientPtr client)
 {
-    DeviceIntPtr 		dev;
-    DeviceIntPtr                tmpd;
-    DeviceIntPtr                master;
-    xkbGetKbdByNameReply 	rep = {0};
-    xkbGetMapReply		mrep = {0};
-    xkbGetCompatMapReply	crep = {0};
-    xkbGetIndicatorMapReply	irep = {0};
-    xkbGetNamesReply		nrep = {0};
-    xkbGetGeometryReply		grep = {0};
-    XkbComponentNamesRec	names = {0};
-    XkbDescPtr			xkb, new;
-    unsigned char *		str;
-    char 			mapFile[PATH_MAX];
-    unsigned			len;
-    unsigned			fwant,fneed,reported;
-    int				status;
-    Bool			geom_changed;
-    XkbSrvLedInfoPtr            old_sli;
-    XkbSrvLedInfoPtr            sli;
+    DeviceIntPtr dev;
+    DeviceIntPtr tmpd;
+    DeviceIntPtr master;
+    xkbGetKbdByNameReply rep = { 0 };
+    xkbGetMapReply mrep = { 0 };
+    xkbGetCompatMapReply crep = { 0 };
+    xkbGetIndicatorMapReply irep = { 0 };
+    xkbGetNamesReply nrep = { 0 };
+    xkbGetGeometryReply grep = { 0 };
+    XkbComponentNamesRec names = { 0 };
+    XkbDescPtr xkb, new;
+    unsigned char *str;
+    char mapFile[PATH_MAX];
+    unsigned len;
+    unsigned fwant, fneed, reported;
+    int status;
+    Bool geom_changed;
+    XkbSrvLedInfoPtr old_sli;
+    XkbSrvLedInfoPtr sli;
     Mask access_mode = DixGetAttrAccess | DixManageAccess;
 
     REQUEST(xkbGetKbdByNameReq);
     REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     memset(&mrep,0,sizeof(mrep));  //MH
     
@@ -5590,272 +5714,278 @@ ProcXkbGetKbdByName(ClientPtr client)
     master = GetMaster(dev, MASTER_KEYBOARD);
 
     xkb = dev->key->xkbInfo->desc;
-    status= Success;
-    str= (unsigned char *)&stuff[1];
-    if (GetComponentSpec(&str,TRUE,&status)) /* keymap, unsupported */
+    status = Success;
+    str = (unsigned char *) &stuff[1];
+    if (GetComponentSpec(&str, TRUE, &status))  /* keymap, unsupported */
         return BadMatch;
-    names.keycodes= GetComponentSpec(&str,TRUE,&status);
-    names.types= GetComponentSpec(&str,TRUE,&status);
-    names.compat= GetComponentSpec(&str,TRUE,&status);
-    names.symbols= GetComponentSpec(&str,TRUE,&status);
-    names.geometry= GetComponentSpec(&str,TRUE,&status);
-    if (status!=Success)
-	return status;
-    len= str-((unsigned char *)stuff);
-    if ((XkbPaddedSize(len)/4)!=stuff->length)
-	return BadLength;
-
-    CHK_MASK_LEGAL(0x01,stuff->want,XkbGBN_AllComponentsMask);
-    CHK_MASK_LEGAL(0x02,stuff->need,XkbGBN_AllComponentsMask);
-    
+    names.keycodes = GetComponentSpec(&str, TRUE, &status);
+    names.types = GetComponentSpec(&str, TRUE, &status);
+    names.compat = GetComponentSpec(&str, TRUE, &status);
+    names.symbols = GetComponentSpec(&str, TRUE, &status);
+    names.geometry = GetComponentSpec(&str, TRUE, &status);
+    if (status != Success)
+        return status;
+    len = str - ((unsigned char *) stuff);
+    if ((XkbPaddedSize(len) / 4) != stuff->length)
+        return BadLength;
+
+    CHK_MASK_LEGAL(0x01, stuff->want, XkbGBN_AllComponentsMask);
+    CHK_MASK_LEGAL(0x02, stuff->need, XkbGBN_AllComponentsMask);
+
     if (stuff->load)
-	 fwant= XkbGBN_AllComponentsMask;
-    else fwant= stuff->want|stuff->need;
-    if ((!names.compat)&&
-        (fwant&(XkbGBN_CompatMapMask|XkbGBN_IndicatorMapMask))) {
-        names.compat= Xstrdup("%");
+        fwant = XkbGBN_AllComponentsMask;
+    else
+        fwant = stuff->want | stuff->need;
+    if ((!names.compat) &&
+        (fwant & (XkbGBN_CompatMapMask | XkbGBN_IndicatorMapMask))) {
+        names.compat = Xstrdup("%");
     }
-    if ((!names.types)&&(fwant&(XkbGBN_TypesMask))) {
-        names.types= Xstrdup("%");
+    if ((!names.types) && (fwant & (XkbGBN_TypesMask))) {
+        names.types = Xstrdup("%");
     }
-    if ((!names.symbols)&&(fwant&XkbGBN_SymbolsMask)) {
-        names.symbols= Xstrdup("%");
+    if ((!names.symbols) && (fwant & XkbGBN_SymbolsMask)) {
+        names.symbols = Xstrdup("%");
     }
-    geom_changed= ((names.geometry!=NULL)&&(strcmp(names.geometry,"%")!=0));
-    if ((!names.geometry)&&(fwant&XkbGBN_GeometryMask)) {
-        names.geometry= Xstrdup("%");
-        geom_changed= FALSE;
+    geom_changed = ((names.geometry != NULL) &&
+                    (strcmp(names.geometry, "%") != 0));
+    if ((!names.geometry) && (fwant & XkbGBN_GeometryMask)) {
+        names.geometry = Xstrdup("%");
+        geom_changed = FALSE;
     }
 
     memset(mapFile, 0, PATH_MAX);
-    rep.type= X_Reply;
+    rep.type = X_Reply;
     rep.deviceID = dev->id;
     rep.sequenceNumber = client->sequence;
     rep.length = 0;
     rep.minKeyCode = xkb->min_key_code;
     rep.maxKeyCode = xkb->max_key_code;
-    rep.loaded=	FALSE;
-    fwant= XkbConvertGetByNameComponents(TRUE,stuff->want)|XkmVirtualModsMask;
-    fneed= XkbConvertGetByNameComponents(TRUE,stuff->need);
-    rep.reported= XkbConvertGetByNameComponents(FALSE,fwant|fneed);
+    rep.loaded = FALSE;
+    fwant =
+        XkbConvertGetByNameComponents(TRUE, stuff->want) | XkmVirtualModsMask;
+    fneed = XkbConvertGetByNameComponents(TRUE, stuff->need);
+    rep.reported = XkbConvertGetByNameComponents(FALSE, fwant | fneed);
     if (stuff->load) {
-	fneed|= XkmKeymapRequired;
-	fwant|= XkmKeymapLegal;
+        fneed |= XkmKeymapRequired;
+        fwant |= XkmKeymapLegal;
     }
-    if ((fwant|fneed)&XkmSymbolsMask) {
-	fneed|= XkmKeyNamesIndex|XkmTypesIndex;
-	fwant|= XkmIndicatorsIndex;
+    if ((fwant | fneed) & XkmSymbolsMask) {
+        fneed |= XkmKeyNamesIndex | XkmTypesIndex;
+        fwant |= XkmIndicatorsIndex;
     }
 
     /* We pass dev in here so we can get the old names out if needed. */
-    rep.found = XkbDDXLoadKeymapByNames(dev,&names,fwant,fneed,&new,
-                                        mapFile,PATH_MAX);
-    rep.newKeyboard= FALSE;
-    rep.pad1= rep.pad2= rep.pad3= rep.pad4= 0;
-
-    stuff->want|= stuff->need;
-    if (new==NULL)
-	rep.reported= 0;
+    rep.found = XkbDDXLoadKeymapByNames(dev, &names, fwant, fneed, &new,
+                                        mapFile, PATH_MAX);
+    rep.newKeyboard = FALSE;
+    rep.pad1 = rep.pad2 = rep.pad3 = rep.pad4 = 0;
+
+    stuff->want |= stuff->need;
+    if (new == NULL)
+        rep.reported = 0;
     else {
-	if (stuff->load)
-	    rep.loaded= TRUE;
-	if (stuff->load || 
-		((rep.reported&XkbGBN_SymbolsMask) && (new->compat))) {
-	    XkbChangesRec changes;
-	    memset(&changes, 0, sizeof(changes));
-	    XkbUpdateDescActions(new,
-			new->min_key_code,XkbNumKeys(new),
-			&changes);
-	}
-
-	if (new->map==NULL)
-	    rep.reported&= ~(XkbGBN_SymbolsMask|XkbGBN_TypesMask);
-	else if (rep.reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask)) {
-	    mrep.type= X_Reply;
-	    mrep.deviceID = dev->id;
-	    mrep.sequenceNumber= client->sequence;
-	    mrep.length = ((SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply))>>2);
-	    mrep.minKeyCode = new->min_key_code;
-	    mrep.maxKeyCode = new->max_key_code;
-	    mrep.present = 0;
-	    mrep.totalSyms = mrep.totalActs =
-		mrep.totalKeyBehaviors= mrep.totalKeyExplicit= 
-		mrep.totalModMapKeys= mrep.totalVModMapKeys= 0;
-	    if (rep.reported&(XkbGBN_TypesMask|XkbGBN_ClientSymbolsMask)) {
-		mrep.present|= XkbKeyTypesMask;
-		mrep.firstType = 0;
-		mrep.nTypes = mrep.totalTypes= new->map->num_types;
-	    }
-	    else {
-		mrep.firstType = mrep.nTypes= 0;
-		mrep.totalTypes= 0;
-	    }
-	    if (rep.reported&XkbGBN_ClientSymbolsMask) {
-		mrep.present|= (XkbKeySymsMask|XkbModifierMapMask);
-		mrep.firstKeySym = mrep.firstModMapKey= new->min_key_code;
-		mrep.nKeySyms = mrep.nModMapKeys= XkbNumKeys(new);
-	    }
-	    else {
-		mrep.firstKeySym= mrep.firstModMapKey= 0;
-		mrep.nKeySyms= mrep.nModMapKeys= 0;
-	    }
-	    if (rep.reported&XkbGBN_ServerSymbolsMask) {
-		mrep.present|= XkbAllServerInfoMask;
-		mrep.virtualMods= ~0;
-		mrep.firstKeyAct = mrep.firstKeyBehavior = 
-			mrep.firstKeyExplicit = new->min_key_code;
-		mrep.nKeyActs = mrep.nKeyBehaviors = 
-			mrep.nKeyExplicit = XkbNumKeys(new);
-		mrep.firstVModMapKey= new->min_key_code;
-		mrep.nVModMapKeys= XkbNumKeys(new);
-	    }
-	    else {
-		mrep.virtualMods= 0;
-		mrep.firstKeyAct= mrep.firstKeyBehavior= 
-			mrep.firstKeyExplicit = 0;
-		mrep.nKeyActs= mrep.nKeyBehaviors= mrep.nKeyExplicit= 0;
-	    }
-	    XkbComputeGetMapReplySize(new,&mrep);
-	    rep.length+= SIZEOF(xGenericReply)/4+mrep.length;
-	}
-	if (new->compat==NULL)
-	    rep.reported&= ~XkbGBN_CompatMapMask;
-	else if (rep.reported&XkbGBN_CompatMapMask) {
-	    crep.type= X_Reply;
-	    crep.deviceID= dev->id;
-	    crep.sequenceNumber= client->sequence;
-	    crep.length= 0;
-	    crep.groups= XkbAllGroupsMask;
-	    crep.firstSI= 0;
-	    crep.nSI= crep.nTotalSI= new->compat->num_si;
-	    XkbComputeGetCompatMapReplySize(new->compat,&crep);
-	    rep.length+= SIZEOF(xGenericReply)/4+crep.length;
-	}
-	if (new->indicators==NULL)
-	    rep.reported&= ~XkbGBN_IndicatorMapMask;
-	else if (rep.reported&XkbGBN_IndicatorMapMask) {
-	    irep.type= X_Reply;
-	    irep.deviceID= dev->id;
-	    irep.sequenceNumber= client->sequence;
-	    irep.length= 0;
-	    irep.which= XkbAllIndicatorsMask;
-	    XkbComputeGetIndicatorMapReplySize(new->indicators,&irep);
-	    rep.length+= SIZEOF(xGenericReply)/4+irep.length;
-	}
-	if (new->names==NULL)
-	    rep.reported&= ~(XkbGBN_OtherNamesMask|XkbGBN_KeyNamesMask);
-	else if (rep.reported&(XkbGBN_OtherNamesMask|XkbGBN_KeyNamesMask)) {
-	    nrep.type= X_Reply;
-	    nrep.deviceID= dev->id;
-	    nrep.sequenceNumber= client->sequence;
-	    nrep.length= 0;
-	    nrep.minKeyCode= new->min_key_code;
-	    nrep.maxKeyCode= new->max_key_code;
-	    if (rep.reported&XkbGBN_OtherNamesMask) {
-		nrep.which= XkbAllNamesMask;
-		if (new->map!=NULL)
-		     nrep.nTypes= new->map->num_types;
-		else nrep.nTypes= 0;
-		nrep.nKTLevels= 0;
-		nrep.groupNames= XkbAllGroupsMask;
-		nrep.virtualMods= XkbAllVirtualModsMask;
-		nrep.indicators= XkbAllIndicatorsMask;
-		nrep.nRadioGroups= new->names->num_rg;
-	    }
-	    else {
-		nrep.which= 0;
-		nrep.nTypes= 0;
-		nrep.nKTLevels= 0;
-		nrep.groupNames= 0;
-		nrep.virtualMods= 0;
-		nrep.indicators= 0;
-		nrep.nRadioGroups= 0;
-	    }
-	    if (rep.reported&XkbGBN_KeyNamesMask) {
-		nrep.which|= XkbKeyNamesMask;
-		nrep.firstKey= new->min_key_code;
-		nrep.nKeys= XkbNumKeys(new);
-		nrep.nKeyAliases= new->names->num_key_aliases;
-		if (nrep.nKeyAliases)
-		    nrep.which|= XkbKeyAliasesMask;
-	    }
-	    else {
-		nrep.which&= ~(XkbKeyNamesMask|XkbKeyAliasesMask);
-		nrep.firstKey= nrep.nKeys= 0;
-		nrep.nKeyAliases= 0;
-	    }
-	    XkbComputeGetNamesReplySize(new,&nrep);
-	    rep.length+= SIZEOF(xGenericReply)/4+nrep.length;
-	}
-	if (new->geom==NULL)
-	    rep.reported&= ~XkbGBN_GeometryMask;
-	else if (rep.reported&XkbGBN_GeometryMask) {
-	    grep.type= X_Reply;
-	    grep.deviceID= dev->id;
-	    grep.sequenceNumber= client->sequence;
-	    grep.length= 0;
-	    grep.found= TRUE;
-	    grep.pad= 0;
-	    grep.widthMM= grep.heightMM= 0;
-	    grep.nProperties= grep.nColors= grep.nShapes= 0;
-	    grep.nSections= grep.nDoodads= 0;
-	    grep.baseColorNdx= grep.labelColorNdx= 0;
-	    XkbComputeGetGeometryReplySize(new->geom,&grep,None);
-	    rep.length+= SIZEOF(xGenericReply)/4+grep.length;
-	}
-    }
-
-    reported= rep.reported;
-    if ( client->swapped ) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swaps(&rep.found);
-	swaps(&rep.reported);
-    }
-    WriteToClient(client,SIZEOF(xkbGetKbdByNameReply), (char *)&rep);
-    if (reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask))
-	XkbSendMap(client,new,&mrep);
-    if (reported&XkbGBN_CompatMapMask)
-	XkbSendCompatMap(client,new->compat,&crep);
-    if (reported&XkbGBN_IndicatorMapMask)
-	XkbSendIndicatorMap(client,new->indicators,&irep);
-    if (reported&(XkbGBN_KeyNamesMask|XkbGBN_OtherNamesMask))
-	XkbSendNames(client,new,&nrep);
-    if (reported&XkbGBN_GeometryMask)
-	XkbSendGeometry(client,new->geom,&grep,FALSE);
+        if (stuff->load)
+            rep.loaded = TRUE;
+        if (stuff->load ||
+            ((rep.reported & XkbGBN_SymbolsMask) && (new->compat))) {
+            XkbChangesRec changes;
+
+            memset(&changes, 0, sizeof(changes));
+            XkbUpdateDescActions(new,
+                                 new->min_key_code, XkbNumKeys(new), &changes);
+        }
+
+        if (new->map == NULL)
+            rep.reported &= ~(XkbGBN_SymbolsMask | XkbGBN_TypesMask);
+        else if (rep.reported & (XkbGBN_SymbolsMask | XkbGBN_TypesMask)) {
+            mrep.type = X_Reply;
+            mrep.deviceID = dev->id;
+            mrep.sequenceNumber = client->sequence;
+            mrep.length =
+                ((SIZEOF(xkbGetMapReply) - SIZEOF(xGenericReply)) >> 2);
+            mrep.minKeyCode = new->min_key_code;
+            mrep.maxKeyCode = new->max_key_code;
+            mrep.present = 0;
+            mrep.totalSyms = mrep.totalActs =
+                mrep.totalKeyBehaviors = mrep.totalKeyExplicit =
+                mrep.totalModMapKeys = mrep.totalVModMapKeys = 0;
+            if (rep.reported & (XkbGBN_TypesMask | XkbGBN_ClientSymbolsMask)) {
+                mrep.present |= XkbKeyTypesMask;
+                mrep.firstType = 0;
+                mrep.nTypes = mrep.totalTypes = new->map->num_types;
+            }
+            else {
+                mrep.firstType = mrep.nTypes = 0;
+                mrep.totalTypes = 0;
+            }
+            if (rep.reported & XkbGBN_ClientSymbolsMask) {
+                mrep.present |= (XkbKeySymsMask | XkbModifierMapMask);
+                mrep.firstKeySym = mrep.firstModMapKey = new->min_key_code;
+                mrep.nKeySyms = mrep.nModMapKeys = XkbNumKeys(new);
+            }
+            else {
+                mrep.firstKeySym = mrep.firstModMapKey = 0;
+                mrep.nKeySyms = mrep.nModMapKeys = 0;
+            }
+            if (rep.reported & XkbGBN_ServerSymbolsMask) {
+                mrep.present |= XkbAllServerInfoMask;
+                mrep.virtualMods = ~0;
+                mrep.firstKeyAct = mrep.firstKeyBehavior =
+                    mrep.firstKeyExplicit = new->min_key_code;
+                mrep.nKeyActs = mrep.nKeyBehaviors =
+                    mrep.nKeyExplicit = XkbNumKeys(new);
+                mrep.firstVModMapKey = new->min_key_code;
+                mrep.nVModMapKeys = XkbNumKeys(new);
+            }
+            else {
+                mrep.virtualMods = 0;
+                mrep.firstKeyAct = mrep.firstKeyBehavior =
+                    mrep.firstKeyExplicit = 0;
+                mrep.nKeyActs = mrep.nKeyBehaviors = mrep.nKeyExplicit = 0;
+            }
+            XkbComputeGetMapReplySize(new, &mrep);
+            rep.length += SIZEOF(xGenericReply) / 4 + mrep.length;
+        }
+        if (new->compat == NULL)
+            rep.reported &= ~XkbGBN_CompatMapMask;
+        else if (rep.reported & XkbGBN_CompatMapMask) {
+            crep.type = X_Reply;
+            crep.deviceID = dev->id;
+            crep.sequenceNumber = client->sequence;
+            crep.length = 0;
+            crep.groups = XkbAllGroupsMask;
+            crep.firstSI = 0;
+            crep.nSI = crep.nTotalSI = new->compat->num_si;
+            XkbComputeGetCompatMapReplySize(new->compat, &crep);
+            rep.length += SIZEOF(xGenericReply) / 4 + crep.length;
+        }
+        if (new->indicators == NULL)
+            rep.reported &= ~XkbGBN_IndicatorMapMask;
+        else if (rep.reported & XkbGBN_IndicatorMapMask) {
+            irep.type = X_Reply;
+            irep.deviceID = dev->id;
+            irep.sequenceNumber = client->sequence;
+            irep.length = 0;
+            irep.which = XkbAllIndicatorsMask;
+            XkbComputeGetIndicatorMapReplySize(new->indicators, &irep);
+            rep.length += SIZEOF(xGenericReply) / 4 + irep.length;
+        }
+        if (new->names == NULL)
+            rep.reported &= ~(XkbGBN_OtherNamesMask | XkbGBN_KeyNamesMask);
+        else if (rep.reported & (XkbGBN_OtherNamesMask | XkbGBN_KeyNamesMask)) {
+            nrep.type = X_Reply;
+            nrep.deviceID = dev->id;
+            nrep.sequenceNumber = client->sequence;
+            nrep.length = 0;
+            nrep.minKeyCode = new->min_key_code;
+            nrep.maxKeyCode = new->max_key_code;
+            if (rep.reported & XkbGBN_OtherNamesMask) {
+                nrep.which = XkbAllNamesMask;
+                if (new->map != NULL)
+                    nrep.nTypes = new->map->num_types;
+                else
+                    nrep.nTypes = 0;
+                nrep.nKTLevels = 0;
+                nrep.groupNames = XkbAllGroupsMask;
+                nrep.virtualMods = XkbAllVirtualModsMask;
+                nrep.indicators = XkbAllIndicatorsMask;
+                nrep.nRadioGroups = new->names->num_rg;
+            }
+            else {
+                nrep.which = 0;
+                nrep.nTypes = 0;
+                nrep.nKTLevels = 0;
+                nrep.groupNames = 0;
+                nrep.virtualMods = 0;
+                nrep.indicators = 0;
+                nrep.nRadioGroups = 0;
+            }
+            if (rep.reported & XkbGBN_KeyNamesMask) {
+                nrep.which |= XkbKeyNamesMask;
+                nrep.firstKey = new->min_key_code;
+                nrep.nKeys = XkbNumKeys(new);
+                nrep.nKeyAliases = new->names->num_key_aliases;
+                if (nrep.nKeyAliases)
+                    nrep.which |= XkbKeyAliasesMask;
+            }
+            else {
+                nrep.which &= ~(XkbKeyNamesMask | XkbKeyAliasesMask);
+                nrep.firstKey = nrep.nKeys = 0;
+                nrep.nKeyAliases = 0;
+            }
+            XkbComputeGetNamesReplySize(new, &nrep);
+            rep.length += SIZEOF(xGenericReply) / 4 + nrep.length;
+        }
+        if (new->geom == NULL)
+            rep.reported &= ~XkbGBN_GeometryMask;
+        else if (rep.reported & XkbGBN_GeometryMask) {
+            grep.type = X_Reply;
+            grep.deviceID = dev->id;
+            grep.sequenceNumber = client->sequence;
+            grep.length = 0;
+            grep.found = TRUE;
+            grep.pad = 0;
+            grep.widthMM = grep.heightMM = 0;
+            grep.nProperties = grep.nColors = grep.nShapes = 0;
+            grep.nSections = grep.nDoodads = 0;
+            grep.baseColorNdx = grep.labelColorNdx = 0;
+            XkbComputeGetGeometryReplySize(new->geom, &grep, None);
+            rep.length += SIZEOF(xGenericReply) / 4 + grep.length;
+        }
+    }
+
+    reported = rep.reported;
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.found);
+        swaps(&rep.reported);
+    }
+    WriteToClient(client, SIZEOF(xkbGetKbdByNameReply), (char *) &rep);
+    if (reported & (XkbGBN_SymbolsMask | XkbGBN_TypesMask))
+        XkbSendMap(client, new, &mrep);
+    if (reported & XkbGBN_CompatMapMask)
+        XkbSendCompatMap(client, new->compat, &crep);
+    if (reported & XkbGBN_IndicatorMapMask)
+        XkbSendIndicatorMap(client, new->indicators, &irep);
+    if (reported & (XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask))
+        XkbSendNames(client, new, &nrep);
+    if (reported & XkbGBN_GeometryMask)
+        XkbSendGeometry(client, new->geom, &grep, FALSE);
     if (rep.loaded) {
-	XkbDescPtr		old_xkb;
-	xkbNewKeyboardNotify 	nkn;
-	int 			i,nG,nTG;
-	old_xkb= xkb;
-	xkb= new;
-	dev->key->xkbInfo->desc= xkb;
-	new= old_xkb; /* so it'll get freed automatically */
-
-	*xkb->ctrls= *old_xkb->ctrls;
-	for (nG=nTG=0,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	    nG= XkbKeyNumGroups(xkb,i);
-	    if (nG>=XkbNumKbdGroups) {
-		nTG= XkbNumKbdGroups;
-		break;
-	    }
-	    if (nG>nTG) {
-		nTG= nG;
-	    }
-	}
-	xkb->ctrls->num_groups= nTG;
-
-	nkn.deviceID= nkn.oldDeviceID= dev->id;
-	nkn.minKeyCode= new->min_key_code;
-	nkn.maxKeyCode= new->max_key_code;
-	nkn.oldMinKeyCode= xkb->min_key_code;
-	nkn.oldMaxKeyCode= xkb->max_key_code;
-	nkn.requestMajor= XkbReqCode;
-	nkn.requestMinor= X_kbGetKbdByName;
-	nkn.changed= XkbNKN_KeycodesMask;
-	if (geom_changed)
-	    nkn.changed|= XkbNKN_GeometryMask;
-	XkbSendNewKeyboardNotify(dev,&nkn);
+        XkbDescPtr old_xkb;
+        xkbNewKeyboardNotify nkn;
+        int i, nG, nTG;
+
+        old_xkb = xkb;
+        xkb = new;
+        dev->key->xkbInfo->desc = xkb;
+        new = old_xkb;          /* so it'll get freed automatically */
+
+        *xkb->ctrls = *old_xkb->ctrls;
+        for (nG = nTG = 0, i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+            nG = XkbKeyNumGroups(xkb, i);
+            if (nG >= XkbNumKbdGroups) {
+                nTG = XkbNumKbdGroups;
+                break;
+            }
+            if (nG > nTG) {
+                nTG = nG;
+            }
+        }
+        xkb->ctrls->num_groups = nTG;
+
+        nkn.deviceID = nkn.oldDeviceID = dev->id;
+        nkn.minKeyCode = new->min_key_code;
+        nkn.maxKeyCode = new->max_key_code;
+        nkn.oldMinKeyCode = xkb->min_key_code;
+        nkn.oldMaxKeyCode = xkb->max_key_code;
+        nkn.requestMajor = XkbReqCode;
+        nkn.requestMinor = X_kbGetKbdByName;
+        nkn.changed = XkbNKN_KeycodesMask;
+        if (geom_changed)
+            nkn.changed |= XkbNKN_GeometryMask;
+        XkbSendNewKeyboardNotify(dev, &nkn);
 
         /* Update the map and LED info on the device itself, as well as
          * any slaves if it's an MD, or its MD if it's an SD and was the
@@ -5881,9 +6011,9 @@ ProcXkbGetKbdByName(ClientPtr client)
             }
         }
     }
-    if ((new!=NULL)&&(new!=xkb)) {
-	XkbFreeKeyboard(new,XkbAllComponentsMask,TRUE);
-	new= NULL;
+    if ((new != NULL) && (new != xkb)) {
+        XkbFreeKeyboard(new, XkbAllComponentsMask, TRUE);
+        new = NULL;
     }
     XkbFreeComponentNames(&names, FALSE);
     return Success;
@@ -5892,627 +6022,648 @@ ProcXkbGetKbdByName(ClientPtr client)
 /***====================================================================***/
 
 static int
-ComputeDeviceLedInfoSize(	DeviceIntPtr		dev,
-				unsigned int		what,
-				XkbSrvLedInfoPtr	sli)
+ComputeDeviceLedInfoSize(DeviceIntPtr dev,
+                         unsigned int what, XkbSrvLedInfoPtr sli)
 {
-int			nNames,nMaps;
-register unsigned 	n,bit;
-
-    if (sli==NULL)
-	return 0;
-    nNames= nMaps= 0;
-    if ((what&XkbXI_IndicatorNamesMask)==0)
-	sli->namesPresent= 0;
-    if ((what&XkbXI_IndicatorMapsMask)==0)
-	sli->mapsPresent= 0;
-
-    for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
-	if (sli->names && sli->names[n]!=None) {
-	    sli->namesPresent|= bit;
-	    nNames++;
-	}
-	if (sli->maps && XkbIM_InUse(&sli->maps[n])) {
-	    sli->mapsPresent|= bit;
-	    nMaps++;
-	}
-    }
-    return (nNames*4)+(nMaps*SIZEOF(xkbIndicatorMapWireDesc));
+    int nNames, nMaps;
+    register unsigned n, bit;
+
+    if (sli == NULL)
+        return 0;
+    nNames = nMaps = 0;
+    if ((what & XkbXI_IndicatorNamesMask) == 0)
+        sli->namesPresent = 0;
+    if ((what & XkbXI_IndicatorMapsMask) == 0)
+        sli->mapsPresent = 0;
+
+    for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+        if (sli->names && sli->names[n] != None) {
+            sli->namesPresent |= bit;
+            nNames++;
+        }
+        if (sli->maps && XkbIM_InUse(&sli->maps[n])) {
+            sli->mapsPresent |= bit;
+            nMaps++;
+        }
+    }
+    return (nNames * 4) + (nMaps * SIZEOF(xkbIndicatorMapWireDesc));
 }
 
-static int 
-CheckDeviceLedFBs(	DeviceIntPtr			dev,
-			int				class,
-			int				id,
-			xkbGetDeviceInfoReply *		rep,
-			ClientPtr			client)
+static int
+CheckDeviceLedFBs(DeviceIntPtr dev,
+                  int class,
+                  int id, xkbGetDeviceInfoReply * rep, ClientPtr client)
 {
-int			nFBs= 0;
-int			length= 0;
-Bool			classOk;
-
-    if (class==XkbDfltXIClass) {
-	if (dev->kbdfeed)	class= KbdFeedbackClass;
-	else if (dev->leds)	class= LedFeedbackClass;
-	else {
-	    client->errorValue= _XkbErrCode2(XkbErr_BadClass,class);
-	    return XkbKeyboardErrorCode;
-	}
-    }
-    classOk= FALSE;
-    if ((dev->kbdfeed)&&((class==KbdFeedbackClass)||(class==XkbAllXIClasses))) {
-	KbdFeedbackPtr kf;
-	classOk= TRUE;
-	for (kf= dev->kbdfeed;(kf);kf=kf->next) {
-	    if ((id!=XkbAllXIIds)&&(id!=XkbDfltXIId)&&(id!=kf->ctrl.id))
-		continue;
-	    nFBs++;
-	    length+= SIZEOF(xkbDeviceLedsWireDesc);
-	    if (!kf->xkb_sli)
-		kf->xkb_sli= XkbAllocSrvLedInfo(dev,kf,NULL,0);
-	    length+= ComputeDeviceLedInfoSize(dev,rep->present,kf->xkb_sli);
-	    if (id!=XkbAllXIIds)
-		break;
-	}
-    }
-    if ((dev->leds)&&((class==LedFeedbackClass)||(class==XkbAllXIClasses))) {
-	LedFeedbackPtr lf;
-	classOk= TRUE;
-	for (lf= dev->leds;(lf);lf=lf->next) {
-	    if ((id!=XkbAllXIIds)&&(id!=XkbDfltXIId)&&(id!=lf->ctrl.id))
-		continue;
-	    nFBs++;
-	    length+= SIZEOF(xkbDeviceLedsWireDesc);
-	    if (!lf->xkb_sli)
-		lf->xkb_sli= XkbAllocSrvLedInfo(dev,NULL,lf,0);
-	    length+= ComputeDeviceLedInfoSize(dev,rep->present,lf->xkb_sli);
-	    if (id!=XkbAllXIIds)
-		break;
-	}
-    }
-    if (nFBs>0) {
-        rep->nDeviceLedFBs= nFBs;
-        rep->length+= (length/4);
-	return Success;
-    }
-    if (classOk) client->errorValue= _XkbErrCode2(XkbErr_BadId,id);
-    else	 client->errorValue= _XkbErrCode2(XkbErr_BadClass,class);
+    int nFBs = 0;
+    int length = 0;
+    Bool classOk;
+
+    if (class == XkbDfltXIClass) {
+        if (dev->kbdfeed)
+            class = KbdFeedbackClass;
+        else if (dev->leds)
+            class = LedFeedbackClass;
+        else {
+            client->errorValue = _XkbErrCode2(XkbErr_BadClass, class);
+            return XkbKeyboardErrorCode;
+        }
+    }
+    classOk = FALSE;
+    if ((dev->kbdfeed) &&
+        ((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) {
+        KbdFeedbackPtr kf;
+
+        classOk = TRUE;
+        for (kf = dev->kbdfeed; (kf); kf = kf->next) {
+            if ((id != XkbAllXIIds) && (id != XkbDfltXIId) &&
+                (id != kf->ctrl.id))
+                continue;
+            nFBs++;
+            length += SIZEOF(xkbDeviceLedsWireDesc);
+            if (!kf->xkb_sli)
+                kf->xkb_sli = XkbAllocSrvLedInfo(dev, kf, NULL, 0);
+            length += ComputeDeviceLedInfoSize(dev, rep->present, kf->xkb_sli);
+            if (id != XkbAllXIIds)
+                break;
+        }
+    }
+    if ((dev->leds) &&
+        ((class == LedFeedbackClass) || (class == XkbAllXIClasses))) {
+        LedFeedbackPtr lf;
+
+        classOk = TRUE;
+        for (lf = dev->leds; (lf); lf = lf->next) {
+            if ((id != XkbAllXIIds) && (id != XkbDfltXIId) &&
+                (id != lf->ctrl.id))
+                continue;
+            nFBs++;
+            length += SIZEOF(xkbDeviceLedsWireDesc);
+            if (!lf->xkb_sli)
+                lf->xkb_sli = XkbAllocSrvLedInfo(dev, NULL, lf, 0);
+            length += ComputeDeviceLedInfoSize(dev, rep->present, lf->xkb_sli);
+            if (id != XkbAllXIIds)
+                break;
+        }
+    }
+    if (nFBs > 0) {
+        rep->nDeviceLedFBs = nFBs;
+        rep->length += (length / 4);
+        return Success;
+    }
+    if (classOk)
+        client->errorValue = _XkbErrCode2(XkbErr_BadId, id);
+    else
+        client->errorValue = _XkbErrCode2(XkbErr_BadClass, class);
     return XkbKeyboardErrorCode;
 }
 
 static int
-SendDeviceLedInfo(	XkbSrvLedInfoPtr	sli,
-			ClientPtr		client)
+SendDeviceLedInfo(XkbSrvLedInfoPtr sli, ClientPtr client)
 {
-xkbDeviceLedsWireDesc	wire;
-int			length;
-
-    length= 0;
-    wire.ledClass= 		sli->class;
-    wire.ledID= 		sli->id;
-    wire.namesPresent= 		sli->namesPresent;
-    wire.mapsPresent=   	sli->mapsPresent;
-    wire.physIndicators= 	sli->physIndicators;
-    wire.state=			sli->effectiveState;
+    xkbDeviceLedsWireDesc wire;
+    int length;
+
+    length = 0;
+    wire.ledClass = sli->class;
+    wire.ledID = sli->id;
+    wire.namesPresent = sli->namesPresent;
+    wire.mapsPresent = sli->mapsPresent;
+    wire.physIndicators = sli->physIndicators;
+    wire.state = sli->effectiveState;
     if (client->swapped) {
-	swaps(&wire.ledClass);
-	swaps(&wire.ledID);
-	swapl(&wire.namesPresent);
-	swapl(&wire.mapsPresent);
-	swapl(&wire.physIndicators);
-	swapl(&wire.state);
-    }
-    WriteToClient(client,SIZEOF(xkbDeviceLedsWireDesc),(char *)&wire);
-    length+= SIZEOF(xkbDeviceLedsWireDesc);
-    if (sli->namesPresent|sli->mapsPresent) {
-	register unsigned i,bit;
-	if (sli->namesPresent) {
-	    CARD32	awire;
-	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-		if (sli->namesPresent&bit) {
-		    awire= (CARD32)sli->names[i];
-		    if (client->swapped) {
-			swapl(&awire);
-		    }
-		    WriteToClient(client,4,(char *)&awire);
-		    length+= 4;
-		}
-	    }
-	}
-	if (sli->mapsPresent) {
-	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-		xkbIndicatorMapWireDesc	iwire;
-		if (sli->mapsPresent&bit) {
-		    iwire.flags= 	sli->maps[i].flags;
-		    iwire.whichGroups=	sli->maps[i].which_groups;
-		    iwire.groups=	sli->maps[i].groups;
-		    iwire.whichMods=	sli->maps[i].which_mods;
-		    iwire.mods=		sli->maps[i].mods.mask;
-		    iwire.realMods=	sli->maps[i].mods.real_mods;
-		    iwire.virtualMods=	sli->maps[i].mods.vmods;
-		    iwire.ctrls= 	sli->maps[i].ctrls;
-		    if (client->swapped) {
-			swaps(&iwire.virtualMods);
-			swapl(&iwire.ctrls);
-		    }
-		    WriteToClient(client,SIZEOF(xkbIndicatorMapWireDesc),
-								(char *)&iwire);
-		    length+= SIZEOF(xkbIndicatorMapWireDesc);
-		}
-	    }
-	}
+        swaps(&wire.ledClass);
+        swaps(&wire.ledID);
+        swapl(&wire.namesPresent);
+        swapl(&wire.mapsPresent);
+        swapl(&wire.physIndicators);
+        swapl(&wire.state);
+    }
+    WriteToClient(client, SIZEOF(xkbDeviceLedsWireDesc), (char *) &wire);
+    length += SIZEOF(xkbDeviceLedsWireDesc);
+    if (sli->namesPresent | sli->mapsPresent) {
+        register unsigned i, bit;
+
+        if (sli->namesPresent) {
+            CARD32 awire;
+
+            for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+                if (sli->namesPresent & bit) {
+                    awire = (CARD32) sli->names[i];
+                    if (client->swapped) {
+                        swapl(&awire);
+                    }
+                    WriteToClient(client, 4, (char *) &awire);
+                    length += 4;
+                }
+            }
+        }
+        if (sli->mapsPresent) {
+            for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+                xkbIndicatorMapWireDesc iwire;
+
+                if (sli->mapsPresent & bit) {
+                    iwire.flags = sli->maps[i].flags;
+                    iwire.whichGroups = sli->maps[i].which_groups;
+                    iwire.groups = sli->maps[i].groups;
+                    iwire.whichMods = sli->maps[i].which_mods;
+                    iwire.mods = sli->maps[i].mods.mask;
+                    iwire.realMods = sli->maps[i].mods.real_mods;
+                    iwire.virtualMods = sli->maps[i].mods.vmods;
+                    iwire.ctrls = sli->maps[i].ctrls;
+                    if (client->swapped) {
+                        swaps(&iwire.virtualMods);
+                        swapl(&iwire.ctrls);
+                    }
+                    WriteToClient(client, SIZEOF(xkbIndicatorMapWireDesc),
+                                  (char *) &iwire);
+                    length += SIZEOF(xkbIndicatorMapWireDesc);
+                }
+            }
+        }
     }
     return length;
 }
 
 static int
-SendDeviceLedFBs(	DeviceIntPtr	dev,
-			int		class,
-			int		id,
-			unsigned	wantLength,
-			ClientPtr	client)
+SendDeviceLedFBs(DeviceIntPtr dev,
+                 int class, int id, unsigned wantLength, ClientPtr client)
 {
-int			length= 0;
-
-    if (class==XkbDfltXIClass) {
-	if (dev->kbdfeed)	class= KbdFeedbackClass;
-	else if (dev->leds)	class= LedFeedbackClass;
-    }
-    if ((dev->kbdfeed)&&
-	((class==KbdFeedbackClass)||(class==XkbAllXIClasses))) {
-	KbdFeedbackPtr kf;
-	for (kf= dev->kbdfeed;(kf);kf=kf->next) {
-	    if ((id==XkbAllXIIds)||(id==XkbDfltXIId)||(id==kf->ctrl.id)) {
-		length+= SendDeviceLedInfo(kf->xkb_sli,client);
-		if (id!=XkbAllXIIds)
-		    break;
-	    }
-	}
-    }
-    if ((dev->leds)&&
-	((class==LedFeedbackClass)||(class==XkbAllXIClasses))) {
-	LedFeedbackPtr lf;
-	for (lf= dev->leds;(lf);lf=lf->next) {
-	    if ((id==XkbAllXIIds)||(id==XkbDfltXIId)||(id==lf->ctrl.id)) {
-		length+= SendDeviceLedInfo(lf->xkb_sli,client);
-		if (id!=XkbAllXIIds)
-		    break;
-	    }
-	}
-    }
-    if (length==wantLength)
-	 return Success;
-    else return BadLength;
+    int length = 0;
+
+    if (class == XkbDfltXIClass) {
+        if (dev->kbdfeed)
+            class = KbdFeedbackClass;
+        else if (dev->leds)
+            class = LedFeedbackClass;
+    }
+    if ((dev->kbdfeed) &&
+        ((class == KbdFeedbackClass) || (class == XkbAllXIClasses))) {
+        KbdFeedbackPtr kf;
+
+        for (kf = dev->kbdfeed; (kf); kf = kf->next) {
+            if ((id == XkbAllXIIds) || (id == XkbDfltXIId) ||
+                (id == kf->ctrl.id)) {
+                length += SendDeviceLedInfo(kf->xkb_sli, client);
+                if (id != XkbAllXIIds)
+                    break;
+            }
+        }
+    }
+    if ((dev->leds) &&
+        ((class == LedFeedbackClass) || (class == XkbAllXIClasses))) {
+        LedFeedbackPtr lf;
+
+        for (lf = dev->leds; (lf); lf = lf->next) {
+            if ((id == XkbAllXIIds) || (id == XkbDfltXIId) ||
+                (id == lf->ctrl.id)) {
+                length += SendDeviceLedInfo(lf->xkb_sli, client);
+                if (id != XkbAllXIIds)
+                    break;
+            }
+        }
+    }
+    if (length == wantLength)
+        return Success;
+    else
+        return BadLength;
 }
 
 int
 ProcXkbGetDeviceInfo(ClientPtr client)
 {
-DeviceIntPtr		dev;
-xkbGetDeviceInfoReply	rep;
-int			status,nDeviceLedFBs;
-unsigned		length,nameLen;
-CARD16			ledClass,ledID;
-unsigned		wanted;
-char *			str;
+    DeviceIntPtr dev;
+    xkbGetDeviceInfoReply rep;
+    int status, nDeviceLedFBs;
+    unsigned length, nameLen;
+    CARD16 ledClass, ledID;
+    unsigned wanted;
+    char *str;
 
     REQUEST(xkbGetDeviceInfoReq);
     REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
-    wanted= stuff->wanted;
+    wanted = stuff->wanted;
 
     CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixGetAttrAccess);
-    CHK_MASK_LEGAL(0x01,wanted,XkbXI_AllDeviceFeaturesMask);
+    CHK_MASK_LEGAL(0x01, wanted, XkbXI_AllDeviceFeaturesMask);
 
-    if ((!dev->button)||((stuff->nBtns<1)&&(!stuff->allBtns)))
-	wanted&= ~XkbXI_ButtonActionsMask;
-    if ((!dev->kbdfeed)&&(!dev->leds))
-	wanted&= ~XkbXI_IndicatorsMask;
+    if ((!dev->button) || ((stuff->nBtns < 1) && (!stuff->allBtns)))
+        wanted &= ~XkbXI_ButtonActionsMask;
+    if ((!dev->kbdfeed) && (!dev->leds))
+        wanted &= ~XkbXI_IndicatorsMask;
 
-    nameLen= XkbSizeCountedString(dev->name);
-    memset((char *)&rep, 0, SIZEOF(xkbGetDeviceInfoReply));
+    nameLen = XkbSizeCountedString(dev->name);
+    memset((char *) &rep, 0, SIZEOF(xkbGetDeviceInfoReply));
     rep.type = X_Reply;
-    rep.deviceID= dev->id;
+    rep.deviceID = dev->id;
     rep.sequenceNumber = client->sequence;
-    rep.length = nameLen/4;
+    rep.length = nameLen / 4;
     rep.present = wanted;
     rep.supported = XkbXI_AllDeviceFeaturesMask;
     rep.unsupported = 0;
     rep.firstBtnWanted = rep.nBtnsWanted = 0;
     rep.firstBtnRtrn = rep.nBtnsRtrn = 0;
     if (dev->button)
-	 rep.totalBtns= dev->button->numButtons;
-    else rep.totalBtns= 0;
-    rep.devType=	dev->xinput_type;
-    rep.hasOwnState=	(dev->key && dev->key->xkbInfo);
+        rep.totalBtns = dev->button->numButtons;
+    else
+        rep.totalBtns = 0;
+    rep.devType = dev->xinput_type;
+    rep.hasOwnState = (dev->key && dev->key->xkbInfo);
     rep.nDeviceLedFBs = 0;
-    if (dev->kbdfeed)	rep.dfltKbdFB= dev->kbdfeed->ctrl.id;
-    else		rep.dfltKbdFB= XkbXINone;
-    if (dev->leds)	rep.dfltLedFB= dev->leds->ctrl.id;
-    else		rep.dfltLedFB= XkbXINone;
-
-    ledClass= stuff->ledClass;
-    ledID= stuff->ledID;
-
-    rep.firstBtnWanted= rep.nBtnsWanted= 0;
-    rep.firstBtnRtrn= rep.nBtnsRtrn= 0;
-    if (wanted&XkbXI_ButtonActionsMask) {
-	if (stuff->allBtns) {
-	    stuff->firstBtn= 0;
-	    stuff->nBtns= dev->button->numButtons;
-	}
-
-	if ((stuff->firstBtn+stuff->nBtns)>dev->button->numButtons) {
-	    client->errorValue = _XkbErrCode4(0x02,dev->button->numButtons,
-							stuff->firstBtn,
-							stuff->nBtns);
-	    return BadValue;
-	}
-	else {
-	    rep.firstBtnWanted= stuff->firstBtn;
-	    rep.nBtnsWanted= stuff->nBtns;
-	    if (dev->button->xkb_acts!=NULL) {
-		XkbAction *act;
-		register int i;
-
-		rep.firstBtnRtrn= stuff->firstBtn;
-		rep.nBtnsRtrn= stuff->nBtns;
-		act= &dev->button->xkb_acts[rep.firstBtnWanted];
-		for (i=0;i<rep.nBtnsRtrn;i++,act++) {
-		    if (act->type!=XkbSA_NoAction)
-			break;
-		}
-		rep.firstBtnRtrn+=	i;
-		rep.nBtnsRtrn-=		i;
-		act= &dev->button->xkb_acts[rep.firstBtnRtrn+rep.nBtnsRtrn-1];
-		for (i=0;i<rep.nBtnsRtrn;i++,act--) {
-		    if (act->type!=XkbSA_NoAction)
-			break;
-		}
-		rep.nBtnsRtrn-=		i;
-	    }
-	    rep.length+= (rep.nBtnsRtrn*SIZEOF(xkbActionWireDesc))/4;
-	}
-    }
-
-    if (wanted&XkbXI_IndicatorsMask) {
-	status= CheckDeviceLedFBs(dev,ledClass,ledID,&rep,client);
-	if (status!=Success)
-	    return status;
-    }
-    length= rep.length*4;
+    if (dev->kbdfeed)
+        rep.dfltKbdFB = dev->kbdfeed->ctrl.id;
+    else
+        rep.dfltKbdFB = XkbXINone;
+    if (dev->leds)
+        rep.dfltLedFB = dev->leds->ctrl.id;
+    else
+        rep.dfltLedFB = XkbXINone;
+
+    ledClass = stuff->ledClass;
+    ledID = stuff->ledID;
+
+    rep.firstBtnWanted = rep.nBtnsWanted = 0;
+    rep.firstBtnRtrn = rep.nBtnsRtrn = 0;
+    if (wanted & XkbXI_ButtonActionsMask) {
+        if (stuff->allBtns) {
+            stuff->firstBtn = 0;
+            stuff->nBtns = dev->button->numButtons;
+        }
+
+        if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
+            client->errorValue = _XkbErrCode4(0x02, dev->button->numButtons,
+                                              stuff->firstBtn, stuff->nBtns);
+            return BadValue;
+        }
+        else {
+            rep.firstBtnWanted = stuff->firstBtn;
+            rep.nBtnsWanted = stuff->nBtns;
+            if (dev->button->xkb_acts != NULL) {
+                XkbAction *act;
+                register int i;
+
+                rep.firstBtnRtrn = stuff->firstBtn;
+                rep.nBtnsRtrn = stuff->nBtns;
+                act = &dev->button->xkb_acts[rep.firstBtnWanted];
+                for (i = 0; i < rep.nBtnsRtrn; i++, act++) {
+                    if (act->type != XkbSA_NoAction)
+                        break;
+                }
+                rep.firstBtnRtrn += i;
+                rep.nBtnsRtrn -= i;
+                act =
+                    &dev->button->xkb_acts[rep.firstBtnRtrn + rep.nBtnsRtrn -
+                                           1];
+                for (i = 0; i < rep.nBtnsRtrn; i++, act--) {
+                    if (act->type != XkbSA_NoAction)
+                        break;
+                }
+                rep.nBtnsRtrn -= i;
+            }
+            rep.length += (rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc)) / 4;
+        }
+    }
+
+    if (wanted & XkbXI_IndicatorsMask) {
+        status = CheckDeviceLedFBs(dev, ledClass, ledID, &rep, client);
+        if (status != Success)
+            return status;
+    }
+    length = rep.length * 4;
     nDeviceLedFBs = rep.nDeviceLedFBs;
     if (client->swapped) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swaps(&rep.present);
-	swaps(&rep.supported);
-	swaps(&rep.unsupported);
-	swaps(&rep.nDeviceLedFBs);
-	swaps(&rep.dfltKbdFB);
-	swaps(&rep.dfltLedFB);
-	swapl(&rep.devType);
-    }
-    WriteToClient(client,SIZEOF(xkbGetDeviceInfoReply), (char *)&rep);
-
-    str= malloc(nameLen);
-    if (!str) 
-	return BadAlloc;
-    XkbWriteCountedString(str,dev->name,client->swapped);
-    WriteToClient(client,nameLen,str);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.present);
+        swaps(&rep.supported);
+        swaps(&rep.unsupported);
+        swaps(&rep.nDeviceLedFBs);
+        swaps(&rep.dfltKbdFB);
+        swaps(&rep.dfltLedFB);
+        swapl(&rep.devType);
+    }
+    WriteToClient(client, SIZEOF(xkbGetDeviceInfoReply), (char *) &rep);
+
+    str = malloc(nameLen);
+    if (!str)
+        return BadAlloc;
+    XkbWriteCountedString(str, dev->name, client->swapped);
+    WriteToClient(client, nameLen, str);
     free(str);
-    length-= nameLen;
-
-    if (rep.nBtnsRtrn>0) {
-	int			sz;
-	xkbActionWireDesc *	awire;
-	sz= rep.nBtnsRtrn*SIZEOF(xkbActionWireDesc);
-	awire= (xkbActionWireDesc *)&dev->button->xkb_acts[rep.firstBtnRtrn];
-	WriteToClient(client,sz,(char *)awire);
-	length-= sz;
-    }
-    if (nDeviceLedFBs>0) {
-	status= SendDeviceLedFBs(dev,ledClass,ledID,length,client);
-	if (status!=Success)
-	    return status;
-    }
-    else if (length!=0)  {
-	ErrorF("[xkb] Internal Error!  BadLength in ProcXkbGetDeviceInfo\n");
-	ErrorF("[xkb]                  Wrote %d fewer bytes than expected\n",length);
-	return BadLength;
+    length -= nameLen;
+
+    if (rep.nBtnsRtrn > 0) {
+        int sz;
+        xkbActionWireDesc *awire;
+
+        sz = rep.nBtnsRtrn * SIZEOF(xkbActionWireDesc);
+        awire = (xkbActionWireDesc *) & dev->button->xkb_acts[rep.firstBtnRtrn];
+        WriteToClient(client, sz, (char *) awire);
+        length -= sz;
+    }
+    if (nDeviceLedFBs > 0) {
+        status = SendDeviceLedFBs(dev, ledClass, ledID, length, client);
+        if (status != Success)
+            return status;
+    }
+    else if (length != 0) {
+        ErrorF("[xkb] Internal Error!  BadLength in ProcXkbGetDeviceInfo\n");
+        ErrorF("[xkb]                  Wrote %d fewer bytes than expected\n",
+               length);
+        return BadLength;
     }
     return Success;
 }
 
 static char *
-CheckSetDeviceIndicators(	char *		wire,
-				DeviceIntPtr	dev,
-				int		num,
-				int *		status_rtrn,
-				ClientPtr	client)
+CheckSetDeviceIndicators(char *wire,
+                         DeviceIntPtr dev,
+                         int num, int *status_rtrn, ClientPtr client)
 {
-xkbDeviceLedsWireDesc *	ledWire;
-int			i;
-XkbSrvLedInfoPtr 	sli;
-
-    ledWire= (xkbDeviceLedsWireDesc *)wire;
-    for (i=0;i<num;i++) {
-	if (client->swapped) {
-	   swaps(&ledWire->ledClass);
-	   swaps(&ledWire->ledID);
-	   swapl(&ledWire->namesPresent);
-	   swapl(&ledWire->mapsPresent);
-	   swapl(&ledWire->physIndicators);
-	}
-
-        sli= XkbFindSrvLedInfo(dev,ledWire->ledClass,ledWire->ledID,
-							XkbXI_IndicatorsMask);
-	if (sli!=NULL) {
-	    register int n;
-	    register unsigned bit;
-	    int nMaps,nNames;
-	    CARD32 *atomWire;
-	    xkbIndicatorMapWireDesc *mapWire;
-
-	    nMaps= nNames= 0;
-	    for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
-		if (ledWire->namesPresent&bit)
-		    nNames++;
-		if (ledWire->mapsPresent&bit)
-		    nMaps++;
-	    }
-	    atomWire= (CARD32 *)&ledWire[1];
-	    if (nNames>0) {
-		for (n=0;n<nNames;n++) {
-		    if (client->swapped) {
-			swapl(atomWire);
-		    }
-		    CHK_ATOM_OR_NONE3(((Atom)(*atomWire)),client->errorValue,
-							*status_rtrn,NULL);
-		    atomWire++;
-		}
-	    }
-	    mapWire= (xkbIndicatorMapWireDesc *)atomWire;
-	    if (nMaps>0) {
-		for (n=0;n<nMaps;n++) {
-		    if (client->swapped) {
-			swaps(&mapWire->virtualMods);
-			swapl(&mapWire->ctrls);
-		    }
-		    CHK_MASK_LEGAL3(0x21,mapWire->whichGroups,
-						XkbIM_UseAnyGroup,
-						client->errorValue,
-						*status_rtrn,NULL);
-		    CHK_MASK_LEGAL3(0x22,mapWire->whichMods,XkbIM_UseAnyMods,
-						client->errorValue,
-						*status_rtrn,NULL);
-		    mapWire++;
-		}
-	    }
-	    ledWire= (xkbDeviceLedsWireDesc *)mapWire;
-	}
-	else {
-	    /* SHOULD NEVER HAPPEN */
-	    return (char *)ledWire;
-	}
-    }
-    return (char *)ledWire;
+    xkbDeviceLedsWireDesc *ledWire;
+    int i;
+    XkbSrvLedInfoPtr sli;
+
+    ledWire = (xkbDeviceLedsWireDesc *) wire;
+    for (i = 0; i < num; i++) {
+        if (client->swapped) {
+            swaps(&ledWire->ledClass);
+            swaps(&ledWire->ledID);
+            swapl(&ledWire->namesPresent);
+            swapl(&ledWire->mapsPresent);
+            swapl(&ledWire->physIndicators);
+        }
+
+        sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
+                                XkbXI_IndicatorsMask);
+        if (sli != NULL) {
+            register int n;
+            register unsigned bit;
+            int nMaps, nNames;
+            CARD32 *atomWire;
+            xkbIndicatorMapWireDesc *mapWire;
+
+            nMaps = nNames = 0;
+            for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+                if (ledWire->namesPresent & bit)
+                    nNames++;
+                if (ledWire->mapsPresent & bit)
+                    nMaps++;
+            }
+            atomWire = (CARD32 *) &ledWire[1];
+            if (nNames > 0) {
+                for (n = 0; n < nNames; n++) {
+                    if (client->swapped) {
+                        swapl(atomWire);
+                    }
+                    CHK_ATOM_OR_NONE3(((Atom) (*atomWire)), client->errorValue,
+                                      *status_rtrn, NULL);
+                    atomWire++;
+                }
+            }
+            mapWire = (xkbIndicatorMapWireDesc *) atomWire;
+            if (nMaps > 0) {
+                for (n = 0; n < nMaps; n++) {
+                    if (client->swapped) {
+                        swaps(&mapWire->virtualMods);
+                        swapl(&mapWire->ctrls);
+                    }
+                    CHK_MASK_LEGAL3(0x21, mapWire->whichGroups,
+                                    XkbIM_UseAnyGroup,
+                                    client->errorValue, *status_rtrn, NULL);
+                    CHK_MASK_LEGAL3(0x22, mapWire->whichMods, XkbIM_UseAnyMods,
+                                    client->errorValue, *status_rtrn, NULL);
+                    mapWire++;
+                }
+            }
+            ledWire = (xkbDeviceLedsWireDesc *) mapWire;
+        }
+        else {
+            /* SHOULD NEVER HAPPEN */
+            return (char *) ledWire;
+        }
+    }
+    return (char *) ledWire;
 }
 
 static char *
-SetDeviceIndicators(	char *			wire,
-			DeviceIntPtr		dev,
-			unsigned		changed,
-			int			num,
-			int *			status_rtrn,
-			ClientPtr		client,
-			xkbExtensionDeviceNotify *ev)
+SetDeviceIndicators(char *wire,
+                    DeviceIntPtr dev,
+                    unsigned changed,
+                    int num,
+                    int *status_rtrn,
+                    ClientPtr client, xkbExtensionDeviceNotify * ev)
 {
-xkbDeviceLedsWireDesc *		ledWire;
-int				i;
-XkbEventCauseRec		cause;
-unsigned			namec,mapc,statec;
-xkbExtensionDeviceNotify	ed;
-XkbChangesRec			changes;
-DeviceIntPtr			kbd;
-
-    memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
-    memset((char *)&changes, 0, sizeof(XkbChangesRec));
-    XkbSetCauseXkbReq(&cause,X_kbSetDeviceInfo,client);
-    ledWire= (xkbDeviceLedsWireDesc *)wire;
-    for (i=0;i<num;i++) {
-	register int			n;
-	register unsigned 		bit;
-	CARD32 *			atomWire;
-	xkbIndicatorMapWireDesc *	mapWire;
-	XkbSrvLedInfoPtr		sli;
-
-	namec= mapc= statec= 0;
-    	sli= XkbFindSrvLedInfo(dev,ledWire->ledClass,ledWire->ledID,
-						XkbXI_IndicatorMapsMask);
-	if (!sli) {
-	    /* SHOULD NEVER HAPPEN!! */
-	    return (char *)ledWire;
-	}
-
-	atomWire= (CARD32 *)&ledWire[1];
-	if (changed&XkbXI_IndicatorNamesMask) {
-	    namec= sli->namesPresent|ledWire->namesPresent;
-	    memset((char *)sli->names, 0, XkbNumIndicators*sizeof(Atom));
-	}
-	if (ledWire->namesPresent) {
-	    sli->namesPresent= ledWire->namesPresent;
-	    memset((char *)sli->names, 0, XkbNumIndicators*sizeof(Atom));
-	    for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
-		if (ledWire->namesPresent&bit) {
-		     sli->names[n]= (Atom)*atomWire;
-		     if (sli->names[n]==None)
-			ledWire->namesPresent&= ~bit;
-		     atomWire++; 
-		}
-	    }
-	}
-	mapWire= (xkbIndicatorMapWireDesc *)atomWire;
-	if (changed&XkbXI_IndicatorMapsMask) {
-	    mapc= sli->mapsPresent|ledWire->mapsPresent;
-	    sli->mapsPresent= ledWire->mapsPresent;
-	    memset((char*)sli->maps, 0, XkbNumIndicators*sizeof(XkbIndicatorMapRec));
-	}
-	if (ledWire->mapsPresent) {
-	    for (n=0,bit=1;n<XkbNumIndicators;n++,bit<<=1) {
-		if (ledWire->mapsPresent&bit) {
-		    sli->maps[n].flags=		mapWire->flags;
-		    sli->maps[n].which_groups=	mapWire->whichGroups;
-		    sli->maps[n].groups=	mapWire->groups;
-		    sli->maps[n].which_mods=	mapWire->whichMods;
-		    sli->maps[n].mods.mask=	mapWire->mods;
-		    sli->maps[n].mods.real_mods=mapWire->realMods;
-		    sli->maps[n].mods.vmods=	mapWire->virtualMods;
-		    sli->maps[n].ctrls=		mapWire->ctrls;
-		    mapWire++; 
-		}
-	    }
-	}
-	if (changed&XkbXI_IndicatorStateMask) {
-	    statec= sli->effectiveState^ledWire->state;
-	    sli->explicitState&= ~statec;
-	    sli->explicitState|= (ledWire->state&statec);
-	}
-	if (namec)
-	    XkbApplyLedNameChanges(dev,sli,namec,&ed,&changes,&cause);
-	if (mapc)
-	    XkbApplyLedMapChanges(dev,sli,mapc,&ed,&changes,&cause);
-	if (statec)
-	    XkbApplyLedStateChanges(dev,sli,statec,&ed,&changes,&cause);
-
-	kbd= dev;
-	if ((sli->flags&XkbSLI_HasOwnState)==0)
-	    kbd = inputInfo.keyboard;
-
-	XkbFlushLedEvents(dev,kbd,sli,&ed,&changes,&cause);
-	ledWire= (xkbDeviceLedsWireDesc *)mapWire;
-    }
-    return (char *)ledWire;
-}
+    xkbDeviceLedsWireDesc *ledWire;
+    int i;
+    XkbEventCauseRec cause;
+    unsigned namec, mapc, statec;
+    xkbExtensionDeviceNotify ed;
+    XkbChangesRec changes;
+    DeviceIntPtr kbd;
+
+    memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+    memset((char *) &changes, 0, sizeof(XkbChangesRec));
+    XkbSetCauseXkbReq(&cause, X_kbSetDeviceInfo, client);
+    ledWire = (xkbDeviceLedsWireDesc *) wire;
+    for (i = 0; i < num; i++) {
+        register int n;
+        register unsigned bit;
+        CARD32 *atomWire;
+        xkbIndicatorMapWireDesc *mapWire;
+        XkbSrvLedInfoPtr sli;
+
+        namec = mapc = statec = 0;
+        sli = XkbFindSrvLedInfo(dev, ledWire->ledClass, ledWire->ledID,
+                                XkbXI_IndicatorMapsMask);
+        if (!sli) {
+            /* SHOULD NEVER HAPPEN!! */
+            return (char *) ledWire;
+        }
 
+        atomWire = (CARD32 *) &ledWire[1];
+        if (changed & XkbXI_IndicatorNamesMask) {
+            namec = sli->namesPresent | ledWire->namesPresent;
+            memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom));
+        }
+        if (ledWire->namesPresent) {
+            sli->namesPresent = ledWire->namesPresent;
+            memset((char *) sli->names, 0, XkbNumIndicators * sizeof(Atom));
+            for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+                if (ledWire->namesPresent & bit) {
+                    sli->names[n] = (Atom) *atomWire;
+                    if (sli->names[n] == None)
+                        ledWire->namesPresent &= ~bit;
+                    atomWire++;
+                }
+            }
+        }
+        mapWire = (xkbIndicatorMapWireDesc *) atomWire;
+        if (changed & XkbXI_IndicatorMapsMask) {
+            mapc = sli->mapsPresent | ledWire->mapsPresent;
+            sli->mapsPresent = ledWire->mapsPresent;
+            memset((char *) sli->maps, 0,
+                   XkbNumIndicators * sizeof(XkbIndicatorMapRec));
+        }
+        if (ledWire->mapsPresent) {
+            for (n = 0, bit = 1; n < XkbNumIndicators; n++, bit <<= 1) {
+                if (ledWire->mapsPresent & bit) {
+                    sli->maps[n].flags = mapWire->flags;
+                    sli->maps[n].which_groups = mapWire->whichGroups;
+                    sli->maps[n].groups = mapWire->groups;
+                    sli->maps[n].which_mods = mapWire->whichMods;
+                    sli->maps[n].mods.mask = mapWire->mods;
+                    sli->maps[n].mods.real_mods = mapWire->realMods;
+                    sli->maps[n].mods.vmods = mapWire->virtualMods;
+                    sli->maps[n].ctrls = mapWire->ctrls;
+                    mapWire++;
+                }
+            }
+        }
+        if (changed & XkbXI_IndicatorStateMask) {
+            statec = sli->effectiveState ^ ledWire->state;
+            sli->explicitState &= ~statec;
+            sli->explicitState |= (ledWire->state & statec);
+        }
+        if (namec)
+            XkbApplyLedNameChanges(dev, sli, namec, &ed, &changes, &cause);
+        if (mapc)
+            XkbApplyLedMapChanges(dev, sli, mapc, &ed, &changes, &cause);
+        if (statec)
+            XkbApplyLedStateChanges(dev, sli, statec, &ed, &changes, &cause);
+
+        kbd = dev;
+        if ((sli->flags & XkbSLI_HasOwnState) == 0)
+            kbd = inputInfo.keyboard;
+
+        XkbFlushLedEvents(dev, kbd, sli, &ed, &changes, &cause);
+        ledWire = (xkbDeviceLedsWireDesc *) mapWire;
+    }
+    return (char *) ledWire;
+}
 
 static int
 _XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
-                  xkbSetDeviceInfoReq *stuff)
+                  xkbSetDeviceInfoReq * stuff)
 {
-    char                       *wire;
-
-    wire= (char *)&stuff[1];
-    if (stuff->change&XkbXI_ButtonActionsMask) {
-	if (!dev->button) {
-	    client->errorValue = _XkbErrCode2(XkbErr_BadClass,ButtonClass);
-	    return XkbKeyboardErrorCode;
-	}
-	if ((stuff->firstBtn+stuff->nBtns)>dev->button->numButtons) {
-	    client->errorValue= _XkbErrCode4(0x02,stuff->firstBtn,stuff->nBtns,
-						dev->button->numButtons);
-	    return BadMatch;
-	}
-	wire+= (stuff->nBtns*SIZEOF(xkbActionWireDesc));
-    }
-    if (stuff->change&XkbXI_IndicatorsMask) {
-	int status= Success;
-	wire= CheckSetDeviceIndicators(wire,dev,stuff->nDeviceLedFBs,
-							&status,client);
-	if (status!=Success)
-	    return status;
-    }
-    if (((wire-((char *)stuff))/4)!=stuff->length)
-	return BadLength;
+    char *wire;
+
+    wire = (char *) &stuff[1];
+    if (stuff->change & XkbXI_ButtonActionsMask) {
+        if (!dev->button) {
+            client->errorValue = _XkbErrCode2(XkbErr_BadClass, ButtonClass);
+            return XkbKeyboardErrorCode;
+        }
+        if ((stuff->firstBtn + stuff->nBtns) > dev->button->numButtons) {
+            client->errorValue =
+                _XkbErrCode4(0x02, stuff->firstBtn, stuff->nBtns,
+                             dev->button->numButtons);
+            return BadMatch;
+        }
+        wire += (stuff->nBtns * SIZEOF(xkbActionWireDesc));
+    }
+    if (stuff->change & XkbXI_IndicatorsMask) {
+        int status = Success;
+
+        wire = CheckSetDeviceIndicators(wire, dev, stuff->nDeviceLedFBs,
+                                        &status, client);
+        if (status != Success)
+            return status;
+    }
+    if (((wire - ((char *) stuff)) / 4) != stuff->length)
+        return BadLength;
 
     return Success;
 }
 
 static int
 _XkbSetDeviceInfoCheck(ClientPtr client, DeviceIntPtr dev,
-                       xkbSetDeviceInfoReq *stuff)
+                       xkbSetDeviceInfoReq * stuff)
 {
-    char                       *wire;
-    xkbExtensionDeviceNotify    ed;
-
-    memset((char *)&ed, 0, SIZEOF(xkbExtensionDeviceNotify));
-    ed.deviceID=	dev->id;
-    wire= (char *)&stuff[1];
-    if (stuff->change&XkbXI_ButtonActionsMask) {
-	int			nBtns,sz,i;
-	XkbAction *		acts;
-	DeviceIntPtr		kbd;
-
-	nBtns= dev->button->numButtons;
-	acts= dev->button->xkb_acts;
-	if (acts==NULL) {
-	    acts= calloc(nBtns, sizeof(XkbAction));
-	    if (!acts)
-		return BadAlloc;
-	    dev->button->xkb_acts= acts;
-	}
-	sz= stuff->nBtns*SIZEOF(xkbActionWireDesc);
-	memcpy((char *)&acts[stuff->firstBtn],(char *)wire,sz);
-	wire+= sz;
-	ed.reason|=	XkbXI_ButtonActionsMask;
-	ed.firstBtn=	stuff->firstBtn;
-	ed.nBtns=	stuff->nBtns;
-
-	if (dev->key)	kbd= dev;
-	else		kbd= inputInfo.keyboard;
-	acts= &dev->button->xkb_acts[stuff->firstBtn];
-	for (i=0;i<stuff->nBtns;i++,acts++) {
-	    if (acts->type!=XkbSA_NoAction)
-		XkbSetActionKeyMods(kbd->key->xkbInfo->desc,acts,0);
-	}
-    }
-    if (stuff->change&XkbXI_IndicatorsMask) {
-	int status= Success;
-	wire= SetDeviceIndicators(wire,dev,stuff->change,
-				  stuff->nDeviceLedFBs, &status,client,&ed);
-	if (status!=Success)
-	    return status;
-    }
-    if ((stuff->change)&&(ed.reason))
-	XkbSendExtensionDeviceNotify(dev,client,&ed);
+    char *wire;
+    xkbExtensionDeviceNotify ed;
+
+    memset((char *) &ed, 0, SIZEOF(xkbExtensionDeviceNotify));
+    ed.deviceID = dev->id;
+    wire = (char *) &stuff[1];
+    if (stuff->change & XkbXI_ButtonActionsMask) {
+        int nBtns, sz, i;
+        XkbAction *acts;
+        DeviceIntPtr kbd;
+
+        nBtns = dev->button->numButtons;
+        acts = dev->button->xkb_acts;
+        if (acts == NULL) {
+            acts = calloc(nBtns, sizeof(XkbAction));
+            if (!acts)
+                return BadAlloc;
+            dev->button->xkb_acts = acts;
+        }
+        sz = stuff->nBtns * SIZEOF(xkbActionWireDesc);
+        memcpy((char *) &acts[stuff->firstBtn], (char *) wire, sz);
+        wire += sz;
+        ed.reason |= XkbXI_ButtonActionsMask;
+        ed.firstBtn = stuff->firstBtn;
+        ed.nBtns = stuff->nBtns;
+
+        if (dev->key)
+            kbd = dev;
+        else
+            kbd = inputInfo.keyboard;
+        acts = &dev->button->xkb_acts[stuff->firstBtn];
+        for (i = 0; i < stuff->nBtns; i++, acts++) {
+            if (acts->type != XkbSA_NoAction)
+                XkbSetActionKeyMods(kbd->key->xkbInfo->desc, acts, 0);
+        }
+    }
+    if (stuff->change & XkbXI_IndicatorsMask) {
+        int status = Success;
+
+        wire = SetDeviceIndicators(wire, dev, stuff->change,
+                                   stuff->nDeviceLedFBs, &status, client, &ed);
+        if (status != Success)
+            return status;
+    }
+    if ((stuff->change) && (ed.reason))
+        XkbSendExtensionDeviceNotify(dev, client, &ed);
     return Success;
 }
 
 int
 ProcXkbSetDeviceInfo(ClientPtr client)
 {
-    DeviceIntPtr        dev;
-    int                 rc;
+    DeviceIntPtr dev;
+    int rc;
 
     REQUEST(xkbSetDeviceInfoReq);
     REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq);
 
-    if (!(client->xkbClientFlags&_XkbClientInitialized))
-	return BadAccess;
+    if (!(client->xkbClientFlags & _XkbClientInitialized))
+        return BadAccess;
 
     CHK_ANY_DEVICE(dev, stuff->deviceSpec, client, DixManageAccess);
-    CHK_MASK_LEGAL(0x01,stuff->change,XkbXI_AllFeaturesMask);
+    CHK_MASK_LEGAL(0x01, stuff->change, XkbXI_AllFeaturesMask);
 
     rc = _XkbSetDeviceInfoCheck(client, dev, stuff);
 
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd || stuff->deviceSpec == XkbUseCorePtr)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd ||
+        stuff->deviceSpec == XkbUseCorePtr) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if (((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev) &&
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if (((other != dev) && !IsMaster(other) &&
+                 GetMaster(other, MASTER_KEYBOARD) == dev) &&
                 ((stuff->deviceSpec == XkbUseCoreKbd && other->key) ||
-                (stuff->deviceSpec == XkbUseCorePtr && other->button)))
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+                 (stuff->deviceSpec == XkbUseCorePtr && other->button))) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     rc = _XkbSetDeviceInfoCheck(client, other, stuff);
                     if (rc != Success)
                         return rc;
@@ -6526,18 +6677,18 @@ ProcXkbSetDeviceInfo(ClientPtr client)
     if (rc != Success)
         return rc;
 
-    if (stuff->deviceSpec == XkbUseCoreKbd || stuff->deviceSpec == XkbUseCorePtr)
-    {
+    if (stuff->deviceSpec == XkbUseCoreKbd ||
+        stuff->deviceSpec == XkbUseCorePtr) {
         DeviceIntPtr other;
-        for (other = inputInfo.devices; other; other = other->next)
-        {
-            if (((other != dev) && !IsMaster(other) && GetMaster(other, MASTER_KEYBOARD) == dev) &&
+
+        for (other = inputInfo.devices; other; other = other->next) {
+            if (((other != dev) && !IsMaster(other) &&
+                 GetMaster(other, MASTER_KEYBOARD) == dev) &&
                 ((stuff->deviceSpec == XkbUseCoreKbd && other->key) ||
-                (stuff->deviceSpec == XkbUseCorePtr && other->button)))
-            {
-                rc = XaceHook(XACE_DEVICE_ACCESS, client, other, DixManageAccess);
-                if (rc == Success)
-                {
+                 (stuff->deviceSpec == XkbUseCorePtr && other->button))) {
+                rc = XaceHook(XACE_DEVICE_ACCESS, client, other,
+                              DixManageAccess);
+                if (rc == Success) {
                     rc = _XkbSetDeviceInfo(client, other, stuff);
                     if (rc != Success)
                         return rc;
@@ -6554,135 +6705,139 @@ ProcXkbSetDeviceInfo(ClientPtr client)
 int
 ProcXkbSetDebuggingFlags(ClientPtr client)
 {
-CARD32 				newFlags,newCtrls,extraLength;
-xkbSetDebuggingFlagsReply 	rep;
-int rc;
+    CARD32 newFlags, newCtrls, extraLength;
+    xkbSetDebuggingFlagsReply rep;
+    int rc;
 
     REQUEST(xkbSetDebuggingFlagsReq);
     REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq);
 
     rc = XaceHook(XACE_SERVER_ACCESS, client, DixDebugAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    newFlags=  xkbDebugFlags&(~stuff->affectFlags);
-    newFlags|= (stuff->flags&stuff->affectFlags);
-    newCtrls=  xkbDebugCtrls&(~stuff->affectCtrls);
-    newCtrls|= (stuff->ctrls&stuff->affectCtrls);
+    newFlags = xkbDebugFlags & (~stuff->affectFlags);
+    newFlags |= (stuff->flags & stuff->affectFlags);
+    newCtrls = xkbDebugCtrls & (~stuff->affectCtrls);
+    newCtrls |= (stuff->ctrls & stuff->affectCtrls);
     if (xkbDebugFlags || newFlags || stuff->msgLength) {
-	ErrorF("[xkb] XkbDebug: Setting debug flags to 0x%lx\n",(long)newFlags);
-	if (newCtrls!=xkbDebugCtrls)
-	    ErrorF("[xkb] XkbDebug: Setting debug controls to 0x%lx\n",(long)newCtrls);
-    }
-    extraLength= (stuff->length<<2)-sz_xkbSetDebuggingFlagsReq;
-    if (stuff->msgLength>0) {
-	char *msg;
-	if (extraLength<XkbPaddedSize(stuff->msgLength)) {
-	    ErrorF("[xkb] XkbDebug: msgLength= %d, length= %ld (should be %d)\n",
-			stuff->msgLength,(long)extraLength,
-			XkbPaddedSize(stuff->msgLength));
-	    return BadLength;
-	}
-	msg= (char *)&stuff[1];
-	if (msg[stuff->msgLength-1]!='\0') {
-	    ErrorF("[xkb] XkbDebug: message not null-terminated\n");
-	    return BadValue;
-	}
-	ErrorF("[xkb] XkbDebug: %s\n",msg);
+        ErrorF("[xkb] XkbDebug: Setting debug flags to 0x%lx\n",
+               (long) newFlags);
+        if (newCtrls != xkbDebugCtrls)
+            ErrorF("[xkb] XkbDebug: Setting debug controls to 0x%lx\n",
+                   (long) newCtrls);
+    }
+    extraLength = (stuff->length << 2) - sz_xkbSetDebuggingFlagsReq;
+    if (stuff->msgLength > 0) {
+        char *msg;
+
+        if (extraLength < XkbPaddedSize(stuff->msgLength)) {
+            ErrorF
+                ("[xkb] XkbDebug: msgLength= %d, length= %ld (should be %d)\n",
+                 stuff->msgLength, (long) extraLength,
+                 XkbPaddedSize(stuff->msgLength));
+            return BadLength;
+        }
+        msg = (char *) &stuff[1];
+        if (msg[stuff->msgLength - 1] != '\0') {
+            ErrorF("[xkb] XkbDebug: message not null-terminated\n");
+            return BadValue;
+        }
+        ErrorF("[xkb] XkbDebug: %s\n", msg);
     }
     xkbDebugFlags = newFlags;
     xkbDebugCtrls = newCtrls;
 
-    rep.type= X_Reply;
+    rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     rep.currentFlags = newFlags;
     rep.currentCtrls = newCtrls;
     rep.supportedFlags = ~0;
     rep.supportedCtrls = ~0;
-    if ( client->swapped ) {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.currentFlags);
-	swapl(&rep.currentCtrls);
-	swapl(&rep.supportedFlags);
-	swapl(&rep.supportedCtrls);
-    }
-    WriteToClient(client,SIZEOF(xkbSetDebuggingFlagsReply), (char *)&rep);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.currentFlags);
+        swapl(&rep.currentCtrls);
+        swapl(&rep.supportedFlags);
+        swapl(&rep.supportedCtrls);
+    }
+    WriteToClient(client, SIZEOF(xkbSetDebuggingFlagsReply), (char *) &rep);
     return Success;
 }
 
 /***====================================================================***/
 
 static int
-ProcXkbDispatch (ClientPtr client)
+ProcXkbDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
-    {
+    switch (stuff->data) {
     case X_kbUseExtension:
-	return ProcXkbUseExtension(client);
+        return ProcXkbUseExtension(client);
     case X_kbSelectEvents:
-	return ProcXkbSelectEvents(client);
+        return ProcXkbSelectEvents(client);
     case X_kbBell:
-	return ProcXkbBell(client);
+        return ProcXkbBell(client);
     case X_kbGetState:
-	return ProcXkbGetState(client);
+        return ProcXkbGetState(client);
     case X_kbLatchLockState:
-	return ProcXkbLatchLockState(client);
+        return ProcXkbLatchLockState(client);
     case X_kbGetControls:
-	return ProcXkbGetControls(client);
+        return ProcXkbGetControls(client);
     case X_kbSetControls:
-	return ProcXkbSetControls(client);
+        return ProcXkbSetControls(client);
     case X_kbGetMap:
-	return ProcXkbGetMap(client);
+        return ProcXkbGetMap(client);
     case X_kbSetMap:
-	return ProcXkbSetMap(client);
+        return ProcXkbSetMap(client);
     case X_kbGetCompatMap:
-	return ProcXkbGetCompatMap(client);
+        return ProcXkbGetCompatMap(client);
     case X_kbSetCompatMap:
-	return ProcXkbSetCompatMap(client);
+        return ProcXkbSetCompatMap(client);
     case X_kbGetIndicatorState:
-	return ProcXkbGetIndicatorState(client);
+        return ProcXkbGetIndicatorState(client);
     case X_kbGetIndicatorMap:
-	return ProcXkbGetIndicatorMap(client);
+        return ProcXkbGetIndicatorMap(client);
     case X_kbSetIndicatorMap:
-	return ProcXkbSetIndicatorMap(client);
+        return ProcXkbSetIndicatorMap(client);
     case X_kbGetNamedIndicator:
-	return ProcXkbGetNamedIndicator(client);
+        return ProcXkbGetNamedIndicator(client);
     case X_kbSetNamedIndicator:
-	return ProcXkbSetNamedIndicator(client);
+        return ProcXkbSetNamedIndicator(client);
     case X_kbGetNames:
-	return ProcXkbGetNames(client);
+        return ProcXkbGetNames(client);
     case X_kbSetNames:
-	return ProcXkbSetNames(client);
+        return ProcXkbSetNames(client);
     case X_kbGetGeometry:
-	return ProcXkbGetGeometry(client);
+        return ProcXkbGetGeometry(client);
     case X_kbSetGeometry:
-	return ProcXkbSetGeometry(client);
+        return ProcXkbSetGeometry(client);
     case X_kbPerClientFlags:
-	return ProcXkbPerClientFlags(client);
+        return ProcXkbPerClientFlags(client);
     case X_kbListComponents:
-	return ProcXkbListComponents(client);
+        return ProcXkbListComponents(client);
     case X_kbGetKbdByName:
-	return ProcXkbGetKbdByName(client);
+        return ProcXkbGetKbdByName(client);
     case X_kbGetDeviceInfo:
-	return ProcXkbGetDeviceInfo(client);
+        return ProcXkbGetDeviceInfo(client);
     case X_kbSetDeviceInfo:
-	return ProcXkbSetDeviceInfo(client);
+        return ProcXkbSetDeviceInfo(client);
     case X_kbSetDebuggingFlags:
-	return ProcXkbSetDebuggingFlags(client);
+        return ProcXkbSetDebuggingFlags(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
 
 static int
-XkbClientGone(pointer data,XID id)
+XkbClientGone(pointer data, XID id)
 {
-    DevicePtr	pXDev = (DevicePtr)data;
+    DevicePtr pXDev = (DevicePtr) data;
 
-    if (!XkbRemoveResourceClient(pXDev,id)) {
-	ErrorF("[xkb] Internal Error! bad RemoveResourceClient in XkbClientGone\n");
+    if (!XkbRemoveResourceClient(pXDev, id)) {
+        ErrorF
+            ("[xkb] Internal Error! bad RemoveResourceClient in XkbClientGone\n");
     }
     return 1;
 }
@@ -6694,20 +6849,18 @@ XkbExtensionInit(void)
 
     RT_XKBCLIENT = CreateNewResourceType(XkbClientGone, "XkbClient");
     if (!RT_XKBCLIENT)
-	return;
+        return;
 
     if (!XkbInitPrivates())
-	return;
+        return;
 
     if ((extEntry = AddExtension(XkbName, XkbNumberEvents, XkbNumberErrors,
-				 ProcXkbDispatch, SProcXkbDispatch,
-				 NULL, StandardMinorOpcode))) {
-	XkbReqCode = (unsigned char)extEntry->base;
-	XkbEventBase = (unsigned char)extEntry->eventBase;
-	XkbErrorBase = (unsigned char)extEntry->errorBase;
-	XkbKeyboardErrorCode = XkbErrorBase+XkbKeyboard;
+                                 ProcXkbDispatch, SProcXkbDispatch,
+                                 NULL, StandardMinorOpcode))) {
+        XkbReqCode = (unsigned char) extEntry->base;
+        XkbEventBase = (unsigned char) extEntry->eventBase;
+        XkbErrorBase = (unsigned char) extEntry->errorBase;
+        XkbKeyboardErrorCode = XkbErrorBase + XkbKeyboard;
     }
     return;
 }
-
-