Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
(cherry picked from commit 9838b7032ea9792bec21af424c53c07078636d21)

28 files changed, 15882 insertions, 15401 deletions

diff --git a/xkb/XKBAlloc.c b/xkb/XKBAlloc.c
index b70ac1705..20e0459af 100644
--- a/xkb/XKBAlloc.c
+++ b/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/xkb/XKBGAlloc.c b/xkb/XKBGAlloc.c
index dd2b04696..f7e017682 100644
--- a/xkb/XKBGAlloc.c
+++ b/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/xkb/XKBMAlloc.c b/xkb/XKBMAlloc.c
index 2681ba3c3..645e90544 100644
--- a/xkb/XKBMAlloc.c
+++ b/xkb/XKBMAlloc.c
@@ -42,174 +42,181 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 /***====================================================================***/
 
 Status
-XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
+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))) {
+    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;
-	}
+               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)
+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;
-	}
+    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;
 }
@@ -217,124 +224,124 @@ XkbServerMapPtr map;
 /***====================================================================***/
 
 static Status
-XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)
+XkbCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into)
 {
-    if ((!from)||(!into))
-	return BadMatch;
+    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));
+    *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)
+XkbCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types)
 {
-register int i,rtrn;
+    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;
+    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)
+XkbResizeKeyType(XkbDescPtr xkb,
+                 int type_ndx,
+                 int map_count, Bool want_preserve, int new_num_lvls)
 {
-XkbKeyTypePtr	type;
-KeyCode		matchingKeys[XkbMaxKeyCount],nMatchingKeys;
+    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;
+    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;
+    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;
-	}
+        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:
@@ -357,156 +364,167 @@ KeyCode		matchingKeys[XkbMaxKeyCount],nMatchingKeys;
      * 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;
+    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)
+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);
+    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;
+    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;
+    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;
@@ -515,365 +533,398 @@ KeySym	*newSyms;
 }
 
 static unsigned
-_ExtendRange(	unsigned int 	old_flags,
-		unsigned int	flag,
-		KeyCode		newKC,
-		KeyCode *	old_min,
-		unsigned char *	old_num)
+_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;
+    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;
-	}
+        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)
+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;
+    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)
+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;
+    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;
+    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;
+    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;
+    xkb->server->num_acts = nActs;
     return &xkb->server->acts[xkb->server->key_acts[key]];
 }
 
 void
-XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+XkbFreeClientMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
 {
-XkbClientMapPtr	map;
+    XkbClientMapPtr map;
 
-    if ((xkb==NULL)||(xkb->map==NULL))
-	return;
+    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;
+        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;
+        free(xkb->map);
+        xkb->map = NULL;
     }
     return;
 }
 
 void
-XkbFreeServerMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+XkbFreeServerMap(XkbDescPtr xkb, unsigned what, Bool freeMap)
 {
-XkbServerMapPtr	map;
+    XkbServerMapPtr map;
 
-    if ((xkb==NULL)||(xkb->server==NULL))
-	return;
+    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;
+        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;
+        free(xkb->server);
+        xkb->server = NULL;
     }
     return;
 }
diff --git a/xkb/XKBMisc.c b/xkb/XKBMisc.c
index 96688be18..6abd1d11a 100644
--- a/xkb/XKBMisc.c
+++ b/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/xkb/ddxBeep.c b/xkb/ddxBeep.c
index 6f74cb541..f95d0ee81 100644
--- a/xkb/ddxBeep.c
+++ b/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/xkb/ddxCtrls.c b/xkb/ddxCtrls.c
index 04de608df..0805fb208 100644
--- a/xkb/ddxCtrls.c
+++ b/xkb/ddxCtrls.c
@@ -39,20 +39,19 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XI.h>
 
 void
-XkbDDXKeybdCtrlProc(DeviceIntPtr dev,KeybdCtrl *ctrl)
+XkbDDXKeybdCtrlProc(DeviceIntPtr dev, KeybdCtrl * ctrl)
 {
-int realRepeat;
+    int realRepeat;
 
-    realRepeat= ctrl->autoRepeat;
-    if ((dev->kbdfeed)&&(XkbDDXUsesSoftRepeat(dev)))
-	ctrl->autoRepeat= 0;
+    realRepeat = ctrl->autoRepeat;
+    if ((dev->kbdfeed) && (XkbDDXUsesSoftRepeat(dev)))
+        ctrl->autoRepeat = 0;
     if (dev->key && dev->key->xkbInfo && dev->key->xkbInfo->kbdProc)
-	(*dev->key->xkbInfo->kbdProc)(dev,ctrl);
-    ctrl->autoRepeat= realRepeat;
+        (*dev->key->xkbInfo->kbdProc) (dev, ctrl);
+    ctrl->autoRepeat = realRepeat;
     return;
 }
 
