24 files changed, 16044 insertions, 15543 deletions

diff --git a/xorg-server/xkb/XKBAlloc.c b/xorg-server/xkb/XKBAlloc.c
index b70ac1705..20e0459af 100644
--- a/xorg-server/xkb/XKBAlloc.c
+++ b/xorg-server/xkb/XKBAlloc.c
@@ -40,75 +40,76 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 /***===================================================================***/
 
-/*ARGSUSED*/
-Status
-XkbAllocCompatMap(XkbDescPtr xkb,unsigned which,unsigned nSI)
+ /*ARGSUSED*/ Status
+XkbAllocCompatMap(XkbDescPtr xkb, unsigned which, unsigned nSI)
 {
-XkbCompatMapPtr	compat;
-XkbSymInterpretRec *prev_interpret;
+    XkbCompatMapPtr compat;
+    XkbSymInterpretRec *prev_interpret;
 
     if (!xkb)
-	return BadMatch;
+        return BadMatch;
     if (xkb->compat) {
-	if (xkb->compat->size_si>=nSI)
-	    return Success;
-	compat= xkb->compat;
-	compat->size_si= nSI;
-	if (compat->sym_interpret==NULL)
-	    compat->num_si= 0;
-	prev_interpret = compat->sym_interpret;
-	compat->sym_interpret= realloc(compat->sym_interpret,
-					nSI * sizeof(XkbSymInterpretRec));
-	if (compat->sym_interpret==NULL) {
-	    free(prev_interpret);
-	    compat->size_si= compat->num_si= 0;
-	    return BadAlloc;
-	}
-	if (compat->num_si!=0) {
-	    memset(&compat->sym_interpret[compat->num_si], 0,
-		   (compat->size_si - compat->num_si) * sizeof(XkbSymInterpretRec));
-	}
-	return Success;
+        if (xkb->compat->size_si >= nSI)
+            return Success;
+        compat = xkb->compat;
+        compat->size_si = nSI;
+        if (compat->sym_interpret == NULL)
+            compat->num_si = 0;
+        prev_interpret = compat->sym_interpret;
+        compat->sym_interpret = realloc(compat->sym_interpret,
+                                        nSI * sizeof(XkbSymInterpretRec));
+        if (compat->sym_interpret == NULL) {
+            free(prev_interpret);
+            compat->size_si = compat->num_si = 0;
+            return BadAlloc;
+        }
+        if (compat->num_si != 0) {
+            memset(&compat->sym_interpret[compat->num_si], 0,
+                   (compat->size_si -
+                    compat->num_si) * sizeof(XkbSymInterpretRec));
+        }
+        return Success;
     }
-   compat= calloc(1, sizeof(XkbCompatMapRec));
-    if (compat==NULL)
-	return BadAlloc;
-    if (nSI>0) {
-	compat->sym_interpret= calloc(nSI, sizeof(XkbSymInterpretRec));
-	if (!compat->sym_interpret) {
-	    free(compat);
-	    return BadAlloc;
-	}
+    compat = calloc(1, sizeof(XkbCompatMapRec));
+    if (compat == NULL)
+        return BadAlloc;
+    if (nSI > 0) {
+        compat->sym_interpret = calloc(nSI, sizeof(XkbSymInterpretRec));
+        if (!compat->sym_interpret) {
+            free(compat);
+            return BadAlloc;
+        }
     }
-    compat->size_si= nSI;
-    compat->num_si= 0;
-    memset((char *)&compat->groups[0], 0, XkbNumKbdGroups*sizeof(XkbModsRec));
-    xkb->compat= compat;
+    compat->size_si = nSI;
+    compat->num_si = 0;
+    memset((char *) &compat->groups[0], 0,
+           XkbNumKbdGroups * sizeof(XkbModsRec));
+    xkb->compat = compat;
     return Success;
 }
 
-
 void
-XkbFreeCompatMap(XkbDescPtr xkb,unsigned which,Bool freeMap)
+XkbFreeCompatMap(XkbDescPtr xkb, unsigned which, Bool freeMap)
 {
-register XkbCompatMapPtr compat;
+    register XkbCompatMapPtr compat;
 
-    if ((xkb==NULL)||(xkb->compat==NULL))
-	return;
-    compat= xkb->compat;
+    if ((xkb == NULL) || (xkb->compat == NULL))
+        return;
+    compat = xkb->compat;
     if (freeMap)
-	which= XkbAllCompatMask;
-    if (which&XkbGroupCompatMask)
-	memset((char *)&compat->groups[0], 0, XkbNumKbdGroups*sizeof(XkbModsRec));
-    if (which&XkbSymInterpMask) {
-	if ((compat->sym_interpret)&&(compat->size_si>0))
-	    free(compat->sym_interpret);
-	compat->size_si= compat->num_si= 0;
-	compat->sym_interpret= NULL;
+        which = XkbAllCompatMask;
+    if (which & XkbGroupCompatMask)
+        memset((char *) &compat->groups[0], 0,
+               XkbNumKbdGroups * sizeof(XkbModsRec));
+    if (which & XkbSymInterpMask) {
+        if ((compat->sym_interpret) && (compat->size_si > 0))
+            free(compat->sym_interpret);
+        compat->size_si = compat->num_si = 0;
+        compat->sym_interpret = NULL;
     }
     if (freeMap) {
-	free(compat);
-	xkb->compat= NULL;
+        free(compat);
+        xkb->compat = NULL;
     }
     return;
 }
@@ -116,153 +117,158 @@ register XkbCompatMapPtr compat;
 /***===================================================================***/
 
 Status
-XkbAllocNames(XkbDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)
+XkbAllocNames(XkbDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases)
 {
-XkbNamesPtr	names;
-
-    if (xkb==NULL)
-	return BadMatch;
-    if (xkb->names==NULL) {
-	xkb->names = calloc(1, sizeof(XkbNamesRec));
-	if (xkb->names==NULL)
-	    return BadAlloc;
+    XkbNamesPtr names;
+
+    if (xkb == NULL)
+        return BadMatch;
+    if (xkb->names == NULL) {
+        xkb->names = calloc(1, sizeof(XkbNamesRec));
+        if (xkb->names == NULL)
+            return BadAlloc;
     }
-    names= xkb->names;
-    if ((which&XkbKTLevelNamesMask)&&(xkb->map!=NULL)&&(xkb->map->types!=NULL)){
-	register int	i;
-	XkbKeyTypePtr	type;
-
-	type= xkb->map->types;
-	for (i=0;i<xkb->map->num_types;i++,type++) {
-	    if (type->level_names==NULL) {
-		type->level_names= calloc(type->num_levels, sizeof(Atom));
-		if (type->level_names==NULL)
-		    return BadAlloc;
-	    }
-	}
+    names = xkb->names;
+    if ((which & XkbKTLevelNamesMask) && (xkb->map != NULL) &&
+        (xkb->map->types != NULL)) {
+        register int i;
+        XkbKeyTypePtr type;
+
+        type = xkb->map->types;
+        for (i = 0; i < xkb->map->num_types; i++, type++) {
+            if (type->level_names == NULL) {
+                type->level_names = calloc(type->num_levels, sizeof(Atom));
+                if (type->level_names == NULL)
+                    return BadAlloc;
+            }
+        }
     }
-    if ((which&XkbKeyNamesMask)&&(names->keys==NULL)) {
-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
-	    (!XkbIsLegalKeycode(xkb->max_key_code))||
-	    (xkb->max_key_code<xkb->min_key_code)) 
-	    return BadValue;
-	names->keys= calloc((xkb->max_key_code+1), sizeof(XkbKeyNameRec));
-	if (names->keys==NULL)
-	    return BadAlloc;
+    if ((which & XkbKeyNamesMask) && (names->keys == NULL)) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadValue;
+        names->keys = calloc((xkb->max_key_code + 1), sizeof(XkbKeyNameRec));
+        if (names->keys == NULL)
+            return BadAlloc;
     }
-    if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {
-	if (names->key_aliases==NULL) {
-	    names->key_aliases= calloc(nTotalAliases, sizeof(XkbKeyAliasRec));
-	}
-	else if (nTotalAliases>names->num_key_aliases) {
-	    XkbKeyAliasRec *prev_aliases = names->key_aliases;
-
-	    names->key_aliases= realloc(names->key_aliases,
-					 nTotalAliases * sizeof(XkbKeyAliasRec));
-	    if (names->key_aliases!=NULL) {
-		memset(&names->key_aliases[names->num_key_aliases], 0,
-			(nTotalAliases - names->num_key_aliases) * sizeof(XkbKeyAliasRec));
-	    } else {
-		free(prev_aliases);
-	    }
-	}
-	if (names->key_aliases==NULL) {
-	    names->num_key_aliases= 0;
-	    return BadAlloc;
-	}
-	names->num_key_aliases= nTotalAliases;
+    if ((which & XkbKeyAliasesMask) && (nTotalAliases > 0)) {
+        if (names->key_aliases == NULL) {
+            names->key_aliases = calloc(nTotalAliases, sizeof(XkbKeyAliasRec));
+        }
+        else if (nTotalAliases > names->num_key_aliases) {
+            XkbKeyAliasRec *prev_aliases = names->key_aliases;
+
+            names->key_aliases = realloc(names->key_aliases,
+                                         nTotalAliases *
+                                         sizeof(XkbKeyAliasRec));
+            if (names->key_aliases != NULL) {
+                memset(&names->key_aliases[names->num_key_aliases], 0,
+                       (nTotalAliases -
+                        names->num_key_aliases) * sizeof(XkbKeyAliasRec));
+            }
+            else {
+                free(prev_aliases);
+            }
+        }
+        if (names->key_aliases == NULL) {
+            names->num_key_aliases = 0;
+            return BadAlloc;
+        }
+        names->num_key_aliases = nTotalAliases;
     }
-    if ((which&XkbRGNamesMask)&&(nTotalRG>0)) {
-	if (names->radio_groups==NULL) {
-	    names->radio_groups= calloc(nTotalRG, sizeof(Atom));
-	}
-	else if (nTotalRG>names->num_rg) {
-	    Atom *prev_radio_groups = names->radio_groups;
-
-	    names->radio_groups= realloc(names->radio_groups,
-					  nTotalRG * sizeof(Atom));
-	    if (names->radio_groups!=NULL) {
-		memset(&names->radio_groups[names->num_rg], 0,
-			(nTotalRG - names->num_rg) * sizeof(Atom));
-	    } else {
-		free(prev_radio_groups);
-	    }
-	}
-	if (names->radio_groups==NULL)
-	    return BadAlloc;
-	names->num_rg= nTotalRG;
+    if ((which & XkbRGNamesMask) && (nTotalRG > 0)) {
+        if (names->radio_groups == NULL) {
+            names->radio_groups = calloc(nTotalRG, sizeof(Atom));
+        }
+        else if (nTotalRG > names->num_rg) {
+            Atom *prev_radio_groups = names->radio_groups;
+
+            names->radio_groups = realloc(names->radio_groups,
+                                          nTotalRG * sizeof(Atom));
+            if (names->radio_groups != NULL) {
+                memset(&names->radio_groups[names->num_rg], 0,
+                       (nTotalRG - names->num_rg) * sizeof(Atom));
+            }
+            else {
+                free(prev_radio_groups);
+            }
+        }
+        if (names->radio_groups == NULL)
+            return BadAlloc;
+        names->num_rg = nTotalRG;
     }
     return Success;
 }
 
 void
-XkbFreeNames(XkbDescPtr xkb,unsigned which,Bool freeMap)
+XkbFreeNames(XkbDescPtr xkb, unsigned which, Bool freeMap)
 {
-XkbNamesPtr	names;
+    XkbNamesPtr names;
 
-    if ((xkb==NULL)||(xkb->names==NULL))
-	return;
-    names= xkb->names;
+    if ((xkb == NULL) || (xkb->names == NULL))
+        return;
+    names = xkb->names;
     if (freeMap)
-	which= XkbAllNamesMask; 
-    if (which&XkbKTLevelNamesMask) {
-	XkbClientMapPtr	map= xkb->map;
-	if ((map!=NULL)&&(map->types!=NULL)) {
-	    register int 		i;
-	    register XkbKeyTypePtr	type;
-	    type= map->types;
-	    for (i=0;i<map->num_types;i++,type++) {
-		free(type->level_names);
-		type->level_names = NULL;
-	    }
-	}
+        which = XkbAllNamesMask;
+    if (which & XkbKTLevelNamesMask) {
+        XkbClientMapPtr map = xkb->map;
+
+        if ((map != NULL) && (map->types != NULL)) {
+            register int i;
+            register XkbKeyTypePtr type;
+
+            type = map->types;
+            for (i = 0; i < map->num_types; i++, type++) {
+                free(type->level_names);
+                type->level_names = NULL;
+            }
+        }
     }
-    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
-	free(names->keys);
-	names->keys= NULL;
-	names->num_keys= 0;
+    if ((which & XkbKeyNamesMask) && (names->keys != NULL)) {
+        free(names->keys);
+        names->keys = NULL;
+        names->num_keys = 0;
     }
-    if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
-	free(names->key_aliases);
-	names->key_aliases=NULL;
-	names->num_key_aliases=0;
+    if ((which & XkbKeyAliasesMask) && (names->key_aliases)) {
+        free(names->key_aliases);
+        names->key_aliases = NULL;
+        names->num_key_aliases = 0;
     }
-    if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
-	free(names->radio_groups);
-	names->radio_groups= NULL;
-	names->num_rg= 0;
+    if ((which & XkbRGNamesMask) && (names->radio_groups)) {
+        free(names->radio_groups);
+        names->radio_groups = NULL;
+        names->num_rg = 0;
     }
     if (freeMap) {
-	free(names);
-	xkb->names= NULL;
+        free(names);
+        xkb->names = NULL;
     }
     return;
 }
 
 /***===================================================================***/
 
-/*ARGSUSED*/
-Status
-XkbAllocControls(XkbDescPtr xkb,unsigned which)
+ /*ARGSUSED*/ Status
+XkbAllocControls(XkbDescPtr xkb, unsigned which)
 {
-    if (xkb==NULL)
-	return BadMatch;
+    if (xkb == NULL)
+        return BadMatch;
 
-    if (xkb->ctrls==NULL) {
-	xkb->ctrls= calloc(1, sizeof(XkbControlsRec));
-	if (!xkb->ctrls)
-	    return BadAlloc;
+    if (xkb->ctrls == NULL) {
+        xkb->ctrls = calloc(1, sizeof(XkbControlsRec));
+        if (!xkb->ctrls)
+            return BadAlloc;
     }
     return Success;
 }
 
-/*ARGSUSED*/
-static void
-XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
+ /*ARGSUSED*/ static void
+XkbFreeControls(XkbDescPtr xkb, unsigned which, Bool freeMap)
 {
-    if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
-	free(xkb->ctrls);
-	xkb->ctrls= NULL;
+    if (freeMap && (xkb != NULL) && (xkb->ctrls != NULL)) {
+        free(xkb->ctrls);
+        xkb->ctrls = NULL;
     }
     return;
 }
@@ -272,12 +278,12 @@ XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
 Status
 XkbAllocIndicatorMaps(XkbDescPtr xkb)
 {
-    if (xkb==NULL)
-	return BadMatch;
-    if (xkb->indicators==NULL) {
-	xkb->indicators= calloc(1, sizeof(XkbIndicatorRec));
-	if (!xkb->indicators)
-	    return BadAlloc;
+    if (xkb == NULL)
+        return BadMatch;
+    if (xkb->indicators == NULL) {
+        xkb->indicators = calloc(1, sizeof(XkbIndicatorRec));
+        if (!xkb->indicators)
+            return BadAlloc;
     }
     return Success;
 }
@@ -285,63 +291,61 @@ XkbAllocIndicatorMaps(XkbDescPtr xkb)
 static void
 XkbFreeIndicatorMaps(XkbDescPtr xkb)
 {
-    if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
-	free(xkb->indicators);
-	xkb->indicators= NULL;
+    if ((xkb != NULL) && (xkb->indicators != NULL)) {
+        free(xkb->indicators);
+        xkb->indicators = NULL;
     }
     return;
 }
 
 /***====================================================================***/
 
-XkbDescRec	*
+XkbDescRec *
 XkbAllocKeyboard(void)
 {
-XkbDescRec *xkb;
+    XkbDescRec *xkb;
 
     xkb = calloc(1, sizeof(XkbDescRec));
     if (xkb)
-	xkb->device_spec= XkbUseCoreKbd;
+        xkb->device_spec = XkbUseCoreKbd;
     return xkb;
 }
 
 void
-XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)
+XkbFreeKeyboard(XkbDescPtr xkb, unsigned which, Bool freeAll)
 {
-    if (xkb==NULL)
-	return;
+    if (xkb == NULL)
+        return;
     if (freeAll)
-	which= XkbAllComponentsMask;
-    if (which&XkbClientMapMask)
-	XkbFreeClientMap(xkb,XkbAllClientInfoMask,TRUE);
-    if (which&XkbServerMapMask)
-	XkbFreeServerMap(xkb,XkbAllServerInfoMask,TRUE);
-    if (which&XkbCompatMapMask)
-	XkbFreeCompatMap(xkb,XkbAllCompatMask,TRUE);
-    if (which&XkbIndicatorMapMask)
-	XkbFreeIndicatorMaps(xkb);
-    if (which&XkbNamesMask)
-	XkbFreeNames(xkb,XkbAllNamesMask,TRUE);
-    if ((which&XkbGeometryMask) && (xkb->geom!=NULL)) {
-	XkbFreeGeometry(xkb->geom,XkbGeomAllMask,TRUE);
+        which = XkbAllComponentsMask;
+    if (which & XkbClientMapMask)
+        XkbFreeClientMap(xkb, XkbAllClientInfoMask, TRUE);
+    if (which & XkbServerMapMask)
+        XkbFreeServerMap(xkb, XkbAllServerInfoMask, TRUE);
+    if (which & XkbCompatMapMask)
+        XkbFreeCompatMap(xkb, XkbAllCompatMask, TRUE);
+    if (which & XkbIndicatorMapMask)
+        XkbFreeIndicatorMaps(xkb);
+    if (which & XkbNamesMask)
+        XkbFreeNames(xkb, XkbAllNamesMask, TRUE);
+    if ((which & XkbGeometryMask) && (xkb->geom != NULL)) {
+        XkbFreeGeometry(xkb->geom, XkbGeomAllMask, TRUE);
         /* PERHAPS BONGHITS etc */
         xkb->geom = NULL;
     }
-    if (which&XkbControlsMask)
-	XkbFreeControls(xkb,XkbAllControlsMask,TRUE);
+    if (which & XkbControlsMask)
+        XkbFreeControls(xkb, XkbAllControlsMask, TRUE);
     if (freeAll)
-	free(xkb);
+        free(xkb);
     return;
 }
 
-
 /***====================================================================***/
 
 void
 XkbFreeComponentNames(XkbComponentNamesPtr names, Bool freeNames)
 {
-    if (names)
-    {
+    if (names) {
         free(names->keycodes);
         free(names->types);
         free(names->compat);
diff --git a/xorg-server/xkb/XKBGAlloc.c b/xorg-server/xkb/XKBGAlloc.c
index dd2b04696..f7e017682 100644
--- a/xorg-server/xkb/XKBGAlloc.c
+++ b/xorg-server/xkb/XKBGAlloc.c
@@ -28,7 +28,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <dix-config.h>
 #endif
 
-
 #include <stdio.h>
 #include <X11/X.h>
 #include <X11/Xproto.h>
@@ -39,89 +38,88 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 /***====================================================================***/
 
-static void 
-_XkbFreeGeomLeafElems(	Bool			freeAll,
-			int			first,
-			int 			count,
-			unsigned short *	num_inout,
-			unsigned short *	sz_inout,
-			char **			elems,
-			unsigned int		elem_sz)
+static void
+_XkbFreeGeomLeafElems(Bool freeAll,
+                      int first,
+                      int count,
+                      unsigned short *num_inout,
+                      unsigned short *sz_inout,
+                      char **elems, unsigned int elem_sz)
 {
-    if ((freeAll)||(*elems==NULL)) {
-	*num_inout= *sz_inout= 0;
-	free(*elems);
-	*elems = NULL;
-	return;
+    if ((freeAll) || (*elems == NULL)) {
+        *num_inout = *sz_inout = 0;
+        free(*elems);
+        *elems = NULL;
+        return;
     }
 
-    if ((first>=(*num_inout))||(first<0)||(count<1))
-	return;
+    if ((first >= (*num_inout)) || (first < 0) || (count < 1))
+        return;
 
-    if (first+count>=(*num_inout)) { 
-	/* truncating the array is easy */
-	(*num_inout)= first;
+    if (first + count >= (*num_inout)) {
+        /* truncating the array is easy */
+        (*num_inout) = first;
     }
     else {
-	char *	ptr;
-	int 	extra;
-	ptr= *elems;
-	extra= ((*num_inout)-(first+count))*elem_sz;
-	if (extra>0)
-	    memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],extra);
-	(*num_inout)-= count;
+        char *ptr;
+        int extra;
+
+        ptr = *elems;
+        extra = ((*num_inout) - (first + count)) * elem_sz;
+        if (extra > 0)
+            memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz],
+                    extra);
+        (*num_inout) -= count;
     }
     return;
 }
 
-typedef void (*ContentsClearFunc)(
-		char *		/* priv */
-);
+typedef void (*ContentsClearFunc) (char *       /* priv */
+    );
 
-static void 
-_XkbFreeGeomNonLeafElems(	Bool			freeAll,
-				int			first,
-				int 			count,
-				unsigned short *	num_inout,
-				unsigned short *	sz_inout,
-				char **			elems,
-				unsigned int		elem_sz,
-				ContentsClearFunc	freeFunc)
+static void
+_XkbFreeGeomNonLeafElems(Bool freeAll,
+                         int first,
+                         int count,
+                         unsigned short *num_inout,
+                         unsigned short *sz_inout,
+                         char **elems,
+                         unsigned int elem_sz, ContentsClearFunc freeFunc)
 {
-register int i;
-register char *ptr;
+    register int i;
+    register char *ptr;
 
     if (freeAll) {
-	first= 0;
-	count= (*num_inout);
+        first = 0;
+        count = (*num_inout);
     }
-    else if ((first>=(*num_inout))||(first<0)||(count<1))
-	return;
-    else if (first+count>(*num_inout))
-	count= (*num_inout)-first;
-    if (*elems==NULL)
-	return;
+    else if ((first >= (*num_inout)) || (first < 0) || (count < 1))
+        return;
+    else if (first + count > (*num_inout))
+        count = (*num_inout) - first;
+    if (*elems == NULL)
+        return;
 
     if (freeFunc) {
-	ptr= *elems;
-	ptr+= first*elem_sz;
-	for (i=0;i<count;i++) {
-	    (*freeFunc)(ptr);
-	    ptr+= elem_sz;
-	}
+        ptr = *elems;
+        ptr += first * elem_sz;
+        for (i = 0; i < count; i++) {
+            (*freeFunc) (ptr);
+            ptr += elem_sz;
+        }
     }
     if (freeAll) {
-	(*num_inout)= (*sz_inout)= 0;
-	free(*elems);
-	*elems = NULL;
+        (*num_inout) = (*sz_inout) = 0;
+        free(*elems);
+        *elems = NULL;
     }
-    else if (first+count>=(*num_inout))
-	*num_inout= first;
+    else if (first + count >= (*num_inout))
+        *num_inout = first;
     else {
-	i= ((*num_inout)-(first+count))*elem_sz;
-	ptr= *elems;
-	memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],i);
-	(*num_inout)-= count;
+        i = ((*num_inout) - (first + count)) * elem_sz;
+        ptr = *elems;
+        memmove(&ptr[first * elem_sz], &ptr[(first + count) * elem_sz], i);
+        (*num_inout) -= count;
     }
     return;
 }
@@ -131,7 +129,7 @@ register char *ptr;
 static void
 _XkbClearProperty(char *prop_in)
 {
-XkbPropertyPtr	prop= (XkbPropertyPtr)prop_in;
+    XkbPropertyPtr prop = (XkbPropertyPtr) prop_in;
 
     free(prop->name);
     prop->name = NULL;
@@ -141,30 +139,23 @@ XkbPropertyPtr	prop= (XkbPropertyPtr)prop_in;
 }
 
 void
-XkbFreeGeomProperties(	XkbGeometryPtr	geom,
-			int		first,
-			int		count,
-			Bool		freeAll)
-{
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_properties,&geom->sz_properties,
-				(char **)&geom->properties,
-				sizeof(XkbPropertyRec),_XkbClearProperty);
+XkbFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+{
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_properties, &geom->sz_properties,
+                             (char **) &geom->properties,
+                             sizeof(XkbPropertyRec), _XkbClearProperty);
     return;
 }
 
 /***====================================================================***/
 
 void
-XkbFreeGeomKeyAliases(	XkbGeometryPtr	geom,
-			int		first,
-			int		count,
-			Bool		freeAll)
-{	
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&geom->num_key_aliases,&geom->sz_key_aliases,
-				(char **)&geom->key_aliases,
-				sizeof(XkbKeyAliasRec));
+XkbFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+{
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &geom->num_key_aliases, &geom->sz_key_aliases,
+                          (char **) &geom->key_aliases, sizeof(XkbKeyAliasRec));
     return;
 }
 
@@ -173,31 +164,30 @@ XkbFreeGeomKeyAliases(	XkbGeometryPtr	geom,
 static void
 _XkbClearColor(char *color_in)
 {
-XkbColorPtr	color= (XkbColorPtr)color_in;
+    XkbColorPtr color = (XkbColorPtr) color_in;
 
     free(color->spec);
     return;
 }
 
 void
-XkbFreeGeomColors(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_colors,&geom->sz_colors,
-				(char **)&geom->colors,
-				sizeof(XkbColorRec),_XkbClearColor);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_colors, &geom->sz_colors,
+                             (char **) &geom->colors,
+                             sizeof(XkbColorRec), _XkbClearColor);
     return;
 }
 
 /***====================================================================***/
 
 void
-XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
+XkbFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&outline->num_points,&outline->sz_points,
-				(char **)&outline->points,
-				sizeof(XkbPointRec));
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &outline->num_points, &outline->sz_points,
+                          (char **) &outline->points, sizeof(XkbPointRec));
     return;
 }
 
@@ -206,21 +196,21 @@ XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
 static void
 _XkbClearOutline(char *outline_in)
 {
-XkbOutlinePtr	outline= (XkbOutlinePtr)outline_in;
+    XkbOutlinePtr outline = (XkbOutlinePtr) outline_in;
 
-    if (outline->points!=NULL)
-	XkbFreeGeomPoints(outline,0,outline->num_points,TRUE);
+    if (outline->points != NULL)
+        XkbFreeGeomPoints(outline, 0, outline->num_points, TRUE);
     return;
 }
 
 void
-XkbFreeGeomOutlines(XkbShapePtr	shape,int first,int count,Bool freeAll)
+XkbFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&shape->num_outlines,&shape->sz_outlines,
-				(char **)&shape->outlines,
-				sizeof(XkbOutlineRec),_XkbClearOutline);
-	
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &shape->num_outlines, &shape->sz_outlines,
+                             (char **) &shape->outlines,
+                             sizeof(XkbOutlineRec), _XkbClearOutline);
+
     return;
 }
 
@@ -229,32 +219,31 @@ XkbFreeGeomOutlines(XkbShapePtr	shape,int first,int count,Bool freeAll)
 static void
 _XkbClearShape(char *shape_in)
 {
-XkbShapePtr	shape= (XkbShapePtr)shape_in;
+    XkbShapePtr shape = (XkbShapePtr) shape_in;
 
     if (shape->outlines)
-	XkbFreeGeomOutlines(shape,0,shape->num_outlines,TRUE);
+        XkbFreeGeomOutlines(shape, 0, shape->num_outlines, TRUE);
     return;
 }
 
 void
-XkbFreeGeomShapes(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_shapes,&geom->sz_shapes,
-				(char **)&geom->shapes,
-				sizeof(XkbShapeRec),_XkbClearShape);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_shapes, &geom->sz_shapes,
+                             (char **) &geom->shapes,
+                             sizeof(XkbShapeRec), _XkbClearShape);
     return;
 }
 
 /***====================================================================***/
 
-void 
-XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
+void
+XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&row->num_keys,&row->sz_keys,
-				(char **)&row->keys,
-				sizeof(XkbOverlayKeyRec));
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &row->num_keys, &row->sz_keys,
+                          (char **) &row->keys, sizeof(XkbOverlayKeyRec));
     return;
 }
 
@@ -263,20 +252,21 @@ XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
 static void
 _XkbClearOverlayRow(char *row_in)
 {
-XkbOverlayRowPtr	row= (XkbOverlayRowPtr)row_in;
+    XkbOverlayRowPtr row = (XkbOverlayRowPtr) row_in;
 
-    if (row->keys!=NULL)
-	XkbFreeGeomOverlayKeys(row,0,row->num_keys,TRUE);
+    if (row->keys != NULL)
+        XkbFreeGeomOverlayKeys(row, 0, row->num_keys, TRUE);
     return;
 }
 
 void
-XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
+XkbFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count,
+                       Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&overlay->num_rows,&overlay->sz_rows,
-				(char **)&overlay->rows,
-				sizeof(XkbOverlayRowRec),_XkbClearOverlayRow);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &overlay->num_rows, &overlay->sz_rows,
+                             (char **) &overlay->rows,
+                             sizeof(XkbOverlayRowRec), _XkbClearOverlayRow);
     return;
 }
 
@@ -285,32 +275,31 @@ XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
 static void
 _XkbClearOverlay(char *overlay_in)
 {
-XkbOverlayPtr	overlay= (XkbOverlayPtr)overlay_in;
+    XkbOverlayPtr overlay = (XkbOverlayPtr) overlay_in;
 
-    if (overlay->rows!=NULL)
-	XkbFreeGeomOverlayRows(overlay,0,overlay->num_rows,TRUE);
+    if (overlay->rows != NULL)
+        XkbFreeGeomOverlayRows(overlay, 0, overlay->num_rows, TRUE);
     return;
 }
 
 void
-XkbFreeGeomOverlays(XkbSectionPtr section,int first,int	count,Bool freeAll)
+XkbFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&section->num_overlays,&section->sz_overlays,
-				(char **)&section->overlays,
-				sizeof(XkbOverlayRec),_XkbClearOverlay);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &section->num_overlays, &section->sz_overlays,
+                             (char **) &section->overlays,
+                             sizeof(XkbOverlayRec), _XkbClearOverlay);
     return;
 }
 
 /***====================================================================***/
 
 void
-XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
+XkbFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&row->num_keys,&row->sz_keys,
-				(char **)&row->keys,
-				sizeof(XkbKeyRec));
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &row->num_keys, &row->sz_keys,
+                          (char **) &row->keys, sizeof(XkbKeyRec));
     return;
 }
 
@@ -319,20 +308,20 @@ XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
 static void
 _XkbClearRow(char *row_in)
 {
-XkbRowPtr	row= (XkbRowPtr)row_in;
+    XkbRowPtr row = (XkbRowPtr) row_in;
 
-    if (row->keys!=NULL)
-	XkbFreeGeomKeys(row,0,row->num_keys,TRUE);
+    if (row->keys != NULL)
+        XkbFreeGeomKeys(row, 0, row->num_keys, TRUE);
     return;
 }
 
 void
-XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
+XkbFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&section->num_rows,&section->sz_rows,
-				(char **)&section->rows,
-				sizeof(XkbRowRec),_XkbClearRow);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &section->num_rows, &section->sz_rows,
+                             (char **) &section->rows,
+                             sizeof(XkbRowRec), _XkbClearRow);
 }
 
 /***====================================================================***/
@@ -340,24 +329,24 @@ XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
 static void
 _XkbClearSection(char *section_in)
 {
-XkbSectionPtr	section= (XkbSectionPtr)section_in;
+    XkbSectionPtr section = (XkbSectionPtr) section_in;
 
-    if (section->rows!=NULL)
-	XkbFreeGeomRows(section,0,section->num_rows,TRUE);
-    if (section->doodads!=NULL) {
-	XkbFreeGeomDoodads(section->doodads,section->num_doodads,TRUE);
-	section->doodads= NULL;
+    if (section->rows != NULL)
+        XkbFreeGeomRows(section, 0, section->num_rows, TRUE);
+    if (section->doodads != NULL) {
+        XkbFreeGeomDoodads(section->doodads, section->num_doodads, TRUE);
+        section->doodads = NULL;
     }
     return;
 }
 
 void
-XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_sections,&geom->sz_sections,
-				(char **)&geom->sections,
-				sizeof(XkbSectionRec),_XkbClearSection);
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_sections, &geom->sz_sections,
+                             (char **) &geom->sections,
+                             sizeof(XkbSectionRec), _XkbClearSection);
     return;
 }
 
@@ -366,69 +355,69 @@ XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
 static void
 _XkbClearDoodad(char *doodad_in)
 {
-XkbDoodadPtr	doodad= (XkbDoodadPtr)doodad_in;
+    XkbDoodadPtr doodad = (XkbDoodadPtr) doodad_in;
 
     switch (doodad->any.type) {
-   	case XkbTextDoodad: 
-	    {
-		free(doodad->text.text);
-		doodad->text.text = NULL;
-		free(doodad->text.font);
-		doodad->text.font = NULL;
-	    }
-	    break;
-   	case XkbLogoDoodad: 
-	    {
-		free(doodad->logo.logo_name);
-		doodad->logo.logo_name = NULL;
-	    }
-	    break;
+    case XkbTextDoodad:
+    {
+        free(doodad->text.text);
+        doodad->text.text = NULL;
+        free(doodad->text.font);
+        doodad->text.font = NULL;
+    }
+        break;
+    case XkbLogoDoodad:
+    {
+        free(doodad->logo.logo_name);
+        doodad->logo.logo_name = NULL;
+    }
+        break;
     }
     return;
 }
 
 void
-XkbFreeGeomDoodads(XkbDoodadPtr doodads,int nDoodads,Bool freeAll)
+XkbFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
 {
-register int 		i;
-register XkbDoodadPtr	doodad;
+    register int i;
+    register XkbDoodadPtr doodad;
 
     if (doodads) {
-	for (i=0,doodad= doodads;i<nDoodads;i++,doodad++) {
-	    _XkbClearDoodad((char *)doodad);
-	}
-	if (freeAll)
-	    free(doodads);
+        for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++) {
+            _XkbClearDoodad((char *) doodad);
+        }
+        if (freeAll)
+            free(doodads);
     }
     return;
 }
 
 void
-XkbFreeGeometry(XkbGeometryPtr geom,unsigned which,Bool freeMap)
+XkbFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
 {
-    if (geom==NULL)
-	return;
+    if (geom == NULL)
+        return;
     if (freeMap)
-	which= XkbGeomAllMask;
-    if ((which&XkbGeomPropertiesMask)&&(geom->properties!=NULL))
-	XkbFreeGeomProperties(geom,0,geom->num_properties,TRUE);
-    if ((which&XkbGeomColorsMask)&&(geom->colors!=NULL))
-	XkbFreeGeomColors(geom,0,geom->num_colors,TRUE);
-    if ((which&XkbGeomShapesMask)&&(geom->shapes!=NULL))
-	XkbFreeGeomShapes(geom,0,geom->num_shapes,TRUE);
-    if ((which&XkbGeomSectionsMask)&&(geom->sections!=NULL))
-	XkbFreeGeomSections(geom,0,geom->num_sections,TRUE);
-    if ((which&XkbGeomDoodadsMask)&&(geom->doodads!= NULL)) {
-	XkbFreeGeomDoodads(geom->doodads,geom->num_doodads,TRUE);
-	geom->doodads= NULL;
-	geom->num_doodads= geom->sz_doodads= 0;
-    }
-    if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL))
-	XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,TRUE);
+        which = XkbGeomAllMask;
+    if ((which & XkbGeomPropertiesMask) && (geom->properties != NULL))
+        XkbFreeGeomProperties(geom, 0, geom->num_properties, TRUE);
+    if ((which & XkbGeomColorsMask) && (geom->colors != NULL))
+        XkbFreeGeomColors(geom, 0, geom->num_colors, TRUE);
+    if ((which & XkbGeomShapesMask) && (geom->shapes != NULL))
+        XkbFreeGeomShapes(geom, 0, geom->num_shapes, TRUE);
+    if ((which & XkbGeomSectionsMask) && (geom->sections != NULL))
+        XkbFreeGeomSections(geom, 0, geom->num_sections, TRUE);
+    if ((which & XkbGeomDoodadsMask) && (geom->doodads != NULL)) {
+        XkbFreeGeomDoodads(geom->doodads, geom->num_doodads, TRUE);
+        geom->doodads = NULL;
+        geom->num_doodads = geom->sz_doodads = 0;
+    }
+    if ((which & XkbGeomKeyAliasesMask) && (geom->key_aliases != NULL))
+        XkbFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, TRUE);
     if (freeMap) {
-	free(geom->label_font);
-	geom->label_font = NULL;
-	free(geom);
+        free(geom->label_font);
+        geom->label_font = NULL;
+        free(geom);
     }
     return;
 }
@@ -456,6 +445,7 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
 {
     void *items;
     int clearBegin;
+
     /* Check validity of arguments. */
     if (!buffer)
         return FALSE;
@@ -467,8 +457,7 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
         if (!(items = realloc(items, nrItems * itemSize)))
             return FALSE;
     /* Clear specified items to zero. */
-    switch (clearance)
-    {
+    switch (clearance) {
     case XKB_GEOM_CLEAR_EXCESS:
         clearBegin = szItems;
         break;
@@ -481,34 +470,32 @@ XkbGeomRealloc(void **buffer, int szItems, int nrItems,
         break;
     }
     if (items && (clearBegin < nrItems))
-        memset((char *)items + (clearBegin * itemSize), 0, (nrItems - clearBegin) * itemSize);
+        memset((char *) items + (clearBegin * itemSize), 0,
+               (nrItems - clearBegin) * itemSize);
     *buffer = items;
     return TRUE;
 }
 
 static Status
-_XkbGeomAlloc(	void **		old,
-		unsigned short *	num,
-		unsigned short *	total,
-		int			num_new,
-		size_t			sz_elem)
+_XkbGeomAlloc(void **old,
+              unsigned short *num,
+              unsigned short *total, int num_new, size_t sz_elem)
 {
-    if (num_new<1)
-	return Success;
-    if ((*old)==NULL)
-	*num= *total= 0;
+    if (num_new < 1)
+        return Success;
+    if ((*old) == NULL)
+        *num = *total = 0;
 
-    if ((*num)+num_new<=(*total))
-	return Success;
+    if ((*num) + num_new <= (*total))
+        return Success;
 
-    *total= (*num)+num_new;
+    *total = (*num) + num_new;
 
-    if (!XkbGeomRealloc(old, *num, *total, sz_elem, XKB_GEOM_CLEAR_EXCESS))
-    {
-	free(*old);
-	(*old)= NULL;
-	*total= *num= 0;
-	return BadAlloc;
+    if (!XkbGeomRealloc(old, *num, *total, sz_elem, XKB_GEOM_CLEAR_EXCESS)) {
+        free(*old);
+        (*old) = NULL;
+        *total = *num = 0;
+        return BadAlloc;
     }
 
     return Success;
@@ -554,265 +541,267 @@ _XkbGeomAlloc(	void **		old,
 #define	_XkbAllocOverlayKeys(r,n) _XkbGeomAlloc((void *)&(r)->keys,\
 				&(r)->num_keys,&(r)->sz_keys,\
 				(n),sizeof(XkbOverlayKeyRec))
-    
+
 Status
-XkbAllocGeomProps(XkbGeometryPtr geom,int nProps)
+XkbAllocGeomProps(XkbGeometryPtr geom, int nProps)
 {
-    return _XkbAllocProps(geom,nProps);
+    return _XkbAllocProps(geom, nProps);
 }
 
 Status
-XkbAllocGeomColors(XkbGeometryPtr geom,int nColors)
+XkbAllocGeomColors(XkbGeometryPtr geom, int nColors)
 {
-    return _XkbAllocColors(geom,nColors);
+    return _XkbAllocColors(geom, nColors);
 }
 
 Status
-XkbAllocGeomKeyAliases(XkbGeometryPtr geom,int nKeyAliases)
+XkbAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases)
 {
-    return _XkbAllocKeyAliases(geom,nKeyAliases);
+    return _XkbAllocKeyAliases(geom, nKeyAliases);
 }
 
 Status
-XkbAllocGeomShapes(XkbGeometryPtr geom,int nShapes)
+XkbAllocGeomShapes(XkbGeometryPtr geom, int nShapes)
 {
-    return _XkbAllocShapes(geom,nShapes);
+    return _XkbAllocShapes(geom, nShapes);
 }
 
 Status
-XkbAllocGeomSections(XkbGeometryPtr geom,int nSections)
+XkbAllocGeomSections(XkbGeometryPtr geom, int nSections)
 {
-    return _XkbAllocSections(geom,nSections);
+    return _XkbAllocSections(geom, nSections);
 }
 
 Status
-XkbAllocGeomOverlays(XkbSectionPtr section,int nOverlays)
+XkbAllocGeomOverlays(XkbSectionPtr section, int nOverlays)
 {
-    return _XkbAllocOverlays(section,nOverlays);
+    return _XkbAllocOverlays(section, nOverlays);
 }
 
 Status
-XkbAllocGeomOverlayRows(XkbOverlayPtr overlay,int nRows)
+XkbAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows)
 {
-    return _XkbAllocOverlayRows(overlay,nRows);
+    return _XkbAllocOverlayRows(overlay, nRows);
 }
 
 Status
-XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row,int nKeys)
+XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys)
 {
-    return _XkbAllocOverlayKeys(row,nKeys);
+    return _XkbAllocOverlayKeys(row, nKeys);
 }
 
 Status
-XkbAllocGeomDoodads(XkbGeometryPtr geom,int nDoodads)
+XkbAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads)
 {
-    return _XkbAllocDoodads(geom,nDoodads);
+    return _XkbAllocDoodads(geom, nDoodads);
 }
 
 Status
-XkbAllocGeomSectionDoodads(XkbSectionPtr section,int nDoodads)
+XkbAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads)
 {
-    return _XkbAllocDoodads(section,nDoodads);
+    return _XkbAllocDoodads(section, nDoodads);
 }
 
 Status
-XkbAllocGeomOutlines(XkbShapePtr shape,int nOL)
+XkbAllocGeomOutlines(XkbShapePtr shape, int nOL)
 {
-    return _XkbAllocOutlines(shape,nOL);
+    return _XkbAllocOutlines(shape, nOL);
 }
 
 Status
-XkbAllocGeomRows(XkbSectionPtr section,int nRows)
+XkbAllocGeomRows(XkbSectionPtr section, int nRows)
 {
-    return _XkbAllocRows(section,nRows);
+    return _XkbAllocRows(section, nRows);
 }
 
 Status
-XkbAllocGeomPoints(XkbOutlinePtr ol,int nPts)
+XkbAllocGeomPoints(XkbOutlinePtr ol, int nPts)
 {
-    return _XkbAllocPoints(ol,nPts);
+    return _XkbAllocPoints(ol, nPts);
 }
 
 Status
-XkbAllocGeomKeys(XkbRowPtr row,int nKeys)
+XkbAllocGeomKeys(XkbRowPtr row, int nKeys)
 {
-    return _XkbAllocKeys(row,nKeys);
+    return _XkbAllocKeys(row, nKeys);
 }
 
 Status
-XkbAllocGeometry(XkbDescPtr xkb,XkbGeometrySizesPtr sizes)
+XkbAllocGeometry(XkbDescPtr xkb, XkbGeometrySizesPtr sizes)
 {
-XkbGeometryPtr	geom;
-Status		rtrn;
+    XkbGeometryPtr geom;
+    Status rtrn;
 
-    if (xkb->geom==NULL) {
-	xkb->geom= calloc(1, sizeof(XkbGeometryRec));
-	if (!xkb->geom)
-	    return BadAlloc;
+    if (xkb->geom == NULL) {
+        xkb->geom = calloc(1, sizeof(XkbGeometryRec));
+        if (!xkb->geom)
+            return BadAlloc;
     }
-    geom= xkb->geom;
-    if ((sizes->which&XkbGeomPropertiesMask)&&
-	((rtrn=_XkbAllocProps(geom,sizes->num_properties))!=Success)) {
-	goto BAIL;
+    geom = xkb->geom;
+    if ((sizes->which & XkbGeomPropertiesMask) &&
+        ((rtrn = _XkbAllocProps(geom, sizes->num_properties)) != Success)) {
+        goto BAIL;
     }
-    if ((sizes->which&XkbGeomColorsMask)&&
-	((rtrn=_XkbAllocColors(geom,sizes->num_colors))!=Success)) {
-	goto BAIL;
+    if ((sizes->which & XkbGeomColorsMask) &&
+        ((rtrn = _XkbAllocColors(geom, sizes->num_colors)) != Success)) {
+        goto BAIL;
     }
-    if ((sizes->which&XkbGeomShapesMask)&&
-	((rtrn=_XkbAllocShapes(geom,sizes->num_shapes))!=Success)) {
-	goto BAIL;
+    if ((sizes->which & XkbGeomShapesMask) &&
+        ((rtrn = _XkbAllocShapes(geom, sizes->num_shapes)) != Success)) {
+        goto BAIL;
     }
-    if ((sizes->which&XkbGeomSectionsMask)&&
-	((rtrn=_XkbAllocSections(geom,sizes->num_sections))!=Success)) {
-	goto BAIL;
+    if ((sizes->which & XkbGeomSectionsMask) &&
+        ((rtrn = _XkbAllocSections(geom, sizes->num_sections)) != Success)) {
+        goto BAIL;
     }
-    if ((sizes->which&XkbGeomDoodadsMask)&&
-	((rtrn=_XkbAllocDoodads(geom,sizes->num_doodads))!=Success)) {
-	goto BAIL;
+    if ((sizes->which & XkbGeomDoodadsMask) &&
+        ((rtrn = _XkbAllocDoodads(geom, sizes->num_doodads)) != Success)) {
+        goto BAIL;
     }
-    if ((sizes->which&XkbGeomKeyAliasesMask)&&
-	((rtrn=_XkbAllocKeyAliases(geom,sizes->num_key_aliases))!=Success)) {
-	goto BAIL;
+    if ((sizes->which & XkbGeomKeyAliasesMask) &&
+        ((rtrn =
+          _XkbAllocKeyAliases(geom, sizes->num_key_aliases)) != Success)) {
+        goto BAIL;
     }
     return Success;
-BAIL:
-    XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
-    xkb->geom= NULL;
+ BAIL:
+    XkbFreeGeometry(geom, XkbGeomAllMask, TRUE);
+    xkb->geom = NULL;
     return rtrn;
 }
 
 /***====================================================================***/
 
 XkbPropertyPtr
-XkbAddGeomProperty(XkbGeometryPtr geom,char *name,char *value)
-{
-register int i;
-register XkbPropertyPtr prop;
-
-    if ((!geom)||(!name)||(!value))
-	return NULL;
-    for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
-	if ((prop->name)&&(strcmp(name,prop->name)==0)) {
-	    free(prop->value);
-	    prop->value= strdup(value);
-	    return prop;
-	}    
-    }
-    if ((geom->num_properties>=geom->sz_properties)&&
-					(_XkbAllocProps(geom,1)!=Success)) {
-	return NULL;
-    }
-    prop= &geom->properties[geom->num_properties];
-    prop->name= strdup(name);
+XkbAddGeomProperty(XkbGeometryPtr geom, char *name, char *value)
+{
+    register int i;
+    register XkbPropertyPtr prop;
+
+    if ((!geom) || (!name) || (!value))
+        return NULL;
+    for (i = 0, prop = geom->properties; i < geom->num_properties; i++, prop++) {
+        if ((prop->name) && (strcmp(name, prop->name) == 0)) {
+            free(prop->value);
+            prop->value = strdup(value);
+            return prop;
+        }
+    }
+    if ((geom->num_properties >= geom->sz_properties) &&
+        (_XkbAllocProps(geom, 1) != Success)) {
+        return NULL;
+    }
+    prop = &geom->properties[geom->num_properties];
+    prop->name = strdup(name);
     if (!prop->name)
-	return NULL;
-    prop->value= strdup(value);
+        return NULL;
+    prop->value = strdup(value);
     if (!prop->value) {
-	free(prop->name);
-	prop->name= NULL;
-	return NULL;
+        free(prop->name);
+        prop->name = NULL;
+        return NULL;
     }
     geom->num_properties++;
     return prop;
 }
 
 XkbKeyAliasPtr
-XkbAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr)
-{
-register int i;
-register XkbKeyAliasPtr alias;
-
-    if ((!geom)||(!aliasStr)||(!realStr)||(!aliasStr[0])||(!realStr[0]))
-	return NULL;
-    for (i=0,alias=geom->key_aliases;i<geom->num_key_aliases;i++,alias++) {
-	if (strncmp(alias->alias,aliasStr,XkbKeyNameLength)==0) {
-	    memset(alias->real, 0, XkbKeyNameLength);
-	    strncpy(alias->real,realStr,XkbKeyNameLength);
-	    return alias;
-	}
-    }
-    if ((geom->num_key_aliases>=geom->sz_key_aliases)&&
-				(_XkbAllocKeyAliases(geom,1)!=Success)) {
-	return NULL;
-    }
-    alias= &geom->key_aliases[geom->num_key_aliases];
+XkbAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr)
+{
+    register int i;
+    register XkbKeyAliasPtr alias;
+
+    if ((!geom) || (!aliasStr) || (!realStr) || (!aliasStr[0]) || (!realStr[0]))
+        return NULL;
+    for (i = 0, alias = geom->key_aliases; i < geom->num_key_aliases;
+         i++, alias++) {
+        if (strncmp(alias->alias, aliasStr, XkbKeyNameLength) == 0) {
+            memset(alias->real, 0, XkbKeyNameLength);
+            strncpy(alias->real, realStr, XkbKeyNameLength);
+            return alias;
+        }
+    }
+    if ((geom->num_key_aliases >= geom->sz_key_aliases) &&
+        (_XkbAllocKeyAliases(geom, 1) != Success)) {
+        return NULL;
+    }
+    alias = &geom->key_aliases[geom->num_key_aliases];
     memset(alias, 0, sizeof(XkbKeyAliasRec));
-    strncpy(alias->alias,aliasStr,XkbKeyNameLength);
-    strncpy(alias->real,realStr,XkbKeyNameLength);
+    strncpy(alias->alias, aliasStr, XkbKeyNameLength);
+    strncpy(alias->real, realStr, XkbKeyNameLength);
     geom->num_key_aliases++;
     return alias;
 }
 
 XkbColorPtr
-XkbAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel)
-{
-register int i;
-register XkbColorPtr color;
-
-    if ((!geom)||(!spec))
-	return NULL;
-    for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
-	if ((color->spec)&&(strcmp(color->spec,spec)==0)) {
-	    color->pixel= pixel;
-	    return color;
-	}
-    }
-    if ((geom->num_colors>=geom->sz_colors)&&
-					(_XkbAllocColors(geom,1)!=Success)) {
-	return NULL;
-    }
-    color= &geom->colors[geom->num_colors];
-    color->pixel= pixel;
-    color->spec= strdup(spec);
+XkbAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel)
+{
+    register int i;
+    register XkbColorPtr color;
+
+    if ((!geom) || (!spec))
+        return NULL;
+    for (i = 0, color = geom->colors; i < geom->num_colors; i++, color++) {
+        if ((color->spec) && (strcmp(color->spec, spec) == 0)) {
+            color->pixel = pixel;
+            return color;
+        }
+    }
+    if ((geom->num_colors >= geom->sz_colors) &&
+        (_XkbAllocColors(geom, 1) != Success)) {
+        return NULL;
+    }
+    color = &geom->colors[geom->num_colors];
+    color->pixel = pixel;
+    color->spec = strdup(spec);
     if (!color->spec)
-	return NULL;
+        return NULL;
     geom->num_colors++;
     return color;
 }
 
 XkbOutlinePtr
-XkbAddGeomOutline(XkbShapePtr shape,int sz_points)
+XkbAddGeomOutline(XkbShapePtr shape, int sz_points)
 {
-XkbOutlinePtr	outline;
+    XkbOutlinePtr outline;
 
-    if ((!shape)||(sz_points<0))
-	return NULL;
-    if ((shape->num_outlines>=shape->sz_outlines)&&
-					(_XkbAllocOutlines(shape,1)!=Success)) {
-	return NULL;
+    if ((!shape) || (sz_points < 0))
+        return NULL;
+    if ((shape->num_outlines >= shape->sz_outlines) &&
+        (_XkbAllocOutlines(shape, 1) != Success)) {
+        return NULL;
     }
-    outline= &shape->outlines[shape->num_outlines];
+    outline = &shape->outlines[shape->num_outlines];
     memset(outline, 0, sizeof(XkbOutlineRec));
-    if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success))
-	return NULL;
+    if ((sz_points > 0) && (_XkbAllocPoints(outline, sz_points) != Success))
+        return NULL;
     shape->num_outlines++;
     return outline;
 }
 
 XkbShapePtr
-XkbAddGeomShape(XkbGeometryPtr geom,Atom name,int sz_outlines)
-{
-XkbShapePtr	shape;
-register int	i;
-
-    if ((!geom)||(!name)||(sz_outlines<0))
-	return NULL;
-    if (geom->num_shapes>0) {
-	for (shape=geom->shapes,i=0;i<geom->num_shapes;i++,shape++) {
-	    if (name==shape->name)
-		return shape;
-	}
-    }
-    if ((geom->num_shapes>=geom->sz_shapes)&&
-					(_XkbAllocShapes(geom,1)!=Success))
-	return NULL;
-    shape= &geom->shapes[geom->num_shapes];
+XkbAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines)
+{
+    XkbShapePtr shape;
+    register int i;
+
+    if ((!geom) || (!name) || (sz_outlines < 0))
+        return NULL;
+    if (geom->num_shapes > 0) {
+        for (shape = geom->shapes, i = 0; i < geom->num_shapes; i++, shape++) {
+            if (name == shape->name)
+                return shape;
+        }
+    }
+    if ((geom->num_shapes >= geom->sz_shapes) &&
+        (_XkbAllocShapes(geom, 1) != Success))
+        return NULL;
+    shape = &geom->shapes[geom->num_shapes];
     memset(shape, 0, sizeof(XkbShapeRec));
-    if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success))
-	return NULL;
-    shape->name= name;
-    shape->primary= shape->approx= NULL;
+    if ((sz_outlines > 0) && (_XkbAllocOutlines(shape, sz_outlines) != Success))
+        return NULL;
+    shape->name = name;
+    shape->primary = shape->approx = NULL;
     geom->num_shapes++;
     return shape;
 }
@@ -820,203 +809,204 @@ register int	i;
 XkbKeyPtr
 XkbAddGeomKey(XkbRowPtr row)
 {
-XkbKeyPtr	key;
+    XkbKeyPtr key;
+
     if (!row)
-	return NULL;
-    if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success))
-	return NULL;
-    key= &row->keys[row->num_keys++];
+        return NULL;
+    if ((row->num_keys >= row->sz_keys) && (_XkbAllocKeys(row, 1) != Success))
+        return NULL;
+    key = &row->keys[row->num_keys++];
     memset(key, 0, sizeof(XkbKeyRec));
     return key;
 }
 
 XkbRowPtr
-XkbAddGeomRow(XkbSectionPtr section,int sz_keys)
+XkbAddGeomRow(XkbSectionPtr section, int sz_keys)
 {
-XkbRowPtr	row;
+    XkbRowPtr row;
 
-    if ((!section)||(sz_keys<0))
-	return NULL;
-    if ((section->num_rows>=section->sz_rows)&&
-    					(_XkbAllocRows(section,1)!=Success))
-	return NULL;
-    row= &section->rows[section->num_rows];
+    if ((!section) || (sz_keys < 0))
+        return NULL;
+    if ((section->num_rows >= section->sz_rows) &&
+        (_XkbAllocRows(section, 1) != Success))
+        return NULL;
+    row = &section->rows[section->num_rows];
     memset(row, 0, sizeof(XkbRowRec));
-    if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
-	return NULL;
+    if ((sz_keys > 0) && (_XkbAllocKeys(row, sz_keys) != Success))
+        return NULL;
     section->num_rows++;
     return row;
 }
 
 XkbSectionPtr
-XkbAddGeomSection(	XkbGeometryPtr	geom,
-			Atom		name,
-			int		sz_rows,
-			int		sz_doodads,
-			int		sz_over)
-{
-register int	i;
-XkbSectionPtr	section;
-
-    if ((!geom)||(name==None)||(sz_rows<0))
-	return NULL;
-    for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
-	if (section->name!=name)
-	    continue;
-	if (((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))||
-	    ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success))||
-	    ((sz_over>0)&&(_XkbAllocOverlays(section,sz_over)!=Success)))
-	    return NULL;
-	return section;
-    }
-    if ((geom->num_sections>=geom->sz_sections)&&
-					(_XkbAllocSections(geom,1)!=Success))
-	return NULL;
-    section= &geom->sections[geom->num_sections];
-    if ((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))
-	return NULL;
-    if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) {
-	if (section->rows) {
-	    free(section->rows);
-	    section->rows= NULL;
-	    section->sz_rows= section->num_rows= 0;
-	}
-	return NULL;
-    }
-    section->name= name;
+XkbAddGeomSection(XkbGeometryPtr geom,
+                  Atom name, int sz_rows, int sz_doodads, int sz_over)
+{
+    register int i;
+    XkbSectionPtr section;
+
+    if ((!geom) || (name == None) || (sz_rows < 0))
+        return NULL;
+    for (i = 0, section = geom->sections; i < geom->num_sections;
+         i++, section++) {
+        if (section->name != name)
+            continue;
+        if (((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success)) ||
+            ((sz_doodads > 0) &&
+             (_XkbAllocDoodads(section, sz_doodads) != Success)) ||
+            ((sz_over > 0) && (_XkbAllocOverlays(section, sz_over) != Success)))
+            return NULL;
+        return section;
+    }
+    if ((geom->num_sections >= geom->sz_sections) &&
+        (_XkbAllocSections(geom, 1) != Success))
+        return NULL;
+    section = &geom->sections[geom->num_sections];
+    if ((sz_rows > 0) && (_XkbAllocRows(section, sz_rows) != Success))
+        return NULL;
+    if ((sz_doodads > 0) && (_XkbAllocDoodads(section, sz_doodads) != Success)) {
+        if (section->rows) {
+            free(section->rows);
+            section->rows = NULL;
+            section->sz_rows = section->num_rows = 0;
+        }
+        return NULL;
+    }
+    section->name = name;
     geom->num_sections++;
     return section;
 }
 
 XkbDoodadPtr
-XkbAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name)
+XkbAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name)
 {
-XkbDoodadPtr	old,doodad;
-register int	i,nDoodads;
+    XkbDoodadPtr old, doodad;
+    register int i, nDoodads;
 
-    if ((!geom)||(name==None))
-	return NULL;
-    if ((section!=NULL)&&(section->num_doodads>0)) {
-	old= section->doodads;
-	nDoodads= section->num_doodads;
+    if ((!geom) || (name == None))
+        return NULL;
+    if ((section != NULL) && (section->num_doodads > 0)) {
+        old = section->doodads;
+        nDoodads = section->num_doodads;
     }
     else {
-	old= geom->doodads;
-	nDoodads= geom->num_doodads;
+        old = geom->doodads;
+        nDoodads = geom->num_doodads;
     }
-    for (i=0,doodad=old;i<nDoodads;i++,doodad++) {
-	if (doodad->any.name==name)
-	    return doodad;
+    for (i = 0, doodad = old; i < nDoodads; i++, doodad++) {
+        if (doodad->any.name == name)
+            return doodad;
     }
     if (section) {
-	if ((section->num_doodads>=geom->sz_doodads)&&
-	    (_XkbAllocDoodads(section,1)!=Success)) {
-	    return NULL;
-	}
-	doodad= &section->doodads[section->num_doodads++];
+        if ((section->num_doodads >= geom->sz_doodads) &&
+            (_XkbAllocDoodads(section, 1) != Success)) {
+            return NULL;
+        }
+        doodad = &section->doodads[section->num_doodads++];
     }
     else {
-	if ((geom->num_doodads>=geom->sz_doodads)&&
-					(_XkbAllocDoodads(geom,1)!=Success))
-	    return NULL;
-	doodad= &geom->doodads[geom->num_doodads++];
+        if ((geom->num_doodads >= geom->sz_doodads) &&
+            (_XkbAllocDoodads(geom, 1) != Success))
+            return NULL;
+        doodad = &geom->doodads[geom->num_doodads++];
     }
     memset(doodad, 0, sizeof(XkbDoodadRec));
-    doodad->any.name= name;
+    doodad->any.name = name;
     return doodad;
 }
 
 XkbOverlayKeyPtr
-XkbAddGeomOverlayKey(	XkbOverlayPtr		overlay,
-			XkbOverlayRowPtr 	row,
-			char *			over,
-			char *			under)
-{
-register int	i;
-XkbOverlayKeyPtr key;
-XkbSectionPtr	section;
-XkbRowPtr	row_under;
-Bool		found;
-
-    if ((!overlay)||(!row)||(!over)||(!under))
-	return NULL;
-    section= overlay->section_under;
-    if (row->row_under>=section->num_rows)
-	return NULL;
-    row_under= &section->rows[row->row_under];
-    for (i=0,found=FALSE;i<row_under->num_keys;i++) {
-	if (strncmp(under,row_under->keys[i].name.name,XkbKeyNameLength)==0) {
-	    found= TRUE;
-	    break;
-	}
+XkbAddGeomOverlayKey(XkbOverlayPtr overlay,
+                     XkbOverlayRowPtr row, char *over, char *under)
+{
+    register int i;
+    XkbOverlayKeyPtr key;
+    XkbSectionPtr section;
+    XkbRowPtr row_under;
+    Bool found;
+
+    if ((!overlay) || (!row) || (!over) || (!under))
+        return NULL;
+    section = overlay->section_under;
+    if (row->row_under >= section->num_rows)
+        return NULL;
+    row_under = &section->rows[row->row_under];
+    for (i = 0, found = FALSE; i < row_under->num_keys; i++) {
+        if (strncmp(under, row_under->keys[i].name.name, XkbKeyNameLength) == 0) {
+            found = TRUE;
+            break;
+        }
     }
     if (!found)
-   	return NULL; 
-    if ((row->num_keys>=row->sz_keys)&&(_XkbAllocOverlayKeys(row,1)!=Success))
-	return NULL;
-    key= &row->keys[row->num_keys];
-    strncpy(key->under.name,under,XkbKeyNameLength);
-    strncpy(key->over.name,over,XkbKeyNameLength);
+        return NULL;
+    if ((row->num_keys >= row->sz_keys) &&
+        (_XkbAllocOverlayKeys(row, 1) != Success))
+        return NULL;
+    key = &row->keys[row->num_keys];
+    strncpy(key->under.name, under, XkbKeyNameLength);
+    strncpy(key->over.name, over, XkbKeyNameLength);
     row->num_keys++;
     return key;
 }
 
 XkbOverlayRowPtr
-XkbAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys)
-{
-register int		i;
-XkbOverlayRowPtr	row;
-
-    if ((!overlay)||(sz_keys<0))
-	return NULL;
-    if (row_under>=overlay->section_under->num_rows)
-	return NULL;
-    for (i=0;i<overlay->num_rows;i++) {
-	if (overlay->rows[i].row_under==row_under) {
-	    row= &overlay->rows[i];
-	    if ((row->sz_keys<sz_keys)&&
-				(_XkbAllocOverlayKeys(row,sz_keys)!=Success)) {
-		return NULL;
-	    }
-	    return &overlay->rows[i];
-	}
-    }
-    if ((overlay->num_rows>=overlay->sz_rows)&&
-				(_XkbAllocOverlayRows(overlay,1)!=Success))
-	return NULL;
-    row= &overlay->rows[overlay->num_rows];
+XkbAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys)
+{
+    register int i;
+    XkbOverlayRowPtr row;
+
+    if ((!overlay) || (sz_keys < 0))
+        return NULL;
+    if (row_under >= overlay->section_under->num_rows)
+        return NULL;
+    for (i = 0; i < overlay->num_rows; i++) {
+        if (overlay->rows[i].row_under == row_under) {
+            row = &overlay->rows[i];
+            if ((row->sz_keys < sz_keys) &&
+                (_XkbAllocOverlayKeys(row, sz_keys) != Success)) {
+                return NULL;
+            }
+            return &overlay->rows[i];
+        }
+    }
+    if ((overlay->num_rows >= overlay->sz_rows) &&
+        (_XkbAllocOverlayRows(overlay, 1) != Success))
+        return NULL;
+    row = &overlay->rows[overlay->num_rows];
     memset(row, 0, sizeof(XkbOverlayRowRec));
-    if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
-	return NULL;
-    row->row_under= row_under;
+    if ((sz_keys > 0) && (_XkbAllocOverlayKeys(row, sz_keys) != Success))
+        return NULL;
+    row->row_under = row_under;
     overlay->num_rows++;
     return row;
 }
 
 XkbOverlayPtr
-XkbAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows)
-{
-register int	i;
-XkbOverlayPtr	overlay;
-
-    if ((!section)||(name==None)||(sz_rows==0))
-	return NULL;
-
-    for (i=0,overlay=section->overlays;i<section->num_overlays;i++,overlay++) {
-	if (overlay->name==name) {
-	    if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
-		return NULL;
-	    return overlay;
-	}
-    }
-    if ((section->num_overlays>=section->sz_overlays)&&
-				(_XkbAllocOverlays(section,1)!=Success))
-	return NULL;
-    overlay= &section->overlays[section->num_overlays];
-    if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
-	return NULL;
-    overlay->name= name;
-    overlay->section_under= section;
+XkbAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows)
+{
+    register int i;
+    XkbOverlayPtr overlay;
+
+    if ((!section) || (name == None) || (sz_rows == 0))
+        return NULL;
+
+    for (i = 0, overlay = section->overlays; i < section->num_overlays;
+         i++, overlay++) {
+        if (overlay->name == name) {
+            if ((sz_rows > 0) &&
+                (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
+                return NULL;
+            return overlay;
+        }
+    }
+    if ((section->num_overlays >= section->sz_overlays) &&
+        (_XkbAllocOverlays(section, 1) != Success))
+        return NULL;
+    overlay = &section->overlays[section->num_overlays];
+    if ((sz_rows > 0) && (_XkbAllocOverlayRows(overlay, sz_rows) != Success))
+        return NULL;
+    overlay->name = name;
+    overlay->section_under = section;
     section->num_overlays++;
     return overlay;
 }
diff --git a/xorg-server/xkb/XKBMAlloc.c b/xorg-server/xkb/XKBMAlloc.c
index ad13b940c..645e90544 100644
--- a/xorg-server/xkb/XKBMAlloc.c
+++ b/xorg-server/xkb/XKBMAlloc.c
@@ -1,879 +1,930 @@
-/************************************************************

-Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.

-

-Permission to use, copy, modify, and distribute this

-software and its documentation for any purpose and without

-fee is hereby granted, provided that the above copyright

-notice appear in all copies and that both that copyright

-notice and this permission notice appear in supporting

-documentation, and that the name of Silicon Graphics not be 

-used in advertising or publicity pertaining to distribution 

-of the software without specific prior written permission.

-Silicon Graphics makes no representation about the suitability 

-of this software for any purpose. It is provided "as is"

-without any express or implied warranty.

-

-SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 

-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 

-AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON

-GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 

-DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 

-DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 

-OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH

-THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

-********************************************************/

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#elif defined(HAVE_CONFIG_H)

-#include <config.h>

-#endif

-

-#include <stdio.h>

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "inputstr.h"

-#include <X11/keysym.h>

-#define	XKBSRV_NEED_FILE_FUNCS

-#include <xkbsrv.h>

-

-/***====================================================================***/

-

-Status

-XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)

-{

-register int	i;

-XkbClientMapPtr map;

-

-    if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))

-	return BadValue;

-    if ((which&XkbKeySymsMask)&&

-	((!XkbIsLegalKeycode(xkb->min_key_code))||

-	 (!XkbIsLegalKeycode(xkb->max_key_code))||

-	 (xkb->max_key_code<xkb->min_key_code))) {

-        DebugF("bad keycode (%d,%d) in XkbAllocClientMap\n",

-				xkb->min_key_code,xkb->max_key_code);

-	return BadValue;

-    }

-

-    if (xkb->map==NULL) {

-	map= calloc(1, sizeof(XkbClientMapRec));

-	if (map==NULL)

-	    return BadAlloc;

-	xkb->map= map;

-    }

-    else map= xkb->map;

-

-    if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {

-	if (map->types==NULL) {

-	    map->types= calloc(nTotalTypes, sizeof(XkbKeyTypeRec));

-	    if (map->types==NULL)

-		return BadAlloc;

-	    map->num_types= 0;

-	    map->size_types= nTotalTypes;

-	}

-	else if (map->size_types<nTotalTypes) {

-	    XkbKeyTypeRec *prev_types = map->types;

-

-	    map->types= realloc(map->types,nTotalTypes * sizeof(XkbKeyTypeRec));

-	    if (map->types==NULL) {

-		free(prev_types);

-		map->num_types= map->size_types= 0;

-		return BadAlloc;

-	    }

-	    map->size_types= nTotalTypes;

-	    memset(&map->types[map->num_types], 0,

-		  ((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));

-	}

-    }

-    if (which&XkbKeySymsMask) {

-	int nKeys= XkbNumKeys(xkb);

-	if (map->syms==NULL) {

-	    map->size_syms= (nKeys*15)/10;

-	    map->syms= calloc(map->size_syms, sizeof(KeySym));

-	    if (!map->syms) {

-		map->size_syms= 0;

-		return BadAlloc;

-	    }

-	    map->num_syms= 1;

-	    map->syms[0]= NoSymbol;

-	}

-	if (map->key_sym_map==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->key_sym_map= calloc(i, sizeof(XkbSymMapRec));

-	    if (map->key_sym_map==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbModifierMapMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->modmap==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->modmap= calloc(i, sizeof(unsigned char));

-	    if (map->modmap==NULL)

-		return BadAlloc;

-	}

-    }

-    return Success;

-}

-

-Status

-XkbAllocServerMap(XkbDescPtr xkb,unsigned which,unsigned nNewActions)

-{

-register int	i;

-XkbServerMapPtr map;

-

-    if (xkb==NULL)

-	return BadMatch;

-    if (xkb->server==NULL) {

-	map= calloc(1, sizeof(XkbServerMapRec));

-	if (map==NULL)

-	    return BadAlloc;

-	for (i=0;i<XkbNumVirtualMods;i++) {

-	    map->vmods[i]= XkbNoModifierMask;

-	}

-	xkb->server= map;

-    }

-    else map= xkb->server;

-    if (which&XkbExplicitComponentsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->explicit==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->explicit= calloc(i, sizeof(unsigned char));

-	    if (map->explicit==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbKeyActionsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-        if (nNewActions<1)

-	    nNewActions= 1;

-	if (map->acts==NULL) {

-	    map->acts= calloc((nNewActions+1), sizeof(XkbAction));

-	    if (map->acts==NULL)

-		return BadAlloc;

-	    map->num_acts= 1;

-	    map->size_acts= nNewActions+1;

-	}

-	else if ((map->size_acts-map->num_acts)<nNewActions) {

-	    unsigned need;

-	    XkbAction *prev_acts = map->acts;

-	    need= map->num_acts+nNewActions;

-	    map->acts= realloc(map->acts,need * sizeof(XkbAction));

-	    if (map->acts==NULL) {

-		free(prev_acts);

-	        map->num_acts= map->size_acts= 0;

-	        return BadAlloc;

-	    }

-	    map->size_acts= need;

-	    memset(&map->acts[map->num_acts], 0,

-		    ((map->size_acts-map->num_acts)*sizeof(XkbAction)));

-	}

-	if (map->key_acts==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->key_acts= calloc(i, sizeof(unsigned short));

-	    if (map->key_acts==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbKeyBehaviorsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->behaviors==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->behaviors= calloc(i, sizeof(XkbBehavior));

-	    if (map->behaviors==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbVirtualModMapMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->vmodmap==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->vmodmap= calloc(i, sizeof(unsigned short));

-	    if (map->vmodmap==NULL)

-		return BadAlloc;

-	}

-    }

-    return Success;

-}

-

-/***====================================================================***/

-

-static Status

-XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)

-{

-    if ((!from)||(!into))

-	return BadMatch;

-    free(into->map);

-    into->map = NULL;

-    free(into->preserve);

-    into->preserve = NULL;

-    free(into->level_names);

-    into->level_names = NULL;

-    *into= *from;

-    if ((from->map)&&(into->map_count>0)) {

-	into->map= calloc(into->map_count, sizeof(XkbKTMapEntryRec));

-	if (!into->map)

-	    return BadAlloc;

-	memcpy(into->map,from->map,into->map_count*sizeof(XkbKTMapEntryRec));

-    }

-    if ((from->preserve)&&(into->map_count>0)) {

-	into->preserve= calloc(into->map_count, sizeof(XkbModsRec));

-	if (!into->preserve)

-	    return BadAlloc;

-	memcpy(into->preserve,from->preserve,

-				into->map_count*sizeof(XkbModsRec));

-    }

-    if ((from->level_names)&&(into->num_levels>0)) {

-	into->level_names= calloc(into->num_levels, sizeof(Atom));

-	if (!into->level_names)

-	    return BadAlloc;

-	memcpy(into->level_names,from->level_names,

-				 into->num_levels*sizeof(Atom));

-    }

-    return Success;

-}

-

-Status

-XkbCopyKeyTypes(XkbKeyTypePtr from,XkbKeyTypePtr into,int num_types)

-{

-register int i,rtrn;

-

-    if ((!from)||(!into)||(num_types<0))

-	return BadMatch;

-    for (i=0;i<num_types;i++) {

-	if ((rtrn= XkbCopyKeyType(from++,into++))!=Success)

-	    return rtrn;

-    }

-    return Success;

-}

-

-Status

-XkbResizeKeyType(	XkbDescPtr	xkb,

-			int		type_ndx,

-			int		map_count,

-			Bool		want_preserve,

-			int		new_num_lvls)

-{

-XkbKeyTypePtr	type;

-KeyCode		matchingKeys[XkbMaxKeyCount],nMatchingKeys;

-

-    if ((type_ndx<0)||(type_ndx>=xkb->map->num_types)||(map_count<0)||

-    							(new_num_lvls<1))

-	return BadValue;

-    switch (type_ndx) {

-	case XkbOneLevelIndex:

-	    if (new_num_lvls!=1)

-		return BadMatch;

-	    break;

-	case XkbTwoLevelIndex:

-	case XkbAlphabeticIndex:

-	case XkbKeypadIndex:

-	    if (new_num_lvls!=2)

-		return BadMatch;

-	    break;

-    }

-    type= &xkb->map->types[type_ndx];

-    if (map_count==0) {

-	free(type->map);

-	type->map= NULL;

-	free(type->preserve);

-	type->preserve= NULL;

-	type->map_count= 0;

-    }

-    else {

-	XkbKTMapEntryRec *prev_map = type->map;

-

-	if ((map_count>type->map_count)||(type->map==NULL))

-	    type->map = realloc(type->map,map_count * sizeof(XkbKTMapEntryRec));

-	if (!type->map) {

-	    free(prev_map);

-	    return BadAlloc;

-	}

-	if (want_preserve) {

-	    XkbModsRec *prev_preserve = type->preserve;

-

-	    if ((map_count>type->map_count)||(type->preserve==NULL)) {

-		type->preserve = realloc(type->preserve,

-					  map_count * sizeof(XkbModsRec));

-	    }

-	    if (!type->preserve) {

-		free(prev_preserve);

-		return BadAlloc;

-	    }

-	}

-	else {

-	    free(type->preserve);

-	    type->preserve = NULL;

-	}

-	type->map_count= map_count;

-    }

-

-    if ((new_num_lvls>type->num_levels)||(type->level_names==NULL)) {

-	Atom * prev_level_names = type->level_names;

-

-	type->level_names = realloc(type->level_names,

-				     new_num_lvls * sizeof(Atom));

-	if (!type->level_names) {

-	    free(prev_level_names);

-	    return BadAlloc;

-	}

-    }

-    /*

-     * Here's the theory:

-     *    If the width of the type changed, we might have to resize the symbol

-     * maps for any keys that use the type for one or more groups.  This is

-     * expensive, so we'll try to cull out any keys that are obviously okay:

-     * In any case:

-     *    - keys that have a group width <= the old width are okay (because

-     *      they could not possibly have been associated with the old type)

-     * If the key type increased in size:

-     *    - keys that already have a group width >= to the new width are okay

-     *    + keys that have a group width >= the old width but < the new width

-     *      might have to be enlarged.

-     * If the key type decreased in size:

-     *    - keys that have a group width > the old width don't have to be

-     *      resized (because they must have some other wider type associated 

-     *      with some group).

-     *    + keys that have a group width == the old width might have to be

-     *      shrunk.

-     * The possibilities marked with '+' require us to examine the key types

-     * associated with each group for the key.

-     */

-    memset(matchingKeys, 0, XkbMaxKeyCount*sizeof(KeyCode));

-    nMatchingKeys= 0;

-    if (new_num_lvls>type->num_levels) {

-	int	 		nTotal;

-	KeySym	*		newSyms;

-	int			width,match,nResize;

-	register int		i,g,nSyms;

-

-	nResize= 0;

-	for (nTotal=1,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-	    width= XkbKeyGroupsWidth(xkb,i);

-	    if (width<type->num_levels)

-		continue;

-	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {

-		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {

-		    matchingKeys[nMatchingKeys++]= i;

-		    match= 1;

-		}

-	    }

-	    if ((!match)||(width>=new_num_lvls))

-		nTotal+= XkbKeyNumSyms(xkb,i);

-	    else {

-		nTotal+= XkbKeyNumGroups(xkb,i)*new_num_lvls;

-		nResize++;

-	    }

-	}

-	if (nResize>0) {

-	    int nextMatch;

-	    xkb->map->size_syms= (nTotal*15)/10;

-	    newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));

-	    if (newSyms==NULL)

-		return BadAlloc;

-	    nextMatch= 0;

-	    nSyms= 1;

-	    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-		if (matchingKeys[nextMatch]==i) {

-		    KeySym *pOld;

-		    nextMatch++;

-		    width= XkbKeyGroupsWidth(xkb,i);

-		    pOld= XkbKeySymsPtr(xkb,i);

-		    for (g=XkbKeyNumGroups(xkb,i)-1;g>=0;g--) {

-			memcpy(&newSyms[nSyms+(new_num_lvls*g)],&pOld[width*g],

-							width*sizeof(KeySym));

-		    }

-		    xkb->map->key_sym_map[i].offset= nSyms;

-		    nSyms+= XkbKeyNumGroups(xkb,i)*new_num_lvls;

-		}

-		else {

-		    memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),

-					XkbKeyNumSyms(xkb,i)*sizeof(KeySym));

-		    xkb->map->key_sym_map[i].offset= nSyms;

-		    nSyms+= XkbKeyNumSyms(xkb,i);

-		}

-	    }

-	    type->num_levels= new_num_lvls;

-	    free(xkb->map->syms);

-	    xkb->map->syms= newSyms;

-	    xkb->map->num_syms= nSyms;

-	    return Success;

-	}

-    }

-    else if (new_num_lvls<type->num_levels) {

-	int 		width,match;

-	register int	g,i;

-	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-	    width= XkbKeyGroupsWidth(xkb,i);

-	    if (width<type->num_levels)

-		continue;

-	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {

-		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {

-		    matchingKeys[nMatchingKeys++]= i;

-		    match= 1;

-		}

-	    }

-	}

-    }

-    if (nMatchingKeys>0) {

-	int 		key,firstClear;

-	register int	i,g;

-	if (new_num_lvls>type->num_levels)

-	     firstClear= type->num_levels;

-	else firstClear= new_num_lvls;

-	for (i=0;i<nMatchingKeys;i++) {

-	    KeySym *	pSyms;

-	    int		width,nClear;

-

-	    key= matchingKeys[i];

-	    width= XkbKeyGroupsWidth(xkb,key);

-	    nClear= width-firstClear;

-	    pSyms= XkbKeySymsPtr(xkb,key);

-	    for (g=XkbKeyNumGroups(xkb,key)-1;g>=0;g--) {

-		if (XkbKeyKeyTypeIndex(xkb,key,g)==type_ndx) {

-		    if (nClear>0)

-			memset(&pSyms[g*width+firstClear], 0, nClear*sizeof(KeySym));

-		}

-	    }

-	}

-    }

-    type->num_levels= new_num_lvls;

-    return Success;

-}

-

-KeySym *

-XkbResizeKeySyms(XkbDescPtr xkb,int key,int needed)

-{

-register int i,nSyms,nKeySyms;

-unsigned nOldSyms;

-KeySym	*newSyms;

-

-    if (needed==0) {

-	xkb->map->key_sym_map[key].offset= 0;

-	return xkb->map->syms;

-    }

-    nOldSyms= XkbKeyNumSyms(xkb,key);

-    if (nOldSyms>=(unsigned)needed) {

-	return XkbKeySymsPtr(xkb,key);

-    }

-    if (xkb->map->size_syms-xkb->map->num_syms>=(unsigned)needed) {

-	if (nOldSyms>0) {

-	    memcpy(&xkb->map->syms[xkb->map->num_syms],XkbKeySymsPtr(xkb,key),

-						nOldSyms*sizeof(KeySym));

-	}

-	if ((needed-nOldSyms)>0) {

-	    memset(&xkb->map->syms[xkb->map->num_syms+XkbKeyNumSyms(xkb, key)],

-                   0, (needed-nOldSyms)*sizeof(KeySym));

-	}

-	xkb->map->key_sym_map[key].offset = xkb->map->num_syms;

-	xkb->map->num_syms+= needed;

-	return &xkb->map->syms[xkb->map->key_sym_map[key].offset];

-    }

-    xkb->map->size_syms+= (needed>32?needed:32);

-    newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));

-    if (newSyms==NULL)

-	return NULL;

-    newSyms[0]= NoSymbol;

-    nSyms = 1;

-    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {

-	int nCopy;

-

-	nCopy= nKeySyms= XkbKeyNumSyms(xkb,i);

-	if ((nKeySyms==0)&&(i!=key))

-	    continue;

-	if (i==key)

-	    nKeySyms= needed;

-	if (nCopy!=0)

-	   memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),nCopy*sizeof(KeySym));

-	if (nKeySyms>nCopy)

-	    memset(&newSyms[nSyms+nCopy], 0, (nKeySyms-nCopy)*sizeof(KeySym));

-	xkb->map->key_sym_map[i].offset = nSyms;

-	nSyms+= nKeySyms;

-    }

-    free(xkb->map->syms);

-    xkb->map->syms = newSyms;

-    xkb->map->num_syms = nSyms;

-    return &xkb->map->syms[xkb->map->key_sym_map[key].offset];

-}

-

-static unsigned

-_ExtendRange(	unsigned int 	old_flags,

-		unsigned int	flag,

-		KeyCode		newKC,

-		KeyCode *	old_min,

-		unsigned char *	old_num)

-{

-    if ((old_flags&flag)==0) {

-	old_flags|= flag;

-	*old_min= newKC;

-	*old_num= 1;

-    }

-    else {

-	int	last= (*old_min)+(*old_num)-1;

-	if (newKC<*old_min) {

-	    *old_min= newKC;

-	    *old_num= (last-newKC)+1;

-	}

-	else if (newKC>last) {

-	    *old_num= (newKC-(*old_min))+1;

-	}

-    }

-    return old_flags;

-}

-

-Status

-XkbChangeKeycodeRange(	XkbDescPtr	xkb,

-			int 		minKC,

-			int 		maxKC,

-			XkbChangesPtr	changes)

-{

-int	tmp;

-

-    if ((!xkb)||(minKC<XkbMinLegalKeyCode)||(maxKC>XkbMaxLegalKeyCode))

-	return BadValue;

-    if (minKC>maxKC)

-	return BadMatch;

-    if (minKC<xkb->min_key_code) {

-	if (changes)

-	    changes->map.min_key_code= minKC;

-	tmp= xkb->min_key_code-minKC;

-	if (xkb->map)  {

-	    if (xkb->map->key_sym_map) {

-		memset((char *)&xkb->map->key_sym_map[minKC], 0,

-					tmp*sizeof(XkbSymMapRec));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbKeySymsMask,minKC,

-	    					&changes->map.first_key_sym,

-	    					&changes->map.num_key_syms);

-		}

-	    }

-	    if (xkb->map->modmap) {

-		memset((char *)&xkb->map->modmap[minKC], 0, tmp);

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbModifierMapMask,minKC,

-	    					&changes->map.first_modmap_key,

-	    					&changes->map.num_modmap_keys);

-		}

-	    }

-	}

-	if (xkb->server) {

-	    if (xkb->server->behaviors) {

-		memset((char *)&xkb->server->behaviors[minKC], 0,

-						tmp*sizeof(XkbBehavior));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyBehaviorsMask,minKC,

-    					&changes->map.first_key_behavior,

-    					&changes->map.num_key_behaviors);

-		}

-	    }

-	    if (xkb->server->key_acts) {

-		memset((char *)&xkb->server->key_acts[minKC], 0,

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyActionsMask,minKC,

-    					&changes->map.first_key_act,

-    					&changes->map.num_key_acts);

-		}

-	    }

-	    if (xkb->server->vmodmap) {

-		memset((char *)&xkb->server->vmodmap[minKC], 0,

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbVirtualModMapMask,minKC,

-		    			&changes->map.first_modmap_key,

-    					&changes->map.num_vmodmap_keys);

-		}

-	    }

-	}

-	if ((xkb->names)&&(xkb->names->keys)) {

-	    memset((char *)&xkb->names->keys[minKC], 0, tmp*sizeof(XkbKeyNameRec));

-	    if (changes) {

-		changes->names.changed= _ExtendRange(changes->names.changed,

-					XkbKeyNamesMask,minKC,

-					&changes->names.first_key,

-    					&changes->names.num_keys);

-	    }

-	}

-	xkb->min_key_code= minKC;

-    }

-    if (maxKC>xkb->max_key_code) {

-	if (changes)

-	    changes->map.max_key_code= maxKC;

-	tmp= maxKC-xkb->max_key_code;

-	if (xkb->map)  {

-	    if (xkb->map->key_sym_map) {

-		XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;

-

-		xkb->map->key_sym_map = realloc(xkb->map->key_sym_map,

-						(maxKC+1) * sizeof(XkbSymMapRec));

-		if (!xkb->map->key_sym_map) {

-		    free(prev_key_sym_map);

-		    return BadAlloc;

-		}

-		memset((char *)&xkb->map->key_sym_map[xkb->max_key_code], 0,

-					tmp*sizeof(XkbSymMapRec));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbKeySymsMask,maxKC,

-	    					&changes->map.first_key_sym,

-	    					&changes->map.num_key_syms);

-		}

-	    }

-	    if (xkb->map->modmap) {

-		unsigned char *prev_modmap = xkb->map->modmap;

-

-		xkb->map->modmap = realloc(xkb->map->modmap,

-					    (maxKC+1) * sizeof(unsigned char));

-		if (!xkb->map->modmap) {

-		    free(prev_modmap);

-		    return BadAlloc;

-		}

-		memset((char *)&xkb->map->modmap[xkb->max_key_code], 0, tmp);

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbModifierMapMask,maxKC,

-	    					&changes->map.first_modmap_key,

-	    					&changes->map.num_modmap_keys);

-		}

-	    }

-	}

-	if (xkb->server) {

-	    if (xkb->server->behaviors) {

-		XkbBehavior *prev_behaviors = xkb->server->behaviors;

-

-		xkb->server->behaviors = realloc(xkb->server->behaviors,

-						(maxKC+1) * sizeof(XkbBehavior));

-		if (!xkb->server->behaviors) {

-		    free(prev_behaviors);

-		    return BadAlloc;

-		}

-		memset((char *)&xkb->server->behaviors[xkb->max_key_code], 0,

-						tmp*sizeof(XkbBehavior));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyBehaviorsMask,maxKC,

-    					&changes->map.first_key_behavior,

-    					&changes->map.num_key_behaviors);

-		}

-	    }

-	    if (xkb->server->key_acts) {

-		unsigned short *prev_key_acts = xkb->server->key_acts;

-

-		xkb->server->key_acts= realloc(xkb->server->key_acts,

-						(maxKC+1) * sizeof(unsigned short));

-		if (!xkb->server->key_acts) {

-		    free(prev_key_acts);

-		    return BadAlloc;

-		}

-		memset((char *)&xkb->server->key_acts[xkb->max_key_code], 0,

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyActionsMask,maxKC,

-    					&changes->map.first_key_act,

-    					&changes->map.num_key_acts);

-		}

-	    }

-	    if (xkb->server->vmodmap) {

-		unsigned short *prev_vmodmap = xkb->server->vmodmap;

-

-		xkb->server->vmodmap= realloc(xkb->server->vmodmap,

-						(maxKC+1) * sizeof(unsigned short));

-		if (!xkb->server->vmodmap) {

-		    free(prev_vmodmap);

-		    return BadAlloc;

-		}

-		memset((char *)&xkb->server->vmodmap[xkb->max_key_code], 0,

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbVirtualModMapMask,maxKC,

-		    			&changes->map.first_modmap_key,

-    					&changes->map.num_vmodmap_keys);

-		}

-	    }

-	}

-	if ((xkb->names)&&(xkb->names->keys)) {

-	    XkbKeyNameRec *prev_keys = xkb->names->keys;

-

-	    xkb->names->keys = realloc(xkb->names->keys,

-					(maxKC+1) * sizeof(XkbKeyNameRec));

-	    if (!xkb->names->keys) {

-		free(prev_keys);

-		return BadAlloc;

-	    }

-	    memset((char *)&xkb->names->keys[xkb->max_key_code], 0,

-	    					tmp*sizeof(XkbKeyNameRec));

-	    if (changes) {

-		changes->names.changed= _ExtendRange(changes->names.changed,

-					XkbKeyNamesMask,maxKC,

-					&changes->names.first_key,

-    					&changes->names.num_keys);

-	    }

-	}

-	xkb->max_key_code= maxKC;

-    }

-    return Success;

-}

-

-XkbAction *

-XkbResizeKeyActions(XkbDescPtr xkb,int key,int needed)

-{

-register int i,nActs;

-XkbAction *newActs;

-

-    if (needed==0) {

-	xkb->server->key_acts[key]= 0;

-	return NULL;

-    }

-    if (XkbKeyHasActions(xkb,key)&&(XkbKeyNumSyms(xkb,key)>=(unsigned)needed))

-	return XkbKeyActionsPtr(xkb,key);

-    if (xkb->server->size_acts-xkb->server->num_acts>=(unsigned)needed) {

-	xkb->server->key_acts[key]= xkb->server->num_acts;

-	xkb->server->num_acts+= needed;

-	return &xkb->server->acts[xkb->server->key_acts[key]];

-    }

-    xkb->server->size_acts= xkb->server->num_acts+needed+8;

-    newActs = calloc(xkb->server->size_acts, sizeof(XkbAction));

-    if (newActs==NULL)

-	return NULL;

-    newActs[0].type = XkbSA_NoAction;

-    nActs = 1;

-    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {

-	int nKeyActs,nCopy;

-

-	if ((xkb->server->key_acts[i]==0)&&(i!=key))

-	    continue;

-

-	nCopy= nKeyActs= XkbKeyNumActions(xkb,i);

-	if (i==key) {

-	    nKeyActs= needed;

-	    if (needed<nCopy)

-		nCopy= needed;

-	}

-

-	if (nCopy>0)

-	    memcpy(&newActs[nActs],XkbKeyActionsPtr(xkb,i),

-						nCopy*sizeof(XkbAction));

-	if (nCopy<nKeyActs)

-	    memset(&newActs[nActs+nCopy], 0, (nKeyActs-nCopy)*sizeof(XkbAction));

-	xkb->server->key_acts[i]= nActs;

-	nActs+= nKeyActs;

-    }

-    free(xkb->server->acts);

-    xkb->server->acts = newActs;

-    xkb->server->num_acts= nActs;

-    return &xkb->server->acts[xkb->server->key_acts[key]];

-}

-

-void

-XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)

-{

-XkbClientMapPtr	map;

-

-    if ((xkb==NULL)||(xkb->map==NULL))

-	return;

-    if (freeMap)

-	what= XkbAllClientInfoMask;

-    map= xkb->map;

-    if (what&XkbKeyTypesMask) {

-	if (map->types!=NULL) {

-	    if (map->num_types>0) {

-		register int 	i;

-		XkbKeyTypePtr	type;

-		for (i=0,type=map->types;i<map->num_types;i++,type++) {

-		    free(type->map);

-		    type->map = NULL;

-		    free(type->preserve);

-		    type->preserve = NULL;

-		    type->map_count= 0;

-		    free(type->level_names);

-		    type->level_names = NULL;

-		}

-	    }

-	    free(map->types);

-	    map->num_types= map->size_types= 0;

-	    map->types= NULL;

-	}

-    }

-    if (what&XkbKeySymsMask) {

-	free(map->key_sym_map);

-	map->key_sym_map = NULL;

-	if (map->syms!=NULL) {

-	    free(map->syms);

-	    map->size_syms= map->num_syms= 0;

-	    map->syms= NULL;

-	}

-    }

-    if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {

-	free(map->modmap);

-	map->modmap= NULL;

-    }

-    if (freeMap) {

-	free(xkb->map);

-	xkb->map= NULL;

-    }

-    return;

-}

-

-void

-XkbFreeServerMap(XkbDescPtr xkb,unsigned what,Bool freeMap)

-{

-XkbServerMapPtr	map;

-

-    if ((xkb==NULL)||(xkb->server==NULL))

-	return;

-    if (freeMap)

-	what= XkbAllServerInfoMask;

-    map= xkb->server;

-    if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {

-	free(map->explicit);

-	map->explicit= NULL;

-    }

-    if (what&XkbKeyActionsMask) {

-	free(map->key_acts);

-	map->key_acts = NULL;

-	if (map->acts!=NULL) {

-	    free(map->acts);

-	    map->num_acts= map->size_acts= 0;

-	    map->acts= NULL;

-	}

-    }

-    if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {

-	free(map->behaviors);

-	map->behaviors= NULL;

-    }

-    if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {

-	free(map->vmodmap);

-	map->vmodmap= NULL;

-    }

-

-    if (freeMap) {

-	free(xkb->server);

-	xkb->server= NULL;

-    }

-    return;

-}

+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be 
+used in advertising or publicity pertaining to distribution 
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability 
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#elif defined(HAVE_CONFIG_H)
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "inputstr.h"
+#include <X11/keysym.h>
+#define	XKBSRV_NEED_FILE_FUNCS
+#include <xkbsrv.h>
+
+/***====================================================================***/
+
+Status
+XkbAllocClientMap(XkbDescPtr xkb, unsigned which, unsigned nTotalTypes)
+{
+    register int i;
+    XkbClientMapPtr map;
+
+    if ((xkb == NULL) ||
+        ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
+        return BadValue;
+    if ((which & XkbKeySymsMask) &&
+        ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+         (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+         (xkb->max_key_code < xkb->min_key_code))) {
+        DebugF("bad keycode (%d,%d) in XkbAllocClientMap\n",
+               xkb->min_key_code, xkb->max_key_code);
+        return BadValue;
+    }
+
+    if (xkb->map == NULL) {
+        map = calloc(1, sizeof(XkbClientMapRec));
+        if (map == NULL)
+            return BadAlloc;
+        xkb->map = map;
+    }
+    else
+        map = xkb->map;
+
+    if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
+        if (map->types == NULL) {
+            map->types = calloc(nTotalTypes, sizeof(XkbKeyTypeRec));
+            if (map->types == NULL)
+                return BadAlloc;
+            map->num_types = 0;
+            map->size_types = nTotalTypes;
+        }
+        else if (map->size_types < nTotalTypes) {
+            XkbKeyTypeRec *prev_types = map->types;
+
+            map->types =
+                realloc(map->types, nTotalTypes * sizeof(XkbKeyTypeRec));
+            if (map->types == NULL) {
+                free(prev_types);
+                map->num_types = map->size_types = 0;
+                return BadAlloc;
+            }
+            map->size_types = nTotalTypes;
+            memset(&map->types[map->num_types], 0,
+                   ((map->size_types -
+                     map->num_types) * sizeof(XkbKeyTypeRec)));
+        }
+    }
+    if (which & XkbKeySymsMask) {
+        int nKeys = XkbNumKeys(xkb);
+
+        if (map->syms == NULL) {
+            map->size_syms = (nKeys * 15) / 10;
+            map->syms = calloc(map->size_syms, sizeof(KeySym));
+            if (!map->syms) {
+                map->size_syms = 0;
+                return BadAlloc;
+            }
+            map->num_syms = 1;
+            map->syms[0] = NoSymbol;
+        }
+        if (map->key_sym_map == NULL) {
+            i = xkb->max_key_code + 1;
+            map->key_sym_map = calloc(i, sizeof(XkbSymMapRec));
+            if (map->key_sym_map == NULL)
+                return BadAlloc;
+        }
+    }
+    if (which & XkbModifierMapMask) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadMatch;
+        if (map->modmap == NULL) {
+            i = xkb->max_key_code + 1;
+            map->modmap = calloc(i, sizeof(unsigned char));
+            if (map->modmap == NULL)
+                return BadAlloc;
+        }
+    }
+    return Success;
+}
+
+Status
+XkbAllocServerMap(XkbDescPtr xkb, unsigned which, unsigned nNewActions)
+{
+    register int i;
+    XkbServerMapPtr map;
+
+    if (xkb == NULL)
+        return BadMatch;
+    if (xkb->server == NULL) {
+        map = calloc(1, sizeof(XkbServerMapRec));
+        if (map == NULL)
+            return BadAlloc;
+        for (i = 0; i < XkbNumVirtualMods; i++) {
+            map->vmods[i] = XkbNoModifierMask;
+        }
+        xkb->server = map;
+    }
+    else
+        map = xkb->server;
+    if (which & XkbExplicitComponentsMask) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadMatch;
+        if (map->explicit == NULL) {
+            i = xkb->max_key_code + 1;
+            map->explicit = calloc(i, sizeof(unsigned char));
+            if (map->explicit == NULL)
+                return BadAlloc;
+        }
+    }
+    if (which & XkbKeyActionsMask) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadMatch;
+        if (nNewActions < 1)
+            nNewActions = 1;
+        if (map->acts == NULL) {
+            map->acts = calloc((nNewActions + 1), sizeof(XkbAction));
+            if (map->acts == NULL)
+                return BadAlloc;
+            map->num_acts = 1;
+            map->size_acts = nNewActions + 1;
+        }
+        else if ((map->size_acts - map->num_acts) < nNewActions) {
+            unsigned need;
+            XkbAction *prev_acts = map->acts;
+
+            need = map->num_acts + nNewActions;
+            map->acts = realloc(map->acts, need * sizeof(XkbAction));
+            if (map->acts == NULL) {
+                free(prev_acts);
+                map->num_acts = map->size_acts = 0;
+                return BadAlloc;
+            }
+            map->size_acts = need;
+            memset(&map->acts[map->num_acts], 0,
+                   ((map->size_acts - map->num_acts) * sizeof(XkbAction)));
+        }
+        if (map->key_acts == NULL) {
+            i = xkb->max_key_code + 1;
+            map->key_acts = calloc(i, sizeof(unsigned short));
+            if (map->key_acts == NULL)
+                return BadAlloc;
+        }
+    }
+    if (which & XkbKeyBehaviorsMask) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadMatch;
+        if (map->behaviors == NULL) {
+            i = xkb->max_key_code + 1;
+            map->behaviors = calloc(i, sizeof(XkbBehavior));
+            if (map->behaviors == NULL)
+                return BadAlloc;
+        }
+    }
+    if (which & XkbVirtualModMapMask) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadMatch;
+        if (map->vmodmap == NULL) {
+            i = xkb->max_key_code + 1;
+            map->vmodmap = calloc(i, sizeof(unsigned short));
+            if (map->vmodmap == NULL)
+                return BadAlloc;
+        }
+    }
+    return Success;
+}
+
+/***====================================================================***/
+
+static Status
+XkbCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into)
+{
+    if ((!from) || (!into))
+        return BadMatch;
+    free(into->map);
+    into->map = NULL;
+    free(into->preserve);
+    into->preserve = NULL;
+    free(into->level_names);
+    into->level_names = NULL;
+    *into = *from;
+    if ((from->map) && (into->map_count > 0)) {
+        into->map = calloc(into->map_count, sizeof(XkbKTMapEntryRec));
+        if (!into->map)
+            return BadAlloc;
+        memcpy(into->map, from->map,
+               into->map_count * sizeof(XkbKTMapEntryRec));
+    }
+    if ((from->preserve) && (into->map_count > 0)) {
+        into->preserve = calloc(into->map_count, sizeof(XkbModsRec));
+        if (!into->preserve)
+            return BadAlloc;
+        memcpy(into->preserve, from->preserve,
+               into->map_count * sizeof(XkbModsRec));
+    }
+    if ((from->level_names) && (into->num_levels > 0)) {
+        into->level_names = calloc(into->num_levels, sizeof(Atom));
+        if (!into->level_names)
+            return BadAlloc;
+        memcpy(into->level_names, from->level_names,
+               into->num_levels * sizeof(Atom));
+    }
+    return Success;
+}
+
+Status
+XkbCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types)
+{
+    register int i, rtrn;
+
+    if ((!from) || (!into) || (num_types < 0))
+        return BadMatch;
+    for (i = 0; i < num_types; i++) {
+        if ((rtrn = XkbCopyKeyType(from++, into++)) != Success)
+            return rtrn;
+    }
+    return Success;
+}
+
+Status
+XkbResizeKeyType(XkbDescPtr xkb,
+                 int type_ndx,
+                 int map_count, Bool want_preserve, int new_num_lvls)
+{
+    XkbKeyTypePtr type;
+    KeyCode matchingKeys[XkbMaxKeyCount], nMatchingKeys;
+
+    if ((type_ndx < 0) || (type_ndx >= xkb->map->num_types) || (map_count < 0)
+        || (new_num_lvls < 1))
+        return BadValue;
+    switch (type_ndx) {
+    case XkbOneLevelIndex:
+        if (new_num_lvls != 1)
+            return BadMatch;
+        break;
+    case XkbTwoLevelIndex:
+    case XkbAlphabeticIndex:
+    case XkbKeypadIndex:
+        if (new_num_lvls != 2)
+            return BadMatch;
+        break;
+    }
+    type = &xkb->map->types[type_ndx];
+    if (map_count == 0) {
+        free(type->map);
+        type->map = NULL;
+        free(type->preserve);
+        type->preserve = NULL;
+        type->map_count = 0;
+    }
+    else {
+        XkbKTMapEntryRec *prev_map = type->map;
+
+        if ((map_count > type->map_count) || (type->map == NULL))
+            type->map =
+                realloc(type->map, map_count * sizeof(XkbKTMapEntryRec));
+        if (!type->map) {
+            free(prev_map);
+            return BadAlloc;
+        }
+        if (want_preserve) {
+            XkbModsRec *prev_preserve = type->preserve;
+
+            if ((map_count > type->map_count) || (type->preserve == NULL)) {
+                type->preserve = realloc(type->preserve,
+                                         map_count * sizeof(XkbModsRec));
+            }
+            if (!type->preserve) {
+                free(prev_preserve);
+                return BadAlloc;
+            }
+        }
+        else {
+            free(type->preserve);
+            type->preserve = NULL;
+        }
+        type->map_count = map_count;
+    }
+
+    if ((new_num_lvls > type->num_levels) || (type->level_names == NULL)) {
+        Atom *prev_level_names = type->level_names;
+
+        type->level_names = realloc(type->level_names,
+                                    new_num_lvls * sizeof(Atom));
+        if (!type->level_names) {
+            free(prev_level_names);
+            return BadAlloc;
+        }
+    }
+    /*
+     * Here's the theory:
+     *    If the width of the type changed, we might have to resize the symbol
+     * maps for any keys that use the type for one or more groups.  This is
+     * expensive, so we'll try to cull out any keys that are obviously okay:
+     * In any case:
+     *    - keys that have a group width <= the old width are okay (because
+     *      they could not possibly have been associated with the old type)
+     * If the key type increased in size:
+     *    - keys that already have a group width >= to the new width are okay
+     *    + keys that have a group width >= the old width but < the new width
+     *      might have to be enlarged.
+     * If the key type decreased in size:
+     *    - keys that have a group width > the old width don't have to be
+     *      resized (because they must have some other wider type associated 
+     *      with some group).
+     *    + keys that have a group width == the old width might have to be
+     *      shrunk.
+     * The possibilities marked with '+' require us to examine the key types
+     * associated with each group for the key.
+     */
+    memset(matchingKeys, 0, XkbMaxKeyCount * sizeof(KeyCode));
+    nMatchingKeys = 0;
+    if (new_num_lvls > type->num_levels) {
+        int nTotal;
+        KeySym *newSyms;
+        int width, match, nResize;
+        register int i, g, nSyms;
+
+        nResize = 0;
+        for (nTotal = 1, i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+            width = XkbKeyGroupsWidth(xkb, i);
+            if (width < type->num_levels)
+                continue;
+            for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
+                 (g >= 0) && (!match); g--) {
+                if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
+                    matchingKeys[nMatchingKeys++] = i;
+                    match = 1;
+                }
+            }
+            if ((!match) || (width >= new_num_lvls))
+                nTotal += XkbKeyNumSyms(xkb, i);
+            else {
+                nTotal += XkbKeyNumGroups(xkb, i) * new_num_lvls;
+                nResize++;
+            }
+        }
+        if (nResize > 0) {
+            int nextMatch;
+
+            xkb->map->size_syms = (nTotal * 15) / 10;
+            newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));
+            if (newSyms == NULL)
+                return BadAlloc;
+            nextMatch = 0;
+            nSyms = 1;
+            for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+                if (matchingKeys[nextMatch] == i) {
+                    KeySym *pOld;
+
+                    nextMatch++;
+                    width = XkbKeyGroupsWidth(xkb, i);
+                    pOld = XkbKeySymsPtr(xkb, i);
+                    for (g = XkbKeyNumGroups(xkb, i) - 1; g >= 0; g--) {
+                        memcpy(&newSyms[nSyms + (new_num_lvls * g)],
+                               &pOld[width * g], width * sizeof(KeySym));
+                    }
+                    xkb->map->key_sym_map[i].offset = nSyms;
+                    nSyms += XkbKeyNumGroups(xkb, i) * new_num_lvls;
+                }
+                else {
+                    memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
+                           XkbKeyNumSyms(xkb, i) * sizeof(KeySym));
+                    xkb->map->key_sym_map[i].offset = nSyms;
+                    nSyms += XkbKeyNumSyms(xkb, i);
+                }
+            }
+            type->num_levels = new_num_lvls;
+            free(xkb->map->syms);
+            xkb->map->syms = newSyms;
+            xkb->map->num_syms = nSyms;
+            return Success;
+        }
+    }
+    else if (new_num_lvls < type->num_levels) {
+        int width, match;
+        register int g, i;
+
+        for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+            width = XkbKeyGroupsWidth(xkb, i);
+            if (width < type->num_levels)
+                continue;
+            for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
+                 (g >= 0) && (!match); g--) {
+                if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
+                    matchingKeys[nMatchingKeys++] = i;
+                    match = 1;
+                }
+            }
+        }
+    }
+    if (nMatchingKeys > 0) {
+        int key, firstClear;
+        register int i, g;
+
+        if (new_num_lvls > type->num_levels)
+            firstClear = type->num_levels;
+        else
+            firstClear = new_num_lvls;
+        for (i = 0; i < nMatchingKeys; i++) {
+            KeySym *pSyms;
+            int width, nClear;
+
+            key = matchingKeys[i];
+            width = XkbKeyGroupsWidth(xkb, key);
+            nClear = width - firstClear;
+            pSyms = XkbKeySymsPtr(xkb, key);
+            for (g = XkbKeyNumGroups(xkb, key) - 1; g >= 0; g--) {
+                if (XkbKeyKeyTypeIndex(xkb, key, g) == type_ndx) {
+                    if (nClear > 0)
+                        memset(&pSyms[g * width + firstClear], 0,
+                               nClear * sizeof(KeySym));
+                }
+            }
+        }
+    }
+    type->num_levels = new_num_lvls;
+    return Success;
+}
+
+KeySym *
+XkbResizeKeySyms(XkbDescPtr xkb, int key, int needed)
+{
+    register int i, nSyms, nKeySyms;
+    unsigned nOldSyms;
+    KeySym *newSyms;
+
+    if (needed == 0) {
+        xkb->map->key_sym_map[key].offset = 0;
+        return xkb->map->syms;
+    }
+    nOldSyms = XkbKeyNumSyms(xkb, key);
+    if (nOldSyms >= (unsigned) needed) {
+        return XkbKeySymsPtr(xkb, key);
+    }
+    if (xkb->map->size_syms - xkb->map->num_syms >= (unsigned) needed) {
+        if (nOldSyms > 0) {
+            memcpy(&xkb->map->syms[xkb->map->num_syms], XkbKeySymsPtr(xkb, key),
+                   nOldSyms * sizeof(KeySym));
+        }
+        if ((needed - nOldSyms) > 0) {
+            memset(&xkb->map->
+                   syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)], 0,
+                   (needed - nOldSyms) * sizeof(KeySym));
+        }
+        xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
+        xkb->map->num_syms += needed;
+        return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
+    }
+    xkb->map->size_syms += (needed > 32 ? needed : 32);
+    newSyms = calloc(xkb->map->size_syms, sizeof(KeySym));
+    if (newSyms == NULL)
+        return NULL;
+    newSyms[0] = NoSymbol;
+    nSyms = 1;
+    for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
+        int nCopy;
+
+        nCopy = nKeySyms = XkbKeyNumSyms(xkb, i);
+        if ((nKeySyms == 0) && (i != key))
+            continue;
+        if (i == key)
+            nKeySyms = needed;
+        if (nCopy != 0)
+            memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
+                   nCopy * sizeof(KeySym));
+        if (nKeySyms > nCopy)
+            memset(&newSyms[nSyms + nCopy], 0,
+                   (nKeySyms - nCopy) * sizeof(KeySym));
+        xkb->map->key_sym_map[i].offset = nSyms;
+        nSyms += nKeySyms;
+    }
+    free(xkb->map->syms);
+    xkb->map->syms = newSyms;
+    xkb->map->num_syms = nSyms;
+    return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
+}
+
+static unsigned
+_ExtendRange(unsigned int old_flags,
+             unsigned int flag,
+             KeyCode newKC, KeyCode *old_min, unsigned char *old_num)
+{
+    if ((old_flags & flag) == 0) {
+        old_flags |= flag;
+        *old_min = newKC;
+        *old_num = 1;
+    }
+    else {
+        int last = (*old_min) + (*old_num) - 1;
+
+        if (newKC < *old_min) {
+            *old_min = newKC;
+            *old_num = (last - newKC) + 1;
+        }
+        else if (newKC > last) {
+            *old_num = (newKC - (*old_min)) + 1;
+        }
+    }
+    return old_flags;
+}
+
+Status
+XkbChangeKeycodeRange(XkbDescPtr xkb,
+                      int minKC, int maxKC, XkbChangesPtr changes)
+{
+    int tmp;
+
+    if ((!xkb) || (minKC < XkbMinLegalKeyCode) || (maxKC > XkbMaxLegalKeyCode))
+        return BadValue;
+    if (minKC > maxKC)
+        return BadMatch;
+    if (minKC < xkb->min_key_code) {
+        if (changes)
+            changes->map.min_key_code = minKC;
+        tmp = xkb->min_key_code - minKC;
+        if (xkb->map) {
+            if (xkb->map->key_sym_map) {
+                memset((char *) &xkb->map->key_sym_map[minKC], 0,
+                       tmp * sizeof(XkbSymMapRec));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeySymsMask, minKC,
+                                                        &changes->map.
+                                                        first_key_sym,
+                                                        &changes->map.
+                                                        num_key_syms);
+                }
+            }
+            if (xkb->map->modmap) {
+                memset((char *) &xkb->map->modmap[minKC], 0, tmp);
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbModifierMapMask,
+                                                        minKC,
+                                                        &changes->map.
+                                                        first_modmap_key,
+                                                        &changes->map.
+                                                        num_modmap_keys);
+                }
+            }
+        }
+        if (xkb->server) {
+            if (xkb->server->behaviors) {
+                memset((char *) &xkb->server->behaviors[minKC], 0,
+                       tmp * sizeof(XkbBehavior));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeyBehaviorsMask,
+                                                        minKC,
+                                                        &changes->map.
+                                                        first_key_behavior,
+                                                        &changes->map.
+                                                        num_key_behaviors);
+                }
+            }
+            if (xkb->server->key_acts) {
+                memset((char *) &xkb->server->key_acts[minKC], 0,
+                       tmp * sizeof(unsigned short));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeyActionsMask,
+                                                        minKC,
+                                                        &changes->map.
+                                                        first_key_act,
+                                                        &changes->map.
+                                                        num_key_acts);
+                }
+            }
+            if (xkb->server->vmodmap) {
+                memset((char *) &xkb->server->vmodmap[minKC], 0,
+                       tmp * sizeof(unsigned short));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbVirtualModMapMask,
+                                                        minKC,
+                                                        &changes->map.
+                                                        first_modmap_key,
+                                                        &changes->map.
+                                                        num_vmodmap_keys);
+                }
+            }
+        }
+        if ((xkb->names) && (xkb->names->keys)) {
+            memset((char *) &xkb->names->keys[minKC], 0,
+                   tmp * sizeof(XkbKeyNameRec));
+            if (changes) {
+                changes->names.changed = _ExtendRange(changes->names.changed,
+                                                      XkbKeyNamesMask, minKC,
+                                                      &changes->names.first_key,
+                                                      &changes->names.num_keys);
+            }
+        }
+        xkb->min_key_code = minKC;
+    }
+    if (maxKC > xkb->max_key_code) {
+        if (changes)
+            changes->map.max_key_code = maxKC;
+        tmp = maxKC - xkb->max_key_code;
+        if (xkb->map) {
+            if (xkb->map->key_sym_map) {
+                XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;
+
+                xkb->map->key_sym_map = realloc(xkb->map->key_sym_map,
+                                                (maxKC +
+                                                 1) * sizeof(XkbSymMapRec));
+                if (!xkb->map->key_sym_map) {
+                    free(prev_key_sym_map);
+                    return BadAlloc;
+                }
+                memset((char *) &xkb->map->key_sym_map[xkb->max_key_code], 0,
+                       tmp * sizeof(XkbSymMapRec));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeySymsMask, maxKC,
+                                                        &changes->map.
+                                                        first_key_sym,
+                                                        &changes->map.
+                                                        num_key_syms);
+                }
+            }
+            if (xkb->map->modmap) {
+                unsigned char *prev_modmap = xkb->map->modmap;
+
+                xkb->map->modmap = realloc(xkb->map->modmap,
+                                           (maxKC + 1) * sizeof(unsigned char));
+                if (!xkb->map->modmap) {
+                    free(prev_modmap);
+                    return BadAlloc;
+                }
+                memset((char *) &xkb->map->modmap[xkb->max_key_code], 0, tmp);
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbModifierMapMask,
+                                                        maxKC,
+                                                        &changes->map.
+                                                        first_modmap_key,
+                                                        &changes->map.
+                                                        num_modmap_keys);
+                }
+            }
+        }
+        if (xkb->server) {
+            if (xkb->server->behaviors) {
+                XkbBehavior *prev_behaviors = xkb->server->behaviors;
+
+                xkb->server->behaviors = realloc(xkb->server->behaviors,
+                                                 (maxKC +
+                                                  1) * sizeof(XkbBehavior));
+                if (!xkb->server->behaviors) {
+                    free(prev_behaviors);
+                    return BadAlloc;
+                }
+                memset((char *) &xkb->server->behaviors[xkb->max_key_code], 0,
+                       tmp * sizeof(XkbBehavior));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeyBehaviorsMask,
+                                                        maxKC,
+                                                        &changes->map.
+                                                        first_key_behavior,
+                                                        &changes->map.
+                                                        num_key_behaviors);
+                }
+            }
+            if (xkb->server->key_acts) {
+                unsigned short *prev_key_acts = xkb->server->key_acts;
+
+                xkb->server->key_acts = realloc(xkb->server->key_acts,
+                                                (maxKC +
+                                                 1) * sizeof(unsigned short));
+                if (!xkb->server->key_acts) {
+                    free(prev_key_acts);
+                    return BadAlloc;
+                }
+                memset((char *) &xkb->server->key_acts[xkb->max_key_code], 0,
+                       tmp * sizeof(unsigned short));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbKeyActionsMask,
+                                                        maxKC,
+                                                        &changes->map.
+                                                        first_key_act,
+                                                        &changes->map.
+                                                        num_key_acts);
+                }
+            }
+            if (xkb->server->vmodmap) {
+                unsigned short *prev_vmodmap = xkb->server->vmodmap;
+
+                xkb->server->vmodmap = realloc(xkb->server->vmodmap,
+                                               (maxKC +
+                                                1) * sizeof(unsigned short));
+                if (!xkb->server->vmodmap) {
+                    free(prev_vmodmap);
+                    return BadAlloc;
+                }
+                memset((char *) &xkb->server->vmodmap[xkb->max_key_code], 0,
+                       tmp * sizeof(unsigned short));
+                if (changes) {
+                    changes->map.changed = _ExtendRange(changes->map.changed,
+                                                        XkbVirtualModMapMask,
+                                                        maxKC,
+                                                        &changes->map.
+                                                        first_modmap_key,
+                                                        &changes->map.
+                                                        num_vmodmap_keys);
+                }
+            }
+        }
+        if ((xkb->names) && (xkb->names->keys)) {
+            XkbKeyNameRec *prev_keys = xkb->names->keys;
+
+            xkb->names->keys = realloc(xkb->names->keys,
+                                       (maxKC + 1) * sizeof(XkbKeyNameRec));
+            if (!xkb->names->keys) {
+                free(prev_keys);
+                return BadAlloc;
+            }
+            memset((char *) &xkb->names->keys[xkb->max_key_code], 0,
+                   tmp * sizeof(XkbKeyNameRec));
+            if (changes) {
+                changes->names.changed = _ExtendRange(changes->names.changed,
+                                                      XkbKeyNamesMask, maxKC,
+                                                      &changes->names.first_key,
+                                                      &changes->names.num_keys);
+            }
+        }
+        xkb->max_key_code = maxKC;
+    }
+    return Success;
+}
+
+XkbAction *
+XkbResizeKeyActions(XkbDescPtr xkb, int key, int needed)
+{
+    register int i, nActs;
+    XkbAction *newActs;
+
+    if (needed == 0) {
+        xkb->server->key_acts[key] = 0;
+        return NULL;
+    }
+    if (XkbKeyHasActions(xkb, key) &&
+        (XkbKeyNumSyms(xkb, key) >= (unsigned) needed))
+        return XkbKeyActionsPtr(xkb, key);
+    if (xkb->server->size_acts - xkb->server->num_acts >= (unsigned) needed) {
+        xkb->server->key_acts[key] = xkb->server->num_acts;
+        xkb->server->num_acts += needed;
+        return &xkb->server->acts[xkb->server->key_acts[key]];
+    }
+    xkb->server->size_acts = xkb->server->num_acts + needed + 8;
+    newActs = calloc(xkb->server->size_acts, sizeof(XkbAction));
+    if (newActs == NULL)
+        return NULL;
+    newActs[0].type = XkbSA_NoAction;
+    nActs = 1;
+    for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
+        int nKeyActs, nCopy;
+
+        if ((xkb->server->key_acts[i] == 0) && (i != key))
+            continue;
+
+        nCopy = nKeyActs = XkbKeyNumActions(xkb, i);
+        if (i == key) {
+            nKeyActs = needed;
+            if (needed < nCopy)
+                nCopy = needed;
+        }
+
+        if (nCopy > 0)
+            memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),
+                   nCopy * sizeof(XkbAction));
+        if (nCopy < nKeyActs)
+            memset(&newActs[nActs + nCopy], 0,
+                   (nKeyActs - nCopy) * sizeof(XkbAction));
+        xkb->server->key_acts[i] = nActs;
+        nActs += nKeyActs;
+    }
+    free(xkb->server->acts);
+    xkb->server->acts = newActs;
+    xkb->server->num_acts = nActs;
+    return &xkb->server->acts[xkb->server->key_acts[key]];
+}
+
+void
+XkbFreeClientMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
+{
+    XkbClientMapPtr map;
+
+    if ((xkb == NULL) || (xkb->map == NULL))
+        return;
+    if (freeMap)
+        what = XkbAllClientInfoMask;
+    map = xkb->map;
+    if (what & XkbKeyTypesMask) {
+        if (map->types != NULL) {
+            if (map->num_types > 0) {
+                register int i;
+                XkbKeyTypePtr type;
+
+                for (i = 0, type = map->types; i < map->num_types; i++, type++) {
+                    free(type->map);
+                    type->map = NULL;
+                    free(type->preserve);
+                    type->preserve = NULL;
+                    type->map_count = 0;
+                    free(type->level_names);
+                    type->level_names = NULL;
+                }
+            }
+            free(map->types);
+            map->num_types = map->size_types = 0;
+            map->types = NULL;
+        }
+    }
+    if (what & XkbKeySymsMask) {
+        free(map->key_sym_map);
+        map->key_sym_map = NULL;
+        if (map->syms != NULL) {
+            free(map->syms);
+            map->size_syms = map->num_syms = 0;
+            map->syms = NULL;
+        }
+    }
+    if ((what & XkbModifierMapMask) && (map->modmap != NULL)) {
+        free(map->modmap);
+        map->modmap = NULL;
+    }
+    if (freeMap) {
+        free(xkb->map);
+        xkb->map = NULL;
+    }
+    return;
+}
+
+void
+XkbFreeServerMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
+{
+    XkbServerMapPtr map;
+
+    if ((xkb == NULL) || (xkb->server == NULL))
+        return;
+    if (freeMap)
+        what = XkbAllServerInfoMask;
+    map = xkb->server;
+    if ((what & XkbExplicitComponentsMask) && (map->explicit != NULL)) {
+        free(map->explicit);
+        map->explicit = NULL;
+    }
+    if (what & XkbKeyActionsMask) {
+        free(map->key_acts);
+        map->key_acts = NULL;
+        if (map->acts != NULL) {
+            free(map->acts);
+            map->num_acts = map->size_acts = 0;
+            map->acts = NULL;
+        }
+    }
+    if ((what & XkbKeyBehaviorsMask) && (map->behaviors != NULL)) {
+        free(map->behaviors);
+        map->behaviors = NULL;
+    }
+    if ((what & XkbVirtualModMapMask) && (map->vmodmap != NULL)) {
+        free(map->vmodmap);
+        map->vmodmap = NULL;
+    }
+
+    if (freeMap) {
+        free(xkb->server);
+        xkb->server = NULL;
+    }
+    return;
+}
diff --git a/xorg-server/xkb/XKBMisc.c b/xorg-server/xkb/XKBMisc.c
index 96688be18..6abd1d11a 100644
--- a/xorg-server/xkb/XKBMisc.c
+++ b/xorg-server/xkb/XKBMisc.c
@@ -45,56 +45,54 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #define	XKB_OFFSET(g,l)	(((g)*groupsWidth)+(l))
 
 int
-XkbKeyTypesForCoreSymbols(	XkbDescPtr	xkb,
-				int		map_width,
-				KeySym *	core_syms,
-				unsigned int 	protected,
-    				int *		types_inout,
-				KeySym *	xkb_syms_rtrn)
+XkbKeyTypesForCoreSymbols(XkbDescPtr xkb,
+                          int map_width,
+                          KeySym * core_syms,
+                          unsigned int protected,
+                          int *types_inout, KeySym * xkb_syms_rtrn)
 {
-register int	i;
-unsigned int	empty;
-int		nSyms[XkbNumKbdGroups];
-int		nGroups,tmp,groupsWidth;
-BOOL		replicated = FALSE;
+    register int i;
+    unsigned int empty;
+    int nSyms[XkbNumKbdGroups];
+    int nGroups, tmp, groupsWidth;
+    BOOL replicated = FALSE;
 
     /* Section 12.2 of the protocol describes this process in more detail */
     /* Step 1:  find the # of symbols in the core mapping per group */
-    groupsWidth= 2;
-    for (i=0;i<XkbNumKbdGroups;i++) {
-	if ((protected&(1<<i))&&(types_inout[i]<xkb->map->num_types)) {
-	    nSyms[i]= xkb->map->types[types_inout[i]].num_levels;
-	    if (nSyms[i]>groupsWidth)
-		groupsWidth= nSyms[i];
-	}
-	else {
-	    types_inout[i]= XkbTwoLevelIndex;	/* don't really know, yet */
-	    nSyms[i]= 2;
-	}
-    }
-    if (nSyms[XkbGroup1Index]<2)
-	nSyms[XkbGroup1Index]= 2;
-    if (nSyms[XkbGroup2Index]<2)
-	nSyms[XkbGroup2Index]= 2;
-    /* Step 2:	Copy the symbols from the core ordering to XKB ordering	*/
-    /*		symbols in the core are in the order:			*/
-    /*		G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*]	*/
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,0)]= CORE_SYM(0);
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,1)]= CORE_SYM(1);
-    for (i=2;i<nSyms[XkbGroup1Index];i++) {
-	xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,i)]= CORE_SYM(2+i);
-    }
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,0)]= CORE_SYM(2);
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,1)]= CORE_SYM(3);
-    tmp= 2+(nSyms[XkbGroup1Index]-2); /* offset to extra group2 syms */
-    for (i=2;i<nSyms[XkbGroup2Index];i++) {
-	xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,i)]= CORE_SYM(tmp+i);
+    groupsWidth = 2;
+    for (i = 0; i < XkbNumKbdGroups; i++) {
+        if ((protected & (1 << i)) && (types_inout[i] < xkb->map->num_types)) {
+            nSyms[i] = xkb->map->types[types_inout[i]].num_levels;
+            if (nSyms[i] > groupsWidth)
+                groupsWidth = nSyms[i];
+        }
+        else {
+            types_inout[i] = XkbTwoLevelIndex;  /* don't really know, yet */
+            nSyms[i] = 2;
+        }
+    }
+    if (nSyms[XkbGroup1Index] < 2)
+        nSyms[XkbGroup1Index] = 2;
+    if (nSyms[XkbGroup2Index] < 2)
+        nSyms[XkbGroup2Index] = 2;
+    /* Step 2:  Copy the symbols from the core ordering to XKB ordering */
+    /*          symbols in the core are in the order:                   */
+    /*          G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*] */
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 0)] = CORE_SYM(0);
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 1)] = CORE_SYM(1);
+    for (i = 2; i < nSyms[XkbGroup1Index]; i++) {
+        xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, i)] = CORE_SYM(2 + i);
+    }
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 0)] = CORE_SYM(2);
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 1)] = CORE_SYM(3);
+    tmp = 2 + (nSyms[XkbGroup1Index] - 2);      /* offset to extra group2 syms */
+    for (i = 2; i < nSyms[XkbGroup2Index]; i++) {
+        xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, i)] = CORE_SYM(tmp + i);
     }
 
     /* Special case: if only the first group is explicit, and the symbols
      * replicate across all groups, then we have a Section 12.4 replication */
-    if ((protected & ~XkbExplicitKeyType1Mask) == 0)
-    {
+    if ((protected & ~XkbExplicitKeyType1Mask) == 0) {
         int j, width = nSyms[XkbGroup1Index];
 
         replicated = TRUE;
@@ -105,119 +103,123 @@ BOOL		replicated = FALSE;
             replicated = FALSE;
 
         /* Check CDECDE in ABABCDECDEABCDE */
-        for (i = 2; i < width && replicated; i++)
-        {
+        for (i = 2; i < width && replicated; i++) {
             if (CORE_SYM(2 + i) != CORE_SYM(i + width))
                 replicated = FALSE;
         }
 
         /* Check ABCDE in ABABCDECDEABCDE */
         for (j = 2; replicated &&
-                    j < XkbNumKbdGroups &&
-                    map_width >= width * (j + 1); j++)
-        {
-            for (i = 0; i < width && replicated; i++)
-            {
+             j < XkbNumKbdGroups && map_width >= width * (j + 1); j++) {
+            for (i = 0; i < width && replicated; i++) {
                 if (CORE_SYM(((i < 2) ? i : 2 + i)) != CORE_SYM(i + width * j))
                     replicated = FALSE;
             }
         }
     }
 
-    if (replicated)
-    {
-	nSyms[XkbGroup2Index]= 0;
-	nSyms[XkbGroup3Index]= 0;
-	nSyms[XkbGroup4Index]= 0;
-	nGroups= 1;
-    } else
-    {
-        tmp= nSyms[XkbGroup1Index]+nSyms[XkbGroup2Index];
-        if ((tmp>=map_width)&&
-                ((protected&(XkbExplicitKeyType3Mask|XkbExplicitKeyType4Mask))==0)) {
-            nSyms[XkbGroup3Index]= 0;
-            nSyms[XkbGroup4Index]= 0;
-            nGroups= 2;
-        } else
-        {
-            nGroups= 3;
-            for (i=0;i<nSyms[XkbGroup3Index];i++,tmp++) {
-                xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index,i)]= CORE_SYM(tmp);
+    if (replicated) {
+        nSyms[XkbGroup2Index] = 0;
+        nSyms[XkbGroup3Index] = 0;
+        nSyms[XkbGroup4Index] = 0;
+        nGroups = 1;
+    }
+    else {
+        tmp = nSyms[XkbGroup1Index] + nSyms[XkbGroup2Index];
+        if ((tmp >= map_width) &&
+            ((protected & (XkbExplicitKeyType3Mask | XkbExplicitKeyType4Mask))
+             == 0)) {
+            nSyms[XkbGroup3Index] = 0;
+            nSyms[XkbGroup4Index] = 0;
+            nGroups = 2;
+        }
+        else {
+            nGroups = 3;
+            for (i = 0; i < nSyms[XkbGroup3Index]; i++, tmp++) {
+                xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index, i)] = CORE_SYM(tmp);
             }
-            if ((tmp<map_width)||(protected&XkbExplicitKeyType4Mask)) {
-                nGroups= 4;
-                for (i=0;i<nSyms[XkbGroup4Index];i++,tmp++) {
-                    xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index,i)]= CORE_SYM(tmp);
+            if ((tmp < map_width) || (protected & XkbExplicitKeyType4Mask)) {
+                nGroups = 4;
+                for (i = 0; i < nSyms[XkbGroup4Index]; i++, tmp++) {
+                    xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index, i)] =
+                        CORE_SYM(tmp);
                 }
             }
             else {
-                nSyms[XkbGroup4Index]= 0;
+                nSyms[XkbGroup4Index] = 0;
             }
         }
     }
     /* steps 3&4: alphanumeric expansion,  assign canonical types */
-    empty= 0;
-    for (i=0;i<nGroups;i++) {
-	KeySym *syms;
-	syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
-	if ((nSyms[i]>1)&&(syms[1]==NoSymbol)&&(syms[0]!=NoSymbol)) {
-	    KeySym upper,lower;
-	    XkbConvertCase(syms[0],&lower,&upper);
-	    if (upper!=lower) {
-		xkb_syms_rtrn[XKB_OFFSET(i,0)]= lower;
-		xkb_syms_rtrn[XKB_OFFSET(i,1)]= upper;
-		if ((protected&(1<<i))==0)
-		    types_inout[i]= XkbAlphabeticIndex;
-	    }
-	    else if ((protected&(1<<i))==0) {
-		types_inout[i]= XkbOneLevelIndex;
-	/*	nSyms[i]=	1;*/
-	    }
-	}
-	if (((protected&(1<<i))==0)&&(types_inout[i]==XkbTwoLevelIndex)) {
-	    if (XkbKSIsKeypad(syms[0])||XkbKSIsKeypad(syms[1]))
-		types_inout[i]= XkbKeypadIndex;
-	    else {
-		KeySym upper,lower;
-		XkbConvertCase(syms[0],&lower,&upper);
-		if ((syms[0]==lower)&&(syms[1]==upper))
-		    types_inout[i]= XkbAlphabeticIndex;
-	    }
-	}
-	if (syms[0]==NoSymbol) {
-	    register int n;
-	    Bool	found;
-	    for (n=1,found=FALSE;(!found)&&(n<nSyms[i]);n++) {
-		found= (syms[n]!=NoSymbol);
-	    }
-	    if (!found)
-		empty|= (1<<i);
-	}
+    empty = 0;
+    for (i = 0; i < nGroups; i++) {
+        KeySym *syms;
+
+        syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
+        if ((nSyms[i] > 1) && (syms[1] == NoSymbol) && (syms[0] != NoSymbol)) {
+            KeySym upper, lower;
+
+            XkbConvertCase(syms[0], &lower, &upper);
+            if (upper != lower) {
+                xkb_syms_rtrn[XKB_OFFSET(i, 0)] = lower;
+                xkb_syms_rtrn[XKB_OFFSET(i, 1)] = upper;
+                if ((protected & (1 << i)) == 0)
+                    types_inout[i] = XkbAlphabeticIndex;
+            }
+            else if ((protected & (1 << i)) == 0) {
+                types_inout[i] = XkbOneLevelIndex;
+                /*      nSyms[i]=       1; */
+            }
+        }
+        if (((protected & (1 << i)) == 0) &&
+            (types_inout[i] == XkbTwoLevelIndex)) {
+            if (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))
+                types_inout[i] = XkbKeypadIndex;
+            else {
+                KeySym upper, lower;
+
+                XkbConvertCase(syms[0], &lower, &upper);
+                if ((syms[0] == lower) && (syms[1] == upper))
+                    types_inout[i] = XkbAlphabeticIndex;
+            }
+        }
+        if (syms[0] == NoSymbol) {
+            register int n;
+            Bool found;
+
+            for (n = 1, found = FALSE; (!found) && (n < nSyms[i]); n++) {
+                found = (syms[n] != NoSymbol);
+            }
+            if (!found)
+                empty |= (1 << i);
+        }
     }
     /* step 5: squoosh out empty groups */
     if (empty) {
-	for (i=nGroups-1;i>=0;i--) {
-	    if (((empty&(1<<i))==0)||(protected&(1<<i)))
-		break;
-	    nGroups--;
-	}
+        for (i = nGroups - 1; i >= 0; i--) {
+            if (((empty & (1 << i)) == 0) || (protected & (1 << i)))
+                break;
+            nGroups--;
+        }
     }
-    if (nGroups<1)
-	return 0;
+    if (nGroups < 1)
+        return 0;
 
     /* step 6: replicate group 1 into group two, if necessary */
-    if ((nGroups>1)&&((empty&(XkbGroup1Mask|XkbGroup2Mask))==XkbGroup2Mask)) {
-	if ((protected&(XkbExplicitKeyType1Mask|XkbExplicitKeyType2Mask))==0) {
-	    nSyms[XkbGroup2Index]= nSyms[XkbGroup1Index];
-	    types_inout[XkbGroup2Index]= types_inout[XkbGroup1Index];
-	    memcpy((char *)&xkb_syms_rtrn[2],(char *)xkb_syms_rtrn,
-							2*sizeof(KeySym));
-	}
-	else if (types_inout[XkbGroup1Index]==types_inout[XkbGroup2Index]) {
-	    memcpy((char *)&xkb_syms_rtrn[nSyms[XkbGroup1Index]],
-	    				(char *)xkb_syms_rtrn,
-					nSyms[XkbGroup1Index]*sizeof(KeySym));
-	}
+    if ((nGroups > 1) &&
+        ((empty & (XkbGroup1Mask | XkbGroup2Mask)) == XkbGroup2Mask)) {
+        if ((protected & (XkbExplicitKeyType1Mask | XkbExplicitKeyType2Mask)) ==
+            0) {
+            nSyms[XkbGroup2Index] = nSyms[XkbGroup1Index];
+            types_inout[XkbGroup2Index] = types_inout[XkbGroup1Index];
+            memcpy((char *) &xkb_syms_rtrn[2], (char *) xkb_syms_rtrn,
+                   2 * sizeof(KeySym));
+        }
+        else if (types_inout[XkbGroup1Index] == types_inout[XkbGroup2Index]) {
+            memcpy((char *) &xkb_syms_rtrn[nSyms[XkbGroup1Index]],
+                   (char *) xkb_syms_rtrn,
+                   nSyms[XkbGroup1Index] * sizeof(KeySym));
+        }
     }
 
     /* step 7: check for all groups identical or all width 1
@@ -226,136 +228,145 @@ BOOL		replicated = FALSE;
      * have canonical types with same symbols, we assume it's info lost from
      * the core replication.
      */
-    if (nGroups>1) {
-	Bool sameType,allOneLevel, canonical = TRUE;
-	allOneLevel= (xkb->map->types[types_inout[0]].num_levels==1);
-	for (i=1,sameType=TRUE;(allOneLevel||sameType)&&(i<nGroups);i++) {
-	    sameType=(sameType&&(types_inout[i]==types_inout[XkbGroup1Index]));
-	    if (allOneLevel)
-		allOneLevel= (xkb->map->types[types_inout[i]].num_levels==1);
-	    if (types_inout[i] > XkbLastRequiredType)
-		canonical = FALSE;
-	}
-	if (((sameType) || canonical)&&
-	    (!(protected&(XkbExplicitKeyTypesMask&~XkbExplicitKeyType1Mask)))){
-	    register int s;
-	    Bool	identical;
-	    for (i=1,identical=TRUE;identical&&(i<nGroups);i++) {
-		KeySym *syms;
+    if (nGroups > 1) {
+        Bool sameType, allOneLevel, canonical = TRUE;
+
+        allOneLevel = (xkb->map->types[types_inout[0]].num_levels == 1);
+        for (i = 1, sameType = TRUE; (allOneLevel || sameType) && (i < nGroups);
+             i++) {
+            sameType = (sameType &&
+                        (types_inout[i] == types_inout[XkbGroup1Index]));
+            if (allOneLevel)
+                allOneLevel = (xkb->map->types[types_inout[i]].num_levels == 1);
+            if (types_inout[i] > XkbLastRequiredType)
+                canonical = FALSE;
+        }
+        if (((sameType) || canonical) &&
+            (!(protected &
+               (XkbExplicitKeyTypesMask & ~XkbExplicitKeyType1Mask)))) {
+            register int s;
+            Bool identical;
+
+            for (i = 1, identical = TRUE; identical && (i < nGroups); i++) {
+                KeySym *syms;
+
                 if (nSyms[i] != nSyms[XkbGroup1Index])
                     identical = FALSE;
-		syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
-		for (s=0;identical&&(s<nSyms[i]);s++) {
-		    if (syms[s]!=xkb_syms_rtrn[s])
-			identical= FALSE;
-		}
-	    }
-	    if (identical)
-		nGroups= 1;
-	}
-	if (allOneLevel && (nGroups>1)) {
-	    KeySym *syms;
-	    syms= &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
-	    nSyms[XkbGroup1Index]= 1;
-	    for (i=1;i<nGroups;i++) {
-		xkb_syms_rtrn[i]= syms[0];
-		syms+= nSyms[i];
-		nSyms[i]= 1;
-	    }
-	}
+                syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
+                for (s = 0; identical && (s < nSyms[i]); s++) {
+                    if (syms[s] != xkb_syms_rtrn[s])
+                        identical = FALSE;
+                }
+            }
+            if (identical)
+                nGroups = 1;
+        }
+        if (allOneLevel && (nGroups > 1)) {
+            KeySym *syms;
+
+            syms = &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
+            nSyms[XkbGroup1Index] = 1;
+            for (i = 1; i < nGroups; i++) {
+                xkb_syms_rtrn[i] = syms[0];
+                syms += nSyms[i];
+                nSyms[i] = 1;
+            }
+        }
     }
     return nGroups;
 }
 
 static XkbSymInterpretPtr
-_XkbFindMatchingInterp(	XkbDescPtr	xkb,
-			KeySym 		sym,
-			unsigned int	real_mods,
-			unsigned int	level)
+_XkbFindMatchingInterp(XkbDescPtr xkb,
+                       KeySym sym, unsigned int real_mods, unsigned int level)
 {
-register unsigned	 i;
-XkbSymInterpretPtr	 interp,rtrn;
-CARD8			 mods;
-
-    rtrn= NULL;
-    interp= xkb->compat->sym_interpret;
-    for (i=0;i<xkb->compat->num_si;i++,interp++) {
-	if ((interp->sym==NoSymbol)||(sym==interp->sym)) {
-	    int match;
-	    if ((level==0)||((interp->match&XkbSI_LevelOneOnly)==0))
-		 mods= real_mods;
-	    else mods= 0;
-	    switch (interp->match&XkbSI_OpMask) {
-		case XkbSI_NoneOf:
-		    match= ((interp->mods&mods)==0);
-		    break;
-		case XkbSI_AnyOfOrNone:
-		    match= ((mods==0)||((interp->mods&mods)!=0));
-		    break;
-		case XkbSI_AnyOf:
-		    match= ((interp->mods&mods)!=0);
-		    break;
-		case XkbSI_AllOf:
-		    match= ((interp->mods&mods)==interp->mods);
-		    break;
-		case XkbSI_Exactly:
-		    match= (interp->mods==mods);
-		    break;
-		default:
-		    match= 0;
-		    break;
-	    }
-	    if (match) {
-		if (interp->sym!=NoSymbol) {
-		    return interp;
-		}
-		else if (rtrn==NULL) {
-		    rtrn= interp;
-		}
-	    }
-	}
+    register unsigned i;
+    XkbSymInterpretPtr interp, rtrn;
+    CARD8 mods;
+
+    rtrn = NULL;
+    interp = xkb->compat->sym_interpret;
+    for (i = 0; i < xkb->compat->num_si; i++, interp++) {
+        if ((interp->sym == NoSymbol) || (sym == interp->sym)) {
+            int match;
+
+            if ((level == 0) || ((interp->match & XkbSI_LevelOneOnly) == 0))
+                mods = real_mods;
+            else
+                mods = 0;
+            switch (interp->match & XkbSI_OpMask) {
+            case XkbSI_NoneOf:
+                match = ((interp->mods & mods) == 0);
+                break;
+            case XkbSI_AnyOfOrNone:
+                match = ((mods == 0) || ((interp->mods & mods) != 0));
+                break;
+            case XkbSI_AnyOf:
+                match = ((interp->mods & mods) != 0);
+                break;
+            case XkbSI_AllOf:
+                match = ((interp->mods & mods) == interp->mods);
+                break;
+            case XkbSI_Exactly:
+                match = (interp->mods == mods);
+                break;
+            default:
+                match = 0;
+                break;
+            }
+            if (match) {
+                if (interp->sym != NoSymbol) {
+                    return interp;
+                }
+                else if (rtrn == NULL) {
+                    rtrn = interp;
+                }
+            }
+        }
     }
     return rtrn;
 }
 
 static void
-_XkbAddKeyChange(KeyCode *pFirst,unsigned char *pNum,KeyCode newKey)
+_XkbAddKeyChange(KeyCode *pFirst, unsigned char *pNum, KeyCode newKey)
 {
-KeyCode	last;
+    KeyCode last;
 
-    last= (*pFirst)+(*pNum);
-    if (newKey<*pFirst) {
-	*pFirst= newKey;
-	*pNum= (last-newKey)+1;
+    last = (*pFirst) + (*pNum);
+    if (newKey < *pFirst) {
+        *pFirst = newKey;
+        *pNum = (last - newKey) + 1;
     }
-    else if (newKey>last) {
-	*pNum= (last-*pFirst)+1;
+    else if (newKey > last) {
+        *pNum = (last - *pFirst) + 1;
     }
     return;
 }
 
 static void
-_XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
+_XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods)
 {
-unsigned	tmp;
+    unsigned tmp;
 
     switch (act->type) {
-	case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
-	    if (act->mods.flags&XkbSA_UseModMapMods)
-		act->mods.real_mods= act->mods.mask= mods;
-	    if ((tmp= XkbModActionVMods(&act->mods))!=0) {
-		XkbVirtualModsToReal(xkb,tmp,&tmp);
-		act->mods.mask|= tmp;
-	    }
-	    break;
-	case XkbSA_ISOLock:
-	    if (act->iso.flags&XkbSA_UseModMapMods)
-		act->iso.real_mods= act->iso.mask= mods;
-	    if ((tmp= XkbModActionVMods(&act->iso))!=0) {
-		XkbVirtualModsToReal(xkb,tmp,&tmp);
-		act->iso.mask|= tmp;
-	    }
-	    break;
+    case XkbSA_SetMods:
+    case XkbSA_LatchMods:
+    case XkbSA_LockMods:
+        if (act->mods.flags & XkbSA_UseModMapMods)
+            act->mods.real_mods = act->mods.mask = mods;
+        if ((tmp = XkbModActionVMods(&act->mods)) != 0) {
+            XkbVirtualModsToReal(xkb, tmp, &tmp);
+            act->mods.mask |= tmp;
+        }
+        break;
+    case XkbSA_ISOLock:
+        if (act->iso.flags & XkbSA_UseModMapMods)
+            act->iso.real_mods = act->iso.mask = mods;
+        if ((tmp = XkbModActionVMods(&act->iso)) != 0) {
+            XkbVirtualModsToReal(xkb, tmp, &tmp);
+            act->iso.mask |= tmp;
+        }
+        break;
     }
     return;
 }
@@ -363,273 +374,285 @@ unsigned	tmp;
 #define	IBUF_SIZE	8
 
 Bool
-XkbApplyCompatMapToKey(XkbDescPtr xkb,KeyCode key,XkbChangesPtr changes)
+XkbApplyCompatMapToKey(XkbDescPtr xkb, KeyCode key, XkbChangesPtr changes)
 {
-KeySym *		syms;
-unsigned char 		explicit,mods;
-XkbSymInterpretPtr	*interps,ibuf[IBUF_SIZE]; 
-int			n,nSyms,found;
-unsigned		changed,tmp;
-
-    if ((!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)||
-    			(!xkb->compat)||(!xkb->compat->sym_interpret)||
-			(key<xkb->min_key_code)||(key>xkb->max_key_code)) {
-	return FALSE;
-    }
-    if (((!xkb->server)||(!xkb->server->key_acts))&&
-		(XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success)) {
-	return FALSE;
-    }
-    changed= 0;	/* keeps track of what has changed in _this_ call */
-    explicit= xkb->server->explicit[key];
-    if (explicit&XkbExplicitInterpretMask) /* nothing to do */
-	return TRUE;
-    mods= (xkb->map->modmap?xkb->map->modmap[key]:0);
-    nSyms= XkbKeyNumSyms(xkb,key);
-    syms= XkbKeySymsPtr(xkb,key);
-    if (nSyms>IBUF_SIZE) {
-	interps= calloc(nSyms, sizeof(XkbSymInterpretPtr));
-	if (interps==NULL) {
-	    interps= ibuf;
-	    nSyms= IBUF_SIZE;
-	}
+    KeySym *syms;
+    unsigned char explicit, mods;
+    XkbSymInterpretPtr *interps, ibuf[IBUF_SIZE];
+    int n, nSyms, found;
+    unsigned changed, tmp;
+
+    if ((!xkb) || (!xkb->map) || (!xkb->map->key_sym_map) ||
+        (!xkb->compat) || (!xkb->compat->sym_interpret) ||
+        (key < xkb->min_key_code) || (key > xkb->max_key_code)) {
+        return FALSE;
+    }
+    if (((!xkb->server) || (!xkb->server->key_acts)) &&
+        (XkbAllocServerMap(xkb, XkbAllServerInfoMask, 0) != Success)) {
+        return FALSE;
+    }
+    changed = 0;                /* keeps track of what has changed in _this_ call */
+    explicit = xkb->server->explicit[key];
+    if (explicit & XkbExplicitInterpretMask)    /* nothing to do */
+        return TRUE;
+    mods = (xkb->map->modmap ? xkb->map->modmap[key] : 0);
+    nSyms = XkbKeyNumSyms(xkb, key);
+    syms = XkbKeySymsPtr(xkb, key);
+    if (nSyms > IBUF_SIZE) {
+        interps = calloc(nSyms, sizeof(XkbSymInterpretPtr));
+        if (interps == NULL) {
+            interps = ibuf;
+            nSyms = IBUF_SIZE;
+        }
     }
     else {
-	interps= ibuf;
-    }
-    found= 0;
-    for (n=0;n<nSyms;n++) {
-	unsigned level= (n%XkbKeyGroupsWidth(xkb,key));
-	interps[n]= NULL;
-	if (syms[n]!=NoSymbol) {
-	    interps[n]= _XkbFindMatchingInterp(xkb,syms[n],mods,level);
-	    if (interps[n]&&interps[n]->act.type!=XkbSA_NoAction)
-		found++;
-	    else interps[n]= NULL;
-	}
+        interps = ibuf;
+    }
+    found = 0;
+    for (n = 0; n < nSyms; n++) {
+        unsigned level = (n % XkbKeyGroupsWidth(xkb, key));
+
+        interps[n] = NULL;
+        if (syms[n] != NoSymbol) {
+            interps[n] = _XkbFindMatchingInterp(xkb, syms[n], mods, level);
+            if (interps[n] && interps[n]->act.type != XkbSA_NoAction)
+                found++;
+            else
+                interps[n] = NULL;
+        }
     }
     /* 1/28/96 (ef) -- XXX! WORKING HERE */
     if (!found) {
-	if (xkb->server->key_acts[key]!=0) {
-	    xkb->server->key_acts[key]= 0;
-	    changed|= XkbKeyActionsMask;
-	}
+        if (xkb->server->key_acts[key] != 0) {
+            xkb->server->key_acts[key] = 0;
+            changed |= XkbKeyActionsMask;
+        }
     }
     else {
-	XkbAction *pActs;
-	unsigned int	new_vmodmask;
-	changed|= XkbKeyActionsMask;
-	pActs= XkbResizeKeyActions(xkb,key,nSyms);
-	if (!pActs) {
+        XkbAction *pActs;
+        unsigned int new_vmodmask;
+
+        changed |= XkbKeyActionsMask;
+        pActs = XkbResizeKeyActions(xkb, key, nSyms);
+        if (!pActs) {
             if (nSyms > IBUF_SIZE)
                 free(interps);
-	    return FALSE;
-        }
-	new_vmodmask= 0;
-	for (n=0;n<nSyms;n++) {
-	    if (interps[n]) {
-		unsigned effMods;
-
-		pActs[n]= *((XkbAction *)&interps[n]->act);
-		if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0)) {
-		     effMods= mods;
-		     if (interps[n]->virtual_mod!=XkbNoModifier)
-			new_vmodmask|= (1<<interps[n]->virtual_mod);
-		}
-		else effMods= 0;
-		_XkbSetActionKeyMods(xkb,&pActs[n],effMods);
-	    }
-	    else pActs[n].type= XkbSA_NoAction;
-	}
-	if (((explicit&XkbExplicitVModMapMask)==0)&&
-				(xkb->server->vmodmap[key]!=new_vmodmask)) {
-	    changed|= XkbVirtualModMapMask;
-	    xkb->server->vmodmap[key]= new_vmodmask;
-	}
-	if (interps[0]) {
-	    if ((interps[0]->flags&XkbSI_LockingKey)&&
-				((explicit&XkbExplicitBehaviorMask)==0)) {
-		xkb->server->behaviors[key].type= XkbKB_Lock;
-		changed|= XkbKeyBehaviorsMask;
-	    }
-	    if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
-		CARD8 old;
-		old= BitIsOn(xkb->ctrls->per_key_repeat, key);
-		if (interps[0]->flags&XkbSI_AutoRepeat)
-		    SetBit(xkb->ctrls->per_key_repeat, key);
-		else
-		    ClearBit(xkb->ctrls->per_key_repeat, key);
-		if (changes && old != BitIsOn(xkb->ctrls->per_key_repeat, key))
-		    changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
-	    }
-	}
-    }
-    if ((!found)||(interps[0]==NULL)) {
-	if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
-	    CARD8 old;
-	    old = BitIsOn(xkb->ctrls->per_key_repeat, key);
-	    SetBit(xkb->ctrls->per_key_repeat, key);
-	    if (changes && (old != BitIsOn(xkb->ctrls->per_key_repeat, key)))
-		changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
-	}
-	if (((explicit&XkbExplicitBehaviorMask)==0)&&
-		(xkb->server->behaviors[key].type==XkbKB_Lock)) {
-		xkb->server->behaviors[key].type= XkbKB_Default;
-		changed|= XkbKeyBehaviorsMask;
-	}
+            return FALSE;
+        }
+        new_vmodmask = 0;
+        for (n = 0; n < nSyms; n++) {
+            if (interps[n]) {
+                unsigned effMods;
+
+                pActs[n] = *((XkbAction *) &interps[n]->act);
+                if ((n == 0) || ((interps[n]->match & XkbSI_LevelOneOnly) == 0)) {
+                    effMods = mods;
+                    if (interps[n]->virtual_mod != XkbNoModifier)
+                        new_vmodmask |= (1 << interps[n]->virtual_mod);
+                }
+                else
+                    effMods = 0;
+                _XkbSetActionKeyMods(xkb, &pActs[n], effMods);
+            }
+            else
+                pActs[n].type = XkbSA_NoAction;
+        }
+        if (((explicit & XkbExplicitVModMapMask) == 0) &&
+            (xkb->server->vmodmap[key] != new_vmodmask)) {
+            changed |= XkbVirtualModMapMask;
+            xkb->server->vmodmap[key] = new_vmodmask;
+        }
+        if (interps[0]) {
+            if ((interps[0]->flags & XkbSI_LockingKey) &&
+                ((explicit & XkbExplicitBehaviorMask) == 0)) {
+                xkb->server->behaviors[key].type = XkbKB_Lock;
+                changed |= XkbKeyBehaviorsMask;
+            }
+            if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
+                CARD8 old;
+
+                old = BitIsOn(xkb->ctrls->per_key_repeat, key);
+                if (interps[0]->flags & XkbSI_AutoRepeat)
+                    SetBit(xkb->ctrls->per_key_repeat, key);
+                else
+                    ClearBit(xkb->ctrls->per_key_repeat, key);
+                if (changes && old != BitIsOn(xkb->ctrls->per_key_repeat, key))
+                    changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
+            }
+        }
+    }
+    if ((!found) || (interps[0] == NULL)) {
+        if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
+            CARD8 old;
+
+            old = BitIsOn(xkb->ctrls->per_key_repeat, key);
+            SetBit(xkb->ctrls->per_key_repeat, key);
+            if (changes && (old != BitIsOn(xkb->ctrls->per_key_repeat, key)))
+                changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
+        }
+        if (((explicit & XkbExplicitBehaviorMask) == 0) &&
+            (xkb->server->behaviors[key].type == XkbKB_Lock)) {
+            xkb->server->behaviors[key].type = XkbKB_Default;
+            changed |= XkbKeyBehaviorsMask;
+        }
     }
     if (changes) {
-	XkbMapChangesPtr	mc;
-	mc= &changes->map;
-	tmp= (changed&mc->changed);
-	if (tmp&XkbKeyActionsMask)
-	    _XkbAddKeyChange(&mc->first_key_act,&mc->num_key_acts,key);
-	else if (changed&XkbKeyActionsMask) {
-	    mc->changed|= XkbKeyActionsMask;
-	    mc->first_key_act= key;
-	    mc->num_key_acts= 1;
-	}
-	if (tmp&XkbKeyBehaviorsMask) {
-	    _XkbAddKeyChange(&mc->first_key_behavior,&mc->num_key_behaviors,
-	    								key);
-	}
-	else if (changed&XkbKeyBehaviorsMask) {
-	    mc->changed|= XkbKeyBehaviorsMask;
-	    mc->first_key_behavior= key;
-	    mc->num_key_behaviors= 1;
-	}
-	if (tmp&XkbVirtualModMapMask)
-	    _XkbAddKeyChange(&mc->first_vmodmap_key,&mc->num_vmodmap_keys,key);
-	else if (changed&XkbVirtualModMapMask) {
-	    mc->changed|= XkbVirtualModMapMask;
-	    mc->first_vmodmap_key= key;
-	    mc->num_vmodmap_keys= 1;
-	}
-	mc->changed|= changed;
-    }
-    if (interps!=ibuf)
-	free(interps);
+        XkbMapChangesPtr mc;
+
+        mc = &changes->map;
+        tmp = (changed & mc->changed);
+        if (tmp & XkbKeyActionsMask)
+            _XkbAddKeyChange(&mc->first_key_act, &mc->num_key_acts, key);
+        else if (changed & XkbKeyActionsMask) {
+            mc->changed |= XkbKeyActionsMask;
+            mc->first_key_act = key;
+            mc->num_key_acts = 1;
+        }
+        if (tmp & XkbKeyBehaviorsMask) {
+            _XkbAddKeyChange(&mc->first_key_behavior, &mc->num_key_behaviors,
+                             key);
+        }
+        else if (changed & XkbKeyBehaviorsMask) {
+            mc->changed |= XkbKeyBehaviorsMask;
+            mc->first_key_behavior = key;
+            mc->num_key_behaviors = 1;
+        }
+        if (tmp & XkbVirtualModMapMask)
+            _XkbAddKeyChange(&mc->first_vmodmap_key, &mc->num_vmodmap_keys,
+                             key);
+        else if (changed & XkbVirtualModMapMask) {
+            mc->changed |= XkbVirtualModMapMask;
+            mc->first_vmodmap_key = key;
+            mc->num_vmodmap_keys = 1;
+        }
+        mc->changed |= changed;
+    }
+    if (interps != ibuf)
+        free(interps);
     return TRUE;
 }
 
 Status
-XkbChangeTypesOfKey(	XkbDescPtr		 xkb,
-			int		 	 key,
-			int			 nGroups,
-			unsigned	 	 groups,
-			int	* 	 	 newTypesIn,
-			XkbMapChangesPtr	 changes)
+XkbChangeTypesOfKey(XkbDescPtr xkb,
+                    int key,
+                    int nGroups,
+                    unsigned groups, int *newTypesIn, XkbMapChangesPtr changes)
 {
-XkbKeyTypePtr	pOldType,pNewType;
-register int	i;
-int		width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
-
-    if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) ||
-	(!xkb->map->types)||(!newTypesIn)||((groups&XkbAllGroupsMask)==0)||
-	(nGroups>XkbNumKbdGroups)) {
-	return BadMatch;
-    }
-    if (nGroups==0) {
-	for (i=0;i<XkbNumKbdGroups;i++) {
-	    xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex;
-	}
-	i= xkb->map->key_sym_map[key].group_info;
-	i= XkbSetNumGroups(i,0);
-	xkb->map->key_sym_map[key].group_info= i;
-	XkbResizeKeySyms(xkb,key,0);
-	return Success;
-    }
-
-    nOldGroups= XkbKeyNumGroups(xkb,key);
-    oldWidth= XkbKeyGroupsWidth(xkb,key);
-    for (width=i=0;i<nGroups;i++) {
-	if (groups&(1<<i))
-	     newTypes[i]=  newTypesIn[i];
-	else if (i<nOldGroups)
-	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i);
-	else if (nOldGroups>0)
-	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
-	else newTypes[i]= XkbTwoLevelIndex;
-	if (newTypes[i]>xkb->map->num_types)
-	    return BadMatch;
-	pNewType= &xkb->map->types[newTypes[i]];
-	if (pNewType->num_levels>width)
-	    width= pNewType->num_levels;
-    }
-    if ((xkb->ctrls)&&(nGroups>xkb->ctrls->num_groups))
-	xkb->ctrls->num_groups= nGroups;
-    if ((width!=oldWidth)||(nGroups!=nOldGroups)) {
-	KeySym		oldSyms[XkbMaxSymsPerKey],*pSyms;
-	int		nCopy;
-
-	if (nOldGroups==0) {
-	    pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
-	    if (pSyms!=NULL) {
-		i= xkb->map->key_sym_map[key].group_info;
-		i= XkbSetNumGroups(i,nGroups);
-		xkb->map->key_sym_map[key].group_info= i;
-		xkb->map->key_sym_map[key].width= width;
-		for (i=0;i<nGroups;i++) {
-		    xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
-		}
-		return Success;
-	    }
-	    return BadAlloc;
-	}
-	pSyms= XkbKeySymsPtr(xkb,key);
-	memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
-	pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
-	if (pSyms==NULL)
-	    return BadAlloc;
-	memset(pSyms, 0, width*nGroups*sizeof(KeySym));
-	for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
-	    pOldType= XkbKeyKeyType(xkb,key,i);
-	    pNewType= &xkb->map->types[newTypes[i]];
-	    if (pNewType->num_levels>pOldType->num_levels)
-		 nCopy= pOldType->num_levels;
-	    else nCopy= pNewType->num_levels;
-	    memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym));
-	}
-	if (XkbKeyHasActions(xkb,key)) {
-	    XkbAction	oldActs[XkbMaxSymsPerKey],*pActs;
-	    pActs= XkbKeyActionsPtr(xkb,key);
-	    memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction));
-	    pActs= XkbResizeKeyActions(xkb,key,width*nGroups);
-	    if (pActs==NULL)
-		return BadAlloc;
-	    memset(pActs, 0, width*nGroups*sizeof(XkbAction));
-	    for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
-		pOldType= XkbKeyKeyType(xkb,key,i);
-		pNewType= &xkb->map->types[newTypes[i]];
-		if (pNewType->num_levels>pOldType->num_levels)
-		     nCopy= pOldType->num_levels;
-		else nCopy= pNewType->num_levels;
-		memcpy(&pActs[i*width],&oldActs[i*oldWidth],
-						nCopy*sizeof(XkbAction));
-	    }
-	}
-	i= xkb->map->key_sym_map[key].group_info;
-	i= XkbSetNumGroups(i,nGroups);
-	xkb->map->key_sym_map[key].group_info= i;
-	xkb->map->key_sym_map[key].width= width;
-    }
-    width= 0;
-    for (i=0;i<nGroups;i++) {
-	xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
-	if (xkb->map->types[newTypes[i]].num_levels>width)
-	    width= xkb->map->types[newTypes[i]].num_levels;
-    }
-    xkb->map->key_sym_map[key].width= width;
-    if (changes!=NULL) {
-	if (changes->changed&XkbKeySymsMask) {
-	    _XkbAddKeyChange(&changes->first_key_sym,&changes->num_key_syms,
-	    								key);
-	}
-	else {
-	    changes->changed|= XkbKeySymsMask;
-	    changes->first_key_sym= key;
-	    changes->num_key_syms= 1;
-	}
+    XkbKeyTypePtr pOldType, pNewType;
+    register int i;
+    int width, nOldGroups, oldWidth, newTypes[XkbNumKbdGroups];
+
+    if ((!xkb) || (!XkbKeycodeInRange(xkb, key)) || (!xkb->map) ||
+        (!xkb->map->types) || (!newTypesIn) ||
+        ((groups & XkbAllGroupsMask) == 0) || (nGroups > XkbNumKbdGroups)) {
+        return BadMatch;
+    }
+    if (nGroups == 0) {
+        for (i = 0; i < XkbNumKbdGroups; i++) {
+            xkb->map->key_sym_map[key].kt_index[i] = XkbOneLevelIndex;
+        }
+        i = xkb->map->key_sym_map[key].group_info;
+        i = XkbSetNumGroups(i, 0);
+        xkb->map->key_sym_map[key].group_info = i;
+        XkbResizeKeySyms(xkb, key, 0);
+        return Success;
+    }
+
+    nOldGroups = XkbKeyNumGroups(xkb, key);
+    oldWidth = XkbKeyGroupsWidth(xkb, key);
+    for (width = i = 0; i < nGroups; i++) {
+        if (groups & (1 << i))
+            newTypes[i] = newTypesIn[i];
+        else if (i < nOldGroups)
+            newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, i);
+        else if (nOldGroups > 0)
+            newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
+        else
+            newTypes[i] = XkbTwoLevelIndex;
+        if (newTypes[i] > xkb->map->num_types)
+            return BadMatch;
+        pNewType = &xkb->map->types[newTypes[i]];
+        if (pNewType->num_levels > width)
+            width = pNewType->num_levels;
+    }
+    if ((xkb->ctrls) && (nGroups > xkb->ctrls->num_groups))
+        xkb->ctrls->num_groups = nGroups;
+    if ((width != oldWidth) || (nGroups != nOldGroups)) {
+        KeySym oldSyms[XkbMaxSymsPerKey], *pSyms;
+        int nCopy;
+
+        if (nOldGroups == 0) {
+            pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
+            if (pSyms != NULL) {
+                i = xkb->map->key_sym_map[key].group_info;
+                i = XkbSetNumGroups(i, nGroups);
+                xkb->map->key_sym_map[key].group_info = i;
+                xkb->map->key_sym_map[key].width = width;
+                for (i = 0; i < nGroups; i++) {
+                    xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
+                }
+                return Success;
+            }
+            return BadAlloc;
+        }
+        pSyms = XkbKeySymsPtr(xkb, key);
+        memcpy(oldSyms, pSyms, XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
+        pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
+        if (pSyms == NULL)
+            return BadAlloc;
+        memset(pSyms, 0, width * nGroups * sizeof(KeySym));
+        for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
+            pOldType = XkbKeyKeyType(xkb, key, i);
+            pNewType = &xkb->map->types[newTypes[i]];
+            if (pNewType->num_levels > pOldType->num_levels)
+                nCopy = pOldType->num_levels;
+            else
+                nCopy = pNewType->num_levels;
+            memcpy(&pSyms[i * width], &oldSyms[i * oldWidth],
+                   nCopy * sizeof(KeySym));
+        }
+        if (XkbKeyHasActions(xkb, key)) {
+            XkbAction oldActs[XkbMaxSymsPerKey], *pActs;
+
+            pActs = XkbKeyActionsPtr(xkb, key);
+            memcpy(oldActs, pActs, XkbKeyNumSyms(xkb, key) * sizeof(XkbAction));
+            pActs = XkbResizeKeyActions(xkb, key, width * nGroups);
+            if (pActs == NULL)
+                return BadAlloc;
+            memset(pActs, 0, width * nGroups * sizeof(XkbAction));
+            for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
+                pOldType = XkbKeyKeyType(xkb, key, i);
+                pNewType = &xkb->map->types[newTypes[i]];
+                if (pNewType->num_levels > pOldType->num_levels)
+                    nCopy = pOldType->num_levels;
+                else
+                    nCopy = pNewType->num_levels;
+                memcpy(&pActs[i * width], &oldActs[i * oldWidth],
+                       nCopy * sizeof(XkbAction));
+            }
+        }
+        i = xkb->map->key_sym_map[key].group_info;
+        i = XkbSetNumGroups(i, nGroups);
+        xkb->map->key_sym_map[key].group_info = i;
+        xkb->map->key_sym_map[key].width = width;
+    }
+    width = 0;
+    for (i = 0; i < nGroups; i++) {
+        xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
+        if (xkb->map->types[newTypes[i]].num_levels > width)
+            width = xkb->map->types[newTypes[i]].num_levels;
+    }
+    xkb->map->key_sym_map[key].width = width;
+    if (changes != NULL) {
+        if (changes->changed & XkbKeySymsMask) {
+            _XkbAddKeyChange(&changes->first_key_sym, &changes->num_key_syms,
+                             key);
+        }
+        else {
+            changes->changed |= XkbKeySymsMask;
+            changes->first_key_sym = key;
+            changes->num_key_syms = 1;
+        }
     }
     return Success;
 }
@@ -637,204 +660,221 @@ int		width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
 /***====================================================================***/
 
 Bool
-XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn)
+XkbVirtualModsToReal(XkbDescPtr xkb, unsigned virtual_mask, unsigned *mask_rtrn)
 {
-register int i,bit;
-register unsigned mask;
-
-    if (xkb==NULL)
-	return FALSE;
-    if (virtual_mask==0) {
-	*mask_rtrn= 0;
-	return TRUE;
-    }
-    if (xkb->server==NULL)
-	return FALSE;
-    for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (virtual_mask&bit)
-	    mask|= xkb->server->vmods[i];
-    }
-    *mask_rtrn= mask;
+    register int i, bit;
+    register unsigned mask;
+
+    if (xkb == NULL)
+        return FALSE;
+    if (virtual_mask == 0) {
+        *mask_rtrn = 0;
+        return TRUE;
+    }
+    if (xkb->server == NULL)
+        return FALSE;
+    for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (virtual_mask & bit)
+            mask |= xkb->server->vmods[i];
+    }
+    *mask_rtrn = mask;
     return TRUE;
 }
 
 /***====================================================================***/
 
 static Bool
-XkbUpdateActionVirtualMods(XkbDescPtr xkb,XkbAction *act,unsigned changed)
+XkbUpdateActionVirtualMods(XkbDescPtr xkb, XkbAction *act, unsigned changed)
 {
-unsigned int	tmp;
+    unsigned int tmp;
 
     switch (act->type) {
-	case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
-	    if (((tmp= XkbModActionVMods(&act->mods))&changed)!=0) {
-		XkbVirtualModsToReal(xkb,tmp,&tmp);
-		act->mods.mask= act->mods.real_mods;
-		act->mods.mask|= tmp;
-		return TRUE;
-	    }
-	    break;
-	case XkbSA_ISOLock:
-	    if ((((tmp= XkbModActionVMods(&act->iso))!=0)&changed)!=0) {
-		XkbVirtualModsToReal(xkb,tmp,&tmp);
-		act->iso.mask= act->iso.real_mods;
-		act->iso.mask|= tmp;
-		return TRUE;
-	    }
-	    break;
+    case XkbSA_SetMods:
+    case XkbSA_LatchMods:
+    case XkbSA_LockMods:
+        if (((tmp = XkbModActionVMods(&act->mods)) & changed) != 0) {
+            XkbVirtualModsToReal(xkb, tmp, &tmp);
+            act->mods.mask = act->mods.real_mods;
+            act->mods.mask |= tmp;
+            return TRUE;
+        }
+        break;
+    case XkbSA_ISOLock:
+        if ((((tmp = XkbModActionVMods(&act->iso)) != 0) & changed) != 0) {
+            XkbVirtualModsToReal(xkb, tmp, &tmp);
+            act->iso.mask = act->iso.real_mods;
+            act->iso.mask |= tmp;
+            return TRUE;
+        }
+        break;
     }
     return FALSE;
 }
 
 static void
-XkbUpdateKeyTypeVirtualMods(	XkbDescPtr	xkb,
-				XkbKeyTypePtr	type,
-				unsigned int	changed,
-				XkbChangesPtr 	changes)
+XkbUpdateKeyTypeVirtualMods(XkbDescPtr xkb,
+                            XkbKeyTypePtr type,
+                            unsigned int changed, XkbChangesPtr changes)
 {
-register unsigned int	i;
-unsigned int		mask;
-
-    XkbVirtualModsToReal(xkb,type->mods.vmods,&mask);
-    type->mods.mask= type->mods.real_mods|mask;
-    if ((type->map_count>0)&&(type->mods.vmods!=0)) {
-	XkbKTMapEntryPtr entry;
-	for (i=0,entry=type->map;i<type->map_count;i++,entry++) {
-	    if (entry->mods.vmods!=0) {
-		XkbVirtualModsToReal(xkb,entry->mods.vmods,&mask);
-		entry->mods.mask=entry->mods.real_mods|mask;
-		/* entry is active if vmods are bound*/
-	    	entry->active= (mask!=0);
-	    }
-	    else entry->active= 1;
-	}
+    register unsigned int i;
+    unsigned int mask;
+
+    XkbVirtualModsToReal(xkb, type->mods.vmods, &mask);
+    type->mods.mask = type->mods.real_mods | mask;
+    if ((type->map_count > 0) && (type->mods.vmods != 0)) {
+        XkbKTMapEntryPtr entry;
+
+        for (i = 0, entry = type->map; i < type->map_count; i++, entry++) {
+            if (entry->mods.vmods != 0) {
+                XkbVirtualModsToReal(xkb, entry->mods.vmods, &mask);
+                entry->mods.mask = entry->mods.real_mods | mask;
+                /* entry is active if vmods are bound */
+                entry->active = (mask != 0);
+            }
+            else
+                entry->active = 1;
+        }
     }
     if (changes) {
-	int	type_ndx;
-	type_ndx= type-xkb->map->types;
-	if ((type_ndx<0)||(type_ndx>xkb->map->num_types))
-	    return;
-	if (changes->map.changed&XkbKeyTypesMask) {
-	    int last;
-	    last= changes->map.first_type+changes->map.num_types-1;
-	    if (type_ndx<changes->map.first_type) {
-		changes->map.first_type= type_ndx;
-		changes->map.num_types= (last-type_ndx)+1;
-	    }
-	    else if (type_ndx>last) {
-		changes->map.num_types= (type_ndx-changes->map.first_type)+1;
-	    }
-	}
-	else {
-	    changes->map.changed|= XkbKeyTypesMask;
-	    changes->map.first_type= type_ndx;
-	    changes->map.num_types= 1;
-	}
+        int type_ndx;
+
+        type_ndx = type - xkb->map->types;
+        if ((type_ndx < 0) || (type_ndx > xkb->map->num_types))
+            return;
+        if (changes->map.changed & XkbKeyTypesMask) {
+            int last;
+
+            last = changes->map.first_type + changes->map.num_types - 1;
+            if (type_ndx < changes->map.first_type) {
+                changes->map.first_type = type_ndx;
+                changes->map.num_types = (last - type_ndx) + 1;
+            }
+            else if (type_ndx > last) {
+                changes->map.num_types =
+                    (type_ndx - changes->map.first_type) + 1;
+            }
+        }
+        else {
+            changes->map.changed |= XkbKeyTypesMask;
+            changes->map.first_type = type_ndx;
+            changes->map.num_types = 1;
+        }
     }
     return;
 }
 
 Bool
-XkbApplyVirtualModChanges(XkbDescPtr xkb,unsigned changed,XkbChangesPtr changes)
+XkbApplyVirtualModChanges(XkbDescPtr xkb, unsigned changed,
+                          XkbChangesPtr changes)
 {
-register int	i;
-unsigned int	checkState = 0;
-
-    if ((!xkb) || (!xkb->map) || (changed==0))
-	return FALSE;
-    for (i=0;i<xkb->map->num_types;i++) {
-	if (xkb->map->types[i].mods.vmods & changed)
-	XkbUpdateKeyTypeVirtualMods(xkb,&xkb->map->types[i],changed,changes);
-    }
-    if (changed&xkb->ctrls->internal.vmods) {
-	unsigned int	newMask;
-	XkbVirtualModsToReal(xkb,xkb->ctrls->internal.vmods,&newMask);
-	newMask|= xkb->ctrls->internal.real_mods;
-	if (xkb->ctrls->internal.mask!=newMask) {
-	    xkb->ctrls->internal.mask= newMask;
-	    if (changes) {
-		changes->ctrls.changed_ctrls|= XkbInternalModsMask;
-		checkState= TRUE;
-	    }
-	}
-    }
-    if (changed&xkb->ctrls->ignore_lock.vmods) {
-	unsigned int	newMask;
-	XkbVirtualModsToReal(xkb,xkb->ctrls->ignore_lock.vmods,&newMask);
-	newMask|= xkb->ctrls->ignore_lock.real_mods;
-	if (xkb->ctrls->ignore_lock.mask!=newMask) {
-	    xkb->ctrls->ignore_lock.mask= newMask;
-	    if (changes) {
-		changes->ctrls.changed_ctrls|= XkbIgnoreLockModsMask;
-		checkState= TRUE;
-	    }
-	}
-    }
-    if (xkb->indicators!=NULL) {
-	XkbIndicatorMapPtr map;
-	map= &xkb->indicators->maps[0];
-	for (i=0;i<XkbNumIndicators;i++,map++) {
-	    if (map->mods.vmods&changed) {
-		unsigned int newMask;
-		XkbVirtualModsToReal(xkb,map->mods.vmods,&newMask);
-		newMask|= map->mods.real_mods;
-		if (newMask!=map->mods.mask) {
-		    map->mods.mask= newMask;
-		    if (changes) {
-			changes->indicators.map_changes|= (1<<i);
-			checkState= TRUE;
-		    }
-		}
-	    }
-	}
-    }
-    if (xkb->compat!=NULL) {
-	XkbCompatMapPtr	compat;
-	compat= xkb->compat;
-	for (i=0;i<XkbNumKbdGroups;i++) {
-	    unsigned int newMask;
-	    XkbVirtualModsToReal(xkb,compat->groups[i].vmods,&newMask);
-	    newMask|= compat->groups[i].real_mods;
-	    if (compat->groups[i].mask!=newMask) {
-		compat->groups[i].mask= newMask;
-		if (changes) {
-		    changes->compat.changed_groups|= (1<<i);
-		    checkState= TRUE;
-		}
-	    }
-	}
+    register int i;
+    unsigned int checkState = 0;
+
+    if ((!xkb) || (!xkb->map) || (changed == 0))
+        return FALSE;
+    for (i = 0; i < xkb->map->num_types; i++) {
+        if (xkb->map->types[i].mods.vmods & changed)
+            XkbUpdateKeyTypeVirtualMods(xkb, &xkb->map->types[i], changed,
+                                        changes);
+    }
+    if (changed & xkb->ctrls->internal.vmods) {
+        unsigned int newMask;
+
+        XkbVirtualModsToReal(xkb, xkb->ctrls->internal.vmods, &newMask);
+        newMask |= xkb->ctrls->internal.real_mods;
+        if (xkb->ctrls->internal.mask != newMask) {
+            xkb->ctrls->internal.mask = newMask;
+            if (changes) {
+                changes->ctrls.changed_ctrls |= XkbInternalModsMask;
+                checkState = TRUE;
+            }
+        }
+    }
+    if (changed & xkb->ctrls->ignore_lock.vmods) {
+        unsigned int newMask;
+
+        XkbVirtualModsToReal(xkb, xkb->ctrls->ignore_lock.vmods, &newMask);
+        newMask |= xkb->ctrls->ignore_lock.real_mods;
+        if (xkb->ctrls->ignore_lock.mask != newMask) {
+            xkb->ctrls->ignore_lock.mask = newMask;
+            if (changes) {
+                changes->ctrls.changed_ctrls |= XkbIgnoreLockModsMask;
+                checkState = TRUE;
+            }
+        }
+    }
+    if (xkb->indicators != NULL) {
+        XkbIndicatorMapPtr map;
+
+        map = &xkb->indicators->maps[0];
+        for (i = 0; i < XkbNumIndicators; i++, map++) {
+            if (map->mods.vmods & changed) {
+                unsigned int newMask;
+
+                XkbVirtualModsToReal(xkb, map->mods.vmods, &newMask);
+                newMask |= map->mods.real_mods;
+                if (newMask != map->mods.mask) {
+                    map->mods.mask = newMask;
+                    if (changes) {
+                        changes->indicators.map_changes |= (1 << i);
+                        checkState = TRUE;
+                    }
+                }
+            }
+        }
+    }
+    if (xkb->compat != NULL) {
+        XkbCompatMapPtr compat;
+
+        compat = xkb->compat;
+        for (i = 0; i < XkbNumKbdGroups; i++) {
+            unsigned int newMask;
+
+            XkbVirtualModsToReal(xkb, compat->groups[i].vmods, &newMask);
+            newMask |= compat->groups[i].real_mods;
+            if (compat->groups[i].mask != newMask) {
+                compat->groups[i].mask = newMask;
+                if (changes) {
+                    changes->compat.changed_groups |= (1 << i);
+                    checkState = TRUE;
+                }
+            }
+        }
     }
     if (xkb->map && xkb->server) {
-	int highChange = 0, lowChange = -1;
-	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	    if (XkbKeyHasActions(xkb,i)) {
-		register XkbAction *pAct;
-		register int n;
-
-		pAct= XkbKeyActionsPtr(xkb,i);
-		for (n=XkbKeyNumActions(xkb,i);n>0;n--,pAct++) {
-		    if ((pAct->type!=XkbSA_NoAction)&&
-			XkbUpdateActionVirtualMods(xkb,pAct,changed)) {
-			if (lowChange<0)
-			    lowChange= i;
-			highChange= i;
-		    }
-		}
-	    }
-	}
-	if (changes && (lowChange>0)) { /* something changed */
-	    if (changes->map.changed&XkbKeyActionsMask) {
-		int last;
-		if (changes->map.first_key_act<lowChange)
-		    lowChange= changes->map.first_key_act;
-		last= changes->map.first_key_act+changes->map.num_key_acts-1;
-		if (last>highChange)
-		    highChange= last;
-	    }
-	    changes->map.changed|= 	XkbKeyActionsMask;
-	    changes->map.first_key_act=	lowChange;
-	    changes->map.num_key_acts=	(highChange-lowChange)+1;
-	}
+        int highChange = 0, lowChange = -1;
+
+        for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+            if (XkbKeyHasActions(xkb, i)) {
+                register XkbAction *pAct;
+                register int n;
+
+                pAct = XkbKeyActionsPtr(xkb, i);
+                for (n = XkbKeyNumActions(xkb, i); n > 0; n--, pAct++) {
+                    if ((pAct->type != XkbSA_NoAction) &&
+                        XkbUpdateActionVirtualMods(xkb, pAct, changed)) {
+                        if (lowChange < 0)
+                            lowChange = i;
+                        highChange = i;
+                    }
+                }
+            }
+        }
+        if (changes && (lowChange > 0)) {       /* something changed */
+            if (changes->map.changed & XkbKeyActionsMask) {
+                int last;
+
+                if (changes->map.first_key_act < lowChange)
+                    lowChange = changes->map.first_key_act;
+                last =
+                    changes->map.first_key_act + changes->map.num_key_acts - 1;
+                if (last > highChange)
+                    highChange = last;
+            }
+            changes->map.changed |= XkbKeyActionsMask;
+            changes->map.first_key_act = lowChange;
+            changes->map.num_key_acts = (highChange - lowChange) + 1;
+        }
     }
     return checkState;
 }
diff --git a/xorg-server/xkb/ddxBeep.c b/xorg-server/xkb/ddxBeep.c
index 6f74cb541..f95d0ee81 100644
--- a/xorg-server/xkb/ddxBeep.c
+++ b/xorg-server/xkb/ddxBeep.c
@@ -55,23 +55,23 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #define	HIGH_PITCH	2000
 #define CLICK_PITCH	1500
 
-static	unsigned long	atomGeneration= 0;
-static	Atom	featureOn;
-static	Atom	featureOff;
-static	Atom	featureChange;
-static	Atom	ledOn;
-static	Atom	ledOff;
-static	Atom	ledChange;
-static	Atom	slowWarn;
-static	Atom	slowPress;
-static	Atom	slowReject;
-static	Atom	slowAccept;
-static	Atom	slowRelease;
-static	Atom	stickyLatch;
-static	Atom	stickyLock;
-static	Atom	stickyUnlock;
-static	Atom	bounceReject;
-static  char 	doesPitch = 1;
+static unsigned long atomGeneration = 0;
+static Atom featureOn;
+static Atom featureOff;
+static Atom featureChange;
+static Atom ledOn;
+static Atom ledOff;
+static Atom ledChange;
+static Atom slowWarn;
+static Atom slowPress;
+static Atom slowReject;
+static Atom slowAccept;
+static Atom slowRelease;
+static Atom stickyLatch;
+static Atom stickyLock;
+static Atom stickyUnlock;
+static Atom bounceReject;
+static char doesPitch = 1;
 
 #define	FEATURE_ON	"AX_FeatureOn"
 #define	FEATURE_OFF	"AX_FeatureOff"
@@ -94,238 +94,257 @@ static  char 	doesPitch = 1;
 static void
 _XkbDDXBeepInitAtoms(void)
 {
-    featureOn= 		MAKE_ATOM(FEATURE_ON);
-    featureOff= 	MAKE_ATOM(FEATURE_OFF);
-    featureChange= 	MAKE_ATOM(FEATURE_CHANGE);
-    ledOn= 		MAKE_ATOM(LED_ON);
-    ledOff= 		MAKE_ATOM(LED_OFF);
-    ledChange= 		MAKE_ATOM(LED_CHANGE);
-    slowWarn= 		MAKE_ATOM(SLOW_WARN);
-    slowPress= 		MAKE_ATOM(SLOW_PRESS);
-    slowReject= 	MAKE_ATOM(SLOW_REJECT);
-    slowAccept= 	MAKE_ATOM(SLOW_ACCEPT);
-    slowRelease= 	MAKE_ATOM(SLOW_RELEASE);
-    stickyLatch= 	MAKE_ATOM(STICKY_LATCH);
-    stickyLock=		MAKE_ATOM(STICKY_LOCK);
-    stickyUnlock= 	MAKE_ATOM(STICKY_UNLOCK);
-    bounceReject= 	MAKE_ATOM(BOUNCE_REJECT);
+    featureOn = MAKE_ATOM(FEATURE_ON);
+    featureOff = MAKE_ATOM(FEATURE_OFF);
+    featureChange = MAKE_ATOM(FEATURE_CHANGE);
+    ledOn = MAKE_ATOM(LED_ON);
+    ledOff = MAKE_ATOM(LED_OFF);
+    ledChange = MAKE_ATOM(LED_CHANGE);
+    slowWarn = MAKE_ATOM(SLOW_WARN);
+    slowPress = MAKE_ATOM(SLOW_PRESS);
+    slowReject = MAKE_ATOM(SLOW_REJECT);
+    slowAccept = MAKE_ATOM(SLOW_ACCEPT);
+    slowRelease = MAKE_ATOM(SLOW_RELEASE);
+    stickyLatch = MAKE_ATOM(STICKY_LATCH);
+    stickyLock = MAKE_ATOM(STICKY_LOCK);
+    stickyUnlock = MAKE_ATOM(STICKY_UNLOCK);
+    bounceReject = MAKE_ATOM(BOUNCE_REJECT);
     return;
 }
 
 static CARD32
-_XkbDDXBeepExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbDDXBeepExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-DeviceIntPtr	dev= (DeviceIntPtr)arg;
-KbdFeedbackPtr	feed;
-KeybdCtrl *	ctrl;
-XkbSrvInfoPtr	xkbInfo;
-CARD32		next;
-int		pitch,duration;
-int		oldPitch,oldDuration;
-Atom		name;
+    DeviceIntPtr dev = (DeviceIntPtr) arg;
+    KbdFeedbackPtr feed;
+    KeybdCtrl *ctrl;
+    XkbSrvInfoPtr xkbInfo;
+    CARD32 next;
+    int pitch, duration;
+    int oldPitch, oldDuration;
+    Atom name;
 
-    if ((dev==NULL)||(dev->key==NULL)||(dev->key->xkbInfo==NULL)||
-	(dev->kbdfeed==NULL))
-	return 0;
-    if (atomGeneration!=serverGeneration) {
-	_XkbDDXBeepInitAtoms();
-	atomGeneration= serverGeneration;
+    if ((dev == NULL) || (dev->key == NULL) || (dev->key->xkbInfo == NULL) ||
+        (dev->kbdfeed == NULL))
+        return 0;
+    if (atomGeneration != serverGeneration) {
+        _XkbDDXBeepInitAtoms();
+        atomGeneration = serverGeneration;
     }
 
-    feed= dev->kbdfeed;
-    ctrl= &feed->ctrl;
-    xkbInfo= dev->key->xkbInfo;
-    next= 0;
-    pitch= oldPitch= ctrl->bell_pitch;
-    duration= oldDuration= ctrl->bell_duration;
-    name= None;
+    feed = dev->kbdfeed;
+    ctrl = &feed->ctrl;
+    xkbInfo = dev->key->xkbInfo;
+    next = 0;
+    pitch = oldPitch = ctrl->bell_pitch;
+    duration = oldDuration = ctrl->bell_duration;
+    name = None;
     switch (xkbInfo->beepType) {
-	default:
-	    ErrorF("[xkb] Unknown beep type %d\n",xkbInfo->beepType);
-	case _BEEP_NONE:
-	    duration= 0;
-	    break;
+    default:
+        ErrorF("[xkb] Unknown beep type %d\n", xkbInfo->beepType);
+    case _BEEP_NONE:
+        duration = 0;
+        break;
 
-	/* When an LED is turned on, we want a high-pitched beep.
-	 * When the LED it turned off, we want a low-pitched beep.
-	 * If we cannot do pitch, we want a single beep for on and two
-	 * beeps for off.
+        /* When an LED is turned on, we want a high-pitched beep.
+         * When the LED it turned off, we want a low-pitched beep.
+         * If we cannot do pitch, we want a single beep for on and two
+         * beeps for off.
          */
-	case _BEEP_LED_ON:
-	    if (name==None)	name= ledOn;
-	    duration= SHORT_TONE;
-	    pitch= HIGH_PITCH;
-	    break;
-	case _BEEP_LED_OFF:
-	    if (name==None)	name= ledOff;
-	    duration= SHORT_TONE;
-	    pitch= LOW_PITCH;
-	    if (!doesPitch && xkbInfo->beepCount<1)
-		next = SHORT_DELAY;	    
-	    break;
+    case _BEEP_LED_ON:
+        if (name == None)
+            name = ledOn;
+        duration = SHORT_TONE;
+        pitch = HIGH_PITCH;
+        break;
+    case _BEEP_LED_OFF:
+        if (name == None)
+            name = ledOff;
+        duration = SHORT_TONE;
+        pitch = LOW_PITCH;
+        if (!doesPitch && xkbInfo->beepCount < 1)
+            next = SHORT_DELAY;
+        break;
 
-	/* When a Feature is turned on, we want an up-siren.
-	 * When a Feature is turned off, we want a down-siren.
-	 * If we cannot do pitch, we want a single beep for on and two
-	 * beeps for off.
+        /* When a Feature is turned on, we want an up-siren.
+         * When a Feature is turned off, we want a down-siren.
+         * If we cannot do pitch, we want a single beep for on and two
+         * beeps for off.
          */
-	case _BEEP_FEATURE_ON:
-	    if (name==None)	name= featureOn;
-	    if (xkbInfo->beepCount<1) {
-		pitch= LOW_PITCH;
-		duration= VERY_LONG_TONE;
-		if (doesPitch)
-		    next= SHORT_DELAY;
-	    }
-	    else {
-		pitch= MID_PITCH;
-		duration= SHORT_TONE;
-	    }
-	    break;
+    case _BEEP_FEATURE_ON:
+        if (name == None)
+            name = featureOn;
+        if (xkbInfo->beepCount < 1) {
+            pitch = LOW_PITCH;
+            duration = VERY_LONG_TONE;
+            if (doesPitch)
+                next = SHORT_DELAY;
+        }
+        else {
+            pitch = MID_PITCH;
+            duration = SHORT_TONE;
+        }
+        break;
 
-	case _BEEP_FEATURE_OFF:
-	    if (name==None)	name= featureOff;
-	    if (xkbInfo->beepCount<1) {
-		pitch= MID_PITCH;
-		if (doesPitch)
-		     duration= VERY_LONG_TONE;
-		else duration= SHORT_TONE;
-		next= SHORT_DELAY;
-	    }
-	    else {
-		pitch= LOW_PITCH;
-		duration= SHORT_TONE;
-	    }
-	    break;
+    case _BEEP_FEATURE_OFF:
+        if (name == None)
+            name = featureOff;
+        if (xkbInfo->beepCount < 1) {
+            pitch = MID_PITCH;
+            if (doesPitch)
+                duration = VERY_LONG_TONE;
+            else
+                duration = SHORT_TONE;
+            next = SHORT_DELAY;
+        }
+        else {
+            pitch = LOW_PITCH;
+            duration = SHORT_TONE;
+        }
+        break;
 
-	/* Two high beeps indicate an LED or Feature changed
-	 * state, but that another LED or Feature is also on.
-	 * [[[WDW - This is not in AccessDOS ]]]
-	 */
-	case _BEEP_LED_CHANGE:
-            if (name==None)	name= ledChange;
-	case _BEEP_FEATURE_CHANGE:
-	    if (name==None)	name= featureChange;
-	    duration= SHORT_TONE;
-	    pitch= HIGH_PITCH;
-	    if (xkbInfo->beepCount<1) {
-		next= SHORT_DELAY;
-	    }
-            break;
+        /* Two high beeps indicate an LED or Feature changed
+         * state, but that another LED or Feature is also on.
+         * [[[WDW - This is not in AccessDOS ]]]
+         */
+    case _BEEP_LED_CHANGE:
+        if (name == None)
+            name = ledChange;
+    case _BEEP_FEATURE_CHANGE:
+        if (name == None)
+            name = featureChange;
+        duration = SHORT_TONE;
+        pitch = HIGH_PITCH;
+        if (xkbInfo->beepCount < 1) {
+            next = SHORT_DELAY;
+        }
+        break;
 
-	/* Three high-pitched beeps are the warning that SlowKeys
-	 * is going to be turned on or off.
-	 */	  
-	case _BEEP_SLOW_WARN:
-	    if (name==None)	name= slowWarn;
-	    duration= SHORT_TONE;
-	    pitch= HIGH_PITCH;
-	    if (xkbInfo->beepCount<2)
-		next= SHORT_DELAY;
-	    break;
+        /* Three high-pitched beeps are the warning that SlowKeys
+         * is going to be turned on or off.
+         */
+    case _BEEP_SLOW_WARN:
+        if (name == None)
+            name = slowWarn;
+        duration = SHORT_TONE;
+        pitch = HIGH_PITCH;
+        if (xkbInfo->beepCount < 2)
+            next = SHORT_DELAY;
+        break;
 
-	/* Click on SlowKeys press and accept.
-	 * Deep pitch when a SlowKey or BounceKey is rejected.
-	 * [[[WDW - Rejects are not in AccessDOS ]]]
-	 * If we cannot do pitch, we want single beeps.
-	 */	  
-        case _BEEP_SLOW_PRESS:
-	    if (name==None)	name= slowPress;
-	case _BEEP_SLOW_ACCEPT:
-	    if (name==None)	name= slowAccept;
-	case _BEEP_SLOW_RELEASE:
-	    if (name==None)	name= slowRelease;
-	    duration= CLICK_DURATION;
-	    pitch= CLICK_PITCH;
-	    break;
-	case _BEEP_BOUNCE_REJECT:
-	    if (name==None)	name= bounceReject;
-	case _BEEP_SLOW_REJECT:
-	    if (name==None)	name= slowReject;
-	    duration= SHORT_TONE;
-	    pitch= DEEP_PITCH;
-	    break;
+        /* Click on SlowKeys press and accept.
+         * Deep pitch when a SlowKey or BounceKey is rejected.
+         * [[[WDW - Rejects are not in AccessDOS ]]]
+         * If we cannot do pitch, we want single beeps.
+         */
+    case _BEEP_SLOW_PRESS:
+        if (name == None)
+            name = slowPress;
+    case _BEEP_SLOW_ACCEPT:
+        if (name == None)
+            name = slowAccept;
+    case _BEEP_SLOW_RELEASE:
+        if (name == None)
+            name = slowRelease;
+        duration = CLICK_DURATION;
+        pitch = CLICK_PITCH;
+        break;
+    case _BEEP_BOUNCE_REJECT:
+        if (name == None)
+            name = bounceReject;
+    case _BEEP_SLOW_REJECT:
+        if (name == None)
+            name = slowReject;
+        duration = SHORT_TONE;
+        pitch = DEEP_PITCH;
+        break;
 
-	/* Low followed by high pitch when a StickyKey is latched.
-	 * High pitch when a StickyKey is locked.
-	 * Low pitch when unlocked.
+        /* Low followed by high pitch when a StickyKey is latched.
+         * High pitch when a StickyKey is locked.
+         * Low pitch when unlocked.
          * If we cannot do pitch, two beeps for latch, nothing for
-	 * lock, and two for unlock.
-	 */	  
-	case _BEEP_STICKY_LATCH:
-	    if (name==None)	name= stickyLatch;
-	    duration= SHORT_TONE;
-	    if (xkbInfo->beepCount<1) {
-		next= SHORT_DELAY;
-		pitch= LOW_PITCH;
-	    }
-	    else pitch= HIGH_PITCH;
-	    break;
-	case _BEEP_STICKY_LOCK:
-	    if (name==None)	name= stickyLock;
-	    if (doesPitch) {
-		duration= SHORT_TONE;
-		pitch= HIGH_PITCH;
-            }
-	    break;
-	case _BEEP_STICKY_UNLOCK:
-	    if (name==None)	name= stickyUnlock;
-	    duration= SHORT_TONE;
-	    pitch= LOW_PITCH;
-	    if (!doesPitch && xkbInfo->beepCount<1)
-		next = SHORT_DELAY;	    
-	    break;
+         * lock, and two for unlock.
+         */
+    case _BEEP_STICKY_LATCH:
+        if (name == None)
+            name = stickyLatch;
+        duration = SHORT_TONE;
+        if (xkbInfo->beepCount < 1) {
+            next = SHORT_DELAY;
+            pitch = LOW_PITCH;
+        }
+        else
+            pitch = HIGH_PITCH;
+        break;
+    case _BEEP_STICKY_LOCK:
+        if (name == None)
+            name = stickyLock;
+        if (doesPitch) {
+            duration = SHORT_TONE;
+            pitch = HIGH_PITCH;
+        }
+        break;
+    case _BEEP_STICKY_UNLOCK:
+        if (name == None)
+            name = stickyUnlock;
+        duration = SHORT_TONE;
+        pitch = LOW_PITCH;
+        if (!doesPitch && xkbInfo->beepCount < 1)
+            next = SHORT_DELAY;
+        break;
     }
-    if (timer == NULL && duration>0) {
-	CARD32		starttime = GetTimeInMillis();
-	CARD32		elapsedtime;
+    if (timer == NULL && duration > 0) {
+        CARD32 starttime = GetTimeInMillis();
+        CARD32 elapsedtime;
 
-	ctrl->bell_duration= duration;
-	ctrl->bell_pitch= pitch;
-	if (xkbInfo->beepCount==0) {
-	     XkbHandleBell(0,0,dev,ctrl->bell,(pointer)ctrl,KbdFeedbackClass,name,None,
-									NULL);
-	}
-	else if (xkbInfo->desc->ctrls->enabled_ctrls&XkbAudibleBellMask) {
-	    (*dev->kbdfeed->BellProc)(ctrl->bell,dev,(pointer)ctrl,KbdFeedbackClass);
-	}
-	ctrl->bell_duration= oldDuration;
-	ctrl->bell_pitch= oldPitch;
-	xkbInfo->beepCount++;
+        ctrl->bell_duration = duration;
+        ctrl->bell_pitch = pitch;
+        if (xkbInfo->beepCount == 0) {
+            XkbHandleBell(0, 0, dev, ctrl->bell, (pointer) ctrl,
+                          KbdFeedbackClass, name, None, NULL);
+        }
+        else if (xkbInfo->desc->ctrls->enabled_ctrls & XkbAudibleBellMask) {
+            (*dev->kbdfeed->BellProc) (ctrl->bell, dev, (pointer) ctrl,
+                                       KbdFeedbackClass);
+        }
+        ctrl->bell_duration = oldDuration;
+        ctrl->bell_pitch = oldPitch;
+        xkbInfo->beepCount++;
 
-	/* Some DDX schedule the beep and return immediately, others don't
-	   return until the beep is completed.  We measure the time and if
-	   it's less than the beep duration, make sure not to schedule the
-	   next beep until after the current one finishes. */
+        /* Some DDX schedule the beep and return immediately, others don't
+           return until the beep is completed.  We measure the time and if
+           it's less than the beep duration, make sure not to schedule the
+           next beep until after the current one finishes. */
 
-	elapsedtime = GetTimeInMillis();
-	if (elapsedtime > starttime) { /* watch out for millisecond counter
-					  overflow! */
-	    elapsedtime -= starttime;
-	} else {
-	    elapsedtime = 0;
-	}
-	if (elapsedtime < duration) {
-	    next += duration - elapsedtime;
-	}
+        elapsedtime = GetTimeInMillis();
+        if (elapsedtime > starttime) {  /* watch out for millisecond counter
+                                           overflow! */
+            elapsedtime -= starttime;
+        }
+        else {
+            elapsedtime = 0;
+        }
+        if (elapsedtime < duration) {
+            next += duration - elapsedtime;
+        }
 
     }
     return next;
 }
 
 int
-XkbDDXAccessXBeep(DeviceIntPtr dev,unsigned what,unsigned which)
+XkbDDXAccessXBeep(DeviceIntPtr dev, unsigned what, unsigned which)
 {
-XkbSrvInfoRec	*xkbInfo= dev->key->xkbInfo;
-CARD32		 next;
+    XkbSrvInfoRec *xkbInfo = dev->key->xkbInfo;
+    CARD32 next;
 
-    xkbInfo->beepType= what;
-    xkbInfo->beepCount= 0;
-    next= _XkbDDXBeepExpire(NULL,0,(pointer)dev);
-    if (next>0) {
-	xkbInfo->beepTimer= TimerSet(xkbInfo->beepTimer,
-					0, next,
-					_XkbDDXBeepExpire, (pointer)dev);
+    xkbInfo->beepType = what;
+    xkbInfo->beepCount = 0;
+    next = _XkbDDXBeepExpire(NULL, 0, (pointer) dev);
+    if (next > 0) {
+        xkbInfo->beepTimer = TimerSet(xkbInfo->beepTimer,
+                                      0, next,
+                                      _XkbDDXBeepExpire, (pointer) dev);
     }
     return 1;
 }
diff --git a/xorg-server/xkb/ddxLEDs.c b/xorg-server/xkb/ddxLEDs.c
index 246d58c31..81b7b00e0 100644
--- a/xorg-server/xkb/ddxLEDs.c
+++ b/xorg-server/xkb/ddxLEDs.c
@@ -39,33 +39,33 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XI.h>
 
 static void
-XkbDDXUpdateIndicators(DeviceIntPtr dev,CARD32 new)
+XkbDDXUpdateIndicators(DeviceIntPtr dev, CARD32 new)
 {
-    dev->kbdfeed->ctrl.leds= new;
-    (*dev->kbdfeed->CtrlProc)(dev,&dev->kbdfeed->ctrl);
+    dev->kbdfeed->ctrl.leds = new;
+    (*dev->kbdfeed->CtrlProc) (dev, &dev->kbdfeed->ctrl);
     return;
 }
 
 void
-XkbDDXUpdateDeviceIndicators(	DeviceIntPtr		dev,
-				XkbSrvLedInfoPtr 	sli,
-				CARD32 			new)
+XkbDDXUpdateDeviceIndicators(DeviceIntPtr dev, XkbSrvLedInfoPtr sli, CARD32 new)
 {
-    if (sli->fb.kf==dev->kbdfeed)
-	XkbDDXUpdateIndicators(dev,new);
-    else if (sli->class==KbdFeedbackClass) {
-	KbdFeedbackPtr	kf;
-	kf= sli->fb.kf;
-	if (kf && kf->CtrlProc) {
-	    (*kf->CtrlProc)(dev,&kf->ctrl);
-	}
+    if (sli->fb.kf == dev->kbdfeed)
+        XkbDDXUpdateIndicators(dev, new);
+    else if (sli->class == KbdFeedbackClass) {
+        KbdFeedbackPtr kf;
+
+        kf = sli->fb.kf;
+        if (kf && kf->CtrlProc) {
+            (*kf->CtrlProc) (dev, &kf->ctrl);
+        }
     }
-    else if (sli->class==LedFeedbackClass) {
-	LedFeedbackPtr	lf;
-	lf= sli->fb.lf;
-	if (lf && lf->CtrlProc) {
-	    (*lf->CtrlProc)(dev,&lf->ctrl);
-	}
+    else if (sli->class == LedFeedbackClass) {
+        LedFeedbackPtr lf;
+
+        lf = sli->fb.lf;
+        if (lf && lf->CtrlProc) {
+            (*lf->CtrlProc) (dev, &lf->ctrl);
+        }
     }
     return;
 }
diff --git a/xorg-server/xkb/ddxList.c b/xorg-server/xkb/ddxList.c
index db34c8df5..9b69b2b82 100644
--- a/xorg-server/xkb/ddxList.c
+++ b/xorg-server/xkb/ddxList.c
@@ -44,8 +44,9 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #ifdef WIN32
 /* from ddxLoad.c */
-extern const char* Win32TempDir(void);
+extern const char *Win32TempDir(void);
 extern int Win32System(const char *cmdline);
+
 #undef System
 #define System Win32System
 
@@ -54,63 +55,62 @@ extern int Win32System(const char *cmdline);
 #define W32_tmplen strlen(tmpname)+3
 #else
 #define W32_tmparg
-#define W32_tmpfile 
+#define W32_tmpfile
 #define W32_tmplen 0
-#endif 
+#endif
 
 /***====================================================================***/
 
 static const char *componentDirs[_XkbListNumComponents] = {
-	"keycodes", "types", "compat", "symbols", "geometry"
+    "keycodes", "types", "compat", "symbols", "geometry"
 };
 
 /***====================================================================***/
 
 static Status
-_AddListComponent(	XkbSrvListInfoPtr	list,
-			int			what,
-			unsigned		flags,
-			char *			str,
-			ClientPtr		client)
+_AddListComponent(XkbSrvListInfoPtr list,
+                  int what, unsigned flags, char *str, ClientPtr client)
 {
-int		slen,wlen;
-unsigned char *	wire8;
-unsigned short *wire16;
-char *		tmp;
+    int slen, wlen;
+    unsigned char *wire8;
+    unsigned short *wire16;
+    char *tmp;
 
-    if (list->nTotal>=list->maxRtrn) {
-	list->nTotal++;
-	return Success;
+    if (list->nTotal >= list->maxRtrn) {
+        list->nTotal++;
+        return Success;
     }
-    tmp= strchr(str,')');
-    if ((tmp==NULL)&&((tmp=strchr(str,'('))==NULL)) {
-	slen= strlen(str);
-	while ((slen>0) && isspace(str[slen-1])) {
-	    slen--;
-	}
+    tmp = strchr(str, ')');
+    if ((tmp == NULL) && ((tmp = strchr(str, '(')) == NULL)) {
+        slen = strlen(str);
+        while ((slen > 0) && isspace(str[slen - 1])) {
+            slen--;
+        }
     }
     else {
-	slen= (tmp-str+1);
+        slen = (tmp - str + 1);
     }
-    wlen= (((slen+1)/2)*2)+4;	/* four bytes for flags and length, pad to */
-				/* 2-byte boundary */
-    if ((list->szPool-list->nPool)<wlen) {
-	if (wlen>1024)	list->szPool+= XkbPaddedSize(wlen*2);
-	else		list->szPool+= 1024;
-	list->pool= realloc(list->pool, list->szPool * sizeof(char));
-	if (!list->pool)
-	    return BadAlloc;
+    wlen = (((slen + 1) / 2) * 2) + 4;  /* four bytes for flags and length, pad to */
+    /* 2-byte boundary */
+    if ((list->szPool - list->nPool) < wlen) {
+        if (wlen > 1024)
+            list->szPool += XkbPaddedSize(wlen * 2);
+        else
+            list->szPool += 1024;
+        list->pool = realloc(list->pool, list->szPool * sizeof(char));
+        if (!list->pool)
+            return BadAlloc;
     }
-    wire16= (unsigned short *)&list->pool[list->nPool];
-    wire8= (unsigned char *)&wire16[2];
-    wire16[0]= flags;
-    wire16[1]= slen;
-    memcpy(wire8,str,slen);
+    wire16 = (unsigned short *) &list->pool[list->nPool];
+    wire8 = (unsigned char *) &wire16[2];
+    wire16[0] = flags;
+    wire16[1] = slen;
+    memcpy(wire8, str, slen);
     if (client->swapped) {
-	swaps(&wire16[0]);
-	swaps(&wire16[1]);
+        swaps(&wire16[0]);
+        swaps(&wire16[1]);
     }
-    list->nPool+= wlen;
+    list->nPool += wlen;
     list->nFound[what]++;
     list->nTotal++;
     return Success;
@@ -118,108 +118,104 @@ char *		tmp;
 
 /***====================================================================***/
 static Status
-XkbDDXListComponent(	DeviceIntPtr 		dev,
-			int			what,
-			XkbSrvListInfoPtr	list,
-			ClientPtr		client)
+XkbDDXListComponent(DeviceIntPtr dev,
+                    int what, XkbSrvListInfoPtr list, ClientPtr client)
 {
-char 	*file,*map,*tmp,*buf=NULL;
-FILE 	*in;
-Status	status;
-Bool	haveDir;
+    char *file, *map, *tmp, *buf = NULL;
+    FILE *in;
+    Status status;
+    Bool haveDir;
+
 #ifdef WIN32
-char	tmpname[PATH_MAX];
+    char tmpname[PATH_MAX];
 #else
-int	rval;
+    int rval;
 #endif
 
-    if ((list->pattern[what]==NULL)||(list->pattern[what][0]=='\0'))
-	return Success;
-    file= list->pattern[what];
-    map= strrchr(file,'(');
-    if (map!=NULL) {
-	char *tmp;
-	map++;
-	tmp= strrchr(map,')');
-	if ((tmp==NULL)||(tmp[1]!='\0')) {
-	    /* illegal pattern.  No error, but no match */
-	    return Success;
-	}
+    if ((list->pattern[what] == NULL) || (list->pattern[what][0] == '\0'))
+        return Success;
+    file = list->pattern[what];
+    map = strrchr(file, '(');
+    if (map != NULL) {
+        char *tmp;
+
+        map++;
+        tmp = strrchr(map, ')');
+        if ((tmp == NULL) || (tmp[1] != '\0')) {
+            /* illegal pattern.  No error, but no match */
+            return Success;
+        }
     }
 
-    in= NULL;
-    haveDir= TRUE;
+    in = NULL;
+    haveDir = TRUE;
 #ifdef WIN32
     strcpy(tmpname, Win32TempDir());
     strcat(tmpname, "\\xkb_XXXXXX");
     (void) mktemp(tmpname);
 #endif
-    if (XkbBaseDirectory!=NULL) {
-	if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
-	    if (asprintf(&buf, "%s/%s.dir", XkbBaseDirectory,
-			 componentDirs[what]) == -1)
-		buf = NULL;
-	    else
-		in = fopen(buf,"r");
-	}
-	if (!in) {
-	    haveDir= FALSE;
-	    free(buf);
-	    if (asprintf
-		(&buf,
-		 "'%s/xkbcomp' '-R%s/%s' -w %ld -l -vlfhpR '%s'" W32_tmparg,
-		 XkbBinDirectory, XkbBaseDirectory, componentDirs[what],
-		 (long) ((xkbDebugFlags < 2) ? 1 :
-			 ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
-		 file W32_tmpfile
-		    ) == -1)
-		buf = NULL;
-	}
+    if (XkbBaseDirectory != NULL) {
+        if ((list->pattern[what][0] == '*') && (list->pattern[what][1] == '\0')) {
+            if (asprintf(&buf, "%s/%s.dir", XkbBaseDirectory,
+                         componentDirs[what]) == -1)
+                buf = NULL;
+            else
+                in = fopen(buf, "r");
+        }
+        if (!in) {
+            haveDir = FALSE;
+            free(buf);
+            if (asprintf
+                (&buf,
+                 "'%s/xkbcomp' '-R%s/%s' -w %ld -l -vlfhpR '%s'" W32_tmparg,
+                 XkbBinDirectory, XkbBaseDirectory, componentDirs[what],
+                 (long) ((xkbDebugFlags < 2) ? 1 :
+                         ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
+                 file W32_tmpfile) == -1)
+                buf = NULL;
+        }
     }
     else {
-	if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
-	    if (asprintf(&buf, "%s.dir", componentDirs[what]) == -1)
-		buf = NULL;
-	    else
-		in = fopen(buf,"r");
-	}
-	if (!in) {
-	    haveDir= FALSE;
-	    free(buf);
-	    if (asprintf
-		(&buf,
-		 "xkbcomp -R%s -w %ld -l -vlfhpR '%s'" W32_tmparg,
-		 componentDirs[what],
-		 (long)	((xkbDebugFlags < 2) ? 1 :
-			 ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
-		 file W32_tmpfile
-		    ) == -1)
-		buf = NULL;
-	}
+        if ((list->pattern[what][0] == '*') && (list->pattern[what][1] == '\0')) {
+            if (asprintf(&buf, "%s.dir", componentDirs[what]) == -1)
+                buf = NULL;
+            else
+                in = fopen(buf, "r");
+        }
+        if (!in) {
+            haveDir = FALSE;
+            free(buf);
+            if (asprintf
+                (&buf,
+                 "xkbcomp -R%s -w %ld -l -vlfhpR '%s'" W32_tmparg,
+                 componentDirs[what],
+                 (long) ((xkbDebugFlags < 2) ? 1 :
+                         ((xkbDebugFlags > 10) ? 10 : xkbDebugFlags)),
+                 file W32_tmpfile) == -1)
+                buf = NULL;
+        }
     }
-    status= Success;
-    if (!haveDir)
-    {  
+    status = Success;
+    if (!haveDir) {
 #ifndef WIN32
-	in= Popen(buf,"r");
+        in = Popen(buf, "r");
 #else
         if (xkbDebugFlags)
-            DebugF("[xkb] xkbList executes: %s\n",buf);
-	if (System(buf) < 0)
-	    ErrorF("[xkb] Could not invoke keymap compiler\n");
-	else
-	    in= fopen(tmpname, "r");
+            DebugF("[xkb] xkbList executes: %s\n", buf);
+        if (System(buf) < 0)
+            ErrorF("[xkb] Could not invoke keymap compiler\n");
+        else
+            in = fopen(tmpname, "r");
 #endif
     }
-    if (!in)
-    {
-	free(buf);
+    if (!in) {
+        free(buf);
 #ifdef WIN32
-	unlink(tmpname);
+        unlink(tmpname);
 #endif
-	return BadImplementation;
+        return BadImplementation;
     }
-    list->nFound[what]= 0;
+    list->nFound[what] = 0;
     free(buf);
     buf = malloc(PATH_MAX * sizeof(char));
     if (!buf) {
@@ -229,53 +225,61 @@ int	rval;
 #endif
         return BadAlloc;
     }
-    while ((status==Success)&&((tmp=fgets(buf,PATH_MAX,in))!=NULL)) {
-	unsigned flags;
-	register unsigned int i;
-	if (*tmp=='#') /* comment, skip it */
-	    continue;
-	if (!strncmp(tmp, "Warning:", 8) || !strncmp(tmp, "        ", 8))
-	    /* skip warnings too */
-	    continue;
-	flags= 0;
-	/* each line in the listing is supposed to start with two */
-	/* groups of eight characters, which specify the general  */
-	/* flags and the flags that are specific to the component */
-	/* if they're missing, fail with BadImplementation	  */
-	for (i=0;(i<8)&&(status==Success);i++) { /* read the general flags */
-	   if (isalpha(*tmp))	flags|= (1L<<i);
-	   else if (*tmp!='-')	status= BadImplementation;
-	   tmp++;
-	}
-	if (status != Success)  break;
-	if (!isspace(*tmp)) {
-	     status= BadImplementation;
-	     break;
-	}
-	else tmp++;
-	for (i=0;(i<8)&&(status==Success);i++) { /* read the component flags */
-	   if (isalpha(*tmp))	flags|= (1L<<(i+8));
-	   else if (*tmp!='-')	status= BadImplementation;
-	   tmp++;
-	}
-	if (status != Success)  break;
-	if (isspace(*tmp)) {
-	    while (isspace(*tmp)) {
-		tmp++;
-	    }
-	}
-	else {
-	    status= BadImplementation;
-	    break;
-	}
-	status= _AddListComponent(list,what,flags,tmp,client);
+    while ((status == Success) && ((tmp = fgets(buf, PATH_MAX, in)) != NULL)) {
+        unsigned flags;
+        register unsigned int i;
+
+        if (*tmp == '#')        /* comment, skip it */
+            continue;
+        if (!strncmp(tmp, "Warning:", 8) || !strncmp(tmp, "        ", 8))
+            /* skip warnings too */
+            continue;
+        flags = 0;
+        /* each line in the listing is supposed to start with two */
+        /* groups of eight characters, which specify the general  */
+        /* flags and the flags that are specific to the component */
+        /* if they're missing, fail with BadImplementation        */
+        for (i = 0; (i < 8) && (status == Success); i++) {      /* read the general flags */
+            if (isalpha(*tmp))
+                flags |= (1L << i);
+            else if (*tmp != '-')
+                status = BadImplementation;
+            tmp++;
+        }
+        if (status != Success)
+            break;
+        if (!isspace(*tmp)) {
+            status = BadImplementation;
+            break;
+        }
+        else
+            tmp++;
+        for (i = 0; (i < 8) && (status == Success); i++) {      /* read the component flags */
+            if (isalpha(*tmp))
+                flags |= (1L << (i + 8));
+            else if (*tmp != '-')
+                status = BadImplementation;
+            tmp++;
+        }
+        if (status != Success)
+            break;
+        if (isspace(*tmp)) {
+            while (isspace(*tmp)) {
+                tmp++;
+            }
+        }
+        else {
+            status = BadImplementation;
+            break;
+        }
+        status = _AddListComponent(list, what, flags, tmp, client);
     }
 #ifndef WIN32
     if (haveDir)
-	fclose(in);
-    else if ((rval=Pclose(in))!=0) {
-	if (xkbDebugFlags)
-	    ErrorF("[xkb] xkbcomp returned exit code %d\n",rval);
+        fclose(in);
+    else if ((rval = Pclose(in)) != 0) {
+        if (xkbDebugFlags)
+            ErrorF("[xkb] xkbcomp returned exit code %d\n", rval);
     }
 #else
     fclose(in);
@@ -289,18 +293,18 @@ int	rval;
 
 /* ARGSUSED */
 Status
-XkbDDXList(DeviceIntPtr	dev,XkbSrvListInfoPtr list,ClientPtr client)
+XkbDDXList(DeviceIntPtr dev, XkbSrvListInfoPtr list, ClientPtr client)
 {
-Status	status;
+    Status status;
 
-    status= XkbDDXListComponent(dev,_XkbListKeycodes,list,client);
-    if (status==Success)
-	status= XkbDDXListComponent(dev,_XkbListTypes,list,client);
-    if (status==Success)
-	status= XkbDDXListComponent(dev,_XkbListCompat,list,client);
-    if (status==Success)
-	status= XkbDDXListComponent(dev,_XkbListSymbols,list,client);
-    if (status==Success)
-	status= XkbDDXListComponent(dev,_XkbListGeometry,list,client);
+    status = XkbDDXListComponent(dev, _XkbListKeycodes, list, client);
+    if (status == Success)
+        status = XkbDDXListComponent(dev, _XkbListTypes, list, client);
+    if (status == Success)
+        status = XkbDDXListComponent(dev, _XkbListCompat, list, client);
+    if (status == Success)
+        status = XkbDDXListComponent(dev, _XkbListSymbols, list, client);
+    if (status == Success)
+        status = XkbDDXListComponent(dev, _XkbListGeometry, list, client);
     return status;
 }
diff --git a/xorg-server/xkb/ddxLoad.c b/xorg-server/xkb/ddxLoad.c
index 196142318..cb2dfc31c 100644
--- a/xorg-server/xkb/ddxLoad.c
+++ b/xorg-server/xkb/ddxLoad.c
@@ -45,14 +45,14 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XI.h>
 #include "xkb.h"
 
-	/*
-	 * If XKM_OUTPUT_DIR specifies a path without a leading slash, it is
-	 * relative to the top-level XKB configuration directory.
-	 * Making the server write to a subdirectory of that directory
-	 * requires some work in the general case (install procedure
-	 * has to create links to /var or somesuch on many machines),
-	 * so we just compile into /usr/tmp for now.
-	 */
+        /*
+         * If XKM_OUTPUT_DIR specifies a path without a leading slash, it is
+         * relative to the top-level XKB configuration directory.
+         * Making the server write to a subdirectory of that directory
+         * requires some work in the general case (install procedure
+         * has to create links to /var or somesuch on many machines),
+         * so we just compile into /usr/tmp for now.
+         */
 #ifndef XKM_OUTPUT_DIR
 #define	XKM_OUTPUT_DIR	"compiled/"
 #endif
@@ -71,18 +71,19 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #ifdef WIN32
 
 #include <X11/Xwindows.h>
-const char* 
+const char *
 Win32TempDir()
 {
     static char buffer[PATH_MAX];
-    if (GetTempPath(sizeof(buffer), buffer))
-    {
+
+    if (GetTempPath(sizeof(buffer), buffer)) {
         int len;
-        buffer[sizeof(buffer)-1] = 0;
+
+        buffer[sizeof(buffer) - 1] = 0;
         len = strlen(buffer);
         if (len > 0)
-            if (buffer[len-1] == '\\')
-                buffer[len-1] = 0;
+            if (buffer[len - 1] == '\\')
+                buffer[len - 1] = 0;
         return buffer;
     }
     if (getenv("TEMP") != NULL)
@@ -93,7 +94,7 @@ Win32TempDir()
         return "/tmp";
 }
 
-int 
+int
 Win32System(const char *cmdline)
 {
     STARTUPINFO si;
@@ -101,90 +102,82 @@ Win32System(const char *cmdline)
     DWORD dwExitCode;
     char *cmd = strdup(cmdline);
 
-    ZeroMemory( &si, sizeof(si) );
+    ZeroMemory(&si, sizeof(si));
     si.cb = sizeof(si);
-    ZeroMemory( &pi, sizeof(pi) );
-
-    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) 
-    {
-	LPVOID buffer;
-	if (!FormatMessage( 
-		    FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-		    FORMAT_MESSAGE_FROM_SYSTEM | 
-		    FORMAT_MESSAGE_IGNORE_INSERTS,
-		    NULL,
-		    GetLastError(),
-		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-		    (LPTSTR) &buffer,
-		    0,
-		    NULL ))
-	{
-	    ErrorF("[xkb] Starting '%s' failed!\n", cmdline); 
-	}
-	else
-	{
-	    ErrorF("[xkb] Starting '%s' failed: %s", cmdline, (char *)buffer); 
-	    LocalFree(buffer);
-	}
-
-	free(cmd);
-	return -1;
+    ZeroMemory(&pi, sizeof(pi));
+
+    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
+        LPVOID buffer;
+
+        if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                           FORMAT_MESSAGE_FROM_SYSTEM |
+                           FORMAT_MESSAGE_IGNORE_INSERTS,
+                           NULL,
+                           GetLastError(),
+                           MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                           (LPTSTR) & buffer, 0, NULL)) {
+            ErrorF("[xkb] Starting '%s' failed!\n", cmdline);
+        }
+        else {
+            ErrorF("[xkb] Starting '%s' failed: %s", cmdline, (char *) buffer);
+            LocalFree(buffer);
+        }
+
+        free(cmd);
+        return -1;
     }
     /* Wait until child process exits. */
-    WaitForSingleObject( pi.hProcess, INFINITE );
+    WaitForSingleObject(pi.hProcess, INFINITE);
+
+    GetExitCodeProcess(pi.hProcess, &dwExitCode);
 
-    GetExitCodeProcess( pi.hProcess, &dwExitCode);
-    
     /* Close process and thread handles. */
-    CloseHandle( pi.hProcess );
-    CloseHandle( pi.hThread );
+    CloseHandle(pi.hProcess);
+    CloseHandle(pi.hThread);
     free(cmd);
 
     return dwExitCode;
 }
+
 #undef System
 #define System(x) Win32System(x)
 #endif
 
 static void
-OutputDirectory(
-    char* outdir,
-    size_t size)
+OutputDirectory(char *outdir, size_t size)
 {
 #ifndef WIN32
     /* Can we write an xkm and then open it too? */
-    if (access(XKM_OUTPUT_DIR, W_OK | X_OK) == 0 && (strlen(XKM_OUTPUT_DIR) < size))
-    {
-	(void) strcpy (outdir, XKM_OUTPUT_DIR);
-    } else
+    if (access(XKM_OUTPUT_DIR, W_OK | X_OK) == 0 &&
+        (strlen(XKM_OUTPUT_DIR) < size)) {
+        (void) strcpy(outdir, XKM_OUTPUT_DIR);
+    }
+    else
 #else
-    if (strlen(Win32TempDir()) + 1 < size)
-    {
-	(void) strcpy(outdir, Win32TempDir());
-	(void) strcat(outdir, "\\");
-    } else 
+    if (strlen(Win32TempDir()) + 1 < size) {
+        (void) strcpy(outdir, Win32TempDir());
+        (void) strcat(outdir, "\\");
+    }
+    else
 #endif
-    if (strlen("/tmp/") < size)
-    {
-	(void) strcpy (outdir, "/tmp/");
+    if (strlen("/tmp/") < size) {
+        (void) strcpy(outdir, "/tmp/");
     }
 }
 
 static Bool
-XkbDDXCompileKeymapByNames(	XkbDescPtr		xkb,
-				XkbComponentNamesPtr	names,
-				unsigned		want,
-				unsigned		need,
-				char *			nameRtrn,
-				int			nameRtrnLen)
+XkbDDXCompileKeymapByNames(XkbDescPtr xkb,
+                           XkbComponentNamesPtr names,
+                           unsigned want,
+                           unsigned need, char *nameRtrn, int nameRtrnLen)
 {
-    FILE *	out;
-    char	*buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX];
+    FILE *out;
+    char *buf = NULL, keymap[PATH_MAX], xkm_output_dir[PATH_MAX];
 
-    const char	*emptystring = "";
+    const char *emptystring = "";
     char *xkbbasedirflag = NULL;
-    const char	*xkbbindir = emptystring;
-    const char	*xkbbindirsep = emptystring;
+    const char *xkbbindir = emptystring;
+    const char *xkbbindirsep = emptystring;
 
 #ifdef WIN32
     /* WIN32 has no popen. The input must be stored in a file which is
@@ -206,73 +199,73 @@ XkbDDXCompileKeymapByNames(	XkbDescPtr		xkb,
 #endif
 
     if (XkbBaseDirectory != NULL) {
-	if (asprintf(&xkbbasedirflag, "\"-R%s\"", XkbBaseDirectory) == -1)
-	    xkbbasedirflag = NULL;
+        if (asprintf(&xkbbasedirflag, "\"-R%s\"", XkbBaseDirectory) == -1)
+            xkbbasedirflag = NULL;
     }
 
     if (XkbBinDirectory != NULL) {
-	int ld = strlen(XkbBinDirectory);
-	int lps = strlen(PATHSEPARATOR);
+        int ld = strlen(XkbBinDirectory);
+        int lps = strlen(PATHSEPARATOR);
 
-	xkbbindir = XkbBinDirectory;
+        xkbbindir = XkbBinDirectory;
 
-	if ((ld >= lps) &&
-	    (strcmp(xkbbindir + ld - lps, PATHSEPARATOR) != 0)) {
-	    xkbbindirsep = PATHSEPARATOR;
-	}
+        if ((ld >= lps) && (strcmp(xkbbindir + ld - lps, PATHSEPARATOR) != 0)) {
+            xkbbindirsep = PATHSEPARATOR;
+        }
     }
 
     if (asprintf(&buf,
-		 "\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" "
-		  "-em1 %s -emp %s -eml %s \"%s%s.xkm\"",
-		 xkbbindir, xkbbindirsep,
-		 ((xkbDebugFlags < 2) ? 1 :
-		  ((xkbDebugFlags > 10) ? 10 : (int) xkbDebugFlags)),
-		 xkbbasedirflag ? xkbbasedirflag : "", xkmfile,
-		 PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1,
-		 xkm_output_dir, keymap) == -1)
-	buf = NULL;
+                 "\"%s%sxkbcomp\" -w %d %s -xkm \"%s\" "
+                 "-em1 %s -emp %s -eml %s \"%s%s.xkm\"",
+                 xkbbindir, xkbbindirsep,
+                 ((xkbDebugFlags < 2) ? 1 :
+                  ((xkbDebugFlags > 10) ? 10 : (int) xkbDebugFlags)),
+                 xkbbasedirflag ? xkbbasedirflag : "", xkmfile,
+                 PRE_ERROR_MSG, ERROR_PREFIX, POST_ERROR_MSG1,
+                 xkm_output_dir, keymap) == -1)
+        buf = NULL;
 
     free(xkbbasedirflag);
 
     if (!buf) {
-        LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp: not enough memory\n");
+        LogMessage(X_ERROR,
+                   "XKB: Could not invoke xkbcomp: not enough memory\n");
         return FALSE;
     }
-    
+
 #ifndef WIN32
-    out= Popen(buf,"w");
+    out = Popen(buf, "w");
 #else
-    out= fopen(tmpname, "w");
+    out = fopen(tmpname, "w");
 #endif
-    
-    if (out!=NULL) {
+
+    if (out != NULL) {
 #ifdef DEBUG
-    if (xkbDebugFlags) {
-       ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n");
-       XkbWriteXKBKeymapForNames(stderr,names,xkb,want,need);
-    }
+        if (xkbDebugFlags) {
+            ErrorF("[xkb] XkbDDXCompileKeymapByNames compiling keymap:\n");
+            XkbWriteXKBKeymapForNames(stderr, names, xkb, want, need);
+        }
 #endif
-	XkbWriteXKBKeymapForNames(out,names,xkb,want,need);
+        XkbWriteXKBKeymapForNames(out, names, xkb, want, need);
 #ifndef WIN32
-	if (Pclose(out)==0)
+        if (Pclose(out) == 0)
 #else
-	if (fclose(out)==0 && System(buf) >= 0)
+        if (fclose(out) == 0 && System(buf) >= 0)
 #endif
-	{
+        {
             if (xkbDebugFlags)
-                DebugF("[xkb] xkb executes: %s\n",buf);
-	    if (nameRtrn) {
-		strlcpy(nameRtrn,keymap,nameRtrnLen);
-	    }
+                DebugF("[xkb] xkb executes: %s\n", buf);
+            if (nameRtrn) {
+                strlcpy(nameRtrn, keymap, nameRtrnLen);
+            }
             free(buf);
 #ifdef WIN32
-	    unlink(tmpname);
+            unlink(tmpname);
 #endif
-	    return TRUE;
-	}
-	else
-	    LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap);
+            return TRUE;
+        }
+        else
+            LogMessage(X_ERROR, "Error compiling keymap (%s)\n", keymap);
 #ifdef WIN32
         /* remove the temporary file */
         unlink(tmpname);
@@ -280,115 +273,117 @@ XkbDDXCompileKeymapByNames(	XkbDescPtr		xkb,
     }
     else {
 #ifndef WIN32
-	LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp\n");
+        LogMessage(X_ERROR, "XKB: Could not invoke xkbcomp\n");
 #else
-	LogMessage(X_ERROR, "Could not open file %s\n", tmpname);
+        LogMessage(X_ERROR, "Could not open file %s\n", tmpname);
 #endif
     }
     if (nameRtrn)
-	nameRtrn[0]= '\0';
+        nameRtrn[0] = '\0';
     free(buf);
     return FALSE;
 }
 
 static FILE *
-XkbDDXOpenConfigFile(char *mapName,char *fileNameRtrn,int fileNameRtrnLen)
+XkbDDXOpenConfigFile(char *mapName, char *fileNameRtrn, int fileNameRtrnLen)
 {
-char	buf[PATH_MAX],xkm_output_dir[PATH_MAX];
-FILE *	file;
+    char buf[PATH_MAX], xkm_output_dir[PATH_MAX];
+    FILE *file;
 
-    buf[0]= '\0';
-    if (mapName!=NULL) {
-	OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir));
-	if ((XkbBaseDirectory!=NULL)&&(xkm_output_dir[0]!='/')
+    buf[0] = '\0';
+    if (mapName != NULL) {
+        OutputDirectory(xkm_output_dir, sizeof(xkm_output_dir));
+        if ((XkbBaseDirectory != NULL) && (xkm_output_dir[0] != '/')
 #ifdef WIN32
-                &&(!isalpha(xkm_output_dir[0]) || xkm_output_dir[1]!=':')
+            && (!isalpha(xkm_output_dir[0]) || xkm_output_dir[1] != ':')
 #endif
-                ) {
+            ) {
             if (snprintf(buf, PATH_MAX, "%s/%s%s.xkm", XkbBaseDirectory,
                          xkm_output_dir, mapName) >= PATH_MAX)
                 buf[0] = '\0';
-	}
-	else
-	{
+        }
+        else {
             if (snprintf(buf, PATH_MAX, "%s%s.xkm", xkm_output_dir, mapName)
                 >= PATH_MAX)
                 buf[0] = '\0';
-	}
-	if (buf[0] != '\0')
-	    file= fopen(buf,"rb");
-	else file= NULL;
+        }
+        if (buf[0] != '\0')
+            file = fopen(buf, "rb");
+        else
+            file = NULL;
     }
-    else file= NULL;
-    if ((fileNameRtrn!=NULL)&&(fileNameRtrnLen>0)) {
-	strlcpy(fileNameRtrn,buf,fileNameRtrnLen);
+    else
+        file = NULL;
+    if ((fileNameRtrn != NULL) && (fileNameRtrnLen > 0)) {
+        strlcpy(fileNameRtrn, buf, fileNameRtrnLen);
     }
     return file;
 }
 
 unsigned
-XkbDDXLoadKeymapByNames(	DeviceIntPtr		keybd,
-				XkbComponentNamesPtr	names,
-				unsigned		want,
-				unsigned		need,
-				XkbDescPtr *		xkbRtrn,
-				char *			nameRtrn,
-				int 			nameRtrnLen)
+XkbDDXLoadKeymapByNames(DeviceIntPtr keybd,
+                        XkbComponentNamesPtr names,
+                        unsigned want,
+                        unsigned need,
+                        XkbDescPtr *xkbRtrn, char *nameRtrn, int nameRtrnLen)
 {
-XkbDescPtr      xkb;
-FILE	*	file;
-char		fileName[PATH_MAX];
-unsigned	missing;
+    XkbDescPtr xkb;
+    FILE *file;
+    char fileName[PATH_MAX];
+    unsigned missing;
 
     *xkbRtrn = NULL;
-    if ((keybd==NULL)||(keybd->key==NULL)||(keybd->key->xkbInfo==NULL))
-	 xkb= NULL;
-    else xkb= keybd->key->xkbInfo->desc;
-    if ((names->keycodes==NULL)&&(names->types==NULL)&&
-	(names->compat==NULL)&&(names->symbols==NULL)&&
-	(names->geometry==NULL)) {
+    if ((keybd == NULL) || (keybd->key == NULL) ||
+        (keybd->key->xkbInfo == NULL))
+        xkb = NULL;
+    else
+        xkb = keybd->key->xkbInfo->desc;
+    if ((names->keycodes == NULL) && (names->types == NULL) &&
+        (names->compat == NULL) && (names->symbols == NULL) &&
+        (names->geometry == NULL)) {
         LogMessage(X_ERROR, "XKB: No components provided for device %s\n",
                    keybd->name ? keybd->name : "(unnamed keyboard)");
         return 0;
     }
-    else if (!XkbDDXCompileKeymapByNames(xkb,names,want,need,
-                                         nameRtrn,nameRtrnLen)){
-	LogMessage(X_ERROR, "XKB: Couldn't compile keymap\n");
-	return 0;
+    else if (!XkbDDXCompileKeymapByNames(xkb, names, want, need,
+                                         nameRtrn, nameRtrnLen)) {
+        LogMessage(X_ERROR, "XKB: Couldn't compile keymap\n");
+        return 0;
     }
-    file= XkbDDXOpenConfigFile(nameRtrn,fileName,PATH_MAX);
-    if (file==NULL) {
-	LogMessage(X_ERROR, "Couldn't open compiled keymap file %s\n",fileName);
-	return 0;
+    file = XkbDDXOpenConfigFile(nameRtrn, fileName, PATH_MAX);
+    if (file == NULL) {
+        LogMessage(X_ERROR, "Couldn't open compiled keymap file %s\n",
+                   fileName);
+        return 0;
     }
-    missing= XkmReadFile(file,need,want,xkbRtrn);
-    if (*xkbRtrn==NULL) {
-	LogMessage(X_ERROR, "Error loading keymap %s\n",fileName);
-	fclose(file);
-	(void) unlink (fileName);
-	return 0;
+    missing = XkmReadFile(file, need, want, xkbRtrn);
+    if (*xkbRtrn == NULL) {
+        LogMessage(X_ERROR, "Error loading keymap %s\n", fileName);
+        fclose(file);
+        (void) unlink(fileName);
+        return 0;
     }
     else {
-	DebugF("Loaded XKB keymap %s, defined=0x%x\n",fileName,(*xkbRtrn)->defined);
+        DebugF("Loaded XKB keymap %s, defined=0x%x\n", fileName,
+               (*xkbRtrn)->defined);
     }
     fclose(file);
-    (void) unlink (fileName);
-    return (need|want)&(~missing);
+    (void) unlink(fileName);
+    return (need | want) & (~missing);
 }
 
 Bool
-XkbDDXNamesFromRules(	DeviceIntPtr		keybd,
-			char *			rules_name,
-			XkbRF_VarDefsPtr	defs,
-			XkbComponentNamesPtr	names)
+XkbDDXNamesFromRules(DeviceIntPtr keybd,
+                     char *rules_name,
+                     XkbRF_VarDefsPtr defs, XkbComponentNamesPtr names)
 {
-char 		buf[PATH_MAX];
-FILE *		file;
-Bool		complete;
-XkbRF_RulesPtr	rules;
+    char buf[PATH_MAX];
+    FILE *file;
+    Bool complete;
+    XkbRF_RulesPtr rules;
 
     if (!rules_name)
-	return FALSE;
+        return FALSE;
 
     if (snprintf(buf, PATH_MAX, "%s/rules/%s", XkbBaseDirectory, rules_name)
         >= PATH_MAX) {
@@ -399,25 +394,25 @@ XkbRF_RulesPtr	rules;
     file = fopen(buf, "r");
     if (!file) {
         LogMessage(X_ERROR, "XKB: Couldn't open rules file %s\n", buf);
-	return FALSE;
+        return FALSE;
     }
 
     rules = XkbRF_Create();
     if (!rules) {
         LogMessage(X_ERROR, "XKB: Couldn't create rules struct\n");
-	fclose(file);
-	return FALSE;
+        fclose(file);
+        return FALSE;
     }
 
     if (!XkbRF_LoadRules(file, rules)) {
         LogMessage(X_ERROR, "XKB: Couldn't parse rules file %s\n", rules_name);
-	fclose(file);
-	XkbRF_Free(rules,TRUE);
-	return FALSE;
+        fclose(file);
+        XkbRF_Free(rules, TRUE);
+        return FALSE;
     }
 
     memset(names, 0, sizeof(*names));
-    complete = XkbRF_GetComponents(rules,defs,names);
+    complete = XkbRF_GetComponents(rules, defs, names);
     fclose(file);
     XkbRF_Free(rules, TRUE);
 
@@ -428,7 +423,8 @@ XkbRF_RulesPtr	rules;
 }
 
 static Bool
-XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, XkbComponentNamesPtr kccgst)
+XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet * rmlvo,
+                 XkbComponentNamesPtr kccgst)
 {
     XkbRF_VarDefsRec mlvo;
 
@@ -446,16 +442,17 @@ XkbRMLVOtoKcCGST(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, XkbComponentNamesPtr kccg
  * or equal to need, the compiliation is treated as failure.
  */
 static XkbDescPtr
-XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, int need)
+XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet * rmlvo, int need)
 {
     XkbDescPtr xkb = NULL;
     unsigned int provided;
-    XkbComponentNamesRec kccgst = {0};
+    XkbComponentNamesRec kccgst = { 0 };
     char name[PATH_MAX];
 
     if (XkbRMLVOtoKcCGST(dev, rmlvo, &kccgst)) {
-        provided = XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, need,
-                                           &xkb, name, PATH_MAX);
+        provided =
+            XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, need, &xkb,
+                                    name, PATH_MAX);
         if ((need & provided) != need) {
             if (xkb) {
                 XkbFreeKeyboard(xkb, 0, TRUE);
@@ -469,7 +466,7 @@ XkbCompileKeymapForDevice(DeviceIntPtr dev, XkbRMLVOSet *rmlvo, int need)
 }
 
 XkbDescPtr
-XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo)
+XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet * rmlvo)
 {
     XkbDescPtr xkb;
     unsigned int need;
@@ -481,8 +478,7 @@ XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo)
 
     /* These are the components we really really need */
     need = XkmSymbolsMask | XkmCompatMapMask | XkmTypesMask |
-           XkmKeyNamesMask | XkmVirtualModsMask;
-
+        XkmKeyNamesMask | XkmVirtualModsMask;
 
     xkb = XkbCompileKeymapForDevice(dev, rmlvo, need);
 
diff --git a/xorg-server/xkb/maprules.c b/xorg-server/xkb/maprules.c
index 66800478c..c6900eccb 100644
--- a/xorg-server/xkb/maprules.c
+++ b/xorg-server/xkb/maprules.c
@@ -52,54 +52,52 @@
 
 /***====================================================================***/
 
-
-
 #define DFLT_LINE_SIZE	128
 
 typedef struct {
-	int	line_num;
-	int	sz_line;
-	int	num_line;
-	char	buf[DFLT_LINE_SIZE];
-	char *	line;
+    int line_num;
+    int sz_line;
+    int num_line;
+    char buf[DFLT_LINE_SIZE];
+    char *line;
 } InputLine;
 
 static void
-InitInputLine(InputLine *line)
+InitInputLine(InputLine * line)
 {
-    line->line_num= 1;
-    line->num_line= 0;
-    line->sz_line= DFLT_LINE_SIZE;
-    line->line=	line->buf;
+    line->line_num = 1;
+    line->num_line = 0;
+    line->sz_line = DFLT_LINE_SIZE;
+    line->line = line->buf;
     return;
 }
 
 static void
-FreeInputLine(InputLine *line)
+FreeInputLine(InputLine * line)
 {
-    if (line->line!=line->buf)
-	free(line->line);
-    line->line_num= 1;
-    line->num_line= 0;
-    line->sz_line= DFLT_LINE_SIZE;
-    line->line= line->buf;
+    if (line->line != line->buf)
+        free(line->line);
+    line->line_num = 1;
+    line->num_line = 0;
+    line->sz_line = DFLT_LINE_SIZE;
+    line->line = line->buf;
     return;
 }
 
 static int
-InputLineAddChar(InputLine *line,int ch)
+InputLineAddChar(InputLine * line, int ch)
 {
-    if (line->num_line>=line->sz_line) {
-	if (line->line==line->buf) {
-	    line->line= malloc(line->sz_line*2);
-	    memcpy(line->line,line->buf,line->sz_line);
-	}
-	else {
-	    line->line= realloc((char *)line->line,line->sz_line*2);
-	}
-	line->sz_line*= 2;
-    }
-    line->line[line->num_line++]= ch;
+    if (line->num_line >= line->sz_line) {
+        if (line->line == line->buf) {
+            line->line = malloc(line->sz_line * 2);
+            memcpy(line->line, line->buf, line->sz_line);
+        }
+        else {
+            line->line = realloc((char *) line->line, line->sz_line * 2);
+        }
+        line->sz_line *= 2;
+    }
+    line->line[line->num_line++] = ch;
     return ch;
 }
 
@@ -108,80 +106,80 @@ InputLineAddChar(InputLine *line,int ch)
 				InputLineAddChar(l,c))
 
 static Bool
-GetInputLine(FILE *file,InputLine *line,Bool checkbang)
+GetInputLine(FILE * file, InputLine * line, Bool checkbang)
 {
-int	ch;
-Bool	endOfFile,spacePending,slashPending,inComment;
-
-     endOfFile= FALSE;
-     while ((!endOfFile)&&(line->num_line==0)) {
-	spacePending= slashPending= inComment= FALSE;
-	while (((ch=getc(file))!='\n')&&(ch!=EOF)) {
-	    if (ch=='\\') {
-		if ((ch=getc(file))==EOF)
-		    break;
-		if (ch=='\n') {
-		    inComment= FALSE;
-		    ch= ' ';
-		    line->line_num++;
-		}
-	    }
-	    if (inComment)
-		continue;
-	    if (ch=='/') {
-		if (slashPending) {
-		    inComment= TRUE;
-		    slashPending= FALSE;
-		}
-		else {
-		    slashPending= TRUE;
-		}
-		continue;
-	    }
-	    else if (slashPending) {
-		if (spacePending) {
-		    ADD_CHAR(line,' ');
-		    spacePending= FALSE;
-		}
-		ADD_CHAR(line,'/');
-		slashPending= FALSE;
-	    }
-	    if (isspace(ch)) {
-		while (isspace(ch)&&(ch!='\n')&&(ch!=EOF)) {
-		    ch= getc(file);
-		}
-		if (ch==EOF)
-		    break;
-		if ((ch!='\n')&&(line->num_line>0))
-		    spacePending= TRUE;
-		ungetc(ch,file);
-	    }
-	    else {
-		if (spacePending) {
-		    ADD_CHAR(line,' ');
-		    spacePending= FALSE;
-		}
-		if (checkbang && ch=='!') {
-		    if (line->num_line!=0) {
-			DebugF("The '!' legal only at start of line\n");
-			DebugF("Line containing '!' ignored\n");
-			line->num_line= 0;
-			inComment= 0;
-			break;
-		    }
-
-		}
-		ADD_CHAR(line,ch);
-	    }
-	}
-	if (ch==EOF)
-	     endOfFile= TRUE;
+    int ch;
+    Bool endOfFile, spacePending, slashPending, inComment;
+
+    endOfFile = FALSE;
+    while ((!endOfFile) && (line->num_line == 0)) {
+        spacePending = slashPending = inComment = FALSE;
+        while (((ch = getc(file)) != '\n') && (ch != EOF)) {
+            if (ch == '\\') {
+                if ((ch = getc(file)) == EOF)
+                    break;
+                if (ch == '\n') {
+                    inComment = FALSE;
+                    ch = ' ';
+                    line->line_num++;
+                }
+            }
+            if (inComment)
+                continue;
+            if (ch == '/') {
+                if (slashPending) {
+                    inComment = TRUE;
+                    slashPending = FALSE;
+                }
+                else {
+                    slashPending = TRUE;
+                }
+                continue;
+            }
+            else if (slashPending) {
+                if (spacePending) {
+                    ADD_CHAR(line, ' ');
+                    spacePending = FALSE;
+                }
+                ADD_CHAR(line, '/');
+                slashPending = FALSE;
+            }
+            if (isspace(ch)) {
+                while (isspace(ch) && (ch != '\n') && (ch != EOF)) {
+                    ch = getc(file);
+                }
+                if (ch == EOF)
+                    break;
+                if ((ch != '\n') && (line->num_line > 0))
+                    spacePending = TRUE;
+                ungetc(ch, file);
+            }
+            else {
+                if (spacePending) {
+                    ADD_CHAR(line, ' ');
+                    spacePending = FALSE;
+                }
+                if (checkbang && ch == '!') {
+                    if (line->num_line != 0) {
+                        DebugF("The '!' legal only at start of line\n");
+                        DebugF("Line containing '!' ignored\n");
+                        line->num_line = 0;
+                        inComment = 0;
+                        break;
+                    }
+
+                }
+                ADD_CHAR(line, ch);
+            }
+        }
+        if (ch == EOF)
+            endOfFile = TRUE;
 /*	else line->num_line++;*/
-     }
-     if ((line->num_line==0)&&(endOfFile))
-	return FALSE;
-      ADD_CHAR(line,'\0');
-      return TRUE;
+    }
+    if ((line->num_line == 0) && (endOfFile))
+        return FALSE;
+    ADD_CHAR(line, '\0');
+    return TRUE;
 }
 
 /***====================================================================***/
@@ -200,164 +198,169 @@ Bool	endOfFile,spacePending,slashPending,inComment;
 #define	PART_MASK	0x000F
 #define	COMPONENT_MASK	0x03F0
 
-static	const char *	cname[MAX_WORDS] = {
-	"model", "layout", "variant", "option", 
-	"keycodes", "symbols", "types", "compat", "geometry"
+static const char *cname[MAX_WORDS] = {
+    "model", "layout", "variant", "option",
+    "keycodes", "symbols", "types", "compat", "geometry"
 };
 
-typedef	struct _RemapSpec {
-	int			number;
-	int			num_remap;
-	struct	{
-		int	word;
-		int	index;
-                }		remap[MAX_WORDS];
+typedef struct _RemapSpec {
+    int number;
+    int num_remap;
+    struct {
+        int word;
+        int index;
+    } remap[MAX_WORDS];
 } RemapSpec;
 
 typedef struct _FileSpec {
-	char *			name[MAX_WORDS];
-	struct _FileSpec *	pending;
+    char *name[MAX_WORDS];
+    struct _FileSpec *pending;
 } FileSpec;
 
 typedef struct {
-	char *			model;
-	char *			layout[XkbNumKbdGroups+1];
-	char *			variant[XkbNumKbdGroups+1];
-	char *			options;
+    char *model;
+    char *layout[XkbNumKbdGroups + 1];
+    char *variant[XkbNumKbdGroups + 1];
+    char *options;
 } XkbRF_MultiDefsRec, *XkbRF_MultiDefsPtr;
 
 #define NDX_BUFF_SIZE	4
 
 /***====================================================================***/
 
-static char*
+static char *
 get_index(char *str, int *ndx)
 {
-   char ndx_buf[NDX_BUFF_SIZE];
-   char *end;
-
-   if (*str != '[') {
-       *ndx = 0;
-       return str;
-   }
-   str++;
-   end = strchr(str, ']');
-   if (end == NULL) {
-       *ndx = -1;
-       return str - 1;
-   }
-   if ( (end - str) >= NDX_BUFF_SIZE) {
-       *ndx = -1;
-       return end + 1;
-   }
-   strlcpy(ndx_buf, str, 1 + end - str);
-   *ndx = atoi(ndx_buf);
-   return end + 1;
+    char ndx_buf[NDX_BUFF_SIZE];
+    char *end;
+
+    if (*str != '[') {
+        *ndx = 0;
+        return str;
+    }
+    str++;
+    end = strchr(str, ']');
+    if (end == NULL) {
+        *ndx = -1;
+        return str - 1;
+    }
+    if ((end - str) >= NDX_BUFF_SIZE) {
+        *ndx = -1;
+        return end + 1;
+    }
+    strlcpy(ndx_buf, str, 1 + end - str);
+    *ndx = atoi(ndx_buf);
+    return end + 1;
 }
 
 static void
-SetUpRemap(InputLine *line,RemapSpec *remap)
+SetUpRemap(InputLine * line, RemapSpec * remap)
 {
-char *		tok,*str;
-unsigned	present, l_ndx_present, v_ndx_present;
-register int	i;
-int		len, ndx;
-_Xstrtokparams	strtok_buf;
-Bool		found;
-
-
-   l_ndx_present = v_ndx_present = present= 0;
-   str= &line->line[1];
-   len = remap->number;
-   memset((char *)remap, 0, sizeof(RemapSpec));
-   remap->number = len;
-   while ((tok=_XStrtok(str," ",strtok_buf))!=NULL) {
-	found= FALSE;
-	str= NULL;
-	if (strcmp(tok,"=")==0)
-	    continue;
-	for (i=0;i<MAX_WORDS;i++) {
+    char *tok, *str;
+    unsigned present, l_ndx_present, v_ndx_present;
+    register int i;
+    int len, ndx;
+    _Xstrtokparams strtok_buf;
+    Bool found;
+
+    l_ndx_present = v_ndx_present = present = 0;
+    str = &line->line[1];
+    len = remap->number;
+    memset((char *) remap, 0, sizeof(RemapSpec));
+    remap->number = len;
+    while ((tok = _XStrtok(str, " ", strtok_buf)) != NULL) {
+        found = FALSE;
+        str = NULL;
+        if (strcmp(tok, "=") == 0)
+            continue;
+        for (i = 0; i < MAX_WORDS; i++) {
             len = strlen(cname[i]);
-	    if (strncmp(cname[i],tok,len)==0) {
-		if(strlen(tok) > len) {
-		    char *end = get_index(tok+len, &ndx);
-		    if ((i != LAYOUT && i != VARIANT) ||
-			*end != '\0' || ndx == -1)
-		        break;
-		     if (ndx < 1 || ndx > XkbNumKbdGroups) {
-		        DebugF("Illegal %s index: %d\n", cname[i], ndx);
-		        DebugF("Index must be in range 1..%d\n",
-				   XkbNumKbdGroups);
-			break;
-		     }
-                } else {
-		    ndx = 0;
+            if (strncmp(cname[i], tok, len) == 0) {
+                if (strlen(tok) > len) {
+                    char *end = get_index(tok + len, &ndx);
+
+                    if ((i != LAYOUT && i != VARIANT) ||
+                        *end != '\0' || ndx == -1)
+                        break;
+                    if (ndx < 1 || ndx > XkbNumKbdGroups) {
+                        DebugF("Illegal %s index: %d\n", cname[i], ndx);
+                        DebugF("Index must be in range 1..%d\n",
+                               XkbNumKbdGroups);
+                        break;
+                    }
                 }
-		found= TRUE;
-		if (present&(1<<i)) {
-		    if ((i == LAYOUT && l_ndx_present&(1<<ndx)) ||
-			(i == VARIANT && v_ndx_present&(1<<ndx)) ) {
-		        DebugF("Component \"%s\" listed twice\n",tok);
-		        DebugF("Second definition ignored\n");
-		        break;
-		    }
-		}
-		present |= (1<<i);
+                else {
+                    ndx = 0;
+                }
+                found = TRUE;
+                if (present & (1 << i)) {
+                    if ((i == LAYOUT && l_ndx_present & (1 << ndx)) ||
+                        (i == VARIANT && v_ndx_present & (1 << ndx))) {
+                        DebugF("Component \"%s\" listed twice\n", tok);
+                        DebugF("Second definition ignored\n");
+                        break;
+                    }
+                }
+                present |= (1 << i);
                 if (i == LAYOUT)
                     l_ndx_present |= 1 << ndx;
                 if (i == VARIANT)
                     v_ndx_present |= 1 << ndx;
-		remap->remap[remap->num_remap].word= i;
-		remap->remap[remap->num_remap++].index= ndx;
-		break;
-	    }
-	}
-	if (!found) {
-	    fprintf(stderr,"Unknown component \"%s\" ignored\n",tok);
-	}
-   }
-   if ((present&PART_MASK)==0) {
-	unsigned mask= PART_MASK;
-	ErrorF("Mapping needs at least one of ");
-	for (i=0; (i<MAX_WORDS); i++) {
-	    if ((1L<<i)&mask) {
-		mask&= ~(1L<<i);
-		if (mask)	DebugF("\"%s,\" ",cname[i]);
-		else		DebugF("or \"%s\"\n",cname[i]);
-	    }
-	}
-	DebugF("Illegal mapping ignored\n");
-	remap->num_remap= 0;
-	return;
-   }
-   if ((present&COMPONENT_MASK)==0) {
-	DebugF("Mapping needs at least one component\n");
-	DebugF("Illegal mapping ignored\n");
-	remap->num_remap= 0;
-	return;
-   }
-   remap->number++;
-   return;
+                remap->remap[remap->num_remap].word = i;
+                remap->remap[remap->num_remap++].index = ndx;
+                break;
+            }
+        }
+        if (!found) {
+            fprintf(stderr, "Unknown component \"%s\" ignored\n", tok);
+        }
+    }
+    if ((present & PART_MASK) == 0) {
+        unsigned mask = PART_MASK;
+
+        ErrorF("Mapping needs at least one of ");
+        for (i = 0; (i < MAX_WORDS); i++) {
+            if ((1L << i) & mask) {
+                mask &= ~(1L << i);
+                if (mask)
+                    DebugF("\"%s,\" ", cname[i]);
+                else
+                    DebugF("or \"%s\"\n", cname[i]);
+            }
+        }
+        DebugF("Illegal mapping ignored\n");
+        remap->num_remap = 0;
+        return;
+    }
+    if ((present & COMPONENT_MASK) == 0) {
+        DebugF("Mapping needs at least one component\n");
+        DebugF("Illegal mapping ignored\n");
+        remap->num_remap = 0;
+        return;
+    }
+    remap->number++;
+    return;
 }
 
 static Bool
-MatchOneOf(char *wanted,char *vals_defined)
+MatchOneOf(char *wanted, char *vals_defined)
 {
-char	*str,*next;
-int	want_len= strlen(wanted);
-
-    for (str=vals_defined,next=NULL;str!=NULL;str=next) {
-	int len;
-	next= strchr(str,',');
-	if (next) {
-	    len= next-str;
-	    next++;
-	}
-	else {
-	    len= strlen(str);
-	}
-	if ((len==want_len)&&(strncmp(wanted,str,len)==0))
-	    return TRUE;
+    char *str, *next;
+    int want_len = strlen(wanted);
+
+    for (str = vals_defined, next = NULL; str != NULL; str = next) {
+        int len;
+
+        next = strchr(str, ',');
+        if (next) {
+            len = next - str;
+            next++;
+        }
+        else {
+            len = strlen(str);
+        }
+        if ((len == want_len) && (strncmp(wanted, str, len) == 0))
+            return TRUE;
     }
     return FALSE;
 }
@@ -365,23 +368,22 @@ int	want_len= strlen(wanted);
 /***====================================================================***/
 
 static Bool
-CheckLine(	InputLine *		line,
-		RemapSpec *		remap,
-		XkbRF_RulePtr		rule,
-		XkbRF_GroupPtr		group)
+CheckLine(InputLine * line,
+          RemapSpec * remap, XkbRF_RulePtr rule, XkbRF_GroupPtr group)
 {
-char *		str,*tok;
-register int	nread, i;
-FileSpec	tmp;
-_Xstrtokparams	strtok_buf;
-Bool 		append = FALSE;
+    char *str, *tok;
+    register int nread, i;
+    FileSpec tmp;
+    _Xstrtokparams strtok_buf;
+    Bool append = FALSE;
 
-    if (line->line[0]=='!') {
+    if (line->line[0] == '!') {
         if (line->line[1] == '$' ||
             (line->line[1] == ' ' && line->line[2] == '$')) {
             char *gname = strchr(line->line, '$');
             char *words = strchr(gname, ' ');
-            if(!words)
+
+            if (!words)
                 return FALSE;
             *words++ = '\0';
             for (; *words; words++) {
@@ -393,168 +395,178 @@ Bool 		append = FALSE;
             group->name = Xstrdup(gname);
             group->words = Xstrdup(words);
             for (i = 1, words = group->words; *words; words++) {
-                 if ( *words == ' ') {
-                     *words++ = '\0';
-                     i++;
-                 }
+                if (*words == ' ') {
+                    *words++ = '\0';
+                    i++;
+                }
             }
             group->number = i;
             return TRUE;
-        } else {
-	    SetUpRemap(line,remap);
-	    return FALSE;
-        }
-    }
-
-    if (remap->num_remap==0) {
-	DebugF("Must have a mapping before first line of data\n");
-	DebugF("Illegal line of data ignored\n");
-	return FALSE;
-    }
-    memset((char *)&tmp, 0, sizeof(FileSpec));
-    str= line->line;
-    for (nread= 0;(tok=_XStrtok(str," ",strtok_buf))!=NULL;nread++) {
-	str= NULL;
-	if (strcmp(tok,"=")==0) {
-	    nread--;
-	    continue;
-	}
-	if (nread>remap->num_remap) {
-	    DebugF("Too many words on a line\n");
-	    DebugF("Extra word \"%s\" ignored\n",tok);
-	    continue;
-	}
-	tmp.name[remap->remap[nread].word]= tok;
-	if (*tok == '+' || *tok == '|')
-	    append = TRUE;
-    }
-    if (nread<remap->num_remap) {
-	DebugF("Too few words on a line: %s\n", line->line);
-	DebugF("line ignored\n");
-	return FALSE;
-    }
-
-    rule->flags= 0;
+        }
+        else {
+            SetUpRemap(line, remap);
+            return FALSE;
+        }
+    }
+
+    if (remap->num_remap == 0) {
+        DebugF("Must have a mapping before first line of data\n");
+        DebugF("Illegal line of data ignored\n");
+        return FALSE;
+    }
+    memset((char *) &tmp, 0, sizeof(FileSpec));
+    str = line->line;
+    for (nread = 0; (tok = _XStrtok(str, " ", strtok_buf)) != NULL; nread++) {
+        str = NULL;
+        if (strcmp(tok, "=") == 0) {
+            nread--;
+            continue;
+        }
+        if (nread > remap->num_remap) {
+            DebugF("Too many words on a line\n");
+            DebugF("Extra word \"%s\" ignored\n", tok);
+            continue;
+        }
+        tmp.name[remap->remap[nread].word] = tok;
+        if (*tok == '+' || *tok == '|')
+            append = TRUE;
+    }
+    if (nread < remap->num_remap) {
+        DebugF("Too few words on a line: %s\n", line->line);
+        DebugF("line ignored\n");
+        return FALSE;
+    }
+
+    rule->flags = 0;
     rule->number = remap->number;
     if (tmp.name[OPTION])
-	 rule->flags|= XkbRF_Option;
+        rule->flags |= XkbRF_Option;
     else if (append)
-	 rule->flags|= XkbRF_Append;
+        rule->flags |= XkbRF_Append;
     else
-	 rule->flags|= XkbRF_Normal;
-    rule->model= Xstrdup(tmp.name[MODEL]);
-    rule->layout= Xstrdup(tmp.name[LAYOUT]);
-    rule->variant= Xstrdup(tmp.name[VARIANT]);
-    rule->option= Xstrdup(tmp.name[OPTION]);
-
-    rule->keycodes= Xstrdup(tmp.name[KEYCODES]);
-    rule->symbols= Xstrdup(tmp.name[SYMBOLS]);
-    rule->types= Xstrdup(tmp.name[TYPES]);
-    rule->compat= Xstrdup(tmp.name[COMPAT]);
-    rule->geometry= Xstrdup(tmp.name[GEOMETRY]);
+        rule->flags |= XkbRF_Normal;
+    rule->model = Xstrdup(tmp.name[MODEL]);
+    rule->layout = Xstrdup(tmp.name[LAYOUT]);
+    rule->variant = Xstrdup(tmp.name[VARIANT]);
+    rule->option = Xstrdup(tmp.name[OPTION]);
+
+    rule->keycodes = Xstrdup(tmp.name[KEYCODES]);
+    rule->symbols = Xstrdup(tmp.name[SYMBOLS]);
+    rule->types = Xstrdup(tmp.name[TYPES]);
+    rule->compat = Xstrdup(tmp.name[COMPAT]);
+    rule->geometry = Xstrdup(tmp.name[GEOMETRY]);
 
     rule->layout_num = rule->variant_num = 0;
     for (i = 0; i < nread; i++) {
         if (remap->remap[i].index) {
-	    if (remap->remap[i].word == LAYOUT)
-	        rule->layout_num = remap->remap[i].index;
-	    if (remap->remap[i].word == VARIANT)
-	        rule->variant_num = remap->remap[i].index;
+            if (remap->remap[i].word == LAYOUT)
+                rule->layout_num = remap->remap[i].index;
+            if (remap->remap[i].word == VARIANT)
+                rule->variant_num = remap->remap[i].index;
         }
     }
     return TRUE;
 }
 
 static char *
-_Concat(char *str1,char *str2)
+_Concat(char *str1, char *str2)
 {
-int len;
+    int len;
 
-    if ((!str1)||(!str2))
-	return str1;
-    len= strlen(str1)+strlen(str2)+1;
-    str1= realloc(str1,len * sizeof(char));
+    if ((!str1) || (!str2))
+        return str1;
+    len = strlen(str1) + strlen(str2) + 1;
+    str1 = realloc(str1, len * sizeof(char));
     if (str1)
-	strcat(str1,str2);
+        strcat(str1, str2);
     return str1;
 }
 
 static void
 squeeze_spaces(char *p1)
 {
-   char *p2;
-   for (p2 = p1; *p2; p2++) {
-       *p1 = *p2;
-       if (*p1 != ' ') p1++;
-   }
-   *p1 = '\0';
+    char *p2;
+
+    for (p2 = p1; *p2; p2++) {
+        *p1 = *p2;
+        if (*p1 != ' ')
+            p1++;
+    }
+    *p1 = '\0';
 }
 
 static Bool
 MakeMultiDefs(XkbRF_MultiDefsPtr mdefs, XkbRF_VarDefsPtr defs)
 {
 
-   memset((char *)mdefs, 0, sizeof(XkbRF_MultiDefsRec));
-   mdefs->model = defs->model;
-   mdefs->options = Xstrdup(defs->options);
-   if (mdefs->options) squeeze_spaces(mdefs->options); 
-
-   if (defs->layout) {
-       if (!strchr(defs->layout, ',')) {
-           mdefs->layout[0] = defs->layout;
-       } else {
-           char *p;
-           int i;
-           mdefs->layout[1] = Xstrdup(defs->layout);
-	   if (mdefs->layout[1] == NULL)
-	      return FALSE;
-           squeeze_spaces(mdefs->layout[1]);
-           p = mdefs->layout[1];
-           for (i = 2; i <= XkbNumKbdGroups; i++) {
-              if ((p = strchr(p, ','))) {
-                 *p++ = '\0';
-                 mdefs->layout[i] = p;
-              } else {
-                 break;
-              }
-           }
-           if (p && (p = strchr(p, ',')))
-              *p = '\0';
-       }
-   }
-
-   if (defs->variant) {
-       if (!strchr(defs->variant, ',')) {
-           mdefs->variant[0] = defs->variant;
-       } else {
-           char *p;
-           int i;
-           mdefs->variant[1] = Xstrdup(defs->variant);
-	   if (mdefs->variant[1] == NULL)
-	      return FALSE;
-           squeeze_spaces(mdefs->variant[1]);
-           p = mdefs->variant[1];
-           for (i = 2; i <= XkbNumKbdGroups; i++) {
-              if ((p = strchr(p, ','))) {
-                 *p++ = '\0';
-                 mdefs->variant[i] = p;
-              } else {
-                 break;
-              }
-           }
-           if (p && (p = strchr(p, ',')))
-              *p = '\0';
-       }
-   }
-   return TRUE;
+    memset((char *) mdefs, 0, sizeof(XkbRF_MultiDefsRec));
+    mdefs->model = defs->model;
+    mdefs->options = Xstrdup(defs->options);
+    if (mdefs->options)
+        squeeze_spaces(mdefs->options);
+
+    if (defs->layout) {
+        if (!strchr(defs->layout, ',')) {
+            mdefs->layout[0] = defs->layout;
+        }
+        else {
+            char *p;
+            int i;
+
+            mdefs->layout[1] = Xstrdup(defs->layout);
+            if (mdefs->layout[1] == NULL)
+                return FALSE;
+            squeeze_spaces(mdefs->layout[1]);
+            p = mdefs->layout[1];
+            for (i = 2; i <= XkbNumKbdGroups; i++) {
+                if ((p = strchr(p, ','))) {
+                    *p++ = '\0';
+                    mdefs->layout[i] = p;
+                }
+                else {
+                    break;
+                }
+            }
+            if (p && (p = strchr(p, ',')))
+                *p = '\0';
+        }
+    }
+
+    if (defs->variant) {
+        if (!strchr(defs->variant, ',')) {
+            mdefs->variant[0] = defs->variant;
+        }
+        else {
+            char *p;
+            int i;
+
+            mdefs->variant[1] = Xstrdup(defs->variant);
+            if (mdefs->variant[1] == NULL)
+                return FALSE;
+            squeeze_spaces(mdefs->variant[1]);
+            p = mdefs->variant[1];
+            for (i = 2; i <= XkbNumKbdGroups; i++) {
+                if ((p = strchr(p, ','))) {
+                    *p++ = '\0';
+                    mdefs->variant[i] = p;
+                }
+                else {
+                    break;
+                }
+            }
+            if (p && (p = strchr(p, ',')))
+                *p = '\0';
+        }
+    }
+    return TRUE;
 }
 
 static void
 FreeMultiDefs(XkbRF_MultiDefsPtr defs)
 {
-  free(defs->options);
-  free(defs->layout[1]);
-  free(defs->variant[1]);
+    free(defs->options);
+    free(defs->layout[1]);
+    free(defs->variant[1]);
 }
 
 static void
@@ -562,168 +574,171 @@ Apply(char *src, char **dst)
 {
     if (src) {
         if (*src == '+' || *src == '!') {
-	    *dst= _Concat(*dst, src);
-        } else {
+            *dst = _Concat(*dst, src);
+        }
+        else {
             if (*dst == NULL)
-	        *dst= Xstrdup(src);
+                *dst = Xstrdup(src);
         }
     }
 }
 
 static void
-XkbRF_ApplyRule(	XkbRF_RulePtr 		rule,
-			XkbComponentNamesPtr	names)
+XkbRF_ApplyRule(XkbRF_RulePtr rule, XkbComponentNamesPtr names)
 {
-    rule->flags&= ~XkbRF_PendingMatch; /* clear the flag because it's applied */
+    rule->flags &= ~XkbRF_PendingMatch; /* clear the flag because it's applied */
 
     Apply(rule->keycodes, &names->keycodes);
-    Apply(rule->symbols,  &names->symbols);
-    Apply(rule->types,    &names->types);
-    Apply(rule->compat,   &names->compat);
+    Apply(rule->symbols, &names->symbols);
+    Apply(rule->types, &names->types);
+    Apply(rule->compat, &names->compat);
     Apply(rule->geometry, &names->geometry);
 }
 
 static Bool
-CheckGroup(	XkbRF_RulesPtr          rules,
-		char * 			group_name,
-		char * 			name)
+CheckGroup(XkbRF_RulesPtr rules, char *group_name, char *name)
 {
-   int i;
-   char *p;
-   XkbRF_GroupPtr group;
-
-   for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
-       if (! strcmp(group->name, group_name)) {
-           break;
-       }
-   }
-   if (i == rules->num_groups)
-       return FALSE;
-   for (i = 0, p = group->words; i < group->number; i++, p += strlen(p)+1) {
-       if (! strcmp(p, name)) {
-           return TRUE;
-       }
-   }
-   return FALSE;
+    int i;
+    char *p;
+    XkbRF_GroupPtr group;
+
+    for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
+        if (!strcmp(group->name, group_name)) {
+            break;
+        }
+    }
+    if (i == rules->num_groups)
+        return FALSE;
+    for (i = 0, p = group->words; i < group->number; i++, p += strlen(p) + 1) {
+        if (!strcmp(p, name)) {
+            return TRUE;
+        }
+    }
+    return FALSE;
 }
 
 static int
-XkbRF_CheckApplyRule(	XkbRF_RulePtr 		rule,
-			XkbRF_MultiDefsPtr	mdefs,
-			XkbComponentNamesPtr	names,
-			XkbRF_RulesPtr          rules)
+XkbRF_CheckApplyRule(XkbRF_RulePtr rule,
+                     XkbRF_MultiDefsPtr mdefs,
+                     XkbComponentNamesPtr names, XkbRF_RulesPtr rules)
 {
     Bool pending = FALSE;
 
     if (rule->model != NULL) {
-        if(mdefs->model == NULL)
+        if (mdefs->model == NULL)
             return 0;
         if (strcmp(rule->model, "*") == 0) {
             pending = TRUE;
-        } else {
+        }
+        else {
             if (rule->model[0] == '$') {
-               if (!CheckGroup(rules, rule->model, mdefs->model))
-                  return 0;
-            } else {
-	       if (strcmp(rule->model, mdefs->model) != 0)
-	          return 0;
-	    }
-	}
+                if (!CheckGroup(rules, rule->model, mdefs->model))
+                    return 0;
+            }
+            else {
+                if (strcmp(rule->model, mdefs->model) != 0)
+                    return 0;
+            }
+        }
     }
     if (rule->option != NULL) {
-	if (mdefs->options == NULL)
-	    return 0;
-	if ((!MatchOneOf(rule->option,mdefs->options)))
-	    return 0;
+        if (mdefs->options == NULL)
+            return 0;
+        if ((!MatchOneOf(rule->option, mdefs->options)))
+            return 0;
     }
 
     if (rule->layout != NULL) {
-	if(mdefs->layout[rule->layout_num] == NULL ||
-	   *mdefs->layout[rule->layout_num] == '\0')
-	    return 0;
+        if (mdefs->layout[rule->layout_num] == NULL ||
+            *mdefs->layout[rule->layout_num] == '\0')
+            return 0;
         if (strcmp(rule->layout, "*") == 0) {
             pending = TRUE;
-        } else {
+        }
+        else {
             if (rule->layout[0] == '$') {
-               if (!CheckGroup(rules, rule->layout,
-                               mdefs->layout[rule->layout_num]))
-                  return 0;
-	    } else {
-	       if (strcmp(rule->layout, mdefs->layout[rule->layout_num]) != 0)
-	           return 0;
-	    }
-	}
+                if (!CheckGroup(rules, rule->layout,
+                                mdefs->layout[rule->layout_num]))
+                    return 0;
+            }
+            else {
+                if (strcmp(rule->layout, mdefs->layout[rule->layout_num]) != 0)
+                    return 0;
+            }
+        }
     }
     if (rule->variant != NULL) {
-	if (mdefs->variant[rule->variant_num] == NULL ||
-	    *mdefs->variant[rule->variant_num] == '\0')
-	    return 0;
+        if (mdefs->variant[rule->variant_num] == NULL ||
+            *mdefs->variant[rule->variant_num] == '\0')
+            return 0;
         if (strcmp(rule->variant, "*") == 0) {
             pending = TRUE;
-        } else {
+        }
+        else {
             if (rule->variant[0] == '$') {
-               if (!CheckGroup(rules, rule->variant,
-                               mdefs->variant[rule->variant_num]))
-                  return 0;
-            } else {
-	       if (strcmp(rule->variant,
-                          mdefs->variant[rule->variant_num]) != 0)
-	           return 0;
-	    }
-	}
+                if (!CheckGroup(rules, rule->variant,
+                                mdefs->variant[rule->variant_num]))
+                    return 0;
+            }
+            else {
+                if (strcmp(rule->variant,
+                           mdefs->variant[rule->variant_num]) != 0)
+                    return 0;
+            }
+        }
     }
     if (pending) {
-        rule->flags|= XkbRF_PendingMatch;
-	return rule->number;
+        rule->flags |= XkbRF_PendingMatch;
+        return rule->number;
     }
     /* exact match, apply it now */
-    XkbRF_ApplyRule(rule,names);
+    XkbRF_ApplyRule(rule, names);
     return rule->number;
 }
 
 static void
 XkbRF_ClearPartialMatches(XkbRF_RulesPtr rules)
 {
-register int 	i;
-XkbRF_RulePtr	rule;
+    register int i;
+    XkbRF_RulePtr rule;
 
-    for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) {
-	rule->flags&= ~XkbRF_PendingMatch;
+    for (i = 0, rule = rules->rules; i < rules->num_rules; i++, rule++) {
+        rule->flags &= ~XkbRF_PendingMatch;
     }
 }
 
 static void
-XkbRF_ApplyPartialMatches(XkbRF_RulesPtr rules,XkbComponentNamesPtr names)
+XkbRF_ApplyPartialMatches(XkbRF_RulesPtr rules, XkbComponentNamesPtr names)
 {
-int		i;
-XkbRF_RulePtr	rule;
+    int i;
+    XkbRF_RulePtr rule;
 
     for (rule = rules->rules, i = 0; i < rules->num_rules; i++, rule++) {
-	if ((rule->flags&XkbRF_PendingMatch)==0)
-	    continue;
-	XkbRF_ApplyRule(rule,names);
+        if ((rule->flags & XkbRF_PendingMatch) == 0)
+            continue;
+        XkbRF_ApplyRule(rule, names);
     }
 }
 
 static void
-XkbRF_CheckApplyRules(	XkbRF_RulesPtr 		rules,
-			XkbRF_MultiDefsPtr	mdefs,
-			XkbComponentNamesPtr	names,
-			int			flags)
+XkbRF_CheckApplyRules(XkbRF_RulesPtr rules,
+                      XkbRF_MultiDefsPtr mdefs,
+                      XkbComponentNamesPtr names, int flags)
 {
-int		i;
-XkbRF_RulePtr	rule;
-int		skip;
-
-    for (rule = rules->rules, i=0; i < rules->num_rules; rule++, i++) {
-	if ((rule->flags & flags) != flags)
-	    continue;
-	skip = XkbRF_CheckApplyRule(rule, mdefs, names, rules);
-	if (skip && !(flags & XkbRF_Option)) {
-	    for ( ;(i < rules->num_rules) && (rule->number == skip);
-		  rule++, i++);
-	    rule--; i--;
-	}
+    int i;
+    XkbRF_RulePtr rule;
+    int skip;
+
+    for (rule = rules->rules, i = 0; i < rules->num_rules; rule++, i++) {
+        if ((rule->flags & flags) != flags)
+            continue;
+        skip = XkbRF_CheckApplyRule(rule, mdefs, names, rules);
+        if (skip && !(flags & XkbRF_Option)) {
+            for (; (i < rules->num_rules) && (rule->number == skip);
+                 rule++, i++);
+            rule--;
+            i--;
+        }
     }
 }
 
@@ -732,108 +747,117 @@ int		skip;
 static char *
 XkbRF_SubstituteVars(char *name, XkbRF_MultiDefsPtr mdefs)
 {
-char 	*str, *outstr, *orig, *var;
-int	len, ndx;
-
-    orig= name;
-    str= index(name,'%');
-    if (str==NULL)
-	return name;
-    len= strlen(name);
-    while (str!=NULL) {
-	char pfx= str[1];
-	int   extra_len= 0;
-	if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
-	    extra_len= 1;
-	    str++;
-	}
-	else if (pfx=='(') {
-	    extra_len= 2;
-	    str++;
-	}
-	var = str + 1;
-	str = get_index(var + 1, &ndx);
-	if (ndx == -1) {
-	    str = index(str,'%');
-	    continue;
-        }
-	if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx])
-	    len+= strlen(mdefs->layout[ndx])+extra_len;
-	else if ((*var=='m')&&mdefs->model)
-	    len+= strlen(mdefs->model)+extra_len;
-	else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx])
-	    len+= strlen(mdefs->variant[ndx])+extra_len;
-	if ((pfx=='(')&&(*str==')')) {
-	    str++;
-	}
-	str= index(&str[0],'%');
-    }
-    name= malloc(len+1);
-    str= orig;
-    outstr= name;
-    while (*str!='\0') {
-	if (str[0]=='%') {
-	    char pfx,sfx;
-	    str++;
-	    pfx= str[0];
-	    sfx= '\0';
-	    if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
-		str++;
-	    }
-	    else if (pfx=='(') {
-		sfx= ')';
-		str++;
-	    }
-	    else pfx= '\0';
-
-	    var = str;
-	    str = get_index(var + 1, &ndx);
-	    if (ndx == -1) {
-	        continue;
+    char *str, *outstr, *orig, *var;
+    int len, ndx;
+
+    orig = name;
+    str = index(name, '%');
+    if (str == NULL)
+        return name;
+    len = strlen(name);
+    while (str != NULL) {
+        char pfx = str[1];
+        int extra_len = 0;
+
+        if ((pfx == '+') || (pfx == '|') || (pfx == '_') || (pfx == '-')) {
+            extra_len = 1;
+            str++;
+        }
+        else if (pfx == '(') {
+            extra_len = 2;
+            str++;
+        }
+        var = str + 1;
+        str = get_index(var + 1, &ndx);
+        if (ndx == -1) {
+            str = index(str, '%');
+            continue;
+        }
+        if ((*var == 'l') && mdefs->layout[ndx] && *mdefs->layout[ndx])
+            len += strlen(mdefs->layout[ndx]) + extra_len;
+        else if ((*var == 'm') && mdefs->model)
+            len += strlen(mdefs->model) + extra_len;
+        else if ((*var == 'v') && mdefs->variant[ndx] && *mdefs->variant[ndx])
+            len += strlen(mdefs->variant[ndx]) + extra_len;
+        if ((pfx == '(') && (*str == ')')) {
+            str++;
+        }
+        str = index(&str[0], '%');
+    }
+    name = malloc(len + 1);
+    str = orig;
+    outstr = name;
+    while (*str != '\0') {
+        if (str[0] == '%') {
+            char pfx, sfx;
+
+            str++;
+            pfx = str[0];
+            sfx = '\0';
+            if ((pfx == '+') || (pfx == '|') || (pfx == '_') || (pfx == '-')) {
+                str++;
+            }
+            else if (pfx == '(') {
+                sfx = ')';
+                str++;
             }
-	    if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx]) {
-		if (pfx) *outstr++= pfx;
-		strcpy(outstr,mdefs->layout[ndx]);
-		outstr+= strlen(mdefs->layout[ndx]);
-		if (sfx) *outstr++= sfx;
-	    }
-	    else if ((*var=='m')&&(mdefs->model)) {
-		if (pfx) *outstr++= pfx;
-		strcpy(outstr,mdefs->model);
-		outstr+= strlen(mdefs->model);
-		if (sfx) *outstr++= sfx;
-	    }
-	    else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx]) {
-		if (pfx) *outstr++= pfx;
-		strcpy(outstr,mdefs->variant[ndx]);
-		outstr+= strlen(mdefs->variant[ndx]);
-		if (sfx) *outstr++= sfx;
-	    }
-	    if ((pfx=='(')&&(*str==')'))
-		str++;
-	}
-	else {
-	    *outstr++= *str++;
-	}
-    }
-    *outstr++= '\0';
-    if (orig!=name)
-	free(orig);
+            else
+                pfx = '\0';
+
+            var = str;
+            str = get_index(var + 1, &ndx);
+            if (ndx == -1) {
+                continue;
+            }
+            if ((*var == 'l') && mdefs->layout[ndx] && *mdefs->layout[ndx]) {
+                if (pfx)
+                    *outstr++ = pfx;
+                strcpy(outstr, mdefs->layout[ndx]);
+                outstr += strlen(mdefs->layout[ndx]);
+                if (sfx)
+                    *outstr++ = sfx;
+            }
+            else if ((*var == 'm') && (mdefs->model)) {
+                if (pfx)
+                    *outstr++ = pfx;
+                strcpy(outstr, mdefs->model);
+                outstr += strlen(mdefs->model);
+                if (sfx)
+                    *outstr++ = sfx;
+            }
+            else if ((*var == 'v') && mdefs->variant[ndx] &&
+                     *mdefs->variant[ndx]) {
+                if (pfx)
+                    *outstr++ = pfx;
+                strcpy(outstr, mdefs->variant[ndx]);
+                outstr += strlen(mdefs->variant[ndx]);
+                if (sfx)
+                    *outstr++ = sfx;
+            }
+            if ((pfx == '(') && (*str == ')'))
+                str++;
+        }
+        else {
+            *outstr++ = *str++;
+        }
+    }
+    *outstr++ = '\0';
+    if (orig != name)
+        free(orig);
     return name;
 }
 
 /***====================================================================***/
 
 Bool
-XkbRF_GetComponents(	XkbRF_RulesPtr		rules,
-			XkbRF_VarDefsPtr	defs,
-			XkbComponentNamesPtr	names)
+XkbRF_GetComponents(XkbRF_RulesPtr rules,
+                    XkbRF_VarDefsPtr defs, XkbComponentNamesPtr names)
 {
     XkbRF_MultiDefsRec mdefs;
 
     MakeMultiDefs(&mdefs, defs);
 
-    memset((char *)names, 0, sizeof(XkbComponentNamesRec));
+    memset((char *) names, 0, sizeof(XkbComponentNamesRec));
     XkbRF_ClearPartialMatches(rules);
     XkbRF_CheckApplyRules(rules, &mdefs, names, XkbRF_Normal);
     XkbRF_ApplyPartialMatches(rules, names);
@@ -842,125 +866,127 @@ XkbRF_GetComponents(	XkbRF_RulesPtr		rules,
     XkbRF_CheckApplyRules(rules, &mdefs, names, XkbRF_Option);
 
     if (names->keycodes)
-	names->keycodes= XkbRF_SubstituteVars(names->keycodes, &mdefs);
-    if (names->symbols)	
-	names->symbols=	XkbRF_SubstituteVars(names->symbols, &mdefs);
+        names->keycodes = XkbRF_SubstituteVars(names->keycodes, &mdefs);
+    if (names->symbols)
+        names->symbols = XkbRF_SubstituteVars(names->symbols, &mdefs);
     if (names->types)
-	names->types= XkbRF_SubstituteVars(names->types, &mdefs);
+        names->types = XkbRF_SubstituteVars(names->types, &mdefs);
     if (names->compat)
-	names->compat= XkbRF_SubstituteVars(names->compat, &mdefs);
+        names->compat = XkbRF_SubstituteVars(names->compat, &mdefs);
     if (names->geometry)
-	names->geometry= XkbRF_SubstituteVars(names->geometry, &mdefs);
+        names->geometry = XkbRF_SubstituteVars(names->geometry, &mdefs);
 
     FreeMultiDefs(&mdefs);
     return (names->keycodes && names->symbols && names->types &&
-		names->compat && names->geometry);
+            names->compat && names->geometry);
 }
 
 static XkbRF_RulePtr
-XkbRF_AddRule(XkbRF_RulesPtr	rules)
+XkbRF_AddRule(XkbRF_RulesPtr rules)
 {
-    if (rules->sz_rules<1) {
-	rules->sz_rules= 16;
-	rules->num_rules= 0;
-	rules->rules= calloc(rules->sz_rules, sizeof(XkbRF_RuleRec));
+    if (rules->sz_rules < 1) {
+        rules->sz_rules = 16;
+        rules->num_rules = 0;
+        rules->rules = calloc(rules->sz_rules, sizeof(XkbRF_RuleRec));
     }
-    else if (rules->num_rules>=rules->sz_rules) {
-	rules->sz_rules*= 2;
-	rules->rules= realloc(rules->rules,
-				rules->sz_rules * sizeof(XkbRF_RuleRec));
+    else if (rules->num_rules >= rules->sz_rules) {
+        rules->sz_rules *= 2;
+        rules->rules = realloc(rules->rules,
+                               rules->sz_rules * sizeof(XkbRF_RuleRec));
     }
     if (!rules->rules) {
-	rules->sz_rules= rules->num_rules= 0;
-	DebugF("Allocation failure in XkbRF_AddRule\n");
-	return NULL;
+        rules->sz_rules = rules->num_rules = 0;
+        DebugF("Allocation failure in XkbRF_AddRule\n");
+        return NULL;
     }
-    memset((char *)&rules->rules[rules->num_rules], 0, sizeof(XkbRF_RuleRec));
+    memset((char *) &rules->rules[rules->num_rules], 0, sizeof(XkbRF_RuleRec));
     return &rules->rules[rules->num_rules++];
 }
 
 static XkbRF_GroupPtr
-XkbRF_AddGroup(XkbRF_RulesPtr	rules)
+XkbRF_AddGroup(XkbRF_RulesPtr rules)
 {
-    if (rules->sz_groups<1) {
-	rules->sz_groups= 16;
-	rules->num_groups= 0;
-	rules->groups= calloc(rules->sz_groups, sizeof(XkbRF_GroupRec));
+    if (rules->sz_groups < 1) {
+        rules->sz_groups = 16;
+        rules->num_groups = 0;
+        rules->groups = calloc(rules->sz_groups, sizeof(XkbRF_GroupRec));
     }
     else if (rules->num_groups >= rules->sz_groups) {
-	rules->sz_groups *= 2;
-	rules->groups= realloc(rules->groups,
-				rules->sz_groups * sizeof(XkbRF_GroupRec));
+        rules->sz_groups *= 2;
+        rules->groups = realloc(rules->groups,
+                                rules->sz_groups * sizeof(XkbRF_GroupRec));
     }
     if (!rules->groups) {
-	rules->sz_groups= rules->num_groups= 0;
-	return NULL;
+        rules->sz_groups = rules->num_groups = 0;
+        return NULL;
     }
 
-    memset((char *)&rules->groups[rules->num_groups], 0, sizeof(XkbRF_GroupRec));
+    memset((char *) &rules->groups[rules->num_groups], 0,
+           sizeof(XkbRF_GroupRec));
     return &rules->groups[rules->num_groups++];
 }
 
 Bool
-XkbRF_LoadRules(FILE *file, XkbRF_RulesPtr rules)
+XkbRF_LoadRules(FILE * file, XkbRF_RulesPtr rules)
 {
-InputLine	line;
-RemapSpec	remap;
-XkbRF_RuleRec	trule,*rule;
-XkbRF_GroupRec  tgroup,*group;
+    InputLine line;
+    RemapSpec remap;
+    XkbRF_RuleRec trule, *rule;
+    XkbRF_GroupRec tgroup, *group;
 
     if (!(rules && file))
-	return FALSE;
-    memset((char *)&remap, 0, sizeof(RemapSpec));
-    memset((char *)&tgroup, 0, sizeof(XkbRF_GroupRec));
+        return FALSE;
+    memset((char *) &remap, 0, sizeof(RemapSpec));
+    memset((char *) &tgroup, 0, sizeof(XkbRF_GroupRec));
     InitInputLine(&line);
-    while (GetInputLine(file,&line,TRUE)) {
-	if (CheckLine(&line,&remap,&trule,&tgroup)) {
+    while (GetInputLine(file, &line, TRUE)) {
+        if (CheckLine(&line, &remap, &trule, &tgroup)) {
             if (tgroup.number) {
-	        if ((group= XkbRF_AddGroup(rules))!=NULL) {
-		    *group= tgroup;
-		    memset((char *)&tgroup, 0, sizeof(XkbRF_GroupRec));
-	        }
-	    } else {
-	        if ((rule= XkbRF_AddRule(rules))!=NULL) {
-		    *rule= trule;
-		    memset((char *)&trule, 0, sizeof(XkbRF_RuleRec));
-	        }
-	    }
-	}
-	line.num_line= 0;
+                if ((group = XkbRF_AddGroup(rules)) != NULL) {
+                    *group = tgroup;
+                    memset((char *) &tgroup, 0, sizeof(XkbRF_GroupRec));
+                }
+            }
+            else {
+                if ((rule = XkbRF_AddRule(rules)) != NULL) {
+                    *rule = trule;
+                    memset((char *) &trule, 0, sizeof(XkbRF_RuleRec));
+                }
+            }
+        }
+        line.num_line = 0;
     }
     FreeInputLine(&line);
     return TRUE;
 }
 
 Bool
-XkbRF_LoadRulesByName(char *base,char *locale,XkbRF_RulesPtr rules)
+XkbRF_LoadRulesByName(char *base, char *locale, XkbRF_RulesPtr rules)
 {
-FILE *		file;
-char		buf[PATH_MAX];
-Bool		ok;
+    FILE *file;
+    char buf[PATH_MAX];
+    Bool ok;
 
-    if ((!base)||(!rules))
-	return FALSE;
+    if ((!base) || (!rules))
+        return FALSE;
     if (locale) {
-	if (snprintf(buf, PATH_MAX, "%s-%s", base, locale) >= PATH_MAX)
-	    return FALSE;
+        if (snprintf(buf, PATH_MAX, "%s-%s", base, locale) >= PATH_MAX)
+            return FALSE;
     }
     else {
-	if (strlen(base)+1 > PATH_MAX)
-	    return FALSE;
-	strcpy(buf,base);
+        if (strlen(base) + 1 > PATH_MAX)
+            return FALSE;
+        strcpy(buf, base);
     }
 
-    file= fopen(buf, "r");
-    if ((!file)&&(locale)) { /* fallback if locale was specified */
-	strcpy(buf,base);
-	file= fopen(buf, "r");
+    file = fopen(buf, "r");
+    if ((!file) && (locale)) {  /* fallback if locale was specified */
+        strcpy(buf, base);
+        file = fopen(buf, "r");
     }
     if (!file)
-	return FALSE;
-    ok= XkbRF_LoadRules(file,rules);
+        return FALSE;
+    ok = XkbRF_LoadRules(file, rules);
     fclose(file);
     return ok;
 }
@@ -970,48 +996,48 @@ Bool		ok;
 XkbRF_RulesPtr
 XkbRF_Create(void)
 {
-    return calloc(1, sizeof( XkbRF_RulesRec));
+    return calloc(1, sizeof(XkbRF_RulesRec));
 }
 
 /***====================================================================***/
 
 void
-XkbRF_Free(XkbRF_RulesPtr rules,Bool freeRules)
+XkbRF_Free(XkbRF_RulesPtr rules, Bool freeRules)
 {
-int		i;
-XkbRF_RulePtr	rule;
-XkbRF_GroupPtr	group;
+    int i;
+    XkbRF_RulePtr rule;
+    XkbRF_GroupPtr group;
 
     if (!rules)
-	return;
+        return;
     if (rules->rules) {
-	for (i=0,rule=rules->rules;i<rules->num_rules;i++,rule++) {
-	    free(rule->model);
-	    free(rule->layout);
-	    free(rule->variant);
-	    free(rule->option);
-	    free(rule->keycodes);
-	    free(rule->symbols);
-	    free(rule->types);
-	    free(rule->compat);
-	    free(rule->geometry);
-	    memset((char *)rule, 0, sizeof(XkbRF_RuleRec));
-	}
-	free(rules->rules);
-	rules->num_rules= rules->sz_rules= 0;
-	rules->rules= NULL;
+        for (i = 0, rule = rules->rules; i < rules->num_rules; i++, rule++) {
+            free(rule->model);
+            free(rule->layout);
+            free(rule->variant);
+            free(rule->option);
+            free(rule->keycodes);
+            free(rule->symbols);
+            free(rule->types);
+            free(rule->compat);
+            free(rule->geometry);
+            memset((char *) rule, 0, sizeof(XkbRF_RuleRec));
+        }
+        free(rules->rules);
+        rules->num_rules = rules->sz_rules = 0;
+        rules->rules = NULL;
     }
 
     if (rules->groups) {
-	for (i=0, group=rules->groups;i<rules->num_groups;i++,group++) {
-	    free(group->name);
-	    free(group->words);
-	}
-	free(rules->groups);
-	rules->num_groups= 0;
-	rules->groups= NULL;
+        for (i = 0, group = rules->groups; i < rules->num_groups; i++, group++) {
+            free(group->name);
+            free(group->words);
+        }
+        free(rules->groups);
+        rules->num_groups = 0;
+        rules->groups = NULL;
     }
     if (freeRules)
-	free(rules);
+        free(rules);
     return;
 }
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;
 }
-
-
diff --git a/xorg-server/xkb/xkbAccessX.c b/xorg-server/xkb/xkbAccessX.c
index d246827ea..111bf9f40 100644
--- a/xorg-server/xkb/xkbAccessX.c
+++ b/xorg-server/xkb/xkbAccessX.c
@@ -43,49 +43,52 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <sys/time.h>
 #endif
 
-int	XkbDfltRepeatDelay=	660;
-int	XkbDfltRepeatInterval=	40;
+int XkbDfltRepeatDelay = 660;
+int XkbDfltRepeatInterval = 40;
 
 #define	DFLT_TIMEOUT_CTRLS (XkbAX_KRGMask|XkbStickyKeysMask|XkbMouseKeysMask)
 #define	DFLT_TIMEOUT_OPTS  (XkbAX_IndicatorFBMask)
 
-unsigned short	XkbDfltAccessXTimeout= 	120;
-unsigned int	XkbDfltAccessXTimeoutMask= DFLT_TIMEOUT_CTRLS;
-static unsigned int XkbDfltAccessXTimeoutValues= 0;
-static unsigned int XkbDfltAccessXTimeoutOptionsMask= DFLT_TIMEOUT_OPTS;
-static unsigned int XkbDfltAccessXTimeoutOptionsValues= 0;
-unsigned int	XkbDfltAccessXFeedback= XkbAccessXFeedbackMask;
-unsigned short	XkbDfltAccessXOptions=  XkbAX_AllOptionsMask & ~(XkbAX_IndicatorFBMask|XkbAX_SKReleaseFBMask|XkbAX_SKRejectFBMask);
+unsigned short XkbDfltAccessXTimeout = 120;
+unsigned int XkbDfltAccessXTimeoutMask = DFLT_TIMEOUT_CTRLS;
+static unsigned int XkbDfltAccessXTimeoutValues = 0;
+static unsigned int XkbDfltAccessXTimeoutOptionsMask = DFLT_TIMEOUT_OPTS;
+static unsigned int XkbDfltAccessXTimeoutOptionsValues = 0;
+unsigned int XkbDfltAccessXFeedback = XkbAccessXFeedbackMask;
+unsigned short XkbDfltAccessXOptions =
+    XkbAX_AllOptionsMask & ~(XkbAX_IndicatorFBMask | XkbAX_SKReleaseFBMask |
+                             XkbAX_SKRejectFBMask);
 
 void
-AccessXComputeCurveFactor(XkbSrvInfoPtr xkbi,XkbControlsPtr ctrls)
+AccessXComputeCurveFactor(XkbSrvInfoPtr xkbi, XkbControlsPtr ctrls)
 {
-    xkbi->mouseKeysCurve= 1.0+(((double)ctrls->mk_curve)*0.001);
-    xkbi->mouseKeysCurveFactor= ( ((double)ctrls->mk_max_speed)/
-	pow((double)ctrls->mk_time_to_max,xkbi->mouseKeysCurve));
+    xkbi->mouseKeysCurve = 1.0 + (((double) ctrls->mk_curve) * 0.001);
+    xkbi->mouseKeysCurveFactor = (((double) ctrls->mk_max_speed) /
+                                  pow((double) ctrls->mk_time_to_max,
+                                      xkbi->mouseKeysCurve));
     return;
 }
 
 void
 AccessXInit(DeviceIntPtr keybd)
 {
-XkbSrvInfoPtr	xkbi = keybd->key->xkbInfo;
-XkbControlsPtr	ctrls = xkbi->desc->ctrls;
-
-    xkbi->shiftKeyCount= 0;
-    xkbi->mouseKeysCounter= 0;
-    xkbi->inactiveKey= 0;
-    xkbi->slowKey= 0;
-    xkbi->repeatKey= 0;
-    xkbi->krgTimerActive= _OFF_TIMER;
-    xkbi->beepType= _BEEP_NONE;
-    xkbi->beepCount= 0;
-    xkbi->mouseKeyTimer= NULL;
-    xkbi->slowKeysTimer= NULL;
-    xkbi->bounceKeysTimer= NULL;
-    xkbi->repeatKeyTimer= NULL;
-    xkbi->krgTimer= NULL;
-    xkbi->beepTimer= NULL;
+    XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+
+    xkbi->shiftKeyCount = 0;
+    xkbi->mouseKeysCounter = 0;
+    xkbi->inactiveKey = 0;
+    xkbi->slowKey = 0;
+    xkbi->repeatKey = 0;
+    xkbi->krgTimerActive = _OFF_TIMER;
+    xkbi->beepType = _BEEP_NONE;
+    xkbi->beepCount = 0;
+    xkbi->mouseKeyTimer = NULL;
+    xkbi->slowKeysTimer = NULL;
+    xkbi->bounceKeysTimer = NULL;
+    xkbi->repeatKeyTimer = NULL;
+    xkbi->krgTimer = NULL;
+    xkbi->beepTimer = NULL;
     ctrls->repeat_delay = XkbDfltRepeatDelay;
     ctrls->repeat_interval = XkbDfltRepeatInterval;
     ctrls->debounce_delay = 300;
@@ -102,12 +105,12 @@ XkbControlsPtr	ctrls = xkbi->desc->ctrls;
     ctrls->axt_opts_mask = XkbDfltAccessXTimeoutOptionsMask;
     ctrls->axt_opts_values = XkbDfltAccessXTimeoutOptionsValues;
     if (XkbDfltAccessXTimeout)
-	ctrls->enabled_ctrls |= XkbAccessXTimeoutMask;
+        ctrls->enabled_ctrls |= XkbAccessXTimeoutMask;
     else
-	ctrls->enabled_ctrls &= ~XkbAccessXTimeoutMask;
+        ctrls->enabled_ctrls &= ~XkbAccessXTimeoutMask;
     ctrls->enabled_ctrls |= XkbDfltAccessXFeedback;
-    ctrls->ax_options = XkbDfltAccessXOptions; 
-    AccessXComputeCurveFactor(xkbi,ctrls);
+    ctrls->ax_options = XkbDfltAccessXOptions;
+    AccessXComputeCurveFactor(xkbi, ctrls);
     return;
 }
 
@@ -118,11 +121,8 @@ XkbControlsPtr	ctrls = xkbi->desc->ctrls;
 /*	Generate a synthetic keyboard event.				*/
 /*									*/
 /************************************************************************/
-static void 
-AccessXKeyboardEvent(DeviceIntPtr	keybd,
-				 int		type,
-				 BYTE		keyCode,
-				 Bool		isRepeat)
+static void
+AccessXKeyboardEvent(DeviceIntPtr keybd, int type, BYTE keyCode, Bool isRepeat)
 {
     DeviceEvent event;
 
@@ -131,14 +131,14 @@ AccessXKeyboardEvent(DeviceIntPtr	keybd,
     event.detail.key = keyCode;
     event.key_repeat = isRepeat;
 
-    if (xkbDebugFlags&0x8) {
-	DebugF("[xkb] AXKE: Key %d %s\n", keyCode,
+    if (xkbDebugFlags & 0x8) {
+        DebugF("[xkb] AXKE: Key %d %s\n", keyCode,
                (event.type == ET_KeyPress ? "down" : "up"));
     }
 
     XkbProcessKeyboardEvent(&event, keybd);
     return;
-} /* AccessXKeyboardEvent */
+}                               /* AccessXKeyboardEvent */
 
 /************************************************************************/
 /*									*/
@@ -148,29 +148,29 @@ AccessXKeyboardEvent(DeviceIntPtr	keybd,
 /*									*/
 /************************************************************************/
 static void
-AccessXKRGTurnOn(DeviceIntPtr dev,CARD16 KRGControl,xkbControlsNotify	*pCN)
+AccessXKRGTurnOn(DeviceIntPtr dev, CARD16 KRGControl, xkbControlsNotify * pCN)
 {
-XkbSrvInfoPtr		xkbi = dev->key->xkbInfo;
-XkbControlsPtr		ctrls = xkbi->desc->ctrls;
-XkbControlsRec		old;
-XkbEventCauseRec	cause;
-XkbSrvLedInfoPtr	sli;
-
-    old= *ctrls;
-    ctrls->enabled_ctrls |= (KRGControl&XkbAX_KRGMask);
-    if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
-	XkbSendControlsNotify(dev,pCN);
-    cause.kc=		pCN->keycode;
-    cause.event=	pCN->eventType;
-    cause.mjr=		pCN->requestMajor;
-    cause.mnr=		pCN->requestMinor;
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
-    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
-	XkbDDXAccessXBeep(dev,_BEEP_FEATURE_ON,KRGControl);
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    XkbControlsRec old;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
+
+    old = *ctrls;
+    ctrls->enabled_ctrls |= (KRGControl & XkbAX_KRGMask);
+    if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+        XkbSendControlsNotify(dev, pCN);
+    cause.kc = pCN->keycode;
+    cause.event = pCN->eventType;
+    cause.mjr = pCN->requestMajor;
+    cause.mnr = pCN->requestMinor;
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+    if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+        XkbDDXAccessXBeep(dev, _BEEP_FEATURE_ON, KRGControl);
     return;
-    
-} /* AccessXKRGTurnOn */
+
+}                               /* AccessXKRGTurnOn */
 
 /************************************************************************/
 /*									*/
@@ -179,32 +179,33 @@ XkbSrvLedInfoPtr	sli;
 /*	Turn the keyboard response group off.				*/
 /*									*/
 /************************************************************************/
-static void 
-AccessXKRGTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
+static void
+AccessXKRGTurnOff(DeviceIntPtr dev, xkbControlsNotify * pCN)
 {
-XkbSrvInfoPtr		xkbi = dev->key->xkbInfo;
-XkbControlsPtr		ctrls = xkbi->desc->ctrls;
-XkbControlsRec		old;
-XkbEventCauseRec	cause;
-XkbSrvLedInfoPtr	sli;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    XkbControlsRec old;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
 
     old = *ctrls;
     ctrls->enabled_ctrls &= ~XkbAX_KRGMask;
-    if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
-	XkbSendControlsNotify(dev,pCN);
-    cause.kc=		pCN->keycode;
-    cause.event=	pCN->eventType;
-    cause.mjr=		pCN->requestMajor;
-    cause.mnr=		pCN->requestMinor;
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
-    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
-	unsigned changes= old.enabled_ctrls^ctrls->enabled_ctrls;
-	XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,changes);
+    if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+        XkbSendControlsNotify(dev, pCN);
+    cause.kc = pCN->keycode;
+    cause.event = pCN->eventType;
+    cause.mjr = pCN->requestMajor;
+    cause.mnr = pCN->requestMinor;
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+    if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+        unsigned changes = old.enabled_ctrls ^ ctrls->enabled_ctrls;
+
+        XkbDDXAccessXBeep(dev, _BEEP_FEATURE_OFF, changes);
     }
     return;
-    
-} /* AccessXKRGTurnOff */
+
+}                               /* AccessXKRGTurnOff */
 
 /************************************************************************/
 /*									*/
@@ -214,31 +215,31 @@ XkbSrvLedInfoPtr	sli;
 /*									*/
 /************************************************************************/
 static void
-AccessXStickyKeysTurnOn(DeviceIntPtr dev,xkbControlsNotify *pCN)
+AccessXStickyKeysTurnOn(DeviceIntPtr dev, xkbControlsNotify * pCN)
 {
-XkbSrvInfoPtr		xkbi = dev->key->xkbInfo;
-XkbControlsPtr		ctrls = xkbi->desc->ctrls;
-XkbControlsRec		old;
-XkbEventCauseRec	cause;
-XkbSrvLedInfoPtr	sli;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    XkbControlsRec old;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
 
     old = *ctrls;
     ctrls->enabled_ctrls |= XkbStickyKeysMask;
     xkbi->shiftKeyCount = 0;
-    if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
-	XkbSendControlsNotify(dev,pCN);
-    cause.kc=		pCN->keycode;
-    cause.event=	pCN->eventType;
-    cause.mjr=		pCN->requestMajor;
-    cause.mnr=		pCN->requestMinor;
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
-    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
-	XkbDDXAccessXBeep(dev,_BEEP_FEATURE_ON,XkbStickyKeysMask);
+    if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+        XkbSendControlsNotify(dev, pCN);
+    cause.kc = pCN->keycode;
+    cause.event = pCN->eventType;
+    cause.mjr = pCN->requestMajor;
+    cause.mnr = pCN->requestMinor;
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+    if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+        XkbDDXAccessXBeep(dev, _BEEP_FEATURE_ON, XkbStickyKeysMask);
     }
     return;
-    
-} /* AccessXStickyKeysTurnOn */
+
+}                               /* AccessXStickyKeysTurnOn */
 
 /************************************************************************/
 /*									*/
@@ -248,65 +249,67 @@ XkbSrvLedInfoPtr	sli;
 /*									*/
 /************************************************************************/
 static void
-AccessXStickyKeysTurnOff(DeviceIntPtr dev,xkbControlsNotify *pCN)
+AccessXStickyKeysTurnOff(DeviceIntPtr dev, xkbControlsNotify * pCN)
 {
-XkbSrvInfoPtr		xkbi = dev->key->xkbInfo;
-XkbControlsPtr		ctrls = xkbi->desc->ctrls;
-XkbControlsRec		old;
-XkbEventCauseRec	cause;
-XkbSrvLedInfoPtr	sli;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    XkbControlsRec old;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
 
     old = *ctrls;
     ctrls->enabled_ctrls &= ~XkbStickyKeysMask;
     xkbi->shiftKeyCount = 0;
-    if (XkbComputeControlsNotify(dev,&old,ctrls,pCN,FALSE))
-	XkbSendControlsNotify(dev,pCN);
-
-    cause.kc=		pCN->keycode;
-    cause.event=	pCN->eventType;
-    cause.mjr=		pCN->requestMajor;
-    cause.mnr=		pCN->requestMinor;
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
-    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask)) {
-	XkbDDXAccessXBeep(dev,_BEEP_FEATURE_OFF,XkbStickyKeysMask);
+    if (XkbComputeControlsNotify(dev, &old, ctrls, pCN, FALSE))
+        XkbSendControlsNotify(dev, pCN);
+
+    cause.kc = pCN->keycode;
+    cause.event = pCN->eventType;
+    cause.mjr = pCN->requestMajor;
+    cause.mnr = pCN->requestMinor;
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+    if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask)) {
+        XkbDDXAccessXBeep(dev, _BEEP_FEATURE_OFF, XkbStickyKeysMask);
     }
 #ifndef NO_CLEAR_LATCHES_FOR_STICKY_KEYS_OFF
-    XkbClearAllLatchesAndLocks(dev,xkbi,FALSE,&cause);
+    XkbClearAllLatchesAndLocks(dev, xkbi, FALSE, &cause);
 #endif
     return;
-} /* AccessXStickyKeysTurnOff */
+}                               /* AccessXStickyKeysTurnOff */
 
 static CARD32
-AccessXKRGExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXKRGExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-XkbSrvInfoPtr		xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
-xkbControlsNotify	cn;
-
-    if (xkbi->krgTimerActive==_KRG_WARN_TIMER) {
-	XkbDDXAccessXBeep((DeviceIntPtr)arg,_BEEP_SLOW_WARN,XkbStickyKeysMask);
-	xkbi->krgTimerActive= _KRG_TIMER;
-	return 4000;
+    XkbSrvInfoPtr xkbi = ((DeviceIntPtr) arg)->key->xkbInfo;
+    xkbControlsNotify cn;
+
+    if (xkbi->krgTimerActive == _KRG_WARN_TIMER) {
+        XkbDDXAccessXBeep((DeviceIntPtr) arg, _BEEP_SLOW_WARN,
+                          XkbStickyKeysMask);
+        xkbi->krgTimerActive = _KRG_TIMER;
+        return 4000;
     }
-    xkbi->krgTimerActive= _OFF_TIMER;
+    xkbi->krgTimerActive = _OFF_TIMER;
     cn.keycode = 0;
     cn.eventType = 0;
     cn.requestMajor = 0;
     cn.requestMinor = 0;
-    if (xkbi->desc->ctrls->enabled_ctrls&XkbSlowKeysMask)
-	 AccessXKRGTurnOff((DeviceIntPtr)arg,&cn);
-    else AccessXKRGTurnOn((DeviceIntPtr)arg,XkbSlowKeysMask,&cn);
+    if (xkbi->desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
+        AccessXKRGTurnOff((DeviceIntPtr) arg, &cn);
+    else
+        AccessXKRGTurnOn((DeviceIntPtr) arg, XkbSlowKeysMask, &cn);
     return 0;
 }
 
 static CARD32
-AccessXRepeatKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXRepeatKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-DeviceIntPtr    dev = (DeviceIntPtr) arg;
-XkbSrvInfoPtr	xkbi = dev->key->xkbInfo;
+    DeviceIntPtr dev = (DeviceIntPtr) arg;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
 
     if (xkbi->repeatKey == 0)
-	return 0;
+        return 0;
 
     AccessXKeyboardEvent(dev, ET_KeyPress, xkbi->repeatKey, TRUE);
 
@@ -314,118 +317,122 @@ XkbSrvInfoPtr	xkbi = dev->key->xkbInfo;
 }
 
 void
-AccessXCancelRepeatKey(XkbSrvInfoPtr xkbi,KeyCode key)
+AccessXCancelRepeatKey(XkbSrvInfoPtr xkbi, KeyCode key)
 {
-    if (xkbi->repeatKey==key)
-	xkbi->repeatKey= 0;
+    if (xkbi->repeatKey == key)
+        xkbi->repeatKey = 0;
     return;
 }
 
 static CARD32
-AccessXSlowKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXSlowKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-DeviceIntPtr	keybd;
-XkbSrvInfoPtr	xkbi;
-XkbDescPtr	xkb;
-XkbControlsPtr	ctrls;
-
-    keybd= 	(DeviceIntPtr)arg;
-    xkbi= 	keybd->key->xkbInfo;
-    xkb= 	xkbi->desc;
-    ctrls= 	xkb->ctrls;
-    if (xkbi->slowKey!=0) {
-	xkbAccessXNotify ev;
-	KeySym *sym= XkbKeySymsPtr(xkb,xkbi->slowKey);
-	ev.detail= XkbAXN_SKAccept;
-	ev.keycode= xkbi->slowKey;
-	ev.slowKeysDelay= ctrls->slow_keys_delay;
-	ev.debounceDelay= ctrls->debounce_delay;
-	XkbSendAccessXNotify(keybd,&ev);
-	if (XkbAX_NeedFeedback(ctrls,XkbAX_SKAcceptFBMask))
-	    XkbDDXAccessXBeep(keybd,_BEEP_SLOW_ACCEPT,XkbSlowKeysMask);
-	AccessXKeyboardEvent(keybd, ET_KeyPress,xkbi->slowKey,FALSE);
-	/* check for magic sequences */
-	if ((ctrls->enabled_ctrls&XkbAccessXKeysMask) &&
-	    ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)))
-	    xkbi->shiftKeyCount++;
-
-	/* Start repeating if necessary.  Stop autorepeating if the user
-	 * presses a non-modifier key that doesn't autorepeat.
-	 */
-	if (keybd->kbdfeed->ctrl.autoRepeat && 
-	    ((xkbi->slowKey != xkbi->mouseKey) || (!xkbi->mouseKeysAccel)) &&
-	     (ctrls->enabled_ctrls&XkbRepeatKeysMask)) {
-	    if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats,xkbi->slowKey)) {
-		xkbi->repeatKey = xkbi->slowKey;
-		xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
-					0, ctrls->repeat_delay,
-					AccessXRepeatKeyExpire, (pointer)keybd);
-	    }
-	}
+    DeviceIntPtr keybd;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
+    XkbControlsPtr ctrls;
+
+    keybd = (DeviceIntPtr) arg;
+    xkbi = keybd->key->xkbInfo;
+    xkb = xkbi->desc;
+    ctrls = xkb->ctrls;
+    if (xkbi->slowKey != 0) {
+        xkbAccessXNotify ev;
+        KeySym *sym = XkbKeySymsPtr(xkb, xkbi->slowKey);
+
+        ev.detail = XkbAXN_SKAccept;
+        ev.keycode = xkbi->slowKey;
+        ev.slowKeysDelay = ctrls->slow_keys_delay;
+        ev.debounceDelay = ctrls->debounce_delay;
+        XkbSendAccessXNotify(keybd, &ev);
+        if (XkbAX_NeedFeedback(ctrls, XkbAX_SKAcceptFBMask))
+            XkbDDXAccessXBeep(keybd, _BEEP_SLOW_ACCEPT, XkbSlowKeysMask);
+        AccessXKeyboardEvent(keybd, ET_KeyPress, xkbi->slowKey, FALSE);
+        /* check for magic sequences */
+        if ((ctrls->enabled_ctrls & XkbAccessXKeysMask) &&
+            ((sym[0] == XK_Shift_R) || (sym[0] == XK_Shift_L)))
+            xkbi->shiftKeyCount++;
+
+        /* Start repeating if necessary.  Stop autorepeating if the user
+         * presses a non-modifier key that doesn't autorepeat.
+         */
+        if (keybd->kbdfeed->ctrl.autoRepeat &&
+            ((xkbi->slowKey != xkbi->mouseKey) || (!xkbi->mouseKeysAccel)) &&
+            (ctrls->enabled_ctrls & XkbRepeatKeysMask)) {
+            if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats, xkbi->slowKey)) {
+                xkbi->repeatKey = xkbi->slowKey;
+                xkbi->repeatKeyTimer = TimerSet(xkbi->repeatKeyTimer,
+                                                0, ctrls->repeat_delay,
+                                                AccessXRepeatKeyExpire,
+                                                (pointer) keybd);
+            }
+        }
     }
     return 0;
 }
 
 static CARD32
-AccessXBounceKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXBounceKeyExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-XkbSrvInfoPtr	xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
+    XkbSrvInfoPtr xkbi = ((DeviceIntPtr) arg)->key->xkbInfo;
 
-    xkbi->inactiveKey= 0;
+    xkbi->inactiveKey = 0;
     return 0;
 }
 
 static CARD32
-AccessXTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXTimeoutExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-DeviceIntPtr		dev = (DeviceIntPtr)arg;
-XkbSrvInfoPtr		xkbi= dev->key->xkbInfo;
-XkbControlsPtr		ctrls= xkbi->desc->ctrls;
-XkbControlsRec		old;
-xkbControlsNotify	cn;
-XkbEventCauseRec	cause;
-XkbSrvLedInfoPtr	sli;
+    DeviceIntPtr dev = (DeviceIntPtr) arg;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    XkbControlsRec old;
+    xkbControlsNotify cn;
+    XkbEventCauseRec cause;
+    XkbSrvLedInfoPtr sli;
 
     if (xkbi->lastPtrEventTime) {
-	unsigned timeToWait = (ctrls->ax_timeout*1000);
-	unsigned timeElapsed = (now-xkbi->lastPtrEventTime);
+        unsigned timeToWait = (ctrls->ax_timeout * 1000);
+        unsigned timeElapsed = (now - xkbi->lastPtrEventTime);
 
-	if (timeToWait > timeElapsed)
-	    return timeToWait - timeElapsed;
+        if (timeToWait > timeElapsed)
+            return timeToWait - timeElapsed;
     }
-    old= *ctrls;
-    xkbi->shiftKeyCount= 0;
-    ctrls->enabled_ctrls&= ~ctrls->axt_ctrls_mask;
-    ctrls->enabled_ctrls|= 
-	(ctrls->axt_ctrls_values&ctrls->axt_ctrls_mask);
+    old = *ctrls;
+    xkbi->shiftKeyCount = 0;
+    ctrls->enabled_ctrls &= ~ctrls->axt_ctrls_mask;
+    ctrls->enabled_ctrls |= (ctrls->axt_ctrls_values & ctrls->axt_ctrls_mask);
     if (ctrls->axt_opts_mask) {
-	ctrls->ax_options&= ~ctrls->axt_opts_mask;
-	ctrls->ax_options|= (ctrls->axt_opts_values&ctrls->axt_opts_mask);
+        ctrls->ax_options &= ~ctrls->axt_opts_mask;
+        ctrls->ax_options |= (ctrls->axt_opts_values & ctrls->axt_opts_mask);
     }
-    if (XkbComputeControlsNotify(dev,&old,ctrls,&cn,FALSE)) {
-	cn.keycode = 0;
-	cn.eventType = 0;
-	cn.requestMajor = 0;
-	cn.requestMinor = 0;
-	XkbSendControlsNotify(dev,&cn);
+    if (XkbComputeControlsNotify(dev, &old, ctrls, &cn, FALSE)) {
+        cn.keycode = 0;
+        cn.eventType = 0;
+        cn.requestMajor = 0;
+        cn.requestMinor = 0;
+        XkbSendControlsNotify(dev, &cn);
     }
     XkbSetCauseUnknown(&cause);
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(dev,sli->usesControls,TRUE,NULL,&cause);
-    if (ctrls->ax_options!=old.ax_options) {
-	unsigned set,cleared,bell;
-	set= ctrls->ax_options&(~old.ax_options);
-	cleared= (~ctrls->ax_options)&old.ax_options;
-	if (set && cleared)	bell= _BEEP_FEATURE_CHANGE;
-	else if (set)		bell= _BEEP_FEATURE_ON;
-	else 			bell= _BEEP_FEATURE_OFF;
-	XkbDDXAccessXBeep(dev,bell,XkbAccessXTimeoutMask);
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(dev, sli->usesControls, TRUE, NULL, &cause);
+    if (ctrls->ax_options != old.ax_options) {
+        unsigned set, cleared, bell;
+
+        set = ctrls->ax_options & (~old.ax_options);
+        cleared = (~ctrls->ax_options) & old.ax_options;
+        if (set && cleared)
+            bell = _BEEP_FEATURE_CHANGE;
+        else if (set)
+            bell = _BEEP_FEATURE_ON;
+        else
+            bell = _BEEP_FEATURE_OFF;
+        XkbDDXAccessXBeep(dev, bell, XkbAccessXTimeoutMask);
     }
-    xkbi->krgTimerActive= _OFF_TIMER;
+    xkbi->krgTimerActive = _OFF_TIMER;
     return 0;
 }
 
-
 /************************************************************************/
 /*									*/
 /* AccessXFilterPressEvent						*/
@@ -439,125 +446,129 @@ XkbSrvLedInfoPtr	sli;
 /*									*/
 /************************************************************************/
 Bool
-AccessXFilterPressEvent(	DeviceEvent*	event,
-				DeviceIntPtr	keybd)
+AccessXFilterPressEvent(DeviceEvent *event, DeviceIntPtr keybd)
 {
-XkbSrvInfoPtr	xkbi = keybd->key->xkbInfo;
-XkbControlsPtr	ctrls = xkbi->desc->ctrls;
-Bool		ignoreKeyEvent = FALSE;
-KeyCode		key = event->detail.key;
-KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
-
-    if (ctrls->enabled_ctrls&XkbAccessXKeysMask) {
-	/* check for magic sequences */
-	if ((sym[0]==XK_Shift_R)||(sym[0]==XK_Shift_L)) {
-	    if (XkbAX_NeedFeedback(ctrls,XkbAX_SlowWarnFBMask)) {
-		xkbi->krgTimerActive = _KRG_WARN_TIMER;
-		xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 4000,
-					AccessXKRGExpire, (pointer)keybd);
-	    }
-	    else {
-		xkbi->krgTimerActive = _KRG_TIMER;
-		xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 8000,
-					AccessXKRGExpire, (pointer)keybd);
-	    }
-	    if (!(ctrls->enabled_ctrls & XkbSlowKeysMask)) {
-		CARD32 now= GetTimeInMillis();
-		if ((now-xkbi->lastShiftEventTime)>15000)
-		     xkbi->shiftKeyCount= 1;
-		else xkbi->shiftKeyCount++;
-		xkbi->lastShiftEventTime= now;
-	    }
-	}
-	else {
-	    if (xkbi->krgTimerActive) {
-		xkbi->krgTimer= TimerSet(xkbi->krgTimer,0, 0, NULL, NULL);
-		xkbi->krgTimerActive= _OFF_TIMER;
-	    }
-	}
+    XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    Bool ignoreKeyEvent = FALSE;
+    KeyCode key = event->detail.key;
+    KeySym *sym = XkbKeySymsPtr(xkbi->desc, key);
+
+    if (ctrls->enabled_ctrls & XkbAccessXKeysMask) {
+        /* check for magic sequences */
+        if ((sym[0] == XK_Shift_R) || (sym[0] == XK_Shift_L)) {
+            if (XkbAX_NeedFeedback(ctrls, XkbAX_SlowWarnFBMask)) {
+                xkbi->krgTimerActive = _KRG_WARN_TIMER;
+                xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 4000,
+                                          AccessXKRGExpire, (pointer) keybd);
+            }
+            else {
+                xkbi->krgTimerActive = _KRG_TIMER;
+                xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 8000,
+                                          AccessXKRGExpire, (pointer) keybd);
+            }
+            if (!(ctrls->enabled_ctrls & XkbSlowKeysMask)) {
+                CARD32 now = GetTimeInMillis();
+
+                if ((now - xkbi->lastShiftEventTime) > 15000)
+                    xkbi->shiftKeyCount = 1;
+                else
+                    xkbi->shiftKeyCount++;
+                xkbi->lastShiftEventTime = now;
+            }
+        }
+        else {
+            if (xkbi->krgTimerActive) {
+                xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
+                xkbi->krgTimerActive = _OFF_TIMER;
+            }
+        }
     }
-	
+
     /* Don't transmit the KeyPress if SlowKeys is turned on;
      * The wakeup handler will synthesize one for us if the user
      * has held the key long enough.
      */
     if (ctrls->enabled_ctrls & XkbSlowKeysMask) {
-	xkbAccessXNotify	ev;
-	/* If key was already pressed, ignore subsequent press events
-	 * from the server's autorepeat
-	 */
-	if(xkbi->slowKey == key)
-	    return TRUE;
-	ev.detail= XkbAXN_SKPress;
-	ev.keycode= key;
-	ev.slowKeysDelay= ctrls->slow_keys_delay;
-	ev.debounceDelay= ctrls->debounce_delay;
-	XkbSendAccessXNotify(keybd,&ev);
-	if (XkbAX_NeedFeedback(ctrls,XkbAX_SKPressFBMask))
-	    XkbDDXAccessXBeep(keybd,_BEEP_SLOW_PRESS,XkbSlowKeysMask);
-	xkbi->slowKey= key;
-	xkbi->slowKeysTimer = TimerSet(xkbi->slowKeysTimer,
-				 0, ctrls->slow_keys_delay,
-				 AccessXSlowKeyExpire, (pointer)keybd);
-	ignoreKeyEvent = TRUE;
+        xkbAccessXNotify ev;
+
+        /* If key was already pressed, ignore subsequent press events
+         * from the server's autorepeat
+         */
+        if (xkbi->slowKey == key)
+            return TRUE;
+        ev.detail = XkbAXN_SKPress;
+        ev.keycode = key;
+        ev.slowKeysDelay = ctrls->slow_keys_delay;
+        ev.debounceDelay = ctrls->debounce_delay;
+        XkbSendAccessXNotify(keybd, &ev);
+        if (XkbAX_NeedFeedback(ctrls, XkbAX_SKPressFBMask))
+            XkbDDXAccessXBeep(keybd, _BEEP_SLOW_PRESS, XkbSlowKeysMask);
+        xkbi->slowKey = key;
+        xkbi->slowKeysTimer = TimerSet(xkbi->slowKeysTimer,
+                                       0, ctrls->slow_keys_delay,
+                                       AccessXSlowKeyExpire, (pointer) keybd);
+        ignoreKeyEvent = TRUE;
     }
 
     /* Don't transmit the KeyPress if BounceKeys is turned on
      * and the user pressed the same key within a given time period
      * from the last release.
      */
-    else if ((ctrls->enabled_ctrls & XkbBounceKeysMask) && 
-					(key == xkbi->inactiveKey)) {
-	if (XkbAX_NeedFeedback(ctrls,XkbAX_BKRejectFBMask))
-	    XkbDDXAccessXBeep(keybd,_BEEP_BOUNCE_REJECT,XkbBounceKeysMask);
-	ignoreKeyEvent = TRUE;
+    else if ((ctrls->enabled_ctrls & XkbBounceKeysMask) &&
+             (key == xkbi->inactiveKey)) {
+        if (XkbAX_NeedFeedback(ctrls, XkbAX_BKRejectFBMask))
+            XkbDDXAccessXBeep(keybd, _BEEP_BOUNCE_REJECT, XkbBounceKeysMask);
+        ignoreKeyEvent = TRUE;
     }
 
     /* Start repeating if necessary.  Stop autorepeating if the user
      * presses a non-modifier key that doesn't autorepeat.
      */
     if (XkbDDXUsesSoftRepeat(keybd)) {
-	if ((keybd->kbdfeed->ctrl.autoRepeat) &&
-		((ctrls->enabled_ctrls&(XkbSlowKeysMask|XkbRepeatKeysMask))==
-							XkbRepeatKeysMask)) {
-	    if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats,key)) {
-		if (xkbDebugFlags&0x10)
-		    DebugF("Starting software autorepeat...\n");
-		if (xkbi->repeatKey == key)
-		    ignoreKeyEvent = TRUE;
-		else {
-		    xkbi->repeatKey = key;
-		    xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
-			    0, ctrls->repeat_delay,
-			    AccessXRepeatKeyExpire, (pointer)keybd);
-		}
-	    }
-	}
+        if ((keybd->kbdfeed->ctrl.autoRepeat) &&
+            ((ctrls->enabled_ctrls & (XkbSlowKeysMask | XkbRepeatKeysMask)) ==
+             XkbRepeatKeysMask)) {
+            if (BitIsOn(keybd->kbdfeed->ctrl.autoRepeats, key)) {
+                if (xkbDebugFlags & 0x10)
+                    DebugF("Starting software autorepeat...\n");
+                if (xkbi->repeatKey == key)
+                    ignoreKeyEvent = TRUE;
+                else {
+                    xkbi->repeatKey = key;
+                    xkbi->repeatKeyTimer = TimerSet(xkbi->repeatKeyTimer,
+                                                    0, ctrls->repeat_delay,
+                                                    AccessXRepeatKeyExpire,
+                                                    (pointer) keybd);
+                }
+            }
+        }
     }
-    
+
     /* Check for two keys being pressed at the same time.  This section
      * essentially says the following:
      *
-     *	If StickyKeys is on, and a modifier is currently being held down,
+     *  If StickyKeys is on, and a modifier is currently being held down,
      *  and one of the following is true:  the current key is not a modifier
      *  or the currentKey is a modifier, but not the only modifier being
      *  held down, turn StickyKeys off if the TwoKeys off ctrl is set.
      */
-    if ((ctrls->enabled_ctrls & XkbStickyKeysMask) && 
-				(xkbi->state.base_mods!=0) &&
-				(XkbAX_NeedOption(ctrls,XkbAX_TwoKeysMask))) {
-	xkbControlsNotify cn;
-	cn.keycode = key;
-	cn.eventType = KeyPress;
-	cn.requestMajor = 0;
-	cn.requestMinor = 0;
-	AccessXStickyKeysTurnOff(keybd,&cn);
+    if ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&
+        (xkbi->state.base_mods != 0) &&
+        (XkbAX_NeedOption(ctrls, XkbAX_TwoKeysMask))) {
+        xkbControlsNotify cn;
+
+        cn.keycode = key;
+        cn.eventType = KeyPress;
+        cn.requestMajor = 0;
+        cn.requestMinor = 0;
+        AccessXStickyKeysTurnOff(keybd, &cn);
     }
-    
+
     if (!ignoreKeyEvent)
-	XkbProcessKeyboardEvent(event, keybd);
+        XkbProcessKeyboardEvent(event, keybd);
     return ignoreKeyEvent;
-} /* AccessXFilterPressEvent */
+}                               /* AccessXFilterPressEvent */
 
 /************************************************************************/
 /*									*/
@@ -572,25 +583,25 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 /*									*/
 /************************************************************************/
 Bool
-AccessXFilterReleaseEvent(	DeviceEvent*	event,
-				DeviceIntPtr	keybd)
+AccessXFilterReleaseEvent(DeviceEvent *event, DeviceIntPtr keybd)
 {
-XkbSrvInfoPtr	xkbi = keybd->key->xkbInfo;
-XkbControlsPtr	ctrls = xkbi->desc->ctrls;
-KeyCode		key = event->detail.key;
-Bool		ignoreKeyEvent = FALSE;
-    
+    XkbSrvInfoPtr xkbi = keybd->key->xkbInfo;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    KeyCode key = event->detail.key;
+    Bool ignoreKeyEvent = FALSE;
+
     /* Don't transmit the KeyRelease if BounceKeys is on and
      * this is the release of a key that was ignored due to 
      * BounceKeys.
      */
     if (ctrls->enabled_ctrls & XkbBounceKeysMask) {
-	if ((key!=xkbi->mouseKey)&&(!BitIsOn(keybd->key->down,key)))
-	    ignoreKeyEvent = TRUE;
-	xkbi->inactiveKey= key;
-	xkbi->bounceKeysTimer= TimerSet(xkbi->bounceKeysTimer, 0,
-					ctrls->debounce_delay,
-					AccessXBounceKeyExpire, (pointer)keybd);
+        if ((key != xkbi->mouseKey) && (!BitIsOn(keybd->key->down, key)))
+            ignoreKeyEvent = TRUE;
+        xkbi->inactiveKey = key;
+        xkbi->bounceKeysTimer = TimerSet(xkbi->bounceKeysTimer, 0,
+                                         ctrls->debounce_delay,
+                                         AccessXBounceKeyExpire,
+                                         (pointer) keybd);
     }
 
     /* Don't transmit the KeyRelease if SlowKeys is turned on and
@@ -598,75 +609,79 @@ Bool		ignoreKeyEvent = FALSE;
      * the key if the down bit was set by CoreProcessKeyboadEvent.
      */
     if (ctrls->enabled_ctrls & XkbSlowKeysMask) {
-	xkbAccessXNotify	ev;
-	unsigned		beep_type;
-	ev.keycode= key;
-	ev.slowKeysDelay= ctrls->slow_keys_delay;
-	ev.debounceDelay= ctrls->debounce_delay;
-	if (BitIsOn(keybd->key->down,key) || (xkbi->mouseKey == key)) {
-	    ev.detail= XkbAXN_SKRelease;
-	    beep_type= _BEEP_SLOW_RELEASE;
-	}
-	else {
-	    ev.detail= XkbAXN_SKReject;
-	    beep_type= _BEEP_SLOW_REJECT;
-	    ignoreKeyEvent = TRUE;
-	}
-	XkbSendAccessXNotify(keybd,&ev);
-	if (XkbAX_NeedFeedback(ctrls,XkbAX_SKRejectFBMask)) {
-	    XkbDDXAccessXBeep(keybd,beep_type,XkbSlowKeysMask);
-	}
-	if (xkbi->slowKey==key)
-	    xkbi->slowKey= 0;
+        xkbAccessXNotify ev;
+        unsigned beep_type;
+
+        ev.keycode = key;
+        ev.slowKeysDelay = ctrls->slow_keys_delay;
+        ev.debounceDelay = ctrls->debounce_delay;
+        if (BitIsOn(keybd->key->down, key) || (xkbi->mouseKey == key)) {
+            ev.detail = XkbAXN_SKRelease;
+            beep_type = _BEEP_SLOW_RELEASE;
+        }
+        else {
+            ev.detail = XkbAXN_SKReject;
+            beep_type = _BEEP_SLOW_REJECT;
+            ignoreKeyEvent = TRUE;
+        }
+        XkbSendAccessXNotify(keybd, &ev);
+        if (XkbAX_NeedFeedback(ctrls, XkbAX_SKRejectFBMask)) {
+            XkbDDXAccessXBeep(keybd, beep_type, XkbSlowKeysMask);
+        }
+        if (xkbi->slowKey == key)
+            xkbi->slowKey = 0;
     }
 
     /* Stop Repeating if the user releases the key that is currently
      * repeating.
      */
-    if (xkbi->repeatKey==key) {
-	xkbi->repeatKey= 0;
+    if (xkbi->repeatKey == key) {
+        xkbi->repeatKey = 0;
     }
 
-    if ((ctrls->enabled_ctrls&XkbAccessXTimeoutMask)&&(ctrls->ax_timeout>0)) {
-	xkbi->lastPtrEventTime= 0;
-	xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 
-					ctrls->ax_timeout*1000,
-					AccessXTimeoutExpire, (pointer)keybd);
-	xkbi->krgTimerActive= _ALL_TIMEOUT_TIMER;
+    if ((ctrls->enabled_ctrls & XkbAccessXTimeoutMask) &&
+        (ctrls->ax_timeout > 0)) {
+        xkbi->lastPtrEventTime = 0;
+        xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0,
+                                  ctrls->ax_timeout * 1000,
+                                  AccessXTimeoutExpire, (pointer) keybd);
+        xkbi->krgTimerActive = _ALL_TIMEOUT_TIMER;
     }
-    else if (xkbi->krgTimerActive!=_OFF_TIMER) {
-	xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
-	xkbi->krgTimerActive= _OFF_TIMER;
+    else if (xkbi->krgTimerActive != _OFF_TIMER) {
+        xkbi->krgTimer = TimerSet(xkbi->krgTimer, 0, 0, NULL, NULL);
+        xkbi->krgTimerActive = _OFF_TIMER;
     }
-	
+
     /* Keep track of how many times the Shift key has been pressed.
      * If it has been pressed and released 5 times in a row, toggle
      * the state of StickyKeys.
      */
-    if ((!ignoreKeyEvent)&&(xkbi->shiftKeyCount)) {
-	KeySym *pSym= XkbKeySymsPtr(xkbi->desc,key);
-	if ((pSym[0]!=XK_Shift_L)&&(pSym[0]!=XK_Shift_R)) {
-	    xkbi->shiftKeyCount= 0;
-	}
-	else if (xkbi->shiftKeyCount>=5) {
-	     xkbControlsNotify cn;
-	     cn.keycode = key;
-	     cn.eventType = KeyPress;
-	     cn.requestMajor = 0;
-	     cn.requestMinor = 0;
-	     if (ctrls->enabled_ctrls & XkbStickyKeysMask)
-		AccessXStickyKeysTurnOff(keybd,&cn);
-	     else
-		AccessXStickyKeysTurnOn(keybd,&cn);
-	     xkbi->shiftKeyCount= 0;
-	}
+    if ((!ignoreKeyEvent) && (xkbi->shiftKeyCount)) {
+        KeySym *pSym = XkbKeySymsPtr(xkbi->desc, key);
+
+        if ((pSym[0] != XK_Shift_L) && (pSym[0] != XK_Shift_R)) {
+            xkbi->shiftKeyCount = 0;
+        }
+        else if (xkbi->shiftKeyCount >= 5) {
+            xkbControlsNotify cn;
+
+            cn.keycode = key;
+            cn.eventType = KeyPress;
+            cn.requestMajor = 0;
+            cn.requestMinor = 0;
+            if (ctrls->enabled_ctrls & XkbStickyKeysMask)
+                AccessXStickyKeysTurnOff(keybd, &cn);
+            else
+                AccessXStickyKeysTurnOn(keybd, &cn);
+            xkbi->shiftKeyCount = 0;
+        }
     }
-    
+
     if (!ignoreKeyEvent)
-	XkbProcessKeyboardEvent(event, keybd);
+        XkbProcessKeyboardEvent(event, keybd);
     return ignoreKeyEvent;
-    
-} /* AccessXFilterReleaseEvent */
+
+}                               /* AccessXFilterReleaseEvent */
 
 /************************************************************************/
 /*									*/
@@ -681,90 +696,87 @@ Bool		ignoreKeyEvent = FALSE;
 extern int xkbDevicePrivateIndex;
 extern void xkbUnwrapProc(DeviceIntPtr, DeviceHandleProc, pointer);
 void
-ProcessPointerEvent(	InternalEvent   *ev,
-			DeviceIntPtr    mouse)
+ProcessPointerEvent(InternalEvent *ev, DeviceIntPtr mouse)
 {
-DeviceIntPtr	dev;
-XkbSrvInfoPtr	xkbi = NULL;
-unsigned 	changed = 0;
-ProcessInputProc backupproc;
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
-DeviceEvent     *event = &ev->device_event;
+    DeviceIntPtr dev;
+    XkbSrvInfoPtr xkbi = NULL;
+    unsigned changed = 0;
+    ProcessInputProc backupproc;
+    xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(mouse);
+    DeviceEvent *event = &ev->device_event;
 
     dev = IsFloating(mouse) ? mouse : GetMaster(mouse, MASTER_KEYBOARD);
 
-    if (dev && dev->key)
-    {
-	xkbi = dev->key->xkbInfo;
-	xkbi->shiftKeyCount = 0;
-	xkbi->lastPtrEventTime= event->time;
+    if (dev && dev->key) {
+        xkbi = dev->key->xkbInfo;
+        xkbi->shiftKeyCount = 0;
+        xkbi->lastPtrEventTime = event->time;
     }
 
     if (event->type == ET_ButtonPress) {
-	    changed |= XkbPointerButtonMask;
+        changed |= XkbPointerButtonMask;
     }
     else if (event->type == ET_ButtonRelease) {
-	if (xkbi) {
-	    xkbi->lockedPtrButtons&= ~(1 << (event->detail.key & 0x7));
+        if (xkbi) {
+            xkbi->lockedPtrButtons &= ~(1 << (event->detail.key & 0x7));
 
-            if (IsMaster(dev))
-            {
+            if (IsMaster(dev)) {
                 DeviceIntPtr source;
                 int rc;
-                rc = dixLookupDevice(&source, event->sourceid, serverClient, DixWriteAccess);
+
+                rc = dixLookupDevice(&source, event->sourceid, serverClient,
+                                     DixWriteAccess);
                 if (rc != Success)
-                    ErrorF("[xkb] bad sourceid '%d' on button release event.\n", event->sourceid);
+                    ErrorF("[xkb] bad sourceid '%d' on button release event.\n",
+                           event->sourceid);
                 else if (!IsXTestDevice(source, GetMaster(dev, MASTER_POINTER)))
                     XkbFakeDeviceButton(dev, FALSE, event->detail.key);
             }
-	}
+        }
 
-	changed |= XkbPointerButtonMask;
+        changed |= XkbPointerButtonMask;
     }
 
     UNWRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr, backupproc);
     mouse->public.processInputProc(ev, mouse);
-    COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr,
-				     backupproc, xkbUnwrapProc);
+    COND_WRAP_PROCESS_INPUT_PROC(mouse, xkbPrivPtr, backupproc, xkbUnwrapProc);
 
     if (!xkbi)
-	return;
+        return;
 
     xkbi->state.ptr_buttons = (mouse->button) ? mouse->button->state : 0;
-    
-    /* clear any latched modifiers */
-    if ( xkbi->state.latched_mods && (event->type == ET_ButtonRelease) ) {
-	unsigned 		changed_leds;
-	XkbStateRec		oldState;
-	XkbSrvLedInfoPtr	sli;
-
-	sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-	oldState= xkbi->state;
-	XkbLatchModifiers(dev,0xFF,0x00);
-
-	XkbComputeDerivedState(xkbi);
-	changed |= XkbStateChangedFlags(&oldState,&xkbi->state);
-	if (changed&sli->usedComponents) {
-	    changed_leds= XkbIndicatorsToUpdate(dev,changed,FALSE);
-	    if (changed_leds) {
-		XkbEventCauseRec	cause;
-		XkbSetCauseKey(&cause,(event->detail.key & 0x7), event->type);
-		XkbUpdateIndicators(dev,changed_leds,TRUE,NULL,&cause);
-	    }
-	}
-    }
 
-    if (((xkbi->flags&_XkbStateNotifyInProgress)==0)&&(changed!=0)) {
-	xkbStateNotify	sn;
-	sn.keycode= event->detail.key;
-	sn.eventType= event->type;
-	sn.requestMajor = sn.requestMinor = 0;
-	sn.changed= changed;
-	XkbSendStateNotify(dev,&sn);
+    /* clear any latched modifiers */
+    if (xkbi->state.latched_mods && (event->type == ET_ButtonRelease)) {
+        unsigned changed_leds;
+        XkbStateRec oldState;
+        XkbSrvLedInfoPtr sli;
+
+        sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+        oldState = xkbi->state;
+        XkbLatchModifiers(dev, 0xFF, 0x00);
+
+        XkbComputeDerivedState(xkbi);
+        changed |= XkbStateChangedFlags(&oldState, &xkbi->state);
+        if (changed & sli->usedComponents) {
+            changed_leds = XkbIndicatorsToUpdate(dev, changed, FALSE);
+            if (changed_leds) {
+                XkbEventCauseRec cause;
+
+                XkbSetCauseKey(&cause, (event->detail.key & 0x7), event->type);
+                XkbUpdateIndicators(dev, changed_leds, TRUE, NULL, &cause);
+            }
+        }
     }
 
-} /* ProcessPointerEvent */
-
-
+    if (((xkbi->flags & _XkbStateNotifyInProgress) == 0) && (changed != 0)) {
+        xkbStateNotify sn;
 
+        sn.keycode = event->detail.key;
+        sn.eventType = event->type;
+        sn.requestMajor = sn.requestMinor = 0;
+        sn.changed = changed;
+        XkbSendStateNotify(dev, &sn);
+    }
 
+}                               /* ProcessPointerEvent */
diff --git a/xorg-server/xkb/xkbActions.c b/xorg-server/xkb/xkbActions.c
index 8f3c3dd2b..323886274 100644
--- a/xorg-server/xkb/xkbActions.c
+++ b/xorg-server/xkb/xkbActions.c
@@ -47,122 +47,129 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 DevPrivateKeyRec xkbDevicePrivateKeyRec;
 
-void XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button);
-static void XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y);
+void XkbFakeDeviceButton(DeviceIntPtr dev, Bool press, int button);
+static void XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags, int x,
+                                 int y);
 
 void
-xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc,
-                   pointer data)
+xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, pointer data)
 {
     xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);
     ProcessInputProc backupproc;
-    if(xkbPrivPtr->unwrapProc)
-	xkbPrivPtr->unwrapProc = NULL;
 
-    UNWRAP_PROCESS_INPUT_PROC(device,xkbPrivPtr, backupproc);
-    proc(device,data);
-    COND_WRAP_PROCESS_INPUT_PROC(device,xkbPrivPtr,
-				 backupproc,xkbUnwrapProc);
+    if (xkbPrivPtr->unwrapProc)
+        xkbPrivPtr->unwrapProc = NULL;
+
+    UNWRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc);
+    proc(device, data);
+    COND_WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, backupproc, xkbUnwrapProc);
 }
 
 Bool
 XkbInitPrivates(void)
 {
-    return dixRegisterPrivateKey(&xkbDevicePrivateKeyRec, PRIVATE_DEVICE, sizeof(xkbDeviceInfoRec));
+    return dixRegisterPrivateKey(&xkbDevicePrivateKeyRec, PRIVATE_DEVICE,
+                                 sizeof(xkbDeviceInfoRec));
 }
 
 void
 XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc)
 {
     xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);
+
     WRAP_PROCESS_INPUT_PROC(device, xkbPrivPtr, proc, xkbUnwrapProc);
 }
 
 /***====================================================================***/
 
 static XkbAction
-_FixUpAction(XkbDescPtr xkb,XkbAction *act)
+_FixUpAction(XkbDescPtr xkb, XkbAction *act)
 {
-static XkbAction	fake;
+    static XkbAction fake;
 
-    if (XkbIsPtrAction(act)&&(!(xkb->ctrls->enabled_ctrls&XkbMouseKeysMask))) {
-	fake.type = XkbSA_NoAction;
-	return fake;
+    if (XkbIsPtrAction(act) &&
+        (!(xkb->ctrls->enabled_ctrls & XkbMouseKeysMask))) {
+        fake.type = XkbSA_NoAction;
+        return fake;
     }
-    if (xkb->ctrls->enabled_ctrls&XkbStickyKeysMask) {
-	if (act->any.type==XkbSA_SetMods) {
-	    fake.mods.type = XkbSA_LatchMods;
-	    fake.mods.mask = act->mods.mask;
-	    if (XkbAX_NeedOption(xkb->ctrls,XkbAX_LatchToLockMask))
-		 fake.mods.flags= XkbSA_ClearLocks|XkbSA_LatchToLock;
-	    else fake.mods.flags= XkbSA_ClearLocks;
-	    return fake;
-	}
-	if (act->any.type==XkbSA_SetGroup) {
-	    fake.group.type = XkbSA_LatchGroup;
-	    if (XkbAX_NeedOption(xkb->ctrls,XkbAX_LatchToLockMask))
-		 fake.group.flags= XkbSA_ClearLocks|XkbSA_LatchToLock;
-	    else fake.group.flags= XkbSA_ClearLocks;
-	    XkbSASetGroup(&fake.group,XkbSAGroup(&act->group));
-	    return fake;
-	}
+    if (xkb->ctrls->enabled_ctrls & XkbStickyKeysMask) {
+        if (act->any.type == XkbSA_SetMods) {
+            fake.mods.type = XkbSA_LatchMods;
+            fake.mods.mask = act->mods.mask;
+            if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))
+                fake.mods.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;
+            else
+                fake.mods.flags = XkbSA_ClearLocks;
+            return fake;
+        }
+        if (act->any.type == XkbSA_SetGroup) {
+            fake.group.type = XkbSA_LatchGroup;
+            if (XkbAX_NeedOption(xkb->ctrls, XkbAX_LatchToLockMask))
+                fake.group.flags = XkbSA_ClearLocks | XkbSA_LatchToLock;
+            else
+                fake.group.flags = XkbSA_ClearLocks;
+            XkbSASetGroup(&fake.group, XkbSAGroup(&act->group));
+            return fake;
+        }
     }
     return *act;
 }
 
 static XkbAction
-XkbGetKeyAction(XkbSrvInfoPtr xkbi,XkbStatePtr xkbState,CARD8 key)
+XkbGetKeyAction(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 key)
 {
-int			effectiveGroup;
-int			col;
-XkbDescPtr		xkb;
-XkbKeyTypePtr		type;
-XkbAction *		pActs;
-static XkbAction 	fake;
-
-    xkb= xkbi->desc;
-    if (!XkbKeyHasActions(xkb,key) || !XkbKeycodeInRange(xkb,key)) {
-	fake.type = XkbSA_NoAction;
-	return fake;
+    int effectiveGroup;
+    int col;
+    XkbDescPtr xkb;
+    XkbKeyTypePtr type;
+    XkbAction *pActs;
+    static XkbAction fake;
+
+    xkb = xkbi->desc;
+    if (!XkbKeyHasActions(xkb, key) || !XkbKeycodeInRange(xkb, key)) {
+        fake.type = XkbSA_NoAction;
+        return fake;
     }
-    pActs= XkbKeyActionsPtr(xkb,key);
-    col= 0;
+    pActs = XkbKeyActionsPtr(xkb, key);
+    col = 0;
 
     effectiveGroup = XkbGetEffectiveGroup(xkbi, xkbState, key);
     if (effectiveGroup != XkbGroup1Index)
         col += (effectiveGroup * XkbKeyGroupsWidth(xkb, key));
 
-    type= XkbKeyKeyType(xkb,key,effectiveGroup);
-    if (type->map!=NULL) {
-	register unsigned		i,mods;
-	register XkbKTMapEntryPtr	entry;
-	mods= xkbState->mods&type->mods.mask;
-	for (entry= type->map,i=0;i<type->map_count;i++,entry++) {
-	    if ((entry->active)&&(entry->mods.mask==mods)) {
-		col+= entry->level;
-		break;
-	    }
-	}
+    type = XkbKeyKeyType(xkb, key, effectiveGroup);
+    if (type->map != NULL) {
+        register unsigned i, mods;
+        register XkbKTMapEntryPtr entry;
+
+        mods = xkbState->mods & type->mods.mask;
+        for (entry = type->map, i = 0; i < type->map_count; i++, entry++) {
+            if ((entry->active) && (entry->mods.mask == mods)) {
+                col += entry->level;
+                break;
+            }
+        }
     }
-    if (pActs[col].any.type==XkbSA_NoAction)
-	return pActs[col];
-    fake= _FixUpAction(xkb,&pActs[col]);
+    if (pActs[col].any.type == XkbSA_NoAction)
+        return pActs[col];
+    fake = _FixUpAction(xkb, &pActs[col]);
     return fake;
 }
 
 static XkbAction
-XkbGetButtonAction(DeviceIntPtr kbd,DeviceIntPtr dev,int button)
+XkbGetButtonAction(DeviceIntPtr kbd, DeviceIntPtr dev, int button)
 {
-XkbAction fake;
-   if ((dev->button)&&(dev->button->xkb_acts)) {
-	if (dev->button->xkb_acts[button-1].any.type!=XkbSA_NoAction) {
-	    fake= _FixUpAction(kbd->key->xkbInfo->desc,
-					&dev->button->xkb_acts[button-1]);
-	    return fake;
-	}
-   }
-   fake.any.type= XkbSA_NoAction;
-   return fake;
+    XkbAction fake;
+
+    if ((dev->button) && (dev->button->xkb_acts)) {
+        if (dev->button->xkb_acts[button - 1].any.type != XkbSA_NoAction) {
+            fake = _FixUpAction(kbd->key->xkbInfo->desc,
+                                &dev->button->xkb_acts[button - 1]);
+            return fake;
+        }
+    }
+    fake.any.type = XkbSA_NoAction;
+    return fake;
 }
 
 /***====================================================================***/
@@ -171,47 +178,45 @@ XkbAction fake;
 #define	BTN_ACT_FLAG		0x100
 
 static int
-_XkbFilterSetState(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *pAction)
+_XkbFilterSetState(XkbSrvInfoPtr xkbi,
+                   XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = ((pAction->mods.mask&XkbSA_ClearLocks)!=0);
-	filter->priv = 0;
-	filter->filter = _XkbFilterSetState;
-	if (pAction->type==XkbSA_SetMods) {
-	    filter->upAction = *pAction;
-	    xkbi->setMods= pAction->mods.mask;
-	}
-	else {
-	    xkbi->groupChange = XkbSAGroup(&pAction->group);
-	    if (pAction->group.flags&XkbSA_GroupAbsolute)
-		xkbi->groupChange-= xkbi->state.base_group;
-	    filter->upAction= *pAction;
-	    XkbSASetGroup(&filter->upAction.group,xkbi->groupChange);
-	}
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = ((pAction->mods.mask & XkbSA_ClearLocks) != 0);
+        filter->priv = 0;
+        filter->filter = _XkbFilterSetState;
+        if (pAction->type == XkbSA_SetMods) {
+            filter->upAction = *pAction;
+            xkbi->setMods = pAction->mods.mask;
+        }
+        else {
+            xkbi->groupChange = XkbSAGroup(&pAction->group);
+            if (pAction->group.flags & XkbSA_GroupAbsolute)
+                xkbi->groupChange -= xkbi->state.base_group;
+            filter->upAction = *pAction;
+            XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);
+        }
     }
-    else if (filter->keycode==keycode) {
-	if (filter->upAction.type==XkbSA_SetMods) {
-	    xkbi->clearMods = filter->upAction.mods.mask;
-	    if (filter->upAction.mods.flags&XkbSA_ClearLocks) {
-		xkbi->state.locked_mods&= ~filter->upAction.mods.mask;
-	    }
-	}
-	else {
-	    if (filter->upAction.group.flags&XkbSA_ClearLocks) {
-		xkbi->state.locked_group = 0;
-	    }
-	    xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
-	}
-	filter->active = 0;
+    else if (filter->keycode == keycode) {
+        if (filter->upAction.type == XkbSA_SetMods) {
+            xkbi->clearMods = filter->upAction.mods.mask;
+            if (filter->upAction.mods.flags & XkbSA_ClearLocks) {
+                xkbi->state.locked_mods &= ~filter->upAction.mods.mask;
+            }
+        }
+        else {
+            if (filter->upAction.group.flags & XkbSA_ClearLocks) {
+                xkbi->state.locked_group = 0;
+            }
+            xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
+        }
+        filter->active = 0;
     }
     else {
-	filter->upAction.mods.flags&= ~XkbSA_ClearLocks;
-	filter->filterOthers = 0;
+        filter->upAction.mods.flags &= ~XkbSA_ClearLocks;
+        filter->filterOthers = 0;
     }
     return 1;
 }
@@ -221,141 +226,147 @@ _XkbFilterSetState(	XkbSrvInfoPtr	xkbi,
 #define	NO_LATCH	3
 
 static int
-_XkbFilterLatchState(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterLatchState(XkbSrvInfoPtr xkbi,
+                     XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
 
-    if (filter->keycode==0) {			/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 1;
-	filter->priv = LATCH_KEY_DOWN;
-	filter->filter = _XkbFilterLatchState;
-	if (pAction->type==XkbSA_LatchMods) {
-	    filter->upAction = *pAction;
-	    xkbi->setMods = pAction->mods.mask;
-	}
-	else {
-	    xkbi->groupChange = XkbSAGroup(&pAction->group);
-	    if (pAction->group.flags&XkbSA_GroupAbsolute)
-		 xkbi->groupChange-= xkbi->state.base_group;
-	    filter->upAction= *pAction;
-	    XkbSASetGroup(&filter->upAction.group,xkbi->groupChange);
-	}
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 1;
+        filter->priv = LATCH_KEY_DOWN;
+        filter->filter = _XkbFilterLatchState;
+        if (pAction->type == XkbSA_LatchMods) {
+            filter->upAction = *pAction;
+            xkbi->setMods = pAction->mods.mask;
+        }
+        else {
+            xkbi->groupChange = XkbSAGroup(&pAction->group);
+            if (pAction->group.flags & XkbSA_GroupAbsolute)
+                xkbi->groupChange -= xkbi->state.base_group;
+            filter->upAction = *pAction;
+            XkbSASetGroup(&filter->upAction.group, xkbi->groupChange);
+        }
     }
-    else if ( pAction && (filter->priv==LATCH_PENDING) ) {
-	if (((1<<pAction->type)&XkbSA_BreakLatch)!=0) {
-	    filter->active = 0;
-	    if (filter->upAction.type==XkbSA_LatchMods)
-		 xkbi->state.latched_mods&= ~filter->upAction.mods.mask;
-	    else xkbi->state.latched_group-=XkbSAGroup(&filter->upAction.group);
-	}
-	else if ((pAction->type==filter->upAction.type)&&
-		 (pAction->mods.flags==filter->upAction.mods.flags)&&
-		 (pAction->mods.mask==filter->upAction.mods.mask)) {
-	    if (filter->upAction.mods.flags&XkbSA_LatchToLock) {
-		XkbControlsPtr ctrls= xkbi->desc->ctrls;
-		if (filter->upAction.type==XkbSA_LatchMods)
-		     pAction->mods.type= XkbSA_LockMods;
-		else pAction->group.type= XkbSA_LockGroup;
-		if (XkbAX_NeedFeedback(ctrls,XkbAX_StickyKeysFBMask)&&
-		    		(ctrls->enabled_ctrls&XkbStickyKeysMask)) {
-		    XkbDDXAccessXBeep(xkbi->device,_BEEP_STICKY_LOCK,
-						XkbStickyKeysMask);
-		}
-	    }
-	    else {
-		if (filter->upAction.type==XkbSA_LatchMods)
-		     pAction->mods.type= XkbSA_SetMods;
-		else pAction->group.type= XkbSA_SetGroup;
-	    }
-	    if (filter->upAction.type==XkbSA_LatchMods)
-		 xkbi->state.latched_mods&= ~filter->upAction.mods.mask;
-	    else xkbi->state.latched_group-=XkbSAGroup(&filter->upAction.group);
-	    filter->active = 0;
-	}
+    else if (pAction && (filter->priv == LATCH_PENDING)) {
+        if (((1 << pAction->type) & XkbSA_BreakLatch) != 0) {
+            filter->active = 0;
+            if (filter->upAction.type == XkbSA_LatchMods)
+                xkbi->state.latched_mods &= ~filter->upAction.mods.mask;
+            else
+                xkbi->state.latched_group -=
+                    XkbSAGroup(&filter->upAction.group);
+        }
+        else if ((pAction->type == filter->upAction.type) &&
+                 (pAction->mods.flags == filter->upAction.mods.flags) &&
+                 (pAction->mods.mask == filter->upAction.mods.mask)) {
+            if (filter->upAction.mods.flags & XkbSA_LatchToLock) {
+                XkbControlsPtr ctrls = xkbi->desc->ctrls;
+
+                if (filter->upAction.type == XkbSA_LatchMods)
+                    pAction->mods.type = XkbSA_LockMods;
+                else
+                    pAction->group.type = XkbSA_LockGroup;
+                if (XkbAX_NeedFeedback(ctrls, XkbAX_StickyKeysFBMask) &&
+                    (ctrls->enabled_ctrls & XkbStickyKeysMask)) {
+                    XkbDDXAccessXBeep(xkbi->device, _BEEP_STICKY_LOCK,
+                                      XkbStickyKeysMask);
+                }
+            }
+            else {
+                if (filter->upAction.type == XkbSA_LatchMods)
+                    pAction->mods.type = XkbSA_SetMods;
+                else
+                    pAction->group.type = XkbSA_SetGroup;
+            }
+            if (filter->upAction.type == XkbSA_LatchMods)
+                xkbi->state.latched_mods &= ~filter->upAction.mods.mask;
+            else
+                xkbi->state.latched_group -=
+                    XkbSAGroup(&filter->upAction.group);
+            filter->active = 0;
+        }
     }
-    else if (filter->keycode==keycode) {	/* release */
-	XkbControlsPtr	ctrls= xkbi->desc->ctrls;
-	int		needBeep;
-	int		beepType= _BEEP_NONE;
-
-	needBeep= ((ctrls->enabled_ctrls&XkbStickyKeysMask)&&
-			XkbAX_NeedFeedback(ctrls,XkbAX_StickyKeysFBMask));
-	if (filter->upAction.type==XkbSA_LatchMods) {
-	    xkbi->clearMods = filter->upAction.mods.mask;
-	    if ((filter->upAction.mods.flags&XkbSA_ClearLocks)&&
-		 (xkbi->clearMods&xkbi->state.locked_mods)==xkbi->clearMods) {
-		xkbi->state.locked_mods&= ~xkbi->clearMods;
-		filter->priv= NO_LATCH;
-		beepType= _BEEP_STICKY_UNLOCK;
-	    }
-	}
-	else {
-	    xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
-	    if ((filter->upAction.group.flags&XkbSA_ClearLocks)&&
-						(xkbi->state.locked_group)) {
-		xkbi->state.locked_group = 0;
-		filter->priv = NO_LATCH;
-		beepType= _BEEP_STICKY_UNLOCK;
-	    }
-	}
-	if (filter->priv==NO_LATCH) {
-	    filter->active= 0;
-	}
-	else {
-	    filter->priv= LATCH_PENDING;
-	    if (filter->upAction.type==XkbSA_LatchMods) {
-		xkbi->state.latched_mods |= filter->upAction.mods.mask;
-		needBeep = xkbi->state.latched_mods ? needBeep : 0;
-		xkbi->state.latched_mods |= filter->upAction.mods.mask;
-	    }
-	    else {
-		xkbi->state.latched_group+= XkbSAGroup(&filter->upAction.group);
-	    }
-	    if (needBeep && (beepType==_BEEP_NONE))
-		beepType= _BEEP_STICKY_LATCH;
-	}
-	if (needBeep && (beepType!=_BEEP_NONE))
-	    XkbDDXAccessXBeep(xkbi->device,beepType,XkbStickyKeysMask);
+    else if (filter->keycode == keycode) {      /* release */
+        XkbControlsPtr ctrls = xkbi->desc->ctrls;
+        int needBeep;
+        int beepType = _BEEP_NONE;
+
+        needBeep = ((ctrls->enabled_ctrls & XkbStickyKeysMask) &&
+                    XkbAX_NeedFeedback(ctrls, XkbAX_StickyKeysFBMask));
+        if (filter->upAction.type == XkbSA_LatchMods) {
+            xkbi->clearMods = filter->upAction.mods.mask;
+            if ((filter->upAction.mods.flags & XkbSA_ClearLocks) &&
+                (xkbi->clearMods & xkbi->state.locked_mods) ==
+                xkbi->clearMods) {
+                xkbi->state.locked_mods &= ~xkbi->clearMods;
+                filter->priv = NO_LATCH;
+                beepType = _BEEP_STICKY_UNLOCK;
+            }
+        }
+        else {
+            xkbi->groupChange = -XkbSAGroup(&filter->upAction.group);
+            if ((filter->upAction.group.flags & XkbSA_ClearLocks) &&
+                (xkbi->state.locked_group)) {
+                xkbi->state.locked_group = 0;
+                filter->priv = NO_LATCH;
+                beepType = _BEEP_STICKY_UNLOCK;
+            }
+        }
+        if (filter->priv == NO_LATCH) {
+            filter->active = 0;
+        }
+        else {
+            filter->priv = LATCH_PENDING;
+            if (filter->upAction.type == XkbSA_LatchMods) {
+                xkbi->state.latched_mods |= filter->upAction.mods.mask;
+                needBeep = xkbi->state.latched_mods ? needBeep : 0;
+                xkbi->state.latched_mods |= filter->upAction.mods.mask;
+            }
+            else {
+                xkbi->state.latched_group +=
+                    XkbSAGroup(&filter->upAction.group);
+            }
+            if (needBeep && (beepType == _BEEP_NONE))
+                beepType = _BEEP_STICKY_LATCH;
+        }
+        if (needBeep && (beepType != _BEEP_NONE))
+            XkbDDXAccessXBeep(xkbi->device, beepType, XkbStickyKeysMask);
     }
-    else if (filter->priv==LATCH_KEY_DOWN) {
-	filter->priv= NO_LATCH;
-	filter->filterOthers = 0;
+    else if (filter->priv == LATCH_KEY_DOWN) {
+        filter->priv = NO_LATCH;
+        filter->filterOthers = 0;
     }
     return 1;
 }
 
 static int
-_XkbFilterLockState(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterLockState(XkbSrvInfoPtr xkbi,
+                    XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-    if (pAction&&(pAction->type==XkbSA_LockGroup)) {
-	if (pAction->group.flags&XkbSA_GroupAbsolute)
-	     xkbi->state.locked_group= XkbSAGroup(&pAction->group);
-	else xkbi->state.locked_group+= XkbSAGroup(&pAction->group);
-	return 1;
+    if (pAction && (pAction->type == XkbSA_LockGroup)) {
+        if (pAction->group.flags & XkbSA_GroupAbsolute)
+            xkbi->state.locked_group = XkbSAGroup(&pAction->group);
+        else
+            xkbi->state.locked_group += XkbSAGroup(&pAction->group);
+        return 1;
     }
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->priv = xkbi->state.locked_mods&pAction->mods.mask;
-	filter->filter = _XkbFilterLockState;
-	filter->upAction = *pAction;
-	if (!(filter->upAction.mods.flags&XkbSA_LockNoLock))
-	    xkbi->state.locked_mods|= pAction->mods.mask;
-	xkbi->setMods = pAction->mods.mask;
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->priv = xkbi->state.locked_mods & pAction->mods.mask;
+        filter->filter = _XkbFilterLockState;
+        filter->upAction = *pAction;
+        if (!(filter->upAction.mods.flags & XkbSA_LockNoLock))
+            xkbi->state.locked_mods |= pAction->mods.mask;
+        xkbi->setMods = pAction->mods.mask;
     }
-    else if (filter->keycode==keycode) {
-	filter->active = 0;
-	xkbi->clearMods = filter->upAction.mods.mask;
-	if (!(filter->upAction.mods.flags&XkbSA_LockNoUnlock))
-	    xkbi->state.locked_mods&= ~filter->priv;
+    else if (filter->keycode == keycode) {
+        filter->active = 0;
+        xkbi->clearMods = filter->upAction.mods.mask;
+        if (!(filter->upAction.mods.flags & XkbSA_LockNoUnlock))
+            xkbi->state.locked_mods &= ~filter->priv;
     }
     return 1;
 }
@@ -364,922 +375,944 @@ _XkbFilterLockState(	XkbSrvInfoPtr	xkbi,
 #define	NO_ISO_LOCK		1
 
 static int
-_XkbFilterISOLock(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterISOLock(XkbSrvInfoPtr xkbi,
+                  XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
 
-    if (filter->keycode==0) {		/* initial press */
-	CARD8	flags= pAction->iso.flags;
-
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 1;
-	filter->priv = ISO_KEY_DOWN;
-	filter->upAction = *pAction;
-	filter->filter = _XkbFilterISOLock;
-	if (flags&XkbSA_ISODfltIsGroup) {
-	    xkbi->groupChange = XkbSAGroup(&pAction->iso);
-	    xkbi->setMods = 0;
-	}
-	else {
-	    xkbi->setMods = pAction->iso.mask;
-	    xkbi->groupChange = 0;
-	}
-	if ((!(flags&XkbSA_ISONoAffectMods))&&(xkbi->state.base_mods)) {
-	    filter->priv= NO_ISO_LOCK;
-	    xkbi->state.locked_mods^= xkbi->state.base_mods;
-	}
-	if ((!(flags&XkbSA_ISONoAffectGroup))&&(xkbi->state.base_group)) {
+    if (filter->keycode == 0) { /* initial press */
+        CARD8 flags = pAction->iso.flags;
+
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 1;
+        filter->priv = ISO_KEY_DOWN;
+        filter->upAction = *pAction;
+        filter->filter = _XkbFilterISOLock;
+        if (flags & XkbSA_ISODfltIsGroup) {
+            xkbi->groupChange = XkbSAGroup(&pAction->iso);
+            xkbi->setMods = 0;
+        }
+        else {
+            xkbi->setMods = pAction->iso.mask;
+            xkbi->groupChange = 0;
+        }
+        if ((!(flags & XkbSA_ISONoAffectMods)) && (xkbi->state.base_mods)) {
+            filter->priv = NO_ISO_LOCK;
+            xkbi->state.locked_mods ^= xkbi->state.base_mods;
+        }
+        if ((!(flags & XkbSA_ISONoAffectGroup)) && (xkbi->state.base_group)) {
 /* 6/22/93 (ef) -- lock groups if group key is down first */
-	}
-	if (!(flags&XkbSA_ISONoAffectPtr)) {
+        }
+        if (!(flags & XkbSA_ISONoAffectPtr)) {
 /* 6/22/93 (ef) -- lock mouse buttons if they're down */
-	}
+        }
     }
-    else if (filter->keycode==keycode) {
-	CARD8	flags= filter->upAction.iso.flags;
-
-	if (flags&XkbSA_ISODfltIsGroup) {
-	    xkbi->groupChange = -XkbSAGroup(&filter->upAction.iso);
-	    xkbi->clearMods = 0;
-	    if (filter->priv==ISO_KEY_DOWN)
-		xkbi->state.locked_group+= XkbSAGroup(&filter->upAction.iso);
-	}
-	else {
-	    xkbi->clearMods= filter->upAction.iso.mask;
-	    xkbi->groupChange= 0;
-	    if (filter->priv==ISO_KEY_DOWN)
-		xkbi->state.locked_mods^= filter->upAction.iso.mask;
-	}
-	filter->active = 0;
+    else if (filter->keycode == keycode) {
+        CARD8 flags = filter->upAction.iso.flags;
+
+        if (flags & XkbSA_ISODfltIsGroup) {
+            xkbi->groupChange = -XkbSAGroup(&filter->upAction.iso);
+            xkbi->clearMods = 0;
+            if (filter->priv == ISO_KEY_DOWN)
+                xkbi->state.locked_group += XkbSAGroup(&filter->upAction.iso);
+        }
+        else {
+            xkbi->clearMods = filter->upAction.iso.mask;
+            xkbi->groupChange = 0;
+            if (filter->priv == ISO_KEY_DOWN)
+                xkbi->state.locked_mods ^= filter->upAction.iso.mask;
+        }
+        filter->active = 0;
     }
     else if (pAction) {
-	CARD8	flags= filter->upAction.iso.flags;
-
-	switch (pAction->type) {
-	    case XkbSA_SetMods: case XkbSA_LatchMods:
-		if (!(flags&XkbSA_ISONoAffectMods)) {
-		    pAction->type= XkbSA_LockMods;
-		    filter->priv= NO_ISO_LOCK;
-		}
-		break;
-	    case XkbSA_SetGroup: case XkbSA_LatchGroup:
-		if (!(flags&XkbSA_ISONoAffectGroup)) {
-		    pAction->type= XkbSA_LockGroup;
-		    filter->priv= NO_ISO_LOCK;
-		}
-		break;
-	    case XkbSA_PtrBtn:
-		if (!(flags&XkbSA_ISONoAffectPtr)) {
-		     pAction->type= XkbSA_LockPtrBtn;
-		     filter->priv= NO_ISO_LOCK;
-		}
-		break;
-	    case XkbSA_SetControls:
-		if (!(flags&XkbSA_ISONoAffectCtrls)) {
-		    pAction->type= XkbSA_LockControls;
-		    filter->priv= NO_ISO_LOCK;
-		}
-		break;
-	}
+        CARD8 flags = filter->upAction.iso.flags;
+
+        switch (pAction->type) {
+        case XkbSA_SetMods:
+        case XkbSA_LatchMods:
+            if (!(flags & XkbSA_ISONoAffectMods)) {
+                pAction->type = XkbSA_LockMods;
+                filter->priv = NO_ISO_LOCK;
+            }
+            break;
+        case XkbSA_SetGroup:
+        case XkbSA_LatchGroup:
+            if (!(flags & XkbSA_ISONoAffectGroup)) {
+                pAction->type = XkbSA_LockGroup;
+                filter->priv = NO_ISO_LOCK;
+            }
+            break;
+        case XkbSA_PtrBtn:
+            if (!(flags & XkbSA_ISONoAffectPtr)) {
+                pAction->type = XkbSA_LockPtrBtn;
+                filter->priv = NO_ISO_LOCK;
+            }
+            break;
+        case XkbSA_SetControls:
+            if (!(flags & XkbSA_ISONoAffectCtrls)) {
+                pAction->type = XkbSA_LockControls;
+                filter->priv = NO_ISO_LOCK;
+            }
+            break;
+        }
     }
     return 1;
 }
 
-
 static CARD32
-_XkbPtrAccelExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbPtrAccelExpire(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-XkbSrvInfoPtr	xkbi= (XkbSrvInfoPtr)arg;
-XkbControlsPtr	ctrls= xkbi->desc->ctrls;
-int		dx,dy;
+    XkbSrvInfoPtr xkbi = (XkbSrvInfoPtr) arg;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    int dx, dy;
 
-    if (xkbi->mouseKey==0)
-	return 0;
+    if (xkbi->mouseKey == 0)
+        return 0;
 
     if (xkbi->mouseKeysAccel) {
-	if ((xkbi->mouseKeysCounter)<ctrls->mk_time_to_max) {
-	    double step;
-	    xkbi->mouseKeysCounter++;
-	    step= xkbi->mouseKeysCurveFactor*
-		 pow((double)xkbi->mouseKeysCounter,xkbi->mouseKeysCurve);
-	    if (xkbi->mouseKeysDX<0)
-		 dx= floor( ((double)xkbi->mouseKeysDX)*step );
-	    else dx=  ceil( ((double)xkbi->mouseKeysDX)*step );
-	    if (xkbi->mouseKeysDY<0)
-		 dy= floor( ((double)xkbi->mouseKeysDY)*step );
-	    else dy=  ceil( ((double)xkbi->mouseKeysDY)*step );
-	}
-	else {
-	    dx= xkbi->mouseKeysDX*ctrls->mk_max_speed;
-	    dy= xkbi->mouseKeysDY*ctrls->mk_max_speed;
-	}
-	if (xkbi->mouseKeysFlags&XkbSA_MoveAbsoluteX)
-	    dx= xkbi->mouseKeysDX;
-	if (xkbi->mouseKeysFlags&XkbSA_MoveAbsoluteY)
-	    dy= xkbi->mouseKeysDY;
+        if ((xkbi->mouseKeysCounter) < ctrls->mk_time_to_max) {
+            double step;
+
+            xkbi->mouseKeysCounter++;
+            step = xkbi->mouseKeysCurveFactor *
+                pow((double) xkbi->mouseKeysCounter, xkbi->mouseKeysCurve);
+            if (xkbi->mouseKeysDX < 0)
+                dx = floor(((double) xkbi->mouseKeysDX) * step);
+            else
+                dx = ceil(((double) xkbi->mouseKeysDX) * step);
+            if (xkbi->mouseKeysDY < 0)
+                dy = floor(((double) xkbi->mouseKeysDY) * step);
+            else
+                dy = ceil(((double) xkbi->mouseKeysDY) * step);
+        }
+        else {
+            dx = xkbi->mouseKeysDX * ctrls->mk_max_speed;
+            dy = xkbi->mouseKeysDY * ctrls->mk_max_speed;
+        }
+        if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteX)
+            dx = xkbi->mouseKeysDX;
+        if (xkbi->mouseKeysFlags & XkbSA_MoveAbsoluteY)
+            dy = xkbi->mouseKeysDY;
     }
     else {
-	dx= xkbi->mouseKeysDX;
-	dy= xkbi->mouseKeysDY;
+        dx = xkbi->mouseKeysDX;
+        dy = xkbi->mouseKeysDY;
     }
-    XkbFakePointerMotion(xkbi->device, xkbi->mouseKeysFlags,dx,dy);
+    XkbFakePointerMotion(xkbi->device, xkbi->mouseKeysFlags, dx, dy);
     return xkbi->desc->ctrls->mk_interval;
 }
 
 static int
-_XkbFilterPointerMove(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterPointerMove(XkbSrvInfoPtr xkbi,
+                      XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-int	x,y;
-Bool	accel;
-
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->priv=0;
-	filter->filter = _XkbFilterPointerMove;
-	filter->upAction= *pAction;
-	xkbi->mouseKeysCounter= 0;
-	xkbi->mouseKey= keycode;
-	accel= ((pAction->ptr.flags&XkbSA_NoAcceleration)==0);
-	x= XkbPtrActionX(&pAction->ptr);
-	y= XkbPtrActionY(&pAction->ptr);
-	XkbFakePointerMotion(xkbi->device, pAction->ptr.flags,x,y);
-	AccessXCancelRepeatKey(xkbi,keycode);
-	xkbi->mouseKeysAccel= accel&&
-		(xkbi->desc->ctrls->enabled_ctrls&XkbMouseKeysAccelMask);
-	xkbi->mouseKeysFlags= pAction->ptr.flags;
-	xkbi->mouseKeysDX= XkbPtrActionX(&pAction->ptr);
-	xkbi->mouseKeysDY= XkbPtrActionY(&pAction->ptr);
-	xkbi->mouseKeyTimer= TimerSet(xkbi->mouseKeyTimer, 0,
-				xkbi->desc->ctrls->mk_delay,
-				_XkbPtrAccelExpire,(pointer)xkbi);
+    int x, y;
+    Bool accel;
+
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->priv = 0;
+        filter->filter = _XkbFilterPointerMove;
+        filter->upAction = *pAction;
+        xkbi->mouseKeysCounter = 0;
+        xkbi->mouseKey = keycode;
+        accel = ((pAction->ptr.flags & XkbSA_NoAcceleration) == 0);
+        x = XkbPtrActionX(&pAction->ptr);
+        y = XkbPtrActionY(&pAction->ptr);
+        XkbFakePointerMotion(xkbi->device, pAction->ptr.flags, x, y);
+        AccessXCancelRepeatKey(xkbi, keycode);
+        xkbi->mouseKeysAccel = accel &&
+            (xkbi->desc->ctrls->enabled_ctrls & XkbMouseKeysAccelMask);
+        xkbi->mouseKeysFlags = pAction->ptr.flags;
+        xkbi->mouseKeysDX = XkbPtrActionX(&pAction->ptr);
+        xkbi->mouseKeysDY = XkbPtrActionY(&pAction->ptr);
+        xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0,
+                                       xkbi->desc->ctrls->mk_delay,
+                                       _XkbPtrAccelExpire, (pointer) xkbi);
     }
-    else if (filter->keycode==keycode) {
-	filter->active = 0;
-	if (xkbi->mouseKey==keycode) {
-	    xkbi->mouseKey= 0;
-	    xkbi->mouseKeyTimer= TimerSet(xkbi->mouseKeyTimer, 0, 0,
-							NULL, NULL);
-	}
+    else if (filter->keycode == keycode) {
+        filter->active = 0;
+        if (xkbi->mouseKey == keycode) {
+            xkbi->mouseKey = 0;
+            xkbi->mouseKeyTimer = TimerSet(xkbi->mouseKeyTimer, 0, 0,
+                                           NULL, NULL);
+        }
     }
     return 0;
 }
 
 static int
-_XkbFilterPointerBtn(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterPointerBtn(XkbSrvInfoPtr xkbi,
+                     XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-    if (filter->keycode==0) {		/* initial press */
-	int	button= pAction->btn.button;
-
-	if (button==XkbSA_UseDfltButton)
-	    button = xkbi->desc->ctrls->mk_dflt_btn;
-
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->priv=0;
-	filter->filter = _XkbFilterPointerBtn;
-	filter->upAction= *pAction;
-	filter->upAction.btn.button= button;
-	switch (pAction->type) {
-	    case XkbSA_LockPtrBtn:
-		if (((xkbi->lockedPtrButtons&(1<<button))==0)&&
-			((pAction->btn.flags&XkbSA_LockNoLock)==0)) {
-		    xkbi->lockedPtrButtons|= (1<<button);
-		    AccessXCancelRepeatKey(xkbi,keycode);
-		    XkbFakeDeviceButton(xkbi->device, 1, button);
-		    filter->upAction.type= XkbSA_NoAction;
-		}
-		break;
-	    case XkbSA_PtrBtn:
-		{
-		    register int i,nClicks;
-		    AccessXCancelRepeatKey(xkbi,keycode);
-		    if (pAction->btn.count>0) {
-			nClicks= pAction->btn.count;
-			for (i=0;i<nClicks;i++) {
-			    XkbFakeDeviceButton(xkbi->device, 1, button);
-			    XkbFakeDeviceButton(xkbi->device, 0, button);
-			}
-			filter->upAction.type= XkbSA_NoAction;
-		    }
-		    else XkbFakeDeviceButton(xkbi->device, 1, button);
-		}
-		break;
-	    case XkbSA_SetPtrDflt:
-		{
-		    XkbControlsPtr	ctrls= xkbi->desc->ctrls;
-		    XkbControlsRec	old;
-		    xkbControlsNotify	cn;
-
-		    old= *ctrls;
-		    AccessXCancelRepeatKey(xkbi,keycode);
-		    switch (pAction->dflt.affect) {
-			case XkbSA_AffectDfltBtn:
-			    if (pAction->dflt.flags&XkbSA_DfltBtnAbsolute)
-				ctrls->mk_dflt_btn= 
-					XkbSAPtrDfltValue(&pAction->dflt);
-			    else {
-				ctrls->mk_dflt_btn+=
-					XkbSAPtrDfltValue(&pAction->dflt);
-				if (ctrls->mk_dflt_btn>5)
-				    ctrls->mk_dflt_btn= 5;
-				else if (ctrls->mk_dflt_btn<1)
-				    ctrls->mk_dflt_btn= 1;
-			    }
-			    break;
-			default:
-			    ErrorF(
-		"Attempt to change unknown pointer default (%d) ignored\n",
-							pAction->dflt.affect);
-			    break;
-		    }
-		    if (XkbComputeControlsNotify(xkbi->device,
-						&old,xkbi->desc->ctrls,
-						&cn,FALSE)) {
-			cn.keycode = keycode;
-                        /* XXX: what about DeviceKeyPress? */
-			cn.eventType = KeyPress;
-			cn.requestMajor = 0;
-			cn.requestMinor = 0;
-			XkbSendControlsNotify(xkbi->device,&cn);
-		    }
-		}
-		break;
-	}
+    if (filter->keycode == 0) { /* initial press */
+        int button = pAction->btn.button;
+
+        if (button == XkbSA_UseDfltButton)
+            button = xkbi->desc->ctrls->mk_dflt_btn;
+
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->priv = 0;
+        filter->filter = _XkbFilterPointerBtn;
+        filter->upAction = *pAction;
+        filter->upAction.btn.button = button;
+        switch (pAction->type) {
+        case XkbSA_LockPtrBtn:
+            if (((xkbi->lockedPtrButtons & (1 << button)) == 0) &&
+                ((pAction->btn.flags & XkbSA_LockNoLock) == 0)) {
+                xkbi->lockedPtrButtons |= (1 << button);
+                AccessXCancelRepeatKey(xkbi, keycode);
+                XkbFakeDeviceButton(xkbi->device, 1, button);
+                filter->upAction.type = XkbSA_NoAction;
+            }
+            break;
+        case XkbSA_PtrBtn:
+        {
+            register int i, nClicks;
+
+            AccessXCancelRepeatKey(xkbi, keycode);
+            if (pAction->btn.count > 0) {
+                nClicks = pAction->btn.count;
+                for (i = 0; i < nClicks; i++) {
+                    XkbFakeDeviceButton(xkbi->device, 1, button);
+                    XkbFakeDeviceButton(xkbi->device, 0, button);
+                }
+                filter->upAction.type = XkbSA_NoAction;
+            }
+            else
+                XkbFakeDeviceButton(xkbi->device, 1, button);
+        }
+            break;
+        case XkbSA_SetPtrDflt:
+        {
+            XkbControlsPtr ctrls = xkbi->desc->ctrls;
+            XkbControlsRec old;
+            xkbControlsNotify cn;
+
+            old = *ctrls;
+            AccessXCancelRepeatKey(xkbi, keycode);
+            switch (pAction->dflt.affect) {
+            case XkbSA_AffectDfltBtn:
+                if (pAction->dflt.flags & XkbSA_DfltBtnAbsolute)
+                    ctrls->mk_dflt_btn = XkbSAPtrDfltValue(&pAction->dflt);
+                else {
+                    ctrls->mk_dflt_btn += XkbSAPtrDfltValue(&pAction->dflt);
+                    if (ctrls->mk_dflt_btn > 5)
+                        ctrls->mk_dflt_btn = 5;
+                    else if (ctrls->mk_dflt_btn < 1)
+                        ctrls->mk_dflt_btn = 1;
+                }
+                break;
+            default:
+                ErrorF
+                    ("Attempt to change unknown pointer default (%d) ignored\n",
+                     pAction->dflt.affect);
+                break;
+            }
+            if (XkbComputeControlsNotify(xkbi->device,
+                                         &old, xkbi->desc->ctrls, &cn, FALSE)) {
+                cn.keycode = keycode;
+                /* XXX: what about DeviceKeyPress? */
+                cn.eventType = KeyPress;
+                cn.requestMajor = 0;
+                cn.requestMinor = 0;
+                XkbSendControlsNotify(xkbi->device, &cn);
+            }
+        }
+            break;
+        }
     }
-    else if (filter->keycode==keycode) {
-	int	button= filter->upAction.btn.button;
-
-	switch (filter->upAction.type) {
-	    case XkbSA_LockPtrBtn:
-		if (((filter->upAction.btn.flags&XkbSA_LockNoUnlock)!=0)||
-				((xkbi->lockedPtrButtons&(1<<button))==0)) {
-		    break;
-		}
-		xkbi->lockedPtrButtons&= ~(1<<button);
-
-		if (IsMaster(xkbi->device))
-		{
-		    XkbMergeLockedPtrBtns(xkbi->device);
-                    /* One SD still has lock set, don't post event */
-		    if ((xkbi->lockedPtrButtons & (1 << button)) != 0)
-			break;
-		}
-
-		/* fallthrough */
-	    case XkbSA_PtrBtn:
-		XkbFakeDeviceButton(xkbi->device, 0, button);
-		break;
-	}
-	filter->active = 0;
+    else if (filter->keycode == keycode) {
+        int button = filter->upAction.btn.button;
+
+        switch (filter->upAction.type) {
+        case XkbSA_LockPtrBtn:
+            if (((filter->upAction.btn.flags & XkbSA_LockNoUnlock) != 0) ||
+                ((xkbi->lockedPtrButtons & (1 << button)) == 0)) {
+                break;
+            }
+            xkbi->lockedPtrButtons &= ~(1 << button);
+
+            if (IsMaster(xkbi->device)) {
+                XkbMergeLockedPtrBtns(xkbi->device);
+                /* One SD still has lock set, don't post event */
+                if ((xkbi->lockedPtrButtons & (1 << button)) != 0)
+                    break;
+            }
+
+            /* fallthrough */
+        case XkbSA_PtrBtn:
+            XkbFakeDeviceButton(xkbi->device, 0, button);
+            break;
+        }
+        filter->active = 0;
     }
     return 0;
 }
 
 static int
-_XkbFilterControls(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterControls(XkbSrvInfoPtr xkbi,
+                   XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-XkbControlsRec		old;
-XkbControlsPtr		ctrls;
-DeviceIntPtr		kbd;
-unsigned int		change;
-XkbEventCauseRec	cause;
-
-    kbd= xkbi->device;
-    ctrls= xkbi->desc->ctrls;
-    old= *ctrls;
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	change= XkbActionCtrls(&pAction->ctrls);
-	filter->priv = change;
-	filter->filter = _XkbFilterControls;
-	filter->upAction = *pAction;
-
-	if (pAction->type==XkbSA_LockControls) {
-	    filter->priv= (ctrls->enabled_ctrls&change);
-	    change&= ~ctrls->enabled_ctrls;
-	}
-
-	if (change) {
-	    xkbControlsNotify	cn;
-	    XkbSrvLedInfoPtr	sli;
-
-	    ctrls->enabled_ctrls|= change;
-	    if (XkbComputeControlsNotify(kbd,&old,ctrls,&cn,FALSE)) {
-		cn.keycode = keycode;
+    XkbControlsRec old;
+    XkbControlsPtr ctrls;
+    DeviceIntPtr kbd;
+    unsigned int change;
+    XkbEventCauseRec cause;
+
+    kbd = xkbi->device;
+    ctrls = xkbi->desc->ctrls;
+    old = *ctrls;
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        change = XkbActionCtrls(&pAction->ctrls);
+        filter->priv = change;
+        filter->filter = _XkbFilterControls;
+        filter->upAction = *pAction;
+
+        if (pAction->type == XkbSA_LockControls) {
+            filter->priv = (ctrls->enabled_ctrls & change);
+            change &= ~ctrls->enabled_ctrls;
+        }
+
+        if (change) {
+            xkbControlsNotify cn;
+            XkbSrvLedInfoPtr sli;
+
+            ctrls->enabled_ctrls |= change;
+            if (XkbComputeControlsNotify(kbd, &old, ctrls, &cn, FALSE)) {
+                cn.keycode = keycode;
                 /* XXX: what about DeviceKeyPress? */
-		cn.eventType = KeyPress;
-		cn.requestMajor = 0;
-		cn.requestMinor = 0;
-		XkbSendControlsNotify(kbd,&cn);
-	    }
-
-	    XkbSetCauseKey(&cause,keycode,KeyPress);
-
-	    /* If sticky keys were disabled, clear all locks and latches */
-	    if ((old.enabled_ctrls&XkbStickyKeysMask)&&
-		(!(ctrls->enabled_ctrls&XkbStickyKeysMask))) {
-		XkbClearAllLatchesAndLocks(kbd,xkbi,FALSE,&cause);
-    	    }
-	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
-	    XkbUpdateIndicators(kbd,sli->usesControls,TRUE,NULL,&cause);
-	    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
-		XkbDDXAccessXBeep(kbd,_BEEP_FEATURE_ON,change);
-	}
+                cn.eventType = KeyPress;
+                cn.requestMajor = 0;
+                cn.requestMinor = 0;
+                XkbSendControlsNotify(kbd, &cn);
+            }
+
+            XkbSetCauseKey(&cause, keycode, KeyPress);
+
+            /* If sticky keys were disabled, clear all locks and latches */
+            if ((old.enabled_ctrls & XkbStickyKeysMask) &&
+                (!(ctrls->enabled_ctrls & XkbStickyKeysMask))) {
+                XkbClearAllLatchesAndLocks(kbd, xkbi, FALSE, &cause);
+            }
+            sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+            XkbUpdateIndicators(kbd, sli->usesControls, TRUE, NULL, &cause);
+            if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+                XkbDDXAccessXBeep(kbd, _BEEP_FEATURE_ON, change);
+        }
     }
-    else if (filter->keycode==keycode) {
-	change= filter->priv;
-	if (change) {
-	    xkbControlsNotify 	cn;
-	    XkbSrvLedInfoPtr	sli;
-
-	    ctrls->enabled_ctrls&= ~change;
-	    if (XkbComputeControlsNotify(kbd,&old,ctrls,&cn,FALSE)) {
-		cn.keycode = keycode;
-		cn.eventType = KeyRelease;
-		cn.requestMajor = 0;
-		cn.requestMinor = 0;
-		XkbSendControlsNotify(kbd,&cn);
-	    }
-
-	    XkbSetCauseKey(&cause,keycode,KeyRelease);
-	    /* If sticky keys were disabled, clear all locks and latches */
-	    if ((old.enabled_ctrls&XkbStickyKeysMask)&&
-		(!(ctrls->enabled_ctrls&XkbStickyKeysMask))) {
-		XkbClearAllLatchesAndLocks(kbd,xkbi,FALSE,&cause);
-    	    }
-	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
-	    XkbUpdateIndicators(kbd,sli->usesControls,TRUE,NULL,&cause);
-	    if (XkbAX_NeedFeedback(ctrls,XkbAX_FeatureFBMask))
-		XkbDDXAccessXBeep(kbd,_BEEP_FEATURE_OFF,change);
-	}
-	filter->keycode= 0;
-	filter->active= 0;
+    else if (filter->keycode == keycode) {
+        change = filter->priv;
+        if (change) {
+            xkbControlsNotify cn;
+            XkbSrvLedInfoPtr sli;
+
+            ctrls->enabled_ctrls &= ~change;
+            if (XkbComputeControlsNotify(kbd, &old, ctrls, &cn, FALSE)) {
+                cn.keycode = keycode;
+                cn.eventType = KeyRelease;
+                cn.requestMajor = 0;
+                cn.requestMinor = 0;
+                XkbSendControlsNotify(kbd, &cn);
+            }
+
+            XkbSetCauseKey(&cause, keycode, KeyRelease);
+            /* If sticky keys were disabled, clear all locks and latches */
+            if ((old.enabled_ctrls & XkbStickyKeysMask) &&
+                (!(ctrls->enabled_ctrls & XkbStickyKeysMask))) {
+                XkbClearAllLatchesAndLocks(kbd, xkbi, FALSE, &cause);
+            }
+            sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+            XkbUpdateIndicators(kbd, sli->usesControls, TRUE, NULL, &cause);
+            if (XkbAX_NeedFeedback(ctrls, XkbAX_FeatureFBMask))
+                XkbDDXAccessXBeep(kbd, _BEEP_FEATURE_OFF, change);
+        }
+        filter->keycode = 0;
+        filter->active = 0;
     }
     return 1;
 }
 
 static int
-_XkbFilterActionMessage(XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterActionMessage(XkbSrvInfoPtr xkbi,
+                        XkbFilterPtr filter,
+                        unsigned keycode, XkbAction *pAction)
 {
-XkbMessageAction *	pMsg;
-DeviceIntPtr		kbd;
-
-    kbd= xkbi->device;
-    if (filter->keycode==0) {		/* initial press */
-	pMsg= &pAction->msg;
-	if ((pMsg->flags&XkbSA_MessageOnRelease)||
-	    ((pMsg->flags&XkbSA_MessageGenKeyEvent)==0)) {
-	    filter->keycode = keycode;
-	    filter->active = 1;
-	    filter->filterOthers = 0;
-	    filter->priv = 0;
-	    filter->filter = _XkbFilterActionMessage;
-	    filter->upAction = *pAction;
-	}
-	if (pMsg->flags&XkbSA_MessageOnPress)  {
-	    xkbActionMessage	msg;
-
-	    msg.keycode= keycode;
-	    msg.press= 1;
-	    msg.keyEventFollows=((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
-	    memcpy((char *)msg.message,
-				(char *)pMsg->message,XkbActionMessageLength);
-	    XkbSendActionMessage(kbd,&msg);
-	}
-	return ((pAction->msg.flags&XkbSA_MessageGenKeyEvent)!=0);
+    XkbMessageAction *pMsg;
+    DeviceIntPtr kbd;
+
+    kbd = xkbi->device;
+    if (filter->keycode == 0) { /* initial press */
+        pMsg = &pAction->msg;
+        if ((pMsg->flags & XkbSA_MessageOnRelease) ||
+            ((pMsg->flags & XkbSA_MessageGenKeyEvent) == 0)) {
+            filter->keycode = keycode;
+            filter->active = 1;
+            filter->filterOthers = 0;
+            filter->priv = 0;
+            filter->filter = _XkbFilterActionMessage;
+            filter->upAction = *pAction;
+        }
+        if (pMsg->flags & XkbSA_MessageOnPress) {
+            xkbActionMessage msg;
+
+            msg.keycode = keycode;
+            msg.press = 1;
+            msg.keyEventFollows =
+                ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
+            memcpy((char *) msg.message, (char *) pMsg->message,
+                   XkbActionMessageLength);
+            XkbSendActionMessage(kbd, &msg);
+        }
+        return ((pAction->msg.flags & XkbSA_MessageGenKeyEvent) != 0);
     }
-    else if (filter->keycode==keycode) {
-	pMsg= &filter->upAction.msg;
-	if (pMsg->flags&XkbSA_MessageOnRelease) {
-	    xkbActionMessage	msg;
-
-	    msg.keycode= keycode;
-	    msg.press= 0;
-	    msg.keyEventFollows=((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
-	    memcpy((char *)msg.message,(char *)pMsg->message,
-						XkbActionMessageLength);
-	    XkbSendActionMessage(kbd,&msg);
-	}
-	filter->keycode= 0;
-	filter->active= 0;
-	return ((pMsg->flags&XkbSA_MessageGenKeyEvent)!=0);
+    else if (filter->keycode == keycode) {
+        pMsg = &filter->upAction.msg;
+        if (pMsg->flags & XkbSA_MessageOnRelease) {
+            xkbActionMessage msg;
+
+            msg.keycode = keycode;
+            msg.press = 0;
+            msg.keyEventFollows =
+                ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
+            memcpy((char *) msg.message, (char *) pMsg->message,
+                   XkbActionMessageLength);
+            XkbSendActionMessage(kbd, &msg);
+        }
+        filter->keycode = 0;
+        filter->active = 0;
+        return ((pMsg->flags & XkbSA_MessageGenKeyEvent) != 0);
     }
     return 1;
 }
 
 static int
-_XkbFilterRedirectKey(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterRedirectKey(XkbSrvInfoPtr xkbi,
+                      XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
-DeviceEvent	ev;
-int		x,y;
-XkbStateRec	old;
-unsigned	mods,mask;
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(xkbi->device);
-ProcessInputProc backupproc;
+    DeviceEvent ev;
+    int x, y;
+    XkbStateRec old, old_prev;
+    unsigned mods, mask;
+    xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(xkbi->device);
+    ProcessInputProc backupproc;
 
     /* never actually used uninitialised, but gcc isn't smart enough
      * to work that out. */
     memset(&old, 0, sizeof(old));
+    memset(&old_prev, 0, sizeof(old_prev));
     memset(&ev, 0, sizeof(ev));
 
-    if ((filter->keycode!=0)&&(filter->keycode!=keycode))
-	return 1;
+    if ((filter->keycode != 0) && (filter->keycode != keycode))
+        return 1;
 
-    GetSpritePosition(xkbi->device, &x,&y);
+    GetSpritePosition(xkbi->device, &x, &y);
     ev.header = ET_Internal;
     ev.length = sizeof(DeviceEvent);
     ev.time = GetTimeInMillis();
     ev.root_x = x;
     ev.root_y = y;
-
-    if (filter->keycode==0) {		/* initial press */
-	if ((pAction->redirect.new_key<xkbi->desc->min_key_code)||
-	    (pAction->redirect.new_key>xkbi->desc->max_key_code)) {
-	    return 1;
-	}
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->priv = 0;
-	filter->filter = _XkbFilterRedirectKey;
-	filter->upAction = *pAction;
+    /* redirect actions do not work across devices, therefore the following is
+     * correct: */
+    ev.deviceid = xkbi->device->id;
+    /* filter->priv must be set up by the caller for the initial press. */
+    ev.sourceid = filter->priv;
+
+    if (filter->keycode == 0) { /* initial press */
+        if ((pAction->redirect.new_key < xkbi->desc->min_key_code) ||
+            (pAction->redirect.new_key > xkbi->desc->max_key_code)) {
+            return 1;
+        }
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->filter = _XkbFilterRedirectKey;
+        filter->upAction = *pAction;
 
         ev.type = ET_KeyPress;
         ev.detail.key = pAction->redirect.new_key;
 
-        mask= XkbSARedirectVModsMask(&pAction->redirect);
-        mods= XkbSARedirectVMods(&pAction->redirect);
-        if (mask) XkbVirtualModsToReal(xkbi->desc,mask,&mask);
-        if (mods) XkbVirtualModsToReal(xkbi->desc,mods,&mods);
-        mask|= pAction->redirect.mods_mask;
-        mods|= pAction->redirect.mods;
-
-	if ( mask || mods ) {
-	    old= xkbi->state;
-	    xkbi->state.base_mods&= ~mask;
-	    xkbi->state.base_mods|= (mods&mask);
-	    xkbi->state.latched_mods&= ~mask;
-	    xkbi->state.latched_mods|= (mods&mask);
-	    xkbi->state.locked_mods&= ~mask;
-	    xkbi->state.locked_mods|= (mods&mask);
-	    XkbComputeDerivedState(xkbi);
-	}
-
-	UNWRAP_PROCESS_INPUT_PROC(xkbi->device,xkbPrivPtr, backupproc);
-	xkbi->device->public.processInputProc((InternalEvent*)&ev, xkbi->device);
-	COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr,
-				     backupproc,xkbUnwrapProc);
-	
-	if ( mask || mods )
-	    xkbi->state= old;
+        mask = XkbSARedirectVModsMask(&pAction->redirect);
+        mods = XkbSARedirectVMods(&pAction->redirect);
+        if (mask)
+            XkbVirtualModsToReal(xkbi->desc, mask, &mask);
+        if (mods)
+            XkbVirtualModsToReal(xkbi->desc, mods, &mods);
+        mask |= pAction->redirect.mods_mask;
+        mods |= pAction->redirect.mods;
+
+        if (mask || mods) {
+            old = xkbi->state;
+            old_prev = xkbi->prev_state;
+            xkbi->state.base_mods &= ~mask;
+            xkbi->state.base_mods |= (mods & mask);
+            xkbi->state.latched_mods &= ~mask;
+            xkbi->state.latched_mods |= (mods & mask);
+            xkbi->state.locked_mods &= ~mask;
+            xkbi->state.locked_mods |= (mods & mask);
+            XkbComputeDerivedState(xkbi);
+            xkbi->prev_state = xkbi->state;
+        }
+
+        UNWRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc);
+        xkbi->device->public.processInputProc((InternalEvent *) &ev,
+                                              xkbi->device);
+        COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc,
+                                     xkbUnwrapProc);
+
+        if (mask || mods) {
+            xkbi->state = old;
+            xkbi->prev_state = old_prev;
+        }
     }
-    else if (filter->keycode==keycode) {
+    else if (filter->keycode == keycode) {
 
         ev.type = ET_KeyRelease;
         ev.detail.key = filter->upAction.redirect.new_key;
 
-        mask= XkbSARedirectVModsMask(&filter->upAction.redirect);
-        mods= XkbSARedirectVMods(&filter->upAction.redirect);
-        if (mask) XkbVirtualModsToReal(xkbi->desc,mask,&mask);
-        if (mods) XkbVirtualModsToReal(xkbi->desc,mods,&mods);
-        mask|= filter->upAction.redirect.mods_mask;
-        mods|= filter->upAction.redirect.mods;
-
-	if ( mask || mods ) {
-	    old= xkbi->state;
-	    xkbi->state.base_mods&= ~mask;
-	    xkbi->state.base_mods|= (mods&mask);
-	    xkbi->state.latched_mods&= ~mask;
-	    xkbi->state.latched_mods|= (mods&mask);
-	    xkbi->state.locked_mods&= ~mask;
-	    xkbi->state.locked_mods|= (mods&mask);
-	    XkbComputeDerivedState(xkbi);
-	}
-
-	UNWRAP_PROCESS_INPUT_PROC(xkbi->device,xkbPrivPtr, backupproc);
-	xkbi->device->public.processInputProc((InternalEvent*)&ev, xkbi->device);
-	COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr,
-				     backupproc,xkbUnwrapProc);
-
-	if ( mask || mods )
-	    xkbi->state= old;
-
-	filter->keycode= 0;
-	filter->active= 0;
+        mask = XkbSARedirectVModsMask(&filter->upAction.redirect);
+        mods = XkbSARedirectVMods(&filter->upAction.redirect);
+        if (mask)
+            XkbVirtualModsToReal(xkbi->desc, mask, &mask);
+        if (mods)
+            XkbVirtualModsToReal(xkbi->desc, mods, &mods);
+        mask |= filter->upAction.redirect.mods_mask;
+        mods |= filter->upAction.redirect.mods;
+
+        if (mask || mods) {
+            old = xkbi->state;
+            old_prev = xkbi->prev_state;
+            xkbi->state.base_mods &= ~mask;
+            xkbi->state.base_mods |= (mods & mask);
+            xkbi->state.latched_mods &= ~mask;
+            xkbi->state.latched_mods |= (mods & mask);
+            xkbi->state.locked_mods &= ~mask;
+            xkbi->state.locked_mods |= (mods & mask);
+            XkbComputeDerivedState(xkbi);
+            xkbi->prev_state = xkbi->state;
+        }
+
+        UNWRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc);
+        xkbi->device->public.processInputProc((InternalEvent *) &ev,
+                                              xkbi->device);
+        COND_WRAP_PROCESS_INPUT_PROC(xkbi->device, xkbPrivPtr, backupproc,
+                                     xkbUnwrapProc);
+
+        if (mask || mods) {
+            xkbi->state = old;
+            xkbi->prev_state = old_prev;
+        }
+
+        filter->keycode = 0;
+        filter->active = 0;
     }
     return 0;
 }
 
 static int
-_XkbFilterSwitchScreen(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterSwitchScreen(XkbSrvInfoPtr xkbi,
+                       XkbFilterPtr filter,
+                       unsigned keycode, XkbAction *pAction)
 {
     DeviceIntPtr dev = xkbi->device;
+
     if (dev == inputInfo.keyboard)
         return 0;
 
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->filter = _XkbFilterSwitchScreen;
-	AccessXCancelRepeatKey(xkbi, keycode);
-	XkbDDXSwitchScreen(dev,keycode,pAction);
-        return 0; 
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->filter = _XkbFilterSwitchScreen;
+        AccessXCancelRepeatKey(xkbi, keycode);
+        XkbDDXSwitchScreen(dev, keycode, pAction);
+        return 0;
     }
-    else if (filter->keycode==keycode) {
-	filter->active= 0;
-        return 0; 
+    else if (filter->keycode == keycode) {
+        filter->active = 0;
+        return 0;
     }
     return 1;
 }
 
 static int
-_XkbFilterXF86Private(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterXF86Private(XkbSrvInfoPtr xkbi,
+                      XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
     DeviceIntPtr dev = xkbi->device;
+
     if (dev == inputInfo.keyboard)
         return 0;
 
-    if (filter->keycode==0) {		/* initial press */
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->filter = _XkbFilterXF86Private;
-	XkbDDXPrivate(dev,keycode,pAction);
-        return 0; 
+    if (filter->keycode == 0) { /* initial press */
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->filter = _XkbFilterXF86Private;
+        XkbDDXPrivate(dev, keycode, pAction);
+        return 0;
     }
-    else if (filter->keycode==keycode) {
-	filter->active= 0;
-        return 0; 
+    else if (filter->keycode == keycode) {
+        filter->active = 0;
+        return 0;
     }
     return 1;
 }
 
-
 static int
-_XkbFilterDeviceBtn(	XkbSrvInfoPtr	xkbi,
-			XkbFilterPtr	filter,
-			unsigned	keycode,
-			XkbAction *	pAction)
+_XkbFilterDeviceBtn(XkbSrvInfoPtr xkbi,
+                    XkbFilterPtr filter, unsigned keycode, XkbAction *pAction)
 {
     if (xkbi->device == inputInfo.keyboard)
         return 0;
 
-    if (filter->keycode==0) {		/* initial press */
-	DeviceIntPtr	dev;
-	int		button;
-
-	_XkbLookupButtonDevice(&dev, pAction->devbtn.device, serverClient,
-			       DixUnknownAccess, &button);
-	if (!dev || !dev->public.on)
-	    return 1;
-
-	button= pAction->devbtn.button;
-	if ((button<1)||(button>dev->button->numButtons))
-	    return 1;
-
-	filter->keycode = keycode;
-	filter->active = 1;
-	filter->filterOthers = 0;
-	filter->priv=0;
-	filter->filter = _XkbFilterDeviceBtn;
-	filter->upAction= *pAction;
-	switch (pAction->type) {
-	    case XkbSA_LockDeviceBtn:
-		if ((pAction->devbtn.flags&XkbSA_LockNoLock)||
-		    BitIsOn(dev->button->down, button))
-		    return 0;
-		XkbFakeDeviceButton(dev,TRUE,button);
-		filter->upAction.type= XkbSA_NoAction;
-		break;
-	    case XkbSA_DeviceBtn:
-		if (pAction->devbtn.count>0) {
-		    int nClicks,i;
-		    nClicks= pAction->btn.count;
-		    for (i=0;i<nClicks;i++) {
-			XkbFakeDeviceButton(dev,TRUE,button);
-			XkbFakeDeviceButton(dev,FALSE,button);
-		    }
-		    filter->upAction.type= XkbSA_NoAction;
-		}
-		else XkbFakeDeviceButton(dev,TRUE,button);
-		break;
-	}
+    if (filter->keycode == 0) { /* initial press */
+        DeviceIntPtr dev;
+        int button;
+
+        _XkbLookupButtonDevice(&dev, pAction->devbtn.device, serverClient,
+                               DixUnknownAccess, &button);
+        if (!dev || !dev->public.on)
+            return 1;
+
+        button = pAction->devbtn.button;
+        if ((button < 1) || (button > dev->button->numButtons))
+            return 1;
+
+        filter->keycode = keycode;
+        filter->active = 1;
+        filter->filterOthers = 0;
+        filter->priv = 0;
+        filter->filter = _XkbFilterDeviceBtn;
+        filter->upAction = *pAction;
+        switch (pAction->type) {
+        case XkbSA_LockDeviceBtn:
+            if ((pAction->devbtn.flags & XkbSA_LockNoLock) ||
+                BitIsOn(dev->button->down, button))
+                return 0;
+            XkbFakeDeviceButton(dev, TRUE, button);
+            filter->upAction.type = XkbSA_NoAction;
+            break;
+        case XkbSA_DeviceBtn:
+            if (pAction->devbtn.count > 0) {
+                int nClicks, i;
+
+                nClicks = pAction->btn.count;
+                for (i = 0; i < nClicks; i++) {
+                    XkbFakeDeviceButton(dev, TRUE, button);
+                    XkbFakeDeviceButton(dev, FALSE, button);
+                }
+                filter->upAction.type = XkbSA_NoAction;
+            }
+            else
+                XkbFakeDeviceButton(dev, TRUE, button);
+            break;
+        }
     }
-    else if (filter->keycode==keycode) {
-	DeviceIntPtr	dev;
-	int		button;
-
-	filter->active= 0;
-	_XkbLookupButtonDevice(&dev, filter->upAction.devbtn.device,
-			       serverClient, DixUnknownAccess, &button);
-	if (!dev || !dev->public.on)
-	    return 1;
-
-	button= filter->upAction.btn.button;
-	switch (filter->upAction.type) {
-	    case XkbSA_LockDeviceBtn:
-		if ((filter->upAction.devbtn.flags&XkbSA_LockNoUnlock)||
-		    !BitIsOn(dev->button->down, button))
-		    return 0;
-		XkbFakeDeviceButton(dev,FALSE,button);
-		break;
-	    case XkbSA_DeviceBtn:
-		XkbFakeDeviceButton(dev,FALSE,button);
-		break;
-	}
-	filter->active = 0;
+    else if (filter->keycode == keycode) {
+        DeviceIntPtr dev;
+        int button;
+
+        filter->active = 0;
+        _XkbLookupButtonDevice(&dev, filter->upAction.devbtn.device,
+                               serverClient, DixUnknownAccess, &button);
+        if (!dev || !dev->public.on)
+            return 1;
+
+        button = filter->upAction.btn.button;
+        switch (filter->upAction.type) {
+        case XkbSA_LockDeviceBtn:
+            if ((filter->upAction.devbtn.flags & XkbSA_LockNoUnlock) ||
+                !BitIsOn(dev->button->down, button))
+                return 0;
+            XkbFakeDeviceButton(dev, FALSE, button);
+            break;
+        case XkbSA_DeviceBtn:
+            XkbFakeDeviceButton(dev, FALSE, button);
+            break;
+        }
+        filter->active = 0;
     }
     return 0;
 }
 
 static XkbFilterPtr
-_XkbNextFreeFilter(
-	XkbSrvInfoPtr xkbi
-)
+_XkbNextFreeFilter(XkbSrvInfoPtr xkbi)
 {
-register int	i;
+    register int i;
 
-    if (xkbi->szFilters==0) {
-	xkbi->szFilters = 4;
-	xkbi->filters = calloc(xkbi->szFilters, sizeof(XkbFilterRec));
-	/* 6/21/93 (ef) -- XXX! deal with allocation failure */
+    if (xkbi->szFilters == 0) {
+        xkbi->szFilters = 4;
+        xkbi->filters = calloc(xkbi->szFilters, sizeof(XkbFilterRec));
+        /* 6/21/93 (ef) -- XXX! deal with allocation failure */
     }
-    for (i=0;i<xkbi->szFilters;i++) {
-	if (!xkbi->filters[i].active) {
-	    xkbi->filters[i].keycode = 0;
-	    return &xkbi->filters[i];
-	}
+    for (i = 0; i < xkbi->szFilters; i++) {
+        if (!xkbi->filters[i].active) {
+            xkbi->filters[i].keycode = 0;
+            return &xkbi->filters[i];
+        }
     }
-    xkbi->szFilters*=2;
-    xkbi->filters= realloc(xkbi->filters,
+    xkbi->szFilters *= 2;
+    xkbi->filters = realloc(xkbi->filters,
                             xkbi->szFilters * sizeof(XkbFilterRec));
     /* 6/21/93 (ef) -- XXX! deal with allocation failure */
-    memset(&xkbi->filters[xkbi->szFilters/2], 0,
-            (xkbi->szFilters/2)*sizeof(XkbFilterRec));
-    return &xkbi->filters[xkbi->szFilters/2];
+    memset(&xkbi->filters[xkbi->szFilters / 2], 0,
+           (xkbi->szFilters / 2) * sizeof(XkbFilterRec));
+    return &xkbi->filters[xkbi->szFilters / 2];
 }
 
 static int
-_XkbApplyFilters(XkbSrvInfoPtr xkbi,unsigned kc,XkbAction *pAction)
+_XkbApplyFilters(XkbSrvInfoPtr xkbi, unsigned kc, XkbAction *pAction)
 {
-register int	i,send;
-
-    send= 1;
-    for (i=0;i<xkbi->szFilters;i++) {
-	if ((xkbi->filters[i].active)&&(xkbi->filters[i].filter))
-	    send= ((*xkbi->filters[i].filter)(xkbi,&xkbi->filters[i],kc,pAction) 
-                    && send);
+    register int i, send;
+
+    send = 1;
+    for (i = 0; i < xkbi->szFilters; i++) {
+        if ((xkbi->filters[i].active) && (xkbi->filters[i].filter))
+            send =
+                ((*xkbi->filters[i].filter) (xkbi, &xkbi->filters[i], kc,
+                                             pAction)
+                 && send);
     }
     return send;
 }
 
 void
-XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent* event)
+XkbHandleActions(DeviceIntPtr dev, DeviceIntPtr kbd, DeviceEvent *event)
 {
-int		key,bit,i;
-XkbSrvInfoPtr	xkbi;
-KeyClassPtr	keyc;
-int		changed,sendEvent;
-Bool		genStateNotify;
-XkbAction	act;
-XkbFilterPtr	filter;
-Bool		keyEvent;
-Bool		pressEvent;
-ProcessInputProc backupproc;
-    
-xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
-
-    keyc= kbd->key;
-    xkbi= keyc->xkbInfo;
-    key= event->detail.key;
+    int key, bit, i;
+    XkbSrvInfoPtr xkbi;
+    KeyClassPtr keyc;
+    int changed, sendEvent;
+    Bool genStateNotify;
+    XkbAction act;
+    XkbFilterPtr filter;
+    Bool keyEvent;
+    Bool pressEvent;
+    ProcessInputProc backupproc;
+
+    xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(dev);
+
+    keyc = kbd->key;
+    xkbi = keyc->xkbInfo;
+    key = event->detail.key;
     /* The state may change, so if we're not in the middle of sending a state
      * notify, prepare for it */
-    if ((xkbi->flags&_XkbStateNotifyInProgress)==0) {
-	xkbi->prev_state = xkbi->state;
-	xkbi->flags|= _XkbStateNotifyInProgress;
-	genStateNotify= TRUE;
+    if ((xkbi->flags & _XkbStateNotifyInProgress) == 0) {
+        xkbi->prev_state = xkbi->state;
+        xkbi->flags |= _XkbStateNotifyInProgress;
+        genStateNotify = TRUE;
     }
-    else genStateNotify= FALSE;
+    else
+        genStateNotify = FALSE;
 
     xkbi->clearMods = xkbi->setMods = 0;
     xkbi->groupChange = 0;
 
     sendEvent = 1;
-    keyEvent= ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
-    pressEvent= ((event->type == ET_KeyPress)|| (event->type == ET_ButtonPress));
+    keyEvent = ((event->type == ET_KeyPress) || (event->type == ET_KeyRelease));
+    pressEvent = ((event->type == ET_KeyPress) ||
+                  (event->type == ET_ButtonPress));
 
     if (pressEvent) {
-	if (keyEvent)	
-	    act = XkbGetKeyAction(xkbi,&xkbi->state,key);
-	else {
-	    act = XkbGetButtonAction(kbd,dev,key);
-	    key|= BTN_ACT_FLAG;
-	}
-	sendEvent = _XkbApplyFilters(xkbi,key,&act);
-	if (sendEvent) {
-	    switch (act.type) {
-		case XkbSA_SetMods:
-		case XkbSA_SetGroup:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent = _XkbFilterSetState(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_LatchMods:
-		case XkbSA_LatchGroup:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterLatchState(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_LockMods:
-		case XkbSA_LockGroup:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterLockState(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_ISOLock:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterISOLock(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_MovePtr:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent= _XkbFilterPointerMove(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_PtrBtn:
-		case XkbSA_LockPtrBtn:
-		case XkbSA_SetPtrDflt:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent= _XkbFilterPointerBtn(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_Terminate:
-		    sendEvent= XkbDDXTerminateServer(dev,key,&act);
-		    break;
-		case XkbSA_SwitchScreen:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterSwitchScreen(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_SetControls:
-		case XkbSA_LockControls:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterControls(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_ActionMessage:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent=_XkbFilterActionMessage(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_RedirectKey:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent= _XkbFilterRedirectKey(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_DeviceBtn:
-		case XkbSA_LockDeviceBtn:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent= _XkbFilterDeviceBtn(xkbi,filter,key,&act);
-		    break;
-		case XkbSA_XFree86Private:
-		    filter = _XkbNextFreeFilter(xkbi);
-		    sendEvent= _XkbFilterXF86Private(xkbi,filter,key,&act);
-		    break;
-	    }
-	}
+        if (keyEvent)
+            act = XkbGetKeyAction(xkbi, &xkbi->state, key);
+        else {
+            act = XkbGetButtonAction(kbd, dev, key);
+            key |= BTN_ACT_FLAG;
+        }
+        sendEvent = _XkbApplyFilters(xkbi, key, &act);
+        if (sendEvent) {
+            switch (act.type) {
+            case XkbSA_SetMods:
+            case XkbSA_SetGroup:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterSetState(xkbi, filter, key, &act);
+                break;
+            case XkbSA_LatchMods:
+            case XkbSA_LatchGroup:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterLatchState(xkbi, filter, key, &act);
+                break;
+            case XkbSA_LockMods:
+            case XkbSA_LockGroup:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterLockState(xkbi, filter, key, &act);
+                break;
+            case XkbSA_ISOLock:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterISOLock(xkbi, filter, key, &act);
+                break;
+            case XkbSA_MovePtr:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterPointerMove(xkbi, filter, key, &act);
+                break;
+            case XkbSA_PtrBtn:
+            case XkbSA_LockPtrBtn:
+            case XkbSA_SetPtrDflt:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterPointerBtn(xkbi, filter, key, &act);
+                break;
+            case XkbSA_Terminate:
+                sendEvent = XkbDDXTerminateServer(dev, key, &act);
+                break;
+            case XkbSA_SwitchScreen:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterSwitchScreen(xkbi, filter, key, &act);
+                break;
+            case XkbSA_SetControls:
+            case XkbSA_LockControls:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterControls(xkbi, filter, key, &act);
+                break;
+            case XkbSA_ActionMessage:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterActionMessage(xkbi, filter, key, &act);
+                break;
+            case XkbSA_RedirectKey:
+                filter = _XkbNextFreeFilter(xkbi);
+                /* redirect actions must create a new DeviceEvent.  The
+                 * source device id for this event cannot be obtained from
+                 * xkbi, so we pass it here explicitly. The field deviceid
+                 * equals to xkbi->device->id. */
+                filter->priv = event->sourceid;
+                sendEvent = _XkbFilterRedirectKey(xkbi, filter, key, &act);
+                break;
+            case XkbSA_DeviceBtn:
+            case XkbSA_LockDeviceBtn:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterDeviceBtn(xkbi, filter, key, &act);
+                break;
+            case XkbSA_XFree86Private:
+                filter = _XkbNextFreeFilter(xkbi);
+                sendEvent = _XkbFilterXF86Private(xkbi, filter, key, &act);
+                break;
+            }
+        }
     }
     else {
-	if (!keyEvent)
-	    key|= BTN_ACT_FLAG;
-	sendEvent = _XkbApplyFilters(xkbi,key,NULL);
+        if (!keyEvent)
+            key |= BTN_ACT_FLAG;
+        sendEvent = _XkbApplyFilters(xkbi, key, NULL);
     }
 
-    if (xkbi->groupChange!=0)
-	xkbi->state.base_group+= xkbi->groupChange;
+    if (xkbi->groupChange != 0)
+        xkbi->state.base_group += xkbi->groupChange;
     if (xkbi->setMods) {
-	for (i=0,bit=1; xkbi->setMods; i++,bit<<=1 ) {
-	    if (xkbi->setMods&bit) {
-		keyc->modifierKeyCount[i]++;
-		xkbi->state.base_mods|= bit;
-		xkbi->setMods&= ~bit;
-	    }
-	}
+        for (i = 0, bit = 1; xkbi->setMods; i++, bit <<= 1) {
+            if (xkbi->setMods & bit) {
+                keyc->modifierKeyCount[i]++;
+                xkbi->state.base_mods |= bit;
+                xkbi->setMods &= ~bit;
+            }
+        }
     }
     if (xkbi->clearMods) {
-	for (i=0,bit=1; xkbi->clearMods; i++,bit<<=1 ) {
-	    if (xkbi->clearMods&bit) {
-		keyc->modifierKeyCount[i]--;
-		if (keyc->modifierKeyCount[i]<=0) {
-		    xkbi->state.base_mods&= ~bit;
-		    keyc->modifierKeyCount[i] = 0;
-		}
-		xkbi->clearMods&= ~bit;
-	    }
-	}
+        for (i = 0, bit = 1; xkbi->clearMods; i++, bit <<= 1) {
+            if (xkbi->clearMods & bit) {
+                keyc->modifierKeyCount[i]--;
+                if (keyc->modifierKeyCount[i] <= 0) {
+                    xkbi->state.base_mods &= ~bit;
+                    keyc->modifierKeyCount[i] = 0;
+                }
+                xkbi->clearMods &= ~bit;
+            }
+        }
     }
 
     if (sendEvent) {
         DeviceIntPtr tmpdev;
-	if (keyEvent)
+
+        if (keyEvent)
             tmpdev = dev;
         else
             tmpdev = GetMaster(dev, POINTER_OR_FLOAT);
 
-        UNWRAP_PROCESS_INPUT_PROC(tmpdev,xkbPrivPtr, backupproc);
-        dev->public.processInputProc((InternalEvent*)event, tmpdev);
+        UNWRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr, backupproc);
+        dev->public.processInputProc((InternalEvent *) event, tmpdev);
         COND_WRAP_PROCESS_INPUT_PROC(tmpdev, xkbPrivPtr,
-                                     backupproc,xkbUnwrapProc);
+                                     backupproc, xkbUnwrapProc);
     }
     else if (keyEvent) {
-	FixKeyState(event, dev);
+        FixKeyState(event, dev);
     }
 
     XkbComputeDerivedState(xkbi);
-    changed = XkbStateChangedFlags(&xkbi->prev_state,&xkbi->state);
+    changed = XkbStateChangedFlags(&xkbi->prev_state, &xkbi->state);
     if (genStateNotify) {
-	if (changed) {
-	    xkbStateNotify	sn;
-	    sn.keycode= key;
-	    sn.eventType= event->type;
-	    sn.requestMajor = sn.requestMinor = 0;
-	    sn.changed= changed;
-	    XkbSendStateNotify(dev,&sn);
-	}
-	xkbi->flags&= ~_XkbStateNotifyInProgress;
+        if (changed) {
+            xkbStateNotify sn;
+
+            sn.keycode = key;
+            sn.eventType = event->type;
+            sn.requestMajor = sn.requestMinor = 0;
+            sn.changed = changed;
+            XkbSendStateNotify(dev, &sn);
+        }
+        xkbi->flags &= ~_XkbStateNotifyInProgress;
     }
-    changed= XkbIndicatorsToUpdate(dev,changed,FALSE);
+    changed = XkbIndicatorsToUpdate(dev, changed, FALSE);
     if (changed) {
-	XkbEventCauseRec	cause;
-	XkbSetCauseKey(&cause, key, event->type);
-	XkbUpdateIndicators(dev,changed,FALSE,NULL,&cause);
+        XkbEventCauseRec cause;
+
+        XkbSetCauseKey(&cause, key, event->type);
+        XkbUpdateIndicators(dev, changed, FALSE, NULL, &cause);
     }
     return;
 }
 
 int
-XkbLatchModifiers(DeviceIntPtr pXDev,CARD8 mask,CARD8 latches)
+XkbLatchModifiers(DeviceIntPtr pXDev, CARD8 mask, CARD8 latches)
 {
-XkbSrvInfoPtr	xkbi;
-XkbFilterPtr	filter;
-XkbAction	act;
-unsigned	clear;
-
-    if ( pXDev && pXDev->key && pXDev->key->xkbInfo ) {
-	xkbi = pXDev->key->xkbInfo;
-	clear= (mask&(~latches));
-	xkbi->state.latched_mods&= ~clear;
-	/* Clear any pending latch to locks.
-	 */
-	act.type = XkbSA_NoAction;
-	_XkbApplyFilters(xkbi,SYNTHETIC_KEYCODE,&act);
-	act.type = XkbSA_LatchMods;
-	act.mods.flags = 0;
-	act.mods.mask  = mask&latches;
-	filter = _XkbNextFreeFilter(xkbi);
-	_XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,&act);
-	_XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,(XkbAction *)NULL);
-	return Success;
+    XkbSrvInfoPtr xkbi;
+    XkbFilterPtr filter;
+    XkbAction act;
+    unsigned clear;
+
+    if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
+        xkbi = pXDev->key->xkbInfo;
+        clear = (mask & (~latches));
+        xkbi->state.latched_mods &= ~clear;
+        /* Clear any pending latch to locks.
+         */
+        act.type = XkbSA_NoAction;
+        _XkbApplyFilters(xkbi, SYNTHETIC_KEYCODE, &act);
+        act.type = XkbSA_LatchMods;
+        act.mods.flags = 0;
+        act.mods.mask = mask & latches;
+        filter = _XkbNextFreeFilter(xkbi);
+        _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE, &act);
+        _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE,
+                             (XkbAction *) NULL);
+        return Success;
     }
     return BadValue;
 }
 
 int
-XkbLatchGroup(DeviceIntPtr pXDev,int group)
+XkbLatchGroup(DeviceIntPtr pXDev, int group)
 {
-XkbSrvInfoPtr	xkbi;
-XkbFilterPtr	filter;
-XkbAction	act;
-
-    if ( pXDev && pXDev->key && pXDev->key->xkbInfo ) {
-	xkbi = pXDev->key->xkbInfo;
-	act.type = XkbSA_LatchGroup;
-	act.group.flags = 0;
-	XkbSASetGroup(&act.group,group);
-	filter = _XkbNextFreeFilter(xkbi);
-	_XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,&act);
-	_XkbFilterLatchState(xkbi,filter,SYNTHETIC_KEYCODE,(XkbAction *)NULL);
-	return Success;
+    XkbSrvInfoPtr xkbi;
+    XkbFilterPtr filter;
+    XkbAction act;
+
+    if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
+        xkbi = pXDev->key->xkbInfo;
+        act.type = XkbSA_LatchGroup;
+        act.group.flags = 0;
+        XkbSASetGroup(&act.group, group);
+        filter = _XkbNextFreeFilter(xkbi);
+        _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE, &act);
+        _XkbFilterLatchState(xkbi, filter, SYNTHETIC_KEYCODE,
+                             (XkbAction *) NULL);
+        return Success;
     }
     return BadValue;
 }
@@ -1287,46 +1320,45 @@ XkbAction	act;
 /***====================================================================***/
 
 void
-XkbClearAllLatchesAndLocks(	DeviceIntPtr		dev,
-				XkbSrvInfoPtr		xkbi,
-				Bool			genEv,
-				XkbEventCausePtr	cause)
+XkbClearAllLatchesAndLocks(DeviceIntPtr dev,
+                           XkbSrvInfoPtr xkbi,
+                           Bool genEv, XkbEventCausePtr cause)
 {
-XkbStateRec	os;
-xkbStateNotify	sn;
-
-    sn.changed= 0;
-    os= xkbi->state;
-    if (os.latched_mods) { /* clear all latches */
-	XkbLatchModifiers(dev,~0,0);
-	sn.changed|= XkbModifierLatchMask;
+    XkbStateRec os;
+    xkbStateNotify sn;
+
+    sn.changed = 0;
+    os = xkbi->state;
+    if (os.latched_mods) {      /* clear all latches */
+        XkbLatchModifiers(dev, ~0, 0);
+        sn.changed |= XkbModifierLatchMask;
     }
     if (os.latched_group) {
-	XkbLatchGroup(dev,0);
-	sn.changed|= XkbGroupLatchMask;
+        XkbLatchGroup(dev, 0);
+        sn.changed |= XkbGroupLatchMask;
     }
     if (os.locked_mods) {
-	xkbi->state.locked_mods= 0;
-	sn.changed|= XkbModifierLockMask;
+        xkbi->state.locked_mods = 0;
+        sn.changed |= XkbModifierLockMask;
     }
     if (os.locked_group) {
-	xkbi->state.locked_group= 0;
-	sn.changed|= XkbGroupLockMask;
+        xkbi->state.locked_group = 0;
+        sn.changed |= XkbGroupLockMask;
     }
-    if ( genEv && sn.changed) {
-	CARD32 	changed;
-
-	XkbComputeDerivedState(xkbi);
-	sn.keycode= 		cause->kc;
-	sn.eventType=		cause->event;
-	sn.requestMajor= 	cause->mjr;
-	sn.requestMinor= 	cause->mnr;
-	sn.changed= XkbStateChangedFlags(&os,&xkbi->state);
-	XkbSendStateNotify(dev,&sn);
-	changed= XkbIndicatorsToUpdate(dev,sn.changed,FALSE);
-	if (changed) {
-	    XkbUpdateIndicators(dev,changed,TRUE,NULL,cause);
-	}
+    if (genEv && sn.changed) {
+        CARD32 changed;
+
+        XkbComputeDerivedState(xkbi);
+        sn.keycode = cause->kc;
+        sn.eventType = cause->event;
+        sn.requestMajor = cause->mjr;
+        sn.requestMinor = cause->mnr;
+        sn.changed = XkbStateChangedFlags(&os, &xkbi->state);
+        XkbSendStateNotify(dev, &sn);
+        changed = XkbIndicatorsToUpdate(dev, sn.changed, FALSE);
+        if (changed) {
+            XkbUpdateIndicators(dev, changed, TRUE, NULL, cause);
+        }
     }
     return;
 }
@@ -1352,31 +1384,33 @@ xkbStateNotify	sn;
  * First one on drinking island wins!
  */
 static void
-InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, ValuatorMask *mask)
+InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags,
+                       ValuatorMask *mask)
 {
-    ScreenPtr           pScreen;
-    InternalEvent*      events;
-    int                 nevents, i;
-    DeviceIntPtr        ptr, mpointer, lastSlave = NULL;
-    Bool                saveWait;
+    ScreenPtr pScreen;
+    InternalEvent *events;
+    int nevents, i;
+    DeviceIntPtr ptr, mpointer, lastSlave = NULL;
+    Bool saveWait;
 
     if (IsMaster(dev)) {
         mpointer = GetMaster(dev, MASTER_POINTER);
         lastSlave = mpointer->lastSlave;
         ptr = GetXTestDevice(mpointer);
-    } else if (IsFloating(dev))
+    }
+    else if (IsFloating(dev))
         ptr = dev;
     else
         return;
 
-
     events = InitEventList(GetMaximumEventsNum() + 1);
     OsBlockSignals();
     pScreen = miPointerGetScreen(ptr);
     saveWait = miPointerSetWaitForUpdate(pScreen, FALSE);
     nevents = GetPointerEvents(events, ptr, type, button, flags, mask);
     if (IsMaster(dev) && (lastSlave && lastSlave != ptr))
-        UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT, &nevents);
+        UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT,
+                         &nevents);
     miPointerSetWaitForUpdate(pScreen, saveWait);
     OsReleaseSignals();
 
@@ -1388,10 +1422,10 @@ InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, Valuat
 }
 
 static void
-XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
+XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags, int x, int y)
 {
-    ValuatorMask        mask;
-    int                 gpe_flags = 0;
+    ValuatorMask mask;
+    int gpe_flags = 0;
     int                 Point[]={x, y};
 
     /* ignore attached SDs */
@@ -1403,16 +1437,17 @@ XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
     else
         gpe_flags = POINTER_RELATIVE;
 
-    valuator_mask_set_range(&mask, 0, 2, Point);
+    valuator_mask_set_range(&mask, 0, 2,
+                            Point);
 
     InjectPointerKeyEvents(dev, MotionNotify, 0, gpe_flags, &mask);
 }
 
 void
-XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button)
+XkbFakeDeviceButton(DeviceIntPtr dev, Bool press, int button)
 {
-    DeviceIntPtr        ptr;
-    int                 down;
+    DeviceIntPtr ptr;
+    int down;
 
     /* If dev is a slave device, and the SD is attached, do nothing. If we'd
      * post through the attached master pointer we'd get duplicate events.
@@ -1424,8 +1459,10 @@ XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button)
 
     if (IsMaster(dev)) {
         DeviceIntPtr mpointer = GetMaster(dev, MASTER_POINTER);
+
         ptr = GetXTestDevice(mpointer);
-    } else if (IsFloating(dev))
+    }
+    else if (IsFloating(dev))
         ptr = dev;
     else
         return;
diff --git a/xorg-server/xkb/xkbDflts.h b/xorg-server/xkb/xkbDflts.h
index 5d8690650..994726c0f 100644
--- a/xorg-server/xkb/xkbDflts.h
+++ b/xorg-server/xkb/xkbDflts.h
@@ -26,444 +26,446 @@
 /* types name is "default" */
 static Atom lnames_ONE_LEVEL[1];
 
-static XkbKTMapEntryRec map_TWO_LEVEL[1]= {
-    { 1,      1, {       ShiftMask,       ShiftMask,               0 } }
+static XkbKTMapEntryRec map_TWO_LEVEL[1] = {
+    {1, 1, {ShiftMask, ShiftMask, 0}}
 };
+
 static Atom lnames_TWO_LEVEL[2];
 
-static XkbKTMapEntryRec map_ALPHABETIC[2]= {
-    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
-    { 1,      0, {        LockMask,        LockMask,               0 } }
+static XkbKTMapEntryRec map_ALPHABETIC[2] = {
+    {1, 1, {ShiftMask, ShiftMask, 0}},
+    {1, 0, {LockMask, LockMask, 0}}
 };
-static XkbModsRec preserve_ALPHABETIC[2]= {
-    {                 0,               0,               0 },
-    {          LockMask,        LockMask,               0 }
+
+static XkbModsRec preserve_ALPHABETIC[2] = {
+    {0, 0, 0},
+    {LockMask, LockMask, 0}
 };
+
 static Atom lnames_ALPHABETIC[2];
 
-static XkbKTMapEntryRec map_KEYPAD[2]= {
-    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
-    { 0,      1, {               0,               0, vmod_NumLockMask } }
+static XkbKTMapEntryRec map_KEYPAD[2] = {
+    {1, 1, {ShiftMask, ShiftMask, 0}},
+    {0, 1, {0, 0, vmod_NumLockMask}}
 };
+
 static Atom lnames_KEYPAD[2];
 
-static XkbKTMapEntryRec map_PC_BREAK[1]= {
-    { 1,      1, {     ControlMask,     ControlMask,               0 } }
+static XkbKTMapEntryRec map_PC_BREAK[1] = {
+    {1, 1, {ControlMask, ControlMask, 0}}
 };
+
 static Atom lnames_PC_BREAK[2];
 
-static XkbKTMapEntryRec map_PC_SYSRQ[1]= {
-    { 0,      1, {               0,               0,    vmod_AltMask } }
+static XkbKTMapEntryRec map_PC_SYSRQ[1] = {
+    {0, 1, {0, 0, vmod_AltMask}}
 };
+
 static Atom lnames_PC_SYSRQ[2];
 
-static XkbKTMapEntryRec map_CTRL_ALT[1]= {
-    { 0,      1, {     ControlMask,     ControlMask,    vmod_AltMask } }
+static XkbKTMapEntryRec map_CTRL_ALT[1] = {
+    {0, 1, {ControlMask, ControlMask, vmod_AltMask}}
 };
+
 static Atom lnames_CTRL_ALT[2];
 
-static XkbKTMapEntryRec map_THREE_LEVEL[3]= {
-    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
-    { 0,      2, {               0,               0, vmod_LevelThreeMask } },
-    { 0,      2, {       ShiftMask,       ShiftMask, vmod_LevelThreeMask } }
+static XkbKTMapEntryRec map_THREE_LEVEL[3] = {
+    {1, 1, {ShiftMask, ShiftMask, 0}},
+    {0, 2, {0, 0, vmod_LevelThreeMask}},
+    {0, 2, {ShiftMask, ShiftMask, vmod_LevelThreeMask}}
 };
+
 static Atom lnames_THREE_LEVEL[3];
 
-static XkbKTMapEntryRec map_SHIFT_ALT[1]= {
-    { 0,      1, {       ShiftMask,       ShiftMask,    vmod_AltMask } }
+static XkbKTMapEntryRec map_SHIFT_ALT[1] = {
+    {0, 1, {ShiftMask, ShiftMask, vmod_AltMask}}
 };
+
 static Atom lnames_SHIFT_ALT[2];
 
-static XkbKeyTypeRec dflt_types[]= {
+static XkbKeyTypeRec dflt_types[] = {
     {
-	{               0,               0,               0 },
-	1,
-	0,	NULL,	NULL,
-	None,	lnames_ONE_LEVEL
-    },
+     {0, 0, 0},
+     1,
+     0, NULL, NULL,
+     None, lnames_ONE_LEVEL},
     {
-	{       ShiftMask,       ShiftMask,               0 },
-	2,
-	1,	map_TWO_LEVEL,	NULL,
-	None,	lnames_TWO_LEVEL
-    },
+     {ShiftMask, ShiftMask, 0},
+     2,
+     1, map_TWO_LEVEL, NULL,
+     None, lnames_TWO_LEVEL},
     {
-	{ ShiftMask|LockMask, ShiftMask|LockMask,               0 },
-	2,
-	2,	map_ALPHABETIC,	preserve_ALPHABETIC,
-	None,	lnames_ALPHABETIC
-    },
+     {ShiftMask | LockMask, ShiftMask | LockMask, 0},
+     2,
+     2, map_ALPHABETIC, preserve_ALPHABETIC,
+     None, lnames_ALPHABETIC},
     {
-	{       ShiftMask,       ShiftMask, vmod_NumLockMask },
-	2,
-	2,	map_KEYPAD,	NULL,
-	None,	lnames_KEYPAD
-    },
+     {ShiftMask, ShiftMask, vmod_NumLockMask},
+     2,
+     2, map_KEYPAD, NULL,
+     None, lnames_KEYPAD},
     {
-	{     ControlMask,     ControlMask,               0 },
-	2,
-	1,	map_PC_BREAK,	NULL,
-	None,	lnames_PC_BREAK
-    },
+     {ControlMask, ControlMask, 0},
+     2,
+     1, map_PC_BREAK, NULL,
+     None, lnames_PC_BREAK},
     {
-	{               0,               0,    vmod_AltMask },
-	2,
-	1,	map_PC_SYSRQ,	NULL,
-	None,	lnames_PC_SYSRQ
-    },
+     {0, 0, vmod_AltMask},
+     2,
+     1, map_PC_SYSRQ, NULL,
+     None, lnames_PC_SYSRQ},
     {
-	{     ControlMask,     ControlMask,    vmod_AltMask },
-	2,
-	1,	map_CTRL_ALT,	NULL,
-	None,	lnames_CTRL_ALT
-    },
+     {ControlMask, ControlMask, vmod_AltMask},
+     2,
+     1, map_CTRL_ALT, NULL,
+     None, lnames_CTRL_ALT},
     {
-	{       ShiftMask,       ShiftMask, vmod_LevelThreeMask },
-	3,
-	3,	map_THREE_LEVEL,	NULL,
-	None,	lnames_THREE_LEVEL
-    },
+     {ShiftMask, ShiftMask, vmod_LevelThreeMask},
+     3,
+     3, map_THREE_LEVEL, NULL,
+     None, lnames_THREE_LEVEL},
     {
-	{       ShiftMask,       ShiftMask,    vmod_AltMask },
-	2,
-	1,	map_SHIFT_ALT,	NULL,
-	None,	lnames_SHIFT_ALT
-    }
+     {ShiftMask, ShiftMask, vmod_AltMask},
+     2,
+     1, map_SHIFT_ALT, NULL,
+     None, lnames_SHIFT_ALT}
 };
-#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))
 
+#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))
 
 static void
 initTypeNames(DPYTYPE dpy)
 {
-    dflt_types[0].name= GET_ATOM(dpy,"ONE_LEVEL");
-    lnames_ONE_LEVEL[0]=	GET_ATOM(dpy,"Any");
-    dflt_types[1].name= GET_ATOM(dpy,"TWO_LEVEL");
-    lnames_TWO_LEVEL[0]=	GET_ATOM(dpy,"Base");
-    lnames_TWO_LEVEL[1]=	GET_ATOM(dpy,"Shift");
-    dflt_types[2].name= GET_ATOM(dpy,"ALPHABETIC");
-    lnames_ALPHABETIC[0]=	GET_ATOM(dpy,"Base");
-    lnames_ALPHABETIC[1]=	GET_ATOM(dpy,"Caps");
-    dflt_types[3].name= GET_ATOM(dpy,"KEYPAD");
-    lnames_KEYPAD[0]=	GET_ATOM(dpy,"Base");
-    lnames_KEYPAD[1]=	GET_ATOM(dpy,"Number");
-    dflt_types[4].name= GET_ATOM(dpy,"PC_BREAK");
-    lnames_PC_BREAK[0]=	GET_ATOM(dpy,"Base");
-    lnames_PC_BREAK[1]=	GET_ATOM(dpy,"Control");
-    dflt_types[5].name= GET_ATOM(dpy,"PC_SYSRQ");
-    lnames_PC_SYSRQ[0]=	GET_ATOM(dpy,"Base");
-    lnames_PC_SYSRQ[1]=	GET_ATOM(dpy,"Alt");
-    dflt_types[6].name= GET_ATOM(dpy,"CTRL+ALT");
-    lnames_CTRL_ALT[0]=	GET_ATOM(dpy,"Base");
-    lnames_CTRL_ALT[1]=	GET_ATOM(dpy,"Ctrl+Alt");
-    dflt_types[7].name= GET_ATOM(dpy,"THREE_LEVEL");
-    lnames_THREE_LEVEL[0]=	GET_ATOM(dpy,"Base");
-    lnames_THREE_LEVEL[1]=	GET_ATOM(dpy,"Shift");
-    lnames_THREE_LEVEL[2]=	GET_ATOM(dpy,"Level3");
-    dflt_types[8].name= GET_ATOM(dpy,"SHIFT+ALT");
-    lnames_SHIFT_ALT[0]=	GET_ATOM(dpy,"Base");
-    lnames_SHIFT_ALT[1]=	GET_ATOM(dpy,"Shift+Alt");
+    dflt_types[0].name = GET_ATOM(dpy, "ONE_LEVEL");
+    lnames_ONE_LEVEL[0] = GET_ATOM(dpy, "Any");
+    dflt_types[1].name = GET_ATOM(dpy, "TWO_LEVEL");
+    lnames_TWO_LEVEL[0] = GET_ATOM(dpy, "Base");
+    lnames_TWO_LEVEL[1] = GET_ATOM(dpy, "Shift");
+    dflt_types[2].name = GET_ATOM(dpy, "ALPHABETIC");
+    lnames_ALPHABETIC[0] = GET_ATOM(dpy, "Base");
+    lnames_ALPHABETIC[1] = GET_ATOM(dpy, "Caps");
+    dflt_types[3].name = GET_ATOM(dpy, "KEYPAD");
+    lnames_KEYPAD[0] = GET_ATOM(dpy, "Base");
+    lnames_KEYPAD[1] = GET_ATOM(dpy, "Number");
+    dflt_types[4].name = GET_ATOM(dpy, "PC_BREAK");
+    lnames_PC_BREAK[0] = GET_ATOM(dpy, "Base");
+    lnames_PC_BREAK[1] = GET_ATOM(dpy, "Control");
+    dflt_types[5].name = GET_ATOM(dpy, "PC_SYSRQ");
+    lnames_PC_SYSRQ[0] = GET_ATOM(dpy, "Base");
+    lnames_PC_SYSRQ[1] = GET_ATOM(dpy, "Alt");
+    dflt_types[6].name = GET_ATOM(dpy, "CTRL+ALT");
+    lnames_CTRL_ALT[0] = GET_ATOM(dpy, "Base");
+    lnames_CTRL_ALT[1] = GET_ATOM(dpy, "Ctrl+Alt");
+    dflt_types[7].name = GET_ATOM(dpy, "THREE_LEVEL");
+    lnames_THREE_LEVEL[0] = GET_ATOM(dpy, "Base");
+    lnames_THREE_LEVEL[1] = GET_ATOM(dpy, "Shift");
+    lnames_THREE_LEVEL[2] = GET_ATOM(dpy, "Level3");
+    dflt_types[8].name = GET_ATOM(dpy, "SHIFT+ALT");
+    lnames_SHIFT_ALT[0] = GET_ATOM(dpy, "Base");
+    lnames_SHIFT_ALT[1] = GET_ATOM(dpy, "Shift+Alt");
 }
+
 /* compat name is "default" */
-static XkbSymInterpretRec dfltSI[69]= {
-    {    XK_ISO_Level2_Latch, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_Exactly, ShiftMask,
-         255,
-       {      XkbSA_LatchMods, { 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Eisu_Shift, 0x0000,
-         XkbSI_Exactly, LockMask,
-         255,
-       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Eisu_toggle, 0x0000,
-         XkbSI_Exactly, LockMask,
-         255,
-       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Kana_Shift, 0x0000,
-         XkbSI_Exactly, LockMask,
-         255,
-       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Kana_Lock, 0x0000,
-         XkbSI_Exactly, LockMask,
-         255,
-       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Shift_Lock, 0x0000,
-         XkbSI_AnyOf, ShiftMask|LockMask,
-         255,
-       {       XkbSA_LockMods, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Num_Lock, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         0,
-       {       XkbSA_LockMods, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_Alt_L, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         1,
-       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Alt_R, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         1,
-       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Scroll_Lock, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         4,
-       {       XkbSA_LockMods, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Lock, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         255,
-       {        XkbSA_ISOLock, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Level3_Shift, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
-         2,
-       {        XkbSA_SetMods, { 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
-    {    XK_ISO_Level3_Latch, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
-         2,
-       {      XkbSA_LatchMods, { 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
-    {    XK_Mode_switch, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
-         3,
-       {       XkbSA_SetGroup, { 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_1, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_End, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_2, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_Down, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_3, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_Next, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
-    {    XK_KP_4, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Left, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_6, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Right, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_7, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_Home, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_8, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_Up, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_9, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_Prior, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00 } } },
-    {    XK_KP_5, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Begin, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_F1, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Divide, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_F2, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Multiply, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_F3, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Subtract, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Separator, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Add, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_0, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Insert, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Decimal, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_KP_Delete, 0x0001,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Button_Dflt, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Button1, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Button2, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Button3, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_DblClick_Dflt, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_DblClick1, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_DblClick2, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_DblClick3, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Drag_Dflt, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Drag1, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Drag2, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_Drag3, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_EnableKeys, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00 } } },
-    {    XK_Pointer_Accelerate, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00 } } },
-    {    XK_Pointer_DfltBtnNext, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_Pointer_DfltBtnPrev, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {     XkbSA_SetPtrDflt, { 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_AccessX_Enable, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00 } } },
-    {    XK_Terminate_Server, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {      XkbSA_Terminate, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Group_Latch, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
-         3,
-       {     XkbSA_LatchGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Next_Group, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
-         3,
-       {      XkbSA_LockGroup, { 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Prev_Group, 0x0000,
-         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
-         3,
-       {      XkbSA_LockGroup, { 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_First_Group, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {      XkbSA_LockGroup, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    XK_ISO_Last_Group, 0x0000,
-         XkbSI_AnyOfOrNone, 0xff,
-         255,
-       {      XkbSA_LockGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
-    {    NoSymbol, 0x0000,
-         XkbSI_Exactly, LockMask,
-         255,
-       {       XkbSA_LockMods, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
-    {    NoSymbol, 0x0000,
-         XkbSI_AnyOf, 0xff,
-         255,
-       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }
+static XkbSymInterpretRec dfltSI[69] = {
+    {XK_ISO_Level2_Latch, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_Exactly, ShiftMask,
+     255,
+     {XkbSA_LatchMods, {0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Eisu_Shift, 0x0000,
+     XkbSI_Exactly, LockMask,
+     255,
+     {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Eisu_toggle, 0x0000,
+     XkbSI_Exactly, LockMask,
+     255,
+     {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Kana_Shift, 0x0000,
+     XkbSI_Exactly, LockMask,
+     255,
+     {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Kana_Lock, 0x0000,
+     XkbSI_Exactly, LockMask,
+     255,
+     {XkbSA_NoAction, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Shift_Lock, 0x0000,
+     XkbSI_AnyOf, ShiftMask | LockMask,
+     255,
+     {XkbSA_LockMods, {0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Num_Lock, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     0,
+     {XkbSA_LockMods, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_Alt_L, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     1,
+     {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Alt_R, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     1,
+     {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Scroll_Lock, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     4,
+     {XkbSA_LockMods, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Lock, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     255,
+     {XkbSA_ISOLock, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Level3_Shift, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOf, 0xff,
+     2,
+     {XkbSA_SetMods, {0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00}}},
+    {XK_ISO_Level3_Latch, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOf, 0xff,
+     2,
+     {XkbSA_LatchMods, {0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00}}},
+    {XK_Mode_switch, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+     3,
+     {XkbSA_SetGroup, {0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_1, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_End, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_2, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_Down, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_3, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_Next, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00}}},
+    {XK_KP_4, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Left, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_6, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Right, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_7, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_Home, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_8, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_Up, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_9, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_Prior, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_MovePtr, {0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00}}},
+    {XK_KP_5, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Begin, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_F1, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Divide, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_F2, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Multiply, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_F3, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Subtract, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Separator, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Add, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_0, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Insert, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Decimal, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_KP_Delete, 0x0001,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Button_Dflt, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Button1, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Button2, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Button3, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_DblClick_Dflt, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_DblClick1, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_DblClick2, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_DblClick3, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_PtrBtn, {0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Drag_Dflt, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Drag1, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Drag2, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_Drag3, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockPtrBtn, {0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_EnableKeys, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00}}},
+    {XK_Pointer_Accelerate, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00}}},
+    {XK_Pointer_DfltBtnNext, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_Pointer_DfltBtnPrev, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_SetPtrDflt, {0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_AccessX_Enable, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockControls, {0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00}}},
+    {XK_Terminate_Server, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_Terminate, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Group_Latch, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+     3,
+     {XkbSA_LatchGroup, {0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Next_Group, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+     3,
+     {XkbSA_LockGroup, {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Prev_Group, 0x0000,
+     XkbSI_LevelOneOnly | XkbSI_AnyOfOrNone, 0xff,
+     3,
+     {XkbSA_LockGroup, {0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_First_Group, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockGroup, {0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {XK_ISO_Last_Group, 0x0000,
+     XkbSI_AnyOfOrNone, 0xff,
+     255,
+     {XkbSA_LockGroup, {0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}},
+    {NoSymbol, 0x0000,
+     XkbSI_Exactly, LockMask,
+     255,
+     {XkbSA_LockMods, {0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00}}},
+    {NoSymbol, 0x0000,
+     XkbSI_AnyOf, 0xff,
+     255,
+     {XkbSA_SetMods, {0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}
 };
+
 #define num_dfltSI (sizeof(dfltSI)/sizeof(XkbSymInterpretRec))
 
-static XkbCompatMapRec compatMap= {
+static XkbCompatMapRec compatMap = {
     dfltSI,
-    {   /* group compatibility */
-        {            0,            0,            0 },
-        {            0,            0, vmod_AltGrMask },
-        {            0,            0, vmod_AltGrMask },
-        {            0,            0, vmod_AltGrMask }
-    },
+    {                           /* group compatibility */
+     {0, 0, 0},
+     {0, 0, vmod_AltGrMask},
+     {0, 0, vmod_AltGrMask},
+     {0, 0, vmod_AltGrMask}
+     },
     num_dfltSI, num_dfltSI
 };
 
 static void
-initIndicatorNames(DPYTYPE dpy,XkbDescPtr xkb)
+initIndicatorNames(DPYTYPE dpy, XkbDescPtr xkb)
 {
-    xkb->names->indicators[ 0]=	GET_ATOM(dpy,"Caps Lock");
-    xkb->names->indicators[ 1]=	GET_ATOM(dpy,"Num Lock");
-    xkb->names->indicators[ 2]=	GET_ATOM(dpy,"Shift Lock");
-    xkb->names->indicators[ 3]=	GET_ATOM(dpy,"Mouse Keys");
-    xkb->names->indicators[ 4]=	GET_ATOM(dpy,"Scroll Lock");
-    xkb->names->indicators[ 5]=	GET_ATOM(dpy,"Group 2");
+    xkb->names->indicators[0] = GET_ATOM(dpy, "Caps Lock");
+    xkb->names->indicators[1] = GET_ATOM(dpy, "Num Lock");
+    xkb->names->indicators[2] = GET_ATOM(dpy, "Shift Lock");
+    xkb->names->indicators[3] = GET_ATOM(dpy, "Mouse Keys");
+    xkb->names->indicators[4] = GET_ATOM(dpy, "Scroll Lock");
+    xkb->names->indicators[5] = GET_ATOM(dpy, "Group 2");
 }
-#endif /* DEFAULT_H */
+#endif                          /* DEFAULT_H */
diff --git a/xorg-server/xkb/xkbEvents.c b/xorg-server/xkb/xkbEvents.c
index 347f0f8a4..d49e4c1ba 100644
--- a/xorg-server/xkb/xkbEvents.c
+++ b/xorg-server/xkb/xkbEvents.c
@@ -118,7 +118,7 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
                 core_mn.u.mappingNotify.count = num_keys;
             else
                 core_mn.u.mappingNotify.count = clients[i]->maxKC -
-                                                 clients[i]->minKC + 1;
+                    clients[i]->minKC + 1;
 
             WriteEventsToClient(clients[i], 1, &core_mn);
         }
@@ -152,7 +152,7 @@ XkbSendLegacyMapNotify(DeviceIntPtr kbd, CARD16 xkb_event, CARD16 changed,
 /***====================================================================***/
 
 void
-XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
+XkbSendNewKeyboardNotify(DeviceIntPtr kbd, xkbNewKeyboardNotify * pNKN)
 {
     int i;
     Time time = GetTimeInMillis();
@@ -161,7 +161,7 @@ XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
     pNKN->type = XkbEventCode + XkbEventBase;
     pNKN->xkbType = XkbNewKeyboardNotify;
 
-    for (i=1; i<currentMaxClients; i++) {
+    for (i = 1; i < currentMaxClients; i++) {
         if (!clients[i] || clients[i]->clientState != ClientStateRunning)
             continue;
 
@@ -193,19 +193,19 @@ XkbSendNewKeyboardNotify(DeviceIntPtr kbd,xkbNewKeyboardNotify *pNKN)
 /***====================================================================***/
 
 void
-XkbSendStateNotify(DeviceIntPtr kbd,xkbStateNotify *pSN)
+XkbSendStateNotify(DeviceIntPtr kbd, xkbStateNotify * pSN)
 {
-XkbSrvInfoPtr	xkbi;
-XkbStatePtr	state;
-XkbInterestPtr	interest;
-Time 		time;
-register CARD16	changed,bState;
+    XkbSrvInfoPtr xkbi;
+    XkbStatePtr state;
+    XkbInterestPtr interest;
+    Time time;
+    register CARD16 changed, bState;
 
     interest = kbd->xkb_interest;
     if (!interest || !kbd->key || !kbd->key->xkbInfo)
-	return;
+        return;
     xkbi = kbd->key->xkbInfo;
-    state= &xkbi->state;
+    state = &xkbi->state;
 
     pSN->type = XkbEventCode + XkbEventBase;
     pSN->xkbType = XkbStateNotify;
@@ -226,26 +226,26 @@ register CARD16	changed,bState;
     pSN->compatLookupMods = state->compat_lookup_mods;
     pSN->ptrBtnState = state->ptr_buttons;
     changed = pSN->changed;
-    bState= pSN->ptrBtnState;
+    bState = pSN->ptrBtnState;
 
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->stateNotifyMask&changed)) {
-	    pSN->sequenceNumber = interest->client->sequence;
-	    pSN->time = time;
-	    pSN->changed = changed;
-	    pSN->ptrBtnState = bState;
-	    if ( interest->client->swapped ) {
-		swaps(&pSN->sequenceNumber);
-		swapl(&pSN->time);
-		swaps(&pSN->changed);
-		swaps(&pSN->ptrBtnState);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pSN);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->stateNotifyMask & changed)) {
+            pSN->sequenceNumber = interest->client->sequence;
+            pSN->time = time;
+            pSN->changed = changed;
+            pSN->ptrBtnState = bState;
+            if (interest->client->swapped) {
+                swaps(&pSN->sequenceNumber);
+                swapl(&pSN->time);
+                swaps(&pSN->changed);
+                swaps(&pSN->ptrBtnState);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pSN);
+        }
+        interest = interest->next;
     }
     return;
 }
@@ -257,7 +257,7 @@ register CARD16	changed,bState;
  * have explicitly selected for them.  Core and Xi events are handled by
  * XkbSendLegacyMapNotify. */
 void
-XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify *pMN)
+XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify * pMN)
 {
     int i;
     CARD32 time = GetTimeInMillis();
@@ -295,595 +295,599 @@ XkbSendMapNotify(DeviceIntPtr kbd, xkbMapNotify *pMN)
 }
 
 int
-XkbComputeControlsNotify(	DeviceIntPtr	 	kbd,
-				XkbControlsPtr		old,
-				XkbControlsPtr		new,
-				xkbControlsNotify *	pCN,
-				Bool			forceCtrlProc)
+XkbComputeControlsNotify(DeviceIntPtr kbd,
+                         XkbControlsPtr old,
+                         XkbControlsPtr new,
+                         xkbControlsNotify * pCN, Bool forceCtrlProc)
 {
-int		i;
-CARD32 		changedControls;
+    int i;
+    CARD32 changedControls;
 
-    changedControls= 0;
+    changedControls = 0;
 
     if (!kbd || !kbd->kbdfeed)
         return 0;
-    
-    if (old->enabled_ctrls!=new->enabled_ctrls)
-	changedControls|= XkbControlsEnabledMask;
-    if ((old->repeat_delay!=new->repeat_delay)||
-	(old->repeat_interval!=new->repeat_interval))
-	changedControls|= XkbRepeatKeysMask;
+
+    if (old->enabled_ctrls != new->enabled_ctrls)
+        changedControls |= XkbControlsEnabledMask;
+    if ((old->repeat_delay != new->repeat_delay) ||
+        (old->repeat_interval != new->repeat_interval))
+        changedControls |= XkbRepeatKeysMask;
     for (i = 0; i < XkbPerKeyBitArraySize; i++)
-	if (old->per_key_repeat[i] != new->per_key_repeat[i])
-	    changedControls|= XkbPerKeyRepeatMask;
-    if (old->slow_keys_delay!=new->slow_keys_delay)
-	changedControls|= XkbSlowKeysMask;
-    if (old->debounce_delay!=new->debounce_delay)
-	changedControls|= XkbBounceKeysMask;
-    if ((old->mk_delay!=new->mk_delay)||
-	(old->mk_interval!=new->mk_interval)||
-	(old->mk_dflt_btn!=new->mk_dflt_btn))
-	changedControls|= XkbMouseKeysMask;
-    if ((old->mk_time_to_max!=new->mk_time_to_max)||
-	(old->mk_curve!=new->mk_curve)||
-	(old->mk_max_speed!=new->mk_max_speed))
-	changedControls|= XkbMouseKeysAccelMask;
-    if (old->ax_options!=new->ax_options)
-	changedControls|= XkbAccessXKeysMask;
-    if ((old->ax_options^new->ax_options) & XkbAX_SKOptionsMask)
-	changedControls|= XkbStickyKeysMask;
-    if ((old->ax_options^new->ax_options) & XkbAX_FBOptionsMask)
-	changedControls|= XkbAccessXFeedbackMask;
-    if ((old->ax_timeout!=new->ax_timeout)||
-	(old->axt_ctrls_mask!=new->axt_ctrls_mask)||
-	(old->axt_ctrls_values!=new->axt_ctrls_values)||
-	(old->axt_opts_mask!=new->axt_opts_mask)||
-	(old->axt_opts_values!= new->axt_opts_values)) {
-	changedControls|= XkbAccessXTimeoutMask;
+        if (old->per_key_repeat[i] != new->per_key_repeat[i])
+            changedControls |= XkbPerKeyRepeatMask;
+    if (old->slow_keys_delay != new->slow_keys_delay)
+        changedControls |= XkbSlowKeysMask;
+    if (old->debounce_delay != new->debounce_delay)
+        changedControls |= XkbBounceKeysMask;
+    if ((old->mk_delay != new->mk_delay) ||
+        (old->mk_interval != new->mk_interval) ||
+        (old->mk_dflt_btn != new->mk_dflt_btn))
+        changedControls |= XkbMouseKeysMask;
+    if ((old->mk_time_to_max != new->mk_time_to_max) ||
+        (old->mk_curve != new->mk_curve) ||
+        (old->mk_max_speed != new->mk_max_speed))
+        changedControls |= XkbMouseKeysAccelMask;
+    if (old->ax_options != new->ax_options)
+        changedControls |= XkbAccessXKeysMask;
+    if ((old->ax_options ^ new->ax_options) & XkbAX_SKOptionsMask)
+        changedControls |= XkbStickyKeysMask;
+    if ((old->ax_options ^ new->ax_options) & XkbAX_FBOptionsMask)
+        changedControls |= XkbAccessXFeedbackMask;
+    if ((old->ax_timeout != new->ax_timeout) ||
+        (old->axt_ctrls_mask != new->axt_ctrls_mask) ||
+        (old->axt_ctrls_values != new->axt_ctrls_values) ||
+        (old->axt_opts_mask != new->axt_opts_mask) ||
+        (old->axt_opts_values != new->axt_opts_values)) {
+        changedControls |= XkbAccessXTimeoutMask;
     }
-    if ((old->internal.mask!=new->internal.mask)||
-	(old->internal.real_mods!=new->internal.real_mods)||
-	(old->internal.vmods!=new->internal.vmods))
-	changedControls|= XkbInternalModsMask;
-    if ((old->ignore_lock.mask!=new->ignore_lock.mask)||
-	(old->ignore_lock.real_mods!=new->ignore_lock.real_mods)||
-	(old->ignore_lock.vmods!=new->ignore_lock.vmods))
-	changedControls|= XkbIgnoreLockModsMask;
-
-    if (new->enabled_ctrls&XkbRepeatKeysMask)
-	 kbd->kbdfeed->ctrl.autoRepeat=TRUE;
-    else kbd->kbdfeed->ctrl.autoRepeat=FALSE;
+    if ((old->internal.mask != new->internal.mask) ||
+        (old->internal.real_mods != new->internal.real_mods) ||
+        (old->internal.vmods != new->internal.vmods))
+        changedControls |= XkbInternalModsMask;
+    if ((old->ignore_lock.mask != new->ignore_lock.mask) ||
+        (old->ignore_lock.real_mods != new->ignore_lock.real_mods) ||
+        (old->ignore_lock.vmods != new->ignore_lock.vmods))
+        changedControls |= XkbIgnoreLockModsMask;
+
+    if (new->enabled_ctrls & XkbRepeatKeysMask)
+        kbd->kbdfeed->ctrl.autoRepeat = TRUE;
+    else
+        kbd->kbdfeed->ctrl.autoRepeat = FALSE;
 
     if (kbd->kbdfeed && kbd->kbdfeed->CtrlProc &&
-	(changedControls || forceCtrlProc))
-	(*kbd->kbdfeed->CtrlProc)(kbd, &kbd->kbdfeed->ctrl);
+        (changedControls || forceCtrlProc))
+        (*kbd->kbdfeed->CtrlProc) (kbd, &kbd->kbdfeed->ctrl);
 
-    if ((!changedControls)&&(old->num_groups==new->num_groups))
-	return 0;
+    if ((!changedControls) && (old->num_groups == new->num_groups))
+        return 0;
 
     if (!kbd->xkb_interest)
-	return 0;
+        return 0;
 
     pCN->changedControls = changedControls;
     pCN->enabledControls = new->enabled_ctrls;
-    pCN->enabledControlChanges = (new->enabled_ctrls^old->enabled_ctrls);
+    pCN->enabledControlChanges = (new->enabled_ctrls ^ old->enabled_ctrls);
     pCN->numGroups = new->num_groups;
 
     return 1;
 }
 
 void
-XkbSendControlsNotify(DeviceIntPtr kbd,xkbControlsNotify *pCN)
+XkbSendControlsNotify(DeviceIntPtr kbd, xkbControlsNotify * pCN)
 {
-int			initialized;
-CARD32 		 	changedControls, enabledControls, enabledChanges = 0;
-XkbSrvInfoPtr		xkbi;
-XkbInterestPtr		interest;
-Time 		 	time = 0;
+    int initialized;
+    CARD32 changedControls, enabledControls, enabledChanges = 0;
+    XkbSrvInfoPtr xkbi;
+    XkbInterestPtr interest;
+    Time time = 0;
 
     interest = kbd->xkb_interest;
     if (!interest || !kbd->key || !kbd->key->xkbInfo)
-	return;
+        return;
     xkbi = kbd->key->xkbInfo;
- 
+
     initialized = 0;
     enabledControls = xkbi->desc->ctrls->enabled_ctrls;
     changedControls = pCN->changedControls;
-    pCN->numGroups= xkbi->desc->ctrls->num_groups;
+    pCN->numGroups = xkbi->desc->ctrls->num_groups;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->ctrlsNotifyMask&changedControls)) {
-	    if (!initialized) {
-		pCN->type = XkbEventCode + XkbEventBase;
-		pCN->xkbType = XkbControlsNotify;
-		pCN->deviceID = kbd->id;
-		pCN->time = time = GetTimeInMillis();
-		enabledChanges = pCN->enabledControlChanges;
-		initialized= 1;
-	    }
-	    pCN->changedControls = changedControls;
-	    pCN->enabledControls = enabledControls;
-	    pCN->enabledControlChanges = enabledChanges;
-	    pCN->sequenceNumber = interest->client->sequence;
-	    pCN->time = time;
-	    if ( interest->client->swapped ) {
-		swaps(&pCN->sequenceNumber);
-		swapl(&pCN->changedControls);
-		swapl(&pCN->enabledControls);
-		swapl(&pCN->enabledControlChanges);
-		swapl(&pCN->time);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pCN);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->ctrlsNotifyMask & changedControls)) {
+            if (!initialized) {
+                pCN->type = XkbEventCode + XkbEventBase;
+                pCN->xkbType = XkbControlsNotify;
+                pCN->deviceID = kbd->id;
+                pCN->time = time = GetTimeInMillis();
+                enabledChanges = pCN->enabledControlChanges;
+                initialized = 1;
+            }
+            pCN->changedControls = changedControls;
+            pCN->enabledControls = enabledControls;
+            pCN->enabledControlChanges = enabledChanges;
+            pCN->sequenceNumber = interest->client->sequence;
+            pCN->time = time;
+            if (interest->client->swapped) {
+                swaps(&pCN->sequenceNumber);
+                swapl(&pCN->changedControls);
+                swapl(&pCN->enabledControls);
+                swapl(&pCN->enabledControlChanges);
+                swapl(&pCN->time);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pCN);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 static void
-XkbSendIndicatorNotify(DeviceIntPtr kbd,int xkbType,xkbIndicatorNotify *pEv)
+XkbSendIndicatorNotify(DeviceIntPtr kbd, int xkbType, xkbIndicatorNotify * pEv)
 {
-int		initialized;
-XkbInterestPtr	interest;
-Time 		time = 0;
-CARD32		state,changed;
+    int initialized;
+    XkbInterestPtr interest;
+    Time time = 0;
+    CARD32 state, changed;
 
     interest = kbd->xkb_interest;
     if (!interest)
-	return;
- 
+        return;
+
     initialized = 0;
     state = pEv->state;
     changed = pEv->changed;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (((xkbType==XkbIndicatorStateNotify)&&
-				(interest->iStateNotifyMask&changed))||
-	     ((xkbType==XkbIndicatorMapNotify)&&
-	    			(interest->iMapNotifyMask&changed)))) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = xkbType;
-		pEv->deviceID = kbd->id;
-		pEv->time = time = GetTimeInMillis();
-		initialized= 1;
-	    }
-	    pEv->sequenceNumber = interest->client->sequence;
-	    pEv->time = time;
-	    pEv->changed = changed;
-	    pEv->state = state;
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-		swapl(&pEv->changed);
-		swapl(&pEv->state);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (((xkbType == XkbIndicatorStateNotify) &&
+              (interest->iStateNotifyMask & changed)) ||
+             ((xkbType == XkbIndicatorMapNotify) &&
+              (interest->iMapNotifyMask & changed)))) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = xkbType;
+                pEv->deviceID = kbd->id;
+                pEv->time = time = GetTimeInMillis();
+                initialized = 1;
+            }
+            pEv->sequenceNumber = interest->client->sequence;
+            pEv->time = time;
+            pEv->changed = changed;
+            pEv->state = state;
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+                swapl(&pEv->changed);
+                swapl(&pEv->state);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
-
 void
-XkbHandleBell(	BOOL		 force,
-		BOOL		 eventOnly,
-		DeviceIntPtr	 kbd,
-		CARD8		 percent,
-		pointer		 pCtrl,
-		CARD8		 class,
-		Atom		 name,
-		WindowPtr	 pWin,
-		ClientPtr	 pClient)
+XkbHandleBell(BOOL force,
+              BOOL eventOnly,
+              DeviceIntPtr kbd,
+              CARD8 percent,
+              pointer pCtrl,
+              CARD8 class, Atom name, WindowPtr pWin, ClientPtr pClient)
 {
-xkbBellNotify	bn;
-int		initialized;
-XkbSrvInfoPtr	xkbi;
-XkbInterestPtr	interest;
-CARD8		id;
-CARD16		pitch,duration;
-Time 		time = 0;
-XID		winID = 0;
+    xkbBellNotify bn;
+    int initialized;
+    XkbSrvInfoPtr xkbi;
+    XkbInterestPtr interest;
+    CARD8 id;
+    CARD16 pitch, duration;
+    Time time = 0;
+    XID winID = 0;
 
     if (!kbd->key || !kbd->key->xkbInfo)
         return;
 
     xkbi = kbd->key->xkbInfo;
 
-    if ((force||(xkbi->desc->ctrls->enabled_ctrls&XkbAudibleBellMask))&&
-							(!eventOnly)) {
+    if ((force || (xkbi->desc->ctrls->enabled_ctrls & XkbAudibleBellMask)) &&
+        (!eventOnly)) {
         if (kbd->kbdfeed->BellProc)
-            (*kbd->kbdfeed->BellProc)(percent,kbd,(pointer)pCtrl,class);
+            (*kbd->kbdfeed->BellProc) (percent, kbd, (pointer) pCtrl, class);
     }
     interest = kbd->xkb_interest;
-    if ((!interest)||(force))
-	return;
-
-    if ((class==0)||(class==KbdFeedbackClass)) {
-	KeybdCtrl *pKeyCtrl= (KeybdCtrl *)pCtrl;
-	id= pKeyCtrl->id;
-	pitch= pKeyCtrl->bell_pitch;
-	duration= pKeyCtrl->bell_duration;
+    if ((!interest) || (force))
+        return;
+
+    if ((class == 0) || (class == KbdFeedbackClass)) {
+        KeybdCtrl *pKeyCtrl = (KeybdCtrl *) pCtrl;
+
+        id = pKeyCtrl->id;
+        pitch = pKeyCtrl->bell_pitch;
+        duration = pKeyCtrl->bell_duration;
     }
-    else if (class==BellFeedbackClass) {
-	BellCtrl *pBellCtrl= (BellCtrl *)pCtrl;
-	id= pBellCtrl->id;
-	pitch= pBellCtrl->pitch;
-	duration= pBellCtrl->duration;
+    else if (class == BellFeedbackClass) {
+        BellCtrl *pBellCtrl = (BellCtrl *) pCtrl;
+
+        id = pBellCtrl->id;
+        pitch = pBellCtrl->pitch;
+        duration = pBellCtrl->duration;
     }
-    else return;
- 
+    else
+        return;
+
     initialized = 0;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->bellNotifyMask)) {
-	    if (!initialized) {
-		time = GetTimeInMillis();
-		bn.type = XkbEventCode + XkbEventBase;
-		bn.xkbType = XkbBellNotify;
-		bn.deviceID = kbd->id;
-		bn.bellClass = class;
-		bn.bellID = id;
-		bn.percent= percent;
-		bn.eventOnly = (eventOnly!=0);
-		winID= (pWin?pWin->drawable.id:None);
-		initialized= 1;
-	    }
-	    bn.sequenceNumber = interest->client->sequence;
-	    bn.time = time;
-	    bn.pitch = pitch;
-	    bn.duration = duration;
-	    bn.name = name;
-	    bn.window=  winID;
-	    if ( interest->client->swapped ) {
-		swaps(&bn.sequenceNumber);
-		swapl(&bn.time);
-		swaps(&bn.pitch);
-		swaps(&bn.duration);
-		swapl(&bn.name);
-		swapl(&bn.window);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)&bn);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->bellNotifyMask)) {
+            if (!initialized) {
+                time = GetTimeInMillis();
+                bn.type = XkbEventCode + XkbEventBase;
+                bn.xkbType = XkbBellNotify;
+                bn.deviceID = kbd->id;
+                bn.bellClass = class;
+                bn.bellID = id;
+                bn.percent = percent;
+                bn.eventOnly = (eventOnly != 0);
+                winID = (pWin ? pWin->drawable.id : None);
+                initialized = 1;
+            }
+            bn.sequenceNumber = interest->client->sequence;
+            bn.time = time;
+            bn.pitch = pitch;
+            bn.duration = duration;
+            bn.name = name;
+            bn.window = winID;
+            if (interest->client->swapped) {
+                swaps(&bn.sequenceNumber);
+                swapl(&bn.time);
+                swaps(&bn.pitch);
+                swaps(&bn.duration);
+                swapl(&bn.name);
+                swapl(&bn.window);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) &bn);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendAccessXNotify(DeviceIntPtr kbd,xkbAccessXNotify *pEv)
+XkbSendAccessXNotify(DeviceIntPtr kbd, xkbAccessXNotify * pEv)
 {
-int		initialized;
-XkbInterestPtr	interest;
-Time 		time = 0;
-CARD16		sk_delay,db_delay;
+    int initialized;
+    XkbInterestPtr interest;
+    Time time = 0;
+    CARD16 sk_delay, db_delay;
 
     interest = kbd->xkb_interest;
     if (!interest)
-	return;
- 
+        return;
+
     initialized = 0;
-    sk_delay= pEv->slowKeysDelay;
-    db_delay= pEv->debounceDelay;
+    sk_delay = pEv->slowKeysDelay;
+    db_delay = pEv->debounceDelay;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->accessXNotifyMask&(1<<pEv->detail))) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = XkbAccessXNotify;
-		pEv->deviceID = kbd->id;
-		pEv->time = time = GetTimeInMillis();
-		initialized= 1;
-	    }
-	    pEv->sequenceNumber = interest->client->sequence;
-	    pEv->time = time;
-	    pEv->slowKeysDelay = sk_delay;
-	    pEv->debounceDelay = db_delay;
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-		swaps(&pEv->slowKeysDelay);
-		swaps(&pEv->debounceDelay);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->accessXNotifyMask & (1 << pEv->detail))) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = XkbAccessXNotify;
+                pEv->deviceID = kbd->id;
+                pEv->time = time = GetTimeInMillis();
+                initialized = 1;
+            }
+            pEv->sequenceNumber = interest->client->sequence;
+            pEv->time = time;
+            pEv->slowKeysDelay = sk_delay;
+            pEv->debounceDelay = db_delay;
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+                swaps(&pEv->slowKeysDelay);
+                swaps(&pEv->debounceDelay);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendNamesNotify(DeviceIntPtr kbd,xkbNamesNotify *pEv)
+XkbSendNamesNotify(DeviceIntPtr kbd, xkbNamesNotify * pEv)
 {
-int		initialized;
-XkbInterestPtr	interest;
-Time 		time = 0;
-CARD16		changed,changedVirtualMods;
-CARD32		changedIndicators;
+    int initialized;
+    XkbInterestPtr interest;
+    Time time = 0;
+    CARD16 changed, changedVirtualMods;
+    CARD32 changedIndicators;
 
     interest = kbd->xkb_interest;
     if (!interest)
-	return;
- 
+        return;
+
     initialized = 0;
-    changed= pEv->changed;
-    changedIndicators= pEv->changedIndicators;
-    changedVirtualMods= pEv->changedVirtualMods;
+    changed = pEv->changed;
+    changedIndicators = pEv->changedIndicators;
+    changedVirtualMods = pEv->changedVirtualMods;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->namesNotifyMask&pEv->changed)) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = XkbNamesNotify;
-		pEv->deviceID = kbd->id;
-		pEv->time = time = GetTimeInMillis();
-		initialized= 1;
-	    }
-	    pEv->sequenceNumber = interest->client->sequence;
-	    pEv->time = time;
-	    pEv->changed = changed;
-	    pEv->changedIndicators = changedIndicators;
-	    pEv->changedVirtualMods= changedVirtualMods;
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-		swaps(&pEv->changed);
-		swapl(&pEv->changedIndicators);
-		swaps(&pEv->changedVirtualMods);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->namesNotifyMask & pEv->changed)) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = XkbNamesNotify;
+                pEv->deviceID = kbd->id;
+                pEv->time = time = GetTimeInMillis();
+                initialized = 1;
+            }
+            pEv->sequenceNumber = interest->client->sequence;
+            pEv->time = time;
+            pEv->changed = changed;
+            pEv->changedIndicators = changedIndicators;
+            pEv->changedVirtualMods = changedVirtualMods;
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+                swaps(&pEv->changed);
+                swapl(&pEv->changedIndicators);
+                swaps(&pEv->changedVirtualMods);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendCompatMapNotify(DeviceIntPtr kbd,xkbCompatMapNotify *pEv)
+XkbSendCompatMapNotify(DeviceIntPtr kbd, xkbCompatMapNotify * pEv)
 {
-int		initialized;
-XkbInterestPtr	interest;
-Time 		time = 0;
-CARD16		firstSI = 0, nSI = 0, nTotalSI = 0;
+    int initialized;
+    XkbInterestPtr interest;
+    Time time = 0;
+    CARD16 firstSI = 0, nSI = 0, nTotalSI = 0;
 
     interest = kbd->xkb_interest;
     if (!interest)
-	return;
- 
+        return;
+
     initialized = 0;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->compatNotifyMask)) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = XkbCompatMapNotify;
-		pEv->deviceID = kbd->id;
-		pEv->time = time = GetTimeInMillis();
-		firstSI= pEv->firstSI;
-		nSI= pEv->nSI;
-		nTotalSI= pEv->nTotalSI;
-		initialized= 1;
-	    }
-	    pEv->sequenceNumber = interest->client->sequence;
-	    pEv->time = time;
-	    pEv->firstSI = firstSI;
-	    pEv->nSI = nSI;
-	    pEv->nTotalSI = nTotalSI;
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-		swaps(&pEv->firstSI);
-		swaps(&pEv->nSI);
-		swaps(&pEv->nTotalSI);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->compatNotifyMask)) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = XkbCompatMapNotify;
+                pEv->deviceID = kbd->id;
+                pEv->time = time = GetTimeInMillis();
+                firstSI = pEv->firstSI;
+                nSI = pEv->nSI;
+                nTotalSI = pEv->nTotalSI;
+                initialized = 1;
+            }
+            pEv->sequenceNumber = interest->client->sequence;
+            pEv->time = time;
+            pEv->firstSI = firstSI;
+            pEv->nSI = nSI;
+            pEv->nTotalSI = nTotalSI;
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+                swaps(&pEv->firstSI);
+                swaps(&pEv->nSI);
+                swaps(&pEv->nTotalSI);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendActionMessage(DeviceIntPtr kbd,xkbActionMessage *pEv)
+XkbSendActionMessage(DeviceIntPtr kbd, xkbActionMessage * pEv)
 {
-int		 initialized;
-XkbSrvInfoPtr	 xkbi;
-XkbInterestPtr	 interest;
-Time 		 time = 0;
+    int initialized;
+    XkbSrvInfoPtr xkbi;
+    XkbInterestPtr interest;
+    Time time = 0;
 
     interest = kbd->xkb_interest;
     if (!interest || !kbd->key || !kbd->key->xkbInfo)
-	return;
- 
+        return;
+
     xkbi = kbd->key->xkbInfo;
 
     initialized = 0;
-    pEv->mods= xkbi->state.mods;
-    pEv->group= xkbi->state.group;
+    pEv->mods = xkbi->state.mods;
+    pEv->group = xkbi->state.group;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->actionMessageMask)) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = XkbActionMessage;
-		pEv->deviceID = kbd->id;
-		pEv->sequenceNumber = interest->client->sequence;
-		pEv->time = time = GetTimeInMillis();
-		initialized= 1;
-	    }
-	    pEv->sequenceNumber = interest->client->sequence;
-	    pEv->time = time;
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->actionMessageMask)) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = XkbActionMessage;
+                pEv->deviceID = kbd->id;
+                pEv->sequenceNumber = interest->client->sequence;
+                pEv->time = time = GetTimeInMillis();
+                initialized = 1;
+            }
+            pEv->sequenceNumber = interest->client->sequence;
+            pEv->time = time;
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendExtensionDeviceNotify(	DeviceIntPtr 			dev,
-				ClientPtr			client,
-				xkbExtensionDeviceNotify *	pEv)
+XkbSendExtensionDeviceNotify(DeviceIntPtr dev,
+                             ClientPtr client, xkbExtensionDeviceNotify * pEv)
 {
-int		 initialized;
-XkbInterestPtr	 interest;
-Time 		 time = 0;
-CARD32		 defined, state;
-CARD16		 reason;
+    int initialized;
+    XkbInterestPtr interest;
+    Time time = 0;
+    CARD32 defined, state;
+    CARD16 reason;
 
     interest = dev->xkb_interest;
     if (!interest)
-	return;
- 
+        return;
+
     initialized = 0;
-    reason= pEv->reason;
-    defined= pEv->ledsDefined;
-    state= pEv->ledState;
+    reason = pEv->reason;
+    defined = pEv->ledsDefined;
+    state = pEv->ledState;
     while (interest) {
-	if ((!interest->client->clientGone) &&
-	    (interest->client->requestVector != InitialVector) &&
-	    (interest->client->xkbClientFlags&_XkbClientInitialized) &&
-	    (interest->extDevNotifyMask&reason)) {
-	    if (!initialized) {
-		pEv->type = XkbEventCode + XkbEventBase;
-		pEv->xkbType = XkbExtensionDeviceNotify;
-		pEv->deviceID = dev->id;
-		pEv->sequenceNumber = interest->client->sequence;
-		pEv->time = time = GetTimeInMillis();
-		initialized= 1;
-	    }
-	    else {
-		pEv->sequenceNumber = interest->client->sequence;
-		pEv->time = time;
-		pEv->ledsDefined= defined;
-		pEv->ledState= state;
-		pEv->reason= reason;
-		pEv->supported= XkbXI_AllFeaturesMask;
-	    }
-	    if ( interest->client->swapped ) {
-		swaps(&pEv->sequenceNumber);
-		swapl(&pEv->time);
-		swapl(&pEv->ledsDefined);
-		swapl(&pEv->ledState);
-		swaps(&pEv->reason);
-		swaps(&pEv->supported);
-	    }
-	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
-	}
-	interest= interest->next;
+        if ((!interest->client->clientGone) &&
+            (interest->client->requestVector != InitialVector) &&
+            (interest->client->xkbClientFlags & _XkbClientInitialized) &&
+            (interest->extDevNotifyMask & reason)) {
+            if (!initialized) {
+                pEv->type = XkbEventCode + XkbEventBase;
+                pEv->xkbType = XkbExtensionDeviceNotify;
+                pEv->deviceID = dev->id;
+                pEv->sequenceNumber = interest->client->sequence;
+                pEv->time = time = GetTimeInMillis();
+                initialized = 1;
+            }
+            else {
+                pEv->sequenceNumber = interest->client->sequence;
+                pEv->time = time;
+                pEv->ledsDefined = defined;
+                pEv->ledState = state;
+                pEv->reason = reason;
+                pEv->supported = XkbXI_AllFeaturesMask;
+            }
+            if (interest->client->swapped) {
+                swaps(&pEv->sequenceNumber);
+                swapl(&pEv->time);
+                swapl(&pEv->ledsDefined);
+                swapl(&pEv->ledState);
+                swaps(&pEv->reason);
+                swaps(&pEv->supported);
+            }
+            WriteToClient(interest->client, sizeof(xEvent), (char *) pEv);
+        }
+        interest = interest->next;
     }
     return;
 }
 
 void
-XkbSendNotification(	DeviceIntPtr		kbd,
-			XkbChangesPtr		pChanges,
-			XkbEventCausePtr	cause)
+XkbSendNotification(DeviceIntPtr kbd,
+                    XkbChangesPtr pChanges, XkbEventCausePtr cause)
 {
-XkbSrvLedInfoPtr	sli;
+    XkbSrvLedInfoPtr sli;
 
-    sli= NULL;
+    sli = NULL;
     if (pChanges->state_changes) {
-	xkbStateNotify sn;
-	sn.changed= pChanges->state_changes;
-	sn.keycode= cause->kc;
-	sn.eventType= cause->event;
-	sn.requestMajor= cause->mjr;
-	sn.requestMinor= cause->mnr;
-	XkbSendStateNotify(kbd,&sn);
+        xkbStateNotify sn;
+
+        sn.changed = pChanges->state_changes;
+        sn.keycode = cause->kc;
+        sn.eventType = cause->event;
+        sn.requestMajor = cause->mjr;
+        sn.requestMinor = cause->mnr;
+        XkbSendStateNotify(kbd, &sn);
     }
     if (pChanges->map.changed) {
-	xkbMapNotify mn;
-	memset(&mn, 0, sizeof(xkbMapNotify));
-	mn.changed= pChanges->map.changed;
-	mn.firstType= pChanges->map.first_type;
-	mn.nTypes= pChanges->map.num_types;
-	mn.firstKeySym= pChanges->map.first_key_sym;
-	mn.nKeySyms= pChanges->map.num_key_syms;
-	mn.firstKeyAct= pChanges->map.first_key_act;
-	mn.nKeyActs= pChanges->map.num_key_acts;
-	mn.firstKeyBehavior= pChanges->map.first_key_behavior;
-	mn.nKeyBehaviors= pChanges->map.num_key_behaviors;
-	mn.virtualMods= pChanges->map.vmods;
-	mn.firstKeyExplicit= pChanges->map.first_key_explicit;
-	mn.nKeyExplicit= pChanges->map.num_key_explicit;
-	mn.firstModMapKey= pChanges->map.first_modmap_key;
-	mn.nModMapKeys= pChanges->map.num_modmap_keys;
-	mn.firstVModMapKey= pChanges->map.first_vmodmap_key;
-	mn.nVModMapKeys= pChanges->map.num_vmodmap_keys;
-	XkbSendMapNotify(kbd,&mn);
+        xkbMapNotify mn;
+
+        memset(&mn, 0, sizeof(xkbMapNotify));
+        mn.changed = pChanges->map.changed;
+        mn.firstType = pChanges->map.first_type;
+        mn.nTypes = pChanges->map.num_types;
+        mn.firstKeySym = pChanges->map.first_key_sym;
+        mn.nKeySyms = pChanges->map.num_key_syms;
+        mn.firstKeyAct = pChanges->map.first_key_act;
+        mn.nKeyActs = pChanges->map.num_key_acts;
+        mn.firstKeyBehavior = pChanges->map.first_key_behavior;
+        mn.nKeyBehaviors = pChanges->map.num_key_behaviors;
+        mn.virtualMods = pChanges->map.vmods;
+        mn.firstKeyExplicit = pChanges->map.first_key_explicit;
+        mn.nKeyExplicit = pChanges->map.num_key_explicit;
+        mn.firstModMapKey = pChanges->map.first_modmap_key;
+        mn.nModMapKeys = pChanges->map.num_modmap_keys;
+        mn.firstVModMapKey = pChanges->map.first_vmodmap_key;
+        mn.nVModMapKeys = pChanges->map.num_vmodmap_keys;
+        XkbSendMapNotify(kbd, &mn);
     }
-    if ((pChanges->ctrls.changed_ctrls)||
-	(pChanges->ctrls.enabled_ctrls_changes)) {
-	xkbControlsNotify cn;
-	memset(&cn, 0, sizeof(xkbControlsNotify));
-	cn.changedControls= pChanges->ctrls.changed_ctrls;
-	cn.enabledControlChanges= pChanges->ctrls.enabled_ctrls_changes;
-	cn.keycode= cause->kc;
-	cn.eventType= cause->event;
-	cn.requestMajor= cause->mjr;
-	cn.requestMinor= cause->mnr;
-	XkbSendControlsNotify(kbd,&cn);
+    if ((pChanges->ctrls.changed_ctrls) ||
+        (pChanges->ctrls.enabled_ctrls_changes)) {
+        xkbControlsNotify cn;
+
+        memset(&cn, 0, sizeof(xkbControlsNotify));
+        cn.changedControls = pChanges->ctrls.changed_ctrls;
+        cn.enabledControlChanges = pChanges->ctrls.enabled_ctrls_changes;
+        cn.keycode = cause->kc;
+        cn.eventType = cause->event;
+        cn.requestMajor = cause->mjr;
+        cn.requestMinor = cause->mnr;
+        XkbSendControlsNotify(kbd, &cn);
     }
     if (pChanges->indicators.map_changes) {
-	xkbIndicatorNotify in;
-	if (sli==NULL)
-	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
-	memset(&in, 0, sizeof(xkbIndicatorNotify));
-	in.state= sli->effectiveState;
-	in.changed= pChanges->indicators.map_changes;
-	XkbSendIndicatorNotify(kbd,XkbIndicatorMapNotify,&in);
+        xkbIndicatorNotify in;
+
+        if (sli == NULL)
+            sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+        memset(&in, 0, sizeof(xkbIndicatorNotify));
+        in.state = sli->effectiveState;
+        in.changed = pChanges->indicators.map_changes;
+        XkbSendIndicatorNotify(kbd, XkbIndicatorMapNotify, &in);
     }
     if (pChanges->indicators.state_changes) {
-	xkbIndicatorNotify in;
-	if (sli==NULL)
-	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
-	memset(&in, 0, sizeof(xkbIndicatorNotify));
-	in.state= sli->effectiveState;
-	in.changed= pChanges->indicators.state_changes;
-	XkbSendIndicatorNotify(kbd,XkbIndicatorStateNotify,&in);
+        xkbIndicatorNotify in;
+
+        if (sli == NULL)
+            sli = XkbFindSrvLedInfo(kbd, XkbDfltXIClass, XkbDfltXIId, 0);
+        memset(&in, 0, sizeof(xkbIndicatorNotify));
+        in.state = sli->effectiveState;
+        in.changed = pChanges->indicators.state_changes;
+        XkbSendIndicatorNotify(kbd, XkbIndicatorStateNotify, &in);
     }
     if (pChanges->names.changed) {
-	xkbNamesNotify nn;
-	memset(&nn, 0, sizeof(xkbNamesNotify));
-	nn.changed= pChanges->names.changed;
-	nn.firstType= pChanges->names.first_type;
-	nn.nTypes= pChanges->names.num_types;
-	nn.firstLevelName= pChanges->names.first_lvl;
-	nn.nLevelNames= pChanges->names.num_lvls;
-	nn.nRadioGroups= pChanges->names.num_rg;
-	nn.changedVirtualMods= pChanges->names.changed_vmods;
-	nn.changedIndicators= pChanges->names.changed_indicators;
-	XkbSendNamesNotify(kbd,&nn);
+        xkbNamesNotify nn;
+
+        memset(&nn, 0, sizeof(xkbNamesNotify));
+        nn.changed = pChanges->names.changed;
+        nn.firstType = pChanges->names.first_type;
+        nn.nTypes = pChanges->names.num_types;
+        nn.firstLevelName = pChanges->names.first_lvl;
+        nn.nLevelNames = pChanges->names.num_lvls;
+        nn.nRadioGroups = pChanges->names.num_rg;
+        nn.changedVirtualMods = pChanges->names.changed_vmods;
+        nn.changedIndicators = pChanges->names.changed_indicators;
+        XkbSendNamesNotify(kbd, &nn);
     }
-    if ((pChanges->compat.changed_groups)||(pChanges->compat.num_si>0)) {
-	xkbCompatMapNotify cmn;
-	memset(&cmn, 0, sizeof(xkbCompatMapNotify));
-	cmn.changedGroups= pChanges->compat.changed_groups;
-	cmn.firstSI= pChanges->compat.first_si;
-	cmn.nSI= pChanges->compat.num_si;
-	cmn.nTotalSI= kbd->key->xkbInfo->desc->compat->num_si;
-	XkbSendCompatMapNotify(kbd,&cmn);
+    if ((pChanges->compat.changed_groups) || (pChanges->compat.num_si > 0)) {
+        xkbCompatMapNotify cmn;
+
+        memset(&cmn, 0, sizeof(xkbCompatMapNotify));
+        cmn.changedGroups = pChanges->compat.changed_groups;
+        cmn.firstSI = pChanges->compat.first_si;
+        cmn.nSI = pChanges->compat.num_si;
+        cmn.nTotalSI = kbd->key->xkbInfo->desc->compat->num_si;
+        XkbSendCompatMapNotify(kbd, &cmn);
     }
     return;
 }
@@ -891,7 +895,7 @@ XkbSrvLedInfoPtr	sli;
 /***====================================================================***/
 
 void
-XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
+XkbFilterEvents(ClientPtr client, int nEvents, xEvent *xE)
 {
     DeviceIntPtr dev = NULL;
     XkbSrvInfoPtr xkbi;
@@ -909,76 +913,78 @@ XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
     xkbi = dev->key->xkbInfo;
 
     if (client->xkbClientFlags & _XkbClientInitialized) {
-	if ((xkbDebugFlags&0x10)&&
+        if ((xkbDebugFlags & 0x10) &&
             (type == KeyPress || type == KeyRelease ||
              type == DeviceKeyPress || type == DeviceKeyRelease))
-	    DebugF("[xkb] XkbFilterWriteEvents (XKB client): state 0x%04x\n",
+            DebugF("[xkb] XkbFilterWriteEvents (XKB client): state 0x%04x\n",
                    xE[0].u.keyButtonPointer.state);
 
-	if (dev->deviceGrab.grab != NullGrab && dev->deviceGrab.fromPassiveGrab &&
-	    (type == KeyPress || type == KeyRelease ||
-             type == DeviceKeyPress || type == DeviceKeyRelease)) {
-	    unsigned int state, flags;
-
-	    flags = client->xkbClientFlags;
-	    state = xkbi->state.compat_grab_mods;
-	    if (flags & XkbPCF_GrabsUseXKBStateMask) {
-		int group;
-		if (flags & XkbPCF_LookupStateWhenGrabbed) {
-		     group = xkbi->state.group;
-		     state = xkbi->state.lookup_mods;
-		}
-		else {
-		    state = xkbi->state.grab_mods;
-		    group = xkbi->state.base_group + xkbi->state.latched_group;
-		    if (group < 0 || group >= xkbi->desc->ctrls->num_groups)
-			group = XkbAdjustGroup(group, xkbi->desc->ctrls);
-		}
-		state = XkbBuildCoreState(state, group);
-	    }
-	    else if (flags & XkbPCF_LookupStateWhenGrabbed) {
-		state = xkbi->state.compat_lookup_mods;
+        if (dev->deviceGrab.grab != NullGrab && dev->deviceGrab.fromPassiveGrab
+            && (type == KeyPress || type == KeyRelease || type == DeviceKeyPress
+                || type == DeviceKeyRelease)) {
+            unsigned int state, flags;
+
+            flags = client->xkbClientFlags;
+            state = xkbi->state.compat_grab_mods;
+            if (flags & XkbPCF_GrabsUseXKBStateMask) {
+                int group;
+
+                if (flags & XkbPCF_LookupStateWhenGrabbed) {
+                    group = xkbi->state.group;
+                    state = xkbi->state.lookup_mods;
+                }
+                else {
+                    state = xkbi->state.grab_mods;
+                    group = xkbi->state.base_group + xkbi->state.latched_group;
+                    if (group < 0 || group >= xkbi->desc->ctrls->num_groups)
+                        group = XkbAdjustGroup(group, xkbi->desc->ctrls);
+                }
+                state = XkbBuildCoreState(state, group);
+            }
+            else if (flags & XkbPCF_LookupStateWhenGrabbed) {
+                state = xkbi->state.compat_lookup_mods;
             }
-	    xE[0].u.keyButtonPointer.state = state;
-	}
+            xE[0].u.keyButtonPointer.state = state;
+        }
     }
     else {
         if ((xkbDebugFlags & 0x4) &&
-	    (xE[0].u.u.type == KeyPress || xE[0].u.u.type==KeyRelease ||
+            (xE[0].u.u.type == KeyPress || xE[0].u.u.type == KeyRelease ||
              xE[0].u.u.type == DeviceKeyPress ||
              xE[0].u.u.type == DeviceKeyRelease)) {
-	    DebugF("[xkb] XKbFilterWriteEvents (non-XKB):\n");
-	    DebugF("[xkb] event= 0x%04x\n",xE[0].u.keyButtonPointer.state);
-	    DebugF("[xkb] lookup= 0x%02x, grab= 0x%02x\n",
+            DebugF("[xkb] XKbFilterWriteEvents (non-XKB):\n");
+            DebugF("[xkb] event= 0x%04x\n", xE[0].u.keyButtonPointer.state);
+            DebugF("[xkb] lookup= 0x%02x, grab= 0x%02x\n",
                    xkbi->state.lookup_mods, xkbi->state.grab_mods);
-	    DebugF("[xkb] compat lookup= 0x%02x, grab= 0x%02x\n",
-		   xkbi->state.compat_lookup_mods, xkbi->state.compat_grab_mods);
-	}
-	if (type >= KeyPress && type <= MotionNotify) {
-	    CARD16 old, new;
-
-	    old = xE[0].u.keyButtonPointer.state & ~0x1f00;
-	    new = xE[0].u.keyButtonPointer.state & 0x1F00;
-
-	    if (old == XkbStateFieldFromRec(&xkbi->state))
-		new |= xkbi->state.compat_lookup_mods;
-	    else
+            DebugF("[xkb] compat lookup= 0x%02x, grab= 0x%02x\n",
+                   xkbi->state.compat_lookup_mods,
+                   xkbi->state.compat_grab_mods);
+        }
+        if (type >= KeyPress && type <= MotionNotify) {
+            CARD16 old, new;
+
+            old = xE[0].u.keyButtonPointer.state & ~0x1f00;
+            new = xE[0].u.keyButtonPointer.state & 0x1F00;
+
+            if (old == XkbStateFieldFromRec(&xkbi->state))
+                new |= xkbi->state.compat_lookup_mods;
+            else
                 new |= xkbi->state.compat_grab_mods;
-	    xE[0].u.keyButtonPointer.state = new;
-	}
-	else if (type == EnterNotify || type == LeaveNotify) {
-	    xE[0].u.enterLeave.state &= 0x1F00;
-	    xE[0].u.enterLeave.state |= xkbi->state.compat_grab_mods;
-	}
+            xE[0].u.keyButtonPointer.state = new;
+        }
+        else if (type == EnterNotify || type == LeaveNotify) {
+            xE[0].u.enterLeave.state &= 0x1F00;
+            xE[0].u.enterLeave.state |= xkbi->state.compat_grab_mods;
+        }
         else if (type >= DeviceKeyPress && type <= DeviceMotionNotify) {
             CARD16 old, new;
-            deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer*) &xE[0];
+            deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) &xE[0];
 
             old = kbp->state & ~0x1F00;
             new = kbp->state & 0x1F00;
-	    if (old == XkbStateFieldFromRec(&xkbi->state))
-		new |= xkbi->state.compat_lookup_mods;
-	    else
+            if (old == XkbStateFieldFromRec(&xkbi->state))
+                new |= xkbi->state.compat_lookup_mods;
+            else
                 new |= xkbi->state.compat_grab_mods;
             kbp->state = new;
         }
@@ -988,92 +994,93 @@ XkbFilterEvents(ClientPtr client,int nEvents,xEvent *xE)
 /***====================================================================***/
 
 XkbInterestPtr
-XkbFindClientResource(DevicePtr inDev,ClientPtr client)
+XkbFindClientResource(DevicePtr inDev, ClientPtr client)
 {
-DeviceIntPtr	dev = (DeviceIntPtr)inDev;
-XkbInterestPtr	interest;
-
-    if ( dev->xkb_interest ) {
-	interest = dev->xkb_interest;
-	while (interest){
-	    if (interest->client==client) {
-		return interest;
-	    }
-	    interest = interest->next;
-	}
+    DeviceIntPtr dev = (DeviceIntPtr) inDev;
+    XkbInterestPtr interest;
+
+    if (dev->xkb_interest) {
+        interest = dev->xkb_interest;
+        while (interest) {
+            if (interest->client == client) {
+                return interest;
+            }
+            interest = interest->next;
+        }
     }
     return NULL;
 }
 
 XkbInterestPtr
-XkbAddClientResource(DevicePtr inDev,ClientPtr client,XID id)
+XkbAddClientResource(DevicePtr inDev, ClientPtr client, XID id)
 {
-DeviceIntPtr	dev = (DeviceIntPtr)inDev;
-XkbInterestPtr	interest;
+    DeviceIntPtr dev = (DeviceIntPtr) inDev;
+    XkbInterestPtr interest;
 
     interest = dev->xkb_interest;
     while (interest) {
-	if (interest->client==client)
-	    return ((interest->resource==id)?interest:NULL);
-	interest = interest->next;
+        if (interest->client == client)
+            return ((interest->resource == id) ? interest : NULL);
+        interest = interest->next;
     }
     interest = calloc(1, sizeof(XkbInterestRec));
     if (interest) {
-	interest->dev = dev;
-	interest->client = client;
-	interest->resource = id;
-	interest->next = dev->xkb_interest;
-	dev->xkb_interest= interest;
-	return interest;
+        interest->dev = dev;
+        interest->client = client;
+        interest->resource = id;
+        interest->next = dev->xkb_interest;
+        dev->xkb_interest = interest;
+        return interest;
     }
     return NULL;
 }
 
 int
-XkbRemoveResourceClient(DevicePtr inDev,XID id) 
+XkbRemoveResourceClient(DevicePtr inDev, XID id)
 {
-XkbSrvInfoPtr	xkbi;
-DeviceIntPtr	dev = (DeviceIntPtr)inDev;
-XkbInterestPtr	interest;
-Bool		found;
-unsigned long	autoCtrls,autoValues;
-ClientPtr	client = NULL;
+    XkbSrvInfoPtr xkbi;
+    DeviceIntPtr dev = (DeviceIntPtr) inDev;
+    XkbInterestPtr interest;
+    Bool found;
+    unsigned long autoCtrls, autoValues;
+    ClientPtr client = NULL;
 
-    found= FALSE;
+    found = FALSE;
 
     if (!dev->key || !dev->key->xkbInfo)
         return found;
 
-    autoCtrls= autoValues= 0;
-    if ( dev->xkb_interest ) {
-	interest = dev->xkb_interest;
-	if (interest && (interest->resource==id)){
-	    dev->xkb_interest = interest->next;
-	    autoCtrls= interest->autoCtrls;
-	    autoValues= interest->autoCtrlValues;
-	    client= interest->client;
-	    free(interest);
-	    found= TRUE;
-	}
-	while ((!found)&&(interest->next)) {
-	    if (interest->next->resource==id) {
-		XkbInterestPtr	victim = interest->next;
-		interest->next = victim->next;
-		autoCtrls= victim->autoCtrls;
-		autoValues= victim->autoCtrlValues;
-		client= victim->client;
-		free(victim);
-		found= TRUE;
-	    }
-	    interest = interest->next;
-	}
+    autoCtrls = autoValues = 0;
+    if (dev->xkb_interest) {
+        interest = dev->xkb_interest;
+        if (interest && (interest->resource == id)) {
+            dev->xkb_interest = interest->next;
+            autoCtrls = interest->autoCtrls;
+            autoValues = interest->autoCtrlValues;
+            client = interest->client;
+            free(interest);
+            found = TRUE;
+        }
+        while ((!found) && (interest->next)) {
+            if (interest->next->resource == id) {
+                XkbInterestPtr victim = interest->next;
+
+                interest->next = victim->next;
+                autoCtrls = victim->autoCtrls;
+                autoValues = victim->autoCtrlValues;
+                client = victim->client;
+                free(victim);
+                found = TRUE;
+            }
+            interest = interest->next;
+        }
     }
-    if (found && autoCtrls && dev->key && dev->key->xkbInfo ) {
-	XkbEventCauseRec cause;
+    if (found && autoCtrls && dev->key && dev->key->xkbInfo) {
+        XkbEventCauseRec cause;
 
-	xkbi= dev->key->xkbInfo;
-	XkbSetCauseXkbReq(&cause,X_kbPerClientFlags,client);
-	XkbEnableDisableControls(xkbi,autoCtrls,autoValues,NULL,&cause);
+        xkbi = dev->key->xkbInfo;
+        XkbSetCauseXkbReq(&cause, X_kbPerClientFlags, client);
+        XkbEnableDisableControls(xkbi, autoCtrls, autoValues, NULL, &cause);
     }
     return found;
 }
diff --git a/xorg-server/xkb/xkbInit.c b/xorg-server/xkb/xkbInit.c
index 219f414e2..861c2815d 100644
--- a/xorg-server/xkb/xkbInit.c
+++ b/xorg-server/xkb/xkbInit.c
@@ -75,38 +75,37 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #endif
 
 #define	MAX_TOC	16
-typedef struct	_SrvXkmInfo {
-	DeviceIntPtr	dev;
-	FILE *		file;
-	XkbDescPtr	xkb;
+typedef struct _SrvXkmInfo {
+    DeviceIntPtr dev;
+    FILE *file;
+    XkbDescPtr xkb;
 } SrvXkmInfo;
 
-
 /***====================================================================***/
 
 #ifndef XKB_DFLT_RULES_PROP
 #define	XKB_DFLT_RULES_PROP	TRUE
 #endif
 
-const char *		XkbBaseDirectory=	XKB_BASE_DIRECTORY;
-const char *		XkbBinDirectory=	XKB_BIN_DIRECTORY;
-static int	 	XkbWantAccessX=		0;	
+const char *XkbBaseDirectory = XKB_BASE_DIRECTORY;
+const char *XkbBinDirectory = XKB_BIN_DIRECTORY;
+static int XkbWantAccessX = 0;
 
-static char *		XkbRulesDflt=		NULL;
-static char *		XkbModelDflt=		NULL;
-static char *		XkbLayoutDflt=		NULL;
-static char *		XkbVariantDflt=		NULL;
-static char *		XkbOptionsDflt=		NULL;
+static char *XkbRulesDflt = NULL;
+static char *XkbModelDflt = NULL;
+static char *XkbLayoutDflt = NULL;
+static char *XkbVariantDflt = NULL;
+static char *XkbOptionsDflt = NULL;
 
-static char *           XkbRulesUsed=   NULL;
-static char *		XkbModelUsed=	NULL;
-static char *		XkbLayoutUsed=	NULL;
-static char *		XkbVariantUsed=	NULL;
-static char *		XkbOptionsUsed=	NULL;
+static char *XkbRulesUsed = NULL;
+static char *XkbModelUsed = NULL;
+static char *XkbLayoutUsed = NULL;
+static char *XkbVariantUsed = NULL;
+static char *XkbOptionsUsed = NULL;
 
-static XkbDescPtr	xkb_cached_map = NULL;
+static XkbDescPtr xkb_cached_map = NULL;
 
-static Bool		XkbWantRulesProp=	XKB_DFLT_RULES_PROP;
+static Bool XkbWantRulesProp = XKB_DFLT_RULES_PROP;
 
 /***====================================================================***/
 
@@ -115,17 +114,17 @@ static Bool		XkbWantRulesProp=	XKB_DFLT_RULES_PROP;
  * Caller must free the data in rmlvo.
  */
 void
-XkbGetRulesDflts(XkbRMLVOSet *rmlvo)
+XkbGetRulesDflts(XkbRMLVOSet * rmlvo)
 {
-    rmlvo->rules  = strdup(XkbRulesDflt   ? XkbRulesDflt   : XKB_DFLT_RULES);
-    rmlvo->model  = strdup(XkbModelDflt   ? XkbModelDflt   : XKB_DFLT_MODEL);
-    rmlvo->layout = strdup(XkbLayoutDflt  ? XkbLayoutDflt  : XKB_DFLT_LAYOUT);
-    rmlvo->variant= strdup(XkbVariantDflt ? XkbVariantDflt : XKB_DFLT_VARIANT);
-    rmlvo->options= strdup(XkbOptionsDflt ? XkbOptionsDflt : XKB_DFLT_OPTIONS);
+    rmlvo->rules = strdup(XkbRulesDflt ? XkbRulesDflt : XKB_DFLT_RULES);
+    rmlvo->model = strdup(XkbModelDflt ? XkbModelDflt : XKB_DFLT_MODEL);
+    rmlvo->layout = strdup(XkbLayoutDflt ? XkbLayoutDflt : XKB_DFLT_LAYOUT);
+    rmlvo->variant = strdup(XkbVariantDflt ? XkbVariantDflt : XKB_DFLT_VARIANT);
+    rmlvo->options = strdup(XkbOptionsDflt ? XkbOptionsDflt : XKB_DFLT_OPTIONS);
 }
 
 void
-XkbFreeRMLVOSet(XkbRMLVOSet *rmlvo, Bool freeRMLVO)
+XkbFreeRMLVOSet(XkbRMLVOSet * rmlvo, Bool freeRMLVO)
 {
     if (!rmlvo)
         return;
@@ -145,107 +144,108 @@ XkbFreeRMLVOSet(XkbRMLVOSet *rmlvo, Bool freeRMLVO)
 static Bool
 XkbWriteRulesProp(ClientPtr client, pointer closure)
 {
-int 			len,out;
-Atom			name;
-char *			pval;
-
-    len= (XkbRulesUsed?strlen(XkbRulesUsed):0);
-    len+= (XkbModelUsed?strlen(XkbModelUsed):0);
-    len+= (XkbLayoutUsed?strlen(XkbLayoutUsed):0);
-    len+= (XkbVariantUsed?strlen(XkbVariantUsed):0);
-    len+= (XkbOptionsUsed?strlen(XkbOptionsUsed):0);
-    if (len<1)
-	return TRUE;
-
-    len+= 5; /* trailing NULs */
-
-    name= MakeAtom(_XKB_RF_NAMES_PROP_ATOM,strlen(_XKB_RF_NAMES_PROP_ATOM),1);
-    if (name==None) {
-	ErrorF("[xkb] Atom error: %s not created\n",_XKB_RF_NAMES_PROP_ATOM);
-	return TRUE;
-    }
-    pval= (char*) malloc(len);
+    int len, out;
+    Atom name;
+    char *pval;
+
+    len = (XkbRulesUsed ? strlen(XkbRulesUsed) : 0);
+    len += (XkbModelUsed ? strlen(XkbModelUsed) : 0);
+    len += (XkbLayoutUsed ? strlen(XkbLayoutUsed) : 0);
+    len += (XkbVariantUsed ? strlen(XkbVariantUsed) : 0);
+    len += (XkbOptionsUsed ? strlen(XkbOptionsUsed) : 0);
+    if (len < 1)
+        return TRUE;
+
+    len += 5;                   /* trailing NULs */
+
+    name =
+        MakeAtom(_XKB_RF_NAMES_PROP_ATOM, strlen(_XKB_RF_NAMES_PROP_ATOM), 1);
+    if (name == None) {
+        ErrorF("[xkb] Atom error: %s not created\n", _XKB_RF_NAMES_PROP_ATOM);
+        return TRUE;
+    }
+    pval = (char *) malloc(len);
     if (!pval) {
-	ErrorF("[xkb] Allocation error: %s proprerty not created\n",
-						_XKB_RF_NAMES_PROP_ATOM);
-	return TRUE;
+        ErrorF("[xkb] Allocation error: %s proprerty not created\n",
+               _XKB_RF_NAMES_PROP_ATOM);
+        return TRUE;
     }
-    out= 0;
+    out = 0;
     if (XkbRulesUsed) {
-	strcpy(&pval[out],XkbRulesUsed);
-	out+= strlen(XkbRulesUsed);
+        strcpy(&pval[out], XkbRulesUsed);
+        out += strlen(XkbRulesUsed);
     }
-    pval[out++]= '\0';
+    pval[out++] = '\0';
     if (XkbModelUsed) {
-	strcpy(&pval[out],XkbModelUsed);
-	out+= strlen(XkbModelUsed);
-    } 
-    pval[out++]= '\0';
+        strcpy(&pval[out], XkbModelUsed);
+        out += strlen(XkbModelUsed);
+    }
+    pval[out++] = '\0';
     if (XkbLayoutUsed) {
-	strcpy(&pval[out],XkbLayoutUsed);
-	out+= strlen(XkbLayoutUsed);
+        strcpy(&pval[out], XkbLayoutUsed);
+        out += strlen(XkbLayoutUsed);
     }
-    pval[out++]= '\0';
+    pval[out++] = '\0';
     if (XkbVariantUsed) {
-	strcpy(&pval[out],XkbVariantUsed);
-	out+= strlen(XkbVariantUsed);
+        strcpy(&pval[out], XkbVariantUsed);
+        out += strlen(XkbVariantUsed);
     }
-    pval[out++]= '\0';
+    pval[out++] = '\0';
     if (XkbOptionsUsed) {
-	strcpy(&pval[out],XkbOptionsUsed);
-	out+= strlen(XkbOptionsUsed);
+        strcpy(&pval[out], XkbOptionsUsed);
+        out += strlen(XkbOptionsUsed);
     }
-    pval[out++]= '\0';
-    if (out!=len) {
-	ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
-								out,len);
+    pval[out++] = '\0';
+    if (out != len) {
+        ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
+               out, len);
     }
-    dixChangeWindowProperty(serverClient, screenInfo.screens[0]->root, name, XA_STRING, 8,
-			    PropModeReplace, len, pval, TRUE);
+    dixChangeWindowProperty(serverClient, screenInfo.screens[0]->root, name,
+                            XA_STRING, 8, PropModeReplace, len, pval, TRUE);
     free(pval);
     return TRUE;
 }
 
 static void
-XkbSetRulesUsed(XkbRMLVOSet *rmlvo)
+XkbSetRulesUsed(XkbRMLVOSet * rmlvo)
 {
     free(XkbRulesUsed);
-    XkbRulesUsed= (rmlvo->rules?Xstrdup(rmlvo->rules):NULL);
+    XkbRulesUsed = (rmlvo->rules ? Xstrdup(rmlvo->rules) : NULL);
     free(XkbModelUsed);
-    XkbModelUsed= (rmlvo->model?Xstrdup(rmlvo->model):NULL);
+    XkbModelUsed = (rmlvo->model ? Xstrdup(rmlvo->model) : NULL);
     free(XkbLayoutUsed);
-    XkbLayoutUsed= (rmlvo->layout?Xstrdup(rmlvo->layout):NULL);
+    XkbLayoutUsed = (rmlvo->layout ? Xstrdup(rmlvo->layout) : NULL);
     free(XkbVariantUsed);
-    XkbVariantUsed= (rmlvo->variant?Xstrdup(rmlvo->variant):NULL);
+    XkbVariantUsed = (rmlvo->variant ? Xstrdup(rmlvo->variant) : NULL);
     free(XkbOptionsUsed);
-    XkbOptionsUsed= (rmlvo->options?Xstrdup(rmlvo->options):NULL);
+    XkbOptionsUsed = (rmlvo->options ? Xstrdup(rmlvo->options) : NULL);
     if (XkbWantRulesProp)
-	QueueWorkProc(XkbWriteRulesProp,NULL,NULL);
+        QueueWorkProc(XkbWriteRulesProp, NULL, NULL);
     return;
 }
 
 void
-XkbSetRulesDflts(XkbRMLVOSet *rmlvo)
+XkbSetRulesDflts(XkbRMLVOSet * rmlvo)
 {
     if (rmlvo->rules) {
         free(XkbRulesDflt);
-        XkbRulesDflt= Xstrdup(rmlvo->rules);
+        XkbRulesDflt = Xstrdup(rmlvo->rules);
     }
     if (rmlvo->model) {
-	free(XkbModelDflt);
-	XkbModelDflt= Xstrdup(rmlvo->model);
+        free(XkbModelDflt);
+        XkbModelDflt = Xstrdup(rmlvo->model);
     }
     if (rmlvo->layout) {
-	free(XkbLayoutDflt);
-	XkbLayoutDflt= Xstrdup(rmlvo->layout);
+        free(XkbLayoutDflt);
+        XkbLayoutDflt = Xstrdup(rmlvo->layout);
     }
     if (rmlvo->variant) {
-	free(XkbVariantDflt);
-	XkbVariantDflt= Xstrdup(rmlvo->variant);
+        free(XkbVariantDflt);
+        XkbVariantDflt = Xstrdup(rmlvo->variant);
     }
     if (rmlvo->options) {
-	free(XkbOptionsDflt);
-	XkbOptionsDflt= Xstrdup(rmlvo->options);
+        free(XkbOptionsDflt);
+        XkbOptionsDflt = Xstrdup(rmlvo->options);
     }
     return;
 }
@@ -271,7 +271,7 @@ XkbDeleteRulesDflts(void)
 #define DIFFERS(a, b) (strcmp((a) ? (a) : "", (b) ? (b) : "") != 0)
 
 static Bool
-XkbCompareUsedRMLVO(XkbRMLVOSet *rmlvo)
+XkbCompareUsedRMLVO(XkbRMLVOSet * rmlvo)
 {
     if (DIFFERS(rmlvo->rules, XkbRulesUsed) ||
         DIFFERS(rmlvo->model, XkbModelUsed) ||
@@ -295,13 +295,12 @@ XkbInitKeyTypes(XkbDescPtr xkb)
         return TRUE;
 
     initTypeNames(NULL);
-    if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_dflt_types)!=Success)
-	return FALSE;
-    if (XkbCopyKeyTypes(dflt_types,xkb->map->types,num_dflt_types)!=
-    								 Success) {
-	return FALSE;
+    if (XkbAllocClientMap(xkb, XkbKeyTypesMask, num_dflt_types) != Success)
+        return FALSE;
+    if (XkbCopyKeyTypes(dflt_types, xkb->map->types, num_dflt_types) != Success) {
+        return FALSE;
     }
-    xkb->map->size_types= xkb->map->num_types= num_dflt_types;
+    xkb->map->size_types = xkb->map->num_types = num_dflt_types;
     return TRUE;
 }
 
@@ -313,31 +312,32 @@ XkbInitRadioGroups(XkbSrvInfoPtr xkbi)
     return;
 }
 
-
 static Status
 XkbInitCompatStructs(XkbDescPtr xkb)
 {
-register int 	i;
-XkbCompatMapPtr	compat;
+    register int i;
+    XkbCompatMapPtr compat;
 
     if (xkb->defined & XkmCompatMapMask)
         return TRUE;
 
-    if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_dfltSI)!=Success)
-	return BadAlloc;
+    if (XkbAllocCompatMap(xkb, XkbAllCompatMask, num_dfltSI) != Success)
+        return BadAlloc;
     compat = xkb->compat;
     if (compat->sym_interpret) {
-	compat->num_si = num_dfltSI;
-	memcpy((char *)compat->sym_interpret,(char *)dfltSI,sizeof(dfltSI));
-    }
-    for (i=0;i<XkbNumKbdGroups;i++) {
-	compat->groups[i]= compatMap.groups[i];
-	if (compat->groups[i].vmods!=0) {
-	    unsigned mask;
-	    mask= XkbMaskForVMask(xkb,compat->groups[i].vmods);
-	    compat->groups[i].mask= compat->groups[i].real_mods|mask;
-	}
-	else compat->groups[i].mask= compat->groups[i].real_mods;
+        compat->num_si = num_dfltSI;
+        memcpy((char *) compat->sym_interpret, (char *) dfltSI, sizeof(dfltSI));
+    }
+    for (i = 0; i < XkbNumKbdGroups; i++) {
+        compat->groups[i] = compatMap.groups[i];
+        if (compat->groups[i].vmods != 0) {
+            unsigned mask;
+
+            mask = XkbMaskForVMask(xkb, compat->groups[i].vmods);
+            compat->groups[i].mask = compat->groups[i].real_mods | mask;
+        }
+        else
+            compat->groups[i].mask = compat->groups[i].real_mods;
     }
     return Success;
 }
@@ -355,49 +355,56 @@ XkbInitSemantics(XkbDescPtr xkb)
 static Status
 XkbInitNames(XkbSrvInfoPtr xkbi)
 {
-XkbDescPtr	xkb;
-XkbNamesPtr	names;
-Status		rtrn;
-Atom		unknown;
-
-    xkb= xkbi->desc;
-    if ((rtrn=XkbAllocNames(xkb,XkbAllNamesMask,0,0))!=Success)
-	return rtrn;
-    unknown= CREATE_ATOM("unknown");
+    XkbDescPtr xkb;
+    XkbNamesPtr names;
+    Status rtrn;
+    Atom unknown;
+
+    xkb = xkbi->desc;
+    if ((rtrn = XkbAllocNames(xkb, XkbAllNamesMask, 0, 0)) != Success)
+        return rtrn;
+    unknown = CREATE_ATOM("unknown");
     names = xkb->names;
-    if (names->keycodes==None)		names->keycodes= unknown;
-    if (names->geometry==None)		names->geometry= unknown;
-    if (names->phys_symbols==None)	names->phys_symbols= unknown;
-    if (names->symbols==None)		names->symbols= unknown;
-    if (names->types==None)		names->types= unknown;
-    if (names->compat==None)		names->compat= unknown;
+    if (names->keycodes == None)
+        names->keycodes = unknown;
+    if (names->geometry == None)
+        names->geometry = unknown;
+    if (names->phys_symbols == None)
+        names->phys_symbols = unknown;
+    if (names->symbols == None)
+        names->symbols = unknown;
+    if (names->types == None)
+        names->types = unknown;
+    if (names->compat == None)
+        names->compat = unknown;
     if (!(xkb->defined & XkmVirtualModsMask)) {
-        if (names->vmods[vmod_NumLock]==None)
-            names->vmods[vmod_NumLock]= CREATE_ATOM("NumLock");
-        if (names->vmods[vmod_Alt]==None)
-            names->vmods[vmod_Alt]= CREATE_ATOM("Alt");
-        if (names->vmods[vmod_AltGr]==None)
-            names->vmods[vmod_AltGr]= CREATE_ATOM("ModeSwitch");
+        if (names->vmods[vmod_NumLock] == None)
+            names->vmods[vmod_NumLock] = CREATE_ATOM("NumLock");
+        if (names->vmods[vmod_Alt] == None)
+            names->vmods[vmod_Alt] = CREATE_ATOM("Alt");
+        if (names->vmods[vmod_AltGr] == None)
+            names->vmods[vmod_AltGr] = CREATE_ATOM("ModeSwitch");
     }
 
     if (!(xkb->defined & XkmIndicatorsMask) ||
         !(xkb->defined & XkmGeometryMask)) {
-        initIndicatorNames(NULL,xkb);
-        if (names->indicators[LED_CAPS-1]==None)
-            names->indicators[LED_CAPS-1] = CREATE_ATOM("Caps Lock");
-        if (names->indicators[LED_NUM-1]==None)
-            names->indicators[LED_NUM-1] = CREATE_ATOM("Num Lock");
-        if (names->indicators[LED_SCROLL-1]==None)
-            names->indicators[LED_SCROLL-1] = CREATE_ATOM("Scroll Lock");
+        initIndicatorNames(NULL, xkb);
+        if (names->indicators[LED_CAPS - 1] == None)
+            names->indicators[LED_CAPS - 1] = CREATE_ATOM("Caps Lock");
+        if (names->indicators[LED_NUM - 1] == None)
+            names->indicators[LED_NUM - 1] = CREATE_ATOM("Num Lock");
+        if (names->indicators[LED_SCROLL - 1] == None)
+            names->indicators[LED_SCROLL - 1] = CREATE_ATOM("Scroll Lock");
 #ifdef LED_COMPOSE
-        if (names->indicators[LED_COMPOSE-1]==None)
-            names->indicators[LED_COMPOSE-1] = CREATE_ATOM("Compose");
+        if (names->indicators[LED_COMPOSE - 1] == None)
+            names->indicators[LED_COMPOSE - 1] = CREATE_ATOM("Compose");
 #endif
     }
 
-    if (xkb->geom!=NULL)
-	 names->geometry= xkb->geom->name;
-    else names->geometry= unknown;
+    if (xkb->geom != NULL)
+        names->geometry = xkb->geom->name;
+    else
+        names->geometry = unknown;
 
     return Success;
 }
@@ -405,75 +412,74 @@ Atom		unknown;
 static Status
 XkbInitIndicatorMap(XkbSrvInfoPtr xkbi)
 {
-XkbDescPtr		xkb;
-XkbIndicatorPtr		map;
-XkbSrvLedInfoPtr	sli;
+    XkbDescPtr xkb;
+    XkbIndicatorPtr map;
+    XkbSrvLedInfoPtr sli;
 
-    xkb= xkbi->desc;
-    if (XkbAllocIndicatorMaps(xkb)!=Success)
-	return BadAlloc;
+    xkb = xkbi->desc;
+    if (XkbAllocIndicatorMaps(xkb) != Success)
+        return BadAlloc;
 
     if (!(xkb->defined & XkmIndicatorsMask)) {
-        map= xkb->indicators;
+        map = xkb->indicators;
         map->phys_indicators = PHYS_LEDS;
-        map->maps[LED_CAPS-1].flags= XkbIM_NoExplicit;
-        map->maps[LED_CAPS-1].which_mods= XkbIM_UseLocked;
-        map->maps[LED_CAPS-1].mods.mask= LockMask;
-        map->maps[LED_CAPS-1].mods.real_mods= LockMask;
+        map->maps[LED_CAPS - 1].flags = XkbIM_NoExplicit;
+        map->maps[LED_CAPS - 1].which_mods = XkbIM_UseLocked;
+        map->maps[LED_CAPS - 1].mods.mask = LockMask;
+        map->maps[LED_CAPS - 1].mods.real_mods = LockMask;
 
-        map->maps[LED_NUM-1].flags= XkbIM_NoExplicit;
-        map->maps[LED_NUM-1].which_mods= XkbIM_UseLocked;
-        map->maps[LED_NUM-1].mods.mask= 0;
-        map->maps[LED_NUM-1].mods.real_mods= 0;
-        map->maps[LED_NUM-1].mods.vmods= vmod_NumLockMask;
+        map->maps[LED_NUM - 1].flags = XkbIM_NoExplicit;
+        map->maps[LED_NUM - 1].which_mods = XkbIM_UseLocked;
+        map->maps[LED_NUM - 1].mods.mask = 0;
+        map->maps[LED_NUM - 1].mods.real_mods = 0;
+        map->maps[LED_NUM - 1].mods.vmods = vmod_NumLockMask;
 
-        map->maps[LED_SCROLL-1].flags= XkbIM_NoExplicit;
-        map->maps[LED_SCROLL-1].which_mods= XkbIM_UseLocked;
-        map->maps[LED_SCROLL-1].mods.mask= Mod3Mask;
-        map->maps[LED_SCROLL-1].mods.real_mods= Mod3Mask;
+        map->maps[LED_SCROLL - 1].flags = XkbIM_NoExplicit;
+        map->maps[LED_SCROLL - 1].which_mods = XkbIM_UseLocked;
+        map->maps[LED_SCROLL - 1].mods.mask = Mod3Mask;
+        map->maps[LED_SCROLL - 1].mods.real_mods = Mod3Mask;
     }
 
-    sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
+    sli = XkbFindSrvLedInfo(xkbi->device, XkbDfltXIClass, XkbDfltXIId, 0);
     if (sli)
-	XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
+        XkbCheckIndicatorMaps(xkbi->device, sli, XkbAllIndicatorsMask);
 
     return Success;
 }
 
 static Status
-XkbInitControls(DeviceIntPtr pXDev,XkbSrvInfoPtr xkbi)
+XkbInitControls(DeviceIntPtr pXDev, XkbSrvInfoPtr xkbi)
 {
-XkbDescPtr	xkb;
-XkbControlsPtr	ctrls;
+    XkbDescPtr xkb;
+    XkbControlsPtr ctrls;
 
-    xkb= xkbi->desc;
+    xkb = xkbi->desc;
     /* 12/31/94 (ef) -- XXX! Should check if controls loaded from file */
-    if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success)
-	FatalError("Couldn't allocate keyboard controls\n");
-    ctrls= xkb->ctrls;
+    if (XkbAllocControls(xkb, XkbAllControlsMask) != Success)
+        FatalError("Couldn't allocate keyboard controls\n");
+    ctrls = xkb->ctrls;
     if (!(xkb->defined & XkmSymbolsMask))
         ctrls->num_groups = 1;
-    ctrls->groups_wrap = XkbSetGroupInfo(1,XkbWrapIntoRange,0);
+    ctrls->groups_wrap = XkbSetGroupInfo(1, XkbWrapIntoRange, 0);
     ctrls->internal.mask = 0;
     ctrls->internal.real_mods = 0;
     ctrls->internal.vmods = 0;
     ctrls->ignore_lock.mask = 0;
     ctrls->ignore_lock.real_mods = 0;
     ctrls->ignore_lock.vmods = 0;
-    ctrls->enabled_ctrls = XkbAccessXTimeoutMask|XkbRepeatKeysMask|
-				XkbMouseKeysAccelMask|XkbAudibleBellMask|
-				XkbIgnoreGroupLockMask;
+    ctrls->enabled_ctrls = XkbAccessXTimeoutMask | XkbRepeatKeysMask |
+        XkbMouseKeysAccelMask | XkbAudibleBellMask | XkbIgnoreGroupLockMask;
     if (XkbWantAccessX)
-	ctrls->enabled_ctrls|= XkbAccessXKeysMask;
+        ctrls->enabled_ctrls |= XkbAccessXKeysMask;
     AccessXInit(pXDev);
     return Success;
 }
 
 _X_EXPORT Bool
-InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
+InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet * rmlvo,
                          BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func)
 {
-    int	i;
+    int i;
     unsigned int check;
     XkbSrvInfoPtr xkbi;
     XkbDescPtr xkb;
@@ -483,15 +489,13 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
     XkbRMLVOSet rmlvo_dflts = { NULL };
 
     if (dev->key || dev->kbdfeed)
-	return FALSE;
+        return FALSE;
 
-    if (!rmlvo)
-    {
+    if (!rmlvo) {
         rmlvo = &rmlvo_dflts;
         XkbGetRulesDflts(rmlvo);
     }
 
-
     memset(&changes, 0, sizeof(changes));
     XkbSetCauseUnknown(&cause);
 
@@ -585,11 +589,11 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
 
     sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
     if (sli)
-	XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
+        XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
     else
         DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
 
-    dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl);
+    dev->kbdfeed->CtrlProc(dev, &dev->kbdfeed->ctrl);
 
     XkbSetRulesDflts(rmlvo);
     XkbSetRulesUsed(rmlvo);
@@ -597,63 +601,62 @@ InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
 
     return TRUE;
 
-unwind_desc:
+ unwind_desc:
     XkbFreeKeyboard(xkb, 0, TRUE);
-unwind_info:
+ unwind_info:
     free(xkbi);
     dev->key->xkbInfo = NULL;
-unwind_kbdfeed:
+ unwind_kbdfeed:
     free(dev->kbdfeed);
     dev->kbdfeed = NULL;
-unwind_key:
+ unwind_key:
     free(dev->key);
     dev->key = NULL;
     return FALSE;
 }
 
-
 /***====================================================================***/
 
-	/*
-	 * Be very careful about what does and doesn't get freed by this 
-	 * function.  To reduce fragmentation, XkbInitDevice allocates a 
-	 * single huge block per device and divides it up into most of the 
-	 * fixed-size structures for the device.   Don't free anything that
-	 * is part of this larger block.
-	 */
+        /*
+         * Be very careful about what does and doesn't get freed by this 
+         * function.  To reduce fragmentation, XkbInitDevice allocates a 
+         * single huge block per device and divides it up into most of the 
+         * fixed-size structures for the device.   Don't free anything that
+         * is part of this larger block.
+         */
 void
 XkbFreeInfo(XkbSrvInfoPtr xkbi)
 {
     free(xkbi->radioGroups);
     xkbi->radioGroups = NULL;
     if (xkbi->mouseKeyTimer) {
-	TimerFree(xkbi->mouseKeyTimer);
-	xkbi->mouseKeyTimer= NULL;
+        TimerFree(xkbi->mouseKeyTimer);
+        xkbi->mouseKeyTimer = NULL;
     }
     if (xkbi->slowKeysTimer) {
-	TimerFree(xkbi->slowKeysTimer);
-	xkbi->slowKeysTimer= NULL;
+        TimerFree(xkbi->slowKeysTimer);
+        xkbi->slowKeysTimer = NULL;
     }
     if (xkbi->bounceKeysTimer) {
-	TimerFree(xkbi->bounceKeysTimer);
-	xkbi->bounceKeysTimer= NULL;
+        TimerFree(xkbi->bounceKeysTimer);
+        xkbi->bounceKeysTimer = NULL;
     }
     if (xkbi->repeatKeyTimer) {
-	TimerFree(xkbi->repeatKeyTimer);
-	xkbi->repeatKeyTimer= NULL;
+        TimerFree(xkbi->repeatKeyTimer);
+        xkbi->repeatKeyTimer = NULL;
     }
     if (xkbi->krgTimer) {
-	TimerFree(xkbi->krgTimer);
-	xkbi->krgTimer= NULL;
+        TimerFree(xkbi->krgTimer);
+        xkbi->krgTimer = NULL;
     }
-    xkbi->beepType= _BEEP_NONE;
+    xkbi->beepType = _BEEP_NONE;
     if (xkbi->beepTimer) {
-	TimerFree(xkbi->beepTimer);
-	xkbi->beepTimer= NULL;
+        TimerFree(xkbi->beepTimer);
+        xkbi->beepTimer = NULL;
     }
     if (xkbi->desc) {
-	XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,TRUE);
-	xkbi->desc= NULL;
+        XkbFreeKeyboard(xkbi->desc, XkbAllComponentsMask, TRUE);
+        xkbi->desc = NULL;
     }
     free(xkbi);
     return;
@@ -661,88 +664,92 @@ XkbFreeInfo(XkbSrvInfoPtr xkbi)
 
 /***====================================================================***/
 
-extern int	XkbDfltRepeatDelay;
-extern int	XkbDfltRepeatInterval;
+extern int XkbDfltRepeatDelay;
+extern int XkbDfltRepeatInterval;
 
-extern unsigned short	XkbDfltAccessXTimeout;
-extern unsigned int	XkbDfltAccessXTimeoutMask;
-extern unsigned int	XkbDfltAccessXFeedback;
+extern unsigned short XkbDfltAccessXTimeout;
+extern unsigned int XkbDfltAccessXTimeoutMask;
+extern unsigned int XkbDfltAccessXFeedback;
 extern unsigned short	XkbDfltAccessXOptions;
 
 int
-XkbProcessArguments(int argc,char *argv[],int i)
+XkbProcessArguments(int argc, char *argv[], int i)
 {
     if (strncmp(argv[i], "-xkbdir", 7) == 0) {
-	if(++i < argc) {
+        if (++i < argc) {
 #if !defined(WIN32) && !defined(__CYGWIN__)
-	    if (getuid() != geteuid()) {
-		LogMessage(X_WARNING, "-xkbdir is not available for setuid X servers\n");
-		return -1;
-	    } else
+            if (getuid() != geteuid()) {
+                LogMessage(X_WARNING,
+                           "-xkbdir is not available for setuid X servers\n");
+                return -1;
+            }
+            else
 #endif
-	    {
-		if (strlen(argv[i]) < PATH_MAX) {
-		    XkbBaseDirectory= argv[i];
-		    return 2;
-	        } else {
-		    LogMessage(X_ERROR, "-xkbdir pathname too long\n");
-		    return -1;
-		}
-	    }
-	}
-	else {
-	    return -1;
-	}
-    }
-    else if ((strncmp(argv[i],"-accessx",8)==0)||
-                 (strncmp(argv[i],"+accessx",8)==0)) {
-	int j=1;	    
-	if (argv[i][0]=='-')        
-	    XkbWantAccessX= 0;
-	else {
-	    XkbWantAccessX= 1;
-	    
-	    if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
-		XkbDfltAccessXTimeout = atoi(argv[++i]);
-		j++;
-
-		if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
-		    /*
-		     * presumption that the reasonably useful range of
-		     * values fits in 0..MAXINT since SunOS 4 doesn't
-		     * have strtoul.
-		     */
-		    XkbDfltAccessXTimeoutMask=(unsigned int)
-					      strtol(argv[++i],NULL,16); 
-		    j++;
-		}
-		if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
-		    if (argv[++i][0] == '1' ) 
-			XkbDfltAccessXFeedback=XkbAccessXFeedbackMask;
-		    else
-			XkbDfltAccessXFeedback=0;
-		    j++;
-		}
-		if ( ((i+1)<argc) && (isdigit(argv[i+1][0])) ) {
-		    XkbDfltAccessXOptions=(unsigned short)
-					   strtol(argv[++i],NULL,16);
-		    j++;
-		}
-	    }
-	}
-	return j;
-    }
-    if ((strcmp(argv[i], "-ardelay") == 0) ||
-        (strcmp (argv[i], "-ar1") == 0)) {	/* -ardelay int */
-	if (++i >= argc) UseMsg ();
-	XkbDfltRepeatDelay = (long)atoi(argv[i]);
-	return 2;
-    }
-    if ((strcmp(argv[i], "-arinterval") == 0) ||
-        (strcmp (argv[i], "-ar2") == 0)) {	/* -arinterval int */
-	if (++i >= argc) UseMsg ();
-	XkbDfltRepeatInterval = (long)atoi(argv[i]);
-	return 2;
+            {
+                if (strlen(argv[i]) < PATH_MAX) {
+                    XkbBaseDirectory = argv[i];
+                    return 2;
+                }
+                else {
+                    LogMessage(X_ERROR, "-xkbdir pathname too long\n");
+                    return -1;
+                }
+            }
+        }
+        else {
+            return -1;
+        }
+    }
+    else if ((strncmp(argv[i], "-accessx", 8) == 0) ||
+             (strncmp(argv[i], "+accessx", 8) == 0)) {
+        int j = 1;
+
+        if (argv[i][0] == '-')
+            XkbWantAccessX = 0;
+        else {
+            XkbWantAccessX = 1;
+
+            if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+                XkbDfltAccessXTimeout = atoi(argv[++i]);
+                j++;
+
+                if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+                    /*
+                     * presumption that the reasonably useful range of
+                     * values fits in 0..MAXINT since SunOS 4 doesn't
+                     * have strtoul.
+                     */
+                    XkbDfltAccessXTimeoutMask = (unsigned int)
+                        strtol(argv[++i], NULL, 16);
+                    j++;
+                }
+                if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+                    if (argv[++i][0] == '1')
+                        XkbDfltAccessXFeedback = XkbAccessXFeedbackMask;
+                    else
+                        XkbDfltAccessXFeedback = 0;
+                    j++;
+                }
+                if (((i + 1) < argc) && (isdigit(argv[i + 1][0]))) {
+                    XkbDfltAccessXOptions=(unsigned short)
+                        strtol(argv[++i], NULL, 16);
+                    j++;
+                }
+            }
+        }
+        return j;
+    }
+    if ((strcmp(argv[i], "-ardelay") == 0) || (strcmp(argv[i], "-ar1") == 0)) { /* -ardelay int */
+        if (++i >= argc)
+            UseMsg();
+        XkbDfltRepeatDelay = (long) atoi(argv[i]);
+        return 2;
+    }
+    if ((strcmp(argv[i], "-arinterval") == 0) || (strcmp(argv[i], "-ar2") == 0)) {      /* -arinterval int */
+        if (++i >= argc)
+            UseMsg();
+        XkbDfltRepeatInterval = (long) atoi(argv[i]);
+        return 2;
     }
     return 0;
 }
@@ -750,7 +757,8 @@ XkbProcessArguments(int argc,char *argv[],int i)
 void
 XkbUseMsg(void)
 {
-    ErrorF("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
+    ErrorF
+        ("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
     ErrorF("                       enable/disable accessx key sequences\n");
     ErrorF("-ardelay               set XKB autorepeat delay\n");
     ErrorF("-arinterval            set XKB autorepeat interval\n");
diff --git a/xorg-server/xkb/xkbLEDs.c b/xorg-server/xkb/xkbLEDs.c
index 24fcd3b48..e1e22d178 100644
--- a/xorg-server/xkb/xkbLEDs.c
+++ b/xorg-server/xkb/xkbLEDs.c
@@ -42,347 +42,358 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 /***====================================================================***/
 
-	/*
-	 * unsigned
-	 * XkbIndicatorsToUpdate(dev,changed,check_devs_rtrn)
-	 *
-	 * Given a keyboard and a set of state components that have changed,
-	 * this function returns the indicators on the default keyboard 
-	 * feedback that might be affected.   It also reports whether or not 
-	 * any extension devices might be affected in check_devs_rtrn.
-	 */
+        /*
+         * unsigned
+         * XkbIndicatorsToUpdate(dev,changed,check_devs_rtrn)
+         *
+         * Given a keyboard and a set of state components that have changed,
+         * this function returns the indicators on the default keyboard 
+         * feedback that might be affected.   It also reports whether or not 
+         * any extension devices might be affected in check_devs_rtrn.
+         */
 
 unsigned
-XkbIndicatorsToUpdate(	DeviceIntPtr	dev,
-			unsigned long 	state_changes,
-			Bool		enable_changes)
+XkbIndicatorsToUpdate(DeviceIntPtr dev,
+                      unsigned long state_changes, Bool enable_changes)
 {
-register unsigned	update=	0;
-XkbSrvLedInfoPtr	sli;
+    register unsigned update = 0;
+    XkbSrvLedInfoPtr sli;
 
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
 
     if (!sli)
         return update;
 
-    if (state_changes&(XkbModifierStateMask|XkbGroupStateMask))
-	update|= sli->usesEffective;
-    if (state_changes&(XkbModifierBaseMask|XkbGroupBaseMask))
-	update|= sli->usesBase;
-    if (state_changes&(XkbModifierLatchMask|XkbGroupLatchMask))
-	update|= sli->usesLatched;
-    if (state_changes&(XkbModifierLockMask|XkbGroupLockMask))
-	update|= sli->usesLocked;
-    if (state_changes&XkbCompatStateMask)
-	update|= sli->usesCompat;
+    if (state_changes & (XkbModifierStateMask | XkbGroupStateMask))
+        update |= sli->usesEffective;
+    if (state_changes & (XkbModifierBaseMask | XkbGroupBaseMask))
+        update |= sli->usesBase;
+    if (state_changes & (XkbModifierLatchMask | XkbGroupLatchMask))
+        update |= sli->usesLatched;
+    if (state_changes & (XkbModifierLockMask | XkbGroupLockMask))
+        update |= sli->usesLocked;
+    if (state_changes & XkbCompatStateMask)
+        update |= sli->usesCompat;
     if (enable_changes)
-	update|= sli->usesControls;
+        update |= sli->usesControls;
     return update;
 }
 
 /***====================================================================***/
 
-	/*
-	 * Bool
-	 *XkbApplyLEDChangeToKeyboard(xkbi,map,on,change)
-	 *
-	 * Some indicators "drive" the keyboard when their state is explicitly 
-	 * changed, as described in section 9.2.1 of the XKB protocol spec.
-	 * This function updates the state and controls for the keyboard 
-	 * specified by 'xkbi' to reflect any changes that are required 
-	 * when the indicator described by 'map' is turned on or off.  The
-	 * extent of the changes is reported in change, which must be defined.
-	 */
+        /*
+         * Bool
+         *XkbApplyLEDChangeToKeyboard(xkbi,map,on,change)
+         *
+         * Some indicators "drive" the keyboard when their state is explicitly 
+         * changed, as described in section 9.2.1 of the XKB protocol spec.
+         * This function updates the state and controls for the keyboard 
+         * specified by 'xkbi' to reflect any changes that are required 
+         * when the indicator described by 'map' is turned on or off.  The
+         * extent of the changes is reported in change, which must be defined.
+         */
 static Bool
-XkbApplyLEDChangeToKeyboard(	XkbSrvInfoPtr		xkbi,
-				XkbIndicatorMapPtr	map,
-				Bool			on,
-				XkbChangesPtr		change)
+XkbApplyLEDChangeToKeyboard(XkbSrvInfoPtr xkbi,
+                            XkbIndicatorMapPtr map,
+                            Bool on, XkbChangesPtr change)
 {
-Bool		ctrlChange,stateChange;
-XkbStatePtr	state;
+    Bool ctrlChange, stateChange;
+    XkbStatePtr state;
 
-    if ((map->flags&XkbIM_NoExplicit)||((map->flags&XkbIM_LEDDrivesKB)==0))
-	return FALSE;
-    ctrlChange= stateChange= FALSE;
+    if ((map->flags & XkbIM_NoExplicit) ||
+        ((map->flags & XkbIM_LEDDrivesKB) == 0))
+        return FALSE;
+    ctrlChange = stateChange = FALSE;
     if (map->ctrls) {
-	XkbControlsPtr	ctrls= xkbi->desc->ctrls;
-	unsigned 	old;
-
-	old= ctrls->enabled_ctrls;
-	if (on)	ctrls->enabled_ctrls|= map->ctrls;
-	else	ctrls->enabled_ctrls&= ~map->ctrls;
-	if (old!=ctrls->enabled_ctrls) {
-	    change->ctrls.changed_ctrls= XkbControlsEnabledMask;
-	    change->ctrls.enabled_ctrls_changes= old^ctrls->enabled_ctrls;
-	    ctrlChange= TRUE;
-	}
-    }
-    state= &xkbi->state;
-    if ((map->groups)&&((map->which_groups&(~XkbIM_UseBase))!=0)) {
-	register int i;
-	register unsigned bit,match;
-
-	if (on)	match= (map->groups)&XkbAllGroupsMask;
-	else 	match= (~map->groups)&XkbAllGroupsMask;
-	if (map->which_groups&(XkbIM_UseLocked|XkbIM_UseEffective)) {
-	    for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-		if (bit&match)
-		    break;
-	    }
-	    if (map->which_groups&XkbIM_UseLatched)
-		XkbLatchGroup(xkbi->device,0); /* unlatch group */
-	    state->locked_group= i;
-	    stateChange= TRUE;
-	}
-	else if (map->which_groups&(XkbIM_UseLatched|XkbIM_UseEffective)) {
-	    for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-		if (bit&match)
-		    break;
-	    }
-	    state->locked_group= 0;
-	    XkbLatchGroup(xkbi->device,i);
-	    stateChange= TRUE;
-	}
-    }
-    if ((map->mods.mask)&&((map->which_mods&(~XkbIM_UseBase))!=0)) {
-	if (map->which_mods&(XkbIM_UseLocked|XkbIM_UseEffective)) {
-	    register unsigned long old;
-	    old= state->locked_mods;
-	    if (on)	state->locked_mods|= map->mods.mask;
-	    else	state->locked_mods&= ~map->mods.mask;
-	    if (state->locked_mods!=old)
-		stateChange= TRUE;
-	}
-	if (map->which_mods&(XkbIM_UseLatched|XkbIM_UseEffective)) {
-	    register unsigned long newmods;
-	    newmods= state->latched_mods;
-	    if (on)	newmods|=  map->mods.mask;
-	    else	newmods&= ~map->mods.mask;
-	    if (newmods!=state->locked_mods) {
-		newmods&= map->mods.mask;
-		XkbLatchModifiers(xkbi->device,map->mods.mask,newmods);
-		stateChange= TRUE;
-	    }
-	}
+        XkbControlsPtr ctrls = xkbi->desc->ctrls;
+        unsigned old;
+
+        old = ctrls->enabled_ctrls;
+        if (on)
+            ctrls->enabled_ctrls |= map->ctrls;
+        else
+            ctrls->enabled_ctrls &= ~map->ctrls;
+        if (old != ctrls->enabled_ctrls) {
+            change->ctrls.changed_ctrls = XkbControlsEnabledMask;
+            change->ctrls.enabled_ctrls_changes = old ^ ctrls->enabled_ctrls;
+            ctrlChange = TRUE;
+        }
+    }
+    state = &xkbi->state;
+    if ((map->groups) && ((map->which_groups & (~XkbIM_UseBase)) != 0)) {
+        register int i;
+        register unsigned bit, match;
+
+        if (on)
+            match = (map->groups) & XkbAllGroupsMask;
+        else
+            match = (~map->groups) & XkbAllGroupsMask;
+        if (map->which_groups & (XkbIM_UseLocked | XkbIM_UseEffective)) {
+            for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+                if (bit & match)
+                    break;
+            }
+            if (map->which_groups & XkbIM_UseLatched)
+                XkbLatchGroup(xkbi->device, 0); /* unlatch group */
+            state->locked_group = i;
+            stateChange = TRUE;
+        }
+        else if (map->which_groups & (XkbIM_UseLatched | XkbIM_UseEffective)) {
+            for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+                if (bit & match)
+                    break;
+            }
+            state->locked_group = 0;
+            XkbLatchGroup(xkbi->device, i);
+            stateChange = TRUE;
+        }
+    }
+    if ((map->mods.mask) && ((map->which_mods & (~XkbIM_UseBase)) != 0)) {
+        if (map->which_mods & (XkbIM_UseLocked | XkbIM_UseEffective)) {
+            register unsigned long old;
+
+            old = state->locked_mods;
+            if (on)
+                state->locked_mods |= map->mods.mask;
+            else
+                state->locked_mods &= ~map->mods.mask;
+            if (state->locked_mods != old)
+                stateChange = TRUE;
+        }
+        if (map->which_mods & (XkbIM_UseLatched | XkbIM_UseEffective)) {
+            register unsigned long newmods;
+
+            newmods = state->latched_mods;
+            if (on)
+                newmods |= map->mods.mask;
+            else
+                newmods &= ~map->mods.mask;
+            if (newmods != state->locked_mods) {
+                newmods &= map->mods.mask;
+                XkbLatchModifiers(xkbi->device, map->mods.mask, newmods);
+                stateChange = TRUE;
+            }
+        }
     }
     return stateChange || ctrlChange;
 }
-	
-	/*
-	 * Bool
-	 * ComputeAutoState(map,state,ctrls)
-	 *
-	 * This function reports the effect of applying the specified
-	 * indicator map given the specified state and controls, as
-	 * described in section 9.2 of the XKB protocol specification.
-	 */
+
+        /*
+         * Bool
+         * ComputeAutoState(map,state,ctrls)
+         *
+         * This function reports the effect of applying the specified
+         * indicator map given the specified state and controls, as
+         * described in section 9.2 of the XKB protocol specification.
+         */
 
 static Bool
-ComputeAutoState(	XkbIndicatorMapPtr	map,
-			XkbStatePtr 		state,
-			XkbControlsPtr 		ctrls)
+ComputeAutoState(XkbIndicatorMapPtr map,
+                 XkbStatePtr state, XkbControlsPtr ctrls)
 {
-Bool 			on;
-CARD8 			mods,group;
-
-    on= FALSE;
-    mods= group= 0;
-    if (map->which_mods&XkbIM_UseAnyMods) {
-	if (map->which_mods&XkbIM_UseBase)
-	    mods|= state->base_mods;
-	if (map->which_mods&XkbIM_UseLatched)
-	    mods|= state->latched_mods;
-	if (map->which_mods&XkbIM_UseLocked)
-	    mods|= state->locked_mods;
-	if (map->which_mods&XkbIM_UseEffective)
-	    mods|= state->mods;
-	if (map->which_mods&XkbIM_UseCompat)
-	    mods|= state->compat_state;
-	on = ((map->mods.mask&mods)!=0);
-	on = on||((mods==0)&&(map->mods.mask==0)&&(map->mods.vmods==0));
-    }
-    if (map->which_groups&XkbIM_UseAnyGroup) {
-	if (map->which_groups&XkbIM_UseBase)
-	    group|= (1L << state->base_group);
-	if (map->which_groups&XkbIM_UseLatched)
-	    group|= (1L << state->latched_group);
-	if (map->which_groups&XkbIM_UseLocked)
-	    group|= (1L << state->locked_group);
-	if (map->which_groups&XkbIM_UseEffective)
-	    group|= (1L << state->group);
-	on = on||(((map->groups&group)!=0)||(map->groups==0));
+    Bool on;
+    CARD8 mods, group;
+
+    on = FALSE;
+    mods = group = 0;
+    if (map->which_mods & XkbIM_UseAnyMods) {
+        if (map->which_mods & XkbIM_UseBase)
+            mods |= state->base_mods;
+        if (map->which_mods & XkbIM_UseLatched)
+            mods |= state->latched_mods;
+        if (map->which_mods & XkbIM_UseLocked)
+            mods |= state->locked_mods;
+        if (map->which_mods & XkbIM_UseEffective)
+            mods |= state->mods;
+        if (map->which_mods & XkbIM_UseCompat)
+            mods |= state->compat_state;
+        on = ((map->mods.mask & mods) != 0);
+        on = on || ((mods == 0) && (map->mods.mask == 0) &&
+                    (map->mods.vmods == 0));
+    }
+    if (map->which_groups & XkbIM_UseAnyGroup) {
+        if (map->which_groups & XkbIM_UseBase)
+            group |= (1L << state->base_group);
+        if (map->which_groups & XkbIM_UseLatched)
+            group |= (1L << state->latched_group);
+        if (map->which_groups & XkbIM_UseLocked)
+            group |= (1L << state->locked_group);
+        if (map->which_groups & XkbIM_UseEffective)
+            group |= (1L << state->group);
+        on = on || (((map->groups & group) != 0) || (map->groups == 0));
     }
     if (map->ctrls)
-	on = on||(ctrls->enabled_ctrls&map->ctrls);
+        on = on || (ctrls->enabled_ctrls & map->ctrls);
     return on;
 }
 
-
 static void
-XkbUpdateLedAutoState(	DeviceIntPtr			dev,
-			XkbSrvLedInfoPtr		sli,
-			unsigned			maps_to_check,
-			xkbExtensionDeviceNotify *	ed,
-			XkbChangesPtr			changes,
-			XkbEventCausePtr		cause)
+XkbUpdateLedAutoState(DeviceIntPtr dev,
+                      XkbSrvLedInfoPtr sli,
+                      unsigned maps_to_check,
+                      xkbExtensionDeviceNotify * ed,
+                      XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-DeviceIntPtr			kbd;
-XkbStatePtr			state;
-XkbControlsPtr			ctrls;
-XkbChangesRec			my_changes;
-xkbExtensionDeviceNotify	my_ed;
-register unsigned		i,bit,affected;
-register XkbIndicatorMapPtr	map;
-unsigned			oldState;
-
-    if ((maps_to_check==0)||(sli->maps==NULL)||(sli->mapsPresent==0))
-	return;
+    DeviceIntPtr kbd;
+    XkbStatePtr state;
+    XkbControlsPtr ctrls;
+    XkbChangesRec my_changes;
+    xkbExtensionDeviceNotify my_ed;
+    register unsigned i, bit, affected;
+    register XkbIndicatorMapPtr map;
+    unsigned oldState;
+
+    if ((maps_to_check == 0) || (sli->maps == NULL) || (sli->mapsPresent == 0))
+        return;
 
     if (dev->key && dev->key->xkbInfo)
-	 kbd= dev;
-    else kbd= inputInfo.keyboard;
-
-    state= &kbd->key->xkbInfo->state;
-    ctrls= kbd->key->xkbInfo->desc->ctrls;
-    affected= maps_to_check;
-    oldState= sli->effectiveState;
-    sli->autoState&= ~affected;
-    for (i=0,bit=1;(i<XkbNumIndicators)&&(affected);i++,bit<<=1) {
-	if ((affected&bit)==0)
-	    continue;
-	affected&= ~bit;
-	map= &sli->maps[i];
-	if((!(map->flags&XkbIM_NoAutomatic))&&ComputeAutoState(map,state,ctrls))
-	    sli->autoState|= bit;
-    }
-    sli->effectiveState= (sli->autoState|sli->explicitState);
-    affected= sli->effectiveState^oldState;
-    if (affected==0)
-	return;
-
-    if (ed==NULL) {
-	ed= &my_ed;
-	memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
-    }
-    else if ((ed->reason&XkbXI_IndicatorsMask)&&
-	     ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
-    }
-
-    if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) {
-	if (changes==NULL) {
-	    changes= &my_changes;
-	    memset((char *)changes, 0, sizeof(XkbChangesRec));
-	}
-	changes->indicators.state_changes|= affected;
-    }
-
-    ed->reason|=	XkbXI_IndicatorStateMask;
-    ed->ledClass= 	sli->class;
-    ed->ledID=		sli->id;
-    ed->ledsDefined=	sli->namesPresent|sli->mapsPresent;
-    ed->ledState=	sli->effectiveState;
-    ed->unsupported=	0;
-    ed->supported=	XkbXI_AllFeaturesMask;
-
-    if (changes!=&my_changes)	changes= NULL;
-    if (ed!=&my_ed)		ed= NULL;
+        kbd = dev;
+    else
+        kbd = inputInfo.keyboard;
+
+    state = &kbd->key->xkbInfo->state;
+    ctrls = kbd->key->xkbInfo->desc->ctrls;
+    affected = maps_to_check;
+    oldState = sli->effectiveState;
+    sli->autoState &= ~affected;
+    for (i = 0, bit = 1; (i < XkbNumIndicators) && (affected); i++, bit <<= 1) {
+        if ((affected & bit) == 0)
+            continue;
+        affected &= ~bit;
+        map = &sli->maps[i];
+        if ((!(map->flags & XkbIM_NoAutomatic)) &&
+            ComputeAutoState(map, state, ctrls))
+            sli->autoState |= bit;
+    }
+    sli->effectiveState = (sli->autoState | sli->explicitState);
+    affected = sli->effectiveState ^ oldState;
+    if (affected == 0)
+        return;
+
+    if (ed == NULL) {
+        ed = &my_ed;
+        memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+    }
+    else if ((ed->reason & XkbXI_IndicatorsMask) &&
+             ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+    }
+
+    if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+        if (changes == NULL) {
+            changes = &my_changes;
+            memset((char *) changes, 0, sizeof(XkbChangesRec));
+        }
+        changes->indicators.state_changes |= affected;
+    }
+
+    ed->reason |= XkbXI_IndicatorStateMask;
+    ed->ledClass = sli->class;
+    ed->ledID = sli->id;
+    ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+    ed->ledState = sli->effectiveState;
+    ed->unsupported = 0;
+    ed->supported = XkbXI_AllFeaturesMask;
+
+    if (changes != &my_changes)
+        changes = NULL;
+    if (ed != &my_ed)
+        ed = NULL;
     if (changes || ed)
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
     return;
 }
 
 static void
-XkbUpdateAllDeviceIndicators(XkbChangesPtr changes,XkbEventCausePtr cause)
+XkbUpdateAllDeviceIndicators(XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-DeviceIntPtr		edev;
-XkbSrvLedInfoPtr	sli;
-
-    for (edev=inputInfo.devices;edev!=NULL;edev=edev->next) {
-	if (edev->kbdfeed) {
-	    KbdFeedbackPtr	kf;
-	    for (kf=edev->kbdfeed;kf!=NULL;kf=kf->next) {
-		if ((kf->xkb_sli==NULL)||(kf->xkb_sli->maps==NULL))
-		    continue;
-		sli= kf->xkb_sli;
-		XkbUpdateLedAutoState(edev,sli,sli->mapsPresent,NULL,
-								changes,cause);
-			
-	    }
-	}
-	if (edev->leds) {
-	    LedFeedbackPtr	lf;
-	    for (lf=edev->leds;lf!=NULL;lf=lf->next) {
-		if ((lf->xkb_sli==NULL)||(lf->xkb_sli->maps==NULL))
-		    continue;
-		sli= lf->xkb_sli;
-		XkbUpdateLedAutoState(edev,sli,sli->mapsPresent,NULL,
-								changes,cause);
-			
-	    }
-	}
+    DeviceIntPtr edev;
+    XkbSrvLedInfoPtr sli;
+
+    for (edev = inputInfo.devices; edev != NULL; edev = edev->next) {
+        if (edev->kbdfeed) {
+            KbdFeedbackPtr kf;
+
+            for (kf = edev->kbdfeed; kf != NULL; kf = kf->next) {
+                if ((kf->xkb_sli == NULL) || (kf->xkb_sli->maps == NULL))
+                    continue;
+                sli = kf->xkb_sli;
+                XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL,
+                                      changes, cause);
+
+            }
+        }
+        if (edev->leds) {
+            LedFeedbackPtr lf;
+
+            for (lf = edev->leds; lf != NULL; lf = lf->next) {
+                if ((lf->xkb_sli == NULL) || (lf->xkb_sli->maps == NULL))
+                    continue;
+                sli = lf->xkb_sli;
+                XkbUpdateLedAutoState(edev, sli, sli->mapsPresent, NULL,
+                                      changes, cause);
+
+            }
+        }
     }
     return;
 }
 
-
 /***====================================================================***/
 
-	/*
-	 * void
-	 * XkbSetIndicators(dev,affect,values,cause)
-	 *
-	 * Attempts to change the indicators specified in 'affect' to the
-	 * states specified in 'values' for the default keyboard feedback
-	 * on the keyboard specified by 'dev.'   Attempts to change indicator
-	 * state might be ignored or have no affect, depending on the XKB
-	 * indicator map for any affected indicators, as described in section
-	 * 9.2 of the XKB protocol specification.
-	 *
-	 * If 'changes' is non-NULL, this function notes any changes to the
-	 * keyboard state, controls, or indicator state that result from this
-	 * attempted change.   If 'changes' is NULL, this function generates
-	 * XKB events to report any such changes to interested clients.
-	 *
-	 * If 'cause' is non-NULL, it specifies the reason for the change, 
-	 * as reported in some XKB events.   If it is NULL, this function 
-	 * assumes that the change is the result of a core protocol 
-	 * ChangeKeyboardMapping request.
-	 */
+        /*
+         * void
+         * XkbSetIndicators(dev,affect,values,cause)
+         *
+         * Attempts to change the indicators specified in 'affect' to the
+         * states specified in 'values' for the default keyboard feedback
+         * on the keyboard specified by 'dev.'   Attempts to change indicator
+         * state might be ignored or have no affect, depending on the XKB
+         * indicator map for any affected indicators, as described in section
+         * 9.2 of the XKB protocol specification.
+         *
+         * If 'changes' is non-NULL, this function notes any changes to the
+         * keyboard state, controls, or indicator state that result from this
+         * attempted change.   If 'changes' is NULL, this function generates
+         * XKB events to report any such changes to interested clients.
+         *
+         * If 'cause' is non-NULL, it specifies the reason for the change, 
+         * as reported in some XKB events.   If it is NULL, this function 
+         * assumes that the change is the result of a core protocol 
+         * ChangeKeyboardMapping request.
+         */
 
 void
-XkbSetIndicators(	DeviceIntPtr		dev,
-			CARD32			affect,
-			CARD32			values,
-			XkbEventCausePtr	cause)
+XkbSetIndicators(DeviceIntPtr dev,
+                 CARD32 affect, CARD32 values, XkbEventCausePtr cause)
 {
-XkbSrvLedInfoPtr		sli;
-XkbChangesRec			changes;
-xkbExtensionDeviceNotify	ed;
-unsigned 			side_affected;
-
-    memset((char *)&changes, 0, sizeof(XkbChangesRec));
-    memset((char *)&ed, 0, sizeof(xkbExtensionDeviceNotify));
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    sli->explicitState&= ~affect;
-    sli->explicitState|= (affect&values);
-    XkbApplyLedStateChanges(dev,sli,affect,&ed,&changes,cause);
-
-    side_affected= 0;
-    if (changes.state_changes!=0)
-	side_affected|= XkbIndicatorsToUpdate(dev,changes.state_changes,FALSE);
+    XkbSrvLedInfoPtr sli;
+    XkbChangesRec changes;
+    xkbExtensionDeviceNotify ed;
+    unsigned side_affected;
+
+    memset((char *) &changes, 0, sizeof(XkbChangesRec));
+    memset((char *) &ed, 0, sizeof(xkbExtensionDeviceNotify));
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    sli->explicitState &= ~affect;
+    sli->explicitState |= (affect & values);
+    XkbApplyLedStateChanges(dev, sli, affect, &ed, &changes, cause);
+
+    side_affected = 0;
+    if (changes.state_changes != 0)
+        side_affected |=
+            XkbIndicatorsToUpdate(dev, changes.state_changes, FALSE);
     if (changes.ctrls.enabled_ctrls_changes)
-	side_affected|= sli->usesControls;
+        side_affected |= sli->usesControls;
 
     if (side_affected) {
-	XkbUpdateLedAutoState(dev,sli,side_affected,&ed,&changes,cause);
-	affect|= side_affected;
+        XkbUpdateLedAutoState(dev, sli, side_affected, &ed, &changes, cause);
+        affect |= side_affected;
     }
     if (changes.state_changes || changes.ctrls.enabled_ctrls_changes)
-	XkbUpdateAllDeviceIndicators(NULL,cause);
+        XkbUpdateAllDeviceIndicators(NULL, cause);
 
-    XkbFlushLedEvents(dev,dev,sli,&ed,&changes,cause);
+    XkbFlushLedEvents(dev, dev, sli, &ed, &changes, cause);
     return;
 }
 
@@ -390,36 +401,35 @@ unsigned 			side_affected;
 
 /***====================================================================***/
 
-	/*
-	 * void
-	 * XkbUpdateIndicators(dev,update,check_edevs,changes,cause)
-	 *
-	 * Applies the indicator maps for any indicators specified in
-	 * 'update' from the default keyboard feedback on the device
-	 * specified by 'dev.' 
-	 *
-	 * If 'changes' is NULL, this function generates and XKB events
-	 * required to report the necessary changes, otherwise it simply
-	 * notes the indicators with changed state.
-	 *
-	 * If 'check_edevs' is TRUE, this function also checks the indicator
-	 * maps for any open extension devices that have them, and updates
-	 * the state of any extension device indicators as necessary.
-	 */
+        /*
+         * void
+         * XkbUpdateIndicators(dev,update,check_edevs,changes,cause)
+         *
+         * Applies the indicator maps for any indicators specified in
+         * 'update' from the default keyboard feedback on the device
+         * specified by 'dev.' 
+         *
+         * If 'changes' is NULL, this function generates and XKB events
+         * required to report the necessary changes, otherwise it simply
+         * notes the indicators with changed state.
+         *
+         * If 'check_edevs' is TRUE, this function also checks the indicator
+         * maps for any open extension devices that have them, and updates
+         * the state of any extension device indicators as necessary.
+         */
 
 void
-XkbUpdateIndicators(	DeviceIntPtr		dev,
-			register CARD32		update,
-			Bool			check_edevs,
-			XkbChangesPtr		changes,
-			XkbEventCausePtr	cause)
+XkbUpdateIndicators(DeviceIntPtr dev,
+                    register CARD32 update,
+                    Bool check_edevs,
+                    XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-XkbSrvLedInfoPtr	sli;
+    XkbSrvLedInfoPtr sli;
 
-    sli= XkbFindSrvLedInfo(dev,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateLedAutoState(dev,sli,update,NULL,changes,cause);
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateLedAutoState(dev, sli, update, NULL, changes, cause);
     if (check_edevs)
-	XkbUpdateAllDeviceIndicators(changes,cause);
+        XkbUpdateAllDeviceIndicators(changes, cause);
     return;
 }
 
@@ -427,192 +437,196 @@ XkbSrvLedInfoPtr	sli;
 
 /***====================================================================***/
 
-	/*
-	 * void
-	 * XkbCheckIndicatorMaps(dev,sli,which)
-	 *
-	 * Updates the 'indicator accelerators' for the indicators specified
-	 * by 'which' in the feedback specified by 'sli.' The indicator 
-	 * accelerators are internal to the server and are used to simplify 
-	 * and speed up the process of figuring out which indicators might 
-	 * be affected by a particular change in keyboard state or controls.
-	 */
+        /*
+         * void
+         * XkbCheckIndicatorMaps(dev,sli,which)
+         *
+         * Updates the 'indicator accelerators' for the indicators specified
+         * by 'which' in the feedback specified by 'sli.' The indicator 
+         * accelerators are internal to the server and are used to simplify 
+         * and speed up the process of figuring out which indicators might 
+         * be affected by a particular change in keyboard state or controls.
+         */
 
 void
-XkbCheckIndicatorMaps(DeviceIntPtr dev,XkbSrvLedInfoPtr sli,unsigned which)
+XkbCheckIndicatorMaps(DeviceIntPtr dev, XkbSrvLedInfoPtr sli, unsigned which)
 {
-register unsigned	i,bit;
-XkbIndicatorMapPtr	map;
-XkbDescPtr		xkb;
+    register unsigned i, bit;
+    XkbIndicatorMapPtr map;
+    XkbDescPtr xkb;
 
-    if ((sli->flags&XkbSLI_HasOwnState)==0)
+    if ((sli->flags & XkbSLI_HasOwnState) == 0)
         return;
 
-    sli->usesBase&=	 ~which;
-    sli->usesLatched&=	 ~which;
-    sli->usesLocked&=	 ~which;
-    sli->usesEffective&= ~which;
-    sli->usesCompat&=	 ~which;
-    sli->usesControls&=	 ~which;
-    sli->mapsPresent&=	 ~which;
-
-    xkb= dev->key->xkbInfo->desc;
-    for (i=0,bit=1,map=sli->maps;i<XkbNumIndicators;i++,bit<<=1,map++) {
-	if (which&bit) {
-	    CARD8		what;
-
-	    if (!map || !XkbIM_InUse(map))
-		continue;
-	    sli->mapsPresent|= bit;
-
-	    what= (map->which_mods|map->which_groups);
-	    if (what&XkbIM_UseBase)
-		 sli->usesBase|= bit;
-	    if (what&XkbIM_UseLatched)
-		 sli->usesLatched|= bit;
-	    if (what&XkbIM_UseLocked)
-		 sli->usesLocked|= bit;
-	    if (what&XkbIM_UseEffective)
-		 sli->usesEffective|= bit;
-	    if (what&XkbIM_UseCompat)
-		 sli->usesCompat|= bit;
-	    if (map->ctrls)
-		 sli->usesControls|= bit;
-
-	    map->mods.mask= map->mods.real_mods;
-	    if (map->mods.vmods!=0) {
-		map->mods.mask|= XkbMaskForVMask(xkb,map->mods.vmods);
-	    }
-	}
-    }
-    sli->usedComponents= 0;
+    sli->usesBase &= ~which;
+    sli->usesLatched &= ~which;
+    sli->usesLocked &= ~which;
+    sli->usesEffective &= ~which;
+    sli->usesCompat &= ~which;
+    sli->usesControls &= ~which;
+    sli->mapsPresent &= ~which;
+
+    xkb = dev->key->xkbInfo->desc;
+    for (i = 0, bit = 1, map = sli->maps; i < XkbNumIndicators;
+         i++, bit <<= 1, map++) {
+        if (which & bit) {
+            CARD8 what;
+
+            if (!map || !XkbIM_InUse(map))
+                continue;
+            sli->mapsPresent |= bit;
+
+            what = (map->which_mods | map->which_groups);
+            if (what & XkbIM_UseBase)
+                sli->usesBase |= bit;
+            if (what & XkbIM_UseLatched)
+                sli->usesLatched |= bit;
+            if (what & XkbIM_UseLocked)
+                sli->usesLocked |= bit;
+            if (what & XkbIM_UseEffective)
+                sli->usesEffective |= bit;
+            if (what & XkbIM_UseCompat)
+                sli->usesCompat |= bit;
+            if (map->ctrls)
+                sli->usesControls |= bit;
+
+            map->mods.mask = map->mods.real_mods;
+            if (map->mods.vmods != 0) {
+                map->mods.mask |= XkbMaskForVMask(xkb, map->mods.vmods);
+            }
+        }
+    }
+    sli->usedComponents = 0;
     if (sli->usesBase)
-	sli->usedComponents|= XkbModifierBaseMask|XkbGroupBaseMask;
+        sli->usedComponents |= XkbModifierBaseMask | XkbGroupBaseMask;
     if (sli->usesLatched)
-	sli->usedComponents|= XkbModifierLatchMask|XkbGroupLatchMask;
+        sli->usedComponents |= XkbModifierLatchMask | XkbGroupLatchMask;
     if (sli->usesLocked)
-	sli->usedComponents|= XkbModifierLockMask|XkbGroupLockMask;
+        sli->usedComponents |= XkbModifierLockMask | XkbGroupLockMask;
     if (sli->usesEffective)
-	sli->usedComponents|= XkbModifierStateMask|XkbGroupStateMask;
+        sli->usedComponents |= XkbModifierStateMask | XkbGroupStateMask;
     if (sli->usesCompat)
-	sli->usedComponents|= XkbCompatStateMask;
+        sli->usedComponents |= XkbCompatStateMask;
     return;
 }
 
 /***====================================================================***/
 
-	/*
-	 * XkbSrvLedInfoPtr
-	 * XkbAllocSrvLedInfo(dev,kf,lf,needed_parts)
-	 *
-	 * Allocates an XkbSrvLedInfoPtr for the feedback specified by either
-	 * 'kf' or 'lf' on the keyboard specified by 'dev.'
-	 *
-	 * If 'needed_parts' is non-zero, this function makes sure that any
-	 * of the parts speicified therein are allocated.
-	 */
+        /*
+         * XkbSrvLedInfoPtr
+         * XkbAllocSrvLedInfo(dev,kf,lf,needed_parts)
+         *
+         * Allocates an XkbSrvLedInfoPtr for the feedback specified by either
+         * 'kf' or 'lf' on the keyboard specified by 'dev.'
+         *
+         * If 'needed_parts' is non-zero, this function makes sure that any
+         * of the parts speicified therein are allocated.
+         */
 XkbSrvLedInfoPtr
-XkbAllocSrvLedInfo(	DeviceIntPtr		dev,
-			KbdFeedbackPtr		kf,
-			LedFeedbackPtr		lf,
-			unsigned		needed_parts)
+XkbAllocSrvLedInfo(DeviceIntPtr dev,
+                   KbdFeedbackPtr kf, LedFeedbackPtr lf, unsigned needed_parts)
 {
-XkbSrvLedInfoPtr	sli;
-Bool			checkAccel;
-Bool			checkNames;
-
-    sli= NULL;
-    checkAccel= checkNames= FALSE;
-    if ((kf!=NULL)&&(kf->xkb_sli==NULL)) {
-	kf->xkb_sli= sli= calloc(1, sizeof(XkbSrvLedInfoRec));
-	if (sli==NULL)
-	    return NULL; /* ALLOCATION ERROR */
-	if (dev->key && dev->key->xkbInfo)
-	     sli->flags= XkbSLI_HasOwnState;
-	else sli->flags= 0;	
-	sli->class=	KbdFeedbackClass;
-	sli->id=	kf->ctrl.id;
-	sli->fb.kf=	kf;
-
-	sli->autoState=		0;
-	sli->explicitState=	kf->ctrl.leds;
-	sli->effectiveState=	kf->ctrl.leds;
-
-	if ((kf==dev->kbdfeed) && (dev->key) && (dev->key->xkbInfo)) {
-	    XkbDescPtr	xkb;
-	    xkb= dev->key->xkbInfo->desc;
-	    sli->flags|= 		XkbSLI_IsDefault;
-	    sli->physIndicators=	xkb->indicators->phys_indicators;
-	    sli->names=			xkb->names->indicators;
-	    sli->maps=			xkb->indicators->maps;
-	    checkNames= checkAccel=	TRUE;
-	}
-	else {
-	    sli->physIndicators=	XkbAllIndicatorsMask;
-	    sli->names=			NULL;
-	    sli->maps=			NULL;
-	}
-    }
-    else if ((kf!=NULL)&&((kf->xkb_sli->flags&XkbSLI_IsDefault)!=0)) {
-	XkbDescPtr	xkb;
-	xkb= dev->key->xkbInfo->desc;
-	sli= kf->xkb_sli;
-	sli->physIndicators=	xkb->indicators->phys_indicators;
-	if (xkb->names->indicators!=sli->names) {
-	    checkNames= TRUE;
-	    sli->names= xkb->names->indicators;
-	}
-	if (xkb->indicators->maps!=sli->maps) {
-	    checkAccel= TRUE;
-	    sli->maps= xkb->indicators->maps;
-	}
-    }
-    else if ((lf!=NULL)&&(lf->xkb_sli==NULL)) {
-	lf->xkb_sli= sli= calloc(1, sizeof(XkbSrvLedInfoRec));
-	if (sli==NULL)
-	    return NULL; /* ALLOCATION ERROR */
-	if (dev->key && dev->key->xkbInfo)
-	     sli->flags= XkbSLI_HasOwnState;
-	else sli->flags= 0;	
-	sli->class=	LedFeedbackClass;
-	sli->id=	lf->ctrl.id;
-	sli->fb.lf=	lf;
-
-	sli->physIndicators=	lf->ctrl.led_mask;
-	sli->autoState=		0;
-	sli->explicitState=	lf->ctrl.led_values;
-	sli->effectiveState=	lf->ctrl.led_values;
-	sli->maps=		NULL;
-	sli->names=		NULL;
+    XkbSrvLedInfoPtr sli;
+    Bool checkAccel;
+    Bool checkNames;
+
+    sli = NULL;
+    checkAccel = checkNames = FALSE;
+    if ((kf != NULL) && (kf->xkb_sli == NULL)) {
+        kf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec));
+        if (sli == NULL)
+            return NULL;        /* ALLOCATION ERROR */
+        if (dev->key && dev->key->xkbInfo)
+            sli->flags = XkbSLI_HasOwnState;
+        else
+            sli->flags = 0;
+        sli->class = KbdFeedbackClass;
+        sli->id = kf->ctrl.id;
+        sli->fb.kf = kf;
+
+        sli->autoState = 0;
+        sli->explicitState = kf->ctrl.leds;
+        sli->effectiveState = kf->ctrl.leds;
+
+        if ((kf == dev->kbdfeed) && (dev->key) && (dev->key->xkbInfo)) {
+            XkbDescPtr xkb;
+
+            xkb = dev->key->xkbInfo->desc;
+            sli->flags |= XkbSLI_IsDefault;
+            sli->physIndicators = xkb->indicators->phys_indicators;
+            sli->names = xkb->names->indicators;
+            sli->maps = xkb->indicators->maps;
+            checkNames = checkAccel = TRUE;
+        }
+        else {
+            sli->physIndicators = XkbAllIndicatorsMask;
+            sli->names = NULL;
+            sli->maps = NULL;
+        }
+    }
+    else if ((kf != NULL) && ((kf->xkb_sli->flags & XkbSLI_IsDefault) != 0)) {
+        XkbDescPtr xkb;
+
+        xkb = dev->key->xkbInfo->desc;
+        sli = kf->xkb_sli;
+        sli->physIndicators = xkb->indicators->phys_indicators;
+        if (xkb->names->indicators != sli->names) {
+            checkNames = TRUE;
+            sli->names = xkb->names->indicators;
+        }
+        if (xkb->indicators->maps != sli->maps) {
+            checkAccel = TRUE;
+            sli->maps = xkb->indicators->maps;
+        }
+    }
+    else if ((lf != NULL) && (lf->xkb_sli == NULL)) {
+        lf->xkb_sli = sli = calloc(1, sizeof(XkbSrvLedInfoRec));
+        if (sli == NULL)
+            return NULL;        /* ALLOCATION ERROR */
+        if (dev->key && dev->key->xkbInfo)
+            sli->flags = XkbSLI_HasOwnState;
+        else
+            sli->flags = 0;
+        sli->class = LedFeedbackClass;
+        sli->id = lf->ctrl.id;
+        sli->fb.lf = lf;
+
+        sli->physIndicators = lf->ctrl.led_mask;
+        sli->autoState = 0;
+        sli->explicitState = lf->ctrl.led_values;
+        sli->effectiveState = lf->ctrl.led_values;
+        sli->maps = NULL;
+        sli->names = NULL;
     }
     else
-	return NULL;
-    if ((sli->names==NULL)&&(needed_parts&XkbXI_IndicatorNamesMask))
-	sli->names= calloc(XkbNumIndicators, sizeof(Atom));
-    if ((sli->maps==NULL)&&(needed_parts&XkbXI_IndicatorMapsMask))
-	sli->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+        return NULL;
+    if ((sli->names == NULL) && (needed_parts & XkbXI_IndicatorNamesMask))
+        sli->names = calloc(XkbNumIndicators, sizeof(Atom));
+    if ((sli->maps == NULL) && (needed_parts & XkbXI_IndicatorMapsMask))
+        sli->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
     if (checkNames) {
-	register unsigned i,bit;
-	sli->namesPresent=	0;
-	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
-	    if (sli->names[i]!=None)
-		sli->namesPresent|= bit;
-	}
+        register unsigned i, bit;
+
+        sli->namesPresent = 0;
+        for (i = 0, bit = 1; i < XkbNumIndicators; i++, bit <<= 1) {
+            if (sli->names[i] != None)
+                sli->namesPresent |= bit;
+        }
     }
     if (checkAccel)
-	 XkbCheckIndicatorMaps(dev,sli,XkbAllIndicatorsMask);
+        XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
     return sli;
 }
 
 void
 XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli)
 {
-    if ((sli->flags&XkbSLI_IsDefault)==0) {
-	free(sli->maps);
-	free(sli->names);
+    if ((sli->flags & XkbSLI_IsDefault) == 0) {
+        free(sli->maps);
+        free(sli->names);
     }
-    sli->maps= NULL;
-    sli->names= NULL;
+    sli->maps = NULL;
+    sli->names = NULL;
     free(sli);
     return;
 }
@@ -626,100 +640,103 @@ XkbFreeSrvLedInfo(XkbSrvLedInfoPtr sli)
  * XkbFreeSrvLedInfo.
  */
 XkbSrvLedInfoPtr
-XkbCopySrvLedInfo(	DeviceIntPtr		from,
-			XkbSrvLedInfoPtr	src,
-			KbdFeedbackPtr		kf,
-			LedFeedbackPtr		lf)
+XkbCopySrvLedInfo(DeviceIntPtr from,
+                  XkbSrvLedInfoPtr src, KbdFeedbackPtr kf, LedFeedbackPtr lf)
 {
     XkbSrvLedInfoPtr sli_new = NULL;
 
     if (!src)
-	goto finish;
+        goto finish;
 
-    sli_new = calloc(1, sizeof( XkbSrvLedInfoRec));
+    sli_new = calloc(1, sizeof(XkbSrvLedInfoRec));
     if (!sli_new)
-	goto finish;
+        goto finish;
 
     memcpy(sli_new, src, sizeof(XkbSrvLedInfoRec));
     if (sli_new->class == KbdFeedbackClass)
-	sli_new->fb.kf = kf;
+        sli_new->fb.kf = kf;
     else
-	sli_new->fb.lf = lf;
+        sli_new->fb.lf = lf;
 
     if (!(sli_new->flags & XkbSLI_IsDefault)) {
-	sli_new->names= calloc(XkbNumIndicators, sizeof(Atom));
-	sli_new->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
-    } /* else sli_new->names/maps is pointing to
-	dev->key->xkbInfo->desc->names->indicators;
-	dev->key->xkbInfo->desc->names->indicators; */
+        sli_new->names = calloc(XkbNumIndicators, sizeof(Atom));
+        sli_new->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+    }                           /* else sli_new->names/maps is pointing to
+                                   dev->key->xkbInfo->desc->names->indicators;
+                                   dev->key->xkbInfo->desc->names->indicators; */
 
-finish:
+ finish:
     return sli_new;
 }
 
 /***====================================================================***/
 
-	/*
-	 * XkbSrvLedInfoPtr
-	 * XkbFindSrvLedInfo(dev,class,id,needed_parts)
-	 *
-	 * Finds the XkbSrvLedInfoPtr for the specified 'class' and 'id'
-	 * on the device specified by 'dev.'   If the class and id specify
-	 * a valid device feedback, this function returns the existing 
-	 * feedback or allocates a new one.
-	 *
-	 */
+        /*
+         * XkbSrvLedInfoPtr
+         * XkbFindSrvLedInfo(dev,class,id,needed_parts)
+         *
+         * Finds the XkbSrvLedInfoPtr for the specified 'class' and 'id'
+         * on the device specified by 'dev.'   If the class and id specify
+         * a valid device feedback, this function returns the existing 
+         * feedback or allocates a new one.
+         *
+         */
 
 XkbSrvLedInfoPtr
-XkbFindSrvLedInfo(	DeviceIntPtr		dev,
-			unsigned		class,
-			unsigned		id,
-			unsigned		needed_parts)
+XkbFindSrvLedInfo(DeviceIntPtr dev,
+                  unsigned class, unsigned id, unsigned needed_parts)
 {
-XkbSrvLedInfoPtr	sli;
+    XkbSrvLedInfoPtr sli;
 
     /* optimization to check for most common case */
-    if (((class==XkbDfltXIClass)&&(id==XkbDfltXIId))&&(dev->kbdfeed)) {
-	if (dev->kbdfeed->xkb_sli==NULL) {
-	    dev->kbdfeed->xkb_sli=
-		XkbAllocSrvLedInfo(dev,dev->kbdfeed,NULL,needed_parts);
-	}
-	return dev->kbdfeed->xkb_sli;
-    }
-
-    sli= NULL;
-    if (class==XkbDfltXIClass) {
-	if (dev->kbdfeed)	class= KbdFeedbackClass;
-	else if (dev->leds)	class= LedFeedbackClass;
-	else 			return NULL;
-    }
-    if (class==KbdFeedbackClass) {
-	KbdFeedbackPtr	kf;
-	for (kf=dev->kbdfeed;kf!=NULL;kf=kf->next) {
-	    if ((id==XkbDfltXIId)||(id==kf->ctrl.id)) {
-		if (kf->xkb_sli==NULL)
-		    kf->xkb_sli= XkbAllocSrvLedInfo(dev,kf,NULL,needed_parts);
-		sli= kf->xkb_sli;
-		break;
-	    }	
-	}
-    }
-    else if (class==LedFeedbackClass) {
-	LedFeedbackPtr	lf;
-	for (lf=dev->leds;lf!=NULL;lf=lf->next) {
-	    if ((id==XkbDfltXIId)||(id==lf->ctrl.id)) {
-		if (lf->xkb_sli==NULL)
-		    lf->xkb_sli= XkbAllocSrvLedInfo(dev,NULL,lf,needed_parts);
-		sli= lf->xkb_sli;
-		break;
-	    }	
-	}
+    if (((class == XkbDfltXIClass) && (id == XkbDfltXIId)) && (dev->kbdfeed)) {
+        if (dev->kbdfeed->xkb_sli == NULL) {
+            dev->kbdfeed->xkb_sli =
+                XkbAllocSrvLedInfo(dev, dev->kbdfeed, NULL, needed_parts);
+        }
+        return dev->kbdfeed->xkb_sli;
+    }
+
+    sli = NULL;
+    if (class == XkbDfltXIClass) {
+        if (dev->kbdfeed)
+            class = KbdFeedbackClass;
+        else if (dev->leds)
+            class = LedFeedbackClass;
+        else
+            return NULL;
+    }
+    if (class == KbdFeedbackClass) {
+        KbdFeedbackPtr kf;
+
+        for (kf = dev->kbdfeed; kf != NULL; kf = kf->next) {
+            if ((id == XkbDfltXIId) || (id == kf->ctrl.id)) {
+                if (kf->xkb_sli == NULL)
+                    kf->xkb_sli =
+                        XkbAllocSrvLedInfo(dev, kf, NULL, needed_parts);
+                sli = kf->xkb_sli;
+                break;
+            }
+        }
+    }
+    else if (class == LedFeedbackClass) {
+        LedFeedbackPtr lf;
+
+        for (lf = dev->leds; lf != NULL; lf = lf->next) {
+            if ((id == XkbDfltXIId) || (id == lf->ctrl.id)) {
+                if (lf->xkb_sli == NULL)
+                    lf->xkb_sli =
+                        XkbAllocSrvLedInfo(dev, NULL, lf, needed_parts);
+                sli = lf->xkb_sli;
+                break;
+            }
+        }
     }
     if (sli) {
-	if ((sli->names==NULL)&&(needed_parts&XkbXI_IndicatorNamesMask))
-	    sli->names= calloc(XkbNumIndicators, sizeof(Atom));
-	if ((sli->maps==NULL)&&(needed_parts&XkbXI_IndicatorMapsMask))
-	    sli->maps= calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
+        if ((sli->names == NULL) && (needed_parts & XkbXI_IndicatorNamesMask))
+            sli->names = calloc(XkbNumIndicators, sizeof(Atom));
+        if ((sli->maps == NULL) && (needed_parts & XkbXI_IndicatorMapsMask))
+            sli->maps = calloc(XkbNumIndicators, sizeof(XkbIndicatorMapRec));
     }
     return sli;
 }
@@ -727,34 +744,34 @@ XkbSrvLedInfoPtr	sli;
 /***====================================================================***/
 
 void
-XkbFlushLedEvents(	DeviceIntPtr			dev,
-			DeviceIntPtr			kbd,
-			XkbSrvLedInfoPtr		sli,
-			xkbExtensionDeviceNotify *	ed,
-			XkbChangesPtr			changes,
-			XkbEventCausePtr		cause)
+XkbFlushLedEvents(DeviceIntPtr dev,
+                  DeviceIntPtr kbd,
+                  XkbSrvLedInfoPtr sli,
+                  xkbExtensionDeviceNotify * ed,
+                  XkbChangesPtr changes, XkbEventCausePtr cause)
 {
     if (changes) {
-	if (changes->indicators.state_changes)
-	    XkbDDXUpdateDeviceIndicators(dev,sli,sli->effectiveState);
-	XkbSendNotification(kbd,changes,cause);
-	memset((char *)changes, 0, sizeof(XkbChangesRec));
-
-	if (XkbAX_NeedFeedback(kbd->key->xkbInfo->desc->ctrls, XkbAX_IndicatorFBMask)) {
-		if (sli->effectiveState)
-			/* it appears that the which parameter is not used */
-			XkbDDXAccessXBeep(dev, _BEEP_LED_ON, XkbAccessXFeedbackMask);
-		else
-			XkbDDXAccessXBeep(dev, _BEEP_LED_OFF, XkbAccessXFeedbackMask);
-	}
+        if (changes->indicators.state_changes)
+            XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState);
+        XkbSendNotification(kbd, changes, cause);
+        memset((char *) changes, 0, sizeof(XkbChangesRec));
+
+        if (XkbAX_NeedFeedback
+            (kbd->key->xkbInfo->desc->ctrls, XkbAX_IndicatorFBMask)) {
+            if (sli->effectiveState)
+                /* it appears that the which parameter is not used */
+                XkbDDXAccessXBeep(dev, _BEEP_LED_ON, XkbAccessXFeedbackMask);
+            else
+                XkbDDXAccessXBeep(dev, _BEEP_LED_OFF, XkbAccessXFeedbackMask);
+        }
     }
     if (ed) {
-	if (ed->reason) {
-	    if ((dev!=kbd)&&(ed->reason&XkbXI_IndicatorStateMask))
-		XkbDDXUpdateDeviceIndicators(dev,sli,sli->effectiveState);
-	    XkbSendExtensionDeviceNotify(dev,cause->client,ed);
-	}
-	memset((char *)ed, 0, sizeof(XkbExtensionDeviceNotify));
+        if (ed->reason) {
+            if ((dev != kbd) && (ed->reason & XkbXI_IndicatorStateMask))
+                XkbDDXUpdateDeviceIndicators(dev, sli, sli->effectiveState);
+            XkbSendExtensionDeviceNotify(dev, cause->client, ed);
+        }
+        memset((char *) ed, 0, sizeof(XkbExtensionDeviceNotify));
     }
     return;
 }
@@ -762,219 +779,227 @@ XkbFlushLedEvents(	DeviceIntPtr			dev,
 /***====================================================================***/
 
 void
-XkbApplyLedNameChanges(	DeviceIntPtr 			dev,
-			XkbSrvLedInfoPtr		sli,
-			unsigned			changed_names,
-			xkbExtensionDeviceNotify *	ed,
-			XkbChangesPtr			changes,
-			XkbEventCausePtr		cause)
+XkbApplyLedNameChanges(DeviceIntPtr dev,
+                       XkbSrvLedInfoPtr sli,
+                       unsigned changed_names,
+                       xkbExtensionDeviceNotify * ed,
+                       XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-DeviceIntPtr			kbd;
-XkbChangesRec			my_changes;
-xkbExtensionDeviceNotify	my_ed;
+    DeviceIntPtr kbd;
+    XkbChangesRec my_changes;
+    xkbExtensionDeviceNotify my_ed;
 
-    if (changed_names==0)
-	return;
+    if (changed_names == 0)
+        return;
     if (dev->key && dev->key->xkbInfo)
-	 kbd= dev;
-    else kbd= inputInfo.keyboard;
-
-    if (ed==NULL) {
-	ed= &my_ed;
-	memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
-    }
-    else if ((ed->reason&XkbXI_IndicatorsMask)&&
-	     ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
-    }
-
-    if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) { 
-	if (changes==NULL) {
-	   changes= &my_changes;
-	   memset((char *)changes, 0, sizeof(XkbChangesRec));
-	}
-	changes->names.changed|= XkbIndicatorNamesMask;
-	changes->names.changed_indicators|= changed_names;
-    }
-
-    ed->reason|=	XkbXI_IndicatorNamesMask;
-    ed->ledClass= 	sli->class;
-    ed->ledID=		sli->id;
-    ed->ledsDefined=	sli->namesPresent|sli->mapsPresent;
-    ed->ledState=	sli->effectiveState;
-    ed->unsupported=	0;
-    ed->supported=	XkbXI_AllFeaturesMask;
-
-    if (changes!=&my_changes)	changes= NULL;
-    if (ed!=&my_ed)		ed= NULL;
+        kbd = dev;
+    else
+        kbd = inputInfo.keyboard;
+
+    if (ed == NULL) {
+        ed = &my_ed;
+        memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+    }
+    else if ((ed->reason & XkbXI_IndicatorsMask) &&
+             ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+    }
+
+    if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+        if (changes == NULL) {
+            changes = &my_changes;
+            memset((char *) changes, 0, sizeof(XkbChangesRec));
+        }
+        changes->names.changed |= XkbIndicatorNamesMask;
+        changes->names.changed_indicators |= changed_names;
+    }
+
+    ed->reason |= XkbXI_IndicatorNamesMask;
+    ed->ledClass = sli->class;
+    ed->ledID = sli->id;
+    ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+    ed->ledState = sli->effectiveState;
+    ed->unsupported = 0;
+    ed->supported = XkbXI_AllFeaturesMask;
+
+    if (changes != &my_changes)
+        changes = NULL;
+    if (ed != &my_ed)
+        ed = NULL;
     if (changes || ed)
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
     return;
 }
+
 /***====================================================================***/
 
-	/*
-	 * void
-	 * XkbApplyLedMapChanges(dev,sli,changed_maps,changes,cause)
-	 *
-	 * Handles all of the secondary effects of the changes to the
-	 * feedback specified by 'sli' on the device specified by 'dev.'
-	 * 
-	 * If 'changed_maps' specifies any indicators, this function generates
-	 * XkbExtensionDeviceNotify events and possibly IndicatorMapNotify
-	 * events to report the changes, and recalculates the effective
-	 * state of each indicator with a changed map.  If any indicators
-	 * change state, the server generates XkbExtensionDeviceNotify and
-	 * XkbIndicatorStateNotify events as appropriate.
-	 *
-	 * If 'changes' is non-NULL, this function updates it to reflect
-	 * any changes to the keyboard state or controls or to the 'core'
-	 * indicator names, maps, or state.   If 'changes' is NULL, this
-	 * function generates XKB events as needed to report the changes.
-	 * If 'dev' is not a keyboard device, any changes are reported
-	 * for the core keyboard.
-	 *
-	 * The 'cause' specifies the reason for the event (key event or
-	 * request) for the change, as reported in some XKB events.
-	 */
+        /*
+         * void
+         * XkbApplyLedMapChanges(dev,sli,changed_maps,changes,cause)
+         *
+         * Handles all of the secondary effects of the changes to the
+         * feedback specified by 'sli' on the device specified by 'dev.'
+         * 
+         * If 'changed_maps' specifies any indicators, this function generates
+         * XkbExtensionDeviceNotify events and possibly IndicatorMapNotify
+         * events to report the changes, and recalculates the effective
+         * state of each indicator with a changed map.  If any indicators
+         * change state, the server generates XkbExtensionDeviceNotify and
+         * XkbIndicatorStateNotify events as appropriate.
+         *
+         * If 'changes' is non-NULL, this function updates it to reflect
+         * any changes to the keyboard state or controls or to the 'core'
+         * indicator names, maps, or state.   If 'changes' is NULL, this
+         * function generates XKB events as needed to report the changes.
+         * If 'dev' is not a keyboard device, any changes are reported
+         * for the core keyboard.
+         *
+         * The 'cause' specifies the reason for the event (key event or
+         * request) for the change, as reported in some XKB events.
+         */
 
 void
-XkbApplyLedMapChanges(	DeviceIntPtr 			dev,
-			XkbSrvLedInfoPtr		sli,
-			unsigned			changed_maps,
-			xkbExtensionDeviceNotify *	ed,
-			XkbChangesPtr			changes,
-			XkbEventCausePtr		cause)
+XkbApplyLedMapChanges(DeviceIntPtr dev,
+                      XkbSrvLedInfoPtr sli,
+                      unsigned changed_maps,
+                      xkbExtensionDeviceNotify * ed,
+                      XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-DeviceIntPtr			kbd;
-XkbChangesRec			my_changes;
-xkbExtensionDeviceNotify	my_ed;
+    DeviceIntPtr kbd;
+    XkbChangesRec my_changes;
+    xkbExtensionDeviceNotify my_ed;
 
-    if (changed_maps==0)
-	return;
+    if (changed_maps == 0)
+        return;
     if (dev->key && dev->key->xkbInfo)
-	 kbd= dev;
-    else kbd= inputInfo.keyboard;
+        kbd = dev;
+    else
+        kbd = inputInfo.keyboard;
 
-    if (ed==NULL) {
-	ed= &my_ed;
-	memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
+    if (ed == NULL) {
+        ed = &my_ed;
+        memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
     }
-    else if ((ed->reason&XkbXI_IndicatorsMask)&&
-	     ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+    else if ((ed->reason & XkbXI_IndicatorsMask) &&
+             ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
     }
 
-    if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault)) {
-	if (changes==NULL) {
-	    changes= &my_changes;
-	    memset((char *)changes, 0, sizeof(XkbChangesRec));
-	}
-	changes->indicators.map_changes|= changed_maps;
+    if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault)) {
+        if (changes == NULL) {
+            changes = &my_changes;
+            memset((char *) changes, 0, sizeof(XkbChangesRec));
+        }
+        changes->indicators.map_changes |= changed_maps;
     }
 
-    XkbCheckIndicatorMaps(dev,sli,changed_maps);
+    XkbCheckIndicatorMaps(dev, sli, changed_maps);
 
-    ed->reason|=	XkbXI_IndicatorMapsMask;
-    ed->ledClass= 	sli->class;
-    ed->ledID=		sli->id;
-    ed->ledsDefined=	sli->namesPresent|sli->mapsPresent;
-    ed->ledState=	sli->effectiveState;
-    ed->unsupported=	0;
-    ed->supported=	XkbXI_AllFeaturesMask;
+    ed->reason |= XkbXI_IndicatorMapsMask;
+    ed->ledClass = sli->class;
+    ed->ledID = sli->id;
+    ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+    ed->ledState = sli->effectiveState;
+    ed->unsupported = 0;
+    ed->supported = XkbXI_AllFeaturesMask;
 
-    XkbUpdateLedAutoState(dev,sli,changed_maps,ed,changes,cause);
+    XkbUpdateLedAutoState(dev, sli, changed_maps, ed, changes, cause);
 
-    if (changes!=&my_changes)	changes= NULL;
-    if (ed!=&my_ed)		ed= NULL;
+    if (changes != &my_changes)
+        changes = NULL;
+    if (ed != &my_ed)
+        ed = NULL;
     if (changes || ed)
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
     return;
 }
 
 /***====================================================================***/
 
 void
-XkbApplyLedStateChanges(DeviceIntPtr 			dev,
-			XkbSrvLedInfoPtr		sli,
-			unsigned			changed_leds,
-			xkbExtensionDeviceNotify *	ed,
-			XkbChangesPtr			changes,
-			XkbEventCausePtr		cause)
+XkbApplyLedStateChanges(DeviceIntPtr dev,
+                        XkbSrvLedInfoPtr sli,
+                        unsigned changed_leds,
+                        xkbExtensionDeviceNotify * ed,
+                        XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-XkbSrvInfoPtr			xkbi;
-DeviceIntPtr			kbd;
-XkbChangesRec			my_changes;
-xkbExtensionDeviceNotify	my_ed;
-register unsigned		i,bit,affected;
-XkbIndicatorMapPtr		map;
-unsigned			oldState;
-Bool				kb_changed;
-
-    if (changed_leds==0)
-	return;
+    XkbSrvInfoPtr xkbi;
+    DeviceIntPtr kbd;
+    XkbChangesRec my_changes;
+    xkbExtensionDeviceNotify my_ed;
+    register unsigned i, bit, affected;
+    XkbIndicatorMapPtr map;
+    unsigned oldState;
+    Bool kb_changed;
+
+    if (changed_leds == 0)
+        return;
     if (dev->key && dev->key->xkbInfo)
-	 kbd= dev;
-    else kbd= inputInfo.keyboard;
-    xkbi= kbd->key->xkbInfo;
-
-    if (changes==NULL) {
-	changes= &my_changes;
-	memset((char *)changes, 0, sizeof(XkbChangesRec));
-    }
-
-    kb_changed= FALSE;
-    affected= changed_leds;
-    oldState= sli->effectiveState;
-    for (i=0,bit=1;(i<XkbNumIndicators)&&(affected);i++,bit<<=1) {
-	if ((affected&bit)==0)
-	    continue;
-	affected&= ~bit;
-	map= &sli->maps[i];
-	if (map->flags&XkbIM_NoExplicit) {
-	    sli->explicitState&= ~bit;
-	    continue;
-	}
-	if (map->flags&XkbIM_LEDDrivesKB) {
-	    Bool on= ((sli->explicitState&bit)!=0);
-	    if (XkbApplyLEDChangeToKeyboard(xkbi,map,on,changes))
-		kb_changed= TRUE;
-	}
-    }
-    sli->effectiveState= (sli->autoState|sli->explicitState);
-    affected= sli->effectiveState^oldState;
-
-    if (ed==NULL) {
-	ed= &my_ed;
-	memset((char *)ed, 0, sizeof(xkbExtensionDeviceNotify));
-    }
-    else if (affected&&(ed->reason&XkbXI_IndicatorsMask)&&
-	     ((ed->ledClass!=sli->class)||(ed->ledID!=sli->id))) {
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
-    }
-
-    if ((kbd==dev)&&(sli->flags&XkbSLI_IsDefault))
-	changes->indicators.state_changes|= affected;
+        kbd = dev;
+    else
+        kbd = inputInfo.keyboard;
+    xkbi = kbd->key->xkbInfo;
+
+    if (changes == NULL) {
+        changes = &my_changes;
+        memset((char *) changes, 0, sizeof(XkbChangesRec));
+    }
+
+    kb_changed = FALSE;
+    affected = changed_leds;
+    oldState = sli->effectiveState;
+    for (i = 0, bit = 1; (i < XkbNumIndicators) && (affected); i++, bit <<= 1) {
+        if ((affected & bit) == 0)
+            continue;
+        affected &= ~bit;
+        map = &sli->maps[i];
+        if (map->flags & XkbIM_NoExplicit) {
+            sli->explicitState &= ~bit;
+            continue;
+        }
+        if (map->flags & XkbIM_LEDDrivesKB) {
+            Bool on = ((sli->explicitState & bit) != 0);
+
+            if (XkbApplyLEDChangeToKeyboard(xkbi, map, on, changes))
+                kb_changed = TRUE;
+        }
+    }
+    sli->effectiveState = (sli->autoState | sli->explicitState);
+    affected = sli->effectiveState ^ oldState;
+
+    if (ed == NULL) {
+        ed = &my_ed;
+        memset((char *) ed, 0, sizeof(xkbExtensionDeviceNotify));
+    }
+    else if (affected && (ed->reason & XkbXI_IndicatorsMask) &&
+             ((ed->ledClass != sli->class) || (ed->ledID != sli->id))) {
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
+    }
+
+    if ((kbd == dev) && (sli->flags & XkbSLI_IsDefault))
+        changes->indicators.state_changes |= affected;
     if (affected) {
-	ed->reason|=		XkbXI_IndicatorStateMask;
-	ed->ledClass= 		sli->class;
-	ed->ledID=		sli->id;
-	ed->ledsDefined=	sli->namesPresent|sli->mapsPresent;
-	ed->ledState=		sli->effectiveState;
-	ed->unsupported=	0;
-	ed->supported=		XkbXI_AllFeaturesMask;
+        ed->reason |= XkbXI_IndicatorStateMask;
+        ed->ledClass = sli->class;
+        ed->ledID = sli->id;
+        ed->ledsDefined = sli->namesPresent | sli->mapsPresent;
+        ed->ledState = sli->effectiveState;
+        ed->unsupported = 0;
+        ed->supported = XkbXI_AllFeaturesMask;
     }
 
     if (kb_changed) {
-	XkbComputeDerivedState(kbd->key->xkbInfo);
-	XkbUpdateLedAutoState(dev,sli,sli->mapsPresent,ed,changes,cause);
+        XkbComputeDerivedState(kbd->key->xkbInfo);
+        XkbUpdateLedAutoState(dev, sli, sli->mapsPresent, ed, changes, cause);
     }
 
-    if (changes!=&my_changes)	changes= NULL;
-    if (ed!=&my_ed)		ed= NULL;
+    if (changes != &my_changes)
+        changes = NULL;
+    if (ed != &my_ed)
+        ed = NULL;
     if (changes || ed)
-	XkbFlushLedEvents(dev,kbd,sli,ed,changes,cause);
+        XkbFlushLedEvents(dev, kbd, sli, ed, changes, cause);
     if (kb_changed)
-	XkbUpdateAllDeviceIndicators(NULL,cause);
+        XkbUpdateAllDeviceIndicators(NULL, cause);
     return;
 }
diff --git a/xorg-server/xkb/xkbPrKeyEv.c b/xorg-server/xkb/xkbPrKeyEv.c
index 630f17c23..32411838d 100644
--- a/xorg-server/xkb/xkbPrKeyEv.c
+++ b/xorg-server/xkb/xkbPrKeyEv.c
@@ -46,20 +46,21 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 void
 XkbProcessKeyboardEvent(DeviceEvent *event, DeviceIntPtr keybd)
 {
-KeyClassPtr	keyc = keybd->key;
-XkbSrvInfoPtr	xkbi;
-int		key;
-XkbBehavior	behavior;
-unsigned        ndx;
+    KeyClassPtr keyc = keybd->key;
+    XkbSrvInfoPtr xkbi;
+    int key;
+    XkbBehavior behavior;
+    unsigned ndx;
 
     xkbi = keyc->xkbInfo;
     key = event->detail.key;
     if (xkbDebugFlags & 0x8)
-	DebugF("[xkb] XkbPKE: Key %d %s\n",key,(event->type == ET_KeyPress?"down":"up"));
+        DebugF("[xkb] XkbPKE: Key %d %s\n", key,
+               (event->type == ET_KeyPress ? "down" : "up"));
 
-    if (xkbi->repeatKey == key && event->type== ET_KeyRelease &&
+    if (xkbi->repeatKey == key && event->type == ET_KeyRelease &&
         !(xkbi->desc->ctrls->enabled_ctrls & XkbRepeatKeysMask))
-	AccessXCancelRepeatKey(xkbi, key);
+        AccessXCancelRepeatKey(xkbi, key);
 
     behavior = xkbi->desc->server->behaviors[key];
     /* The "permanent" flag indicates a hard-wired behavior that occurs */
@@ -68,73 +69,79 @@ unsigned        ndx;
     /* key is hardwired */
 
     if (!(behavior.type & XkbKB_Permanent)) {
-	switch (behavior.type) {
-	    case XkbKB_Default:
-                /* Neither of these should happen in practice, but ignore them
-                   anyway. */
-		if (event->type == ET_KeyPress && !event->key_repeat &&
-                    key_is_down(keybd, key, KEY_PROCESSED))
+        switch (behavior.type) {
+        case XkbKB_Default:
+            /* Neither of these should happen in practice, but ignore them
+               anyway. */
+            if (event->type == ET_KeyPress && !event->key_repeat &&
+                key_is_down(keybd, key, KEY_PROCESSED))
+                return;
+            else if (event->type == ET_KeyRelease &&
+                     !key_is_down(keybd, key, KEY_PROCESSED))
+                return;
+            break;
+        case XkbKB_Lock:
+            if (event->type == ET_KeyRelease)
+                return;
+            else if (key_is_down(keybd, key, KEY_PROCESSED))
+                event->type = ET_KeyRelease;
+            break;
+        case XkbKB_RadioGroup:
+            ndx = (behavior.data & (~XkbKB_RGAllowNone));
+            if (ndx < xkbi->nRadioGroups) {
+                XkbRadioGroupPtr rg;
+
+                if (event->type == ET_KeyRelease)
                     return;
-		else if (event->type == ET_KeyRelease &&
-                         !key_is_down(keybd, key, KEY_PROCESSED))
+
+                rg = &xkbi->radioGroups[ndx];
+                if (rg->currentDown == event->detail.key) {
+                    if (behavior.data & XkbKB_RGAllowNone) {
+                        event->type = ET_KeyRelease;
+                        XkbHandleActions(keybd, keybd, event);
+                        rg->currentDown = 0;
+                    }
                     return;
-		break;
-	    case XkbKB_Lock:
-		if (event->type == ET_KeyRelease)
-		    return;
-		else if (key_is_down(keybd, key, KEY_PROCESSED))
+                }
+                if (rg->currentDown != 0) {
+                    int key = event->detail.key;
+
                     event->type = ET_KeyRelease;
-		break;
-	    case XkbKB_RadioGroup:
-		ndx= (behavior.data&(~XkbKB_RGAllowNone));
-		if ( ndx<xkbi->nRadioGroups ) {
-		    XkbRadioGroupPtr	rg;
-
-		    if (event->type == ET_KeyRelease)
-		        return;
-
-		    rg = &xkbi->radioGroups[ndx];
-		    if ( rg->currentDown == event->detail.key) {
-		        if (behavior.data&XkbKB_RGAllowNone) {
-		            event->type = ET_KeyRelease;
-			    XkbHandleActions(keybd, keybd, event);
-			    rg->currentDown= 0;
-		        }
-		        return;
-		    }
-		    if ( rg->currentDown!=0 ) {
-			int key = event->detail.key;
-			event->type = ET_KeyRelease;
-			event->detail.key = rg->currentDown;
-			XkbHandleActions(keybd, keybd, event);
-			event->type = ET_KeyPress;
-			event->detail.key = key;
-		    }
-		    rg->currentDown= key;
-		}
-		else ErrorF("[xkb] InternalError! Illegal radio group %d\n",ndx);
-		break;
-	    case XkbKB_Overlay1: case XkbKB_Overlay2:
-		{
-		    unsigned	which;
-		    if (behavior.type==XkbKB_Overlay1)	which= XkbOverlay1Mask;
-		    else				which= XkbOverlay2Mask;
-		    if ( (xkbi->desc->ctrls->enabled_ctrls&which)==0 )
-			break;
-		    if ((behavior.data>=xkbi->desc->min_key_code)&&
-			(behavior.data<=xkbi->desc->max_key_code)) {
-                        event->detail.key = behavior.data;
-			/* 9/11/94 (ef) -- XXX! need to match release with */
-			/*                 press even if the state of the  */
-			/*                 corresponding overlay control   */
-			/*                 changes while the key is down   */
-		    }
-		}
-		break;
-	    default:
-		ErrorF("[xkb] unknown key behavior 0x%04x\n",behavior.type);
-		break;
-	}
+                    event->detail.key = rg->currentDown;
+                    XkbHandleActions(keybd, keybd, event);
+                    event->type = ET_KeyPress;
+                    event->detail.key = key;
+                }
+                rg->currentDown = key;
+            }
+            else
+                ErrorF("[xkb] InternalError! Illegal radio group %d\n", ndx);
+            break;
+        case XkbKB_Overlay1:
+        case XkbKB_Overlay2:
+        {
+            unsigned which;
+
+            if (behavior.type == XkbKB_Overlay1)
+                which = XkbOverlay1Mask;
+            else
+                which = XkbOverlay2Mask;
+            if ((xkbi->desc->ctrls->enabled_ctrls & which) == 0)
+                break;
+            if ((behavior.data >= xkbi->desc->min_key_code) &&
+                (behavior.data <= xkbi->desc->max_key_code)) {
+                event->detail.key = behavior.data;
+                /* 9/11/94 (ef) -- XXX! need to match release with */
+                /*                 press even if the state of the  */
+                /*                 corresponding overlay control   */
+                /*                 changes while the key is down   */
+            }
+        }
+            break;
+        default:
+            ErrorF("[xkb] unknown key behavior 0x%04x\n", behavior.type);
+            break;
+        }
     }
     XkbHandleActions(keybd, keybd, event);
     return;
diff --git a/xorg-server/xkb/xkbSwap.c b/xorg-server/xkb/xkbSwap.c
index fcae918a9..076da340b 100644
--- a/xorg-server/xkb/xkbSwap.c
+++ b/xorg-server/xkb/xkbSwap.c
@@ -38,9 +38,9 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "extnsionst.h"
 #include "xkb.h"
 
-	/*
-	 * REQUEST SWAPPING
-	 */
+        /*
+         * REQUEST SWAPPING
+         */
 static int
 SProcXkbUseExtension(ClientPtr client)
 {
@@ -66,66 +66,67 @@ SProcXkbSelectEvents(ClientPtr client)
     swaps(&stuff->selectAll);
     swaps(&stuff->affectMap);
     swaps(&stuff->map);
-    if ((stuff->affectWhich&(~XkbMapNotifyMask))!=0)  {
-	union {
-	    BOOL	*b;
-	    CARD8	*c8;
-	    CARD16	*c16;
-	    CARD32	*c32;
-	} from;
-	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)||(ndx==XkbMapNotify))
-		continue;
-	    maskLeft&= ~bit;
-	    if ((stuff->selectAll&bit)||(stuff->clear&bit))
-		continue;
-	    switch (ndx) {
-		case XkbNewKeyboardNotify:
-		case XkbStateNotify:
-		case XkbNamesNotify:
-		case XkbAccessXNotify:
-		case XkbExtensionDeviceNotify:
-		    size= 2;
-		    break;
-		case XkbControlsNotify:
-		case XkbIndicatorStateNotify:
-		case XkbIndicatorMapNotify:
-		    size= 4;
-		    break;
-		case XkbBellNotify:
-		case XkbActionMessage:
-		case XkbCompatMapNotify:
-		    size= 1;
-		    break;
-		default:
-		    client->errorValue = _XkbErrCode2(0x1,bit);
-		    return BadValue;
-	    }
-	    if (dataLeft<(size*2))
-		return BadLength;
-	    if (size==2) {
-		swaps(&from.c16[0]);
-		swaps(&from.c16[1]);
-	    }
-	    else if (size==4) {
-		swapl(&from.c32[0]);
-		swapl(&from.c32[1]);
-	    }
-	    else {
-		size= 2;
-	    }
-	    from.c8+= (size*2);
-	    dataLeft-= (size*2);
-	}
-	if (dataLeft>2) {
-	    ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",dataLeft);
-	    return BadLength;
-	}
+    if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) {
+        union {
+            BOOL *b;
+            CARD8 *c8;
+            CARD16 *c16;
+            CARD32 *c32;
+        } from;
+        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) || (ndx == XkbMapNotify))
+                continue;
+            maskLeft &= ~bit;
+            if ((stuff->selectAll & bit) || (stuff->clear & bit))
+                continue;
+            switch (ndx) {
+            case XkbNewKeyboardNotify:
+            case XkbStateNotify:
+            case XkbNamesNotify:
+            case XkbAccessXNotify:
+            case XkbExtensionDeviceNotify:
+                size = 2;
+                break;
+            case XkbControlsNotify:
+            case XkbIndicatorStateNotify:
+            case XkbIndicatorMapNotify:
+                size = 4;
+                break;
+            case XkbBellNotify:
+            case XkbActionMessage:
+            case XkbCompatMapNotify:
+                size = 1;
+                break;
+            default:
+                client->errorValue = _XkbErrCode2(0x1, bit);
+                return BadValue;
+            }
+            if (dataLeft < (size * 2))
+                return BadLength;
+            if (size == 2) {
+                swaps(&from.c16[0]);
+                swaps(&from.c16[1]);
+            }
+            else if (size == 4) {
+                swapl(&from.c32[0]);
+                swapl(&from.c32[1]);
+            }
+            else {
+                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 ProcXkbSelectEvents(client);
 }
@@ -244,7 +245,6 @@ SProcXkbSetMap(ClientPtr client)
     return ProcXkbSetMap(client);
 }
 
-
 static int
 SProcXkbGetCompatMap(ClientPtr client)
 {
@@ -336,7 +336,6 @@ SProcXkbSetNamedIndicator(ClientPtr client)
     return ProcXkbSetNamedIndicator(client);
 }
 
-
 static int
 SProcXkbGetNames(ClientPtr client)
 {
@@ -478,64 +477,63 @@ SProcXkbSetDebuggingFlags(ClientPtr client)
 }
 
 int
-SProcXkbDispatch (ClientPtr client)
+SProcXkbDispatch(ClientPtr client)
 {
     REQUEST(xReq);
-    switch (stuff->data)
-    {
+    switch (stuff->data) {
     case X_kbUseExtension:
-	return SProcXkbUseExtension(client);
+        return SProcXkbUseExtension(client);
     case X_kbSelectEvents:
-	return SProcXkbSelectEvents(client);
+        return SProcXkbSelectEvents(client);
     case X_kbBell:
-	return SProcXkbBell(client);
+        return SProcXkbBell(client);
     case X_kbGetState:
-	return SProcXkbGetState(client);
+        return SProcXkbGetState(client);
     case X_kbLatchLockState:
-	return SProcXkbLatchLockState(client);
+        return SProcXkbLatchLockState(client);
     case X_kbGetControls:
-	return SProcXkbGetControls(client);
+        return SProcXkbGetControls(client);
     case X_kbSetControls:
-	return SProcXkbSetControls(client);
+        return SProcXkbSetControls(client);
     case X_kbGetMap:
-	return SProcXkbGetMap(client);
+        return SProcXkbGetMap(client);
     case X_kbSetMap:
-	return SProcXkbSetMap(client);
+        return SProcXkbSetMap(client);
     case X_kbGetCompatMap:
-	return SProcXkbGetCompatMap(client);
+        return SProcXkbGetCompatMap(client);
     case X_kbSetCompatMap:
-	return SProcXkbSetCompatMap(client);
+        return SProcXkbSetCompatMap(client);
     case X_kbGetIndicatorState:
-	return SProcXkbGetIndicatorState(client);
+        return SProcXkbGetIndicatorState(client);
     case X_kbGetIndicatorMap:
-	return SProcXkbGetIndicatorMap(client);
+        return SProcXkbGetIndicatorMap(client);
     case X_kbSetIndicatorMap:
-	return SProcXkbSetIndicatorMap(client);
+        return SProcXkbSetIndicatorMap(client);
     case X_kbGetNamedIndicator:
-	return SProcXkbGetNamedIndicator(client);
+        return SProcXkbGetNamedIndicator(client);
     case X_kbSetNamedIndicator:
-	return SProcXkbSetNamedIndicator(client);
+        return SProcXkbSetNamedIndicator(client);
     case X_kbGetNames:
-	return SProcXkbGetNames(client);
+        return SProcXkbGetNames(client);
     case X_kbSetNames:
-	return SProcXkbSetNames(client);
+        return SProcXkbSetNames(client);
     case X_kbGetGeometry:
-	return SProcXkbGetGeometry(client);
+        return SProcXkbGetGeometry(client);
     case X_kbSetGeometry:
-	return SProcXkbSetGeometry(client);
+        return SProcXkbSetGeometry(client);
     case X_kbPerClientFlags:
-	return SProcXkbPerClientFlags(client);
+        return SProcXkbPerClientFlags(client);
     case X_kbListComponents:
-	return SProcXkbListComponents(client);
+        return SProcXkbListComponents(client);
     case X_kbGetKbdByName:
-	return SProcXkbGetKbdByName(client);
+        return SProcXkbGetKbdByName(client);
     case X_kbGetDeviceInfo:
-	return SProcXkbGetDeviceInfo(client);
+        return SProcXkbGetDeviceInfo(client);
     case X_kbSetDeviceInfo:
-	return SProcXkbSetDeviceInfo(client);
+        return SProcXkbSetDeviceInfo(client);
     case X_kbSetDebuggingFlags:
-	return SProcXkbSetDebuggingFlags(client);
+        return SProcXkbSetDebuggingFlags(client);
     default:
-	return BadRequest;
+        return BadRequest;
     }
 }
diff --git a/xorg-server/xkb/xkbUtils.c b/xorg-server/xkb/xkbUtils.c
index cc9aaa75a..c23cd7784 100644
--- a/xorg-server/xkb/xkbUtils.c
+++ b/xorg-server/xkb/xkbUtils.c
@@ -73,7 +73,7 @@ DEALINGS IN THE SOFTWARE.
 
 int
 _XkbLookupAnyDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
-		    Mask access_mode, int *xkb_err)
+                    Mask access_mode, int *xkb_err)
 {
     int rc = XkbKeyboardErrorCode;
 
@@ -84,14 +84,14 @@ _XkbLookupAnyDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
 
     rc = dixLookupDevice(pDev, id, client, access_mode);
     if (rc != Success)
-	*xkb_err = XkbErr_BadDevice;
+        *xkb_err = XkbErr_BadDevice;
 
     return rc;
 }
 
 int
 _XkbLookupKeyboard(DeviceIntPtr *pDev, int id, ClientPtr client,
-		   Mask access_mode, int *xkb_err)
+                   Mask access_mode, int *xkb_err)
 {
     DeviceIntPtr dev;
     int rc;
@@ -101,40 +101,40 @@ _XkbLookupKeyboard(DeviceIntPtr *pDev, int id, ClientPtr client,
 
     rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
     if (rc != Success)
-	return rc;
+        return rc;
 
     dev = *pDev;
     if (!dev->key || !dev->key->xkbInfo) {
-	*pDev = NULL;
-	*xkb_err= XkbErr_BadClass;
-	return XkbKeyboardErrorCode;
+        *pDev = NULL;
+        *xkb_err = XkbErr_BadClass;
+        return XkbKeyboardErrorCode;
     }
     return Success;
 }
 
 int
 _XkbLookupBellDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
-		     Mask access_mode, int *xkb_err)
+                     Mask access_mode, int *xkb_err)
 {
     DeviceIntPtr dev;
     int rc;
 
     rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
     if (rc != Success)
-	return rc;
+        return rc;
 
     dev = *pDev;
     if (!dev->kbdfeed && !dev->bell) {
-	*pDev = NULL;
-	*xkb_err= XkbErr_BadClass;
-	return XkbKeyboardErrorCode;
+        *pDev = NULL;
+        *xkb_err = XkbErr_BadClass;
+        return XkbKeyboardErrorCode;
     }
     return Success;
 }
 
 int
 _XkbLookupLedDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
-		    Mask access_mode, int *xkb_err)
+                    Mask access_mode, int *xkb_err)
 {
     DeviceIntPtr dev;
     int rc;
@@ -144,68 +144,70 @@ _XkbLookupLedDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
 
     rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
     if (rc != Success)
-	return rc;
+        return rc;
 
     dev = *pDev;
     if (!dev->kbdfeed && !dev->leds) {
-	*pDev = NULL;
-	*xkb_err= XkbErr_BadClass;
-	return XkbKeyboardErrorCode;
+        *pDev = NULL;
+        *xkb_err = XkbErr_BadClass;
+        return XkbKeyboardErrorCode;
     }
     return Success;
 }
 
 int
 _XkbLookupButtonDevice(DeviceIntPtr *pDev, int id, ClientPtr client,
-		       Mask access_mode, int *xkb_err)
+                       Mask access_mode, int *xkb_err)
 {
     DeviceIntPtr dev;
     int rc;
 
     rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err);
     if (rc != Success)
-	return rc;
+        return rc;
 
     dev = *pDev;
     if (!dev->button) {
-	*pDev = NULL;
-	*xkb_err= XkbErr_BadClass;
-	return XkbKeyboardErrorCode;
+        *pDev = NULL;
+        *xkb_err = XkbErr_BadClass;
+        return XkbKeyboardErrorCode;
     }
     return Success;
 }
 
 void
-XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
+XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods)
 {
-register unsigned	tmp;
+    register unsigned tmp;
 
     switch (act->type) {
-	case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
-	    if (act->mods.flags&XkbSA_UseModMapMods)
-		act->mods.real_mods= act->mods.mask= mods;
-	    if ((tmp= XkbModActionVMods(&act->mods))!=0)
-		act->mods.mask|= XkbMaskForVMask(xkb,tmp);
-	    break;
-	case XkbSA_ISOLock:
-	    if (act->iso.flags&XkbSA_UseModMapMods)
-		act->iso.real_mods= act->iso.mask= mods;
-	    if ((tmp= XkbModActionVMods(&act->iso))!=0)
-		act->iso.mask|= XkbMaskForVMask(xkb,tmp);
-	    break;
+    case XkbSA_SetMods:
+    case XkbSA_LatchMods:
+    case XkbSA_LockMods:
+        if (act->mods.flags & XkbSA_UseModMapMods)
+            act->mods.real_mods = act->mods.mask = mods;
+        if ((tmp = XkbModActionVMods(&act->mods)) != 0)
+            act->mods.mask |= XkbMaskForVMask(xkb, tmp);
+        break;
+    case XkbSA_ISOLock:
+        if (act->iso.flags & XkbSA_UseModMapMods)
+            act->iso.real_mods = act->iso.mask = mods;
+        if ((tmp = XkbModActionVMods(&act->iso)) != 0)
+            act->iso.mask |= XkbMaskForVMask(xkb, tmp);
+        break;
     }
     return;
 }
 
 unsigned
-XkbMaskForVMask(XkbDescPtr xkb,unsigned vmask)
+XkbMaskForVMask(XkbDescPtr xkb, unsigned vmask)
 {
-register int i,bit;
-register unsigned mask;
-    
-    for (mask=i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (vmask&bit)
-	    mask|= xkb->server->vmods[i];
+    register int i, bit;
+    register unsigned mask;
+
+    for (mask = i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (vmask & bit)
+            mask |= xkb->server->vmods[i];
     }
     return mask;
 }
@@ -213,147 +215,144 @@ register unsigned mask;
 /***====================================================================***/
 
 void
-XkbUpdateKeyTypesFromCore(	DeviceIntPtr	pXDev,
-                                KeySymsPtr      pCore,
-				KeyCode	 	first,
-				CARD8	 	num,
-				XkbChangesPtr	changes)
+XkbUpdateKeyTypesFromCore(DeviceIntPtr pXDev,
+                          KeySymsPtr pCore,
+                          KeyCode first, CARD8 num, XkbChangesPtr changes)
 {
-XkbDescPtr		xkb;
-unsigned		key,nG,explicit;
-int			types[XkbNumKbdGroups];
-KeySym			tsyms[XkbMaxSymsPerKey],*syms;
-XkbMapChangesPtr	mc;
-
-    xkb= pXDev->key->xkbInfo->desc;
-    if (first+num-1>xkb->max_key_code) {
-	/* 1/12/95 (ef) -- XXX! should allow XKB structures to grow */
-	num= xkb->max_key_code-first+1;
+    XkbDescPtr xkb;
+    unsigned key, nG, explicit;
+    int types[XkbNumKbdGroups];
+    KeySym tsyms[XkbMaxSymsPerKey], *syms;
+    XkbMapChangesPtr mc;
+
+    xkb = pXDev->key->xkbInfo->desc;
+    if (first + num - 1 > xkb->max_key_code) {
+        /* 1/12/95 (ef) -- XXX! should allow XKB structures to grow */
+        num = xkb->max_key_code - first + 1;
     }
 
-    mc= (changes?(&changes->map):NULL);
-
-    syms= &pCore->map[(first - pCore->minKeyCode) * pCore->mapWidth];
-    for (key=first; key<(first+num); key++,syms+= pCore->mapWidth) {
-        explicit= xkb->server->explicit[key]&XkbExplicitKeyTypesMask;
-        types[XkbGroup1Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
-        types[XkbGroup2Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup2Index);
-        types[XkbGroup3Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup3Index);
-        types[XkbGroup4Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup4Index);
-        nG= XkbKeyTypesForCoreSymbols(xkb,pCore->mapWidth,syms,explicit,types,
-									tsyms);
-	XkbChangeTypesOfKey(xkb,key,nG,XkbAllGroupsMask,types,mc);
-	memcpy((char *)XkbKeySymsPtr(xkb,key),(char *)tsyms,
-					XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
+    mc = (changes ? (&changes->map) : NULL);
+
+    syms = &pCore->map[(first - pCore->minKeyCode) * pCore->mapWidth];
+    for (key = first; key < (first + num); key++, syms += pCore->mapWidth) {
+        explicit = xkb->server->explicit[key] & XkbExplicitKeyTypesMask;
+        types[XkbGroup1Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
+        types[XkbGroup2Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup2Index);
+        types[XkbGroup3Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup3Index);
+        types[XkbGroup4Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup4Index);
+        nG = XkbKeyTypesForCoreSymbols(xkb, pCore->mapWidth, syms, explicit,
+                                       types, tsyms);
+        XkbChangeTypesOfKey(xkb, key, nG, XkbAllGroupsMask, types, mc);
+        memcpy((char *) XkbKeySymsPtr(xkb, key), (char *) tsyms,
+               XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
     }
-    if (changes->map.changed&XkbKeySymsMask) {
-	CARD8 oldLast,newLast;
-	oldLast = changes->map.first_key_sym+changes->map.num_key_syms-1;
-	newLast = first+num-1;
-
-	if (first<changes->map.first_key_sym)
-	    changes->map.first_key_sym = first;
-	if (oldLast>newLast)
-	    newLast= oldLast;
-	changes->map.num_key_syms = newLast-changes->map.first_key_sym+1;
+    if (changes->map.changed & XkbKeySymsMask) {
+        CARD8 oldLast, newLast;
+
+        oldLast = changes->map.first_key_sym + changes->map.num_key_syms - 1;
+        newLast = first + num - 1;
+
+        if (first < changes->map.first_key_sym)
+            changes->map.first_key_sym = first;
+        if (oldLast > newLast)
+            newLast = oldLast;
+        changes->map.num_key_syms = newLast - changes->map.first_key_sym + 1;
     }
     else {
-	changes->map.changed|= XkbKeySymsMask;
-	changes->map.first_key_sym = first;
-	changes->map.num_key_syms = num;
+        changes->map.changed |= XkbKeySymsMask;
+        changes->map.first_key_sym = first;
+        changes->map.num_key_syms = num;
     }
     return;
 }
 
 void
-XkbUpdateDescActions(	XkbDescPtr		xkb,
-			KeyCode		 	first,
-			CARD8		 	num,
-			XkbChangesPtr	 	changes)
+XkbUpdateDescActions(XkbDescPtr xkb,
+                     KeyCode first, CARD8 num, XkbChangesPtr changes)
 {
-register unsigned	key;
+    register unsigned key;
 
-    for (key=first;key<(first+num);key++) {
-	XkbApplyCompatMapToKey(xkb,key,changes);
+    for (key = first; key < (first + num); key++) {
+        XkbApplyCompatMapToKey(xkb, key, changes);
     }
 
-    if (changes->map.changed&(XkbVirtualModMapMask|XkbModifierMapMask)) {
-        unsigned char           newVMods[XkbNumVirtualMods];
-        register  unsigned      bit,i;
-        unsigned                present;
+    if (changes->map.changed & (XkbVirtualModMapMask | XkbModifierMapMask)) {
+        unsigned char newVMods[XkbNumVirtualMods];
+        register unsigned bit, i;
+        unsigned present;
 
         memset(newVMods, 0, XkbNumVirtualMods);
-        present= 0;
-        for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
-            if (xkb->server->vmodmap[key]==0)
+        present = 0;
+        for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+            if (xkb->server->vmodmap[key] == 0)
                 continue;
-            for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-                if (bit&xkb->server->vmodmap[key]) {
-                    present|= bit;
-                    newVMods[i]|= xkb->map->modmap[key];
+            for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+                if (bit & xkb->server->vmodmap[key]) {
+                    present |= bit;
+                    newVMods[i] |= xkb->map->modmap[key];
                 }
             }
         }
-        for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-            if ((bit&present)&&(newVMods[i]!=xkb->server->vmods[i])) {
-                changes->map.changed|= XkbVirtualModsMask;
-                changes->map.vmods|= bit;
-                xkb->server->vmods[i]= newVMods[i];
+        for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+            if ((bit & present) && (newVMods[i] != xkb->server->vmods[i])) {
+                changes->map.changed |= XkbVirtualModsMask;
+                changes->map.vmods |= bit;
+                xkb->server->vmods[i] = newVMods[i];
             }
         }
     }
-    if (changes->map.changed&XkbVirtualModsMask)
-        XkbApplyVirtualModChanges(xkb,changes->map.vmods,changes);
-
-    if (changes->map.changed&XkbKeyActionsMask) {
-	CARD8 oldLast,newLast;
-	oldLast= changes->map.first_key_act+changes->map.num_key_acts-1;
-	newLast = first+num-1;
-
-	if (first<changes->map.first_key_act)
-	    changes->map.first_key_act = first;
-	if (newLast>oldLast)
-	    newLast= oldLast;
-	changes->map.num_key_acts= newLast-changes->map.first_key_act+1;
+    if (changes->map.changed & XkbVirtualModsMask)
+        XkbApplyVirtualModChanges(xkb, changes->map.vmods, changes);
+
+    if (changes->map.changed & XkbKeyActionsMask) {
+        CARD8 oldLast, newLast;
+
+        oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1;
+        newLast = first + num - 1;
+
+        if (first < changes->map.first_key_act)
+            changes->map.first_key_act = first;
+        if (newLast > oldLast)
+            newLast = oldLast;
+        changes->map.num_key_acts = newLast - changes->map.first_key_act + 1;
     }
     else {
-	changes->map.changed|= XkbKeyActionsMask;
-	changes->map.first_key_act = first;
-	changes->map.num_key_acts = num;
+        changes->map.changed |= XkbKeyActionsMask;
+        changes->map.first_key_act = first;
+        changes->map.num_key_acts = num;
     }
     return;
 }
 
 void
-XkbUpdateActions(	DeviceIntPtr	 	pXDev,
-			KeyCode		 	first,
-			CARD8		 	num,
-			XkbChangesPtr	 	changes,
-			unsigned *	 	needChecksRtrn,
-			XkbEventCausePtr	cause)
+XkbUpdateActions(DeviceIntPtr pXDev,
+                 KeyCode first,
+                 CARD8 num,
+                 XkbChangesPtr changes,
+                 unsigned *needChecksRtrn, XkbEventCausePtr cause)
 {
-XkbSrvInfoPtr		xkbi;
-XkbDescPtr		xkb;
-CARD8 *			repeat;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
+    CARD8 *repeat;
 
     if (needChecksRtrn)
-	*needChecksRtrn= 0;
-    xkbi= pXDev->key->xkbInfo;
-    xkb= xkbi->desc;
-    repeat= xkb->ctrls->per_key_repeat;
+        *needChecksRtrn = 0;
+    xkbi = pXDev->key->xkbInfo;
+    xkb = xkbi->desc;
+    repeat = xkb->ctrls->per_key_repeat;
 
     /* before letting XKB do any changes, copy the current core values */
     if (pXDev->kbdfeed)
-	memcpy(repeat,pXDev->kbdfeed->ctrl.autoRepeats,XkbPerKeyBitArraySize);
+        memcpy(repeat, pXDev->kbdfeed->ctrl.autoRepeats, XkbPerKeyBitArraySize);
 
-    XkbUpdateDescActions(xkb,first,num,changes);
+    XkbUpdateDescActions(xkb, first, num, changes);
 
-    if ((pXDev->kbdfeed)&&
-	(changes->ctrls.changed_ctrls&XkbPerKeyRepeatMask)) {
-	/* now copy the modified changes back to core */
-	memcpy(pXDev->kbdfeed->ctrl.autoRepeats,repeat, XkbPerKeyBitArraySize);
-	if (pXDev->kbdfeed->CtrlProc)
-	    (*pXDev->kbdfeed->CtrlProc)(pXDev, &pXDev->kbdfeed->ctrl);
+    if ((pXDev->kbdfeed) &&
+        (changes->ctrls.changed_ctrls & XkbPerKeyRepeatMask)) {
+        /* now copy the modified changes back to core */
+        memcpy(pXDev->kbdfeed->ctrl.autoRepeats, repeat, XkbPerKeyBitArraySize);
+        if (pXDev->kbdfeed->CtrlProc)
+            (*pXDev->kbdfeed->CtrlProc) (pXDev, &pXDev->kbdfeed->ctrl);
     }
     return;
 }
@@ -361,53 +360,57 @@ CARD8 *			repeat;
 KeySymsPtr
 XkbGetCoreMap(DeviceIntPtr keybd)
 {
-register int		key,tmp;
-int			maxSymsPerKey, maxGroup1Width;
-XkbDescPtr		xkb;
-KeySymsPtr              syms;
-int			maxNumberOfGroups;
+    register int key, tmp;
+    int maxSymsPerKey, maxGroup1Width;
+    XkbDescPtr xkb;
+    KeySymsPtr syms;
+    int maxNumberOfGroups;
 
     if (!keybd || !keybd->key || !keybd->key->xkbInfo)
-	return NULL;
+        return NULL;
 
-    xkb= keybd->key->xkbInfo->desc;
-    maxSymsPerKey= maxGroup1Width= 0;
+    xkb = keybd->key->xkbInfo->desc;
+    maxSymsPerKey = maxGroup1Width = 0;
     maxNumberOfGroups = 0;
 
     /* determine sizes */
-    for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
-	if (XkbKeycodeInRange(xkb,key)) {
-	    int	nGroups;
-	    int	w;
-	    nGroups= XkbKeyNumGroups(xkb,key);
-	    tmp= 0;
-	    if (nGroups>0) {
-		if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup1Index))<=2)
-		     tmp+= 2;
-		else tmp+= w + 2;
+    for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+        if (XkbKeycodeInRange(xkb, key)) {
+            int nGroups;
+            int w;
+
+            nGroups = XkbKeyNumGroups(xkb, key);
+            tmp = 0;
+            if (nGroups > 0) {
+                if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup1Index)) <= 2)
+                    tmp += 2;
+                else
+                    tmp += w + 2;
                 /* remember highest G1 width */
                 if (w > maxGroup1Width)
                     maxGroup1Width = w;
-	    }
-	    if (nGroups>1) {
+            }
+            if (nGroups > 1) {
                 if (tmp <= 2) {
-		     if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup2Index))<2)
-		          tmp+= 2;
-		     else tmp+= w;
-                } else {
-                     if ((w=XkbKeyGroupWidth(xkb,key,XkbGroup2Index))>2)
-                          tmp+= w - 2;
+                    if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)) < 2)
+                        tmp += 2;
+                    else
+                        tmp += w;
+                }
+                else {
+                    if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)) > 2)
+                        tmp += w - 2;
                 }
-	    }
-	    if (nGroups>2)
-		tmp+= XkbKeyGroupWidth(xkb,key,XkbGroup3Index);
-	    if (nGroups>3)
-		tmp+= XkbKeyGroupWidth(xkb,key,XkbGroup4Index);
-	    if (tmp>maxSymsPerKey)
-		maxSymsPerKey= tmp;
+            }
+            if (nGroups > 2)
+                tmp += XkbKeyGroupWidth(xkb, key, XkbGroup3Index);
+            if (nGroups > 3)
+                tmp += XkbKeyGroupWidth(xkb, key, XkbGroup4Index);
+            if (tmp > maxSymsPerKey)
+                maxSymsPerKey = tmp;
             if (nGroups > maxNumberOfGroups)
-		maxNumberOfGroups = nGroups;
-	}
+                maxNumberOfGroups = nGroups;
+        }
     }
 
     if (maxSymsPerKey <= 0)
@@ -436,104 +439,110 @@ int			maxNumberOfGroups;
         return NULL;
     }
 
-    for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
-        KeySym *pCore,*pXKB;
-        unsigned nGroups,groupWidth,n,nOut;
-
-        nGroups= XkbKeyNumGroups(xkb,key);
-        n= (key-xkb->min_key_code)*syms->mapWidth;
-        pCore= &syms->map[n];
-        pXKB= XkbKeySymsPtr(xkb,key);
-        nOut= 2;
-        if (nGroups>0) {
-            groupWidth= XkbKeyGroupWidth(xkb,key,XkbGroup1Index);
-            if (groupWidth>0)   pCore[0]= pXKB[0];
-            if (groupWidth>1)   pCore[1]= pXKB[1];
-            for (n=2;n<groupWidth;n++)
-                pCore[2+n]= pXKB[n];
-            if (groupWidth>2)
-                nOut= groupWidth;
-        }
-
-	/* See XKB Protocol Sec, Section 12.4.
+    for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
+        KeySym *pCore, *pXKB;
+        unsigned nGroups, groupWidth, n, nOut;
+
+        nGroups = XkbKeyNumGroups(xkb, key);
+        n = (key - xkb->min_key_code) * syms->mapWidth;
+        pCore = &syms->map[n];
+        pXKB = XkbKeySymsPtr(xkb, key);
+        nOut = 2;
+        if (nGroups > 0) {
+            groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
+            if (groupWidth > 0)
+                pCore[0] = pXKB[0];
+            if (groupWidth > 1)
+                pCore[1] = pXKB[1];
+            for (n = 2; n < groupWidth; n++)
+                pCore[2 + n] = pXKB[n];
+            if (groupWidth > 2)
+                nOut = groupWidth;
+        }
+
+        /* See XKB Protocol Sec, Section 12.4.
            A 1-group key with ABCDE on a 2 group keyboard must be
-	   duplicated across all groups as ABABCDECDE.
-	 */
-	if (nGroups == 1)
-	{
-	    int idx, j;
-
-	    groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
-
-	    /* AB..CDE... -> ABABCDE... */
-	    if (groupWidth > 0 && syms->mapWidth >= 3)
-	        pCore[2] = pCore[0];
-	    if (groupWidth > 1 && syms->mapWidth >= 4)
-	        pCore[3] = pCore[1];
-
-	    /* ABABCDE... -> ABABCDECDE */
-	    idx = 2 + groupWidth;
-	    while (groupWidth > 2 && idx < syms->mapWidth &&
-		   idx < groupWidth * 2)
-	    {
-		pCore[idx] = pCore[idx - groupWidth + 2];
-		idx++;
-	    }
-	    idx = 2 * groupWidth;
-	    if (idx < 4)
-		idx = 4;
-	    /* 3 or more groups: ABABCDECDEABCDEABCDE */
-	    for (j = 3; j <= maxNumberOfGroups; j++)
-		for (n = 0; n < groupWidth && idx < maxSymsPerKey; n++)
-		    pCore[idx++] = pXKB[n];
-	}
-
-	pXKB+= XkbKeyGroupsWidth(xkb,key);
-	nOut+= 2;
-	if (nGroups>1) {
-	    groupWidth= XkbKeyGroupWidth(xkb,key,XkbGroup2Index);
-	    if (groupWidth>0)	pCore[2]= pXKB[0];
-	    if (groupWidth>1)	pCore[3]= pXKB[1];
-	    for (n=2;n<groupWidth;n++) {
-		pCore[nOut+(n-2)]= pXKB[n];
-	    }
-	    if (groupWidth>2)
-		nOut+= (groupWidth-2);
-	}
-	pXKB+= XkbKeyGroupsWidth(xkb,key);
-	for (n=XkbGroup3Index;n<nGroups;n++) {
-	    register int s;
-	    groupWidth= XkbKeyGroupWidth(xkb,key,n);
-	    for (s=0;s<groupWidth;s++) {
-		pCore[nOut++]= pXKB[s];
-	    }
-	    pXKB+= XkbKeyGroupsWidth(xkb,key);
-	}
+           duplicated across all groups as ABABCDECDE.
+         */
+        if (nGroups == 1) {
+            int idx, j;
+
+            groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index);
+
+            /* AB..CDE... -> ABABCDE... */
+            if (groupWidth > 0 && syms->mapWidth >= 3)
+                pCore[2] = pCore[0];
+            if (groupWidth > 1 && syms->mapWidth >= 4)
+                pCore[3] = pCore[1];
+
+            /* ABABCDE... -> ABABCDECDE */
+            idx = 2 + groupWidth;
+            while (groupWidth > 2 && idx < syms->mapWidth &&
+                   idx < groupWidth * 2) {
+                pCore[idx] = pCore[idx - groupWidth + 2];
+                idx++;
+            }
+            idx = 2 * groupWidth;
+            if (idx < 4)
+                idx = 4;
+            /* 3 or more groups: ABABCDECDEABCDEABCDE */
+            for (j = 3; j <= maxNumberOfGroups; j++)
+                for (n = 0; n < groupWidth && idx < maxSymsPerKey; n++)
+                    pCore[idx++] = pXKB[n];
+        }
+
+        pXKB += XkbKeyGroupsWidth(xkb, key);
+        nOut += 2;
+        if (nGroups > 1) {
+            groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup2Index);
+            if (groupWidth > 0)
+                pCore[2] = pXKB[0];
+            if (groupWidth > 1)
+                pCore[3] = pXKB[1];
+            for (n = 2; n < groupWidth; n++) {
+                pCore[nOut + (n - 2)] = pXKB[n];
+            }
+            if (groupWidth > 2)
+                nOut += (groupWidth - 2);
+        }
+        pXKB += XkbKeyGroupsWidth(xkb, key);
+        for (n = XkbGroup3Index; n < nGroups; n++) {
+            register int s;
+
+            groupWidth = XkbKeyGroupWidth(xkb, key, n);
+            for (s = 0; s < groupWidth; s++) {
+                pCore[nOut++] = pXKB[s];
+            }
+            pXKB += XkbKeyGroupsWidth(xkb, key);
+        }
     }
 
     return syms;
 }
 
 void
-XkbSetRepeatKeys(DeviceIntPtr pXDev,int key,int onoff)
+XkbSetRepeatKeys(DeviceIntPtr pXDev, int key, int onoff)
 {
     if (pXDev && pXDev->key && pXDev->key->xkbInfo) {
-	xkbControlsNotify	cn;
-	XkbControlsPtr		ctrls = pXDev->key->xkbInfo->desc->ctrls;
-	XkbControlsRec 		old;
-	old = *ctrls;
-
-	if (key== -1) {	/* global autorepeat setting changed */
-	    if (onoff)	ctrls->enabled_ctrls |= XkbRepeatKeysMask;
-	    else	ctrls->enabled_ctrls &= ~XkbRepeatKeysMask;
-	}
-	else if (pXDev->kbdfeed) {
-	    ctrls->per_key_repeat[key/8] = 
-		pXDev->kbdfeed->ctrl.autoRepeats[key/8];
-	}
-	
-	if (XkbComputeControlsNotify(pXDev,&old,ctrls,&cn,TRUE))
-	    XkbSendControlsNotify(pXDev,&cn);
+        xkbControlsNotify cn;
+        XkbControlsPtr ctrls = pXDev->key->xkbInfo->desc->ctrls;
+        XkbControlsRec old;
+
+        old = *ctrls;
+
+        if (key == -1) {        /* global autorepeat setting changed */
+            if (onoff)
+                ctrls->enabled_ctrls |= XkbRepeatKeysMask;
+            else
+                ctrls->enabled_ctrls &= ~XkbRepeatKeysMask;
+        }
+        else if (pXDev->kbdfeed) {
+            ctrls->per_key_repeat[key / 8] =
+                pXDev->kbdfeed->ctrl.autoRepeats[key / 8];
+        }
+
+        if (XkbComputeControlsNotify(pXDev, &old, ctrls, &cn, TRUE))
+            XkbSendControlsNotify(pXDev, &cn);
     }
     return;
 }
@@ -566,7 +575,7 @@ XkbApplyMappingChange(DeviceIntPtr kbd, KeySymsPtr map, KeyCode first_key,
         /* A keymap change can imply a modmap change, se we prefer the
          * former. */
         if (!cause.mjr)
-            XkbSetCauseCoreReq(&cause,X_SetModifierMapping,client);
+            XkbSetCauseCoreReq(&cause, X_SetModifierMapping, client);
 
         check = 0;
         num_keys = xkb->max_key_code - xkb->min_key_code + 1;
@@ -585,102 +594,110 @@ XkbApplyMappingChange(DeviceIntPtr kbd, KeySymsPtr map, KeyCode first_key,
 }
 
 void
-XkbDisableComputedAutoRepeats(DeviceIntPtr dev,unsigned key)
+XkbDisableComputedAutoRepeats(DeviceIntPtr dev, unsigned key)
 {
-XkbSrvInfoPtr	xkbi = dev->key->xkbInfo;
-xkbMapNotify	mn;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    xkbMapNotify mn;
 
-    xkbi->desc->server->explicit[key]|= XkbExplicitAutoRepeatMask;
+    xkbi->desc->server->explicit[key] |= XkbExplicitAutoRepeatMask;
     memset(&mn, 0, sizeof(mn));
-    mn.changed= XkbExplicitComponentsMask;
-    mn.firstKeyExplicit= key;
-    mn.nKeyExplicit= 1;
-    XkbSendMapNotify(dev,&mn);
+    mn.changed = XkbExplicitComponentsMask;
+    mn.firstKeyExplicit = key;
+    mn.nKeyExplicit = 1;
+    XkbSendMapNotify(dev, &mn);
     return;
 }
 
 unsigned
-XkbStateChangedFlags(XkbStatePtr old,XkbStatePtr new)
+XkbStateChangedFlags(XkbStatePtr old, XkbStatePtr new)
 {
-int		changed;
-
-    changed=(old->group!=new->group?XkbGroupStateMask:0);
-    changed|=(old->base_group!=new->base_group?XkbGroupBaseMask:0);
-    changed|=(old->latched_group!=new->latched_group?XkbGroupLatchMask:0);
-    changed|=(old->locked_group!=new->locked_group?XkbGroupLockMask:0);
-    changed|=(old->mods!=new->mods?XkbModifierStateMask:0);
-    changed|=(old->base_mods!=new->base_mods?XkbModifierBaseMask:0);
-    changed|=(old->latched_mods!=new->latched_mods?XkbModifierLatchMask:0);
-    changed|=(old->locked_mods!=new->locked_mods?XkbModifierLockMask:0);
-    changed|=(old->compat_state!=new->compat_state?XkbCompatStateMask:0);
-    changed|=(old->grab_mods!=new->grab_mods?XkbGrabModsMask:0);
-    if (old->compat_grab_mods!=new->compat_grab_mods)
-	changed|= XkbCompatGrabModsMask;
-    changed|=(old->lookup_mods!=new->lookup_mods?XkbLookupModsMask:0);
-    if (old->compat_lookup_mods!=new->compat_lookup_mods)
-	changed|= XkbCompatLookupModsMask;
-    changed|=(old->ptr_buttons!=new->ptr_buttons?XkbPointerButtonMask:0);
+    int changed;
+
+    changed = (old->group != new->group ? XkbGroupStateMask : 0);
+    changed |= (old->base_group != new->base_group ? XkbGroupBaseMask : 0);
+    changed |=
+        (old->latched_group != new->latched_group ? XkbGroupLatchMask : 0);
+    changed |= (old->locked_group != new->locked_group ? XkbGroupLockMask : 0);
+    changed |= (old->mods != new->mods ? XkbModifierStateMask : 0);
+    changed |= (old->base_mods != new->base_mods ? XkbModifierBaseMask : 0);
+    changed |=
+        (old->latched_mods != new->latched_mods ? XkbModifierLatchMask : 0);
+    changed |= (old->locked_mods != new->locked_mods ? XkbModifierLockMask : 0);
+    changed |=
+        (old->compat_state != new->compat_state ? XkbCompatStateMask : 0);
+    changed |= (old->grab_mods != new->grab_mods ? XkbGrabModsMask : 0);
+    if (old->compat_grab_mods != new->compat_grab_mods)
+        changed |= XkbCompatGrabModsMask;
+    changed |= (old->lookup_mods != new->lookup_mods ? XkbLookupModsMask : 0);
+    if (old->compat_lookup_mods != new->compat_lookup_mods)
+        changed |= XkbCompatLookupModsMask;
+    changed |=
+        (old->ptr_buttons != new->ptr_buttons ? XkbPointerButtonMask : 0);
     return changed;
 }
 
 static void
 XkbComputeCompatState(XkbSrvInfoPtr xkbi)
 {
-CARD16 		grp_mask;
-XkbStatePtr	state= &xkbi->state;
-XkbCompatMapPtr	map;
+    CARD16 grp_mask;
+    XkbStatePtr state = &xkbi->state;
+    XkbCompatMapPtr map;
 
     if (!state || !xkbi->desc || !xkbi->desc->ctrls || !xkbi->desc->compat)
         return;
 
-    map= xkbi->desc->compat;
-    grp_mask= map->groups[state->group].mask;
-    state->compat_state = state->mods|grp_mask;
-    state->compat_lookup_mods= state->lookup_mods|grp_mask;
+    map = xkbi->desc->compat;
+    grp_mask = map->groups[state->group].mask;
+    state->compat_state = state->mods | grp_mask;
+    state->compat_lookup_mods = state->lookup_mods | grp_mask;
 
-    if (xkbi->desc->ctrls->enabled_ctrls&XkbIgnoreGroupLockMask)
-	 grp_mask= map->groups[state->base_group].mask;
-    state->compat_grab_mods= state->grab_mods|grp_mask;
+    if (xkbi->desc->ctrls->enabled_ctrls & XkbIgnoreGroupLockMask)
+        grp_mask = map->groups[state->base_group].mask;
+    state->compat_grab_mods = state->grab_mods | grp_mask;
     return;
 }
 
 unsigned
-XkbAdjustGroup(int group,XkbControlsPtr ctrls)
+XkbAdjustGroup(int group, XkbControlsPtr ctrls)
 {
-unsigned	act;
-
-    act= XkbOutOfRangeGroupAction(ctrls->groups_wrap);
-    if (group<0) {
-	while ( group < 0 )  {
-	    if (act==XkbClampIntoRange) {
-		group= XkbGroup1Index;
-	    }
-	    else if (act==XkbRedirectIntoRange) {
-		int newGroup;
-		newGroup= XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
-		if (newGroup>=ctrls->num_groups)
-		     group= XkbGroup1Index;
-		else group= newGroup;
-	    }
-	    else {
-		group+= ctrls->num_groups;
-	    }
-	}
+    unsigned act;
+
+    act = XkbOutOfRangeGroupAction(ctrls->groups_wrap);
+    if (group < 0) {
+        while (group < 0) {
+            if (act == XkbClampIntoRange) {
+                group = XkbGroup1Index;
+            }
+            else if (act == XkbRedirectIntoRange) {
+                int newGroup;
+
+                newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
+                if (newGroup >= ctrls->num_groups)
+                    group = XkbGroup1Index;
+                else
+                    group = newGroup;
+            }
+            else {
+                group += ctrls->num_groups;
+            }
+        }
     }
-    else if (group>=ctrls->num_groups) {
-	if (act==XkbClampIntoRange) {
-	    group= ctrls->num_groups-1;
-	}
-	else if (act==XkbRedirectIntoRange) {
-	    int newGroup;
-	    newGroup= XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
-	    if (newGroup>=ctrls->num_groups)
-		 group= XkbGroup1Index;
-	    else group= newGroup;
-	}
-	else {
-	    group%= ctrls->num_groups;
-	}
+    else if (group >= ctrls->num_groups) {
+        if (act == XkbClampIntoRange) {
+            group = ctrls->num_groups - 1;
+        }
+        else if (act == XkbRedirectIntoRange) {
+            int newGroup;
+
+            newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap);
+            if (newGroup >= ctrls->num_groups)
+                group = XkbGroup1Index;
+            else
+                group = newGroup;
+        }
+        else {
+            group %= ctrls->num_groups;
+        }
     }
     return group;
 }
@@ -688,28 +705,28 @@ unsigned	act;
 void
 XkbComputeDerivedState(XkbSrvInfoPtr xkbi)
 {
-XkbStatePtr	state= &xkbi->state;
-XkbControlsPtr	ctrls= xkbi->desc->ctrls;
-unsigned char	grp;
+    XkbStatePtr state = &xkbi->state;
+    XkbControlsPtr ctrls = xkbi->desc->ctrls;
+    unsigned char grp;
 
     if (!state || !ctrls)
         return;
 
-    state->mods= (state->base_mods|state->latched_mods|state->locked_mods);
-    state->lookup_mods= state->mods&(~ctrls->internal.mask);
-    state->grab_mods= state->lookup_mods&(~ctrls->ignore_lock.mask);
-    state->grab_mods|= 
-	((state->base_mods|state->latched_mods)&ctrls->ignore_lock.mask);
-
+    state->mods = (state->base_mods | state->latched_mods | state->locked_mods);
+    state->lookup_mods = state->mods & (~ctrls->internal.mask);
+    state->grab_mods = state->lookup_mods & (~ctrls->ignore_lock.mask);
+    state->grab_mods |=
+        ((state->base_mods | state->latched_mods) & ctrls->ignore_lock.mask);
 
-    grp= state->locked_group;
-    if (grp>=ctrls->num_groups)
-	state->locked_group= XkbAdjustGroup(XkbCharToInt(grp),ctrls);
+    grp = state->locked_group;
+    if (grp >= ctrls->num_groups)
+        state->locked_group = XkbAdjustGroup(XkbCharToInt(grp), ctrls);
 
-    grp= state->locked_group+state->base_group+state->latched_group;
-    if (grp>=ctrls->num_groups)
-	 state->group= XkbAdjustGroup(XkbCharToInt(grp),ctrls);
-    else state->group= grp;
+    grp = state->locked_group + state->base_group + state->latched_group;
+    if (grp >= ctrls->num_groups)
+        state->group = XkbAdjustGroup(XkbCharToInt(grp), ctrls);
+    else
+        state->group = grp;
     XkbComputeCompatState(xkbi);
     return;
 }
@@ -717,67 +734,68 @@ unsigned char	grp;
 /***====================================================================***/
 
 void
-XkbCheckSecondaryEffects(	XkbSrvInfoPtr		xkbi,
-				unsigned		which,
-				XkbChangesPtr 		changes,
-				XkbEventCausePtr	cause)
+XkbCheckSecondaryEffects(XkbSrvInfoPtr xkbi,
+                         unsigned which,
+                         XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-    if (which&XkbStateNotifyMask) {
-	XkbStateRec old;
-	old= xkbi->state;
-	changes->state_changes|= XkbStateChangedFlags(&old,&xkbi->state);
-	XkbComputeDerivedState(xkbi);
+    if (which & XkbStateNotifyMask) {
+        XkbStateRec old;
+
+        old = xkbi->state;
+        changes->state_changes |= XkbStateChangedFlags(&old, &xkbi->state);
+        XkbComputeDerivedState(xkbi);
     }
-    if (which&XkbIndicatorStateNotifyMask)
-	XkbUpdateIndicators(xkbi->device,XkbAllIndicatorsMask,TRUE,changes,
-									cause);
+    if (which & XkbIndicatorStateNotifyMask)
+        XkbUpdateIndicators(xkbi->device, XkbAllIndicatorsMask, TRUE, changes,
+                            cause);
     return;
 }
 
 /***====================================================================***/
 
 Bool
-XkbEnableDisableControls(	XkbSrvInfoPtr		xkbi,
-				unsigned long		change,
-				unsigned long		newValues,
-				XkbChangesPtr		changes,
-				XkbEventCausePtr	cause)
+XkbEnableDisableControls(XkbSrvInfoPtr xkbi,
+                         unsigned long change,
+                         unsigned long newValues,
+                         XkbChangesPtr changes, XkbEventCausePtr cause)
 {
-XkbControlsPtr		ctrls;
-unsigned 		old;
-XkbSrvLedInfoPtr	sli;
-
-    ctrls= xkbi->desc->ctrls;
-    old= ctrls->enabled_ctrls;
-    ctrls->enabled_ctrls&= ~change;
-    ctrls->enabled_ctrls|= (change&newValues);
-    if (old==ctrls->enabled_ctrls)
-	return FALSE;
-    if (cause!=NULL) {
-	xkbControlsNotify cn;
-	cn.numGroups= ctrls->num_groups;
-	cn.changedControls= XkbControlsEnabledMask;
-	cn.enabledControls= ctrls->enabled_ctrls;
-	cn.enabledControlChanges= (ctrls->enabled_ctrls^old);
-	cn.keycode= cause->kc;
-	cn.eventType= cause->event;
-	cn.requestMajor= cause->mjr;
-	cn.requestMinor= cause->mnr;
-	XkbSendControlsNotify(xkbi->device,&cn);
+    XkbControlsPtr ctrls;
+    unsigned old;
+    XkbSrvLedInfoPtr sli;
+
+    ctrls = xkbi->desc->ctrls;
+    old = ctrls->enabled_ctrls;
+    ctrls->enabled_ctrls &= ~change;
+    ctrls->enabled_ctrls |= (change & newValues);
+    if (old == ctrls->enabled_ctrls)
+        return FALSE;
+    if (cause != NULL) {
+        xkbControlsNotify cn;
+
+        cn.numGroups = ctrls->num_groups;
+        cn.changedControls = XkbControlsEnabledMask;
+        cn.enabledControls = ctrls->enabled_ctrls;
+        cn.enabledControlChanges = (ctrls->enabled_ctrls ^ old);
+        cn.keycode = cause->kc;
+        cn.eventType = cause->event;
+        cn.requestMajor = cause->mjr;
+        cn.requestMinor = cause->mnr;
+        XkbSendControlsNotify(xkbi->device, &cn);
     }
     else {
-	/* Yes, this really should be an XOR.  If ctrls->enabled_ctrls_changes*/
-	/* is non-zero, the controls in question changed already in "this" */
-	/* request and this change merely undoes the previous one.  By the */
-	/* same token, we have to figure out whether or not ControlsEnabled */
-	/* should be set or not in the changes structure */
-	changes->ctrls.enabled_ctrls_changes^= (ctrls->enabled_ctrls^old);
-	if (changes->ctrls.enabled_ctrls_changes)
-	     changes->ctrls.changed_ctrls|= XkbControlsEnabledMask;
-	else changes->ctrls.changed_ctrls&= ~XkbControlsEnabledMask;
+        /* Yes, this really should be an XOR.  If ctrls->enabled_ctrls_changes */
+        /* is non-zero, the controls in question changed already in "this" */
+        /* request and this change merely undoes the previous one.  By the */
+        /* same token, we have to figure out whether or not ControlsEnabled */
+        /* should be set or not in the changes structure */
+        changes->ctrls.enabled_ctrls_changes ^= (ctrls->enabled_ctrls ^ old);
+        if (changes->ctrls.enabled_ctrls_changes)
+            changes->ctrls.changed_ctrls |= XkbControlsEnabledMask;
+        else
+            changes->ctrls.changed_ctrls &= ~XkbControlsEnabledMask;
     }
-    sli= XkbFindSrvLedInfo(xkbi->device,XkbDfltXIClass,XkbDfltXIId,0);
-    XkbUpdateIndicators(xkbi->device,sli->usesControls,TRUE,changes,cause);
+    sli = XkbFindSrvLedInfo(xkbi->device, XkbDfltXIClass, XkbDfltXIId, 0);
+    XkbUpdateIndicators(xkbi->device, sli->usesControls, TRUE, changes, cause);
     return TRUE;
 }
 
@@ -786,120 +804,120 @@ XkbSrvLedInfoPtr	sli;
 #define	MAX_TOC	16
 
 XkbGeometryPtr
-XkbLookupNamedGeometry(DeviceIntPtr dev,Atom name,Bool *shouldFree)
+XkbLookupNamedGeometry(DeviceIntPtr dev, Atom name, Bool *shouldFree)
 {
-XkbSrvInfoPtr	xkbi=	dev->key->xkbInfo;
-XkbDescPtr	xkb=	xkbi->desc;
-
-    *shouldFree= 0;
-    if (name==None) {
-	if (xkb->geom!=NULL)
-	    return xkb->geom;
-	name= xkb->names->geometry;
+    XkbSrvInfoPtr xkbi = dev->key->xkbInfo;
+    XkbDescPtr xkb = xkbi->desc;
+
+    *shouldFree = 0;
+    if (name == None) {
+        if (xkb->geom != NULL)
+            return xkb->geom;
+        name = xkb->names->geometry;
     }
-    if ((xkb->geom!=NULL)&&(xkb->geom->name==name))
-	return xkb->geom;
-    *shouldFree= 1;
+    if ((xkb->geom != NULL) && (xkb->geom->name == name))
+        return xkb->geom;
+    *shouldFree = 1;
     return NULL;
 }
 
 void
-XkbConvertCase(register KeySym sym, KeySym *lower, KeySym *upper)
+XkbConvertCase(register KeySym sym, KeySym * lower, KeySym * upper)
 {
     *lower = sym;
     *upper = sym;
-    switch(sym >> 8) {
-    case 0: /* Latin 1 */
-	if ((sym >= XK_A) && (sym <= XK_Z))
-	    *lower += (XK_a - XK_A);
-	else if ((sym >= XK_a) && (sym <= XK_z))
-	    *upper -= (XK_a - XK_A);
-	else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
-	    *lower += (XK_agrave - XK_Agrave);
-	else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
-	    *upper -= (XK_agrave - XK_Agrave);
-	else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
-	    *lower += (XK_oslash - XK_Ooblique);
-	else if ((sym >= XK_oslash) && (sym <= XK_thorn))
-	    *upper -= (XK_oslash - XK_Ooblique);
-	break;
-    case 1: /* Latin 2 */
-	/* Assume the KeySym is a legal value (ignore discontinuities) */
-	if (sym == XK_Aogonek)
-	    *lower = XK_aogonek;
-	else if (sym >= XK_Lstroke && sym <= XK_Sacute)
-	    *lower += (XK_lstroke - XK_Lstroke);
-	else if (sym >= XK_Scaron && sym <= XK_Zacute)
-	    *lower += (XK_scaron - XK_Scaron);
-	else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
-	    *lower += (XK_zcaron - XK_Zcaron);
-	else if (sym == XK_aogonek)
-	    *upper = XK_Aogonek;
-	else if (sym >= XK_lstroke && sym <= XK_sacute)
-	    *upper -= (XK_lstroke - XK_Lstroke);
-	else if (sym >= XK_scaron && sym <= XK_zacute)
-	    *upper -= (XK_scaron - XK_Scaron);
-	else if (sym >= XK_zcaron && sym <= XK_zabovedot)
-	    *upper -= (XK_zcaron - XK_Zcaron);
-	else if (sym >= XK_Racute && sym <= XK_Tcedilla)
-	    *lower += (XK_racute - XK_Racute);
-	else if (sym >= XK_racute && sym <= XK_tcedilla)
-	    *upper -= (XK_racute - XK_Racute);
-	break;
-    case 2: /* Latin 3 */
-	/* Assume the KeySym is a legal value (ignore discontinuities) */
-	if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
-	    *lower += (XK_hstroke - XK_Hstroke);
-	else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
-	    *lower += (XK_gbreve - XK_Gbreve);
-	else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
-	    *upper -= (XK_hstroke - XK_Hstroke);
-	else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
-	    *upper -= (XK_gbreve - XK_Gbreve);
-	else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
-	    *lower += (XK_cabovedot - XK_Cabovedot);
-	else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
-	    *upper -= (XK_cabovedot - XK_Cabovedot);
-	break;
-    case 3: /* Latin 4 */
-	/* Assume the KeySym is a legal value (ignore discontinuities) */
-	if (sym >= XK_Rcedilla && sym <= XK_Tslash)
-	    *lower += (XK_rcedilla - XK_Rcedilla);
-	else if (sym >= XK_rcedilla && sym <= XK_tslash)
-	    *upper -= (XK_rcedilla - XK_Rcedilla);
-	else if (sym == XK_ENG)
-	    *lower = XK_eng;
-	else if (sym == XK_eng)
-	    *upper = XK_ENG;
-	else if (sym >= XK_Amacron && sym <= XK_Umacron)
-	    *lower += (XK_amacron - XK_Amacron);
-	else if (sym >= XK_amacron && sym <= XK_umacron)
-	    *upper -= (XK_amacron - XK_Amacron);
-	break;
-    case 6: /* Cyrillic */
-	/* Assume the KeySym is a legal value (ignore discontinuities) */
-	if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
-	    *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
-	else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
-	    *upper += (XK_Serbian_DJE - XK_Serbian_dje);
-	else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
-	    *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
-	else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
-	    *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+    switch (sym >> 8) {
+    case 0:                    /* Latin 1 */
+        if ((sym >= XK_A) && (sym <= XK_Z))
+            *lower += (XK_a - XK_A);
+        else if ((sym >= XK_a) && (sym <= XK_z))
+            *upper -= (XK_a - XK_A);
+        else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
+            *lower += (XK_agrave - XK_Agrave);
+        else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
+            *upper -= (XK_agrave - XK_Agrave);
+        else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
+            *lower += (XK_oslash - XK_Ooblique);
+        else if ((sym >= XK_oslash) && (sym <= XK_thorn))
+            *upper -= (XK_oslash - XK_Ooblique);
+        break;
+    case 1:                    /* Latin 2 */
+        /* Assume the KeySym is a legal value (ignore discontinuities) */
+        if (sym == XK_Aogonek)
+            *lower = XK_aogonek;
+        else if (sym >= XK_Lstroke && sym <= XK_Sacute)
+            *lower += (XK_lstroke - XK_Lstroke);
+        else if (sym >= XK_Scaron && sym <= XK_Zacute)
+            *lower += (XK_scaron - XK_Scaron);
+        else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
+            *lower += (XK_zcaron - XK_Zcaron);
+        else if (sym == XK_aogonek)
+            *upper = XK_Aogonek;
+        else if (sym >= XK_lstroke && sym <= XK_sacute)
+            *upper -= (XK_lstroke - XK_Lstroke);
+        else if (sym >= XK_scaron && sym <= XK_zacute)
+            *upper -= (XK_scaron - XK_Scaron);
+        else if (sym >= XK_zcaron && sym <= XK_zabovedot)
+            *upper -= (XK_zcaron - XK_Zcaron);
+        else if (sym >= XK_Racute && sym <= XK_Tcedilla)
+            *lower += (XK_racute - XK_Racute);
+        else if (sym >= XK_racute && sym <= XK_tcedilla)
+            *upper -= (XK_racute - XK_Racute);
+        break;
+    case 2:                    /* Latin 3 */
+        /* Assume the KeySym is a legal value (ignore discontinuities) */
+        if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
+            *lower += (XK_hstroke - XK_Hstroke);
+        else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
+            *lower += (XK_gbreve - XK_Gbreve);
+        else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
+            *upper -= (XK_hstroke - XK_Hstroke);
+        else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
+            *upper -= (XK_gbreve - XK_Gbreve);
+        else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
+            *lower += (XK_cabovedot - XK_Cabovedot);
+        else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
+            *upper -= (XK_cabovedot - XK_Cabovedot);
+        break;
+    case 3:                    /* Latin 4 */
+        /* Assume the KeySym is a legal value (ignore discontinuities) */
+        if (sym >= XK_Rcedilla && sym <= XK_Tslash)
+            *lower += (XK_rcedilla - XK_Rcedilla);
+        else if (sym >= XK_rcedilla && sym <= XK_tslash)
+            *upper -= (XK_rcedilla - XK_Rcedilla);
+        else if (sym == XK_ENG)
+            *lower = XK_eng;
+        else if (sym == XK_eng)
+            *upper = XK_ENG;
+        else if (sym >= XK_Amacron && sym <= XK_Umacron)
+            *lower += (XK_amacron - XK_Amacron);
+        else if (sym >= XK_amacron && sym <= XK_umacron)
+            *upper -= (XK_amacron - XK_Amacron);
         break;
-    case 7: /* Greek */
-	/* Assume the KeySym is a legal value (ignore discontinuities) */
-	if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
-	    *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
-	else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
-		 sym != XK_Greek_iotaaccentdieresis &&
-		 sym != XK_Greek_upsilonaccentdieresis)
-	    *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
-	else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
-	    *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
-	else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
-		 sym != XK_Greek_finalsmallsigma)
-	    *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
+    case 6:                    /* Cyrillic */
+        /* Assume the KeySym is a legal value (ignore discontinuities) */
+        if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
+            *lower -= (XK_Serbian_DJE - XK_Serbian_dje);
+        else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
+            *upper += (XK_Serbian_DJE - XK_Serbian_dje);
+        else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
+            *lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
+        else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
+            *upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+        break;
+    case 7:                    /* Greek */
+        /* Assume the KeySym is a legal value (ignore discontinuities) */
+        if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
+            *lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+        else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
+                 sym != XK_Greek_iotaaccentdieresis &&
+                 sym != XK_Greek_upsilonaccentdieresis)
+            *upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+        else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
+            *lower += (XK_Greek_alpha - XK_Greek_ALPHA);
+        else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
+                 sym != XK_Greek_finalsmallsigma)
+            *upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
         break;
     }
 }
@@ -960,13 +978,13 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
                 !dst->map->types || !dst->map->size_types) {
                 if (dst->map->types && dst->map->size_types) {
                     tmp = realloc(dst->map->types,
-                                   src->map->num_types * sizeof(XkbKeyTypeRec));
+                                  src->map->num_types * sizeof(XkbKeyTypeRec));
                     if (!tmp)
                         return FALSE;
                     dst->map->types = tmp;
                     memset(dst->map->types + dst->map->num_types, 0,
-                          (src->map->num_types - dst->map->num_types) *
-                            sizeof(XkbKeyTypeRec));
+                           (src->map->num_types - dst->map->num_types) *
+                           sizeof(XkbKeyTypeRec));
                 }
                 else {
                     tmp = calloc(src->map->num_types, sizeof(XkbKeyTypeRec));
@@ -997,7 +1015,7 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
                         dtype->num_levels && dtype->level_names &&
                         i < dst->map->num_types) {
                         tmp = realloc(dtype->level_names,
-                                       stype->num_levels * sizeof(Atom));
+                                      stype->num_levels * sizeof(Atom));
                         if (!tmp)
                             continue;
                         dtype->level_names = tmp;
@@ -1030,8 +1048,8 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
                             dtype->map_count && dtype->map &&
                             i < dst->map->num_types) {
                             tmp = realloc(dtype->map,
-                                           stype->map_count *
-                                             sizeof(XkbKTMapEntryRec));
+                                          stype->map_count *
+                                          sizeof(XkbKTMapEntryRec));
                             if (!tmp)
                                 return FALSE;
                             dtype->map = tmp;
@@ -1039,7 +1057,7 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
                         else if (!dtype->map_count || !dtype->map ||
                                  i >= dst->map->num_types) {
                             tmp = malloc(stype->map_count *
-                                           sizeof(XkbKTMapEntryRec));
+                                         sizeof(XkbKTMapEntryRec));
                             if (!tmp)
                                 return FALSE;
                             dtype->map = tmp;
@@ -1059,16 +1077,15 @@ _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst)
                             dtype->map_count && dtype->preserve &&
                             i < dst->map->num_types) {
                             tmp = realloc(dtype->preserve,
-                                           stype->map_count *
-                                             sizeof(XkbModsRec));
+                                          stype->map_count *
+                                          sizeof(XkbModsRec));
                             if (!tmp)
                                 return FALSE;
                             dtype->preserve = tmp;
                         }
                         else if (!dtype->preserve || !dtype->map_count ||
                                  i >= dst->map->num_types) {
-                            tmp = malloc(stype->map_count *
-                                         sizeof(XkbModsRec));
+                            tmp = malloc(stype->map_count * sizeof(XkbModsRec));
                             if (!tmp)
                                 return FALSE;
                             dtype->preserve = tmp;
@@ -1182,8 +1199,8 @@ _XkbCopyServerMap(XkbDescPtr src, XkbDescPtr dst)
             free(dst->server->acts);
             dst->server->acts = NULL;
         }
-       dst->server->size_acts = src->server->size_acts;
-       dst->server->num_acts = src->server->num_acts;
+        dst->server->size_acts = src->server->size_acts;
+        dst->server->num_acts = src->server->num_acts;
 
         if (src->server->key_acts) {
             if (src->max_key_code != dst->max_key_code) {
@@ -1402,8 +1419,8 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
              * the source, run through and free all the excess ones
              * first. */
             if (src->geom->num_properties < dst->geom->sz_properties) {
-                for (i = src->geom->num_properties, dprop = dst->geom->properties + i;
-                     i < dst->geom->num_properties;
+                for (i = src->geom->num_properties, dprop =
+                     dst->geom->properties + i; i < dst->geom->num_properties;
                      i++, dprop++) {
                     free(dprop->name);
                     free(dprop->value);
@@ -1411,18 +1428,19 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
             }
 
             /* Reallocate and clear all new items if the buffer grows. */
-            if (!XkbGeomRealloc((void **)&dst->geom->properties, dst->geom->sz_properties, src->geom->num_properties,
-                                sizeof(XkbPropertyRec), XKB_GEOM_CLEAR_EXCESS))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->properties, dst->geom->sz_properties,
+                 src->geom->num_properties, sizeof(XkbPropertyRec),
+                 XKB_GEOM_CLEAR_EXCESS))
                 return FALSE;
             /* We don't set num_properties as we need it to try and avoid
              * too much reallocing. */
             dst->geom->sz_properties = src->geom->num_properties;
 
             for (i = 0,
-                  sprop = src->geom->properties,
-                  dprop = dst->geom->properties;
-                 i < src->geom->num_properties;
-                 i++, sprop++, dprop++) {
+                 sprop = src->geom->properties,
+                 dprop = dst->geom->properties;
+                 i < src->geom->num_properties; i++, sprop++, dprop++) {
                 if (i < dst->geom->num_properties) {
                     if (strlen(sprop->name) != strlen(dprop->name)) {
                         tmp = realloc(dprop->name, strlen(sprop->name) + 1);
@@ -1451,8 +1469,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         else {
             if (dst->geom->sz_properties) {
                 for (i = 0, dprop = dst->geom->properties;
-                     i < dst->geom->num_properties;
-                     i++, dprop++) {
+                     i < dst->geom->num_properties; i++, dprop++) {
                     free(dprop->name);
                     free(dprop->value);
                 }
@@ -1468,23 +1485,23 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         if (src->geom->num_colors) {
             if (src->geom->num_colors < dst->geom->sz_colors) {
                 for (i = src->geom->num_colors, dcolor = dst->geom->colors + i;
-                     i < dst->geom->num_colors;
-                     i++, dcolor++) {
+                     i < dst->geom->num_colors; i++, dcolor++) {
                     free(dcolor->spec);
                 }
             }
 
             /* Reallocate and clear all new items if the buffer grows. */
-            if (!XkbGeomRealloc((void **)&dst->geom->colors, dst->geom->sz_colors, src->geom->num_colors,
-                                sizeof(XkbColorRec), XKB_GEOM_CLEAR_EXCESS))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->colors, dst->geom->sz_colors,
+                 src->geom->num_colors, sizeof(XkbColorRec),
+                 XKB_GEOM_CLEAR_EXCESS))
                 return FALSE;
             dst->geom->sz_colors = src->geom->num_colors;
 
             for (i = 0,
-                  scolor = src->geom->colors,
-                  dcolor = dst->geom->colors;
-                 i < src->geom->num_colors;
-                 i++, scolor++, dcolor++) {
+                 scolor = src->geom->colors,
+                 dcolor = dst->geom->colors;
+                 i < src->geom->num_colors; i++, scolor++, dcolor++) {
                 if (i < dst->geom->num_colors) {
                     if (strlen(scolor->spec) != strlen(dcolor->spec)) {
                         tmp = realloc(dcolor->spec, strlen(scolor->spec) + 1);
@@ -1505,8 +1522,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         else {
             if (dst->geom->sz_colors) {
                 for (i = 0, dcolor = dst->geom->colors;
-                     i < dst->geom->num_colors;
-                     i++, dcolor++) {
+                     i < dst->geom->num_colors; i++, dcolor++) {
                     free(dcolor->spec);
                 }
                 free(dst->geom->colors);
@@ -1521,11 +1537,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         /* shapes break down into outlines, which break down into points. */
         if (dst->geom->num_shapes) {
             for (i = 0, dshape = dst->geom->shapes;
-                 i < dst->geom->num_shapes;
-                 i++, dshape++) {
+                 i < dst->geom->num_shapes; i++, dshape++) {
                 for (j = 0, doutline = dshape->outlines;
-                     j < dshape->num_outlines;
-                     j++, doutline++) {
+                     j < dshape->num_outlines; j++, doutline++) {
                     if (doutline->sz_points)
                         free(doutline->points);
                 }
@@ -1542,27 +1556,28 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
 
         if (src->geom->num_shapes) {
             /* Reallocate and clear all items. */
-            if (!XkbGeomRealloc((void **)&dst->geom->shapes, dst->geom->sz_shapes, src->geom->num_shapes,
-                                sizeof(XkbShapeRec), XKB_GEOM_CLEAR_ALL))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->shapes, dst->geom->sz_shapes,
+                 src->geom->num_shapes, sizeof(XkbShapeRec),
+                 XKB_GEOM_CLEAR_ALL))
                 return FALSE;
 
             for (i = 0, sshape = src->geom->shapes, dshape = dst->geom->shapes;
-                 i < src->geom->num_shapes;
-                 i++, sshape++, dshape++) {
+                 i < src->geom->num_shapes; i++, sshape++, dshape++) {
                 if (sshape->num_outlines) {
                     tmp = calloc(sshape->num_outlines, sizeof(XkbOutlineRec));
                     if (!tmp)
                         return FALSE;
                     dshape->outlines = tmp;
-                    
+
                     for (j = 0,
-                          soutline = sshape->outlines,
-                          doutline = dshape->outlines;
+                         soutline = sshape->outlines,
+                         doutline = dshape->outlines;
                          j < sshape->num_outlines;
                          j++, soutline++, doutline++) {
                         if (soutline->num_points) {
                             tmp = malloc(soutline->num_points *
-                                          sizeof(XkbPointRec));
+                                         sizeof(XkbPointRec));
                             if (!tmp)
                                 return FALSE;
                             doutline->points = tmp;
@@ -1587,13 +1602,14 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
                 if (sshape->approx && sshape->num_outlines > 0) {
 
                     const ptrdiff_t approx_idx =
-                            sshape->approx - sshape->outlines;
+                        sshape->approx - sshape->outlines;
 
                     if (approx_idx < dshape->num_outlines) {
-                            dshape->approx = dshape->outlines + approx_idx;
-                    } else {
-                            LogMessage(X_WARNING, "XKB: approx outline "
-                                            "index is out of range\n");
+                        dshape->approx = dshape->outlines + approx_idx;
+                    }
+                    else {
+                        LogMessage(X_WARNING, "XKB: approx outline "
+                                   "index is out of range\n");
                     }
                 }
 
@@ -1601,13 +1617,14 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
                 if (sshape->primary && sshape->num_outlines > 0) {
 
                     const ptrdiff_t primary_idx =
-                            sshape->primary - sshape->outlines;
+                        sshape->primary - sshape->outlines;
 
                     if (primary_idx < dshape->num_outlines) {
-                            dshape->primary = dshape->outlines + primary_idx;
-                    } else {
-                            LogMessage(X_WARNING, "XKB: primary outline "
-                                            "index is out of range\n");
+                        dshape->primary = dshape->outlines + primary_idx;
+                    }
+                    else {
+                        LogMessage(X_WARNING, "XKB: primary outline "
+                                   "index is out of range\n");
                     }
                 }
             }
@@ -1629,11 +1646,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
          * down into keys. */
         if (dst->geom->num_sections) {
             for (i = 0, dsection = dst->geom->sections;
-                 i < dst->geom->num_sections;
-                 i++, dsection++) {
+                 i < dst->geom->num_sections; i++, dsection++) {
                 for (j = 0, drow = dsection->rows;
-                     j < dsection->num_rows;
-                     j++, drow++) {
+                     j < dsection->num_rows; j++, drow++) {
                     if (drow->num_keys)
                         free(drow->keys);
                 }
@@ -1643,17 +1658,16 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
 
                 /* cut and waste from geom/doodad below. */
                 for (j = 0, ddoodad = dsection->doodads;
-                     j < dsection->num_doodads;
-                     j++, ddoodad++) {
+                     j < dsection->num_doodads; j++, ddoodad++) {
                     if (ddoodad->any.type == XkbTextDoodad) {
                         free(ddoodad->text.text);
                         ddoodad->text.text = NULL;
                         free(ddoodad->text.font);
                         ddoodad->text.font = NULL;
-                     }
-                     else if (ddoodad->any.type == XkbLogoDoodad) {
-                         free(ddoodad->logo.logo_name);
-                         ddoodad->logo.logo_name = NULL;
+                    }
+                    else if (ddoodad->any.type == XkbLogoDoodad) {
+                        free(ddoodad->logo.logo_name);
+                        ddoodad->logo.logo_name = NULL;
                     }
                 }
 
@@ -1665,17 +1679,18 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
 
         if (src->geom->num_sections) {
             /* Reallocate and clear all items. */
-            if (!XkbGeomRealloc((void **)&dst->geom->sections, dst->geom->sz_sections, src->geom->num_sections,
-                                sizeof(XkbSectionRec), XKB_GEOM_CLEAR_ALL))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->sections, dst->geom->sz_sections,
+                 src->geom->num_sections, sizeof(XkbSectionRec),
+                 XKB_GEOM_CLEAR_ALL))
                 return FALSE;
             dst->geom->num_sections = src->geom->num_sections;
             dst->geom->sz_sections = src->geom->num_sections;
 
             for (i = 0,
-                  ssection = src->geom->sections,
-                  dsection = dst->geom->sections;
-                 i < src->geom->num_sections;
-                 i++, ssection++, dsection++) {
+                 ssection = src->geom->sections,
+                 dsection = dst->geom->sections;
+                 i < src->geom->num_sections; i++, ssection++, dsection++) {
                 *dsection = *ssection;
                 if (ssection->num_rows) {
                     tmp = calloc(ssection->num_rows, sizeof(XkbRowRec));
@@ -1687,8 +1702,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
                 dsection->sz_rows = ssection->num_rows;
 
                 for (j = 0, srow = ssection->rows, drow = dsection->rows;
-                     j < ssection->num_rows;
-                     j++, srow++, drow++) {
+                     j < ssection->num_rows; j++, srow++, drow++) {
                     if (srow->num_keys) {
                         tmp = malloc(srow->num_keys * sizeof(XkbKeyRec));
                         if (!tmp)
@@ -1717,23 +1731,20 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
 
                 dsection->sz_doodads = ssection->num_doodads;
                 for (k = 0,
-                      sdoodad = ssection->doodads,
-                      ddoodad = dsection->doodads;
-                     k < ssection->num_doodads;
-                     k++, sdoodad++, ddoodad++) {
-                    memcpy(ddoodad , sdoodad, sizeof(XkbDoodadRec));
+                     sdoodad = ssection->doodads,
+                     ddoodad = dsection->doodads;
+                     k < ssection->num_doodads; k++, sdoodad++, ddoodad++) {
+                    memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec));
                     if (sdoodad->any.type == XkbTextDoodad) {
                         if (sdoodad->text.text)
-                            ddoodad->text.text =
-                             strdup(sdoodad->text.text);
+                            ddoodad->text.text = strdup(sdoodad->text.text);
                         if (sdoodad->text.font)
-                            ddoodad->text.font =
-                             strdup(sdoodad->text.font);
+                            ddoodad->text.font = strdup(sdoodad->text.font);
                     }
                     else if (sdoodad->any.type == XkbLogoDoodad) {
                         if (sdoodad->logo.logo_name)
                             ddoodad->logo.logo_name =
-                             strdup(sdoodad->logo.logo_name);
+                                strdup(sdoodad->logo.logo_name);
                     }
                 }
                 dsection->overlays = NULL;
@@ -1754,19 +1765,18 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         /* doodads */
         if (dst->geom->num_doodads) {
             for (i = src->geom->num_doodads,
-                  ddoodad = dst->geom->doodads +
-                             src->geom->num_doodads;
-                 i < dst->geom->num_doodads;
-                 i++, ddoodad++) {
-                 if (ddoodad->any.type == XkbTextDoodad) {
-                     free(ddoodad->text.text);
-                     ddoodad->text.text = NULL;
-                     free(ddoodad->text.font);
-                     ddoodad->text.font = NULL;
-                 }
-                 else if (ddoodad->any.type == XkbLogoDoodad) {
-                     free(ddoodad->logo.logo_name);
-                     ddoodad->logo.logo_name = NULL;
+                 ddoodad = dst->geom->doodads +
+                 src->geom->num_doodads;
+                 i < dst->geom->num_doodads; i++, ddoodad++) {
+                if (ddoodad->any.type == XkbTextDoodad) {
+                    free(ddoodad->text.text);
+                    ddoodad->text.text = NULL;
+                    free(ddoodad->text.font);
+                    ddoodad->text.font = NULL;
+                }
+                else if (ddoodad->any.type == XkbLogoDoodad) {
+                    free(ddoodad->logo.logo_name);
+                    ddoodad->logo.logo_name = NULL;
                 }
             }
             dst->geom->num_doodads = 0;
@@ -1774,18 +1784,19 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
 
         if (src->geom->num_doodads) {
             /* Reallocate and clear all items. */
-            if (!XkbGeomRealloc((void **)&dst->geom->doodads, dst->geom->sz_doodads, src->geom->num_doodads,
-                                sizeof(XkbDoodadRec), XKB_GEOM_CLEAR_ALL))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->doodads, dst->geom->sz_doodads,
+                 src->geom->num_doodads, sizeof(XkbDoodadRec),
+                 XKB_GEOM_CLEAR_ALL))
                 return FALSE;
 
             dst->geom->sz_doodads = src->geom->num_doodads;
 
             for (i = 0,
-                  sdoodad = src->geom->doodads,
-                  ddoodad = dst->geom->doodads;
-                 i < src->geom->num_doodads;
-                 i++, sdoodad++, ddoodad++) {
-                memcpy(ddoodad , sdoodad, sizeof(XkbDoodadRec));
+                 sdoodad = src->geom->doodads,
+                 ddoodad = dst->geom->doodads;
+                 i < src->geom->num_doodads; i++, sdoodad++, ddoodad++) {
+                memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec));
                 if (sdoodad->any.type == XkbTextDoodad) {
                     if (sdoodad->text.text)
                         ddoodad->text.text = strdup(sdoodad->text.text);
@@ -1795,7 +1806,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
                 else if (sdoodad->any.type == XkbLogoDoodad) {
                     if (sdoodad->logo.logo_name)
                         ddoodad->logo.logo_name =
-                          strdup(sdoodad->logo.logo_name);
+                            strdup(sdoodad->logo.logo_name);
                 }
             }
 
@@ -1816,8 +1827,10 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
             /* Reallocate but don't clear any items. There is no need
              * to clear anything because data is immediately copied
              * over the whole memory area with memcpy. */
-            if (!XkbGeomRealloc((void **)&dst->geom->key_aliases, dst->geom->sz_key_aliases, src->geom->num_key_aliases,
-                                2 * XkbKeyNameLength, XKB_GEOM_CLEAR_NONE))
+            if (!XkbGeomRealloc
+                ((void **) &dst->geom->key_aliases, dst->geom->sz_key_aliases,
+                 src->geom->num_key_aliases, 2 * XkbKeyNameLength,
+                 XKB_GEOM_CLEAR_NONE))
                 return FALSE;
 
             dst->geom->sz_key_aliases = src->geom->num_key_aliases;
@@ -1833,7 +1846,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
             dst->geom->num_key_aliases = 0;
             dst->geom->sz_key_aliases = 0;
         }
-        
+
         /* font */
         if (src->geom->label_font) {
             if (!dst->geom->label_font) {
@@ -1843,9 +1856,9 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
                 dst->geom->label_font = tmp;
             }
             else if (strlen(src->geom->label_font) !=
-                strlen(dst->geom->label_font)) {
+                     strlen(dst->geom->label_font)) {
                 tmp = realloc(dst->geom->label_font,
-                               strlen(src->geom->label_font) + 1);
+                              strlen(src->geom->label_font) + 1);
                 if (!tmp)
                     return FALSE;
                 dst->geom->label_font = tmp;
@@ -1868,8 +1881,7 @@ _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst)
         dst->geom->width_mm = src->geom->width_mm;
         dst->geom->height_mm = src->geom->height_mm;
     }
-    else
-    {
+    else {
         if (dst->geom) {
             /* I LOVE THE DIFFERENT CALL SIGNATURE.  REALLY, I DO. */
             XkbFreeGeometry(dst->geom, XkbGeomAllMask, TRUE);
@@ -1993,11 +2005,11 @@ XkbCopyDeviceKeymap(DeviceIntPtr dst, DeviceIntPtr src)
     nkn.oldMinKeyCode = dst->key->xkbInfo->desc->min_key_code;
     nkn.oldMaxKeyCode = dst->key->xkbInfo->desc->max_key_code;
     nkn.deviceID = dst->id;
-    nkn.oldDeviceID = dst->id; /* maybe src->id? */
+    nkn.oldDeviceID = dst->id;  /* maybe src->id? */
     nkn.minKeyCode = src->key->xkbInfo->desc->min_key_code;
     nkn.maxKeyCode = src->key->xkbInfo->desc->max_key_code;
     nkn.requestMajor = XkbReqCode;
-    nkn.requestMinor = X_kbSetMap; /* Near enough's good enough. */
+    nkn.requestMinor = X_kbSetMap;      /* Near enough's good enough. */
     nkn.changed = XkbNKN_KeycodesMask;
     if (src->key->xkbInfo->desc->geom)
         nkn.changed |= XkbNKN_GeometryMask;
@@ -2021,26 +2033,28 @@ XkbGetEffectiveGroup(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 keycode)
     if (effectiveGroup == XkbGroup1Index)
         return effectiveGroup;
 
-    if (XkbKeyNumGroups(xkb,keycode) > 1U) {
-        if (effectiveGroup >= XkbKeyNumGroups(xkb,keycode)) {
-            unsigned int gi = XkbKeyGroupInfo(xkb,keycode);
+    if (XkbKeyNumGroups(xkb, keycode) > 1U) {
+        if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode)) {
+            unsigned int gi = XkbKeyGroupInfo(xkb, keycode);
+
             switch (XkbOutOfRangeGroupAction(gi)) {
-                default:
-                case XkbWrapIntoRange:
-                    effectiveGroup %= XkbKeyNumGroups(xkb, keycode);
-                    break;
-                case XkbClampIntoRange:
-                    effectiveGroup = XkbKeyNumGroups(xkb, keycode) - 1;
-                    break;
-                case XkbRedirectIntoRange:
-                    effectiveGroup = XkbOutOfRangeGroupInfo(gi);
-                    if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode))
-                        effectiveGroup = 0;
-                    break;
+            default:
+            case XkbWrapIntoRange:
+                effectiveGroup %= XkbKeyNumGroups(xkb, keycode);
+                break;
+            case XkbClampIntoRange:
+                effectiveGroup = XkbKeyNumGroups(xkb, keycode) - 1;
+                break;
+            case XkbRedirectIntoRange:
+                effectiveGroup = XkbOutOfRangeGroupInfo(gi);
+                if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode))
+                    effectiveGroup = 0;
+                break;
             }
         }
     }
-    else effectiveGroup = XkbGroup1Index;
+    else
+        effectiveGroup = XkbGroup1Index;
 
     return effectiveGroup;
 }
diff --git a/xorg-server/xkb/xkbfmisc.c b/xorg-server/xkb/xkbfmisc.c
index 782b823bb..d96ee4b52 100644
--- a/xorg-server/xkb/xkbfmisc.c
+++ b/xorg-server/xkb/xkbfmisc.c
@@ -51,94 +51,92 @@
 unsigned
 _XkbKSCheckCase(KeySym ks)
 {
-unsigned	set,rtrn;
+    unsigned set, rtrn;
 
-    set= (ks & (~0xff)) >> 8;
-    rtrn= 0;
+    set = (ks & (~0xff)) >> 8;
+    rtrn = 0;
     switch (set) {
-	case 0:		/* latin 1 */
-	    if (((ks>=XK_A)&&(ks<=XK_Z))||
-		((ks>=XK_Agrave)&&(ks<=XK_THORN)&&(ks!=XK_multiply))) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if (((ks>=XK_a)&&(ks<=XK_z))||
-		((ks>=XK_ssharp)&&(ks<=XK_ydiaeresis)&&(ks!=XK_division))) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
-	case 1:		/* latin 2 */
-	    if (((ks>=XK_Aogonek)&&(ks<=XK_Zabovedot)&&(ks!=XK_breve))||
-		((ks>=XK_Racute)&&(ks<=XK_Tcedilla))) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if (((ks>=XK_aogonek)&&(ks<=XK_zabovedot)&&(ks!=XK_ogonek)&&(ks!=XK_caron)&&(ks!=XK_doubleacute))||
-		((ks>=XK_racute)&&(ks<=XK_tcedilla))) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
-	case 2:		/* latin 3 */
-	    if (((ks>=XK_Hstroke)&&(ks<=XK_Jcircumflex))||
-		((ks>=XK_Cabovedot)&&(ks<=XK_Scircumflex))) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if (((ks>=XK_hstroke)&&(ks<=XK_jcircumflex))||
-		((ks>=XK_cabovedot)&&(ks<=XK_scircumflex))) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
-	case 3:		/* latin 4 */
-	    if (((ks>=XK_Rcedilla)&&(ks<=XK_Tslash))||
-	        (ks==XK_ENG)||
-		((ks>=XK_Amacron)&&(ks<=XK_Umacron))) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if ((ks==XK_kra)||
-	        ((ks>=XK_rcedilla)&&(ks<=XK_tslash))||
-	        (ks==XK_eng)||
-		((ks>=XK_amacron)&&(ks<=XK_umacron))) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
-	case 18:		/* latin 8 */
-	    if ((ks==XK_Wcircumflex)||
-		(ks==XK_Ycircumflex)||
-		(ks==XK_Babovedot)||
-		(ks==XK_Dabovedot)||
-		(ks==XK_Fabovedot)||
-		(ks==XK_Mabovedot)||
-		(ks==XK_Pabovedot)||
-		(ks==XK_Sabovedot)||
-		(ks==XK_Tabovedot)||
-		(ks==XK_Wgrave)||
-		(ks==XK_Wacute)||
-		(ks==XK_Wdiaeresis)||
-		(ks==XK_Ygrave)) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if ((ks==XK_wcircumflex)||
-		(ks==XK_ycircumflex)||
-		(ks==XK_babovedot)||
-		(ks==XK_dabovedot)||
-		(ks==XK_fabovedot)||
-		(ks==XK_mabovedot)||
-		(ks==XK_pabovedot)||
-		(ks==XK_sabovedot)||
-		(ks==XK_tabovedot)||
-		(ks==XK_wgrave)||
-		(ks==XK_wacute)||
-		(ks==XK_wdiaeresis)||
-		(ks==XK_ygrave)) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
-	case 19:		/* latin 9 */
-	    if ((ks==XK_OE)||(ks==XK_Ydiaeresis)) {
-		rtrn|= _XkbKSUpper;
-	    }
-	    if (ks==XK_oe) {
-		rtrn|= _XkbKSLower;
-	    }
-	    break;
+    case 0:                    /* latin 1 */
+        if (((ks >= XK_A) && (ks <= XK_Z)) ||
+            ((ks >= XK_Agrave) && (ks <= XK_THORN) && (ks != XK_multiply))) {
+            rtrn |= _XkbKSUpper;
+        }
+        if (((ks >= XK_a) && (ks <= XK_z)) ||
+            ((ks >= XK_ssharp) && (ks <= XK_ydiaeresis) &&
+             (ks != XK_division))) {
+            rtrn |= _XkbKSLower;
+        }
+        break;
+    case 1:                    /* latin 2 */
+        if (((ks >= XK_Aogonek) && (ks <= XK_Zabovedot) && (ks != XK_breve)) ||
+            ((ks >= XK_Racute) && (ks <= XK_Tcedilla))) {
+            rtrn |= _XkbKSUpper;
+        }
+        if (((ks >= XK_aogonek) && (ks <= XK_zabovedot) && (ks != XK_ogonek) &&
+             (ks != XK_caron) && (ks != XK_doubleacute)) || ((ks >= XK_racute)
+                                                             && (ks <=
+                                                                 XK_tcedilla)))
+        {
+            rtrn |= _XkbKSLower;
+        }
+        break;
+    case 2:                    /* latin 3 */
+        if (((ks >= XK_Hstroke) && (ks <= XK_Jcircumflex)) ||
+            ((ks >= XK_Cabovedot) && (ks <= XK_Scircumflex))) {
+            rtrn |= _XkbKSUpper;
+        }
+        if (((ks >= XK_hstroke) && (ks <= XK_jcircumflex)) ||
+            ((ks >= XK_cabovedot) && (ks <= XK_scircumflex))) {
+            rtrn |= _XkbKSLower;
+        }
+        break;
+    case 3:                    /* latin 4 */
+        if (((ks >= XK_Rcedilla) && (ks <= XK_Tslash)) ||
+            (ks == XK_ENG) || ((ks >= XK_Amacron) && (ks <= XK_Umacron))) {
+            rtrn |= _XkbKSUpper;
+        }
+        if ((ks == XK_kra) ||
+            ((ks >= XK_rcedilla) && (ks <= XK_tslash)) ||
+            (ks == XK_eng) || ((ks >= XK_amacron) && (ks <= XK_umacron))) {
+            rtrn |= _XkbKSLower;
+        }
+        break;
+    case 18:                   /* latin 8 */
+        if ((ks == XK_Wcircumflex) ||
+            (ks == XK_Ycircumflex) ||
+            (ks == XK_Babovedot) ||
+            (ks == XK_Dabovedot) ||
+            (ks == XK_Fabovedot) ||
+            (ks == XK_Mabovedot) ||
+            (ks == XK_Pabovedot) ||
+            (ks == XK_Sabovedot) ||
+            (ks == XK_Tabovedot) ||
+            (ks == XK_Wgrave) ||
+            (ks == XK_Wacute) || (ks == XK_Wdiaeresis) || (ks == XK_Ygrave)) {
+            rtrn |= _XkbKSUpper;
+        }
+        if ((ks == XK_wcircumflex) ||
+            (ks == XK_ycircumflex) ||
+            (ks == XK_babovedot) ||
+            (ks == XK_dabovedot) ||
+            (ks == XK_fabovedot) ||
+            (ks == XK_mabovedot) ||
+            (ks == XK_pabovedot) ||
+            (ks == XK_sabovedot) ||
+            (ks == XK_tabovedot) ||
+            (ks == XK_wgrave) ||
+            (ks == XK_wacute) || (ks == XK_wdiaeresis) || (ks == XK_ygrave)) {
+            rtrn |= _XkbKSLower;
+        }
+        break;
+    case 19:                   /* latin 9 */
+        if ((ks == XK_OE) || (ks == XK_Ydiaeresis)) {
+            rtrn |= _XkbKSUpper;
+        }
+        if (ks == XK_oe) {
+            rtrn |= _XkbKSLower;
+        }
+        break;
     }
     return rtrn;
 }
@@ -146,9 +144,9 @@ unsigned	set,rtrn;
 /***===================================================================***/
 
 static Bool
-XkbWriteSectionFromName(FILE *file,const char *sectionName,const char *name)
+XkbWriteSectionFromName(FILE * file, const char *sectionName, const char *name)
 {
-    fprintf(file,"    xkb_%-20s { include \"%s\" };\n",sectionName,name);
+    fprintf(file, "    xkb_%-20s { include \"%s\" };\n", sectionName, name);
     return TRUE;
 }
 
@@ -157,43 +155,43 @@ XkbWriteSectionFromName(FILE *file,const char *sectionName,const char *name)
 
 /* ARGSUSED */
 static void
-_AddIncl(	FILE *		file,
-		XkbDescPtr 	xkb,
-		Bool 		topLevel,
-		Bool 		showImplicit,
-		int 		index,
-		void *		priv)
+_AddIncl(FILE * file,
+         XkbDescPtr xkb,
+         Bool topLevel, Bool showImplicit, int index, void *priv)
 {
-    if ((priv)&&(strcmp((char *)priv,"%")!=0))
-	fprintf(file,"    include \"%s\"\n",(char *)priv);
+    if ((priv) && (strcmp((char *) priv, "%") != 0))
+        fprintf(file, "    include \"%s\"\n", (char *) priv);
     return;
 }
 
 Bool
-XkbWriteXKBKeymapForNames(	FILE *			file,
-				XkbComponentNamesPtr	names,
-				XkbDescPtr		xkb,
-				unsigned		want,
-				unsigned		need)
+XkbWriteXKBKeymapForNames(FILE * file,
+                          XkbComponentNamesPtr names,
+                          XkbDescPtr xkb, unsigned want, unsigned need)
 {
-const char *	tmp;
-unsigned	complete;
-XkbNamesPtr	old_names;
-int		multi_section;
-unsigned	wantNames,wantConfig,wantDflts;
-
-    complete= 0;
-    if (COMPLETE(names->keycodes))	complete|= XkmKeyNamesMask;
-    if (COMPLETE(names->types))		complete|= XkmTypesMask;
-    if (COMPLETE(names->compat))	complete|= XkmCompatMapMask;
-    if (COMPLETE(names->symbols))	complete|= XkmSymbolsMask;
-    if (COMPLETE(names->geometry))	complete|= XkmGeometryMask;
-    want|= (complete|need);
-    if (want&XkmSymbolsMask)
-	want|= XkmKeyNamesMask|XkmTypesMask;
-
-    if (want==0)
-	return FALSE;
+    const char *tmp;
+    unsigned complete;
+    XkbNamesPtr old_names;
+    int multi_section;
+    unsigned wantNames, wantConfig, wantDflts;
+
+    complete = 0;
+    if (COMPLETE(names->keycodes))
+        complete |= XkmKeyNamesMask;
+    if (COMPLETE(names->types))
+        complete |= XkmTypesMask;
+    if (COMPLETE(names->compat))
+        complete |= XkmCompatMapMask;
+    if (COMPLETE(names->symbols))
+        complete |= XkmSymbolsMask;
+    if (COMPLETE(names->geometry))
+        complete |= XkmGeometryMask;
+    want |= (complete | need);
+    if (want & XkmSymbolsMask)
+        want |= XkmKeyNamesMask | XkmTypesMask;
+
+    if (want == 0)
+        return FALSE;
 
     if (xkb) {
         old_names = xkb->names;
@@ -214,207 +212,224 @@ unsigned	wantNames,wantConfig,wantDflts;
             xkb->defined |= XkmGeometryMask;
     }
     else {
-        old_names= NULL;
+        old_names = NULL;
     }
 
-    wantConfig= want&(~complete);
-    if (xkb!=NULL) {
-	if (wantConfig&XkmTypesMask) {
-	    if ((!xkb->map) || (xkb->map->num_types<XkbNumRequiredTypes))
-		wantConfig&= ~XkmTypesMask;
-	}
-	if (wantConfig&XkmCompatMapMask) {
-	    if ((!xkb->compat) || (xkb->compat->num_si<1))
-		wantConfig&= ~XkmCompatMapMask;
-	}
-	if (wantConfig&XkmSymbolsMask) {
-	    if ((!xkb->map) || (!xkb->map->key_sym_map))
-		wantConfig&= ~XkmSymbolsMask;
-	}
-	if (wantConfig&XkmIndicatorsMask) {
-	    if (!xkb->indicators)
-		wantConfig&= ~XkmIndicatorsMask;
-	}
-	if (wantConfig&XkmKeyNamesMask) {
-	    if ((!xkb->names)||(!xkb->names->keys))
-		wantConfig&= ~XkmKeyNamesMask;
-	}
-	if ((wantConfig&XkmGeometryMask)&&(!xkb->geom))
-	    wantConfig&= ~XkmGeometryMask;
+    wantConfig = want & (~complete);
+    if (xkb != NULL) {
+        if (wantConfig & XkmTypesMask) {
+            if ((!xkb->map) || (xkb->map->num_types < XkbNumRequiredTypes))
+                wantConfig &= ~XkmTypesMask;
+        }
+        if (wantConfig & XkmCompatMapMask) {
+            if ((!xkb->compat) || (xkb->compat->num_si < 1))
+                wantConfig &= ~XkmCompatMapMask;
+        }
+        if (wantConfig & XkmSymbolsMask) {
+            if ((!xkb->map) || (!xkb->map->key_sym_map))
+                wantConfig &= ~XkmSymbolsMask;
+        }
+        if (wantConfig & XkmIndicatorsMask) {
+            if (!xkb->indicators)
+                wantConfig &= ~XkmIndicatorsMask;
+        }
+        if (wantConfig & XkmKeyNamesMask) {
+            if ((!xkb->names) || (!xkb->names->keys))
+                wantConfig &= ~XkmKeyNamesMask;
+        }
+        if ((wantConfig & XkmGeometryMask) && (!xkb->geom))
+            wantConfig &= ~XkmGeometryMask;
     }
     else {
-	wantConfig= 0;
+        wantConfig = 0;
     }
-    complete|= wantConfig;
-
-    wantDflts= 0;
-    wantNames= want&(~complete);
-    if ((xkb!=NULL) && (old_names!=NULL)) {
-	if (wantNames&XkmTypesMask) {
-	    if (old_names->types!=None) {
-		tmp= NameForAtom(old_names->types);
-		names->types= Xstrdup(tmp);
-	    }
-	    else {
-		wantDflts|= XkmTypesMask;
-	    }
-	    complete|= XkmTypesMask; 
-	}
-	if (wantNames&XkmCompatMapMask) {
-	    if (old_names->compat!=None) {
-		tmp= NameForAtom(old_names->compat);
-		names->compat= Xstrdup(tmp);
-	    }
-	    else wantDflts|= XkmCompatMapMask;
-	    complete|= XkmCompatMapMask; 
-	}
-	if (wantNames&XkmSymbolsMask) {
-	    if (old_names->symbols==None)
-		return FALSE;
-	    tmp= NameForAtom(old_names->symbols);
-	    names->symbols= Xstrdup(tmp);
-	    complete|= XkmSymbolsMask; 
-	}
-	if (wantNames&XkmKeyNamesMask) {
-	   if (old_names->keycodes!=None) {
-		tmp= NameForAtom(old_names->keycodes);
-		names->keycodes= Xstrdup(tmp);
-	    }
-	    else wantDflts|= XkmKeyNamesMask;
-	    complete|= XkmKeyNamesMask;
-	}
-	if (wantNames&XkmGeometryMask) {
-	    if (old_names->geometry==None)
-		return FALSE;
-	    tmp= NameForAtom(old_names->geometry);
-	    names->geometry= Xstrdup(tmp);
-	    complete|= XkmGeometryMask; 
-	    wantNames&= ~XkmGeometryMask;
-	}
+    complete |= wantConfig;
+
+    wantDflts = 0;
+    wantNames = want & (~complete);
+    if ((xkb != NULL) && (old_names != NULL)) {
+        if (wantNames & XkmTypesMask) {
+            if (old_names->types != None) {
+                tmp = NameForAtom(old_names->types);
+                names->types = Xstrdup(tmp);
+            }
+            else {
+                wantDflts |= XkmTypesMask;
+            }
+            complete |= XkmTypesMask;
+        }
+        if (wantNames & XkmCompatMapMask) {
+            if (old_names->compat != None) {
+                tmp = NameForAtom(old_names->compat);
+                names->compat = Xstrdup(tmp);
+            }
+            else
+                wantDflts |= XkmCompatMapMask;
+            complete |= XkmCompatMapMask;
+        }
+        if (wantNames & XkmSymbolsMask) {
+            if (old_names->symbols == None)
+                return FALSE;
+            tmp = NameForAtom(old_names->symbols);
+            names->symbols = Xstrdup(tmp);
+            complete |= XkmSymbolsMask;
+        }
+        if (wantNames & XkmKeyNamesMask) {
+            if (old_names->keycodes != None) {
+                tmp = NameForAtom(old_names->keycodes);
+                names->keycodes = Xstrdup(tmp);
+            }
+            else
+                wantDflts |= XkmKeyNamesMask;
+            complete |= XkmKeyNamesMask;
+        }
+        if (wantNames & XkmGeometryMask) {
+            if (old_names->geometry == None)
+                return FALSE;
+            tmp = NameForAtom(old_names->geometry);
+            names->geometry = Xstrdup(tmp);
+            complete |= XkmGeometryMask;
+            wantNames &= ~XkmGeometryMask;
+        }
     }
-    if (complete&XkmCompatMapMask)
-	complete|= XkmIndicatorsMask|XkmVirtualModsMask;
-    else if (complete&(XkmSymbolsMask|XkmTypesMask))
-	complete|= XkmVirtualModsMask;
+    if (complete & XkmCompatMapMask)
+        complete |= XkmIndicatorsMask | XkmVirtualModsMask;
+    else if (complete & (XkmSymbolsMask | XkmTypesMask))
+        complete |= XkmVirtualModsMask;
     if (need & (~complete))
-	return FALSE;
-    if ((complete&XkmSymbolsMask)&&((XkmKeyNamesMask|XkmTypesMask)&(~complete)))
-	return FALSE;
-
-    multi_section= 1;
-    if (((complete&XkmKeymapRequired)==XkmKeymapRequired)&&
-	((complete&(~XkmKeymapLegal))==0)) {
-	fprintf(file,"xkb_keymap \"default\" {\n");
+        return FALSE;
+    if ((complete & XkmSymbolsMask) &&
+        ((XkmKeyNamesMask | XkmTypesMask) & (~complete)))
+        return FALSE;
+
+    multi_section = 1;
+    if (((complete & XkmKeymapRequired) == XkmKeymapRequired) &&
+        ((complete & (~XkmKeymapLegal)) == 0)) {
+        fprintf(file, "xkb_keymap \"default\" {\n");
     }
-    else if (((complete&XkmSemanticsRequired)==XkmSemanticsRequired)&&
-	((complete&(~XkmSemanticsLegal))==0)) {
-	fprintf(file,"xkb_semantics \"default\" {\n");
+    else if (((complete & XkmSemanticsRequired) == XkmSemanticsRequired) &&
+             ((complete & (~XkmSemanticsLegal)) == 0)) {
+        fprintf(file, "xkb_semantics \"default\" {\n");
     }
-    else if (((complete&XkmLayoutRequired)==XkmLayoutRequired)&&
-	((complete&(~XkmLayoutLegal))==0)) {
-	fprintf(file,"xkb_layout \"default\" {\n");
+    else if (((complete & XkmLayoutRequired) == XkmLayoutRequired) &&
+             ((complete & (~XkmLayoutLegal)) == 0)) {
+        fprintf(file, "xkb_layout \"default\" {\n");
     }
-    else if (XkmSingleSection(complete&(~XkmVirtualModsMask))) {
-	multi_section= 0;
+    else if (XkmSingleSection(complete & (~XkmVirtualModsMask))) {
+        multi_section = 0;
     }
     else {
-	return FALSE;
+        return FALSE;
     }
 
-    wantNames= complete&(~(wantConfig|wantDflts));
-    if (wantConfig&XkmKeyNamesMask)
-	XkbWriteXKBKeycodes(file,xkb,FALSE,FALSE,_AddIncl,names->keycodes);
-    else if (wantDflts&XkmKeyNamesMask)
-	fprintf(stderr,"Default symbols not implemented yet!\n");
-    else if (wantNames&XkmKeyNamesMask)
-	XkbWriteSectionFromName(file,"keycodes",names->keycodes);
-
-    if (wantConfig&XkmTypesMask)
-	XkbWriteXKBKeyTypes(file,xkb,FALSE,FALSE,_AddIncl,names->types);
-    else if (wantDflts&XkmTypesMask)
-	fprintf(stderr,"Default types not implemented yet!\n");
-    else if (wantNames&XkmTypesMask)
-	XkbWriteSectionFromName(file,"types",names->types);
-
-    if (wantConfig&XkmCompatMapMask)
-	XkbWriteXKBCompatMap(file,xkb,FALSE,FALSE,_AddIncl,names->compat);
-    else if (wantDflts&XkmCompatMapMask)
-	fprintf(stderr,"Default interps not implemented yet!\n");
-    else if (wantNames&XkmCompatMapMask)
-	XkbWriteSectionFromName(file,"compatibility",names->compat);
-
-    if (wantConfig&XkmSymbolsMask)
-	XkbWriteXKBSymbols(file,xkb,FALSE,FALSE,_AddIncl,names->symbols);
-    else if (wantNames&XkmSymbolsMask)
-	XkbWriteSectionFromName(file,"symbols",names->symbols);
-
-    if (wantConfig&XkmGeometryMask)
-	XkbWriteXKBGeometry(file,xkb,FALSE,FALSE,_AddIncl,names->geometry);
-    else if (wantNames&XkmGeometryMask)
-	XkbWriteSectionFromName(file,"geometry",names->geometry);
+    wantNames = complete & (~(wantConfig | wantDflts));
+    if (wantConfig & XkmKeyNamesMask)
+        XkbWriteXKBKeycodes(file, xkb, FALSE, FALSE, _AddIncl, names->keycodes);
+    else if (wantDflts & XkmKeyNamesMask)
+        fprintf(stderr, "Default symbols not implemented yet!\n");
+    else if (wantNames & XkmKeyNamesMask)
+        XkbWriteSectionFromName(file, "keycodes", names->keycodes);
+
+    if (wantConfig & XkmTypesMask)
+        XkbWriteXKBKeyTypes(file, xkb, FALSE, FALSE, _AddIncl, names->types);
+    else if (wantDflts & XkmTypesMask)
+        fprintf(stderr, "Default types not implemented yet!\n");
+    else if (wantNames & XkmTypesMask)
+        XkbWriteSectionFromName(file, "types", names->types);
+
+    if (wantConfig & XkmCompatMapMask)
+        XkbWriteXKBCompatMap(file, xkb, FALSE, FALSE, _AddIncl, names->compat);
+    else if (wantDflts & XkmCompatMapMask)
+        fprintf(stderr, "Default interps not implemented yet!\n");
+    else if (wantNames & XkmCompatMapMask)
+        XkbWriteSectionFromName(file, "compatibility", names->compat);
+
+    if (wantConfig & XkmSymbolsMask)
+        XkbWriteXKBSymbols(file, xkb, FALSE, FALSE, _AddIncl, names->symbols);
+    else if (wantNames & XkmSymbolsMask)
+        XkbWriteSectionFromName(file, "symbols", names->symbols);
+
+    if (wantConfig & XkmGeometryMask)
+        XkbWriteXKBGeometry(file, xkb, FALSE, FALSE, _AddIncl, names->geometry);
+    else if (wantNames & XkmGeometryMask)
+        XkbWriteSectionFromName(file, "geometry", names->geometry);
 
     if (multi_section)
-	fprintf(file,"};\n");
+        fprintf(file, "};\n");
     return TRUE;
 }
 
 /***====================================================================***/
 
 int
-XkbFindKeycodeByName(XkbDescPtr xkb,char *name,Bool use_aliases)
+XkbFindKeycodeByName(XkbDescPtr xkb, char *name, Bool use_aliases)
 {
-register int	i;
+    register int i;
 
-    if ((!xkb)||(!xkb->names)||(!xkb->names->keys))
-	return 0;
-    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	if (strncmp(xkb->names->keys[i].name,name,XkbKeyNameLength)==0)
-	    return i;
+    if ((!xkb) || (!xkb->names) || (!xkb->names->keys))
+        return 0;
+    for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+        if (strncmp(xkb->names->keys[i].name, name, XkbKeyNameLength) == 0)
+            return i;
     }
     if (!use_aliases)
-	return 0;
+        return 0;
     if (xkb->geom && xkb->geom->key_aliases) {
-	XkbKeyAliasPtr	a;
-	a= xkb->geom->key_aliases;
-	for (i=0;i<xkb->geom->num_key_aliases;i++,a++) {
-	    if (strncmp(name,a->alias,XkbKeyNameLength)==0)
-		return XkbFindKeycodeByName(xkb,a->real,FALSE);
-	}
+        XkbKeyAliasPtr a;
+
+        a = xkb->geom->key_aliases;
+        for (i = 0; i < xkb->geom->num_key_aliases; i++, a++) {
+            if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
+                return XkbFindKeycodeByName(xkb, a->real, FALSE);
+        }
     }
     if (xkb->names && xkb->names->key_aliases) {
-	XkbKeyAliasPtr	a;
-	a= xkb->names->key_aliases;
-	for (i=0;i<xkb->names->num_key_aliases;i++,a++) {
-	    if (strncmp(name,a->alias,XkbKeyNameLength)==0)
-		return XkbFindKeycodeByName(xkb,a->real,FALSE);
-	}
+        XkbKeyAliasPtr a;
+
+        a = xkb->names->key_aliases;
+        for (i = 0; i < xkb->names->num_key_aliases; i++, a++) {
+            if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
+                return XkbFindKeycodeByName(xkb, a->real, FALSE);
+        }
     }
     return 0;
 }
 
-
 unsigned
-XkbConvertGetByNameComponents(Bool toXkm,unsigned orig)
+XkbConvertGetByNameComponents(Bool toXkm, unsigned orig)
 {
-unsigned	rtrn;
+    unsigned rtrn;
 
-    rtrn= 0;
+    rtrn = 0;
     if (toXkm) {
-	if (orig&XkbGBN_TypesMask)		rtrn|= XkmTypesMask;
-	if (orig&XkbGBN_CompatMapMask)		rtrn|= XkmCompatMapMask;
-	if (orig&XkbGBN_SymbolsMask)		rtrn|= XkmSymbolsMask;
-	if (orig&XkbGBN_IndicatorMapMask)	rtrn|= XkmIndicatorsMask;
-	if (orig&XkbGBN_KeyNamesMask)		rtrn|= XkmKeyNamesMask;
-	if (orig&XkbGBN_GeometryMask)		rtrn|= XkmGeometryMask;
+        if (orig & XkbGBN_TypesMask)
+            rtrn |= XkmTypesMask;
+        if (orig & XkbGBN_CompatMapMask)
+            rtrn |= XkmCompatMapMask;
+        if (orig & XkbGBN_SymbolsMask)
+            rtrn |= XkmSymbolsMask;
+        if (orig & XkbGBN_IndicatorMapMask)
+            rtrn |= XkmIndicatorsMask;
+        if (orig & XkbGBN_KeyNamesMask)
+            rtrn |= XkmKeyNamesMask;
+        if (orig & XkbGBN_GeometryMask)
+            rtrn |= XkmGeometryMask;
     }
     else {
-	if (orig&XkmTypesMask)			rtrn|= XkbGBN_TypesMask;
-	if (orig&XkmCompatMapMask)		rtrn|= XkbGBN_CompatMapMask;
-	if (orig&XkmSymbolsMask)		rtrn|= XkbGBN_SymbolsMask;
-	if (orig&XkmIndicatorsMask)		rtrn|= XkbGBN_IndicatorMapMask;
-	if (orig&XkmKeyNamesMask)		rtrn|= XkbGBN_KeyNamesMask;
-	if (orig&XkmGeometryMask)		rtrn|= XkbGBN_GeometryMask;
-	if (orig!=0)				rtrn|= XkbGBN_OtherNamesMask;
+        if (orig & XkmTypesMask)
+            rtrn |= XkbGBN_TypesMask;
+        if (orig & XkmCompatMapMask)
+            rtrn |= XkbGBN_CompatMapMask;
+        if (orig & XkmSymbolsMask)
+            rtrn |= XkbGBN_SymbolsMask;
+        if (orig & XkmIndicatorsMask)
+            rtrn |= XkbGBN_IndicatorMapMask;
+        if (orig & XkmKeyNamesMask)
+            rtrn |= XkbGBN_KeyNamesMask;
+        if (orig & XkmGeometryMask)
+            rtrn |= XkbGBN_GeometryMask;
+        if (orig != 0)
+            rtrn |= XkbGBN_OtherNamesMask;
     }
     return rtrn;
 }
@@ -424,30 +439,31 @@ unsigned	rtrn;
 #define	UNMATCHABLE(c)	(((c)=='(')||((c)==')')||((c)=='/'))
 
 Bool
-XkbNameMatchesPattern(char *name,char *ptrn)
+XkbNameMatchesPattern(char *name, char *ptrn)
 {
-    while (ptrn[0]!='\0') {
-	if (name[0]=='\0') {
-	    if (ptrn[0]=='*') {
-		ptrn++;
-		continue;
-	    }
-	    return FALSE;
-	}
-	if (ptrn[0]=='?') {
-	    if (UNMATCHABLE(name[0]))
-		return FALSE;
-	}
-	else if (ptrn[0]=='*') {
-	    if ((!UNMATCHABLE(name[0]))&&XkbNameMatchesPattern(name+1,ptrn))
-		return TRUE;
-	    return XkbNameMatchesPattern(name,ptrn+1);
-	}
-	else if (ptrn[0]!=name[0])
-	    return FALSE;
-	name++;
-	ptrn++;
+    while (ptrn[0] != '\0') {
+        if (name[0] == '\0') {
+            if (ptrn[0] == '*') {
+                ptrn++;
+                continue;
+            }
+            return FALSE;
+        }
+        if (ptrn[0] == '?') {
+            if (UNMATCHABLE(name[0]))
+                return FALSE;
+        }
+        else if (ptrn[0] == '*') {
+            if ((!UNMATCHABLE(name[0])) &&
+                XkbNameMatchesPattern(name + 1, ptrn))
+                return TRUE;
+            return XkbNameMatchesPattern(name, ptrn + 1);
+        }
+        else if (ptrn[0] != name[0])
+            return FALSE;
+        name++;
+        ptrn++;
     }
     /* if we get here, the pattern is exhausted (-:just like me:-) */
-    return name[0]=='\0';
+    return name[0] == '\0';
 }
diff --git a/xorg-server/xkb/xkbgeom.h b/xorg-server/xkb/xkbgeom.h
index d10b956a6..bef3775db 100644
--- a/xorg-server/xkb/xkbgeom.h
+++ b/xorg-server/xkb/xkbgeom.h
@@ -71,88 +71,93 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #define XkbFreeGeomShapes		SrvXkbFreeGeomShapes
 #define XkbFreeGeometry			SrvXkbFreeGeometry
 
-typedef	struct _XkbProperty {
-	char	*name;
-	char	*value;
-} XkbPropertyRec,*XkbPropertyPtr;
+typedef struct _XkbProperty {
+    char *name;
+    char *value;
+} XkbPropertyRec, *XkbPropertyPtr;
 
 typedef struct _XkbColor {
-	unsigned int 	pixel;
-	char *		spec;
-} XkbColorRec,*XkbColorPtr;
+    unsigned int pixel;
+    char *spec;
+} XkbColorRec, *XkbColorPtr;
 
-typedef	struct _XkbPoint {
-	short	x;
-	short	y;
+typedef struct _XkbPoint {
+    short x;
+    short y;
 } XkbPointRec, *XkbPointPtr;
 
-typedef struct	_XkbBounds {
-	short	x1,y1;
-	short	x2,y2;
+typedef struct _XkbBounds {
+    short x1, y1;
+    short x2, y2;
 } XkbBoundsRec, *XkbBoundsPtr;
+
 #define	XkbBoundsWidth(b)	(((b)->x2)-((b)->x1))
 #define	XkbBoundsHeight(b)	(((b)->y2)-((b)->y1))
 
 typedef struct _XkbOutline {
-	unsigned short	num_points;
-	unsigned short	sz_points;
-	unsigned short	corner_radius;
-	XkbPointPtr	points;
+    unsigned short num_points;
+    unsigned short sz_points;
+    unsigned short corner_radius;
+    XkbPointPtr points;
 } XkbOutlineRec, *XkbOutlinePtr;
 
 typedef struct _XkbShape {
-	Atom	 	 name;
-	unsigned short	 num_outlines;
-	unsigned short	 sz_outlines;
-	XkbOutlinePtr	 outlines;
-	XkbOutlinePtr	 approx;
-	XkbOutlinePtr	 primary;
-	XkbBoundsRec	 bounds;
+    Atom name;
+    unsigned short num_outlines;
+    unsigned short sz_outlines;
+    XkbOutlinePtr outlines;
+    XkbOutlinePtr approx;
+    XkbOutlinePtr primary;
+    XkbBoundsRec bounds;
 } XkbShapeRec, *XkbShapePtr;
+
 #define	XkbOutlineIndex(s,o)	((int)((o)-&(s)->outlines[0]))
 
 typedef struct _XkbShapeDoodad {
-	Atom		 name;
-	unsigned char	 type;
-	unsigned char	 priority;
-	short		 top;
-	short		 left;
-	short	 	 angle;
-	unsigned short	 color_ndx;
-	unsigned short	 shape_ndx;
+    Atom name;
+    unsigned char type;
+    unsigned char priority;
+    short top;
+    short left;
+    short angle;
+    unsigned short color_ndx;
+    unsigned short shape_ndx;
 } XkbShapeDoodadRec, *XkbShapeDoodadPtr;
+
 #define	XkbShapeDoodadColor(g,d)	(&(g)->colors[(d)->color_ndx])
 #define	XkbShapeDoodadShape(g,d)	(&(g)->shapes[(d)->shape_ndx])
 #define	XkbSetShapeDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
 #define	XkbSetShapeDoodadShape(g,d,s)	((d)->shape_ndx= (s)-&(g)->shapes[0])
 
 typedef struct _XkbTextDoodad {
-	Atom		 name;
-	unsigned char	 type;
-	unsigned char	 priority;
-	short	 	 top;
-	short	 	 left;
-	short	 	 angle;
-	short	 	 width;
-	short		 height;
-	unsigned short	 color_ndx;
-	char *		 text;
-	char *		 font;
+    Atom name;
+    unsigned char type;
+    unsigned char priority;
+    short top;
+    short left;
+    short angle;
+    short width;
+    short height;
+    unsigned short color_ndx;
+    char *text;
+    char *font;
 } XkbTextDoodadRec, *XkbTextDoodadPtr;
+
 #define	XkbTextDoodadColor(g,d)	(&(g)->colors[(d)->color_ndx])
 #define	XkbSetTextDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
 
 typedef struct _XkbIndicatorDoodad {
-	Atom		 name;
-	unsigned char	 type;
-	unsigned char	 priority;
-	short	 	 top;
-	short	 	 left;
-	short		 angle;
-	unsigned short	 shape_ndx;
-	unsigned short	 on_color_ndx;
-	unsigned short	 off_color_ndx;
+    Atom name;
+    unsigned char type;
+    unsigned char priority;
+    short top;
+    short left;
+    short angle;
+    unsigned short shape_ndx;
+    unsigned short on_color_ndx;
+    unsigned short off_color_ndx;
 } XkbIndicatorDoodadRec, *XkbIndicatorDoodadPtr;
+
 #define	XkbIndicatorDoodadShape(g,d)	(&(g)->shapes[(d)->shape_ndx])
 #define	XkbIndicatorDoodadOnColor(g,d)	(&(g)->colors[(d)->on_color_ndx])
 #define	XkbIndicatorDoodadOffColor(g,d)	(&(g)->colors[(d)->off_color_ndx])
@@ -164,36 +169,37 @@ typedef struct _XkbIndicatorDoodad {
 				((d)->shape_ndx= (s)-&(g)->shapes[0])
 
 typedef struct _XkbLogoDoodad {
-	Atom		 name;
-	unsigned char	 type;
-	unsigned char	 priority;
-	short		 top;
-	short		 left;
-	short	 	 angle;
-	unsigned short	 color_ndx;
-	unsigned short	 shape_ndx;
-	char *		 logo_name;
+    Atom name;
+    unsigned char type;
+    unsigned char priority;
+    short top;
+    short left;
+    short angle;
+    unsigned short color_ndx;
+    unsigned short shape_ndx;
+    char *logo_name;
 } XkbLogoDoodadRec, *XkbLogoDoodadPtr;
+
 #define	XkbLogoDoodadColor(g,d)		(&(g)->colors[(d)->color_ndx])
 #define	XkbLogoDoodadShape(g,d)		(&(g)->shapes[(d)->shape_ndx])
 #define	XkbSetLogoDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
 #define	XkbSetLogoDoodadShape(g,d,s)	((d)->shape_ndx= (s)-&(g)->shapes[0])
 
 typedef struct _XkbAnyDoodad {
-	Atom		 name;
-	unsigned char	 type;
-	unsigned char	 priority;
-	short	 	 top;
-	short	 	 left;
-	short		 angle;
+    Atom name;
+    unsigned char type;
+    unsigned char priority;
+    short top;
+    short left;
+    short angle;
 } XkbAnyDoodadRec, *XkbAnyDoodadPtr;
 
 typedef union _XkbDoodad {
-	XkbAnyDoodadRec		any;
-	XkbShapeDoodadRec	shape;
-	XkbTextDoodadRec	text;
-	XkbIndicatorDoodadRec	indicator;
-	XkbLogoDoodadRec	logo;
+    XkbAnyDoodadRec any;
+    XkbShapeDoodadRec shape;
+    XkbTextDoodadRec text;
+    XkbIndicatorDoodadRec indicator;
+    XkbLogoDoodadRec logo;
 } XkbDoodadRec, *XkbDoodadPtr;
 
 #define	XkbUnknownDoodad	0
@@ -204,93 +210,95 @@ typedef union _XkbDoodad {
 #define	XkbLogoDoodad		5
 
 typedef struct _XkbKey {
-	XkbKeyNameRec	 name;
-	short		 gap;
-	unsigned char	 shape_ndx;
-	unsigned char	 color_ndx;
+    XkbKeyNameRec name;
+    short gap;
+    unsigned char shape_ndx;
+    unsigned char color_ndx;
 } XkbKeyRec, *XkbKeyPtr;
+
 #define	XkbKeyShape(g,k)	(&(g)->shapes[(k)->shape_ndx])
 #define	XkbKeyColor(g,k)	(&(g)->colors[(k)->color_ndx])
 #define	XkbSetKeyShape(g,k,s)	((k)->shape_ndx= (s)-&(g)->shapes[0])
 #define	XkbSetKeyColor(g,k,c)	((k)->color_ndx= (c)-&(g)->colors[0])
 
 typedef struct _XkbRow {
-	short	 	top;
-	short	 	left;
-	unsigned short	num_keys;
-	unsigned short	sz_keys;
-	int		vertical;
-	XkbKeyPtr	keys;
-	XkbBoundsRec	bounds;
+    short top;
+    short left;
+    unsigned short num_keys;
+    unsigned short sz_keys;
+    int vertical;
+    XkbKeyPtr keys;
+    XkbBoundsRec bounds;
 } XkbRowRec, *XkbRowPtr;
 
 typedef struct _XkbSection {
-	Atom		 name;
-	unsigned char	 priority;
-	short	 	 top;
-	short	 	 left;
-	unsigned short	 width;
-	unsigned short	 height;
-	short	 	 angle;
-	unsigned short	 num_rows;
-	unsigned short	 num_doodads;
-	unsigned short	 num_overlays;
-	unsigned short	 sz_rows;
-	unsigned short	 sz_doodads;
-	unsigned short	 sz_overlays;
-	XkbRowPtr	 rows;
-	XkbDoodadPtr	 doodads;
-	XkbBoundsRec	 bounds;
-	struct _XkbOverlay *overlays;
+    Atom name;
+    unsigned char priority;
+    short top;
+    short left;
+    unsigned short width;
+    unsigned short height;
+    short angle;
+    unsigned short num_rows;
+    unsigned short num_doodads;
+    unsigned short num_overlays;
+    unsigned short sz_rows;
+    unsigned short sz_doodads;
+    unsigned short sz_overlays;
+    XkbRowPtr rows;
+    XkbDoodadPtr doodads;
+    XkbBoundsRec bounds;
+    struct _XkbOverlay *overlays;
 } XkbSectionRec, *XkbSectionPtr;
 
-typedef	struct _XkbOverlayKey {
-	XkbKeyNameRec	over;
-	XkbKeyNameRec	under;
-} XkbOverlayKeyRec,*XkbOverlayKeyPtr;
+typedef struct _XkbOverlayKey {
+    XkbKeyNameRec over;
+    XkbKeyNameRec under;
+} XkbOverlayKeyRec, *XkbOverlayKeyPtr;
 
 typedef struct _XkbOverlayRow {
-	unsigned short		row_under;
-	unsigned short		num_keys;
-	unsigned short		sz_keys;
-	XkbOverlayKeyPtr	keys;
-} XkbOverlayRowRec,*XkbOverlayRowPtr;
+    unsigned short row_under;
+    unsigned short num_keys;
+    unsigned short sz_keys;
+    XkbOverlayKeyPtr keys;
+} XkbOverlayRowRec, *XkbOverlayRowPtr;
 
 typedef struct _XkbOverlay {
-	Atom			name;
-	XkbSectionPtr		section_under;
-	unsigned short		num_rows;
-	unsigned short		sz_rows;
-	XkbOverlayRowPtr	rows;
-	XkbBoundsPtr		bounds;
-} XkbOverlayRec,*XkbOverlayPtr;
+    Atom name;
+    XkbSectionPtr section_under;
+    unsigned short num_rows;
+    unsigned short sz_rows;
+    XkbOverlayRowPtr rows;
+    XkbBoundsPtr bounds;
+} XkbOverlayRec, *XkbOverlayPtr;
 
 typedef struct _XkbGeometry {
-	Atom		 name;
-	unsigned short	 width_mm;
-	unsigned short	 height_mm;
-	char *		 label_font;
-	XkbColorPtr	 label_color;
-	XkbColorPtr	 base_color;
-	unsigned short	 sz_properties;
-	unsigned short	 sz_colors;
-	unsigned short	 sz_shapes;
-	unsigned short   sz_sections;
-	unsigned short	 sz_doodads;
-	unsigned short	 sz_key_aliases;
-	unsigned short	 num_properties;
-	unsigned short	 num_colors;
-	unsigned short	 num_shapes;
-	unsigned short	 num_sections;
-	unsigned short	 num_doodads;
-	unsigned short	 num_key_aliases;
-	XkbPropertyPtr	 properties;
-	XkbColorPtr	 colors;
-	XkbShapePtr	 shapes;
-	XkbSectionPtr	 sections;
-	XkbDoodadPtr	 doodads;
-	XkbKeyAliasPtr	 key_aliases;
+    Atom name;
+    unsigned short width_mm;
+    unsigned short height_mm;
+    char *label_font;
+    XkbColorPtr label_color;
+    XkbColorPtr base_color;
+    unsigned short sz_properties;
+    unsigned short sz_colors;
+    unsigned short sz_shapes;
+    unsigned short sz_sections;
+    unsigned short sz_doodads;
+    unsigned short sz_key_aliases;
+    unsigned short num_properties;
+    unsigned short num_colors;
+    unsigned short num_shapes;
+    unsigned short num_sections;
+    unsigned short num_doodads;
+    unsigned short num_key_aliases;
+    XkbPropertyPtr properties;
+    XkbColorPtr colors;
+    XkbShapePtr shapes;
+    XkbSectionPtr sections;
+    XkbDoodadPtr doodads;
+    XkbKeyAliasPtr key_aliases;
 } XkbGeometryRec;
+
 #define	XkbGeomColorIndex(g,c)	((int)((c)-&(g)->colors[0]))
 
 #define	XkbGeomPropertiesMask	(1<<0)
@@ -302,350 +310,271 @@ typedef struct _XkbGeometry {
 #define	XkbGeomAllMask		(0x3f)
 
 typedef struct _XkbGeometrySizes {
-	unsigned int	which;
-	unsigned short	num_properties;
-	unsigned short	num_colors;
-	unsigned short	num_shapes;
-	unsigned short	num_sections;
-	unsigned short	num_doodads;
-	unsigned short	num_key_aliases;
-} XkbGeometrySizesRec,*XkbGeometrySizesPtr;
+    unsigned int which;
+    unsigned short num_properties;
+    unsigned short num_colors;
+    unsigned short num_shapes;
+    unsigned short num_sections;
+    unsigned short num_doodads;
+    unsigned short num_key_aliases;
+} XkbGeometrySizesRec, *XkbGeometrySizesPtr;
 
 /**
  * Specifies which items should be cleared in an XKB geometry array
  * when the array is reallocated.
  */
-typedef enum
-{
-    XKB_GEOM_CLEAR_NONE,   /* Don't clear any items, just reallocate.   */
-    XKB_GEOM_CLEAR_EXCESS, /* Clear new extra items after reallocation. */
-    XKB_GEOM_CLEAR_ALL     /* Clear all items after reallocation.       */
+typedef enum {
+    XKB_GEOM_CLEAR_NONE,        /* Don't clear any items, just reallocate.   */
+    XKB_GEOM_CLEAR_EXCESS,      /* Clear new extra items after reallocation. */
+    XKB_GEOM_CLEAR_ALL          /* Clear all items after reallocation.       */
 } XkbGeomClearance;
 
-extern	XkbPropertyPtr
-XkbAddGeomProperty(
-    XkbGeometryPtr	/* geom */,
-    char *		/* name */,
-    char *		/* value */
-);
-
-extern	XkbKeyAliasPtr
-XkbAddGeomKeyAlias(
-    XkbGeometryPtr	/* geom */,
-    char *		/* alias */,
-    char *		/* real */
-);
-
-extern	XkbColorPtr
-XkbAddGeomColor(
-    XkbGeometryPtr	/* geom */,
-    char *		/* spec */,
-    unsigned int	/* pixel */
-);
-
-extern	XkbOutlinePtr
-XkbAddGeomOutline(
-    XkbShapePtr		/* shape */,
-    int			/* sz_points */
-);
-
-extern XkbShapePtr
-XkbAddGeomShape(
-    XkbGeometryPtr	/* geom */,
-    Atom		/* name */,
-    int			/* sz_outlines */
-);
-
-extern XkbKeyPtr
-XkbAddGeomKey(
-    XkbRowPtr		/* row */
-);
-
-extern XkbRowPtr
-XkbAddGeomRow(
-    XkbSectionPtr	/* section */,
-    int			/* sz_keys */
-);
-
-extern XkbSectionPtr
-XkbAddGeomSection(
-    XkbGeometryPtr	/* geom */,
-    Atom		/* name */,
-    int			/* sz_rows */,
-    int			/* sz_doodads */,
-    int			/* sz_overlays */
-);
-
-extern XkbOverlayPtr
-XkbAddGeomOverlay(
-    XkbSectionPtr	/* section */,
-    Atom		/* name */,
-    int			/* sz_rows */
-);
-
-extern XkbOverlayRowPtr
-XkbAddGeomOverlayRow(
-    XkbOverlayPtr	/* overlay */,
-    int			/* row_under */,
-    int			/* sz_keys */
-);
-
-extern XkbOverlayKeyPtr
-XkbAddGeomOverlayKey(
-    XkbOverlayPtr	/* overlay */,
-    XkbOverlayRowPtr	/* row */,
-    char *		/* over */,
-    char *		/* under */
-);
-
-extern XkbDoodadPtr
-XkbAddGeomDoodad(
-    XkbGeometryPtr	/* geom */,
-    XkbSectionPtr	/* section */,
-    Atom		/* name */
-);
-
+extern XkbPropertyPtr XkbAddGeomProperty(XkbGeometryPtr /* geom */ ,
+                                         char * /* name */ ,
+                                         char * /* value */
+    );
+
+extern XkbKeyAliasPtr XkbAddGeomKeyAlias(XkbGeometryPtr /* geom */ ,
+                                         char * /* alias */ ,
+                                         char * /* real */
+    );
+
+extern XkbColorPtr XkbAddGeomColor(XkbGeometryPtr /* geom */ ,
+                                   char * /* spec */ ,
+                                   unsigned int /* pixel */
+    );
+
+extern XkbOutlinePtr XkbAddGeomOutline(XkbShapePtr /* shape */ ,
+                                       int      /* sz_points */
+    );
+
+extern XkbShapePtr XkbAddGeomShape(XkbGeometryPtr /* geom */ ,
+                                   Atom /* name */ ,
+                                   int  /* sz_outlines */
+    );
+
+extern XkbKeyPtr XkbAddGeomKey(XkbRowPtr        /* row */
+    );
+
+extern XkbRowPtr XkbAddGeomRow(XkbSectionPtr /* section */ ,
+                               int      /* sz_keys */
+    );
+
+extern XkbSectionPtr XkbAddGeomSection(XkbGeometryPtr /* geom */ ,
+                                       Atom /* name */ ,
+                                       int /* sz_rows */ ,
+                                       int /* sz_doodads */ ,
+                                       int      /* sz_overlays */
+    );
+
+extern XkbOverlayPtr XkbAddGeomOverlay(XkbSectionPtr /* section */ ,
+                                       Atom /* name */ ,
+                                       int      /* sz_rows */
+    );
+
+extern XkbOverlayRowPtr XkbAddGeomOverlayRow(XkbOverlayPtr /* overlay */ ,
+                                             int /* row_under */ ,
+                                             int        /* sz_keys */
+    );
+
+extern XkbOverlayKeyPtr XkbAddGeomOverlayKey(XkbOverlayPtr /* overlay */ ,
+                                             XkbOverlayRowPtr /* row */ ,
+                                             char * /* over */ ,
+                                             char *     /* under */
+    );
+
+extern XkbDoodadPtr XkbAddGeomDoodad(XkbGeometryPtr /* geom */ ,
+                                     XkbSectionPtr /* section */ ,
+                                     Atom       /* name */
+    );
 
 extern void
-XkbFreeGeomKeyAliases(
-    XkbGeometryPtr	/* geom */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomKeyAliases(XkbGeometryPtr /* geom */ ,
+                       int /* first */ ,
+                       int /* count */ ,
+                       Bool     /* freeAll */
+    );
 
 extern void
-XkbFreeGeomColors(
-    XkbGeometryPtr	/* geom */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomColors(XkbGeometryPtr /* geom */ ,
+                   int /* first */ ,
+                   int /* count */ ,
+                   Bool         /* freeAll */
+    );
 
 extern void
-XkbFreeGeomDoodads(
-    XkbDoodadPtr	/* doodads */,
-    int			/* nDoodads */,
-    Bool		/* freeAll */
-);
-
+ XkbFreeGeomDoodads(XkbDoodadPtr /* doodads */ ,
+                    int /* nDoodads */ ,
+                    Bool        /* freeAll */
+    );
 
 extern void
-XkbFreeGeomProperties(
-    XkbGeometryPtr	/* geom */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomProperties(XkbGeometryPtr /* geom */ ,
+                       int /* first */ ,
+                       int /* count */ ,
+                       Bool     /* freeAll */
+    );
 
 extern void
-XkbFreeGeomOverlayKeys(
-    XkbOverlayRowPtr	/* row */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomOverlayKeys(XkbOverlayRowPtr /* row */ ,
+                        int /* first */ ,
+                        int /* count */ ,
+                        Bool    /* freeAll */
+    );
 
 extern void
-XkbFreeGeomOverlayRows(
-    XkbOverlayPtr	/* overlay */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomOverlayRows(XkbOverlayPtr /* overlay */ ,
+                        int /* first */ ,
+                        int /* count */ ,
+                        Bool    /* freeAll */
+    );
 
 extern void
-XkbFreeGeomOverlays(
-    XkbSectionPtr	/* section */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomOverlays(XkbSectionPtr /* section */ ,
+                     int /* first */ ,
+                     int /* count */ ,
+                     Bool       /* freeAll */
+    );
 
 extern void
-XkbFreeGeomKeys(
-    XkbRowPtr		/* row */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomKeys(XkbRowPtr /* row */ ,
+                 int /* first */ ,
+                 int /* count */ ,
+                 Bool           /* freeAll */
+    );
 
 extern void
-XkbFreeGeomRows(
-    XkbSectionPtr	/* section */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomRows(XkbSectionPtr /* section */ ,
+                 int /* first */ ,
+                 int /* count */ ,
+                 Bool           /* freeAll */
+    );
 
 extern void
-XkbFreeGeomSections(
-    XkbGeometryPtr	/* geom */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
-
+ XkbFreeGeomSections(XkbGeometryPtr /* geom */ ,
+                     int /* first */ ,
+                     int /* count */ ,
+                     Bool       /* freeAll */
+    );
 
 extern void
-XkbFreeGeomPoints(
-    XkbOutlinePtr	/* outline */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomPoints(XkbOutlinePtr /* outline */ ,
+                   int /* first */ ,
+                   int /* count */ ,
+                   Bool         /* freeAll */
+    );
 
 extern void
-XkbFreeGeomOutlines(
-    XkbShapePtr		/* shape */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomOutlines(XkbShapePtr /* shape */ ,
+                     int /* first */ ,
+                     int /* count */ ,
+                     Bool       /* freeAll */
+    );
 
 extern void
-XkbFreeGeomShapes(
-    XkbGeometryPtr	/* geom */,
-    int			/* first */,
-    int			/* count */,
-    Bool		/* freeAll */
-);
+ XkbFreeGeomShapes(XkbGeometryPtr /* geom */ ,
+                   int /* first */ ,
+                   int /* count */ ,
+                   Bool         /* freeAll */
+    );
 
 extern void
-XkbFreeGeometry(
-    XkbGeometryPtr	/* geom */,
-    unsigned int	/* which */,
-    Bool		/* freeMap */
-);
+ XkbFreeGeometry(XkbGeometryPtr /* geom */ ,
+                 unsigned int /* which */ ,
+                 Bool           /* freeMap */
+    );
+
+extern Bool
+ XkbGeomRealloc(void ** /* buffer */ ,
+                int /* szItems */ ,
+                int /* nrItems */ ,
+                int /* itemSize */ ,
+                XkbGeomClearance        /* clearance */
+    );
+
+extern Status XkbAllocGeomProps(XkbGeometryPtr /* geom */ ,
+                                int     /* nProps */
+    );
+
+extern Status XkbAllocGeomKeyAliases(XkbGeometryPtr /* geom */ ,
+                                     int        /* nAliases */
+    );
+
+extern Status XkbAllocGeomColors(XkbGeometryPtr /* geom */ ,
+                                 int    /* nColors */
+    );
+
+extern Status XkbAllocGeomShapes(XkbGeometryPtr /* geom */ ,
+                                 int    /* nShapes */
+    );
+
+extern Status XkbAllocGeomSections(XkbGeometryPtr /* geom */ ,
+                                   int  /* nSections */
+    );
+
+extern Status XkbAllocGeomOverlays(XkbSectionPtr /* section */ ,
+                                   int  /* num_needed */
+    );
+
+extern Status XkbAllocGeomOverlayRows(XkbOverlayPtr /* overlay */ ,
+                                      int       /* num_needed */
+    );
+
+extern Status XkbAllocGeomOverlayKeys(XkbOverlayRowPtr /* row */ ,
+                                      int       /* num_needed */
+    );
+
+extern Status XkbAllocGeomDoodads(XkbGeometryPtr /* geom */ ,
+                                  int   /* nDoodads */
+    );
+
+extern Status XkbAllocGeomSectionDoodads(XkbSectionPtr /* section */ ,
+                                         int    /* nDoodads */
+    );
+
+extern Status XkbAllocGeomOutlines(XkbShapePtr /* shape */ ,
+                                   int  /* nOL */
+    );
+
+extern Status XkbAllocGeomRows(XkbSectionPtr /* section */ ,
+                               int      /* nRows */
+    );
+
+extern Status XkbAllocGeomPoints(XkbOutlinePtr /* ol */ ,
+                                 int    /* nPts */
+    );
+
+extern Status XkbAllocGeomKeys(XkbRowPtr /* row */ ,
+                               int      /* nKeys */
+    );
+
+extern Status XkbAllocGeometry(XkbDescPtr /* xkb */ ,
+                               XkbGeometrySizesPtr      /* sizes */
+    );
+
+extern Bool
+ XkbComputeShapeTop(XkbShapePtr /* shape */ ,
+                    XkbBoundsPtr        /* bounds */
+    );
+
+extern Bool
+ XkbComputeShapeBounds(XkbShapePtr      /* shape */
+    );
 
 extern Bool
-XkbGeomRealloc(
-    void **		/* buffer */,
-    int			/* szItems */,
-    int			/* nrItems */,
-    int			/* itemSize */,
-    XkbGeomClearance	/* clearance */
-);
-
-extern Status
-XkbAllocGeomProps(
-    XkbGeometryPtr	/* geom */,
-    int			/* nProps */
-);
-
-extern Status
-XkbAllocGeomKeyAliases(
-    XkbGeometryPtr	/* geom */,
-    int			/* nAliases */
-);
-
-extern Status
-XkbAllocGeomColors(
-    XkbGeometryPtr	/* geom */,
-    int			/* nColors */
-);
-
-extern Status
-XkbAllocGeomShapes(
-    XkbGeometryPtr	/* geom */,
-    int			/* nShapes */
-);
-
-extern Status
-XkbAllocGeomSections(
-    XkbGeometryPtr	/* geom */,
-    int			/* nSections */
-);
-
-extern Status
-XkbAllocGeomOverlays(
-    XkbSectionPtr	/* section */,
-    int			/* num_needed */
-);
-
-extern Status
-XkbAllocGeomOverlayRows(
-    XkbOverlayPtr	/* overlay */,
-    int			/* num_needed */
-);
-
-extern Status
-XkbAllocGeomOverlayKeys(
-    XkbOverlayRowPtr	/* row */,
-    int			/* num_needed */
-);
-
-extern Status
-XkbAllocGeomDoodads(
-    XkbGeometryPtr	/* geom */,
-    int			/* nDoodads */
-);
-
-extern Status
-XkbAllocGeomSectionDoodads(
-    XkbSectionPtr	/* section */,
-    int			/* nDoodads */
-);
-
-extern Status
-XkbAllocGeomOutlines(
-    XkbShapePtr		/* shape */,
-    int			/* nOL */
-);
-
-extern Status
-XkbAllocGeomRows(
-    XkbSectionPtr	/* section */,
-    int			/* nRows */
-);
-
-extern Status
-XkbAllocGeomPoints(
-    XkbOutlinePtr	/* ol */,
-    int			/* nPts */
-);
-
-extern Status
-XkbAllocGeomKeys(
-    XkbRowPtr		/* row */,
-    int			/* nKeys */
-);
-
-extern	Status
-XkbAllocGeometry(
-	XkbDescPtr		/* xkb */,
-	XkbGeometrySizesPtr	/* sizes */
-);
-
-extern	Bool
-XkbComputeShapeTop(
-	XkbShapePtr		/* shape */,
-	XkbBoundsPtr		/* bounds */
-);
-
-extern	Bool
-XkbComputeShapeBounds(
-	XkbShapePtr		/* shape */
-);
-
-extern	Bool
-XkbComputeRowBounds(
-	XkbGeometryPtr		/* geom */,
-	XkbSectionPtr		/* section */,
-	XkbRowPtr		/* row */
-);
-
-extern	Bool
-XkbComputeSectionBounds(
-	XkbGeometryPtr		/* geom */,
-	XkbSectionPtr		/* section */
-);
-
-extern	char *
-XkbFindOverlayForKey(
-	XkbGeometryPtr		/* geom */,
-	XkbSectionPtr		/* wanted */,
-	char *			/* under */
-);
-
-#endif /* _XKBGEOM_H_ */
+ XkbComputeRowBounds(XkbGeometryPtr /* geom */ ,
+                     XkbSectionPtr /* section */ ,
+                     XkbRowPtr  /* row */
+    );
+
+extern Bool
+ XkbComputeSectionBounds(XkbGeometryPtr /* geom */ ,
+                         XkbSectionPtr  /* section */
+    );
+
+extern char *XkbFindOverlayForKey(XkbGeometryPtr /* geom */ ,
+                                  XkbSectionPtr /* wanted */ ,
+                                  char *        /* under */
+    );
+
+#endif                          /* _XKBGEOM_H_ */
diff --git a/xorg-server/xkb/xkbout.c b/xorg-server/xkb/xkbout.c
index 889d5cc39..cd1ae0b4e 100644
--- a/xorg-server/xkb/xkbout.c
+++ b/xorg-server/xkb/xkbout.c
@@ -52,849 +52,874 @@
 #define	VMOD_COMMENT_VALUE 2
 
 static Bool
-WriteXKBVModDecl(FILE *file,XkbDescPtr xkb,int showValue)
+WriteXKBVModDecl(FILE * file, XkbDescPtr xkb, int showValue)
 {
-register int 	i,nMods;
-Atom *		vmodNames;
-
-    if (xkb==NULL)
-	return FALSE;
-    if (xkb->names!=NULL)
-	 vmodNames= xkb->names->vmods;
-    else vmodNames= NULL;
-
-    for (i=nMods=0;i<XkbNumVirtualMods;i++) {
-	if ((vmodNames!=NULL)&&(vmodNames[i]!=None)) {
-	    if (nMods==0)	fprintf(file,"    virtual_modifiers ");
-	    else		fprintf(file,",");
-	    fprintf(file,"%s",XkbAtomText(vmodNames[i],XkbXKBFile));
-	    if ((showValue!=VMOD_HIDE_VALUE)&&
-		(xkb->server)&&(xkb->server->vmods[i]!=XkbNoModifierMask)) {
-		if (showValue==VMOD_COMMENT_VALUE) {
-		    fprintf(file,"/* = %s */",
-			XkbModMaskText(xkb->server->vmods[i],XkbXKBFile));
-		}
-		else  {
-		    fprintf(file,"= %s",
-			XkbModMaskText(xkb->server->vmods[i],XkbXKBFile));
-		}
-	    }
-	    nMods++;
-	}
-    }
-    if (nMods>0)
-	fprintf(file,";\n\n");
+    register int i, nMods;
+    Atom *vmodNames;
+
+    if (xkb == NULL)
+        return FALSE;
+    if (xkb->names != NULL)
+        vmodNames = xkb->names->vmods;
+    else
+        vmodNames = NULL;
+
+    for (i = nMods = 0; i < XkbNumVirtualMods; i++) {
+        if ((vmodNames != NULL) && (vmodNames[i] != None)) {
+            if (nMods == 0)
+                fprintf(file, "    virtual_modifiers ");
+            else
+                fprintf(file, ",");
+            fprintf(file, "%s", XkbAtomText(vmodNames[i], XkbXKBFile));
+            if ((showValue != VMOD_HIDE_VALUE) &&
+                (xkb->server) && (xkb->server->vmods[i] != XkbNoModifierMask)) {
+                if (showValue == VMOD_COMMENT_VALUE) {
+                    fprintf(file, "/* = %s */",
+                            XkbModMaskText(xkb->server->vmods[i], XkbXKBFile));
+                }
+                else {
+                    fprintf(file, "= %s",
+                            XkbModMaskText(xkb->server->vmods[i], XkbXKBFile));
+                }
+            }
+            nMods++;
+        }
+    }
+    if (nMods > 0)
+        fprintf(file, ";\n\n");
     return TRUE;
 }
 
 /***====================================================================***/
 
 static Bool
-WriteXKBAction(FILE *file,XkbDescPtr xkb,XkbAnyAction *action)
+WriteXKBAction(FILE * file, XkbDescPtr xkb, XkbAnyAction * action)
 {
-    fprintf(file,"%s",XkbActionText(xkb,(XkbAction *)action,XkbXKBFile));
+    fprintf(file, "%s", XkbActionText(xkb, (XkbAction *) action, XkbXKBFile));
     return TRUE;
 }
 
 /***====================================================================***/
 
 Bool
-XkbWriteXKBKeycodes(	FILE *			file,
-			XkbDescPtr		xkb,
-			Bool			topLevel,
-			Bool			showImplicit,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+XkbWriteXKBKeycodes(FILE * file,
+                    XkbDescPtr xkb,
+                    Bool topLevel,
+                    Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
 {
-Atom			kcName;
-register unsigned 	i;
-const char *		alternate;
-
-    if ((!xkb)||(!xkb->names)||(!xkb->names->keys)) {
-	_XkbLibError(_XkbErrMissingNames,"XkbWriteXKBKeycodes",0);
-	return FALSE;
-    }
-    kcName= xkb->names->keycodes;
-    if (kcName!=None)
-	 fprintf(file,"xkb_keycodes \"%s\" {\n",
-					XkbAtomText(kcName,XkbXKBFile));
-    else fprintf(file,"xkb_keycodes {\n");
-    fprintf(file,"    minimum = %d;\n",xkb->min_key_code);
-    fprintf(file,"    maximum = %d;\n",xkb->max_key_code);
-    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	if (xkb->names->keys[i].name[0]!='\0') {
-	    if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,TRUE)!=i)
-		 alternate= "alternate ";
-	    else alternate= "";
-	    fprintf(file,"    %s%6s = %d;\n",alternate,
-			XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile),
-			i);
-	}
-    }
-    if (xkb->indicators!=NULL) {
-	for (i=0;i<XkbNumIndicators;i++) {
-	    const char *type;
-	    if (xkb->indicators->phys_indicators&(1<<i))
-			type= "    ";
-	    else	type= "    virtual ";
-	    if (xkb->names->indicators[i]!=None) {
-		fprintf(file,"%sindicator %d = \"%s\";\n",type,i+1,
-			XkbAtomText(xkb->names->indicators[i],XkbXKBFile));
-	    }
-	}
-    }
-    if (xkb->names->key_aliases!=NULL) {
-	XkbKeyAliasPtr	pAl;
-	pAl= xkb->names->key_aliases;
-	for (i=0;i<xkb->names->num_key_aliases;i++,pAl++) {
-	    fprintf(file,"    alias %6s = %6s;\n",
-			XkbKeyNameText(pAl->alias,XkbXKBFile),
-			XkbKeyNameText(pAl->real,XkbXKBFile));
-	}
+    Atom kcName;
+    register unsigned i;
+    const char *alternate;
+
+    if ((!xkb) || (!xkb->names) || (!xkb->names->keys)) {
+        _XkbLibError(_XkbErrMissingNames, "XkbWriteXKBKeycodes", 0);
+        return FALSE;
+    }
+    kcName = xkb->names->keycodes;
+    if (kcName != None)
+        fprintf(file, "xkb_keycodes \"%s\" {\n",
+                XkbAtomText(kcName, XkbXKBFile));
+    else
+        fprintf(file, "xkb_keycodes {\n");
+    fprintf(file, "    minimum = %d;\n", xkb->min_key_code);
+    fprintf(file, "    maximum = %d;\n", xkb->max_key_code);
+    for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+        if (xkb->names->keys[i].name[0] != '\0') {
+            if (XkbFindKeycodeByName(xkb, xkb->names->keys[i].name, TRUE) != i)
+                alternate = "alternate ";
+            else
+                alternate = "";
+            fprintf(file, "    %s%6s = %d;\n", alternate,
+                    XkbKeyNameText(xkb->names->keys[i].name, XkbXKBFile), i);
+        }
+    }
+    if (xkb->indicators != NULL) {
+        for (i = 0; i < XkbNumIndicators; i++) {
+            const char *type;
+
+            if (xkb->indicators->phys_indicators & (1 << i))
+                type = "    ";
+            else
+                type = "    virtual ";
+            if (xkb->names->indicators[i] != None) {
+                fprintf(file, "%sindicator %d = \"%s\";\n", type, i + 1,
+                        XkbAtomText(xkb->names->indicators[i], XkbXKBFile));
+            }
+        }
+    }
+    if (xkb->names->key_aliases != NULL) {
+        XkbKeyAliasPtr pAl;
+
+        pAl = xkb->names->key_aliases;
+        for (i = 0; i < xkb->names->num_key_aliases; i++, pAl++) {
+            fprintf(file, "    alias %6s = %6s;\n",
+                    XkbKeyNameText(pAl->alias, XkbXKBFile),
+                    XkbKeyNameText(pAl->real, XkbXKBFile));
+        }
     }
     if (addOn)
-	(*addOn)(file,xkb,topLevel,showImplicit,XkmKeyNamesIndex,priv);
-    fprintf(file,"};\n\n");
+        (*addOn) (file, xkb, topLevel, showImplicit, XkmKeyNamesIndex, priv);
+    fprintf(file, "};\n\n");
     return TRUE;
 }
 
 Bool
-XkbWriteXKBKeyTypes(	FILE *			file,
-			XkbDescPtr              xkb,
-			Bool			topLevel,
-			Bool			showImplicit,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+XkbWriteXKBKeyTypes(FILE * file,
+                    XkbDescPtr xkb,
+                    Bool topLevel,
+                    Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
 {
-register unsigned	i,n;
-XkbKeyTypePtr		type;
-XkbKTMapEntryPtr	entry;
-
-    if ((!xkb)||(!xkb->map)||(!xkb->map->types)) {
-	_XkbLibError(_XkbErrMissingTypes,"XkbWriteXKBKeyTypes",0);
-	return FALSE;
-    }
-    if (xkb->map->num_types<XkbNumRequiredTypes) {
-	_XkbLibError(_XkbErrMissingReqTypes,"XkbWriteXKBKeyTypes",0);
-	return 0;
-    }
-    if ((xkb->names==NULL)||(xkb->names->types==None))
-	 fprintf(file,"xkb_types {\n\n");
-    else fprintf(file,"xkb_types \"%s\" {\n\n",
-			XkbAtomText(xkb->names->types,XkbXKBFile));
-    WriteXKBVModDecl(file,xkb,
-			(showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE));
-
-    type= xkb->map->types;
-    for (i=0;i<xkb->map->num_types;i++,type++) {
-	fprintf(file,"    type \"%s\" {\n",
-		XkbAtomText(type->name,XkbXKBFile));
-	fprintf(file,"        modifiers= %s;\n",
-	       XkbVModMaskText(xkb,type->mods.real_mods,type->mods.vmods,
-								XkbXKBFile));
-	entry= type->map;
-	for (n=0;n<type->map_count;n++,entry++) {
-	    char *str;	
-	    str=XkbVModMaskText(xkb,entry->mods.real_mods,entry->mods.vmods,
-								XkbXKBFile);
-	    fprintf(file,"        map[%s]= Level%d;\n",str,entry->level+1);
-	    if ((type->preserve)&&((type->preserve[n].real_mods)||
-				   (type->preserve[n].vmods))) {
-		fprintf(file,"        preserve[%s]= ",str);
-		fprintf(file,"%s;\n",XkbVModMaskText(xkb,
-					type->preserve[n].real_mods,
-					type->preserve[n].vmods,
-					XkbXKBFile));
-	    }
-	}
-	if (type->level_names!=NULL) {
-	    Atom *name= type->level_names;
-	    for (n=0;n<type->num_levels;n++,name++) {
-		if ((*name)==None)
-		    continue;
-		fprintf(file,"        level_name[Level%d]= \"%s\";\n",n+1,
-					XkbAtomText(*name,XkbXKBFile));
-	    }
-	}
-	fprintf(file,"    };\n");
+    register unsigned i, n;
+    XkbKeyTypePtr type;
+    XkbKTMapEntryPtr entry;
+
+    if ((!xkb) || (!xkb->map) || (!xkb->map->types)) {
+        _XkbLibError(_XkbErrMissingTypes, "XkbWriteXKBKeyTypes", 0);
+        return FALSE;
+    }
+    if (xkb->map->num_types < XkbNumRequiredTypes) {
+        _XkbLibError(_XkbErrMissingReqTypes, "XkbWriteXKBKeyTypes", 0);
+        return 0;
+    }
+    if ((xkb->names == NULL) || (xkb->names->types == None))
+        fprintf(file, "xkb_types {\n\n");
+    else
+        fprintf(file, "xkb_types \"%s\" {\n\n",
+                XkbAtomText(xkb->names->types, XkbXKBFile));
+    WriteXKBVModDecl(file, xkb,
+                     (showImplicit ? VMOD_COMMENT_VALUE : VMOD_HIDE_VALUE));
+
+    type = xkb->map->types;
+    for (i = 0; i < xkb->map->num_types; i++, type++) {
+        fprintf(file, "    type \"%s\" {\n",
+                XkbAtomText(type->name, XkbXKBFile));
+        fprintf(file, "        modifiers= %s;\n",
+                XkbVModMaskText(xkb, type->mods.real_mods, type->mods.vmods,
+                                XkbXKBFile));
+        entry = type->map;
+        for (n = 0; n < type->map_count; n++, entry++) {
+            char *str;
+
+            str = XkbVModMaskText(xkb, entry->mods.real_mods, entry->mods.vmods,
+                                  XkbXKBFile);
+            fprintf(file, "        map[%s]= Level%d;\n", str, entry->level + 1);
+            if ((type->preserve) && ((type->preserve[n].real_mods) ||
+                                     (type->preserve[n].vmods))) {
+                fprintf(file, "        preserve[%s]= ", str);
+                fprintf(file, "%s;\n", XkbVModMaskText(xkb,
+                                                       type->preserve[n].
+                                                       real_mods,
+                                                       type->preserve[n].vmods,
+                                                       XkbXKBFile));
+            }
+        }
+        if (type->level_names != NULL) {
+            Atom *name = type->level_names;
+
+            for (n = 0; n < type->num_levels; n++, name++) {
+                if ((*name) == None)
+                    continue;
+                fprintf(file, "        level_name[Level%d]= \"%s\";\n", n + 1,
+                        XkbAtomText(*name, XkbXKBFile));
+            }
+        }
+        fprintf(file, "    };\n");
     }
     if (addOn)
-	(*addOn)(file,xkb,topLevel,showImplicit,XkmTypesIndex,priv);
-    fprintf(file,"};\n\n");
+        (*addOn) (file, xkb, topLevel, showImplicit, XkmTypesIndex, priv);
+    fprintf(file, "};\n\n");
     return TRUE;
 }
 
 static Bool
-WriteXKBIndicatorMap(	FILE *			file,
-			XkbDescPtr              xkb,
-			Atom			name,
-			XkbIndicatorMapPtr	led,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+WriteXKBIndicatorMap(FILE * file,
+                     XkbDescPtr xkb,
+                     Atom name,
+                     XkbIndicatorMapPtr led, XkbFileAddOnFunc addOn, void *priv)
 {
 
-    fprintf(file,"    indicator \"%s\" {\n",NameForAtom(name));
-    if (led->flags&XkbIM_NoExplicit)
-	fprintf(file,"        !allowExplicit;\n");
-    if (led->flags&XkbIM_LEDDrivesKB)
-	fprintf(file,"        indicatorDrivesKeyboard;\n");
-    if (led->which_groups!=0) {
-	if (led->which_groups!=XkbIM_UseEffective) {
-	    fprintf(file,"        whichGroupState= %s;\n",
-			XkbIMWhichStateMaskText(led->which_groups,XkbXKBFile));
-	}
-	fprintf(file,"        groups= 0x%02x;\n",led->groups);
-    }
-    if (led->which_mods!=0) {
-	if (led->which_mods!=XkbIM_UseEffective) {
-	    fprintf(file,"        whichModState= %s;\n",
-			XkbIMWhichStateMaskText(led->which_mods,XkbXKBFile));
-	}
-	fprintf(file,"        modifiers= %s;\n",
-			XkbVModMaskText(xkb,
-					led->mods.real_mods,led->mods.vmods,
-					XkbXKBFile));
-    }
-    if (led->ctrls!=0) {
-	fprintf(file,"        controls= %s;\n",
-			XkbControlsMaskText(led->ctrls,XkbXKBFile));
+    fprintf(file, "    indicator \"%s\" {\n", NameForAtom(name));
+    if (led->flags & XkbIM_NoExplicit)
+        fprintf(file, "        !allowExplicit;\n");
+    if (led->flags & XkbIM_LEDDrivesKB)
+        fprintf(file, "        indicatorDrivesKeyboard;\n");
+    if (led->which_groups != 0) {
+        if (led->which_groups != XkbIM_UseEffective) {
+            fprintf(file, "        whichGroupState= %s;\n",
+                    XkbIMWhichStateMaskText(led->which_groups, XkbXKBFile));
+        }
+        fprintf(file, "        groups= 0x%02x;\n", led->groups);
+    }
+    if (led->which_mods != 0) {
+        if (led->which_mods != XkbIM_UseEffective) {
+            fprintf(file, "        whichModState= %s;\n",
+                    XkbIMWhichStateMaskText(led->which_mods, XkbXKBFile));
+        }
+        fprintf(file, "        modifiers= %s;\n",
+                XkbVModMaskText(xkb,
+                                led->mods.real_mods, led->mods.vmods,
+                                XkbXKBFile));
+    }
+    if (led->ctrls != 0) {
+        fprintf(file, "        controls= %s;\n",
+                XkbControlsMaskText(led->ctrls, XkbXKBFile));
     }
     if (addOn)
-	(*addOn)(file,xkb,FALSE,TRUE,XkmIndicatorsIndex,priv);
-    fprintf(file,"    };\n");
+        (*addOn) (file, xkb, FALSE, TRUE, XkmIndicatorsIndex, priv);
+    fprintf(file, "    };\n");
     return TRUE;
 }
 
 Bool
-XkbWriteXKBCompatMap(	FILE *			file,
-			XkbDescPtr              xkb,
-			Bool			topLevel,
-			Bool			showImplicit,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+XkbWriteXKBCompatMap(FILE * file,
+                     XkbDescPtr xkb,
+                     Bool topLevel,
+                     Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
 {
-register unsigned	i;
-XkbSymInterpretPtr	interp;
-
-    if ((!xkb)||(!xkb->compat)||(!xkb->compat->sym_interpret)) {
-	_XkbLibError(_XkbErrMissingCompatMap,"XkbWriteXKBCompatMap",0);
-	return FALSE;
-    }
-    if ((xkb->names==NULL)||(xkb->names->compat==None))
-	 fprintf(file,"xkb_compatibility {\n\n");
-    else fprintf(file,"xkb_compatibility \"%s\" {\n\n",
-			XkbAtomText(xkb->names->compat,XkbXKBFile));
-    WriteXKBVModDecl(file,xkb,
-			(showImplicit?VMOD_COMMENT_VALUE:VMOD_HIDE_VALUE));
-
-    fprintf(file,"    interpret.useModMapMods= AnyLevel;\n");
-    fprintf(file,"    interpret.repeat= FALSE;\n");
-    fprintf(file,"    interpret.locking= FALSE;\n");
-    interp= xkb->compat->sym_interpret;
-    for (i=0;i<xkb->compat->num_si;i++,interp++) {
-	fprintf(file,"    interpret %s+%s(%s) {\n",	
-				((interp->sym==NoSymbol)?"Any":
-					XkbKeysymText(interp->sym,XkbXKBFile)),
-				XkbSIMatchText(interp->match,XkbXKBFile),
-				XkbModMaskText(interp->mods,XkbXKBFile));
-	if (interp->virtual_mod!=XkbNoModifier) {
-	    fprintf(file,"        virtualModifier= %s;\n",
-		XkbVModIndexText(xkb,interp->virtual_mod,XkbXKBFile));
-	}
-	if (interp->match&XkbSI_LevelOneOnly)
-	    fprintf(file,"        useModMapMods=level1;\n");
-	if (interp->flags&XkbSI_LockingKey)
-	    fprintf(file,"        locking= TRUE;\n");
-	if (interp->flags&XkbSI_AutoRepeat)
-	    fprintf(file,"        repeat= TRUE;\n");
-	fprintf(file,"        action= ");
-	WriteXKBAction(file,xkb,&interp->act);
-	fprintf(file,";\n");
-	fprintf(file,"    };\n");
-    }
-    for (i=0;i<XkbNumKbdGroups;i++) {
-	XkbModsPtr	gc;
-
-	gc= &xkb->compat->groups[i];
-	if ((gc->real_mods==0)&&(gc->vmods==0))
-	    continue;
-	fprintf(file,"    group %d = %s;\n",i+1,XkbVModMaskText(xkb,
-							gc->real_mods,gc->vmods,
-							XkbXKBFile));
+    register unsigned i;
+    XkbSymInterpretPtr interp;
+
+    if ((!xkb) || (!xkb->compat) || (!xkb->compat->sym_interpret)) {
+        _XkbLibError(_XkbErrMissingCompatMap, "XkbWriteXKBCompatMap", 0);
+        return FALSE;
+    }
+    if ((xkb->names == NULL) || (xkb->names->compat == None))
+        fprintf(file, "xkb_compatibility {\n\n");
+    else
+        fprintf(file, "xkb_compatibility \"%s\" {\n\n",
+                XkbAtomText(xkb->names->compat, XkbXKBFile));
+    WriteXKBVModDecl(file, xkb,
+                     (showImplicit ? VMOD_COMMENT_VALUE : VMOD_HIDE_VALUE));
+
+    fprintf(file, "    interpret.useModMapMods= AnyLevel;\n");
+    fprintf(file, "    interpret.repeat= FALSE;\n");
+    fprintf(file, "    interpret.locking= FALSE;\n");
+    interp = xkb->compat->sym_interpret;
+    for (i = 0; i < xkb->compat->num_si; i++, interp++) {
+        fprintf(file, "    interpret %s+%s(%s) {\n",
+                ((interp->sym == NoSymbol) ? "Any" :
+                 XkbKeysymText(interp->sym, XkbXKBFile)),
+                XkbSIMatchText(interp->match, XkbXKBFile),
+                XkbModMaskText(interp->mods, XkbXKBFile));
+        if (interp->virtual_mod != XkbNoModifier) {
+            fprintf(file, "        virtualModifier= %s;\n",
+                    XkbVModIndexText(xkb, interp->virtual_mod, XkbXKBFile));
+        }
+        if (interp->match & XkbSI_LevelOneOnly)
+            fprintf(file, "        useModMapMods=level1;\n");
+        if (interp->flags & XkbSI_LockingKey)
+            fprintf(file, "        locking= TRUE;\n");
+        if (interp->flags & XkbSI_AutoRepeat)
+            fprintf(file, "        repeat= TRUE;\n");
+        fprintf(file, "        action= ");
+        WriteXKBAction(file, xkb, &interp->act);
+        fprintf(file, ";\n");
+        fprintf(file, "    };\n");
+    }
+    for (i = 0; i < XkbNumKbdGroups; i++) {
+        XkbModsPtr gc;
+
+        gc = &xkb->compat->groups[i];
+        if ((gc->real_mods == 0) && (gc->vmods == 0))
+            continue;
+        fprintf(file, "    group %d = %s;\n", i + 1, XkbVModMaskText(xkb,
+                                                                     gc->
+                                                                     real_mods,
+                                                                     gc->vmods,
+                                                                     XkbXKBFile));
     }
     if (xkb->indicators) {
-	for (i=0;i<XkbNumIndicators;i++) {
-	    XkbIndicatorMapPtr map= &xkb->indicators->maps[i];
-	    if ((map->flags!=0)||(map->which_groups!=0)||(map->groups!=0)||
-		(map->which_mods!=0)||
-		(map->mods.real_mods!=0)||(map->mods.vmods!=0)||
-		(map->ctrls!=0)) {
-		WriteXKBIndicatorMap(file,xkb,xkb->names->indicators[i],map,
-								addOn,priv);
-	    }
-	}
+        for (i = 0; i < XkbNumIndicators; i++) {
+            XkbIndicatorMapPtr map = &xkb->indicators->maps[i];
+
+            if ((map->flags != 0) || (map->which_groups != 0) ||
+                (map->groups != 0) || (map->which_mods != 0) ||
+                (map->mods.real_mods != 0) || (map->mods.vmods != 0) ||
+                (map->ctrls != 0)) {
+                WriteXKBIndicatorMap(file, xkb, xkb->names->indicators[i], map,
+                                     addOn, priv);
+            }
+        }
     }
     if (addOn)
-	(*addOn)(file,xkb,topLevel,showImplicit,XkmCompatMapIndex,priv);
-    fprintf(file,"};\n\n");
+        (*addOn) (file, xkb, topLevel, showImplicit, XkmCompatMapIndex, priv);
+    fprintf(file, "};\n\n");
     return TRUE;
 }
 
 Bool
-XkbWriteXKBSymbols(	FILE *			file,
-			XkbDescPtr              xkb,
-			Bool			topLevel,
-			Bool			showImplicit,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+XkbWriteXKBSymbols(FILE * file,
+                   XkbDescPtr xkb,
+                   Bool topLevel,
+                   Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
 {
-register unsigned	i,tmp;
-XkbClientMapPtr		map;
-XkbServerMapPtr		srv;
-Bool			showActions;
+    register unsigned i, tmp;
+    XkbClientMapPtr map;
+    XkbServerMapPtr srv;
+    Bool showActions;
 
     if (!xkb) {
-	_XkbLibError(_XkbErrMissingSymbols,"XkbWriteXKBSymbols",0);
-	return FALSE;
-    }
-
-    map= xkb->map;
-    if ((!map)||(!map->syms)||(!map->key_sym_map)) {
-	_XkbLibError(_XkbErrMissingSymbols,"XkbWriteXKBSymbols",0);
-	return FALSE;
-    }
-    if ((!xkb->names)||(!xkb->names->keys)) {
-	_XkbLibError(_XkbErrMissingNames,"XkbWriteXKBSymbols",0);
-	return FALSE;
-    }
-    if ((xkb->names==NULL)||(xkb->names->symbols==None))
-	 fprintf(file,"xkb_symbols {\n\n");
-    else fprintf(file,"xkb_symbols \"%s\" {\n\n",
-			XkbAtomText(xkb->names->symbols,XkbXKBFile));
-    for (tmp=i=0;i<XkbNumKbdGroups;i++) {
-	if (xkb->names->groups[i]!=None) {
-	    fprintf(file,"    name[group%d]=\"%s\";\n",i+1,
-			XkbAtomText(xkb->names->groups[i],XkbXKBFile));
-	    tmp++;
-	}
-    }
-    if (tmp>0)
-	fprintf(file,"\n");
-    srv= xkb->server;
-    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	Bool	simple;
-	if ((int)XkbKeyNumSyms(xkb,i)<1)
-	    continue;
-	if (XkbFindKeycodeByName(xkb,xkb->names->keys[i].name,TRUE)!=i)
-	    continue;
-	simple= TRUE;
-	fprintf(file,"    key %6s {",
-			XkbKeyNameText(xkb->names->keys[i].name,XkbXKBFile));
-	if (srv->explicit) {
-	    if (((srv->explicit[i]&XkbExplicitKeyTypesMask)!=0)||
-	   						(showImplicit)) {
-		int 	typeNdx,g;
-		Bool	multi;
-		const char *	comment="  ";
-
-		if ((srv->explicit[i]&XkbExplicitKeyTypesMask)==0)
-		    comment= "//";
-		multi= FALSE;
-		typeNdx= XkbKeyKeyTypeIndex(xkb,i,0);
-		for (g=1;(g<XkbKeyNumGroups(xkb,i))&&(!multi);g++) {
-		    if (XkbKeyKeyTypeIndex(xkb,i,g)!=typeNdx)
-			multi= TRUE;
-		}
-		if (multi) {
-		    for (g=0;g<XkbKeyNumGroups(xkb,i);g++) {
-			typeNdx= XkbKeyKeyTypeIndex(xkb,i,g);
-			if (srv->explicit[i]&(1<<g)) {
-			    fprintf(file,"\n%s      type[group%d]= \"%s\",",
-			    	comment,g+1,
-				XkbAtomText(map->types[typeNdx].name,
-			    	XkbXKBFile));
-			}
-			else if (showImplicit) {
-			    fprintf(file,"\n//      type[group%d]= \"%s\",",g+1,
-				XkbAtomText(map->types[typeNdx].name,
-			    	XkbXKBFile));
-			}
-		    }
-		}
-		else {
-		    fprintf(file,"\n%s      type= \"%s\",",comment,
-				XkbAtomText(map->types[typeNdx].name,
-			    	XkbXKBFile));
-		}
-		simple= FALSE;
-	    }
-	    if (((srv->explicit[i]&XkbExplicitAutoRepeatMask)!=0)&&
-		    					  (xkb->ctrls!=NULL)) {
-		if (xkb->ctrls->per_key_repeat[i/8]&(1<<(i%8)))
-		     fprintf(file,"\n        repeat= Yes,");
-		else fprintf(file,"\n        repeat= No,");
-		simple= FALSE;
-	    }
-	    if ((xkb->server!=NULL)&&(xkb->server->vmodmap!=NULL)&&
-					(xkb->server->vmodmap[i]!=0)) {
-		if ((srv->explicit[i]&XkbExplicitVModMapMask)!=0) {
-		    fprintf(file,"\n        virtualMods= %s,",
-				XkbVModMaskText(xkb,0,
-						xkb->server->vmodmap[i],
-						XkbXKBFile));
-		}
-		else if (showImplicit) {
-		    fprintf(file,"\n//      virtualMods= %s,",
-				XkbVModMaskText(xkb,0,
-						xkb->server->vmodmap[i],
-						XkbXKBFile));
-		}
-	    }
-	}
-	switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(xkb,i))) {
-	    case XkbClampIntoRange:
-		fprintf(file,"\n        groupsClamp,");
-		break;
-	    case XkbRedirectIntoRange:
-		fprintf(file,"\n        groupsRedirect= Group%d,",
-			XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(xkb,i))+1);
-		break;
-	}
-	if (srv->behaviors!=NULL) {
-	    unsigned type;
-	    type= srv->behaviors[i].type&XkbKB_OpMask;
-
-	    if (type!=XkbKB_Default) {
-		simple= FALSE;
-		fprintf(file,"\n        %s,",
-			XkbBehaviorText(xkb,&srv->behaviors[i],XkbXKBFile));
-	    }
-	}
-	if ((srv->explicit==NULL) || showImplicit ||
-	    ((srv->explicit[i]&XkbExplicitInterpretMask)!=0))
-	     showActions= XkbKeyHasActions(xkb,i);
-	else showActions= FALSE;
-	
-	if (((unsigned)XkbKeyNumGroups(xkb,i)>1)||showActions)
-	    simple= FALSE;
-	if (simple) {
-	    KeySym *syms;
-	    unsigned s;
-
-	    syms= XkbKeySymsPtr(xkb,i);
-	    fprintf(file,"         [ ");
-	    for (s=0;s<XkbKeyGroupWidth(xkb,i,XkbGroup1Index);s++) {
-		if (s!=0)
-		    fprintf(file,", ");
-		fprintf(file,"%15s",XkbKeysymText(*syms++,XkbXKBFile));
-	    }
-	    fprintf(file," ] };\n");
-	}
-	else {
-	    unsigned g,s;
-	    KeySym *syms;
-	    XkbAction *acts;
-	    syms= XkbKeySymsPtr(xkb,i);
-	    acts= XkbKeyActionsPtr(xkb,i);
-	    for (g=0;g<XkbKeyNumGroups(xkb,i);g++) {
-		if (g!=0)
-		    fprintf(file,",");
-		fprintf(file,"\n        symbols[Group%d]= [ ",g+1);
-		for (s=0;s<XkbKeyGroupWidth(xkb,i,g);s++) {
-		    if (s!=0)
-			fprintf(file,", ");
-		    fprintf(file,"%15s",XkbKeysymText(syms[s],XkbXKBFile));
-		}
-		fprintf(file," ]");
-		syms+= XkbKeyGroupsWidth(xkb,i);
-		if (showActions) {
-		    fprintf(file,",\n        actions[Group%d]= [ ",g+1);
-		    for (s=0;s<XkbKeyGroupWidth(xkb,i,g);s++) {
-			if (s!=0)
-			    fprintf(file,", ");
-			WriteXKBAction(file,xkb,(XkbAnyAction *)&acts[s]);
-		    }
-		    fprintf(file," ]");
-		    acts+= XkbKeyGroupsWidth(xkb,i);
-		}
-	    }
-	    fprintf(file,"\n    };\n");
-	}
+        _XkbLibError(_XkbErrMissingSymbols, "XkbWriteXKBSymbols", 0);
+        return FALSE;
+    }
+
+    map = xkb->map;
+    if ((!map) || (!map->syms) || (!map->key_sym_map)) {
+        _XkbLibError(_XkbErrMissingSymbols, "XkbWriteXKBSymbols", 0);
+        return FALSE;
+    }
+    if ((!xkb->names) || (!xkb->names->keys)) {
+        _XkbLibError(_XkbErrMissingNames, "XkbWriteXKBSymbols", 0);
+        return FALSE;
+    }
+    if ((xkb->names == NULL) || (xkb->names->symbols == None))
+        fprintf(file, "xkb_symbols {\n\n");
+    else
+        fprintf(file, "xkb_symbols \"%s\" {\n\n",
+                XkbAtomText(xkb->names->symbols, XkbXKBFile));
+    for (tmp = i = 0; i < XkbNumKbdGroups; i++) {
+        if (xkb->names->groups[i] != None) {
+            fprintf(file, "    name[group%d]=\"%s\";\n", i + 1,
+                    XkbAtomText(xkb->names->groups[i], XkbXKBFile));
+            tmp++;
+        }
+    }
+    if (tmp > 0)
+        fprintf(file, "\n");
+    srv = xkb->server;
+    for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+        Bool simple;
+
+        if ((int) XkbKeyNumSyms(xkb, i) < 1)
+            continue;
+        if (XkbFindKeycodeByName(xkb, xkb->names->keys[i].name, TRUE) != i)
+            continue;
+        simple = TRUE;
+        fprintf(file, "    key %6s {",
+                XkbKeyNameText(xkb->names->keys[i].name, XkbXKBFile));
+        if (srv->explicit) {
+            if (((srv->explicit[i] & XkbExplicitKeyTypesMask) != 0) ||
+                (showImplicit)) {
+                int typeNdx, g;
+                Bool multi;
+                const char *comment = "  ";
+
+                if ((srv->explicit[i] & XkbExplicitKeyTypesMask) == 0)
+                    comment = "//";
+                multi = FALSE;
+                typeNdx = XkbKeyKeyTypeIndex(xkb, i, 0);
+                for (g = 1; (g < XkbKeyNumGroups(xkb, i)) && (!multi); g++) {
+                    if (XkbKeyKeyTypeIndex(xkb, i, g) != typeNdx)
+                        multi = TRUE;
+                }
+                if (multi) {
+                    for (g = 0; g < XkbKeyNumGroups(xkb, i); g++) {
+                        typeNdx = XkbKeyKeyTypeIndex(xkb, i, g);
+                        if (srv->explicit[i] & (1 << g)) {
+                            fprintf(file, "\n%s      type[group%d]= \"%s\",",
+                                    comment, g + 1,
+                                    XkbAtomText(map->types[typeNdx].name,
+                                                XkbXKBFile));
+                        }
+                        else if (showImplicit) {
+                            fprintf(file, "\n//      type[group%d]= \"%s\",",
+                                    g + 1, XkbAtomText(map->types[typeNdx].name,
+                                                       XkbXKBFile));
+                        }
+                    }
+                }
+                else {
+                    fprintf(file, "\n%s      type= \"%s\",", comment,
+                            XkbAtomText(map->types[typeNdx].name, XkbXKBFile));
+                }
+                simple = FALSE;
+            }
+            if (((srv->explicit[i] & XkbExplicitAutoRepeatMask) != 0) &&
+                (xkb->ctrls != NULL)) {
+                if (xkb->ctrls->per_key_repeat[i / 8] & (1 << (i % 8)))
+                    fprintf(file, "\n        repeat= Yes,");
+                else
+                    fprintf(file, "\n        repeat= No,");
+                simple = FALSE;
+            }
+            if ((xkb->server != NULL) && (xkb->server->vmodmap != NULL) &&
+                (xkb->server->vmodmap[i] != 0)) {
+                if ((srv->explicit[i] & XkbExplicitVModMapMask) != 0) {
+                    fprintf(file, "\n        virtualMods= %s,",
+                            XkbVModMaskText(xkb, 0,
+                                            xkb->server->vmodmap[i],
+                                            XkbXKBFile));
+                }
+                else if (showImplicit) {
+                    fprintf(file, "\n//      virtualMods= %s,",
+                            XkbVModMaskText(xkb, 0,
+                                            xkb->server->vmodmap[i],
+                                            XkbXKBFile));
+                }
+            }
+        }
+        switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(xkb, i))) {
+        case XkbClampIntoRange:
+            fprintf(file, "\n        groupsClamp,");
+            break;
+        case XkbRedirectIntoRange:
+            fprintf(file, "\n        groupsRedirect= Group%d,",
+                    XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(xkb, i)) + 1);
+            break;
+        }
+        if (srv->behaviors != NULL) {
+            unsigned type;
+
+            type = srv->behaviors[i].type & XkbKB_OpMask;
+
+            if (type != XkbKB_Default) {
+                simple = FALSE;
+                fprintf(file, "\n        %s,",
+                        XkbBehaviorText(xkb, &srv->behaviors[i], XkbXKBFile));
+            }
+        }
+        if ((srv->explicit == NULL) || showImplicit ||
+            ((srv->explicit[i] & XkbExplicitInterpretMask) != 0))
+            showActions = XkbKeyHasActions(xkb, i);
+        else
+            showActions = FALSE;
+
+        if (((unsigned) XkbKeyNumGroups(xkb, i) > 1) || showActions)
+            simple = FALSE;
+        if (simple) {
+            KeySym *syms;
+            unsigned s;
+
+            syms = XkbKeySymsPtr(xkb, i);
+            fprintf(file, "         [ ");
+            for (s = 0; s < XkbKeyGroupWidth(xkb, i, XkbGroup1Index); s++) {
+                if (s != 0)
+                    fprintf(file, ", ");
+                fprintf(file, "%15s", XkbKeysymText(*syms++, XkbXKBFile));
+            }
+            fprintf(file, " ] };\n");
+        }
+        else {
+            unsigned g, s;
+            KeySym *syms;
+            XkbAction *acts;
+
+            syms = XkbKeySymsPtr(xkb, i);
+            acts = XkbKeyActionsPtr(xkb, i);
+            for (g = 0; g < XkbKeyNumGroups(xkb, i); g++) {
+                if (g != 0)
+                    fprintf(file, ",");
+                fprintf(file, "\n        symbols[Group%d]= [ ", g + 1);
+                for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) {
+                    if (s != 0)
+                        fprintf(file, ", ");
+                    fprintf(file, "%15s", XkbKeysymText(syms[s], XkbXKBFile));
+                }
+                fprintf(file, " ]");
+                syms += XkbKeyGroupsWidth(xkb, i);
+                if (showActions) {
+                    fprintf(file, ",\n        actions[Group%d]= [ ", g + 1);
+                    for (s = 0; s < XkbKeyGroupWidth(xkb, i, g); s++) {
+                        if (s != 0)
+                            fprintf(file, ", ");
+                        WriteXKBAction(file, xkb, (XkbAnyAction *) & acts[s]);
+                    }
+                    fprintf(file, " ]");
+                    acts += XkbKeyGroupsWidth(xkb, i);
+                }
+            }
+            fprintf(file, "\n    };\n");
+        }
     }
     if (map && map->modmap) {
-	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
-	    if (map->modmap[i]!=0) {
-		register int n,bit;
-		for (bit=1,n=0;n<XkbNumModifiers;n++,bit<<=1) {
-		    if (map->modmap[i]&bit) {
-			char buf[5];
-			memcpy(buf,xkb->names->keys[i].name,4);
-			buf[4]= '\0';
-			fprintf(file,"    modifier_map %s { <%s> };\n",
-					XkbModIndexText(n,XkbXKBFile),buf);
-		    }
-		}
-	    }
-	}
+        for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+            if (map->modmap[i] != 0) {
+                register int n, bit;
+
+                for (bit = 1, n = 0; n < XkbNumModifiers; n++, bit <<= 1) {
+                    if (map->modmap[i] & bit) {
+                        char buf[5];
+
+                        memcpy(buf, xkb->names->keys[i].name, 4);
+                        buf[4] = '\0';
+                        fprintf(file, "    modifier_map %s { <%s> };\n",
+                                XkbModIndexText(n, XkbXKBFile), buf);
+                    }
+                }
+            }
+        }
     }
     if (addOn)
-	(*addOn)(file,xkb,topLevel,showImplicit,XkmSymbolsIndex,priv);
-    fprintf(file,"};\n\n");
+        (*addOn) (file, xkb, topLevel, showImplicit, XkmSymbolsIndex, priv);
+    fprintf(file, "};\n\n");
     return TRUE;
 }
 
 static Bool
-WriteXKBOutline(	FILE *		file,
-			XkbShapePtr	shape,
-			XkbOutlinePtr	outline,
-			int		lastRadius,
-			int		first,
-			int		indent)
+WriteXKBOutline(FILE * file,
+                XkbShapePtr shape,
+                XkbOutlinePtr outline, int lastRadius, int first, int indent)
 {
-register int	i;
-XkbPointPtr	pt;
-char *		iStr;
-
-    fprintf(file,"%s",iStr= XkbIndentText(first));
-    if (first!=indent)
-	iStr= XkbIndentText(indent);
-    if (outline->corner_radius!=lastRadius) {
-	fprintf(file,"corner= %s,",
-			XkbGeomFPText(outline->corner_radius,XkbMessage));
-	if (shape!=NULL) {
-	    fprintf(file,"\n%s",iStr);
-	}
+    register int i;
+    XkbPointPtr pt;
+    char *iStr;
+
+    fprintf(file, "%s", iStr = XkbIndentText(first));
+    if (first != indent)
+        iStr = XkbIndentText(indent);
+    if (outline->corner_radius != lastRadius) {
+        fprintf(file, "corner= %s,",
+                XkbGeomFPText(outline->corner_radius, XkbMessage));
+        if (shape != NULL) {
+            fprintf(file, "\n%s", iStr);
+        }
     }
     if (shape) {
-	if (outline==shape->approx)
-	    fprintf(file,"approx= ");
-	else if (outline==shape->primary)
-	    fprintf(file,"primary= ");
-    }
-    fprintf(file,"{");
-    for (pt=outline->points,i=0;i<outline->num_points;i++,pt++) {
-	if (i==0)		fprintf(file," ");
-	else if ((i%4)==0)	fprintf(file,",\n%s  ",iStr);
-	else			fprintf(file,", ");
-	fprintf(file,"[ %3s, %3s ]",XkbGeomFPText(pt->x,XkbXKBFile),
-				  XkbGeomFPText(pt->y,XkbXKBFile));
-    }
-    fprintf(file," }");
+        if (outline == shape->approx)
+            fprintf(file, "approx= ");
+        else if (outline == shape->primary)
+            fprintf(file, "primary= ");
+    }
+    fprintf(file, "{");
+    for (pt = outline->points, i = 0; i < outline->num_points; i++, pt++) {
+        if (i == 0)
+            fprintf(file, " ");
+        else if ((i % 4) == 0)
+            fprintf(file, ",\n%s  ", iStr);
+        else
+            fprintf(file, ", ");
+        fprintf(file, "[ %3s, %3s ]", XkbGeomFPText(pt->x, XkbXKBFile),
+                XkbGeomFPText(pt->y, XkbXKBFile));
+    }
+    fprintf(file, " }");
     return TRUE;
 }
 
 static Bool
-WriteXKBDoodad(	FILE *		file,
-		unsigned	indent,
-		XkbGeometryPtr	geom,
-		XkbDoodadPtr	doodad)
+WriteXKBDoodad(FILE * file,
+               unsigned indent, XkbGeometryPtr geom, XkbDoodadPtr doodad)
 {
-register char *	i_str;
-XkbShapePtr	shape;
-XkbColorPtr	color;
-
-    i_str= XkbIndentText(indent);
-    fprintf(file,"%s%s \"%s\" {\n",i_str,
-				XkbDoodadTypeText(doodad->any.type,XkbMessage),
-				XkbAtomText(doodad->any.name,XkbMessage));
-    fprintf(file,"%s    top=      %s;\n",i_str,
-				 XkbGeomFPText(doodad->any.top,XkbXKBFile));
-    fprintf(file,"%s    left=     %s;\n",i_str,
-				XkbGeomFPText(doodad->any.left,XkbXKBFile));
-    fprintf(file,"%s    priority= %d;\n",i_str,doodad->any.priority);
+    register char *i_str;
+    XkbShapePtr shape;
+    XkbColorPtr color;
+
+    i_str = XkbIndentText(indent);
+    fprintf(file, "%s%s \"%s\" {\n", i_str,
+            XkbDoodadTypeText(doodad->any.type, XkbMessage),
+            XkbAtomText(doodad->any.name, XkbMessage));
+    fprintf(file, "%s    top=      %s;\n", i_str,
+            XkbGeomFPText(doodad->any.top, XkbXKBFile));
+    fprintf(file, "%s    left=     %s;\n", i_str,
+            XkbGeomFPText(doodad->any.left, XkbXKBFile));
+    fprintf(file, "%s    priority= %d;\n", i_str, doodad->any.priority);
     switch (doodad->any.type) {
-	case XkbOutlineDoodad:
-	case XkbSolidDoodad:
-	    if (doodad->shape.angle!=0) {
-		fprintf(file,"%s    angle=  %s;\n",i_str,
-			     XkbGeomFPText(doodad->shape.angle,XkbXKBFile));
-	    }
-	    if (doodad->shape.color_ndx!=0) {
-		fprintf(file,"%s    color= \"%s\";\n",i_str,
-			     XkbShapeDoodadColor(geom,&doodad->shape)->spec);
-	    }
-	    shape= XkbShapeDoodadShape(geom,&doodad->shape);
-	    fprintf(file,"%s    shape= \"%s\";\n",i_str,
-			    XkbAtomText(shape->name,XkbXKBFile));
-	    break;
-	case XkbTextDoodad:
-	    if (doodad->text.angle!=0) {
-		fprintf(file,"%s    angle=  %s;\n",i_str,
-			     XkbGeomFPText(doodad->text.angle,XkbXKBFile));
-	    }
-	    if (doodad->text.width!=0) {
-		fprintf(file,"%s    width=  %s;\n",i_str,
-			     XkbGeomFPText(doodad->text.width,XkbXKBFile));
-
-	    }
-	    if (doodad->text.height!=0) {
-		fprintf(file,"%s    height=  %s;\n",i_str,
-			     XkbGeomFPText(doodad->text.height,XkbXKBFile));
-
-	    }
-	    if (doodad->text.color_ndx!=0) {
-		color= XkbTextDoodadColor(geom,&doodad->text);
-		fprintf(file,"%s    color= \"%s\";\n",i_str,
-			     XkbStringText(color->spec,XkbXKBFile));
-	    }
-	    fprintf(file,"%s    XFont= \"%s\";\n",i_str,
-	    		     XkbStringText(doodad->text.font,XkbXKBFile));
-	    fprintf(file,"%s    text=  \"%s\";\n",i_str,
-	    		    XkbStringText(doodad->text.text,XkbXKBFile));
-	    break;
-	case XkbIndicatorDoodad:
-	    shape= XkbIndicatorDoodadShape(geom,&doodad->indicator);
-	    color= XkbIndicatorDoodadOnColor(geom,&doodad->indicator);
-	    fprintf(file,"%s    onColor= \"%s\";\n",i_str,
-	    		    XkbStringText(color->spec,XkbXKBFile));
-	    color= XkbIndicatorDoodadOffColor(geom,&doodad->indicator);
-	    fprintf(file,"%s    offColor= \"%s\";\n",i_str,
-	    		    XkbStringText(color->spec,XkbXKBFile));
-	    fprintf(file,"%s    shape= \"%s\";\n",i_str,
-			     XkbAtomText(shape->name,XkbXKBFile));
-	    break;
-	case XkbLogoDoodad:
-	    fprintf(file,"%s    logoName= \"%s\";\n",i_str,
-			     XkbStringText(doodad->logo.logo_name,XkbXKBFile));
-	    if (doodad->shape.angle!=0) {
-		fprintf(file,"%s    angle=  %s;\n",i_str,
-			     XkbGeomFPText(doodad->logo.angle,XkbXKBFile));
-	    }
-	    if (doodad->shape.color_ndx!=0) {
-		fprintf(file,"%s    color= \"%s\";\n",i_str,
-			     XkbLogoDoodadColor(geom,&doodad->logo)->spec);
-	    }
-	    shape= XkbLogoDoodadShape(geom,&doodad->logo);
-	    fprintf(file,"%s    shape= \"%s\";\n",i_str,
-			    XkbAtomText(shape->name,XkbXKBFile));
-	    break;
-    }
-    fprintf(file,"%s};\n",i_str);
+    case XkbOutlineDoodad:
+    case XkbSolidDoodad:
+        if (doodad->shape.angle != 0) {
+            fprintf(file, "%s    angle=  %s;\n", i_str,
+                    XkbGeomFPText(doodad->shape.angle, XkbXKBFile));
+        }
+        if (doodad->shape.color_ndx != 0) {
+            fprintf(file, "%s    color= \"%s\";\n", i_str,
+                    XkbShapeDoodadColor(geom, &doodad->shape)->spec);
+        }
+        shape = XkbShapeDoodadShape(geom, &doodad->shape);
+        fprintf(file, "%s    shape= \"%s\";\n", i_str,
+                XkbAtomText(shape->name, XkbXKBFile));
+        break;
+    case XkbTextDoodad:
+        if (doodad->text.angle != 0) {
+            fprintf(file, "%s    angle=  %s;\n", i_str,
+                    XkbGeomFPText(doodad->text.angle, XkbXKBFile));
+        }
+        if (doodad->text.width != 0) {
+            fprintf(file, "%s    width=  %s;\n", i_str,
+                    XkbGeomFPText(doodad->text.width, XkbXKBFile));
+
+        }
+        if (doodad->text.height != 0) {
+            fprintf(file, "%s    height=  %s;\n", i_str,
+                    XkbGeomFPText(doodad->text.height, XkbXKBFile));
+
+        }
+        if (doodad->text.color_ndx != 0) {
+            color = XkbTextDoodadColor(geom, &doodad->text);
+            fprintf(file, "%s    color= \"%s\";\n", i_str,
+                    XkbStringText(color->spec, XkbXKBFile));
+        }
+        fprintf(file, "%s    XFont= \"%s\";\n", i_str,
+                XkbStringText(doodad->text.font, XkbXKBFile));
+        fprintf(file, "%s    text=  \"%s\";\n", i_str,
+                XkbStringText(doodad->text.text, XkbXKBFile));
+        break;
+    case XkbIndicatorDoodad:
+        shape = XkbIndicatorDoodadShape(geom, &doodad->indicator);
+        color = XkbIndicatorDoodadOnColor(geom, &doodad->indicator);
+        fprintf(file, "%s    onColor= \"%s\";\n", i_str,
+                XkbStringText(color->spec, XkbXKBFile));
+        color = XkbIndicatorDoodadOffColor(geom, &doodad->indicator);
+        fprintf(file, "%s    offColor= \"%s\";\n", i_str,
+                XkbStringText(color->spec, XkbXKBFile));
+        fprintf(file, "%s    shape= \"%s\";\n", i_str,
+                XkbAtomText(shape->name, XkbXKBFile));
+        break;
+    case XkbLogoDoodad:
+        fprintf(file, "%s    logoName= \"%s\";\n", i_str,
+                XkbStringText(doodad->logo.logo_name, XkbXKBFile));
+        if (doodad->shape.angle != 0) {
+            fprintf(file, "%s    angle=  %s;\n", i_str,
+                    XkbGeomFPText(doodad->logo.angle, XkbXKBFile));
+        }
+        if (doodad->shape.color_ndx != 0) {
+            fprintf(file, "%s    color= \"%s\";\n", i_str,
+                    XkbLogoDoodadColor(geom, &doodad->logo)->spec);
+        }
+        shape = XkbLogoDoodadShape(geom, &doodad->logo);
+        fprintf(file, "%s    shape= \"%s\";\n", i_str,
+                XkbAtomText(shape->name, XkbXKBFile));
+        break;
+    }
+    fprintf(file, "%s};\n", i_str);
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-WriteXKBOverlay(	FILE *		file,
-			unsigned	indent,
-			XkbGeometryPtr	geom,
-			XkbOverlayPtr	ol)
+ /*ARGSUSED*/ static Bool
+WriteXKBOverlay(FILE * file,
+                unsigned indent, XkbGeometryPtr geom, XkbOverlayPtr ol)
 {
-register char *		i_str;
-int			r,k,nOut;
-XkbOverlayRowPtr	row;
-XkbOverlayKeyPtr	key;
-
-    i_str= XkbIndentText(indent);
-    if (ol->name!=None) {
-	 fprintf(file,"%soverlay \"%s\" {\n",i_str,
-    					XkbAtomText(ol->name,XkbMessage));
-    }
-    else fprintf(file,"%soverlay {\n",i_str);
-    for (nOut=r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
-	for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
-	    char *over,*under;
-	    over= XkbKeyNameText(key->over.name,XkbXKBFile);
-	    under= XkbKeyNameText(key->under.name,XkbXKBFile);
-	    if (nOut==0)
-		 fprintf(file,"%s    %6s=%6s",i_str,under,over);
-	    else if ((nOut%4)==0)
-		 fprintf(file,",\n%s    %6s=%6s",i_str,under,over);
-	    else fprintf(file,", %6s=%6s",under,over);
-	    nOut++;
-	}
-    }
-    fprintf(file,"\n%s};\n",i_str);
+    register char *i_str;
+    int r, k, nOut;
+    XkbOverlayRowPtr row;
+    XkbOverlayKeyPtr key;
+
+    i_str = XkbIndentText(indent);
+    if (ol->name != None) {
+        fprintf(file, "%soverlay \"%s\" {\n", i_str,
+                XkbAtomText(ol->name, XkbMessage));
+    }
+    else
+        fprintf(file, "%soverlay {\n", i_str);
+    for (nOut = r = 0, row = ol->rows; r < ol->num_rows; r++, row++) {
+        for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+            char *over, *under;
+
+            over = XkbKeyNameText(key->over.name, XkbXKBFile);
+            under = XkbKeyNameText(key->under.name, XkbXKBFile);
+            if (nOut == 0)
+                fprintf(file, "%s    %6s=%6s", i_str, under, over);
+            else if ((nOut % 4) == 0)
+                fprintf(file, ",\n%s    %6s=%6s", i_str, under, over);
+            else
+                fprintf(file, ", %6s=%6s", under, over);
+            nOut++;
+        }
+    }
+    fprintf(file, "\n%s};\n", i_str);
     return TRUE;
 }
 
 static Bool
-WriteXKBSection(	FILE *		file,
-			XkbSectionPtr 	s,
-			XkbGeometryPtr	geom)
+WriteXKBSection(FILE * file, XkbSectionPtr s, XkbGeometryPtr geom)
 {
-register int	i;
-XkbRowPtr	row;
-int		dfltKeyColor = 0;
-
-    fprintf(file,"    section \"%s\" {\n",
-				XkbAtomText(s->name,XkbXKBFile));
-    if (s->rows&&(s->rows->num_keys>0)) {
-	dfltKeyColor= s->rows->keys[0].color_ndx;
-	fprintf(file,"        key.color= \"%s\";\n",
-		XkbStringText(geom->colors[dfltKeyColor].spec,XkbXKBFile));
-    }
-    fprintf(file,"        priority=  %d;\n",s->priority);
-    fprintf(file,"        top=       %s;\n",XkbGeomFPText(s->top,XkbXKBFile));
-    fprintf(file,"        left=      %s;\n",XkbGeomFPText(s->left,XkbXKBFile));
-    fprintf(file,"        width=     %s;\n",XkbGeomFPText(s->width,XkbXKBFile));
-    fprintf(file,"        height=    %s;\n",
-					XkbGeomFPText(s->height,XkbXKBFile));
-    if (s->angle!=0) {
-	fprintf(file,"        angle=  %s;\n",
-					XkbGeomFPText(s->angle,XkbXKBFile));
-    }
-    for (i=0,row=s->rows;i<s->num_rows;i++,row++) {
-	fprintf(file,"        row {\n");
-	fprintf(file,"            top=  %s;\n",
-					XkbGeomFPText(row->top,XkbXKBFile));
-	fprintf(file,"            left= %s;\n",
-					XkbGeomFPText(row->left,XkbXKBFile));
-	if (row->vertical)
-	    fprintf(file,"            vertical;\n");
-	if (row->num_keys>0) {
-	    register int 	k;
-	    register XkbKeyPtr	key;
-	    int			forceNL=0;
-	    int			nThisLine= 0;
-	    fprintf(file,"            keys {\n");
-	    for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
-		XkbShapePtr	shape;
-		if (key->color_ndx!=dfltKeyColor)
-		    forceNL= 1;
-		if (k==0) {
-		     fprintf(file,"                ");
-		     nThisLine= 0;
-		}
-		else if (((nThisLine%2)==1)||(forceNL)) {
-		     fprintf(file,",\n                ");
-		     forceNL= nThisLine= 0;
-		}
-		else {
-		     fprintf(file,", ");
-		     nThisLine++;
-		}
-		shape= XkbKeyShape(geom,key);
-		fprintf(file,"{ %6s, \"%s\", %3s",
-		      XkbKeyNameText(key->name.name,XkbXKBFile),
-		      XkbAtomText(shape->name,XkbXKBFile),
-		      XkbGeomFPText(key->gap,XkbXKBFile));
-		if (key->color_ndx!=dfltKeyColor) {
-		    fprintf(file,", color=\"%s\"",XkbKeyColor(geom,key)->spec);
-		    forceNL= 1;
-		}
-		fprintf(file," }");
-	    }
-	    fprintf(file,"\n            };\n");
-	}
-	fprintf(file,"        };\n");
-    }
-    if (s->doodads!=NULL) {
-	XkbDoodadPtr	doodad;
-	for (i=0,doodad=s->doodads;i<s->num_doodads;i++,doodad++) {
-	    WriteXKBDoodad(file,8,geom,doodad);
-	}
-    }
-    if (s->overlays!=NULL) {
-	XkbOverlayPtr	ol;
-	for (i=0,ol=s->overlays;i<s->num_overlays;i++,ol++) {
-	    WriteXKBOverlay(file,8,geom,ol);
-	}
-    }
-    fprintf(file,"    }; // End of \"%s\" section\n\n",
-				XkbAtomText(s->name,XkbXKBFile));
+    register int i;
+    XkbRowPtr row;
+    int dfltKeyColor = 0;
+
+    fprintf(file, "    section \"%s\" {\n", XkbAtomText(s->name, XkbXKBFile));
+    if (s->rows && (s->rows->num_keys > 0)) {
+        dfltKeyColor = s->rows->keys[0].color_ndx;
+        fprintf(file, "        key.color= \"%s\";\n",
+                XkbStringText(geom->colors[dfltKeyColor].spec, XkbXKBFile));
+    }
+    fprintf(file, "        priority=  %d;\n", s->priority);
+    fprintf(file, "        top=       %s;\n",
+            XkbGeomFPText(s->top, XkbXKBFile));
+    fprintf(file, "        left=      %s;\n",
+            XkbGeomFPText(s->left, XkbXKBFile));
+    fprintf(file, "        width=     %s;\n",
+            XkbGeomFPText(s->width, XkbXKBFile));
+    fprintf(file, "        height=    %s;\n",
+            XkbGeomFPText(s->height, XkbXKBFile));
+    if (s->angle != 0) {
+        fprintf(file, "        angle=  %s;\n",
+                XkbGeomFPText(s->angle, XkbXKBFile));
+    }
+    for (i = 0, row = s->rows; i < s->num_rows; i++, row++) {
+        fprintf(file, "        row {\n");
+        fprintf(file, "            top=  %s;\n",
+                XkbGeomFPText(row->top, XkbXKBFile));
+        fprintf(file, "            left= %s;\n",
+                XkbGeomFPText(row->left, XkbXKBFile));
+        if (row->vertical)
+            fprintf(file, "            vertical;\n");
+        if (row->num_keys > 0) {
+            register int k;
+            register XkbKeyPtr key;
+            int forceNL = 0;
+            int nThisLine = 0;
+
+            fprintf(file, "            keys {\n");
+            for (k = 0, key = row->keys; k < row->num_keys; k++, key++) {
+                XkbShapePtr shape;
+
+                if (key->color_ndx != dfltKeyColor)
+                    forceNL = 1;
+                if (k == 0) {
+                    fprintf(file, "                ");
+                    nThisLine = 0;
+                }
+                else if (((nThisLine % 2) == 1) || (forceNL)) {
+                    fprintf(file, ",\n                ");
+                    forceNL = nThisLine = 0;
+                }
+                else {
+                    fprintf(file, ", ");
+                    nThisLine++;
+                }
+                shape = XkbKeyShape(geom, key);
+                fprintf(file, "{ %6s, \"%s\", %3s",
+                        XkbKeyNameText(key->name.name, XkbXKBFile),
+                        XkbAtomText(shape->name, XkbXKBFile),
+                        XkbGeomFPText(key->gap, XkbXKBFile));
+                if (key->color_ndx != dfltKeyColor) {
+                    fprintf(file, ", color=\"%s\"",
+                            XkbKeyColor(geom, key)->spec);
+                    forceNL = 1;
+                }
+                fprintf(file, " }");
+            }
+            fprintf(file, "\n            };\n");
+        }
+        fprintf(file, "        };\n");
+    }
+    if (s->doodads != NULL) {
+        XkbDoodadPtr doodad;
+
+        for (i = 0, doodad = s->doodads; i < s->num_doodads; i++, doodad++) {
+            WriteXKBDoodad(file, 8, geom, doodad);
+        }
+    }
+    if (s->overlays != NULL) {
+        XkbOverlayPtr ol;
+
+        for (i = 0, ol = s->overlays; i < s->num_overlays; i++, ol++) {
+            WriteXKBOverlay(file, 8, geom, ol);
+        }
+    }
+    fprintf(file, "    }; // End of \"%s\" section\n\n",
+            XkbAtomText(s->name, XkbXKBFile));
     return TRUE;
 }
 
 Bool
-XkbWriteXKBGeometry(	FILE *			file,
-			XkbDescPtr              xkb,
-			Bool			topLevel,
-			Bool			showImplicit,
-			XkbFileAddOnFunc	addOn,
-			void *			priv)
+XkbWriteXKBGeometry(FILE * file,
+                    XkbDescPtr xkb,
+                    Bool topLevel,
+                    Bool showImplicit, XkbFileAddOnFunc addOn, void *priv)
 {
-register unsigned	i,n;
-XkbGeometryPtr		geom;
-
-    if ((!xkb)||(!xkb->geom)) {
-	_XkbLibError(_XkbErrMissingGeometry,"XkbWriteXKBGeometry",0);
-	return FALSE;
-    }
-    geom= xkb->geom;
-    if (geom->name==None)
-	 fprintf(file,"xkb_geometry {\n\n");
-    else fprintf(file,"xkb_geometry \"%s\" {\n\n",
-				XkbAtomText(geom->name,XkbXKBFile));
-    fprintf(file,"    width=       %s;\n",
-				XkbGeomFPText(geom->width_mm,XkbXKBFile));
-    fprintf(file,"    height=      %s;\n\n",
-				XkbGeomFPText(geom->height_mm,XkbXKBFile));
-
-    if (geom->key_aliases!=NULL) {
-	XkbKeyAliasPtr	pAl;
-	pAl= geom->key_aliases;
-	for (i=0;i<geom->num_key_aliases;i++,pAl++) {
-	    fprintf(file,"    alias %6s = %6s;\n",
-				XkbKeyNameText(pAl->alias,XkbXKBFile),
-				XkbKeyNameText(pAl->real,XkbXKBFile));
-	}
-	fprintf(file,"\n");
-    }
-
-    if (geom->base_color!=NULL)
-	fprintf(file,"    baseColor=   \"%s\";\n",
-			XkbStringText(geom->base_color->spec,XkbXKBFile));
-    if (geom->label_color!=NULL)
-	fprintf(file,"    labelColor=  \"%s\";\n",
-			XkbStringText(geom->label_color->spec,XkbXKBFile));
-    if (geom->label_font!=NULL)
-	fprintf(file,"    xfont=       \"%s\";\n",
-			XkbStringText(geom->label_font,XkbXKBFile));
-    if ((geom->num_colors>0)&&(showImplicit)) {
-	XkbColorPtr	color;
-	for (color=geom->colors,i=0;i<geom->num_colors;i++,color++) {
-		fprintf(file,"//     color[%d]= \"%s\"\n",i,
-				XkbStringText(color->spec,XkbXKBFile));
-	}
-	fprintf(file,"\n");
-    }
-    if (geom->num_properties>0) {
-	XkbPropertyPtr	prop;
-	for (prop=geom->properties,i=0;i<geom->num_properties;i++,prop++) {
-	    fprintf(file,"    %s= \"%s\";\n",prop->name,
-    				XkbStringText(prop->value,XkbXKBFile));
-	}
-	fprintf(file,"\n");
-    }
-    if (geom->num_shapes>0) {
-	XkbShapePtr	shape;
-	XkbOutlinePtr	outline;
-	int		lastR;
-	for (shape=geom->shapes,i=0;i<geom->num_shapes;i++,shape++) {
-	    lastR=0;
-	    fprintf(file,"    shape \"%s\" {",
-				   XkbAtomText(shape->name,XkbXKBFile));
-	    outline= shape->outlines;
-	    if (shape->num_outlines>1) {
-		for (n=0;n<shape->num_outlines;n++,outline++) {
-		    if (n==0)	fprintf(file,"\n");
-		    else	fprintf(file,",\n");
-		    WriteXKBOutline(file,shape,outline,lastR,8,8);
-		    lastR= outline->corner_radius;
-		}
-		fprintf(file,"\n    };\n");
-	    }
-	    else {
-		WriteXKBOutline(file,NULL,outline,lastR,1,8);
-		fprintf(file," };\n");
-	    }
-	}
-    }
-    if (geom->num_sections>0) {
-	XkbSectionPtr	section;
-	for (section=geom->sections,i=0;i<geom->num_sections;i++,section++){
-	    WriteXKBSection(file,section,geom);
-	}
-    }
-    if (geom->num_doodads>0) {
-	XkbDoodadPtr	doodad;
-	for (i=0,doodad=geom->doodads;i<geom->num_doodads;i++,doodad++) {
-	    WriteXKBDoodad(file,4,geom,doodad);
-	}
+    register unsigned i, n;
+    XkbGeometryPtr geom;
+
+    if ((!xkb) || (!xkb->geom)) {
+        _XkbLibError(_XkbErrMissingGeometry, "XkbWriteXKBGeometry", 0);
+        return FALSE;
+    }
+    geom = xkb->geom;
+    if (geom->name == None)
+        fprintf(file, "xkb_geometry {\n\n");
+    else
+        fprintf(file, "xkb_geometry \"%s\" {\n\n",
+                XkbAtomText(geom->name, XkbXKBFile));
+    fprintf(file, "    width=       %s;\n",
+            XkbGeomFPText(geom->width_mm, XkbXKBFile));
+    fprintf(file, "    height=      %s;\n\n",
+            XkbGeomFPText(geom->height_mm, XkbXKBFile));
+
+    if (geom->key_aliases != NULL) {
+        XkbKeyAliasPtr pAl;
+
+        pAl = geom->key_aliases;
+        for (i = 0; i < geom->num_key_aliases; i++, pAl++) {
+            fprintf(file, "    alias %6s = %6s;\n",
+                    XkbKeyNameText(pAl->alias, XkbXKBFile),
+                    XkbKeyNameText(pAl->real, XkbXKBFile));
+        }
+        fprintf(file, "\n");
+    }
+
+    if (geom->base_color != NULL)
+        fprintf(file, "    baseColor=   \"%s\";\n",
+                XkbStringText(geom->base_color->spec, XkbXKBFile));
+    if (geom->label_color != NULL)
+        fprintf(file, "    labelColor=  \"%s\";\n",
+                XkbStringText(geom->label_color->spec, XkbXKBFile));
+    if (geom->label_font != NULL)
+        fprintf(file, "    xfont=       \"%s\";\n",
+                XkbStringText(geom->label_font, XkbXKBFile));
+    if ((geom->num_colors > 0) && (showImplicit)) {
+        XkbColorPtr color;
+
+        for (color = geom->colors, i = 0; i < geom->num_colors; i++, color++) {
+            fprintf(file, "//     color[%d]= \"%s\"\n", i,
+                    XkbStringText(color->spec, XkbXKBFile));
+        }
+        fprintf(file, "\n");
+    }
+    if (geom->num_properties > 0) {
+        XkbPropertyPtr prop;
+
+        for (prop = geom->properties, i = 0; i < geom->num_properties;
+             i++, prop++) {
+            fprintf(file, "    %s= \"%s\";\n", prop->name,
+                    XkbStringText(prop->value, XkbXKBFile));
+        }
+        fprintf(file, "\n");
+    }
+    if (geom->num_shapes > 0) {
+        XkbShapePtr shape;
+        XkbOutlinePtr outline;
+        int lastR;
+
+        for (shape = geom->shapes, i = 0; i < geom->num_shapes; i++, shape++) {
+            lastR = 0;
+            fprintf(file, "    shape \"%s\" {",
+                    XkbAtomText(shape->name, XkbXKBFile));
+            outline = shape->outlines;
+            if (shape->num_outlines > 1) {
+                for (n = 0; n < shape->num_outlines; n++, outline++) {
+                    if (n == 0)
+                        fprintf(file, "\n");
+                    else
+                        fprintf(file, ",\n");
+                    WriteXKBOutline(file, shape, outline, lastR, 8, 8);
+                    lastR = outline->corner_radius;
+                }
+                fprintf(file, "\n    };\n");
+            }
+            else {
+                WriteXKBOutline(file, NULL, outline, lastR, 1, 8);
+                fprintf(file, " };\n");
+            }
+        }
+    }
+    if (geom->num_sections > 0) {
+        XkbSectionPtr section;
+
+        for (section = geom->sections, i = 0; i < geom->num_sections;
+             i++, section++) {
+            WriteXKBSection(file, section, geom);
+        }
+    }
+    if (geom->num_doodads > 0) {
+        XkbDoodadPtr doodad;
+
+        for (i = 0, doodad = geom->doodads; i < geom->num_doodads;
+             i++, doodad++) {
+            WriteXKBDoodad(file, 4, geom, doodad);
+        }
     }
     if (addOn)
-	(*addOn)(file,xkb,topLevel,showImplicit,XkmGeometryIndex,priv);
-    fprintf(file,"};\n\n");
+        (*addOn) (file, xkb, topLevel, showImplicit, XkmGeometryIndex, priv);
+    fprintf(file, "};\n\n");
     return TRUE;
 }
diff --git a/xorg-server/xkb/xkbtext.c b/xorg-server/xkb/xkbtext.c
index 8ef2b05b0..f66a08f75 100644
--- a/xorg-server/xkb/xkbtext.c
+++ b/xorg-server/xkb/xkbtext.c
@@ -50,168 +50,179 @@
 #define	BUFFER_SIZE	512
 
 static char textBuffer[BUFFER_SIZE];
-static int  tbNext= 0;
+static int tbNext = 0;
 
 static char *
 tbGetBuffer(unsigned size)
 {
-char *rtrn;
-
-    if (size>=BUFFER_SIZE)
-	return NULL;
-    if ((BUFFER_SIZE-tbNext)<=size)
-	tbNext= 0;
-    rtrn= &textBuffer[tbNext];
-    tbNext+= size;
+    char *rtrn;
+
+    if (size >= BUFFER_SIZE)
+        return NULL;
+    if ((BUFFER_SIZE - tbNext) <= size)
+        tbNext = 0;
+    rtrn = &textBuffer[tbNext];
+    tbNext += size;
     return rtrn;
 }
 
 /***====================================================================***/
 
 char *
-XkbAtomText(Atom atm,unsigned format)
+XkbAtomText(Atom atm, unsigned format)
 {
-const char	*atmstr;
-char	*rtrn,*tmp;
+    const char *atmstr;
+    char *rtrn, *tmp;
 
     atmstr = NameForAtom(atm);
     if (atmstr != NULL) {
-	int	len;
-	len= strlen(atmstr)+1;
-	if (len>BUFFER_SIZE)
-	    len= BUFFER_SIZE-2;
-	rtrn= tbGetBuffer(len);
-	strlcpy(rtrn,atmstr,len);
+        int len;
+
+        len = strlen(atmstr) + 1;
+        if (len > BUFFER_SIZE)
+            len = BUFFER_SIZE - 2;
+        rtrn = tbGetBuffer(len);
+        strlcpy(rtrn, atmstr, len);
     }
     else {
-	rtrn= tbGetBuffer(1);
-	rtrn[0]= '\0';
+        rtrn = tbGetBuffer(1);
+        rtrn[0] = '\0';
     }
-    if (format==XkbCFile) {
-	for (tmp=rtrn;*tmp!='\0';tmp++) {
-	    if ((tmp==rtrn)&&(!isalpha(*tmp)))
-		*tmp= '_';
-	    else if (!isalnum(*tmp))
-		*tmp= '_';
-	}
+    if (format == XkbCFile) {
+        for (tmp = rtrn; *tmp != '\0'; tmp++) {
+            if ((tmp == rtrn) && (!isalpha(*tmp)))
+                *tmp = '_';
+            else if (!isalnum(*tmp))
+                *tmp = '_';
+        }
     }
-    return XkbStringText(rtrn,format);
+    return XkbStringText(rtrn, format);
 }
 
 /***====================================================================***/
 
 char *
-XkbVModIndexText(XkbDescPtr xkb,unsigned ndx,unsigned format)
+XkbVModIndexText(XkbDescPtr xkb, unsigned ndx, unsigned format)
 {
-register int len;
-register Atom *vmodNames;
-char *rtrn;
-const char *tmp;
-char  numBuf[20];
+    register int len;
+    register Atom *vmodNames;
+    char *rtrn;
+    const char *tmp;
+    char numBuf[20];
 
     if (xkb && xkb->names)
-	 vmodNames= xkb->names->vmods;
-    else vmodNames= NULL;
-
-    tmp= NULL;
-    if (ndx>=XkbNumVirtualMods)
-	 tmp= "illegal";
-    else if (vmodNames&&(vmodNames[ndx]!=None))
-	 tmp= NameForAtom(vmodNames[ndx]);
-    if (tmp==NULL) {
-	snprintf(numBuf,sizeof(numBuf),"%d",ndx);
-	tmp = numBuf;
+        vmodNames = xkb->names->vmods;
+    else
+        vmodNames = NULL;
+
+    tmp = NULL;
+    if (ndx >= XkbNumVirtualMods)
+        tmp = "illegal";
+    else if (vmodNames && (vmodNames[ndx] != None))
+        tmp = NameForAtom(vmodNames[ndx]);
+    if (tmp == NULL) {
+        snprintf(numBuf, sizeof(numBuf), "%d", ndx);
+        tmp = numBuf;
     }
 
-    len= strlen(tmp)+1;
-    if (format==XkbCFile)
-	len+= 4;
-    if (len>=BUFFER_SIZE)
-	len= BUFFER_SIZE-1;
-    rtrn= tbGetBuffer(len);
-    if (format==XkbCFile) {
-	 strcpy(rtrn,"vmod_");
-	 strncpy(&rtrn[5],tmp,len-4);
+    len = strlen(tmp) + 1;
+    if (format == XkbCFile)
+        len += 4;
+    if (len >= BUFFER_SIZE)
+        len = BUFFER_SIZE - 1;
+    rtrn = tbGetBuffer(len);
+    if (format == XkbCFile) {
+        strcpy(rtrn, "vmod_");
+        strncpy(&rtrn[5], tmp, len - 4);
     }
-    else strncpy(rtrn,tmp,len);
+    else
+        strncpy(rtrn, tmp, len);
     return rtrn;
 }
 
 char *
-XkbVModMaskText(        XkbDescPtr	xkb,
-			unsigned	modMask,
-			unsigned	mask,
-			unsigned	format)
+XkbVModMaskText(XkbDescPtr xkb,
+                unsigned modMask, unsigned mask, unsigned format)
 {
-register int i,bit;
-int	 len;
-char *mm,*rtrn;
-char *str,buf[BUFFER_SIZE];
-
-    if ((modMask==0)&&(mask==0)) {
-	rtrn= tbGetBuffer(5);
-	if (format==XkbCFile)
-	     sprintf(rtrn,"0");
-	else sprintf(rtrn,"none");
-	return rtrn;
+    register int i, bit;
+    int len;
+    char *mm, *rtrn;
+    char *str, buf[BUFFER_SIZE];
+
+    if ((modMask == 0) && (mask == 0)) {
+        rtrn = tbGetBuffer(5);
+        if (format == XkbCFile)
+            sprintf(rtrn, "0");
+        else
+            sprintf(rtrn, "none");
+        return rtrn;
     }
-    if (modMask!=0)
-	 mm= XkbModMaskText(modMask,format);
-    else mm= NULL;
+    if (modMask != 0)
+        mm = XkbModMaskText(modMask, format);
+    else
+        mm = NULL;
 
-    str= buf;
-    buf[0]= '\0';
+    str = buf;
+    buf[0] = '\0';
     if (mask) {
-	char *tmp;
-	for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	    if (mask&bit) {
-		tmp= XkbVModIndexText(xkb,i,format);
-		len= strlen(tmp)+1+(str==buf?0:1);
-		if (format==XkbCFile)
-		    len+= 4;
-		if ((str-(buf+len))<=BUFFER_SIZE) {
-		    if (str!=buf) {
-			if (format==XkbCFile)	*str++= '|';
-			else			*str++= '+';
-			len--;
-		    }
-		}
-		if (format==XkbCFile)
-		     sprintf(str,"%sMask",tmp);
-		else strcpy(str,tmp);
-		str= &str[len-1];
-	    }
-	}
-	str= buf;
+        char *tmp;
+
+        for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+            if (mask & bit) {
+                tmp = XkbVModIndexText(xkb, i, format);
+                len = strlen(tmp) + 1 + (str == buf ? 0 : 1);
+                if (format == XkbCFile)
+                    len += 4;
+                if ((str - (buf + len)) <= BUFFER_SIZE) {
+                    if (str != buf) {
+                        if (format == XkbCFile)
+                            *str++ = '|';
+                        else
+                            *str++ = '+';
+                        len--;
+                    }
+                }
+                if (format == XkbCFile)
+                    sprintf(str, "%sMask", tmp);
+                else
+                    strcpy(str, tmp);
+                str = &str[len - 1];
+            }
+        }
+        str = buf;
     }
-    else str= NULL;
-    if (mm)	
-	len= strlen(mm);
-    else	len= 0;
+    else
+        str = NULL;
+    if (mm)
+        len = strlen(mm);
+    else
+        len = 0;
     if (str)
-	len+= strlen(str)+(mm==NULL?0:1);
-    if (len>=BUFFER_SIZE)
-	len= BUFFER_SIZE-1;
-    rtrn= tbGetBuffer(len+1);
-    rtrn[0]= '\0';
-
-    if (mm!=NULL) {
-	i= strlen(mm);
-	if (i>len)
-	    i= len;
-	strcpy(rtrn,mm);
+        len += strlen(str) + (mm == NULL ? 0 : 1);
+    if (len >= BUFFER_SIZE)
+        len = BUFFER_SIZE - 1;
+    rtrn = tbGetBuffer(len + 1);
+    rtrn[0] = '\0';
+
+    if (mm != NULL) {
+        i = strlen(mm);
+        if (i > len)
+            i = len;
+        strcpy(rtrn, mm);
     }
     else {
-	i=0;
+        i = 0;
     }
-    if (str!=NULL) {
-	if (mm!=NULL) {
-	    if (format==XkbCFile)	strcat(rtrn,"|");
-	    else			strcat(rtrn,"+");
-	}
-	strncat(rtrn,str,len-i);
+    if (str != NULL) {
+        if (mm != NULL) {
+            if (format == XkbCFile)
+                strcat(rtrn, "|");
+            else
+                strcat(rtrn, "+");
+        }
+        strncat(rtrn, str, len - i);
     }
-    rtrn[len]= '\0';
+    rtrn[len] = '\0';
     return rtrn;
 }
 
@@ -220,111 +231,119 @@ static const char *modNames[XkbNumModifiers] = {
 };
 
 char *
-XkbModIndexText(unsigned ndx,unsigned format)
+XkbModIndexText(unsigned ndx, unsigned format)
 {
-char *	rtrn;
-char	buf[100];
-
-    if (format==XkbCFile) {
-	if (ndx<XkbNumModifiers)
-	    snprintf(buf,sizeof(buf),"%sMapIndex",modNames[ndx]);
-	else if (ndx==XkbNoModifier)
-	     snprintf(buf,sizeof(buf),"XkbNoModifier");
-	else snprintf(buf,sizeof(buf),"0x%02x",ndx);
+    char *rtrn;
+    char buf[100];
+
+    if (format == XkbCFile) {
+        if (ndx < XkbNumModifiers)
+            snprintf(buf, sizeof(buf), "%sMapIndex", modNames[ndx]);
+        else if (ndx == XkbNoModifier)
+            snprintf(buf, sizeof(buf), "XkbNoModifier");
+        else
+            snprintf(buf, sizeof(buf), "0x%02x", ndx);
     }
     else {
-	if (ndx<XkbNumModifiers)
-	     strcpy(buf,modNames[ndx]);
-	else if (ndx==XkbNoModifier)
-	     strcpy(buf,"none");
-	else snprintf(buf,sizeof(buf),"ILLEGAL_%02x",ndx);
+        if (ndx < XkbNumModifiers)
+            strcpy(buf, modNames[ndx]);
+        else if (ndx == XkbNoModifier)
+            strcpy(buf, "none");
+        else
+            snprintf(buf, sizeof(buf), "ILLEGAL_%02x", ndx);
     }
-    rtrn= tbGetBuffer(strlen(buf)+1);
-    strcpy(rtrn,buf);
+    rtrn = tbGetBuffer(strlen(buf) + 1);
+    strcpy(rtrn, buf);
     return rtrn;
 }
 
 char *
-XkbModMaskText(unsigned mask,unsigned format)
+XkbModMaskText(unsigned mask, unsigned format)
 {
-register int i,bit;
-char buf[64],*rtrn;
-
-    if ((mask&0xff)==0xff) {
-	if (format==XkbCFile) 		strcpy(buf,"0xff");
-	else				strcpy(buf,"all");
+    register int i, bit;
+    char buf[64], *rtrn;
+
+    if ((mask & 0xff) == 0xff) {
+        if (format == XkbCFile)
+            strcpy(buf, "0xff");
+        else
+            strcpy(buf, "all");
     }
-    else if ((mask&0xff)==0) {
-	if (format==XkbCFile)		strcpy(buf,"0");
-	else				strcpy(buf,"none");
+    else if ((mask & 0xff) == 0) {
+        if (format == XkbCFile)
+            strcpy(buf, "0");
+        else
+            strcpy(buf, "none");
     }
     else {
-	char *str= buf;
-	buf[0]= '\0';
-	for (i=0,bit=1;i<XkbNumModifiers;i++,bit<<=1) {
-	    if (mask&bit) {
-		if (str!=buf) {
-		    if (format==XkbCFile)	*str++= '|';
-		    else			*str++= '+';
-		}
-		strcpy(str,modNames[i]);
-		str= &str[strlen(str)];
-		if (format==XkbCFile) {
-		    strcpy(str,"Mask");
-		    str+= 4;
-		}
-	    }
-	}
+        char *str = buf;
+
+        buf[0] = '\0';
+        for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) {
+            if (mask & bit) {
+                if (str != buf) {
+                    if (format == XkbCFile)
+                        *str++ = '|';
+                    else
+                        *str++ = '+';
+                }
+                strcpy(str, modNames[i]);
+                str = &str[strlen(str)];
+                if (format == XkbCFile) {
+                    strcpy(str, "Mask");
+                    str += 4;
+                }
+            }
+        }
     }
-    rtrn= tbGetBuffer(strlen(buf)+1);
-    strcpy(rtrn,buf);
+    rtrn = tbGetBuffer(strlen(buf) + 1);
+    strcpy(rtrn, buf);
     return rtrn;
 }
 
 /***====================================================================***/
 
-/*ARGSUSED*/
-char *
-XkbConfigText(unsigned config,unsigned format)
+ /*ARGSUSED*/ char *
+XkbConfigText(unsigned config, unsigned format)
 {
-static char *buf;
+    static char *buf;
 
-    buf= tbGetBuffer(32);
+    buf = tbGetBuffer(32);
     switch (config) {
-	case XkmSemanticsFile:
-	    strcpy(buf,"Semantics");
-	    break;
-	case XkmLayoutFile:
-	    strcpy(buf,"Layout");
-	    break;
-	case XkmKeymapFile:
-	    strcpy(buf,"Keymap");
-	    break;
-	case XkmGeometryFile:
-	case XkmGeometryIndex:
-	    strcpy(buf,"Geometry");
-	    break;
-	case XkmTypesIndex:
-	    strcpy(buf,"Types");
-	    break;
-	case XkmCompatMapIndex:
-	    strcpy(buf,"CompatMap");
-	    break;
-	case XkmSymbolsIndex:
-	    strcpy(buf,"Symbols");
-	    break;
-	case XkmIndicatorsIndex:
-	    strcpy(buf,"Indicators");
-	    break;
-	case XkmKeyNamesIndex:
-	    strcpy(buf,"KeyNames");
-	    break;
-	case XkmVirtualModsIndex:
-	    strcpy(buf,"VirtualMods");
-	    break;
-	default:
-	    sprintf(buf,"unknown(%d)",config);
-	    break;
+    case XkmSemanticsFile:
+        strcpy(buf, "Semantics");
+        break;
+    case XkmLayoutFile:
+        strcpy(buf, "Layout");
+        break;
+    case XkmKeymapFile:
+        strcpy(buf, "Keymap");
+        break;
+    case XkmGeometryFile:
+    case XkmGeometryIndex:
+        strcpy(buf, "Geometry");
+        break;
+    case XkmTypesIndex:
+        strcpy(buf, "Types");
+        break;
+    case XkmCompatMapIndex:
+        strcpy(buf, "CompatMap");
+        break;
+    case XkmSymbolsIndex:
+        strcpy(buf, "Symbols");
+        break;
+    case XkmIndicatorsIndex:
+        strcpy(buf, "Indicators");
+        break;
+    case XkmKeyNamesIndex:
+        strcpy(buf, "KeyNames");
+        break;
+    case XkmVirtualModsIndex:
+        strcpy(buf, "VirtualMods");
+        break;
+    default:
+        sprintf(buf, "unknown(%d)", config);
+        break;
     }
     return buf;
 }
@@ -332,35 +351,37 @@ static char *buf;
 /***====================================================================***/
 
 char *
-XkbKeysymText(KeySym sym,unsigned format)
+XkbKeysymText(KeySym sym, unsigned format)
 {
-static char buf[32];
+    static char buf[32];
 
-    if (sym==NoSymbol)
-	 strcpy(buf,"NoSymbol");
-    else snprintf(buf, sizeof(buf), "0x%lx", (long)sym);
+    if (sym == NoSymbol)
+        strcpy(buf, "NoSymbol");
+    else
+        snprintf(buf, sizeof(buf), "0x%lx", (long) sym);
     return buf;
 }
 
 char *
-XkbKeyNameText(char *name,unsigned format)
+XkbKeyNameText(char *name, unsigned format)
 {
-char *buf;
+    char *buf;
 
-    if (format==XkbCFile) {
-	buf= tbGetBuffer(5);
-	memcpy(buf,name,4);
-	buf[4]= '\0';
+    if (format == XkbCFile) {
+        buf = tbGetBuffer(5);
+        memcpy(buf, name, 4);
+        buf[4] = '\0';
     }
     else {
-	int len;
-	buf= tbGetBuffer(7);
-	buf[0]= '<';
-	memcpy(&buf[1],name,4);
-	buf[5]= '\0';
-	len= strlen(buf);
-	buf[len++]= '>';
-	buf[len]= '\0';
+        int len;
+
+        buf = tbGetBuffer(7);
+        buf[0] = '<';
+        memcpy(&buf[1], name, 4);
+        buf[5] = '\0';
+        len = strlen(buf);
+        buf[len++] = '>';
+        buf[len] = '\0';
     }
     return buf;
 }
@@ -368,143 +389,156 @@ char *buf;
 /***====================================================================***/
 
 static const char *siMatchText[5] = {
-	"NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
+    "NoneOf", "AnyOfOrNone", "AnyOf", "AllOf", "Exactly"
 };
 
 const char *
-XkbSIMatchText(unsigned type,unsigned format)
+XkbSIMatchText(unsigned type, unsigned format)
 {
-static char buf[40];
-const char *rtrn;
-
-    switch (type&XkbSI_OpMask) {
-	case XkbSI_NoneOf:	rtrn= siMatchText[0]; break;
-	case XkbSI_AnyOfOrNone:	rtrn= siMatchText[1]; break;
-	case XkbSI_AnyOf:	rtrn= siMatchText[2]; break;
-	case XkbSI_AllOf:	rtrn= siMatchText[3]; break;
-	case XkbSI_Exactly:	rtrn= siMatchText[4]; break;
-	default:		snprintf(buf,sizeof(buf),"0x%x",type&XkbSI_OpMask);
-				return buf;
+    static char buf[40];
+    const char *rtrn;
+
+    switch (type & XkbSI_OpMask) {
+    case XkbSI_NoneOf:
+        rtrn = siMatchText[0];
+        break;
+    case XkbSI_AnyOfOrNone:
+        rtrn = siMatchText[1];
+        break;
+    case XkbSI_AnyOf:
+        rtrn = siMatchText[2];
+        break;
+    case XkbSI_AllOf:
+        rtrn = siMatchText[3];
+        break;
+    case XkbSI_Exactly:
+        rtrn = siMatchText[4];
+        break;
+    default:
+        snprintf(buf, sizeof(buf), "0x%x", type & XkbSI_OpMask);
+        return buf;
     }
-    if (format==XkbCFile) {
-	if (type&XkbSI_LevelOneOnly)
-	     snprintf(buf,sizeof(buf),"XkbSI_LevelOneOnly|XkbSI_%s",rtrn);
-	else snprintf(buf,sizeof(buf),"XkbSI_%s",rtrn);
-	rtrn= buf;
+    if (format == XkbCFile) {
+        if (type & XkbSI_LevelOneOnly)
+            snprintf(buf, sizeof(buf), "XkbSI_LevelOneOnly|XkbSI_%s", rtrn);
+        else
+            snprintf(buf, sizeof(buf), "XkbSI_%s", rtrn);
+        rtrn = buf;
     }
     return rtrn;
 }
 
 /***====================================================================***/
 
-static const char *imWhichNames[]= {
-	"base",
-	"latched",
-	"locked",
-	"effective",
-	"compat"
+static const char *imWhichNames[] = {
+    "base",
+    "latched",
+    "locked",
+    "effective",
+    "compat"
 };
 
 char *
-XkbIMWhichStateMaskText(unsigned use_which,unsigned format)
+XkbIMWhichStateMaskText(unsigned use_which, unsigned format)
 {
-int		len;
-unsigned	i,bit,tmp;
-char *		buf;
-
-    if (use_which==0) {
-	buf= tbGetBuffer(2);
-	strcpy(buf,"0");
-	return buf;
+    int len;
+    unsigned i, bit, tmp;
+    char *buf;
+
+    if (use_which == 0) {
+        buf = tbGetBuffer(2);
+        strcpy(buf, "0");
+        return buf;
     }
-    tmp= use_which&XkbIM_UseAnyMods;
-    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
-	if (tmp&bit) {
-	    tmp&= ~bit;
-	    len+= strlen(imWhichNames[i])+1;
-	    if (format==XkbCFile)
-		len+= 9;
-	}
+    tmp = use_which & XkbIM_UseAnyMods;
+    for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+        if (tmp & bit) {
+            tmp &= ~bit;
+            len += strlen(imWhichNames[i]) + 1;
+            if (format == XkbCFile)
+                len += 9;
+        }
     }
-    buf= tbGetBuffer(len+1);
-    tmp= use_which&XkbIM_UseAnyMods;
-    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
-	if (tmp&bit) {
-	    tmp&= ~bit;
-	    if (format==XkbCFile) {
-		if (len!=0)
-		    buf[len++]= '|';
-		sprintf(&buf[len],"XkbIM_Use%s",imWhichNames[i]);
-		buf[len+9]= toupper(buf[len+9]);
-	    }
-	    else {
-		if (len!=0)
-		    buf[len++]= '+';
-		sprintf(&buf[len],"%s",imWhichNames[i]);
-	    }
-	    len+= strlen(&buf[len]);
-	}
+    buf = tbGetBuffer(len + 1);
+    tmp = use_which & XkbIM_UseAnyMods;
+    for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+        if (tmp & bit) {
+            tmp &= ~bit;
+            if (format == XkbCFile) {
+                if (len != 0)
+                    buf[len++] = '|';
+                sprintf(&buf[len], "XkbIM_Use%s", imWhichNames[i]);
+                buf[len + 9] = toupper(buf[len + 9]);
+            }
+            else {
+                if (len != 0)
+                    buf[len++] = '+';
+                sprintf(&buf[len], "%s", imWhichNames[i]);
+            }
+            len += strlen(&buf[len]);
+        }
     }
     return buf;
 }
 
 static const char *ctrlNames[] = {
-	"repeatKeys",
-	"slowKeys",
-	"bounceKeys",
-	"stickyKeys",
-	"mouseKeys",
-	"mouseKeysAccel",
-	"accessXKeys",
-	"accessXTimeout",
-	"accessXFeedback",
-	"audibleBell",
-	"overlay1",
-	"overlay2",
-	"ignoreGroupLock"
+    "repeatKeys",
+    "slowKeys",
+    "bounceKeys",
+    "stickyKeys",
+    "mouseKeys",
+    "mouseKeysAccel",
+    "accessXKeys",
+    "accessXTimeout",
+    "accessXFeedback",
+    "audibleBell",
+    "overlay1",
+    "overlay2",
+    "ignoreGroupLock"
 };
 
 char *
-XkbControlsMaskText(unsigned ctrls,unsigned format)
+XkbControlsMaskText(unsigned ctrls, unsigned format)
 {
-int		len;
-unsigned	i,bit,tmp;
-char *		buf;
-
-    if (ctrls==0) {
-	buf= tbGetBuffer(5);
-	if (format==XkbCFile)
-	     strcpy(buf,"0");
-	else strcpy(buf,"none");
-	return buf;
+    int len;
+    unsigned i, bit, tmp;
+    char *buf;
+
+    if (ctrls == 0) {
+        buf = tbGetBuffer(5);
+        if (format == XkbCFile)
+            strcpy(buf, "0");
+        else
+            strcpy(buf, "none");
+        return buf;
     }
-    tmp= ctrls&XkbAllBooleanCtrlsMask;
-    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
-	if (tmp&bit) {
-	    tmp&= ~bit;
-	    len+= strlen(ctrlNames[i])+1;
-	    if (format==XkbCFile)
-		len+= 7;
-	}
+    tmp = ctrls & XkbAllBooleanCtrlsMask;
+    for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+        if (tmp & bit) {
+            tmp &= ~bit;
+            len += strlen(ctrlNames[i]) + 1;
+            if (format == XkbCFile)
+                len += 7;
+        }
     }
-    buf= tbGetBuffer(len+1);
-    tmp= ctrls&XkbAllBooleanCtrlsMask;
-    for (len=i=0,bit=1;tmp!=0;i++,bit<<=1) {
-	if (tmp&bit) {
-	    tmp&= ~bit;
-	    if (format==XkbCFile) {
-		if (len!=0)
-		    buf[len++]= '|';
-		sprintf(&buf[len],"Xkb%sMask",ctrlNames[i]);
-		buf[len+3]= toupper(buf[len+3]);
-	    }
-	    else {
-		if (len!=0)
-		    buf[len++]= '+';
-		sprintf(&buf[len],"%s",ctrlNames[i]);
-	    }
-	    len+= strlen(&buf[len]);
-	}
+    buf = tbGetBuffer(len + 1);
+    tmp = ctrls & XkbAllBooleanCtrlsMask;
+    for (len = i = 0, bit = 1; tmp != 0; i++, bit <<= 1) {
+        if (tmp & bit) {
+            tmp &= ~bit;
+            if (format == XkbCFile) {
+                if (len != 0)
+                    buf[len++] = '|';
+                sprintf(&buf[len], "Xkb%sMask", ctrlNames[i]);
+                buf[len + 3] = toupper(buf[len + 3]);
+            }
+            else {
+                if (len != 0)
+                    buf[len++] = '+';
+                sprintf(&buf[len], "%s", ctrlNames[i]);
+            }
+            len += strlen(&buf[len]);
+        }
     }
     return buf;
 }
@@ -512,700 +546,763 @@ char *		buf;
 /***====================================================================***/
 
 char *
-XkbStringText(char *str,unsigned format)
+XkbStringText(char *str, unsigned format)
 {
-char *	buf;
-register char *in,*out;
-int	len;
-Bool	ok;
-
-    if (str==NULL) {
-	buf= tbGetBuffer(2);
-	buf[0]='\0';
-	return buf;
+    char *buf;
+    register char *in, *out;
+    int len;
+    Bool ok;
+
+    if (str == NULL) {
+        buf = tbGetBuffer(2);
+        buf[0] = '\0';
+        return buf;
     }
-    else if (format==XkbXKMFile)
-	return str;
-    for (ok= TRUE,len=0,in=str;*in!='\0';in++,len++) {
-	if (!isprint(*in)) {
-	    ok= FALSE;
-	    switch (*in) {
-		case '\n': case '\t': case '\v':
-		case '\b': case '\r': case '\f':
-		    len++;
-		    break;
-		default:
-		    len+= 4;
-		    break;
-	    }
-	}
+    else if (format == XkbXKMFile)
+        return str;
+    for (ok = TRUE, len = 0, in = str; *in != '\0'; in++, len++) {
+        if (!isprint(*in)) {
+            ok = FALSE;
+            switch (*in) {
+            case '\n':
+            case '\t':
+            case '\v':
+            case '\b':
+            case '\r':
+            case '\f':
+                len++;
+                break;
+            default:
+                len += 4;
+                break;
+            }
+        }
     }
     if (ok)
-	return str;
-    buf= tbGetBuffer(len+1);
-    for (in=str,out=buf;*in!='\0';in++) {
-	if (isprint(*in))
-	    *out++= *in;
-	else {
-	    *out++= '\\';
-	    if (*in=='\n')	*out++= 'n';
-	    else if (*in=='\t')	*out++= 't';
-	    else if (*in=='\v')	*out++= 'v';
-	    else if (*in=='\b')	*out++= 'b';
-	    else if (*in=='\r')	*out++= 'r';
-	    else if (*in=='\f')	*out++= 'f';
-	    else if ((*in=='\033')&&(format==XkbXKMFile)) {
-		*out++= 'e';
-	    }
-	    else {
-		*out++= '0';
-		sprintf(out,"%o",*in);
-		while (*out!='\0')
-		    out++;
-	    }
-	}
+        return str;
+    buf = tbGetBuffer(len + 1);
+    for (in = str, out = buf; *in != '\0'; in++) {
+        if (isprint(*in))
+            *out++ = *in;
+        else {
+            *out++ = '\\';
+            if (*in == '\n')
+                *out++ = 'n';
+            else if (*in == '\t')
+                *out++ = 't';
+            else if (*in == '\v')
+                *out++ = 'v';
+            else if (*in == '\b')
+                *out++ = 'b';
+            else if (*in == '\r')
+                *out++ = 'r';
+            else if (*in == '\f')
+                *out++ = 'f';
+            else if ((*in == '\033') && (format == XkbXKMFile)) {
+                *out++ = 'e';
+            }
+            else {
+                *out++ = '0';
+                sprintf(out, "%o", *in);
+                while (*out != '\0')
+                    out++;
+            }
+        }
     }
-    *out++= '\0';
+    *out++ = '\0';
     return buf;
 }
 
 /***====================================================================***/
 
 char *
-XkbGeomFPText(int val,unsigned format)
+XkbGeomFPText(int val, unsigned format)
 {
-int	whole,frac;
-char *	buf;
+    int whole, frac;
+    char *buf;
 
-    buf= tbGetBuffer(12);
-    if (format==XkbCFile) {
-	sprintf(buf,"%d",val);
+    buf = tbGetBuffer(12);
+    if (format == XkbCFile) {
+        sprintf(buf, "%d", val);
     }
     else {
-	whole= val/XkbGeomPtsPerMM;
-	frac= val%XkbGeomPtsPerMM;
-	if (frac!=0)
-	     sprintf(buf,"%d.%d",whole,frac);
-	else sprintf(buf,"%d",whole);
+        whole = val / XkbGeomPtsPerMM;
+        frac = val % XkbGeomPtsPerMM;
+        if (frac != 0)
+            sprintf(buf, "%d.%d", whole, frac);
+        else
+            sprintf(buf, "%d", whole);
     }
     return buf;
 }
 
 char *
-XkbDoodadTypeText(unsigned type,unsigned format)
+XkbDoodadTypeText(unsigned type, unsigned format)
 {
-char *	buf;
-    if (format==XkbCFile) {
-	buf= tbGetBuffer(24);
-	if (type==XkbOutlineDoodad)	   strcpy(buf,"XkbOutlineDoodad");
-	else if (type==XkbSolidDoodad)	   strcpy(buf,"XkbSolidDoodad");
-	else if (type==XkbTextDoodad)	   strcpy(buf,"XkbTextDoodad");
-	else if (type==XkbIndicatorDoodad) strcpy(buf,"XkbIndicatorDoodad");
-	else if (type==XkbLogoDoodad)	   strcpy(buf,"XkbLogoDoodad");
-	else				   sprintf(buf,"UnknownDoodad%d",type);
+    char *buf;
+
+    if (format == XkbCFile) {
+        buf = tbGetBuffer(24);
+        if (type == XkbOutlineDoodad)
+            strcpy(buf, "XkbOutlineDoodad");
+        else if (type == XkbSolidDoodad)
+            strcpy(buf, "XkbSolidDoodad");
+        else if (type == XkbTextDoodad)
+            strcpy(buf, "XkbTextDoodad");
+        else if (type == XkbIndicatorDoodad)
+            strcpy(buf, "XkbIndicatorDoodad");
+        else if (type == XkbLogoDoodad)
+            strcpy(buf, "XkbLogoDoodad");
+        else
+            sprintf(buf, "UnknownDoodad%d", type);
     }
     else {
-	buf= tbGetBuffer(12);
-	if (type==XkbOutlineDoodad)	   strcpy(buf,"outline");
-	else if (type==XkbSolidDoodad)	   strcpy(buf,"solid");
-	else if (type==XkbTextDoodad)	   strcpy(buf,"text");
-	else if (type==XkbIndicatorDoodad) strcpy(buf,"indicator");
-	else if (type==XkbLogoDoodad)	   strcpy(buf,"logo");
-	else				   sprintf(buf,"unknown%d",type);
+        buf = tbGetBuffer(12);
+        if (type == XkbOutlineDoodad)
+            strcpy(buf, "outline");
+        else if (type == XkbSolidDoodad)
+            strcpy(buf, "solid");
+        else if (type == XkbTextDoodad)
+            strcpy(buf, "text");
+        else if (type == XkbIndicatorDoodad)
+            strcpy(buf, "indicator");
+        else if (type == XkbLogoDoodad)
+            strcpy(buf, "logo");
+        else
+            sprintf(buf, "unknown%d", type);
     }
     return buf;
 }
 
-static const char *actionTypeNames[XkbSA_NumActions]= {
-    "NoAction", 
-    "SetMods",      "LatchMods",    "LockMods", 
-    "SetGroup",     "LatchGroup",   "LockGroup",
+static const char *actionTypeNames[XkbSA_NumActions] = {
+    "NoAction",
+    "SetMods", "LatchMods", "LockMods",
+    "SetGroup", "LatchGroup", "LockGroup",
     "MovePtr",
-    "PtrBtn",       "LockPtrBtn",
+    "PtrBtn", "LockPtrBtn",
     "SetPtrDflt",
     "ISOLock",
-    "Terminate",    "SwitchScreen", 
-    "SetControls",  "LockControls",
+    "Terminate", "SwitchScreen",
+    "SetControls", "LockControls",
     "ActionMessage",
     "RedirectKey",
-    "DeviceBtn",    "LockDeviceBtn"
+    "DeviceBtn", "LockDeviceBtn"
 };
 
 const char *
-XkbActionTypeText(unsigned type,unsigned format)
+XkbActionTypeText(unsigned type, unsigned format)
 {
-static char buf[32];
-const char *rtrn;
-
-    if (type<=XkbSA_LastAction) {
-	rtrn= actionTypeNames[type];
-	if (format==XkbCFile) {
-	    snprintf(buf,sizeof(buf),"XkbSA_%s",rtrn);
-	    return buf;
-	}
-	return rtrn;
+    static char buf[32];
+    const char *rtrn;
+
+    if (type <= XkbSA_LastAction) {
+        rtrn = actionTypeNames[type];
+        if (format == XkbCFile) {
+            snprintf(buf, sizeof(buf), "XkbSA_%s", rtrn);
+            return buf;
+        }
+        return rtrn;
     }
-    snprintf(buf,sizeof(buf),"Private");
+    snprintf(buf, sizeof(buf), "Private");
     return buf;
 }
 
 /***====================================================================***/
 
 static int
-TryCopyStr(char *to,const char *from,int *pLeft)
+TryCopyStr(char *to, const char *from, int *pLeft)
 {
-register int len;
-    if (*pLeft>0) {
-	len= strlen(from);
-	if (len<((*pLeft)-3)) {
-	    strcat(to,from);
-	    *pLeft-= len;
-	    return TRUE;
-	}
+    register int len;
+
+    if (*pLeft > 0) {
+        len = strlen(from);
+        if (len < ((*pLeft) - 3)) {
+            strcat(to, from);
+            *pLeft -= len;
+            return TRUE;
+        }
     }
-    *pLeft= -1;
+    *pLeft = -1;
     return FALSE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyNoActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int*sz)
+ /*ARGSUSED*/ static Bool
+CopyNoActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
     return TRUE;
 }
 
 static Bool
-CopyModActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int* sz)
+CopyModActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbModAction *	act;
-unsigned	tmp;
-
-    act= &action->mods;
-    tmp= XkbModActionVMods(act);
-    TryCopyStr(buf,"modifiers=",sz);
-    if (act->flags&XkbSA_UseModMapMods)
-	  TryCopyStr(buf,"modMapMods",sz);
+    XkbModAction *act;
+    unsigned tmp;
+
+    act = &action->mods;
+    tmp = XkbModActionVMods(act);
+    TryCopyStr(buf, "modifiers=", sz);
+    if (act->flags & XkbSA_UseModMapMods)
+        TryCopyStr(buf, "modMapMods", sz);
     else if (act->real_mods || tmp) {
-	 TryCopyStr(buf,
-		     XkbVModMaskText(xkb,act->real_mods,tmp,XkbXKBFile),
-		     sz);
+        TryCopyStr(buf,
+                   XkbVModMaskText(xkb, act->real_mods, tmp, XkbXKBFile), sz);
     }
-    else TryCopyStr(buf,"none",sz);
-    if (act->type==XkbSA_LockMods)
-	return TRUE;
-    if (act->flags&XkbSA_ClearLocks)
-	TryCopyStr(buf,",clearLocks",sz);
-    if (act->flags&XkbSA_LatchToLock)
-	TryCopyStr(buf,",latchToLock",sz);
+    else
+        TryCopyStr(buf, "none", sz);
+    if (act->type == XkbSA_LockMods)
+        return TRUE;
+    if (act->flags & XkbSA_ClearLocks)
+        TryCopyStr(buf, ",clearLocks", sz);
+    if (act->flags & XkbSA_LatchToLock)
+        TryCopyStr(buf, ",latchToLock", sz);
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyGroupActionArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+ /*ARGSUSED*/ static Bool
+CopyGroupActionArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbGroupAction *	act;
-char			tbuf[32];
-
-    act= &action->group;
-    TryCopyStr(buf,"group=",sz);
-    if (act->flags&XkbSA_GroupAbsolute)
-	 snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act)+1);
-    else if (XkbSAGroup(act)<0)
-	 snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act));
-    else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAGroup(act));
-    TryCopyStr(buf,tbuf,sz);
-    if (act->type==XkbSA_LockGroup)
-	return TRUE;
-    if (act->flags&XkbSA_ClearLocks)
-	TryCopyStr(buf,",clearLocks",sz);
-    if (act->flags&XkbSA_LatchToLock)
-	TryCopyStr(buf,",latchToLock",sz);
+    XkbGroupAction *act;
+    char tbuf[32];
+
+    act = &action->group;
+    TryCopyStr(buf, "group=", sz);
+    if (act->flags & XkbSA_GroupAbsolute)
+        snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act) + 1);
+    else if (XkbSAGroup(act) < 0)
+        snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act));
+    else
+        snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAGroup(act));
+    TryCopyStr(buf, tbuf, sz);
+    if (act->type == XkbSA_LockGroup)
+        return TRUE;
+    if (act->flags & XkbSA_ClearLocks)
+        TryCopyStr(buf, ",clearLocks", sz);
+    if (act->flags & XkbSA_LatchToLock)
+        TryCopyStr(buf, ",latchToLock", sz);
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyMovePtrArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyMovePtrArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbPtrAction *	act;
-int		x,y;
-char		tbuf[32];
-
-    act= &action->ptr;
-    x= XkbPtrActionX(act);
-    y= XkbPtrActionY(act);
-    if ((act->flags&XkbSA_MoveAbsoluteX)||(x<0))
-	 snprintf(tbuf,sizeof(tbuf),"x=%d",x);
-    else snprintf(tbuf,sizeof(tbuf),"x=+%d",x);
-    TryCopyStr(buf,tbuf,sz);
-
-    if ((act->flags&XkbSA_MoveAbsoluteY)||(y<0))
-	 snprintf(tbuf,sizeof(tbuf),",y=%d",y);
-    else snprintf(tbuf,sizeof(tbuf),",y=+%d",y);
-    TryCopyStr(buf,tbuf,sz);
-    if (act->flags&XkbSA_NoAcceleration)
-	TryCopyStr(buf,",!accel",sz);
+    XkbPtrAction *act;
+    int x, y;
+    char tbuf[32];
+
+    act = &action->ptr;
+    x = XkbPtrActionX(act);
+    y = XkbPtrActionY(act);
+    if ((act->flags & XkbSA_MoveAbsoluteX) || (x < 0))
+        snprintf(tbuf, sizeof(tbuf), "x=%d", x);
+    else
+        snprintf(tbuf, sizeof(tbuf), "x=+%d", x);
+    TryCopyStr(buf, tbuf, sz);
+
+    if ((act->flags & XkbSA_MoveAbsoluteY) || (y < 0))
+        snprintf(tbuf, sizeof(tbuf), ",y=%d", y);
+    else
+        snprintf(tbuf, sizeof(tbuf), ",y=+%d", y);
+    TryCopyStr(buf, tbuf, sz);
+    if (act->flags & XkbSA_NoAcceleration)
+        TryCopyStr(buf, ",!accel", sz);
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyPtrBtnArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyPtrBtnArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbPtrBtnAction *	act;
-char			tbuf[32];
-
-    act= &action->btn;
-    TryCopyStr(buf,"button=",sz);
-    if ((act->button>0)&&(act->button<6)) {
-	 snprintf(tbuf,sizeof(tbuf),"%d",act->button);
-	 TryCopyStr(buf,tbuf,sz);
+    XkbPtrBtnAction *act;
+    char tbuf[32];
+
+    act = &action->btn;
+    TryCopyStr(buf, "button=", sz);
+    if ((act->button > 0) && (act->button < 6)) {
+        snprintf(tbuf, sizeof(tbuf), "%d", act->button);
+        TryCopyStr(buf, tbuf, sz);
     }
-    else TryCopyStr(buf,"default",sz);
-    if (act->count>0) {
-	snprintf(tbuf,sizeof(tbuf),",count=%d",act->count);
-	TryCopyStr(buf,tbuf,sz);
+    else
+        TryCopyStr(buf, "default", sz);
+    if (act->count > 0) {
+        snprintf(tbuf, sizeof(tbuf), ",count=%d", act->count);
+        TryCopyStr(buf, tbuf, sz);
     }
-    if (action->type==XkbSA_LockPtrBtn) {
-	switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
-	    case XkbSA_LockNoLock:
-		TryCopyStr(buf,",affect=unlock",sz); break;
-	    case XkbSA_LockNoUnlock:
-		TryCopyStr(buf,",affect=lock",sz); break;
-	    case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
-		TryCopyStr(buf,",affect=neither",sz); break;
-	    default:
-		TryCopyStr(buf,",affect=both",sz); break;
-	}
+    if (action->type == XkbSA_LockPtrBtn) {
+        switch (act->flags & (XkbSA_LockNoUnlock | XkbSA_LockNoLock)) {
+        case XkbSA_LockNoLock:
+            TryCopyStr(buf, ",affect=unlock", sz);
+            break;
+        case XkbSA_LockNoUnlock:
+            TryCopyStr(buf, ",affect=lock", sz);
+            break;
+        case XkbSA_LockNoUnlock | XkbSA_LockNoLock:
+            TryCopyStr(buf, ",affect=neither", sz);
+            break;
+        default:
+            TryCopyStr(buf, ",affect=both", sz);
+            break;
+        }
     }
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopySetPtrDfltArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+ /*ARGSUSED*/ static Bool
+CopySetPtrDfltArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbPtrDfltAction *	act;
-char			tbuf[32];
-
-    act= &action->dflt;
-    if (act->affect==XkbSA_AffectDfltBtn) {
-	TryCopyStr(buf,"affect=button,button=",sz);
-	if ((act->flags&XkbSA_DfltBtnAbsolute)||(XkbSAPtrDfltValue(act)<0))
-	     snprintf(tbuf,sizeof(tbuf),"%d",XkbSAPtrDfltValue(act));
-	else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAPtrDfltValue(act));
-	TryCopyStr(buf,tbuf,sz);
+    XkbPtrDfltAction *act;
+    char tbuf[32];
+
+    act = &action->dflt;
+    if (act->affect == XkbSA_AffectDfltBtn) {
+        TryCopyStr(buf, "affect=button,button=", sz);
+        if ((act->flags & XkbSA_DfltBtnAbsolute) ||
+            (XkbSAPtrDfltValue(act) < 0))
+            snprintf(tbuf, sizeof(tbuf), "%d", XkbSAPtrDfltValue(act));
+        else
+            snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAPtrDfltValue(act));
+        TryCopyStr(buf, tbuf, sz);
     }
     return TRUE;
 }
 
 static Bool
-CopyISOLockArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+CopyISOLockArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbISOAction *	act;
-char		tbuf[64];
-
-    act= &action->iso;
-    if (act->flags&XkbSA_ISODfltIsGroup) {
-	TryCopyStr(tbuf,"group=",sz);
-	if (act->flags&XkbSA_GroupAbsolute)
-	     snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act)+1);
-	else if (XkbSAGroup(act)<0)
-	     snprintf(tbuf,sizeof(tbuf),"%d",XkbSAGroup(act));
-	else snprintf(tbuf,sizeof(tbuf),"+%d",XkbSAGroup(act));
-	TryCopyStr(buf,tbuf,sz);
+    XkbISOAction *act;
+    char tbuf[64];
+
+    act = &action->iso;
+    if (act->flags & XkbSA_ISODfltIsGroup) {
+        TryCopyStr(tbuf, "group=", sz);
+        if (act->flags & XkbSA_GroupAbsolute)
+            snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act) + 1);
+        else if (XkbSAGroup(act) < 0)
+            snprintf(tbuf, sizeof(tbuf), "%d", XkbSAGroup(act));
+        else
+            snprintf(tbuf, sizeof(tbuf), "+%d", XkbSAGroup(act));
+        TryCopyStr(buf, tbuf, sz);
     }
     else {
-	unsigned tmp;
-	tmp= XkbModActionVMods(act);
-	TryCopyStr(buf,"modifiers=",sz);
-	if (act->flags&XkbSA_UseModMapMods)
-	     TryCopyStr(buf,"modMapMods",sz);
-	else if (act->real_mods || tmp) {
-	    if (act->real_mods) {
-		TryCopyStr(buf,XkbModMaskText(act->real_mods,XkbXKBFile),sz);
-		if (tmp)
-		    TryCopyStr(buf,"+",sz);
-	    }
-	    if (tmp)
-		TryCopyStr(buf,XkbVModMaskText(xkb,0,tmp,XkbXKBFile),sz);
-	}
-	else TryCopyStr(buf,"none",sz);
+        unsigned tmp;
+
+        tmp = XkbModActionVMods(act);
+        TryCopyStr(buf, "modifiers=", sz);
+        if (act->flags & XkbSA_UseModMapMods)
+            TryCopyStr(buf, "modMapMods", sz);
+        else if (act->real_mods || tmp) {
+            if (act->real_mods) {
+                TryCopyStr(buf, XkbModMaskText(act->real_mods, XkbXKBFile), sz);
+                if (tmp)
+                    TryCopyStr(buf, "+", sz);
+            }
+            if (tmp)
+                TryCopyStr(buf, XkbVModMaskText(xkb, 0, tmp, XkbXKBFile), sz);
+        }
+        else
+            TryCopyStr(buf, "none", sz);
     }
-    TryCopyStr(buf,",affect=",sz);
-    if ((act->affect&XkbSA_ISOAffectMask)==0)
-	TryCopyStr(buf,"all",sz);
+    TryCopyStr(buf, ",affect=", sz);
+    if ((act->affect & XkbSA_ISOAffectMask) == 0)
+        TryCopyStr(buf, "all", sz);
     else {
-	int nOut= 0;
-	if ((act->affect&XkbSA_ISONoAffectMods)==0) {
-	    TryCopyStr(buf,"mods",sz);
-	    nOut++;
-	}
-	if ((act->affect&XkbSA_ISONoAffectGroup)==0) {
-	    snprintf(tbuf,sizeof(tbuf),"%sgroups",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if ((act->affect&XkbSA_ISONoAffectPtr)==0) {
-	    snprintf(tbuf,sizeof(tbuf),"%spointer",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if ((act->affect&XkbSA_ISONoAffectCtrls)==0) {
-	    snprintf(tbuf,sizeof(tbuf),"%scontrols",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
+        int nOut = 0;
+
+        if ((act->affect & XkbSA_ISONoAffectMods) == 0) {
+            TryCopyStr(buf, "mods", sz);
+            nOut++;
+        }
+        if ((act->affect & XkbSA_ISONoAffectGroup) == 0) {
+            snprintf(tbuf, sizeof(tbuf), "%sgroups", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if ((act->affect & XkbSA_ISONoAffectPtr) == 0) {
+            snprintf(tbuf, sizeof(tbuf), "%spointer", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if ((act->affect & XkbSA_ISONoAffectCtrls) == 0) {
+            snprintf(tbuf, sizeof(tbuf), "%scontrols", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
     }
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopySwitchScreenArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+ /*ARGSUSED*/ static Bool
+CopySwitchScreenArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbSwitchScreenAction *	act;
-char			tbuf[32];
-
-    act= &action->screen;
-    if ((act->flags&XkbSA_SwitchAbsolute)||(XkbSAScreen(act)<0))
-	 snprintf(tbuf,sizeof(tbuf),"screen=%d",XkbSAScreen(act));
-    else snprintf(tbuf,sizeof(tbuf),"screen=+%d",XkbSAScreen(act));
-    TryCopyStr(buf,tbuf,sz);
-    if (act->flags&XkbSA_SwitchApplication)
-	 TryCopyStr(buf,",!same",sz);
-    else TryCopyStr(buf,",same",sz);
+    XkbSwitchScreenAction *act;
+    char tbuf[32];
+
+    act = &action->screen;
+    if ((act->flags & XkbSA_SwitchAbsolute) || (XkbSAScreen(act) < 0))
+        snprintf(tbuf, sizeof(tbuf), "screen=%d", XkbSAScreen(act));
+    else
+        snprintf(tbuf, sizeof(tbuf), "screen=+%d", XkbSAScreen(act));
+    TryCopyStr(buf, tbuf, sz);
+    if (act->flags & XkbSA_SwitchApplication)
+        TryCopyStr(buf, ",!same", sz);
+    else
+        TryCopyStr(buf, ",same", sz);
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopySetLockControlsArgs(XkbDescPtr xkb,XkbAction *action,
-							char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopySetLockControlsArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbCtrlsAction *	act;
-unsigned		tmp;
-char			tbuf[32];
-
-    act= &action->ctrls;
-    tmp= XkbActionCtrls(act);
-    TryCopyStr(buf,"controls=",sz);
-    if (tmp==0)
-	TryCopyStr(buf,"none",sz);
-    else if ((tmp&XkbAllBooleanCtrlsMask)==XkbAllBooleanCtrlsMask)
-	TryCopyStr(buf,"all",sz);
+    XkbCtrlsAction *act;
+    unsigned tmp;
+    char tbuf[32];
+
+    act = &action->ctrls;
+    tmp = XkbActionCtrls(act);
+    TryCopyStr(buf, "controls=", sz);
+    if (tmp == 0)
+        TryCopyStr(buf, "none", sz);
+    else if ((tmp & XkbAllBooleanCtrlsMask) == XkbAllBooleanCtrlsMask)
+        TryCopyStr(buf, "all", sz);
     else {
-	int nOut= 0;
-	if (tmp&XkbRepeatKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sRepeatKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbSlowKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sSlowKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbBounceKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sBounceKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbStickyKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sStickyKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbMouseKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sMouseKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbMouseKeysAccelMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sMouseKeysAccel",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbAccessXKeysMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sAccessXKeys",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbAccessXTimeoutMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sAccessXTimeout",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbAccessXFeedbackMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sAccessXFeedback",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbAudibleBellMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sAudibleBell",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbOverlay1Mask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sOverlay1",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbOverlay2Mask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sOverlay2",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
-	if (tmp&XkbIgnoreGroupLockMask) {
-	    snprintf(tbuf,sizeof(tbuf),"%sIgnoreGroupLock",(nOut>0?"+":""));
-	    TryCopyStr(buf,tbuf,sz);
-	    nOut++;
-	}
+        int nOut = 0;
+
+        if (tmp & XkbRepeatKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sRepeatKeys", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbSlowKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sSlowKeys", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbBounceKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sBounceKeys", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbStickyKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sStickyKeys", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbMouseKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sMouseKeys", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbMouseKeysAccelMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sMouseKeysAccel",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbAccessXKeysMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sAccessXKeys",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbAccessXTimeoutMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sAccessXTimeout",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbAccessXFeedbackMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sAccessXFeedback",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbAudibleBellMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sAudibleBell",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbOverlay1Mask) {
+            snprintf(tbuf, sizeof(tbuf), "%sOverlay1", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbOverlay2Mask) {
+            snprintf(tbuf, sizeof(tbuf), "%sOverlay2", (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
+        if (tmp & XkbIgnoreGroupLockMask) {
+            snprintf(tbuf, sizeof(tbuf), "%sIgnoreGroupLock",
+                     (nOut > 0 ? "+" : ""));
+            TryCopyStr(buf, tbuf, sz);
+            nOut++;
+        }
     }
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyActionMessageArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+ /*ARGSUSED*/ static Bool
+CopyActionMessageArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbMessageAction *	act;
-unsigned		all;
-char			tbuf[32];
-
-    act= &action->msg;
-    all= XkbSA_MessageOnPress|XkbSA_MessageOnRelease;
-    TryCopyStr(buf,"report=",sz);
-    if ((act->flags&all)==0)
-	TryCopyStr(buf,"none",sz);
-    else if ((act->flags&all)==all)
-	TryCopyStr(buf,"all",sz);
-    else if (act->flags&XkbSA_MessageOnPress)
-	 TryCopyStr(buf,"KeyPress",sz);
-    else TryCopyStr(buf,"KeyRelease",sz);
-    snprintf(tbuf,sizeof(tbuf),",data[0]=0x%02x",act->message[0]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[1]=0x%02x",act->message[1]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[2]=0x%02x",act->message[2]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[3]=0x%02x",act->message[3]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[4]=0x%02x",act->message[4]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[5]=0x%02x",act->message[5]); TryCopyStr(buf,tbuf,sz);
+    XkbMessageAction *act;
+    unsigned all;
+    char tbuf[32];
+
+    act = &action->msg;
+    all = XkbSA_MessageOnPress | XkbSA_MessageOnRelease;
+    TryCopyStr(buf, "report=", sz);
+    if ((act->flags & all) == 0)
+        TryCopyStr(buf, "none", sz);
+    else if ((act->flags & all) == all)
+        TryCopyStr(buf, "all", sz);
+    else if (act->flags & XkbSA_MessageOnPress)
+        TryCopyStr(buf, "KeyPress", sz);
+    else
+        TryCopyStr(buf, "KeyRelease", sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[0]=0x%02x", act->message[0]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[1]=0x%02x", act->message[1]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[2]=0x%02x", act->message[2]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[3]=0x%02x", act->message[3]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[4]=0x%02x", act->message[4]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[5]=0x%02x", act->message[5]);
+    TryCopyStr(buf, tbuf, sz);
     return TRUE;
 }
 
 static Bool
-CopyRedirectKeyArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+CopyRedirectKeyArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbRedirectKeyAction *	act;
-char			tbuf[32],*tmp;
-unsigned		kc;
-unsigned		vmods,vmods_mask;
-
-    act= &action->redirect;
-    kc= act->new_key;
-    vmods= XkbSARedirectVMods(act);
-    vmods_mask= XkbSARedirectVModsMask(act);
-    if (xkb && xkb->names && xkb->names->keys && (kc<=xkb->max_key_code) &&
-				(xkb->names->keys[kc].name[0]!='\0')) {
-	char *kn;
-	kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
-	snprintf(tbuf,sizeof(tbuf),"key=%s",kn);
+    XkbRedirectKeyAction *act;
+    char tbuf[32], *tmp;
+    unsigned kc;
+    unsigned vmods, vmods_mask;
+
+    act = &action->redirect;
+    kc = act->new_key;
+    vmods = XkbSARedirectVMods(act);
+    vmods_mask = XkbSARedirectVModsMask(act);
+    if (xkb && xkb->names && xkb->names->keys && (kc <= xkb->max_key_code) &&
+        (xkb->names->keys[kc].name[0] != '\0')) {
+        char *kn;
+
+        kn = XkbKeyNameText(xkb->names->keys[kc].name, XkbXKBFile);
+        snprintf(tbuf, sizeof(tbuf), "key=%s", kn);
     }
-    else snprintf(tbuf,sizeof(tbuf),"key=%d",kc);
-    TryCopyStr(buf,tbuf,sz);
-    if ((act->mods_mask==0)&&(vmods_mask==0))
-	return TRUE;
-    if ((act->mods_mask==XkbAllModifiersMask)&&
-	(vmods_mask==XkbAllVirtualModsMask)) {
-	tmp= XkbVModMaskText(xkb,act->mods,vmods,XkbXKBFile);
-	TryCopyStr(buf,",mods=",sz);
-	TryCopyStr(buf,tmp,sz);
+    else
+        snprintf(tbuf, sizeof(tbuf), "key=%d", kc);
+    TryCopyStr(buf, tbuf, sz);
+    if ((act->mods_mask == 0) && (vmods_mask == 0))
+        return TRUE;
+    if ((act->mods_mask == XkbAllModifiersMask) &&
+        (vmods_mask == XkbAllVirtualModsMask)) {
+        tmp = XkbVModMaskText(xkb, act->mods, vmods, XkbXKBFile);
+        TryCopyStr(buf, ",mods=", sz);
+        TryCopyStr(buf, tmp, sz);
     }
     else {
-	if ((act->mods_mask&act->mods)||(vmods_mask&vmods)) {
-	    tmp= XkbVModMaskText(xkb,act->mods_mask&act->mods,
-					 vmods_mask&vmods,XkbXKBFile);
-	    TryCopyStr(buf,",mods= ",sz);
-	    TryCopyStr(buf,tmp,sz);
-	}
-	if ((act->mods_mask&(~act->mods))||(vmods_mask&(~vmods))) {
-	    tmp= XkbVModMaskText(xkb,act->mods_mask&(~act->mods),
-					 vmods_mask&(~vmods),XkbXKBFile);
-	    TryCopyStr(buf,",clearMods= ",sz);
-	    TryCopyStr(buf,tmp,sz);
-	}
+        if ((act->mods_mask & act->mods) || (vmods_mask & vmods)) {
+            tmp = XkbVModMaskText(xkb, act->mods_mask & act->mods,
+                                  vmods_mask & vmods, XkbXKBFile);
+            TryCopyStr(buf, ",mods= ", sz);
+            TryCopyStr(buf, tmp, sz);
+        }
+        if ((act->mods_mask & (~act->mods)) || (vmods_mask & (~vmods))) {
+            tmp = XkbVModMaskText(xkb, act->mods_mask & (~act->mods),
+                                  vmods_mask & (~vmods), XkbXKBFile);
+            TryCopyStr(buf, ",clearMods= ", sz);
+            TryCopyStr(buf, tmp, sz);
+        }
     }
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyDeviceBtnArgs(XkbDescPtr xkb,XkbAction *action,char *buf,
-								int *sz)
+ /*ARGSUSED*/ static Bool
+CopyDeviceBtnArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbDeviceBtnAction *	act;
-char			tbuf[32];
-
-    act= &action->devbtn;
-    snprintf(tbuf,sizeof(tbuf),"device= %d",act->device); TryCopyStr(buf,tbuf,sz);
-    TryCopyStr(buf,",button=",sz);
-    snprintf(tbuf,sizeof(tbuf),"%d",act->button);
-    TryCopyStr(buf,tbuf,sz);
-    if (act->count>0) {
-	snprintf(tbuf,sizeof(tbuf),",count=%d",act->count);
-	TryCopyStr(buf,tbuf,sz);
+    XkbDeviceBtnAction *act;
+    char tbuf[32];
+
+    act = &action->devbtn;
+    snprintf(tbuf, sizeof(tbuf), "device= %d", act->device);
+    TryCopyStr(buf, tbuf, sz);
+    TryCopyStr(buf, ",button=", sz);
+    snprintf(tbuf, sizeof(tbuf), "%d", act->button);
+    TryCopyStr(buf, tbuf, sz);
+    if (act->count > 0) {
+        snprintf(tbuf, sizeof(tbuf), ",count=%d", act->count);
+        TryCopyStr(buf, tbuf, sz);
     }
-    if (action->type==XkbSA_LockDeviceBtn) {
-	switch (act->flags&(XkbSA_LockNoUnlock|XkbSA_LockNoLock)) {
-	    case XkbSA_LockNoLock:
-		TryCopyStr(buf,",affect=unlock",sz); break;
-	    case XkbSA_LockNoUnlock:
-		TryCopyStr(buf,",affect=lock",sz); break;
-	    case XkbSA_LockNoUnlock|XkbSA_LockNoLock:
-		TryCopyStr(buf,",affect=neither",sz); break;
-	    default:
-		TryCopyStr(buf,",affect=both",sz); break;
-	}
+    if (action->type == XkbSA_LockDeviceBtn) {
+        switch (act->flags & (XkbSA_LockNoUnlock | XkbSA_LockNoLock)) {
+        case XkbSA_LockNoLock:
+            TryCopyStr(buf, ",affect=unlock", sz);
+            break;
+        case XkbSA_LockNoUnlock:
+            TryCopyStr(buf, ",affect=lock", sz);
+            break;
+        case XkbSA_LockNoUnlock | XkbSA_LockNoLock:
+            TryCopyStr(buf, ",affect=neither", sz);
+            break;
+        default:
+            TryCopyStr(buf, ",affect=both", sz);
+            break;
+        }
     }
     return TRUE;
 }
 
-/*ARGSUSED*/
-static Bool
-CopyOtherArgs(XkbDescPtr xkb,XkbAction *action,char *buf,int *sz)
+ /*ARGSUSED*/ static Bool
+CopyOtherArgs(XkbDescPtr xkb, XkbAction *action, char *buf, int *sz)
 {
-XkbAnyAction *	act;
-char		tbuf[32];
-
-    act= &action->any;
-    snprintf(tbuf,sizeof(tbuf),"type=0x%02x",act->type); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[0]=0x%02x",act->data[0]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[1]=0x%02x",act->data[1]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[2]=0x%02x",act->data[2]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[3]=0x%02x",act->data[3]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[4]=0x%02x",act->data[4]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[5]=0x%02x",act->data[5]); TryCopyStr(buf,tbuf,sz);
-    snprintf(tbuf,sizeof(tbuf),",data[6]=0x%02x",act->data[6]); TryCopyStr(buf,tbuf,sz);
+    XkbAnyAction *act;
+    char tbuf[32];
+
+    act = &action->any;
+    snprintf(tbuf, sizeof(tbuf), "type=0x%02x", act->type);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[0]=0x%02x", act->data[0]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[1]=0x%02x", act->data[1]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[2]=0x%02x", act->data[2]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[3]=0x%02x", act->data[3]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[4]=0x%02x", act->data[4]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[5]=0x%02x", act->data[5]);
+    TryCopyStr(buf, tbuf, sz);
+    snprintf(tbuf, sizeof(tbuf), ",data[6]=0x%02x", act->data[6]);
+    TryCopyStr(buf, tbuf, sz);
     return TRUE;
 }
 
-typedef	Bool	(*actionCopy)(
-	XkbDescPtr 	/* xkb */,
-	XkbAction *	/* action */,
-	char *		/* buf */,
-	int*		/* sz */
-);
-static actionCopy	copyActionArgs[XkbSA_NumActions] = {
-	CopyNoActionArgs		/* NoAction	*/,
-	CopyModActionArgs		/* SetMods	*/,
-	CopyModActionArgs		/* LatchMods	*/,
-	CopyModActionArgs		/* LockMods	*/,
-	CopyGroupActionArgs		/* SetGroup	*/,
-	CopyGroupActionArgs		/* LatchGroup	*/,
-	CopyGroupActionArgs		/* LockGroup	*/,
-	CopyMovePtrArgs			/* MovePtr	*/,
-	CopyPtrBtnArgs			/* PtrBtn	*/,
-	CopyPtrBtnArgs			/* LockPtrBtn	*/,
-	CopySetPtrDfltArgs		/* SetPtrDflt	*/,
-	CopyISOLockArgs			/* ISOLock	*/,
-	CopyNoActionArgs		/* Terminate	*/,
-	CopySwitchScreenArgs		/* SwitchScreen	*/,
-	CopySetLockControlsArgs		/* SetControls	*/,
-	CopySetLockControlsArgs		/* LockControls	*/,
-	CopyActionMessageArgs		/* ActionMessage*/,
-	CopyRedirectKeyArgs		/* RedirectKey	*/,
-	CopyDeviceBtnArgs		/* DeviceBtn	*/,
-	CopyDeviceBtnArgs		/* LockDeviceBtn*/
+typedef Bool (*actionCopy) (XkbDescPtr /* xkb */ ,
+                            XkbAction * /* action */ ,
+                            char * /* buf */ ,
+                            int *       /* sz */
+    );
+
+static actionCopy copyActionArgs[XkbSA_NumActions] = {
+    CopyNoActionArgs /* NoAction     */ ,
+    CopyModActionArgs /* SetMods      */ ,
+    CopyModActionArgs /* LatchMods    */ ,
+    CopyModActionArgs /* LockMods     */ ,
+    CopyGroupActionArgs /* SetGroup     */ ,
+    CopyGroupActionArgs /* LatchGroup   */ ,
+    CopyGroupActionArgs /* LockGroup    */ ,
+    CopyMovePtrArgs /* MovePtr      */ ,
+    CopyPtrBtnArgs /* PtrBtn       */ ,
+    CopyPtrBtnArgs /* LockPtrBtn   */ ,
+    CopySetPtrDfltArgs /* SetPtrDflt   */ ,
+    CopyISOLockArgs /* ISOLock      */ ,
+    CopyNoActionArgs /* Terminate    */ ,
+    CopySwitchScreenArgs /* SwitchScreen */ ,
+    CopySetLockControlsArgs /* SetControls  */ ,
+    CopySetLockControlsArgs /* LockControls */ ,
+    CopyActionMessageArgs /* ActionMessage */ ,
+    CopyRedirectKeyArgs /* RedirectKey  */ ,
+    CopyDeviceBtnArgs /* DeviceBtn    */ ,
+    CopyDeviceBtnArgs           /* LockDeviceBtn */
 };
 
 #define	ACTION_SZ	256
 
 char *
-XkbActionText(XkbDescPtr xkb,XkbAction *action,unsigned format)
+XkbActionText(XkbDescPtr xkb, XkbAction *action, unsigned format)
 {
-char	buf[ACTION_SZ],*tmp;
-int	sz;
-
-    if (format==XkbCFile) {
-	snprintf(buf,sizeof(buf),
-	    "{ %20s, { 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x } }",
-	    XkbActionTypeText(action->type,XkbCFile),
-	    action->any.data[0],action->any.data[1],action->any.data[2],
-	    action->any.data[3],action->any.data[4],action->any.data[5],
-	    action->any.data[6]);
+    char buf[ACTION_SZ], *tmp;
+    int sz;
+
+    if (format == XkbCFile) {
+        snprintf(buf, sizeof(buf),
+                 "{ %20s, { 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x } }",
+                 XkbActionTypeText(action->type, XkbCFile),
+                 action->any.data[0], action->any.data[1], action->any.data[2],
+                 action->any.data[3], action->any.data[4], action->any.data[5],
+                 action->any.data[6]);
     }
     else {
-	snprintf(buf,sizeof(buf),"%s(",XkbActionTypeText(action->type,XkbXKBFile));
-	sz= ACTION_SZ-strlen(buf)+2; /* room for close paren and NULL */
-	if (action->type<(unsigned)XkbSA_NumActions)
-	     (*copyActionArgs[action->type])(xkb,action,buf,&sz);
-	else CopyOtherArgs(xkb,action,buf,&sz);
-	TryCopyStr(buf,")",&sz);
+        snprintf(buf, sizeof(buf), "%s(",
+                 XkbActionTypeText(action->type, XkbXKBFile));
+        sz = ACTION_SZ - strlen(buf) + 2;       /* room for close paren and NULL */
+        if (action->type < (unsigned) XkbSA_NumActions)
+            (*copyActionArgs[action->type]) (xkb, action, buf, &sz);
+        else
+            CopyOtherArgs(xkb, action, buf, &sz);
+        TryCopyStr(buf, ")", &sz);
     }
-    tmp= tbGetBuffer(strlen(buf)+1);
-    if (tmp!=NULL)
-	strcpy(tmp,buf);
+    tmp = tbGetBuffer(strlen(buf) + 1);
+    if (tmp != NULL)
+        strcpy(tmp, buf);
     return tmp;
 }
 
 char *
-XkbBehaviorText(XkbDescPtr xkb,XkbBehavior *behavior,unsigned format)
+XkbBehaviorText(XkbDescPtr xkb, XkbBehavior * behavior, unsigned format)
 {
-char	buf[256],*tmp;
-
-    if (format==XkbCFile) {
-	if (behavior->type==XkbKB_Default)
-	     snprintf(buf,sizeof(buf),"{   0,    0 }");
-	else snprintf(buf,sizeof(buf),"{ %3d, 0x%02x }",behavior->type,behavior->data);
+    char buf[256], *tmp;
+
+    if (format == XkbCFile) {
+        if (behavior->type == XkbKB_Default)
+            snprintf(buf, sizeof(buf), "{   0,    0 }");
+        else
+            snprintf(buf, sizeof(buf), "{ %3d, 0x%02x }", behavior->type,
+                     behavior->data);
     }
     else {
-	unsigned 	type,permanent;
-	type= behavior->type&XkbKB_OpMask;
-	permanent=((behavior->type&XkbKB_Permanent)!=0);
-
-	if (type==XkbKB_Lock) {
-	    snprintf(buf,sizeof(buf),"lock= %s",(permanent?"Permanent":"TRUE"));
-	}
-	else if (type==XkbKB_RadioGroup) {
-	    int 	g;
-	    char	*tmp;
-	    g= ((behavior->data)&(~XkbKB_RGAllowNone))+1;
-	    if (XkbKB_RGAllowNone&behavior->data) {
-		snprintf(buf,sizeof(buf),"allowNone,");
-		tmp= &buf[strlen(buf)];
-	    }
-	    else tmp= buf;
-	    if (permanent)
-		 sprintf(tmp,"permanentRadioGroup= %d",g);
-	    else sprintf(tmp,"radioGroup= %d",g);
-	}
-	else if ((type==XkbKB_Overlay1)||(type==XkbKB_Overlay2)) {
-	    int ndx,kc;
-	    char *kn;
-
-	    ndx= ((type==XkbKB_Overlay1)?1:2);
-	    kc= behavior->data;
-	    if ((xkb)&&(xkb->names)&&(xkb->names->keys))
-		kn= XkbKeyNameText(xkb->names->keys[kc].name,XkbXKBFile);
-	    else {
-		static char tbuf[8];
-		snprintf(tbuf,sizeof(tbuf),"%d",kc);
-		kn= tbuf;
-	    }
-	    if (permanent)
-		 snprintf(buf,sizeof(buf),"permanentOverlay%d= %s",ndx,kn);
-	    else snprintf(buf,sizeof(buf),"overlay%d= %s",ndx,kn);
-	}
+        unsigned type, permanent;
+
+        type = behavior->type & XkbKB_OpMask;
+        permanent = ((behavior->type & XkbKB_Permanent) != 0);
+
+        if (type == XkbKB_Lock) {
+            snprintf(buf, sizeof(buf), "lock= %s",
+                     (permanent ? "Permanent" : "TRUE"));
+        }
+        else if (type == XkbKB_RadioGroup) {
+            int g;
+            char *tmp;
+
+            g = ((behavior->data) & (~XkbKB_RGAllowNone)) + 1;
+            if (XkbKB_RGAllowNone & behavior->data) {
+                snprintf(buf, sizeof(buf), "allowNone,");
+                tmp = &buf[strlen(buf)];
+            }
+            else
+                tmp = buf;
+            if (permanent)
+                sprintf(tmp, "permanentRadioGroup= %d", g);
+            else
+                sprintf(tmp, "radioGroup= %d", g);
+        }
+        else if ((type == XkbKB_Overlay1) || (type == XkbKB_Overlay2)) {
+            int ndx, kc;
+            char *kn;
+
+            ndx = ((type == XkbKB_Overlay1) ? 1 : 2);
+            kc = behavior->data;
+            if ((xkb) && (xkb->names) && (xkb->names->keys))
+                kn = XkbKeyNameText(xkb->names->keys[kc].name, XkbXKBFile);
+            else {
+                static char tbuf[8];
+
+                snprintf(tbuf, sizeof(tbuf), "%d", kc);
+                kn = tbuf;
+            }
+            if (permanent)
+                snprintf(buf, sizeof(buf), "permanentOverlay%d= %s", ndx, kn);
+            else
+                snprintf(buf, sizeof(buf), "overlay%d= %s", ndx, kn);
+        }
     }
-    tmp= tbGetBuffer(strlen(buf)+1);
-    if (tmp!=NULL)
-	strcpy(tmp,buf);
+    tmp = tbGetBuffer(strlen(buf) + 1);
+    if (tmp != NULL)
+        strcpy(tmp, buf);
     return tmp;
 }
 
@@ -1214,15 +1311,15 @@ char	buf[256],*tmp;
 char *
 XkbIndentText(unsigned size)
 {
-static char buf[32];
-register int i;
+    static char buf[32];
+    register int i;
 
-    if (size>31)
-	size= 31;
+    if (size > 31)
+        size = 31;
 
-    for (i=0;i<size;i++) {
-	buf[i]= ' ';
+    for (i = 0; i < size; i++) {
+        buf[i] = ' ';
     }
-    buf[size]= '\0';
+    buf[size] = '\0';
     return buf;
 }
diff --git a/xorg-server/xkb/xkmread.c b/xorg-server/xkb/xkmread.c
index a5c1ecfff..45da965dc 100644
--- a/xorg-server/xkb/xkmread.c
+++ b/xorg-server/xkb/xkmread.c
@@ -44,34 +44,36 @@
 #include "xkbgeom.h"
 
 Atom
-XkbInternAtom(char *str,Bool only_if_exists)
+XkbInternAtom(char *str, Bool only_if_exists)
 {
-    if (str==NULL)
-	return None;
-    return MakeAtom(str,strlen(str),!only_if_exists);
+    if (str == NULL)
+        return None;
+    return MakeAtom(str, strlen(str), !only_if_exists);
 }
 
 /***====================================================================***/
 
 static void *
-XkmInsureSize(void *oldPtr,int oldCount,int *newCountRtrn,int elemSize)
+XkmInsureSize(void *oldPtr, int oldCount, int *newCountRtrn, int elemSize)
 {
-int	newCount= *newCountRtrn;
+    int newCount = *newCountRtrn;
 
-    if (oldPtr==NULL) {
-	if (newCount==0)
-	    return NULL;
-	oldPtr= calloc(newCount,elemSize);
+    if (oldPtr == NULL) {
+        if (newCount == 0)
+            return NULL;
+        oldPtr = calloc(newCount, elemSize);
     }
-    else if (oldCount<newCount) {
-	oldPtr= realloc(oldPtr,newCount*elemSize);
-	if (oldPtr!=NULL) {
-	    char *tmp= (char *)oldPtr;
-	    memset(&tmp[oldCount*elemSize], 0, (newCount-oldCount)*elemSize);
-	}
+    else if (oldCount < newCount) {
+        oldPtr = realloc(oldPtr, newCount * elemSize);
+        if (oldPtr != NULL) {
+            char *tmp = (char *) oldPtr;
+
+            memset(&tmp[oldCount * elemSize], 0,
+                   (newCount - oldCount) * elemSize);
+        }
     }
-    else if (newCount<oldCount) {
-	*newCountRtrn= oldCount;
+    else if (newCount < oldCount) {
+        *newCountRtrn = oldCount;
     }
     return oldPtr;
 }
@@ -79,114 +81,120 @@ int	newCount= *newCountRtrn;
 #define	XkmInsureTypedSize(p,o,n,t) ((p)=((t *)XkmInsureSize((char *)(p),(o),(n),sizeof(t))))
 
 static CARD8
-XkmGetCARD8(FILE *file,int *pNRead)
+XkmGetCARD8(FILE * file, int *pNRead)
 {
-int	tmp;
-    tmp= getc(file);
-    if (pNRead&&(tmp!=EOF))
-	(*pNRead)+= 1;
+    int tmp;
+
+    tmp = getc(file);
+    if (pNRead && (tmp != EOF))
+        (*pNRead) += 1;
     return tmp;
 }
 
 static CARD16
-XkmGetCARD16(FILE *file,int *pNRead)
+XkmGetCARD16(FILE * file, int *pNRead)
 {
-CARD16		val;
+    CARD16 val;
 
-    if ((fread(&val,2,1,file)==1)&&(pNRead))
-	(*pNRead)+= 2;
+    if ((fread(&val, 2, 1, file) == 1) && (pNRead))
+        (*pNRead) += 2;
     return val;
 }
 
 static CARD32
-XkmGetCARD32(FILE *file,int *pNRead)
+XkmGetCARD32(FILE * file, int *pNRead)
 {
-CARD32	val;
+    CARD32 val;
 
-    if ((fread(&val,4,1,file)==1)&&(pNRead))
-	(*pNRead)+= 4;
+    if ((fread(&val, 4, 1, file) == 1) && (pNRead))
+        (*pNRead) += 4;
     return val;
 }
 
 static int
-XkmSkipPadding(FILE *file,unsigned pad)
+XkmSkipPadding(FILE * file, unsigned pad)
 {
-register int	i,nRead=0;
+    register int i, nRead = 0;
 
-    for (i=0;i<pad;i++) {
-	if (getc(file)!=EOF)
-	    nRead++;
+    for (i = 0; i < pad; i++) {
+        if (getc(file) != EOF)
+            nRead++;
     }
     return nRead;
 }
 
 static int
-XkmGetCountedString(FILE *file,char *str,int max_len)
+XkmGetCountedString(FILE * file, char *str, int max_len)
 {
-int	count,nRead=0;
-
-    count= XkmGetCARD16(file,&nRead);
-    if (count>0) {
-	int tmp;
-	if (count>max_len) {
-	    tmp= fread(str,1,max_len,file);
-	    while (tmp<count) {
-		if ((getc(file))!=EOF)
-		     tmp++;
-		else break;
-	    }
-	}
-	else {
-	    tmp= fread(str,1,count,file);
-	}
-	nRead+= tmp;
+    int count, nRead = 0;
+
+    count = XkmGetCARD16(file, &nRead);
+    if (count > 0) {
+        int tmp;
+
+        if (count > max_len) {
+            tmp = fread(str, 1, max_len, file);
+            while (tmp < count) {
+                if ((getc(file)) != EOF)
+                    tmp++;
+                else
+                    break;
+            }
+        }
+        else {
+            tmp = fread(str, 1, count, file);
+        }
+        nRead += tmp;
     }
-    if (count>=max_len)	str[max_len-1]= '\0';
-    else		str[count]= '\0';
-    count= XkbPaddedSize(nRead)-nRead;
-    if (count>0)
-	nRead+= XkmSkipPadding(file,count);
+    if (count >= max_len)
+        str[max_len - 1] = '\0';
+    else
+        str[count] = '\0';
+    count = XkbPaddedSize(nRead) - nRead;
+    if (count > 0)
+        nRead += XkmSkipPadding(file, count);
     return nRead;
 }
 
 /***====================================================================***/
 
 static int
-ReadXkmVirtualMods(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmVirtualMods(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
 {
-register unsigned int i,bit;
-unsigned int	bound,named,tmp;
-int		nRead=0;
+    register unsigned int i, bit;
+    unsigned int bound, named, tmp;
+    int nRead = 0;
 
-    if (XkbAllocServerMap(xkb,XkbVirtualModsMask,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0);
-	return -1;
+    if (XkbAllocServerMap(xkb, XkbVirtualModsMask, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmVirtualMods", 0);
+        return -1;
     }
-    bound= XkmGetCARD16(file,&nRead);
-    named= XkmGetCARD16(file,&nRead);
-    for (i=tmp=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (bound&bit) {
-	    xkb->server->vmods[i]= XkmGetCARD8(file,&nRead);
-	    if (changes)
-		changes->map.vmods|= bit;
-	    tmp++;
-	}
+    bound = XkmGetCARD16(file, &nRead);
+    named = XkmGetCARD16(file, &nRead);
+    for (i = tmp = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        if (bound & bit) {
+            xkb->server->vmods[i] = XkmGetCARD8(file, &nRead);
+            if (changes)
+                changes->map.vmods |= bit;
+            tmp++;
+        }
     }
-    if ((i= XkbPaddedSize(tmp)-tmp)>0)
-	nRead+= XkmSkipPadding(file,i);
-    if (XkbAllocNames(xkb,XkbVirtualModNamesMask,0,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmVirtualMods",0);
-	return -1;
+    if ((i = XkbPaddedSize(tmp) - tmp) > 0)
+        nRead += XkmSkipPadding(file, i);
+    if (XkbAllocNames(xkb, XkbVirtualModNamesMask, 0, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmVirtualMods", 0);
+        return -1;
     }
-    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	char name[100];
-	if (named&bit) {
-	    if (nRead+=XkmGetCountedString(file,name,100)) {
-		xkb->names->vmods[i]= XkbInternAtom(name,FALSE);
-		if (changes)
-		    changes->names.changed_vmods|= bit;
-	    }
-	}
+    for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+        char name[100];
+
+        if (named & bit) {
+            if (nRead += XkmGetCountedString(file, name, 100)) {
+                xkb->names->vmods[i] = XkbInternAtom(name, FALSE);
+                if (changes)
+                    changes->names.changed_vmods |= bit;
+            }
+        }
     }
     return nRead;
 }
@@ -194,200 +202,208 @@ int		nRead=0;
 /***====================================================================***/
 
 static int
-ReadXkmKeycodes(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmKeycodes(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
 {
-register int	i;
-unsigned	minKC,maxKC,nAl;
-int		nRead=0;
-char 		name[100];
-XkbKeyNamePtr	pN;
-
-    name[0]= '\0';
-    nRead+= XkmGetCountedString(file,name,100);
-    minKC= XkmGetCARD8(file,&nRead);
-    maxKC= XkmGetCARD8(file,&nRead);
-    if (xkb->min_key_code==0) {
-	xkb->min_key_code= minKC;
-	xkb->max_key_code= maxKC;
+    register int i;
+    unsigned minKC, maxKC, nAl;
+    int nRead = 0;
+    char name[100];
+    XkbKeyNamePtr pN;
+
+    name[0] = '\0';
+    nRead += XkmGetCountedString(file, name, 100);
+    minKC = XkmGetCARD8(file, &nRead);
+    maxKC = XkmGetCARD8(file, &nRead);
+    if (xkb->min_key_code == 0) {
+        xkb->min_key_code = minKC;
+        xkb->max_key_code = maxKC;
     }
     else {
-	if (minKC<xkb->min_key_code)
-	    xkb->min_key_code= minKC;
-	if (maxKC>xkb->max_key_code) {
-	    _XkbLibError(_XkbErrBadValue,"ReadXkmKeycodes",maxKC);
-	    return -1;
-	}
+        if (minKC < xkb->min_key_code)
+            xkb->min_key_code = minKC;
+        if (maxKC > xkb->max_key_code) {
+            _XkbLibError(_XkbErrBadValue, "ReadXkmKeycodes", maxKC);
+            return -1;
+        }
     }
-    nAl= XkmGetCARD8(file,&nRead);
-    nRead+= XkmSkipPadding(file,1);
+    nAl = XkmGetCARD8(file, &nRead);
+    nRead += XkmSkipPadding(file, 1);
 
 #define WANTED (XkbKeycodesNameMask|XkbKeyNamesMask|XkbKeyAliasesMask)
-    if (XkbAllocNames(xkb,WANTED,0,nAl)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmKeycodes",0);
-	return -1;
+    if (XkbAllocNames(xkb, WANTED, 0, nAl) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
+        return -1;
     }
-    if (name[0]!='\0') {
-	xkb->names->keycodes= XkbInternAtom(name,FALSE);
+    if (name[0] != '\0') {
+        xkb->names->keycodes = XkbInternAtom(name, FALSE);
     }
 
-    for (pN=&xkb->names->keys[minKC],i=minKC;i<=(int)maxKC;i++,pN++) {
-	if (fread(pN,1,XkbKeyNameLength,file)!=XkbKeyNameLength) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
-	    return -1;
-	}
-	nRead+= XkbKeyNameLength;
+    for (pN = &xkb->names->keys[minKC], i = minKC; i <= (int) maxKC; i++, pN++) {
+        if (fread(pN, 1, XkbKeyNameLength, file) != XkbKeyNameLength) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+            return -1;
+        }
+        nRead += XkbKeyNameLength;
     }
-    if (nAl>0) {
-	XkbKeyAliasPtr	pAl;
-	for (pAl= xkb->names->key_aliases,i=0;i<nAl;i++,pAl++) {
-	    int tmp;
-	    tmp= fread(pAl,1,2*XkbKeyNameLength,file);
-	    if (tmp!=2*XkbKeyNameLength) {
-		_XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
-		return -1;
-	    }
-	    nRead+= 2*XkbKeyNameLength;
-	}
-	if (changes)
-	    changes->names.changed|= XkbKeyAliasesMask;
+    if (nAl > 0) {
+        XkbKeyAliasPtr pAl;
+
+        for (pAl = xkb->names->key_aliases, i = 0; i < nAl; i++, pAl++) {
+            int tmp;
+
+            tmp = fread(pAl, 1, 2 * XkbKeyNameLength, file);
+            if (tmp != 2 * XkbKeyNameLength) {
+                _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+                return -1;
+            }
+            nRead += 2 * XkbKeyNameLength;
+        }
+        if (changes)
+            changes->names.changed |= XkbKeyAliasesMask;
     }
     if (changes)
-	changes->names.changed|= XkbKeyNamesMask;
+        changes->names.changed |= XkbKeyNamesMask;
     return nRead;
 }
 
 /***====================================================================***/
 
 static int
-ReadXkmKeyTypes(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmKeyTypes(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
 {
-register unsigned	i,n;
-unsigned		num_types;
-int			nRead=0;
-int			tmp;
-XkbKeyTypePtr		type;
-xkmKeyTypeDesc		wire;
-XkbKTMapEntryPtr	entry;
-xkmKTMapEntryDesc	wire_entry;
-char 			buf[100];
-
-    if ((tmp= XkmGetCountedString(file,buf,100))<1) {
-	_XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
-	return -1;
-    }	
-    nRead+= tmp;
-    if (buf[0]!='\0') {
-	if (XkbAllocNames(xkb,XkbTypesNameMask,0,0)!=Success) {
-	    _XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0);
-	    return -1;
+    register unsigned i, n;
+    unsigned num_types;
+    int nRead = 0;
+    int tmp;
+    XkbKeyTypePtr type;
+    xkmKeyTypeDesc wire;
+    XkbKTMapEntryPtr entry;
+    xkmKTMapEntryDesc wire_entry;
+    char buf[100];
+
+    if ((tmp = XkmGetCountedString(file, buf, 100)) < 1) {
+        _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+        return -1;
+    }
+    nRead += tmp;
+    if (buf[0] != '\0') {
+        if (XkbAllocNames(xkb, XkbTypesNameMask, 0, 0) != Success) {
+            _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeyTypes", 0);
+            return -1;
         }
-	xkb->names->types= XkbInternAtom(buf,FALSE);
+        xkb->names->types = XkbInternAtom(buf, FALSE);
     }
-    num_types= XkmGetCARD16(file,&nRead);
-    nRead+= XkmSkipPadding(file,2);
-    if (num_types<1)
-	return nRead;
-    if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_types)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmKeyTypes",0);
-	return nRead;
+    num_types = XkmGetCARD16(file, &nRead);
+    nRead += XkmSkipPadding(file, 2);
+    if (num_types < 1)
+        return nRead;
+    if (XkbAllocClientMap(xkb, XkbKeyTypesMask, num_types) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeyTypes", 0);
+        return nRead;
     }
-    xkb->map->num_types= num_types;
-    if (num_types<XkbNumRequiredTypes) {
-	_XkbLibError(_XkbErrMissingReqTypes,"ReadXkmKeyTypes",0);
-	return -1;
+    xkb->map->num_types = num_types;
+    if (num_types < XkbNumRequiredTypes) {
+        _XkbLibError(_XkbErrMissingReqTypes, "ReadXkmKeyTypes", 0);
+        return -1;
     }
-    type= xkb->map->types;
-    for (i=0;i<num_types;i++,type++) {
-	if ((int)fread(&wire,SIZEOF(xkmKeyTypeDesc),1,file)<1) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
-	    return -1;
-	}
-	nRead+= SIZEOF(xkmKeyTypeDesc);
-	if (((i==XkbOneLevelIndex)&&(wire.numLevels!=1))||
-	    (((i==XkbTwoLevelIndex)||(i==XkbAlphabeticIndex)||
-	     ((i)==XkbKeypadIndex))&&(wire.numLevels!=2))) {
-	    _XkbLibError(_XkbErrBadTypeWidth,"ReadXkmKeyTypes",i);
-	    return -1;
-	}
-	tmp= wire.nMapEntries;
-	XkmInsureTypedSize(type->map,type->map_count,&tmp,XkbKTMapEntryRec);
-	if ((wire.nMapEntries>0)&&(type->map==NULL)) {
-	    _XkbLibError(_XkbErrBadValue,"ReadXkmKeyTypes",wire.nMapEntries);
-	    return -1;
-	}
-	for (n=0,entry= type->map;n<wire.nMapEntries;n++,entry++) {
-	    if (fread(&wire_entry,SIZEOF(xkmKTMapEntryDesc),1,file)<(int)1) {
-		_XkbLibError(_XkbErrBadLength,"ReadXkmKeyTypes",0);
-		return -1;
-	    }
-	    nRead+= SIZEOF(xkmKTMapEntryDesc);
-	    entry->active= (wire_entry.virtualMods==0);
-	    entry->level= wire_entry.level;
-	    entry->mods.mask= wire_entry.realMods;
-	    entry->mods.real_mods= wire_entry.realMods;
-	    entry->mods.vmods= wire_entry.virtualMods;
-	}
-	nRead+= XkmGetCountedString(file,buf,100);
-	if (((i==XkbOneLevelIndex)&&(strcmp(buf,"ONE_LEVEL")!=0))||
-	    ((i==XkbTwoLevelIndex)&&(strcmp(buf,"TWO_LEVEL")!=0))||
-	    ((i==XkbAlphabeticIndex)&&(strcmp(buf,"ALPHABETIC")!=0))||
-	    ((i==XkbKeypadIndex)&&(strcmp(buf,"KEYPAD")!=0))) {
-	   _XkbLibError(_XkbErrBadTypeName,"ReadXkmKeyTypes",0);
-	   return -1;
-	}
-	if (buf[0]!='\0') {
-	     type->name= XkbInternAtom(buf,FALSE);
-	}
-	else type->name= None;
-
-	if (wire.preserve) {
-	    xkmModsDesc	p_entry;
-	    XkbModsPtr	pre;
-	    XkmInsureTypedSize(type->preserve,type->map_count,&tmp,
-						XkbModsRec);
-	    if (type->preserve==NULL) {
-		_XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0);
-		return -1;
-	    }
-	    for (n=0,pre=type->preserve;n<wire.nMapEntries;n++,pre++) {
-		if (fread(&p_entry,SIZEOF(xkmModsDesc),1,file)<1) {
-		    _XkbLibError(_XkbErrBadLength,"ReadXkmKeycodes",0);
-		    return -1;
-		}
-		nRead+= SIZEOF(xkmModsDesc);
-		pre->mask= p_entry.realMods;
-		pre->real_mods= p_entry.realMods;
-		pre->vmods= p_entry.virtualMods;
-	    }
-	}
-	if (wire.nLevelNames>0) {
-	    int width= wire.numLevels;
-	    if (wire.nLevelNames>(unsigned)width) {
-		_XkbLibError(_XkbErrBadMatch,"ReadXkmKeycodes",0);
-		return -1;
-	    }
-	    XkmInsureTypedSize(type->level_names,type->num_levels,&width,Atom);
-	    if (type->level_names!=NULL) {
-		for (n=0;n<wire.nLevelNames;n++) {
-		    if ((tmp=XkmGetCountedString(file,buf,100))<1)
-			return -1;
-		    nRead+= tmp;
-		    if (strlen(buf)==0)
-			 type->level_names[n]= None;
-		    else type->level_names[n]= XkbInternAtom(buf,0);
-		}
-	    }
-	}
-	type->mods.mask= wire.realMods;
-	type->mods.real_mods= wire.realMods;
-	type->mods.vmods= wire.virtualMods;
-	type->num_levels= wire.numLevels;
-	type->map_count= wire.nMapEntries;
+    type = xkb->map->types;
+    for (i = 0; i < num_types; i++, type++) {
+        if ((int) fread(&wire, SIZEOF(xkmKeyTypeDesc), 1, file) < 1) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+            return -1;
+        }
+        nRead += SIZEOF(xkmKeyTypeDesc);
+        if (((i == XkbOneLevelIndex) && (wire.numLevels != 1)) ||
+            (((i == XkbTwoLevelIndex) || (i == XkbAlphabeticIndex) ||
+              ((i) == XkbKeypadIndex)) && (wire.numLevels != 2))) {
+            _XkbLibError(_XkbErrBadTypeWidth, "ReadXkmKeyTypes", i);
+            return -1;
+        }
+        tmp = wire.nMapEntries;
+        XkmInsureTypedSize(type->map, type->map_count, &tmp, XkbKTMapEntryRec);
+        if ((wire.nMapEntries > 0) && (type->map == NULL)) {
+            _XkbLibError(_XkbErrBadValue, "ReadXkmKeyTypes", wire.nMapEntries);
+            return -1;
+        }
+        for (n = 0, entry = type->map; n < wire.nMapEntries; n++, entry++) {
+            if (fread(&wire_entry, SIZEOF(xkmKTMapEntryDesc), 1, file) <
+                (int) 1) {
+                _XkbLibError(_XkbErrBadLength, "ReadXkmKeyTypes", 0);
+                return -1;
+            }
+            nRead += SIZEOF(xkmKTMapEntryDesc);
+            entry->active = (wire_entry.virtualMods == 0);
+            entry->level = wire_entry.level;
+            entry->mods.mask = wire_entry.realMods;
+            entry->mods.real_mods = wire_entry.realMods;
+            entry->mods.vmods = wire_entry.virtualMods;
+        }
+        nRead += XkmGetCountedString(file, buf, 100);
+        if (((i == XkbOneLevelIndex) && (strcmp(buf, "ONE_LEVEL") != 0)) ||
+            ((i == XkbTwoLevelIndex) && (strcmp(buf, "TWO_LEVEL") != 0)) ||
+            ((i == XkbAlphabeticIndex) && (strcmp(buf, "ALPHABETIC") != 0)) ||
+            ((i == XkbKeypadIndex) && (strcmp(buf, "KEYPAD") != 0))) {
+            _XkbLibError(_XkbErrBadTypeName, "ReadXkmKeyTypes", 0);
+            return -1;
+        }
+        if (buf[0] != '\0') {
+            type->name = XkbInternAtom(buf, FALSE);
+        }
+        else
+            type->name = None;
+
+        if (wire.preserve) {
+            xkmModsDesc p_entry;
+            XkbModsPtr pre;
+
+            XkmInsureTypedSize(type->preserve, type->map_count, &tmp,
+                               XkbModsRec);
+            if (type->preserve == NULL) {
+                _XkbLibError(_XkbErrBadMatch, "ReadXkmKeycodes", 0);
+                return -1;
+            }
+            for (n = 0, pre = type->preserve; n < wire.nMapEntries; n++, pre++) {
+                if (fread(&p_entry, SIZEOF(xkmModsDesc), 1, file) < 1) {
+                    _XkbLibError(_XkbErrBadLength, "ReadXkmKeycodes", 0);
+                    return -1;
+                }
+                nRead += SIZEOF(xkmModsDesc);
+                pre->mask = p_entry.realMods;
+                pre->real_mods = p_entry.realMods;
+                pre->vmods = p_entry.virtualMods;
+            }
+        }
+        if (wire.nLevelNames > 0) {
+            int width = wire.numLevels;
+
+            if (wire.nLevelNames > (unsigned) width) {
+                _XkbLibError(_XkbErrBadMatch, "ReadXkmKeycodes", 0);
+                return -1;
+            }
+            XkmInsureTypedSize(type->level_names, type->num_levels, &width,
+                               Atom);
+            if (type->level_names != NULL) {
+                for (n = 0; n < wire.nLevelNames; n++) {
+                    if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+                        return -1;
+                    nRead += tmp;
+                    if (strlen(buf) == 0)
+                        type->level_names[n] = None;
+                    else
+                        type->level_names[n] = XkbInternAtom(buf, 0);
+                }
+            }
+        }
+        type->mods.mask = wire.realMods;
+        type->mods.real_mods = wire.realMods;
+        type->mods.vmods = wire.virtualMods;
+        type->num_levels = wire.numLevels;
+        type->map_count = wire.nMapEntries;
     }
     if (changes) {
-	changes->map.changed|= XkbKeyTypesMask;
-	changes->map.first_type= 0;
-	changes->map.num_types= xkb->map->num_types;
+        changes->map.changed |= XkbKeyTypesMask;
+        changes->map.first_type = 0;
+        changes->map.num_types = xkb->map->num_types;
     }
     return nRead;
 }
@@ -395,47 +411,47 @@ char 			buf[100];
 /***====================================================================***/
 
 static int
-ReadXkmCompatMap(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmCompatMap(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
 {
-register int		i;
-unsigned		num_si,groups;
-char 			name[100];
-XkbSymInterpretPtr	interp;
-xkmSymInterpretDesc	wire;
-unsigned		tmp;
-int			nRead=0;
-XkbCompatMapPtr		compat;
-XkbAction               *act;
-
-    if ((tmp= XkmGetCountedString(file,name,100))<1) {
-	_XkbLibError(_XkbErrBadLength,"ReadXkmCompatMap",0);
-	return -1;
+    register int i;
+    unsigned num_si, groups;
+    char name[100];
+    XkbSymInterpretPtr interp;
+    xkmSymInterpretDesc wire;
+    unsigned tmp;
+    int nRead = 0;
+    XkbCompatMapPtr compat;
+    XkbAction *act;
+
+    if ((tmp = XkmGetCountedString(file, name, 100)) < 1) {
+        _XkbLibError(_XkbErrBadLength, "ReadXkmCompatMap", 0);
+        return -1;
     }
-    nRead+= tmp;
-    if (name[0]!='\0') {
-	if (XkbAllocNames(xkb,XkbCompatNameMask,0,0)!=Success) {
-	    _XkbLibError(_XkbErrBadAlloc,"ReadXkmCompatMap",0);
-	    return -1;
-	}
-	xkb->names->compat= XkbInternAtom(name,FALSE);
+    nRead += tmp;
+    if (name[0] != '\0') {
+        if (XkbAllocNames(xkb, XkbCompatNameMask, 0, 0) != Success) {
+            _XkbLibError(_XkbErrBadAlloc, "ReadXkmCompatMap", 0);
+            return -1;
+        }
+        xkb->names->compat = XkbInternAtom(name, FALSE);
     }
-    num_si= XkmGetCARD16(file,&nRead);
-    groups= XkmGetCARD8(file,&nRead);
-    nRead+= XkmSkipPadding(file,1);
-    if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_si)!=Success)
-	return -1;
-    compat= xkb->compat;
-    compat->num_si= 0;
-    interp= compat->sym_interpret;
-    for (i=0;i<num_si;i++) {
-	tmp= fread(&wire,SIZEOF(xkmSymInterpretDesc),1,file);
-	nRead+= tmp*SIZEOF(xkmSymInterpretDesc);
-	interp->sym= wire.sym;
-	interp->mods= wire.mods;
-	interp->match= wire.match;
-	interp->virtual_mod= wire.virtualMod;
-	interp->flags= wire.flags;
-	interp->act.type= wire.actionType;
+    num_si = XkmGetCARD16(file, &nRead);
+    groups = XkmGetCARD8(file, &nRead);
+    nRead += XkmSkipPadding(file, 1);
+    if (XkbAllocCompatMap(xkb, XkbAllCompatMask, num_si) != Success)
+        return -1;
+    compat = xkb->compat;
+    compat->num_si = 0;
+    interp = compat->sym_interpret;
+    for (i = 0; i < num_si; i++) {
+        tmp = fread(&wire, SIZEOF(xkmSymInterpretDesc), 1, file);
+        nRead += tmp * SIZEOF(xkmSymInterpretDesc);
+        interp->sym = wire.sym;
+        interp->mods = wire.mods;
+        interp->match = wire.match;
+        interp->virtual_mod = wire.virtualMod;
+        interp->flags = wire.flags;
+        interp->act.type = wire.actionType;
         act = (XkbAction *) &interp->act;
 
         switch (interp->act.type) {
@@ -545,7 +561,7 @@ XkbAction               *act;
             }
             /* copy the kind of action */
             memcpy(act->any.data, wire.actionData, XkbAnyActionDataSize);
-            break ;
+            break;
 
         case XkbSA_Terminate:
             /* no args, kinda (note: untrue for xfree86). */
@@ -557,624 +573,648 @@ XkbAction               *act;
         interp++;
         compat->num_si++;
     }
-    if ((num_si>0)&&(changes)) {
-	changes->compat.first_si= 0;
-	changes->compat.num_si= compat->num_si;
+    if ((num_si > 0) && (changes)) {
+        changes->compat.first_si = 0;
+        changes->compat.num_si = compat->num_si;
     }
     if (groups) {
-	register unsigned bit;
-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
-	    xkmModsDesc	md;
-	    if (groups&bit) {
-		tmp= fread(&md,SIZEOF(xkmModsDesc),1,file);
-		nRead+= tmp*SIZEOF(xkmModsDesc);
-		xkb->compat->groups[i].real_mods= md.realMods;
-		xkb->compat->groups[i].vmods= md.virtualMods;
-		if (md.virtualMods != 0) {
-		    unsigned mask;
-		    if (XkbVirtualModsToReal(xkb,md.virtualMods,&mask))
-			xkb->compat->groups[i].mask= md.realMods|mask;
-		}
-		else xkb->compat->groups[i].mask= md.realMods;
-	    }
-	}
-	if (changes)
-	    changes->compat.changed_groups|= groups;
+        register unsigned bit;
+
+        for (i = 0, bit = 1; i < XkbNumKbdGroups; i++, bit <<= 1) {
+            xkmModsDesc md;
+
+            if (groups & bit) {
+                tmp = fread(&md, SIZEOF(xkmModsDesc), 1, file);
+                nRead += tmp * SIZEOF(xkmModsDesc);
+                xkb->compat->groups[i].real_mods = md.realMods;
+                xkb->compat->groups[i].vmods = md.virtualMods;
+                if (md.virtualMods != 0) {
+                    unsigned mask;
+
+                    if (XkbVirtualModsToReal(xkb, md.virtualMods, &mask))
+                        xkb->compat->groups[i].mask = md.realMods | mask;
+                }
+                else
+                    xkb->compat->groups[i].mask = md.realMods;
+            }
+        }
+        if (changes)
+            changes->compat.changed_groups |= groups;
     }
     return nRead;
 }
 
 static int
-ReadXkmIndicators(FILE *file,XkbDescPtr xkb,XkbChangesPtr changes)
+ReadXkmIndicators(FILE * file, XkbDescPtr xkb, XkbChangesPtr changes)
 {
-register unsigned	nLEDs;
-xkmIndicatorMapDesc	wire;
-char			buf[100];
-unsigned		tmp;
-int			nRead=0;
-
-    if ((xkb->indicators==NULL)&&(XkbAllocIndicatorMaps(xkb)!=Success)) {
-	_XkbLibError(_XkbErrBadAlloc,"indicator rec",0);
-	return -1;
+    register unsigned nLEDs;
+    xkmIndicatorMapDesc wire;
+    char buf[100];
+    unsigned tmp;
+    int nRead = 0;
+
+    if ((xkb->indicators == NULL) && (XkbAllocIndicatorMaps(xkb) != Success)) {
+        _XkbLibError(_XkbErrBadAlloc, "indicator rec", 0);
+        return -1;
     }
-    if (XkbAllocNames(xkb,XkbIndicatorNamesMask,0,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"indicator names",0);
-	return -1;
+    if (XkbAllocNames(xkb, XkbIndicatorNamesMask, 0, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "indicator names", 0);
+        return -1;
     }
-    nLEDs= XkmGetCARD8(file,&nRead);
-    nRead+= XkmSkipPadding(file,3);
-    xkb->indicators->phys_indicators= XkmGetCARD32(file,&nRead);
-    while (nLEDs-->0) {
-	Atom 			name;
-	XkbIndicatorMapPtr	map;
-
-	if ((tmp=XkmGetCountedString(file,buf,100))<1) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0);
-	    return -1;
-	}
-	nRead+= tmp;
-	if (buf[0]!='\0')
-	     name= XkbInternAtom(buf,FALSE);
-	else name= None;
-	if ((tmp=fread(&wire,SIZEOF(xkmIndicatorMapDesc),1,file))<1) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmIndicators",0);
-	    return -1;
-	}
-	nRead+= tmp*SIZEOF(xkmIndicatorMapDesc);
-	if (xkb->names) {
-	    xkb->names->indicators[wire.indicator-1]= name;
-	    if (changes)
-		changes->names.changed_indicators|= (1<<(wire.indicator-1));
-	}
-	map= &xkb->indicators->maps[wire.indicator-1];
-	map->flags= wire.flags;
-	map->which_groups= wire.which_groups;
-	map->groups= wire.groups;
-	map->which_mods= wire.which_mods;
-	map->mods.mask= wire.real_mods;
-	map->mods.real_mods= wire.real_mods;
-	map->mods.vmods= wire.vmods;
-	map->ctrls= wire.ctrls;
+    nLEDs = XkmGetCARD8(file, &nRead);
+    nRead += XkmSkipPadding(file, 3);
+    xkb->indicators->phys_indicators = XkmGetCARD32(file, &nRead);
+    while (nLEDs-- > 0) {
+        Atom name;
+        XkbIndicatorMapPtr map;
+
+        if ((tmp = XkmGetCountedString(file, buf, 100)) < 1) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmIndicators", 0);
+            return -1;
+        }
+        nRead += tmp;
+        if (buf[0] != '\0')
+            name = XkbInternAtom(buf, FALSE);
+        else
+            name = None;
+        if ((tmp = fread(&wire, SIZEOF(xkmIndicatorMapDesc), 1, file)) < 1) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmIndicators", 0);
+            return -1;
+        }
+        nRead += tmp * SIZEOF(xkmIndicatorMapDesc);
+        if (xkb->names) {
+            xkb->names->indicators[wire.indicator - 1] = name;
+            if (changes)
+                changes->names.changed_indicators |=
+                    (1 << (wire.indicator - 1));
+        }
+        map = &xkb->indicators->maps[wire.indicator - 1];
+        map->flags = wire.flags;
+        map->which_groups = wire.which_groups;
+        map->groups = wire.groups;
+        map->which_mods = wire.which_mods;
+        map->mods.mask = wire.real_mods;
+        map->mods.real_mods = wire.real_mods;
+        map->mods.vmods = wire.vmods;
+        map->ctrls = wire.ctrls;
     }
     return nRead;
 }
 
 static XkbKeyTypePtr
-FindTypeForKey(XkbDescPtr xkb,Atom name,unsigned width,KeySym *syms)
+FindTypeForKey(XkbDescPtr xkb, Atom name, unsigned width, KeySym * syms)
 {
-    if ((!xkb)||(!xkb->map))
-	return NULL;
-    if (name!=None) {
-	register unsigned i;
-	for (i=0;i<xkb->map->num_types;i++) {
-	    if (xkb->map->types[i].name==name) {
-		if (xkb->map->types[i].num_levels!=width)
-		    DebugF("Group width mismatch between key and type\n");
-		return &xkb->map->types[i];
-	    }
-	}
+    if ((!xkb) || (!xkb->map))
+        return NULL;
+    if (name != None) {
+        register unsigned i;
+
+        for (i = 0; i < xkb->map->num_types; i++) {
+            if (xkb->map->types[i].name == name) {
+                if (xkb->map->types[i].num_levels != width)
+                    DebugF("Group width mismatch between key and type\n");
+                return &xkb->map->types[i];
+            }
+        }
     }
-    if ((width<2)||((syms!=NULL)&&(syms[1]==NoSymbol)))
-	return &xkb->map->types[XkbOneLevelIndex];
-    if (syms!=NULL) {
-	if (XkbKSIsLower(syms[0])&&XkbKSIsUpper(syms[1]))
-	    return &xkb->map->types[XkbAlphabeticIndex];
-	else if (XkbKSIsKeypad(syms[0])||XkbKSIsKeypad(syms[1]))
-	    return &xkb->map->types[XkbKeypadIndex];
+    if ((width < 2) || ((syms != NULL) && (syms[1] == NoSymbol)))
+        return &xkb->map->types[XkbOneLevelIndex];
+    if (syms != NULL) {
+        if (XkbKSIsLower(syms[0]) && XkbKSIsUpper(syms[1]))
+            return &xkb->map->types[XkbAlphabeticIndex];
+        else if (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))
+            return &xkb->map->types[XkbKeypadIndex];
     }
     return &xkb->map->types[XkbTwoLevelIndex];
 }
 
 static int
-ReadXkmSymbols(FILE *file,XkbDescPtr xkb)
+ReadXkmSymbols(FILE * file, XkbDescPtr xkb)
 {
-register int		i,g,s,totalVModMaps;
-xkmKeySymMapDesc 	wireMap;
-char 			buf[100];
-unsigned		minKC,maxKC,groupNames,tmp;
-int			nRead=0;
-
-    if ((tmp=XkmGetCountedString(file,buf,100))<1)
-	return -1;
-    nRead+= tmp;
-    minKC= XkmGetCARD8(file,&nRead);
-    maxKC= XkmGetCARD8(file,&nRead);
-    groupNames= XkmGetCARD8(file,&nRead);
-    totalVModMaps= XkmGetCARD8(file,&nRead);
+    register int i, g, s, totalVModMaps;
+    xkmKeySymMapDesc wireMap;
+    char buf[100];
+    unsigned minKC, maxKC, groupNames, tmp;
+    int nRead = 0;
+
+    if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+        return -1;
+    nRead += tmp;
+    minKC = XkmGetCARD8(file, &nRead);
+    maxKC = XkmGetCARD8(file, &nRead);
+    groupNames = XkmGetCARD8(file, &nRead);
+    totalVModMaps = XkmGetCARD8(file, &nRead);
     if (XkbAllocNames(xkb,
-	      XkbSymbolsNameMask|XkbPhysSymbolsNameMask|XkbGroupNamesMask,
-	      0,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"physical names",0);
-	return -1;
+                      XkbSymbolsNameMask | XkbPhysSymbolsNameMask |
+                      XkbGroupNamesMask, 0, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "physical names", 0);
+        return -1;
     }
-    if ((buf[0]!='\0')&&(xkb->names)) {
-	Atom name;
-	name= XkbInternAtom(buf,0);
-	xkb->names->symbols= name;
-	xkb->names->phys_symbols= name;
+    if ((buf[0] != '\0') && (xkb->names)) {
+        Atom name;
+
+        name = XkbInternAtom(buf, 0);
+        xkb->names->symbols = name;
+        xkb->names->phys_symbols = name;
     }
-    for (i=0,g=1;i<XkbNumKbdGroups;i++,g<<=1) {
-	if (groupNames&g) {
-	    if ((tmp=XkmGetCountedString(file,buf,100))<1)
-		return -1;
-	    nRead+= tmp;
-
-	    if (!xkb->names)
-		    continue;
-
-	    if (buf[0]!='\0') {
-		Atom name;
-		name= XkbInternAtom(buf,0);
-		xkb->names->groups[i]= name;
-	    }	
-	    else xkb->names->groups[i]= None;
-	}
+    for (i = 0, g = 1; i < XkbNumKbdGroups; i++, g <<= 1) {
+        if (groupNames & g) {
+            if ((tmp = XkmGetCountedString(file, buf, 100)) < 1)
+                return -1;
+            nRead += tmp;
+
+            if (!xkb->names)
+                continue;
+
+            if (buf[0] != '\0') {
+                Atom name;
+
+                name = XkbInternAtom(buf, 0);
+                xkb->names->groups[i] = name;
+            }
+            else
+                xkb->names->groups[i] = None;
+        }
     }
-    if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"server map",0);
-	return -1;
+    if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "server map", 0);
+        return -1;
     }
-    if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"client map",0);
-	return -1;
+    if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "client map", 0);
+        return -1;
     }
-    if (XkbAllocControls(xkb,XkbAllControlsMask)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"controls",0);
-	return -1;
+    if (XkbAllocControls(xkb, XkbAllControlsMask) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "controls", 0);
+        return -1;
     }
-    if ((xkb->map==NULL)||(xkb->server==NULL))
-	return -1;
-    if (xkb->min_key_code<8)	xkb->min_key_code= minKC;
-    if (xkb->max_key_code<8)	xkb->max_key_code= maxKC;
-    if ((minKC>=8)&&(minKC<xkb->min_key_code))
-	xkb->min_key_code= minKC;
-    if ((maxKC>=8)&&(maxKC>xkb->max_key_code)) {
-	_XkbLibError(_XkbErrBadValue,"keys in symbol map",maxKC);
-	return -1;
+    if ((xkb->map == NULL) || (xkb->server == NULL))
+        return -1;
+    if (xkb->min_key_code < 8)
+        xkb->min_key_code = minKC;
+    if (xkb->max_key_code < 8)
+        xkb->max_key_code = maxKC;
+    if ((minKC >= 8) && (minKC < xkb->min_key_code))
+        xkb->min_key_code = minKC;
+    if ((maxKC >= 8) && (maxKC > xkb->max_key_code)) {
+        _XkbLibError(_XkbErrBadValue, "keys in symbol map", maxKC);
+        return -1;
     }
-    for (i=minKC;i<=(int)maxKC;i++)  {
-	Atom 		typeName[XkbNumKbdGroups];
-	XkbKeyTypePtr	type[XkbNumKbdGroups];
-	if ((tmp=fread(&wireMap,SIZEOF(xkmKeySymMapDesc),1,file))<1) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmSymbols",0);
-	    return -1;
-	}
-	nRead+= tmp*SIZEOF(xkmKeySymMapDesc);
-	memset((char *)typeName, 0, XkbNumKbdGroups*sizeof(Atom));
-	memset((char *)type, 0, XkbNumKbdGroups*sizeof(XkbKeyTypePtr));
-	if (wireMap.flags&XkmKeyHasTypes) {
-	    register int g;
-	    for (g=0;g<XkbNumKbdGroups;g++) {
-		if ((wireMap.flags&(1<<g))&&
-			((tmp=XkmGetCountedString(file,buf,100))>0)) {
-		    typeName[g]= XkbInternAtom(buf,1);
-		    nRead+= tmp;
-		}
-		type[g]=FindTypeForKey(xkb,typeName[g],wireMap.width,NULL);
-		if (type[g]==NULL) {
-		    _XkbLibError(_XkbErrMissingTypes,"ReadXkmSymbols",0);
-		    return -1;
-		}
-		if (typeName[g]==type[g]->name)
-		    xkb->server->explicit[i]|= (1<<g);
-	    }
-	}
-	if (wireMap.flags&XkmRepeatingKey) {
-	    xkb->ctrls->per_key_repeat[i/8]|= (1<<(i%8));
-	    xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask;
-	}
-	else if (wireMap.flags&XkmNonRepeatingKey) {
-	    xkb->ctrls->per_key_repeat[i/8]&= ~(1<<(i%8));
-	    xkb->server->explicit[i]|= XkbExplicitAutoRepeatMask;
-	}
-	xkb->map->modmap[i]= wireMap.modifier_map;
-	if (XkbNumGroups(wireMap.num_groups)>0) {
-	    KeySym	*sym;
-	    int		 nSyms;
-	
-	    if (XkbNumGroups(wireMap.num_groups)>xkb->ctrls->num_groups)
-		xkb->ctrls->num_groups= wireMap.num_groups;
-	    nSyms= XkbNumGroups(wireMap.num_groups)*wireMap.width;
-	    sym= XkbResizeKeySyms(xkb,i,nSyms);
-	    if (!sym)
-		return -1;
-	    for (s=0;s<nSyms;s++) {
-		*sym++= XkmGetCARD32(file,&nRead);
-	    }
-	    if (wireMap.flags&XkmKeyHasActions) {
-		XkbAction *	act;
-		act= XkbResizeKeyActions(xkb,i,nSyms);
-		for (s=0;s<nSyms;s++,act++) {
-		    tmp=fread(act,SIZEOF(xkmActionDesc),1,file);
-		    nRead+= tmp*SIZEOF(xkmActionDesc);
-		}
-		xkb->server->explicit[i]|= XkbExplicitInterpretMask;
-	    }
-	}
-	for (g=0;g<XkbNumGroups(wireMap.num_groups);g++) {
-	    if (((xkb->server->explicit[i]&(1<<g))==0)||(type[g]==NULL)) {
-		KeySym *tmpSyms;
-		tmpSyms= XkbKeySymsPtr(xkb,i)+(wireMap.width*g);
-		type[g]= FindTypeForKey(xkb,None,wireMap.width,tmpSyms);
-	    }
-	    xkb->map->key_sym_map[i].kt_index[g]= type[g]-(&xkb->map->types[0]);
-	}
-	xkb->map->key_sym_map[i].group_info= wireMap.num_groups;
-	xkb->map->key_sym_map[i].width= wireMap.width;
-	if (wireMap.flags&XkmKeyHasBehavior) {
-	    xkmBehaviorDesc	b;
-	    tmp= fread(&b,SIZEOF(xkmBehaviorDesc),1,file);
-	    nRead+= tmp*SIZEOF(xkmBehaviorDesc);
-	    xkb->server->behaviors[i].type= b.type;
-	    xkb->server->behaviors[i].data= b.data;
-	    xkb->server->explicit[i]|= XkbExplicitBehaviorMask;
-	}
+    for (i = minKC; i <= (int) maxKC; i++) {
+        Atom typeName[XkbNumKbdGroups];
+        XkbKeyTypePtr type[XkbNumKbdGroups];
+
+        if ((tmp = fread(&wireMap, SIZEOF(xkmKeySymMapDesc), 1, file)) < 1) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmSymbols", 0);
+            return -1;
+        }
+        nRead += tmp * SIZEOF(xkmKeySymMapDesc);
+        memset((char *) typeName, 0, XkbNumKbdGroups * sizeof(Atom));
+        memset((char *) type, 0, XkbNumKbdGroups * sizeof(XkbKeyTypePtr));
+        if (wireMap.flags & XkmKeyHasTypes) {
+            register int g;
+
+            for (g = 0; g < XkbNumKbdGroups; g++) {
+                if ((wireMap.flags & (1 << g)) &&
+                    ((tmp = XkmGetCountedString(file, buf, 100)) > 0)) {
+                    typeName[g] = XkbInternAtom(buf, 1);
+                    nRead += tmp;
+                }
+                type[g] = FindTypeForKey(xkb, typeName[g], wireMap.width, NULL);
+                if (type[g] == NULL) {
+                    _XkbLibError(_XkbErrMissingTypes, "ReadXkmSymbols", 0);
+                    return -1;
+                }
+                if (typeName[g] == type[g]->name)
+                    xkb->server->explicit[i] |= (1 << g);
+            }
+        }
+        if (wireMap.flags & XkmRepeatingKey) {
+            xkb->ctrls->per_key_repeat[i / 8] |= (1 << (i % 8));
+            xkb->server->explicit[i] |= XkbExplicitAutoRepeatMask;
+        }
+        else if (wireMap.flags & XkmNonRepeatingKey) {
+            xkb->ctrls->per_key_repeat[i / 8] &= ~(1 << (i % 8));
+            xkb->server->explicit[i] |= XkbExplicitAutoRepeatMask;
+        }
+        xkb->map->modmap[i] = wireMap.modifier_map;
+        if (XkbNumGroups(wireMap.num_groups) > 0) {
+            KeySym *sym;
+            int nSyms;
+
+            if (XkbNumGroups(wireMap.num_groups) > xkb->ctrls->num_groups)
+                xkb->ctrls->num_groups = wireMap.num_groups;
+            nSyms = XkbNumGroups(wireMap.num_groups) * wireMap.width;
+            sym = XkbResizeKeySyms(xkb, i, nSyms);
+            if (!sym)
+                return -1;
+            for (s = 0; s < nSyms; s++) {
+                *sym++ = XkmGetCARD32(file, &nRead);
+            }
+            if (wireMap.flags & XkmKeyHasActions) {
+                XkbAction *act;
+
+                act = XkbResizeKeyActions(xkb, i, nSyms);
+                for (s = 0; s < nSyms; s++, act++) {
+                    tmp = fread(act, SIZEOF(xkmActionDesc), 1, file);
+                    nRead += tmp * SIZEOF(xkmActionDesc);
+                }
+                xkb->server->explicit[i] |= XkbExplicitInterpretMask;
+            }
+        }
+        for (g = 0; g < XkbNumGroups(wireMap.num_groups); g++) {
+            if (((xkb->server->explicit[i] & (1 << g)) == 0) ||
+                (type[g] == NULL)) {
+                KeySym *tmpSyms;
+
+                tmpSyms = XkbKeySymsPtr(xkb, i) + (wireMap.width * g);
+                type[g] = FindTypeForKey(xkb, None, wireMap.width, tmpSyms);
+            }
+            xkb->map->key_sym_map[i].kt_index[g] =
+                type[g] - (&xkb->map->types[0]);
+        }
+        xkb->map->key_sym_map[i].group_info = wireMap.num_groups;
+        xkb->map->key_sym_map[i].width = wireMap.width;
+        if (wireMap.flags & XkmKeyHasBehavior) {
+            xkmBehaviorDesc b;
+
+            tmp = fread(&b, SIZEOF(xkmBehaviorDesc), 1, file);
+            nRead += tmp * SIZEOF(xkmBehaviorDesc);
+            xkb->server->behaviors[i].type = b.type;
+            xkb->server->behaviors[i].data = b.data;
+            xkb->server->explicit[i] |= XkbExplicitBehaviorMask;
+        }
     }
-    if (totalVModMaps>0) {
-	xkmVModMapDesc	v;
-	for (i=0;i<totalVModMaps;i++) {
-	    tmp= fread(&v,SIZEOF(xkmVModMapDesc),1,file);
-	    nRead+= tmp*SIZEOF(xkmVModMapDesc);
-	    if (tmp>0)
-		xkb->server->vmodmap[v.key]= v.vmods;
-	}
+    if (totalVModMaps > 0) {
+        xkmVModMapDesc v;
+
+        for (i = 0; i < totalVModMaps; i++) {
+            tmp = fread(&v, SIZEOF(xkmVModMapDesc), 1, file);
+            nRead += tmp * SIZEOF(xkmVModMapDesc);
+            if (tmp > 0)
+                xkb->server->vmodmap[v.key] = v.vmods;
+        }
     }
     return nRead;
 }
 
 static int
-ReadXkmGeomDoodad(
-    FILE *		file,
-    XkbGeometryPtr	geom,
-    XkbSectionPtr	section)
+ReadXkmGeomDoodad(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
 {
-XkbDoodadPtr	doodad;
-xkmDoodadDesc	doodadWire;
-char		buf[100];
-unsigned	tmp;
-int		nRead=0;
-
-    nRead+= XkmGetCountedString(file,buf,100);
-    tmp= fread(&doodadWire,SIZEOF(xkmDoodadDesc),1,file);
-    nRead+= SIZEOF(xkmDoodadDesc)*tmp;
-    doodad= XkbAddGeomDoodad(geom,section,XkbInternAtom(buf,FALSE));
+    XkbDoodadPtr doodad;
+    xkmDoodadDesc doodadWire;
+    char buf[100];
+    unsigned tmp;
+    int nRead = 0;
+
+    nRead += XkmGetCountedString(file, buf, 100);
+    tmp = fread(&doodadWire, SIZEOF(xkmDoodadDesc), 1, file);
+    nRead += SIZEOF(xkmDoodadDesc) * tmp;
+    doodad = XkbAddGeomDoodad(geom, section, XkbInternAtom(buf, FALSE));
     if (!doodad)
-	return nRead;
-    doodad->any.type= doodadWire.any.type;
-    doodad->any.priority= doodadWire.any.priority;
-    doodad->any.top= doodadWire.any.top;
-    doodad->any.left= doodadWire.any.left;
+        return nRead;
+    doodad->any.type = doodadWire.any.type;
+    doodad->any.priority = doodadWire.any.priority;
+    doodad->any.top = doodadWire.any.top;
+    doodad->any.left = doodadWire.any.left;
     switch (doodadWire.any.type) {
-	case XkbOutlineDoodad:
-	case XkbSolidDoodad:
-	    doodad->shape.angle= doodadWire.shape.angle;
-	    doodad->shape.color_ndx= doodadWire.shape.color_ndx;
-	    doodad->shape.shape_ndx= doodadWire.shape.shape_ndx;
-	    break;
-	case XkbTextDoodad:
-	    doodad->text.angle= doodadWire.text.angle;
-	    doodad->text.width= doodadWire.text.width;
-	    doodad->text.height= doodadWire.text.height;
-	    doodad->text.color_ndx= doodadWire.text.color_ndx;
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    doodad->text.text= Xstrdup(buf);
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    doodad->text.font= Xstrdup(buf);
-	    break;
-	case XkbIndicatorDoodad:
-	    doodad->indicator.shape_ndx= doodadWire.indicator.shape_ndx;
-	    doodad->indicator.on_color_ndx= doodadWire.indicator.on_color_ndx;
-	    doodad->indicator.off_color_ndx= doodadWire.indicator.off_color_ndx;
-	    break;
-	case XkbLogoDoodad:
-	    doodad->logo.angle= doodadWire.logo.angle;
-	    doodad->logo.color_ndx= doodadWire.logo.color_ndx;
-	    doodad->logo.shape_ndx= doodadWire.logo.shape_ndx;
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    doodad->logo.logo_name= Xstrdup(buf);
-	    break;
-	default:
-	    /* report error? */
-	    return nRead;
+    case XkbOutlineDoodad:
+    case XkbSolidDoodad:
+        doodad->shape.angle = doodadWire.shape.angle;
+        doodad->shape.color_ndx = doodadWire.shape.color_ndx;
+        doodad->shape.shape_ndx = doodadWire.shape.shape_ndx;
+        break;
+    case XkbTextDoodad:
+        doodad->text.angle = doodadWire.text.angle;
+        doodad->text.width = doodadWire.text.width;
+        doodad->text.height = doodadWire.text.height;
+        doodad->text.color_ndx = doodadWire.text.color_ndx;
+        nRead += XkmGetCountedString(file, buf, 100);
+        doodad->text.text = Xstrdup(buf);
+        nRead += XkmGetCountedString(file, buf, 100);
+        doodad->text.font = Xstrdup(buf);
+        break;
+    case XkbIndicatorDoodad:
+        doodad->indicator.shape_ndx = doodadWire.indicator.shape_ndx;
+        doodad->indicator.on_color_ndx = doodadWire.indicator.on_color_ndx;
+        doodad->indicator.off_color_ndx = doodadWire.indicator.off_color_ndx;
+        break;
+    case XkbLogoDoodad:
+        doodad->logo.angle = doodadWire.logo.angle;
+        doodad->logo.color_ndx = doodadWire.logo.color_ndx;
+        doodad->logo.shape_ndx = doodadWire.logo.shape_ndx;
+        nRead += XkmGetCountedString(file, buf, 100);
+        doodad->logo.logo_name = Xstrdup(buf);
+        break;
+    default:
+        /* report error? */
+        return nRead;
     }
     return nRead;
 }
 
 static int
-ReadXkmGeomOverlay(	FILE *		file,
-			XkbGeometryPtr	geom,
-			XkbSectionPtr	section)
+ReadXkmGeomOverlay(FILE * file, XkbGeometryPtr geom, XkbSectionPtr section)
 {
-char 			buf[100];
-unsigned		tmp;
-int			nRead=0;
-XkbOverlayPtr		ol;
-XkbOverlayRowPtr	row;
-xkmOverlayDesc 		olWire;
-xkmOverlayRowDesc	rowWire;
-register int		r;
-
-    nRead+= XkmGetCountedString(file,buf,100);
-    tmp= fread(&olWire,SIZEOF(xkmOverlayDesc),1,file);
-    nRead+= tmp*SIZEOF(xkmOverlayDesc);
-    ol= XkbAddGeomOverlay(section,XkbInternAtom(buf,FALSE),
-    							olWire.num_rows);
+    char buf[100];
+    unsigned tmp;
+    int nRead = 0;
+    XkbOverlayPtr ol;
+    XkbOverlayRowPtr row;
+    xkmOverlayDesc olWire;
+    xkmOverlayRowDesc rowWire;
+    register int r;
+
+    nRead += XkmGetCountedString(file, buf, 100);
+    tmp = fread(&olWire, SIZEOF(xkmOverlayDesc), 1, file);
+    nRead += tmp * SIZEOF(xkmOverlayDesc);
+    ol = XkbAddGeomOverlay(section, XkbInternAtom(buf, FALSE), olWire.num_rows);
     if (!ol)
-	return nRead;
-    for (r=0;r<olWire.num_rows;r++)  {
-    	int			k;
-	xkmOverlayKeyDesc	keyWire;
-	tmp= fread(&rowWire,SIZEOF(xkmOverlayRowDesc),1,file);
-	nRead+= tmp*SIZEOF(xkmOverlayRowDesc);
-	row= XkbAddGeomOverlayRow(ol,rowWire.row_under,rowWire.num_keys);
-	if (!row) {
-	    _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomOverlay",0);
-	   return nRead;
-	}
-	for (k=0;k<rowWire.num_keys;k++) {
-	    tmp= fread(&keyWire,SIZEOF(xkmOverlayKeyDesc),1,file);
-	    nRead+= tmp*SIZEOF(xkmOverlayKeyDesc);
-	    memcpy(row->keys[k].over.name,keyWire.over,XkbKeyNameLength);
-	    memcpy(row->keys[k].under.name,keyWire.under,XkbKeyNameLength);
-	}
-	row->num_keys= rowWire.num_keys;
+        return nRead;
+    for (r = 0; r < olWire.num_rows; r++) {
+        int k;
+        xkmOverlayKeyDesc keyWire;
+
+        tmp = fread(&rowWire, SIZEOF(xkmOverlayRowDesc), 1, file);
+        nRead += tmp * SIZEOF(xkmOverlayRowDesc);
+        row = XkbAddGeomOverlayRow(ol, rowWire.row_under, rowWire.num_keys);
+        if (!row) {
+            _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomOverlay", 0);
+            return nRead;
+        }
+        for (k = 0; k < rowWire.num_keys; k++) {
+            tmp = fread(&keyWire, SIZEOF(xkmOverlayKeyDesc), 1, file);
+            nRead += tmp * SIZEOF(xkmOverlayKeyDesc);
+            memcpy(row->keys[k].over.name, keyWire.over, XkbKeyNameLength);
+            memcpy(row->keys[k].under.name, keyWire.under, XkbKeyNameLength);
+        }
+        row->num_keys = rowWire.num_keys;
     }
     return nRead;
 }
 
 static int
-ReadXkmGeomSection(	FILE *		file,
-			XkbGeometryPtr	geom)
+ReadXkmGeomSection(FILE * file, XkbGeometryPtr geom)
 {
-register int	i;
-XkbSectionPtr	section;
-xkmSectionDesc	sectionWire;
-unsigned	tmp;
-int		nRead= 0;
-char		buf[100];
-Atom		nameAtom;
-
-    nRead+= XkmGetCountedString(file,buf,100);
-    nameAtom= XkbInternAtom(buf,FALSE);
-    tmp= fread(&sectionWire,SIZEOF(xkmSectionDesc),1,file);
-    nRead+= SIZEOF(xkmSectionDesc)*tmp;
-    section= XkbAddGeomSection(geom,nameAtom,sectionWire.num_rows,
-			 			sectionWire.num_doodads,
-			 			sectionWire.num_overlays);
+    register int i;
+    XkbSectionPtr section;
+    xkmSectionDesc sectionWire;
+    unsigned tmp;
+    int nRead = 0;
+    char buf[100];
+    Atom nameAtom;
+
+    nRead += XkmGetCountedString(file, buf, 100);
+    nameAtom = XkbInternAtom(buf, FALSE);
+    tmp = fread(&sectionWire, SIZEOF(xkmSectionDesc), 1, file);
+    nRead += SIZEOF(xkmSectionDesc) * tmp;
+    section = XkbAddGeomSection(geom, nameAtom, sectionWire.num_rows,
+                                sectionWire.num_doodads,
+                                sectionWire.num_overlays);
     if (!section) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomSection",0);
-	return nRead;
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
+        return nRead;
     }
-    section->top= sectionWire.top;
-    section->left= sectionWire.left;
-    section->width= sectionWire.width;
-    section->height= sectionWire.height;
-    section->angle= sectionWire.angle;
-    section->priority= sectionWire.priority;
-    if (sectionWire.num_rows>0) {
-	register int	k;
-	XkbRowPtr	row;
-	xkmRowDesc	rowWire;
-	XkbKeyPtr	key;
-	xkmKeyDesc	keyWire;
-
-	for (i=0;i<sectionWire.num_rows;i++) {
-	    tmp= fread(&rowWire,SIZEOF(xkmRowDesc),1,file);
-	    nRead+= SIZEOF(xkmRowDesc)*tmp;
-	    row= XkbAddGeomRow(section,rowWire.num_keys);
-	    if (!row) {
-		_XkbLibError(_XkbErrBadAlloc,"ReadXkmKeycodes",0);
-		return nRead;
-	    }
-	    row->top= rowWire.top;
-	    row->left= rowWire.left;
-	    row->vertical= rowWire.vertical;
-	    for (k=0;k<rowWire.num_keys;k++) {
-		tmp= fread(&keyWire,SIZEOF(xkmKeyDesc),1,file);
-		nRead+= SIZEOF(xkmKeyDesc)*tmp;
-		key= XkbAddGeomKey(row);
-		if (!key) {
-		    _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeomSection",0);
-		    return nRead;
-		}
-		memcpy(key->name.name,keyWire.name,XkbKeyNameLength);
-		key->gap= keyWire.gap;
-		key->shape_ndx= keyWire.shape_ndx;
-		key->color_ndx= keyWire.color_ndx;
-	    }
-	}
+    section->top = sectionWire.top;
+    section->left = sectionWire.left;
+    section->width = sectionWire.width;
+    section->height = sectionWire.height;
+    section->angle = sectionWire.angle;
+    section->priority = sectionWire.priority;
+    if (sectionWire.num_rows > 0) {
+        register int k;
+        XkbRowPtr row;
+        xkmRowDesc rowWire;
+        XkbKeyPtr key;
+        xkmKeyDesc keyWire;
+
+        for (i = 0; i < sectionWire.num_rows; i++) {
+            tmp = fread(&rowWire, SIZEOF(xkmRowDesc), 1, file);
+            nRead += SIZEOF(xkmRowDesc) * tmp;
+            row = XkbAddGeomRow(section, rowWire.num_keys);
+            if (!row) {
+                _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
+                return nRead;
+            }
+            row->top = rowWire.top;
+            row->left = rowWire.left;
+            row->vertical = rowWire.vertical;
+            for (k = 0; k < rowWire.num_keys; k++) {
+                tmp = fread(&keyWire, SIZEOF(xkmKeyDesc), 1, file);
+                nRead += SIZEOF(xkmKeyDesc) * tmp;
+                key = XkbAddGeomKey(row);
+                if (!key) {
+                    _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeomSection", 0);
+                    return nRead;
+                }
+                memcpy(key->name.name, keyWire.name, XkbKeyNameLength);
+                key->gap = keyWire.gap;
+                key->shape_ndx = keyWire.shape_ndx;
+                key->color_ndx = keyWire.color_ndx;
+            }
+        }
     }
-    if (sectionWire.num_doodads>0) {
-	for (i=0;i<sectionWire.num_doodads;i++) {
-	    tmp= ReadXkmGeomDoodad(file,geom,section);
-	    nRead+= tmp;
-	    if (tmp<1)
-		return nRead;
-	}
+    if (sectionWire.num_doodads > 0) {
+        for (i = 0; i < sectionWire.num_doodads; i++) {
+            tmp = ReadXkmGeomDoodad(file, geom, section);
+            nRead += tmp;
+            if (tmp < 1)
+                return nRead;
+        }
     }
-    if (sectionWire.num_overlays>0) {
-	for (i=0;i<sectionWire.num_overlays;i++) {
-	    tmp= ReadXkmGeomOverlay(file,geom,section);
-	    nRead+= tmp;
-	    if (tmp<1)
-		return nRead;
-	}
+    if (sectionWire.num_overlays > 0) {
+        for (i = 0; i < sectionWire.num_overlays; i++) {
+            tmp = ReadXkmGeomOverlay(file, geom, section);
+            nRead += tmp;
+            if (tmp < 1)
+                return nRead;
+        }
     }
     return nRead;
 }
 
 static int
-ReadXkmGeometry(FILE *file,XkbDescPtr xkb)
+ReadXkmGeometry(FILE * file, XkbDescPtr xkb)
 {
-register int		i;
-char 			buf[100];
-unsigned		tmp;
-int			nRead= 0;
-xkmGeometryDesc		wireGeom;
-XkbGeometryPtr		geom;
-XkbGeometrySizesRec	sizes;
-
-    nRead+= XkmGetCountedString(file,buf,100);
-    tmp= fread(&wireGeom,SIZEOF(xkmGeometryDesc),1,file);
-    nRead+= tmp*SIZEOF(xkmGeometryDesc);
-    sizes.which= XkbGeomAllMask;
-    sizes.num_properties= wireGeom.num_properties;
-    sizes.num_colors= wireGeom.num_colors;
-    sizes.num_shapes= wireGeom.num_shapes;
-    sizes.num_sections= wireGeom.num_sections;
-    sizes.num_doodads= wireGeom.num_doodads;
-    sizes.num_key_aliases= wireGeom.num_key_aliases;
-    if (XkbAllocGeometry(xkb,&sizes)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-	return nRead;
+    register int i;
+    char buf[100];
+    unsigned tmp;
+    int nRead = 0;
+    xkmGeometryDesc wireGeom;
+    XkbGeometryPtr geom;
+    XkbGeometrySizesRec sizes;
+
+    nRead += XkmGetCountedString(file, buf, 100);
+    tmp = fread(&wireGeom, SIZEOF(xkmGeometryDesc), 1, file);
+    nRead += tmp * SIZEOF(xkmGeometryDesc);
+    sizes.which = XkbGeomAllMask;
+    sizes.num_properties = wireGeom.num_properties;
+    sizes.num_colors = wireGeom.num_colors;
+    sizes.num_shapes = wireGeom.num_shapes;
+    sizes.num_sections = wireGeom.num_sections;
+    sizes.num_doodads = wireGeom.num_doodads;
+    sizes.num_key_aliases = wireGeom.num_key_aliases;
+    if (XkbAllocGeometry(xkb, &sizes) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+        return nRead;
     }
-    geom= xkb->geom;
-    geom->name= XkbInternAtom(buf,FALSE);
-    geom->width_mm= wireGeom.width_mm;
-    geom->height_mm= wireGeom.height_mm;
-    nRead+= XkmGetCountedString(file,buf,100);
-    geom->label_font= Xstrdup(buf);
-    if (wireGeom.num_properties>0) {
-	char val[1024];
-	for (i=0;i<wireGeom.num_properties;i++) {
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    nRead+= XkmGetCountedString(file,val,1024);
-	    if (XkbAddGeomProperty(geom,buf,val)==NULL) {
-		_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-		return nRead;
-	    }
-	}
+    geom = xkb->geom;
+    geom->name = XkbInternAtom(buf, FALSE);
+    geom->width_mm = wireGeom.width_mm;
+    geom->height_mm = wireGeom.height_mm;
+    nRead += XkmGetCountedString(file, buf, 100);
+    geom->label_font = Xstrdup(buf);
+    if (wireGeom.num_properties > 0) {
+        char val[1024];
+
+        for (i = 0; i < wireGeom.num_properties; i++) {
+            nRead += XkmGetCountedString(file, buf, 100);
+            nRead += XkmGetCountedString(file, val, 1024);
+            if (XkbAddGeomProperty(geom, buf, val) == NULL) {
+                _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+                return nRead;
+            }
+        }
     }
-    if (wireGeom.num_colors>0) {
-	for (i=0;i<wireGeom.num_colors;i++) {
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    if (XkbAddGeomColor(geom,buf,i)==NULL) {
-		_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-		return nRead;
-	    }
-	}
+    if (wireGeom.num_colors > 0) {
+        for (i = 0; i < wireGeom.num_colors; i++) {
+            nRead += XkmGetCountedString(file, buf, 100);
+            if (XkbAddGeomColor(geom, buf, i) == NULL) {
+                _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+                return nRead;
+            }
+        }
     }
-    geom->base_color= &geom->colors[wireGeom.base_color_ndx];
-    geom->label_color= &geom->colors[wireGeom.label_color_ndx];
-    if (wireGeom.num_shapes>0) {
-	XkbShapePtr	shape;
-	xkmShapeDesc	shapeWire;
-	Atom		nameAtom;
-	for (i=0;i<wireGeom.num_shapes;i++) {
-	    register int 	n;
-	    XkbOutlinePtr	ol;
-	    xkmOutlineDesc	olWire;
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    nameAtom= XkbInternAtom(buf,FALSE);
-	    tmp= fread(&shapeWire,SIZEOF(xkmShapeDesc),1,file);
-	    nRead+= tmp*SIZEOF(xkmShapeDesc);
-	    shape= XkbAddGeomShape(geom,nameAtom,shapeWire.num_outlines);
-	    if (!shape) {
-		_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-		return nRead;
-	    }
-	    for (n=0;n<shapeWire.num_outlines;n++) {
-		register int	p;
-		xkmPointDesc	ptWire;
-		tmp= fread(&olWire,SIZEOF(xkmOutlineDesc),1,file);
-		nRead+= tmp*SIZEOF(xkmOutlineDesc);
-		ol= XkbAddGeomOutline(shape,olWire.num_points);
-		if (!ol) {
-		    _XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-		    return nRead;
-		}
-		ol->num_points= olWire.num_points;
-		ol->corner_radius= olWire.corner_radius;
-		for (p=0;p<olWire.num_points;p++) {
-		    tmp= fread(&ptWire,SIZEOF(xkmPointDesc),1,file);
-		    nRead+= tmp*SIZEOF(xkmPointDesc);
-		    ol->points[p].x= ptWire.x;
-		    ol->points[p].y= ptWire.y;
-		    if (ptWire.x<shape->bounds.x1) shape->bounds.x1= ptWire.x;
-		    if (ptWire.x>shape->bounds.x2) shape->bounds.x2= ptWire.x;
-		    if (ptWire.y<shape->bounds.y1) shape->bounds.y1= ptWire.y;
-		    if (ptWire.y>shape->bounds.y2) shape->bounds.y2= ptWire.y;
-		}
-	    }
-	    if (shapeWire.primary_ndx!=XkbNoShape)
-		shape->primary= &shape->outlines[shapeWire.primary_ndx];
-	    if (shapeWire.approx_ndx!=XkbNoShape)
-		shape->approx= &shape->outlines[shapeWire.approx_ndx];
-	}
+    geom->base_color = &geom->colors[wireGeom.base_color_ndx];
+    geom->label_color = &geom->colors[wireGeom.label_color_ndx];
+    if (wireGeom.num_shapes > 0) {
+        XkbShapePtr shape;
+        xkmShapeDesc shapeWire;
+        Atom nameAtom;
+
+        for (i = 0; i < wireGeom.num_shapes; i++) {
+            register int n;
+            XkbOutlinePtr ol;
+            xkmOutlineDesc olWire;
+
+            nRead += XkmGetCountedString(file, buf, 100);
+            nameAtom = XkbInternAtom(buf, FALSE);
+            tmp = fread(&shapeWire, SIZEOF(xkmShapeDesc), 1, file);
+            nRead += tmp * SIZEOF(xkmShapeDesc);
+            shape = XkbAddGeomShape(geom, nameAtom, shapeWire.num_outlines);
+            if (!shape) {
+                _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+                return nRead;
+            }
+            for (n = 0; n < shapeWire.num_outlines; n++) {
+                register int p;
+                xkmPointDesc ptWire;
+
+                tmp = fread(&olWire, SIZEOF(xkmOutlineDesc), 1, file);
+                nRead += tmp * SIZEOF(xkmOutlineDesc);
+                ol = XkbAddGeomOutline(shape, olWire.num_points);
+                if (!ol) {
+                    _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+                    return nRead;
+                }
+                ol->num_points = olWire.num_points;
+                ol->corner_radius = olWire.corner_radius;
+                for (p = 0; p < olWire.num_points; p++) {
+                    tmp = fread(&ptWire, SIZEOF(xkmPointDesc), 1, file);
+                    nRead += tmp * SIZEOF(xkmPointDesc);
+                    ol->points[p].x = ptWire.x;
+                    ol->points[p].y = ptWire.y;
+                    if (ptWire.x < shape->bounds.x1)
+                        shape->bounds.x1 = ptWire.x;
+                    if (ptWire.x > shape->bounds.x2)
+                        shape->bounds.x2 = ptWire.x;
+                    if (ptWire.y < shape->bounds.y1)
+                        shape->bounds.y1 = ptWire.y;
+                    if (ptWire.y > shape->bounds.y2)
+                        shape->bounds.y2 = ptWire.y;
+                }
+            }
+            if (shapeWire.primary_ndx != XkbNoShape)
+                shape->primary = &shape->outlines[shapeWire.primary_ndx];
+            if (shapeWire.approx_ndx != XkbNoShape)
+                shape->approx = &shape->outlines[shapeWire.approx_ndx];
+        }
     }
-    if (wireGeom.num_sections>0) {
-	for (i=0;i<wireGeom.num_sections;i++) {
-	    tmp= ReadXkmGeomSection(file,geom);
-	    nRead+= tmp;
-	    if (tmp==0)
-		return nRead;
-	}
+    if (wireGeom.num_sections > 0) {
+        for (i = 0; i < wireGeom.num_sections; i++) {
+            tmp = ReadXkmGeomSection(file, geom);
+            nRead += tmp;
+            if (tmp == 0)
+                return nRead;
+        }
     }
-    if (wireGeom.num_doodads>0) {
-	for (i=0;i<wireGeom.num_doodads;i++) {
-	    tmp= ReadXkmGeomDoodad(file,geom,NULL);
-	    nRead+= tmp;
-	    if (tmp==0)
-		return nRead;
-	}
+    if (wireGeom.num_doodads > 0) {
+        for (i = 0; i < wireGeom.num_doodads; i++) {
+            tmp = ReadXkmGeomDoodad(file, geom, NULL);
+            nRead += tmp;
+            if (tmp == 0)
+                return nRead;
+        }
     }
-    if ((wireGeom.num_key_aliases>0)&&(geom->key_aliases)) {
-	int sz= XkbKeyNameLength*2;
-	int num= wireGeom.num_key_aliases;
-	if (fread(geom->key_aliases,sz,num,file)!=num) {
-	    _XkbLibError(_XkbErrBadLength,"ReadXkmGeometry",0);
-	    return -1;
-	}
-	nRead+= (num*sz);
-	geom->num_key_aliases= num;
+    if ((wireGeom.num_key_aliases > 0) && (geom->key_aliases)) {
+        int sz = XkbKeyNameLength * 2;
+        int num = wireGeom.num_key_aliases;
+
+        if (fread(geom->key_aliases, sz, num, file) != num) {
+            _XkbLibError(_XkbErrBadLength, "ReadXkmGeometry", 0);
+            return -1;
+        }
+        nRead += (num * sz);
+        geom->num_key_aliases = num;
     }
     return nRead;
 }
 
 Bool
-XkmProbe(FILE *file)
+XkmProbe(FILE * file)
 {
-unsigned hdr,tmp;
-int	 nRead=0;
-
-    hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion);
-    tmp= XkmGetCARD32(file,&nRead);
-    if (tmp!=hdr) {
-	if ((tmp&(~0xff))==(hdr&(~0xff))) {
-	    _XkbLibError(_XkbErrBadFileVersion,"XkmProbe",tmp&0xff);
-	}
-	return 0;
+    unsigned hdr, tmp;
+    int nRead = 0;
+
+    hdr = (('x' << 24) | ('k' << 16) | ('m' << 8) | XkmFileVersion);
+    tmp = XkmGetCARD32(file, &nRead);
+    if (tmp != hdr) {
+        if ((tmp & (~0xff)) == (hdr & (~0xff))) {
+            _XkbLibError(_XkbErrBadFileVersion, "XkmProbe", tmp & 0xff);
+        }
+        return 0;
     }
     return 1;
 }
 
 static Bool
-XkmReadTOC(FILE *file,xkmFileInfo* file_info,int max_toc,xkmSectionInfo *toc)
+XkmReadTOC(FILE * file, xkmFileInfo * file_info, int max_toc,
+           xkmSectionInfo * toc)
 {
-unsigned hdr,tmp;
-int	nRead=0;
-unsigned i,size_toc;
-
-    hdr= (('x'<<24)|('k'<<16)|('m'<<8)|XkmFileVersion);
-    tmp= XkmGetCARD32(file,&nRead);
-    if (tmp!=hdr) {
-	if ((tmp&(~0xff))==(hdr&(~0xff))) {
-	    _XkbLibError(_XkbErrBadFileVersion,"XkmReadTOC",tmp&0xff);
-	}
-	else {
-	    _XkbLibError(_XkbErrBadFileType,"XkmReadTOC",tmp);
-	}
-	return 0;
+    unsigned hdr, tmp;
+    int nRead = 0;
+    unsigned i, size_toc;
+
+    hdr = (('x' << 24) | ('k' << 16) | ('m' << 8) | XkmFileVersion);
+    tmp = XkmGetCARD32(file, &nRead);
+    if (tmp != hdr) {
+        if ((tmp & (~0xff)) == (hdr & (~0xff))) {
+            _XkbLibError(_XkbErrBadFileVersion, "XkmReadTOC", tmp & 0xff);
+        }
+        else {
+            _XkbLibError(_XkbErrBadFileType, "XkmReadTOC", tmp);
+        }
+        return 0;
     }
-    fread(file_info,SIZEOF(xkmFileInfo),1,file);
-    size_toc= file_info->num_toc;
-    if (size_toc>max_toc) {
-	DebugF("Warning! Too many TOC entries; last %d ignored\n",
-							size_toc-max_toc);
-	size_toc= max_toc;
+    fread(file_info, SIZEOF(xkmFileInfo), 1, file);
+    size_toc = file_info->num_toc;
+    if (size_toc > max_toc) {
+        DebugF("Warning! Too many TOC entries; last %d ignored\n",
+               size_toc - max_toc);
+        size_toc = max_toc;
     }
-    for (i=0;i<size_toc;i++) {
-	fread(&toc[i],SIZEOF(xkmSectionInfo),1,file);
+    for (i = 0; i < size_toc; i++) {
+        fread(&toc[i], SIZEOF(xkmSectionInfo), 1, file);
     }
     return 1;
 }
@@ -1183,71 +1223,72 @@ unsigned i,size_toc;
 
 #define	MAX_TOC	16
 unsigned
-XkmReadFile(FILE *file,unsigned need,unsigned want,XkbDescPtr *xkb)
+XkmReadFile(FILE * file, unsigned need, unsigned want, XkbDescPtr *xkb)
 {
-register unsigned	i;
-xkmSectionInfo		toc[MAX_TOC],tmpTOC;
-xkmFileInfo		fileInfo;
-unsigned		tmp,nRead=0;
-unsigned		which= need|want;
-
-    if (!XkmReadTOC(file,&fileInfo,MAX_TOC,toc))
-	return which;
-    if ((fileInfo.present&need)!=need) {
-       _XkbLibError(_XkbErrIllegalContents,"XkmReadFile",
-       						need&(~fileInfo.present));
-       return which;
+    register unsigned i;
+    xkmSectionInfo toc[MAX_TOC], tmpTOC;
+    xkmFileInfo fileInfo;
+    unsigned tmp, nRead = 0;
+    unsigned which = need | want;
+
+    if (!XkmReadTOC(file, &fileInfo, MAX_TOC, toc))
+        return which;
+    if ((fileInfo.present & need) != need) {
+        _XkbLibError(_XkbErrIllegalContents, "XkmReadFile",
+                     need & (~fileInfo.present));
+        return which;
     }
-    if (*xkb==NULL)
-	*xkb= XkbAllocKeyboard();
-    for (i=0;i<fileInfo.num_toc;i++) {
-	fseek(file,toc[i].offset,SEEK_SET);
-	tmp= fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file);
-	nRead= tmp*SIZEOF(xkmSectionInfo);
-	if ((tmpTOC.type!=toc[i].type)||(tmpTOC.format!=toc[i].format)||
-	    (tmpTOC.size!=toc[i].size)||(tmpTOC.offset!=toc[i].offset)) {
-	    return which;
-	}
-	if ((which&(1<<tmpTOC.type))==0) {
-	    continue;
-	}
-	switch (tmpTOC.type) {
-	    case XkmVirtualModsIndex:
-		tmp= ReadXkmVirtualMods(file,*xkb,NULL);
-		break;
-	    case XkmTypesIndex:
-		tmp= ReadXkmKeyTypes(file,*xkb,NULL);
-		break;
-	    case XkmCompatMapIndex:
-		tmp= ReadXkmCompatMap(file,*xkb,NULL);
-		break;
-	    case XkmKeyNamesIndex:
-		tmp= ReadXkmKeycodes(file,*xkb,NULL);
-		break;
-	    case XkmIndicatorsIndex:
-		tmp= ReadXkmIndicators(file,*xkb,NULL);
-		break;
-	    case XkmSymbolsIndex:
-		tmp= ReadXkmSymbols(file,*xkb);
-		break;
-	    case XkmGeometryIndex:
-		tmp= ReadXkmGeometry(file,*xkb);
-		break;
-	    default:
-		_XkbLibError(_XkbErrBadImplementation,
-				XkbConfigText(tmpTOC.type,XkbMessage),0);
-		tmp= 0;
-		break;
-	}
-	if (tmp>0) {
-	    nRead+= tmp;
-	    which&= ~(1<<toc[i].type);
-	    (*xkb)->defined|= (1<<toc[i].type);
-	}
-	if (nRead!=tmpTOC.size) {
-	    _XkbLibError(_XkbErrBadLength,XkbConfigText(tmpTOC.type,XkbMessage),
-	    						nRead-tmpTOC.size);
-	}
+    if (*xkb == NULL)
+        *xkb = XkbAllocKeyboard();
+    for (i = 0; i < fileInfo.num_toc; i++) {
+        fseek(file, toc[i].offset, SEEK_SET);
+        tmp = fread(&tmpTOC, SIZEOF(xkmSectionInfo), 1, file);
+        nRead = tmp * SIZEOF(xkmSectionInfo);
+        if ((tmpTOC.type != toc[i].type) || (tmpTOC.format != toc[i].format) ||
+            (tmpTOC.size != toc[i].size) || (tmpTOC.offset != toc[i].offset)) {
+            return which;
+        }
+        if ((which & (1 << tmpTOC.type)) == 0) {
+            continue;
+        }
+        switch (tmpTOC.type) {
+        case XkmVirtualModsIndex:
+            tmp = ReadXkmVirtualMods(file, *xkb, NULL);
+            break;
+        case XkmTypesIndex:
+            tmp = ReadXkmKeyTypes(file, *xkb, NULL);
+            break;
+        case XkmCompatMapIndex:
+            tmp = ReadXkmCompatMap(file, *xkb, NULL);
+            break;
+        case XkmKeyNamesIndex:
+            tmp = ReadXkmKeycodes(file, *xkb, NULL);
+            break;
+        case XkmIndicatorsIndex:
+            tmp = ReadXkmIndicators(file, *xkb, NULL);
+            break;
+        case XkmSymbolsIndex:
+            tmp = ReadXkmSymbols(file, *xkb);
+            break;
+        case XkmGeometryIndex:
+            tmp = ReadXkmGeometry(file, *xkb);
+            break;
+        default:
+            _XkbLibError(_XkbErrBadImplementation,
+                         XkbConfigText(tmpTOC.type, XkbMessage), 0);
+            tmp = 0;
+            break;
+        }
+        if (tmp > 0) {
+            nRead += tmp;
+            which &= ~(1 << toc[i].type);
+            (*xkb)->defined |= (1 << toc[i].type);
+        }
+        if (nRead != tmpTOC.size) {
+            _XkbLibError(_XkbErrBadLength,
+                         XkbConfigText(tmpTOC.type, XkbMessage),
+                         nRead - tmpTOC.size);
+        }
     }
     return which;
 }