-
 int
 XkbDDXUsesSoftRepeat(DeviceIntPtr pXDev)
 {
@@ -60,15 +59,15 @@ XkbDDXUsesSoftRepeat(DeviceIntPtr pXDev)
 }
 
 void
-XkbDDXChangeControls(DeviceIntPtr dev,XkbControlsPtr old,XkbControlsPtr new)
+XkbDDXChangeControls(DeviceIntPtr dev, XkbControlsPtr old, XkbControlsPtr new)
 {
-unsigned	changed, i;
-unsigned 	char *rep_old, *rep_new, *rep_fb;
+    unsigned changed, i;
+    unsigned char *rep_old, *rep_new, *rep_fb;
 
-    changed= new->enabled_ctrls^old->enabled_ctrls;
+    changed = new->enabled_ctrls ^ old->enabled_ctrls;
     for (rep_old = old->per_key_repeat,
          rep_new = new->per_key_repeat,
-	 rep_fb  = dev->kbdfeed->ctrl.autoRepeats,
+         rep_fb = dev->kbdfeed->ctrl.autoRepeats,
          i = 0; i < XkbPerKeyBitArraySize; i++) {
         if (rep_old[i] != rep_new[i]) {
             rep_fb[i] = rep_new[i];
@@ -76,10 +75,9 @@ unsigned 	char *rep_old, *rep_new, *rep_fb;
         }
     }
 
-    if (changed&XkbPerKeyRepeatMask) {
-	if (dev->kbdfeed->CtrlProc)
-	    (*dev->kbdfeed->CtrlProc)(dev,&dev->kbdfeed->ctrl);
+    if (changed & XkbPerKeyRepeatMask) {
+        if (dev->kbdfeed->CtrlProc)
+            (*dev->kbdfeed->CtrlProc) (dev, &dev->kbdfeed->ctrl);
     }
     return;
 }
-
diff --git a/xkb/ddxKillSrv.c b/xkb/ddxKillSrv.c
index 106b39587..1cabb1bd7 100644
--- a/xkb/ddxKillSrv.c
+++ b/xkb/ddxKillSrv.c
@@ -38,7 +38,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <xkbsrv.h>
 
 int
-XkbDDXTerminateServer(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXTerminateServer(DeviceIntPtr dev, KeyCode key, XkbAction *act)
 {
     if (dev != inputInfo.keyboard)
         GiveUp(1);
diff --git a/xkb/ddxLEDs.c b/xkb/ddxLEDs.c
index 246d58c31..81b7b00e0 100644
--- a/xkb/ddxLEDs.c
+++ b/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/xkb/ddxList.c b/xkb/ddxList.c
index db34c8df5..9b69b2b82 100644
--- a/xkb/ddxList.c
+++ b/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/xkb/ddxLoad.c b/xkb/ddxLoad.c
index 196142318..cb2dfc31c 100644
--- a/xkb/ddxLoad.c
+++ b/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/xkb/ddxPrivate.c b/xkb/ddxPrivate.c
index f1c85f6ea..fcde3a18c 100644
--- a/xkb/ddxPrivate.c
+++ b/xkb/ddxPrivate.c
@@ -8,7 +8,7 @@
 #include <xkbsrv.h>
 
 int
-XkbDDXPrivate(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXPrivate(DeviceIntPtr dev, KeyCode key, XkbAction *act)
 {
     return 0;
 }
diff --git a/xkb/ddxVT.c b/xkb/ddxVT.c
index cbd453706..65291026a 100644
--- a/xkb/ddxVT.c
+++ b/xkb/ddxVT.c
@@ -38,7 +38,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <xkbsrv.h>
 
 int
-XkbDDXSwitchScreen(DeviceIntPtr dev,KeyCode key,XkbAction *act)
+XkbDDXSwitchScreen(DeviceIntPtr dev, KeyCode key, XkbAction *act)
 {
     return 1;
 }
diff --git a/xkb/maprules.c b/xkb/maprules.c
index 66800478c..c6900eccb 100644
--- a/xkb/maprules.c
+++ b/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/xkb/xkb.c b/xkb/xkb.c
index ac0b4278f..867a992d2 100644
--- a/xkb/xkb.c
+++ b/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;
+    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;
-    }
-    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);
+    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);
 }
 
 /***====================================================================***/
 
 static int
-CheckKeyTypes(	ClientPtr	client,
-		XkbDescPtr	xkb,
-		xkbSetMapReq *	req,
-		xkbKeyTypeWireDesc **wireRtrn,
-		int	 *	nMapsRtrn,
-		CARD8 *		mapWidthRtrn)
+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;
-	}
+    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;
+        }
     }
     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;
+        *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;
     }
     *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,303 +5681,309 @@ 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;
 
     CHK_KBD_DEVICE(dev, stuff->deviceSpec, client, access_mode);
     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
@@ -5879,9 +6009,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;
@@ -5890,627 +6020,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;
@@ -6524,18 +6675,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;
@@ -6552,135 +6703,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;
 }
@@ -6692,20 +6847,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/xkb/xkbAccessX.c b/xkb/xkbAccessX.c
index d246827ea..111bf9f40 100644
--- a/xkb/xkbAccessX.c
+++ b/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/xkb/xkbActions.c b/xkb/xkbActions.c
index da0bdea69..c473df17c 100644
--- a/xkb/xkbActions.c
+++ b/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,926 @@ _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;
+    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(&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;
+    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;
 
         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;
+            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;
     }
-    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;
+            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;
     }
     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);
+                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 +1302,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 +1366,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 +1404,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;
 
     /* ignore attached SDs */
     if (!IsMaster(dev) && !IsFloating(dev))
@@ -1402,16 +1418,17 @@ XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
     else
         gpe_flags = POINTER_RELATIVE;
 
-    valuator_mask_set_range(&mask, 0, 2, (int[]){x, y});
+    valuator_mask_set_range(&mask, 0, 2, (int[]) {
+                            x, y});
 
     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.
@@ -1423,8 +1440,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/xkb/xkbDflts.h b/xkb/xkbDflts.h
index 5d8690650..994726c0f 100644
--- a/xkb/xkbDflts.h
+++ b/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/xkb/xkbEvents.c b/xkb/xkbEvents.c
index 347f0f8a4..d49e4c1ba 100644
--- a/xkb/xkbEvents.c
+++ b/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/xkb/xkbInit.c b/xkb/xkbInit.c
index f578f1679..4e8e267da 100644
--- a/xkb/xkbInit.c
+++ b/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 char	XkbDfltAccessXOptions;
+extern unsigned short XkbDfltAccessXTimeout;
+extern unsigned int XkbDfltAccessXTimeoutMask;
+extern unsigned int XkbDfltAccessXFeedback;
+extern unsigned char 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 char)
-					   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 char)
+                        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/xkb/xkbLEDs.c b/xkb/xkbLEDs.c
index 24fcd3b48..e1e22d178 100644
--- a/xkb/xkbLEDs.c
+++ b/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/xkb/xkbPrKeyEv.c b/xkb/xkbPrKeyEv.c
index 630f17c23..32411838d 100644
--- a/xkb/xkbPrKeyEv.c
+++ b/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/xkb/xkbSwap.c b/xkb/xkbSwap.c
index fcae918a9..076da340b 100644
--- a/xkb/xkbSwap.c
+++ b/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/xkb/xkbUtils.c b/xkb/xkbUtils.c
index cc9aaa75a..c23cd7784 100644
--- a/xkb/xkbUtils.c
+++ b/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/xkb/xkbfmisc.c b/xkb/xkbfmisc.c
index 782b823bb..d96ee4b52 100644
--- a/xkb/xkbfmisc.c
+++ b/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/xkb/xkbgeom.h b/xkb/xkbgeom.h
index d10b956a6..bef3775db 100644
--- a/xkb/xkbgeom.h
+++ b/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/xkb/xkbout.c b/xkb/xkbout.c
index 889d5cc39..cd1ae0b4e 100644
--- a/xkb/xkbout.c
+++ b/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/xkb/xkbtext.c b/xkb/xkbtext.c
index 8ef2b05b0..f66a08f75 100644
--- a/xkb/xkbtext.c
+++ b/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/xkb/xkmread.c b/xkb/xkmread.c
index a5c1ecfff..45da965dc 100644
--- a/xkb/xkmread.c
+++ b/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;
 }