diff --git a/src/alloc.c b/src/alloc.c
index e2d2c17..b4f0909 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -33,557 +33,620 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XKB.h>
 
 int
-XkbcAllocCompatMap(XkbcDescPtr xkb,unsigned which,unsigned nSI)
+XkbcAllocCompatMap(XkbcDescPtr 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= _XkbTypedRealloc(compat->sym_interpret,
-						     nSI,XkbSymInterpretRec);
-	if (compat->sym_interpret==NULL) {
-	    _XkbFree(prev_interpret);
-	    compat->size_si= compat->num_si= 0;
-	    return BadAlloc;
-	}
-	if (compat->num_si!=0) {
-	    _XkbClearElems(compat->sym_interpret,compat->num_si,
-					compat->size_si-1,XkbSymInterpretRec);
-	}
-	return Success;
+        if (xkb->compat->size_si >= nSI)
+            return Success;
+
+        compat = xkb->compat;
+        compat->size_si = nSI;
+        if (!compat->sym_interpret)
+            compat->num_si = 0;
+
+        prev_interpret = compat->sym_interpret;
+        compat->sym_interpret = _XkbTypedRealloc(compat->sym_interpret,
+                                                 nSI, XkbSymInterpretRec);
+        if (!compat->sym_interpret) {
+            _XkbFree(prev_interpret);
+            compat->size_si = compat->num_si = 0;
+            return BadAlloc;
+        }
+
+        if (compat->num_si != 0)
+            _XkbClearElems(compat->sym_interpret, compat->num_si,
+                           compat->size_si - 1, XkbSymInterpretRec);
+
+        return Success;
     }
-    compat= _XkbTypedCalloc(1,XkbCompatMapRec);
-    if (compat==NULL)
-	return BadAlloc;
-    if (nSI>0) {
-	compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec);
-	if (!compat->sym_interpret) {
-	    _XkbFree(compat);
-	    return BadAlloc;
-	}
+
+    compat = _XkbTypedCalloc(1, XkbCompatMapRec);
+    if (!compat)
+        return BadAlloc;
+
+    if (nSI > 0) {
+        compat->sym_interpret = _XkbTypedCalloc(nSI, XkbSymInterpretRec);
+        if (!compat->sym_interpret) {
+            _XkbFree(compat);
+            return BadAlloc;
+        }
     }
-    compat->size_si= nSI;
-    compat->num_si= 0;
-    bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
-    xkb->compat= compat;
+    compat->size_si = nSI;
+    compat->num_si = 0;
+    bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbModsRec));
+    xkb->compat = compat;
+
     return Success;
 }
 
 
 void
-XkbcFreeCompatMap(XkbcDescPtr xkb,unsigned which,Bool freeMap)
+XkbcFreeCompatMap(XkbcDescPtr xkb, unsigned which, Bool freeMap)
 {
-register XkbCompatMapPtr compat;
+    XkbCompatMapPtr compat;
 
-    if ((xkb==NULL)||(xkb->compat==NULL))
-	return;
-    compat= xkb->compat;
+    if (!xkb || !xkb->compat)
+        return;
+
+    compat = xkb->compat;
     if (freeMap)
-	which= XkbAllCompatMask;
-    if (which&XkbGroupCompatMask)
-	bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
-    if (which&XkbSymInterpMask) {
-	if ((compat->sym_interpret)&&(compat->size_si>0))
-	    _XkbFree(compat->sym_interpret);
-	compat->size_si= compat->num_si= 0;
-	compat->sym_interpret= NULL;
+        which = XkbAllCompatMask;
+
+    if (which & XkbGroupCompatMask)
+        bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbModsRec));
+
+    if (which & XkbSymInterpMask) {
+        if (compat->sym_interpret && (compat->size_si > 0))
+            _XkbFree(compat->sym_interpret);
+        compat->size_si = compat->num_si = 0;
+        compat->sym_interpret = NULL;
     }
+
     if (freeMap) {
-	_XkbFree(compat);
-	xkb->compat= NULL;
+        _XkbFree(compat);
+        xkb->compat = NULL;
     }
-    return;
 }
 
 int
-XkbcAllocNames(XkbcDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)
+XkbcAllocNames(XkbcDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases)
 {
-XkbNamesPtr	names;
+    XkbNamesPtr names;
 
-    if (xkb==NULL)
-	return BadMatch;
-    if (xkb->names==NULL) {
-	xkb->names = _XkbTypedCalloc(1,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;
+    if (!xkb)
+        return BadMatch;
 
-	type= xkb->map->types;
-	for (i=0;i<xkb->map->num_types;i++,type++) {
-	    if (type->level_names==NULL) {
-		type->level_names= _XkbTypedCalloc(type->num_levels,Atom);
-		if (type->level_names==NULL)
-		    return BadAlloc;
-	    }
-	}
+    if (!xkb->names) {
+        xkb->names = _XkbTypedCalloc(1, XkbNamesRec);
+        if (!xkb->names)
+            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= _XkbTypedCalloc((xkb->max_key_code+1),XkbKeyNameRec);
-	if (names->keys==NULL)
-	    return BadAlloc;
-    }
-    if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {
-	if (names->key_aliases==NULL) {
-	    names->key_aliases= _XkbTypedCalloc(nTotalAliases,XkbKeyAliasRec);
-	}
-	else if (nTotalAliases>names->num_key_aliases) {
-	    XkbKeyAliasRec *prev_aliases = names->key_aliases;
+    names = xkb->names;
 
-	    names->key_aliases= _XkbTypedRealloc(names->key_aliases,
-						nTotalAliases,XkbKeyAliasRec);
-	    if (names->key_aliases!=NULL) {
-		_XkbClearElems(names->key_aliases,names->num_key_aliases,
-						nTotalAliases-1,XkbKeyAliasRec);
-	    } else {
-		_XkbFree(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= _XkbTypedCalloc(nTotalRG,Atom);
-	}
-	else if (nTotalRG>names->num_rg) {
-	    Atom *prev_radio_groups = names->radio_groups;
+    if ((which & XkbKTLevelNamesMask) && xkb->map && xkb->map->types) {
+        int i;
+        XkbKeyTypePtr type;
 
-	    names->radio_groups= _XkbTypedRealloc(names->radio_groups,nTotalRG,
-									Atom);
-	    if (names->radio_groups!=NULL) {
-		_XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1,
-									Atom);
-	    } else {
-		_XkbFree(prev_radio_groups);
-	    }
-	}
-	if (names->radio_groups==NULL)
-	    return BadAlloc;
-	names->num_rg= nTotalRG;
+        type = xkb->map->types;
+        for (i = 0; i < xkb->map->num_types; i++, type++) {
+            if (!type->level_names) {
+                type->level_names = _XkbTypedCalloc(type->num_levels, Atom);
+                if (!type->level_names)
+                    return BadAlloc;
+            }
+        }
     }
+
+    if ((which & XkbKeyNamesMask) && names->keys) {
+        if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
+            (!XkbIsLegalKeycode(xkb->max_key_code)) ||
+            (xkb->max_key_code < xkb->min_key_code))
+            return BadValue;
+
+        names->keys = _XkbTypedCalloc(xkb->max_key_code + 1, XkbKeyNameRec);
+        if (!names->keys)
+            return BadAlloc;
+    }
+
+    if ((which & XkbKeyAliasesMask) && (nTotalAliases > 0)) {
+        if (!names->key_aliases)
+            names->key_aliases = _XkbTypedCalloc(nTotalAliases,
+                                                 XkbKeyAliasRec);
+        else if (nTotalAliases > names->num_key_aliases) {
+            XkbKeyAliasRec *prev_aliases = names->key_aliases;
+
+            names->key_aliases = _XkbTypedRealloc(names->key_aliases,
+                                                  nTotalAliases,
+                                                  XkbKeyAliasRec);
+            if (names->key_aliases)
+                _XkbClearElems(names->key_aliases, names->num_key_aliases,
+                               nTotalAliases - 1, XkbKeyAliasRec);
+            else
+                _XkbFree(prev_aliases);
+        }
+
+        if (!names->key_aliases) {
+            names->num_key_aliases = 0;
+            return BadAlloc;
+        }
+
+        names->num_key_aliases = nTotalAliases;
+    }
+
+    if ((which & XkbRGNamesMask) && (nTotalRG > 0)) {
+        if (!names->radio_groups)
+            names->radio_groups = _XkbTypedCalloc(nTotalRG, Atom);
+        else if (nTotalRG > names->num_rg) {
+            Atom *prev_radio_groups = names->radio_groups;
+
+            names->radio_groups = _XkbTypedRealloc(names->radio_groups,
+                                                   nTotalRG, Atom);
+            if (names->radio_groups)
+                _XkbClearElems(names->radio_groups, names->num_rg,
+                               nTotalRG - 1, Atom);
+            else
+                _XkbFree(prev_radio_groups);
+        }
+
+        if (!names->radio_groups)
+            return BadAlloc;
+
+        names->num_rg = nTotalRG;
+    }
+
     return Success;
 }
 
 void
-XkbcFreeNames(XkbcDescPtr xkb,unsigned which,Bool freeMap)
+XkbcFreeNames(XkbcDescPtr xkb, unsigned which, Bool freeMap)
 {
-XkbNamesPtr	names;
+    XkbNamesPtr names;
 
-    if ((xkb==NULL)||(xkb->names==NULL))
-	return;
-    names= xkb->names;
+    if (!xkb || !xkb->names)
+        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++) {
-		if (type->level_names!=NULL) {
-		    _XkbFree(type->level_names);
-		    type->level_names= NULL;
-		}
-	    }
-	}
+        which = XkbAllNamesMask;
+
+    if (which & XkbKTLevelNamesMask) {
+        XkbClientMapPtr map = xkb->map;
+
+        if (map && map->types) {
+            int i;
+            XkbKeyTypePtr type = map->types;
+
+            for (i = 0; i < map->num_types; i++, type++) {
+                if (type->level_names) {
+                    _XkbFree(type->level_names);
+                    type->level_names = NULL;
+                }
+            }
+        }
     }
-    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
-	_XkbFree(names->keys);
-	names->keys= NULL;
-	names->num_keys= 0;
+
+    if ((which & XkbKeyNamesMask) && names->keys) {
+        _XkbFree(names->keys);
+        names->keys = NULL;
+        names->num_keys = 0;
     }
-    if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
-	_XkbFree(names->key_aliases);
-	names->key_aliases=NULL;
-	names->num_key_aliases=0;
+
+    if ((which & XkbKeyAliasesMask) && names->key_aliases) {
+        _XkbFree(names->key_aliases);
+        names->key_aliases = NULL;
+        names->num_key_aliases = 0;
     }
-    if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
-	_XkbFree(names->radio_groups);
-	names->radio_groups= NULL;
-	names->num_rg= 0;
+
+    if ((which & XkbRGNamesMask) && names->radio_groups) {
+        _XkbFree(names->radio_groups);
+        names->radio_groups = NULL;
+        names->num_rg = 0;
     }
+
     if (freeMap) {
-	_XkbFree(names);
-	xkb->names= NULL;
+        _XkbFree(names);
+        xkb->names = NULL;
     }
-    return;
 }
 
 int
-XkbcAllocControls(XkbcDescPtr xkb,unsigned which)
+XkbcAllocControls(XkbcDescPtr xkb, unsigned which)
 {
-    if (xkb==NULL)
-	return BadMatch;
+    if (!xkb)
+        return BadMatch;
 
-    if (xkb->ctrls==NULL) {
-	xkb->ctrls= _XkbTypedCalloc(1,XkbControlsRec);
-	if (!xkb->ctrls)
-	    return BadAlloc;
+    if (!xkb->ctrls) {
+        xkb->ctrls = _XkbTypedCalloc(1, XkbControlsRec);
+        if (!xkb->ctrls)
+            return BadAlloc;
     }
+
     return Success;
 }
 
 void
-XkbcFreeControls(XkbcDescPtr xkb,unsigned which,Bool freeMap)
+XkbcFreeControls(XkbcDescPtr xkb, unsigned which, Bool freeMap)
 {
-    if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
-	_XkbFree(xkb->ctrls);
-	xkb->ctrls= NULL;
+    if (freeMap && xkb && xkb->ctrls) {
+        _XkbFree(xkb->ctrls);
+        xkb->ctrls = NULL;
     }
-    return;
 }
 
 int
 XkbcAllocIndicatorMaps(XkbcDescPtr xkb)
 {
-    if (xkb==NULL)
-	return BadMatch;
-    if (xkb->indicators==NULL) {
-	xkb->indicators= _XkbTypedCalloc(1,XkbIndicatorRec);
-	if (!xkb->indicators)
-	    return BadAlloc;
+    if (!xkb)
+        return BadMatch;
+
+    if (!xkb->indicators) {
+        xkb->indicators = _XkbTypedCalloc(1, XkbIndicatorRec);
+        if (!xkb->indicators)
+            return BadAlloc;
     }
+
     return Success;
 }
 
 void
 XkbcFreeIndicatorMaps(XkbcDescPtr xkb)
 {
-    if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
-	_XkbFree(xkb->indicators);
-	xkb->indicators= NULL;
+    if (xkb && xkb->indicators) {
+        _XkbFree(xkb->indicators);
+        xkb->indicators = NULL;
     }
-    return;
 }
 
-XkbcDescRec	*
+XkbcDescRec *
 XkbcAllocKeyboard(void)
 {
-XkbcDescRec *xkb;
+    XkbcDescRec *xkb;
 
-    xkb = _XkbTypedCalloc(1,XkbcDescRec);
+    xkb = _XkbTypedCalloc(1, XkbcDescRec);
     if (xkb)
-	xkb->device_spec= XkbUseCoreKbd;
+        xkb->device_spec = XkbUseCoreKbd;
     return xkb;
 }
 
 void
-XkbcFreeKeyboard(XkbcDescPtr xkb,unsigned which,Bool freeAll)
+XkbcFreeKeyboard(XkbcDescPtr xkb, unsigned which, Bool freeAll)
 {
-    if (xkb==NULL)
-	return;
+    if (!xkb)
+        return;
+
     if (freeAll)
-	which= XkbAllComponentsMask;
-    if (which&XkbClientMapMask)
-	XkbcFreeClientMap(xkb,XkbAllClientInfoMask,True);
-    if (which&XkbServerMapMask)
-	XkbcFreeServerMap(xkb,XkbAllServerInfoMask,True);
-    if (which&XkbCompatMapMask)
-	XkbcFreeCompatMap(xkb,XkbAllCompatMask,True);
-    if (which&XkbIndicatorMapMask)
-	XkbcFreeIndicatorMaps(xkb);
-    if (which&XkbNamesMask)
-	XkbcFreeNames(xkb,XkbAllNamesMask,True);
-    if ((which&XkbGeometryMask) && (xkb->geom!=NULL))
-	XkbcFreeGeometry(xkb->geom,XkbGeomAllMask,True);
-    if (which&XkbControlsMask)
-	XkbcFreeControls(xkb,XkbAllControlsMask,True);
+        which = XkbAllComponentsMask;
+
+    if (which & XkbClientMapMask)
+        XkbcFreeClientMap(xkb, XkbAllClientInfoMask, True);
+    if (which & XkbServerMapMask)
+        XkbcFreeServerMap(xkb, XkbAllServerInfoMask, True);
+    if (which & XkbCompatMapMask)
+        XkbcFreeCompatMap(xkb, XkbAllCompatMask, True);
+    if (which & XkbIndicatorMapMask)
+        XkbcFreeIndicatorMaps(xkb);
+    if (which & XkbNamesMask)
+        XkbcFreeNames(xkb, XkbAllNamesMask, True);
+    if ((which & XkbGeometryMask) && xkb->geom)
+        XkbcFreeGeometry(xkb->geom, XkbGeomAllMask, True);
+    if (which & XkbControlsMask)
+        XkbcFreeControls(xkb, XkbAllControlsMask, True);
     if (freeAll)
-	_XkbFree(xkb);
-    return;
+        _XkbFree(xkb);
 }
 
 int
-XkbcAllocClientMap(XkbcDescPtr xkb,unsigned which,unsigned nTotalTypes)
+XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes)
 {
-register int	i;
-XkbClientMapPtr map;
+    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))) {
+    if (!xkb || ((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))) {
 #ifdef DEBUG
-fprintf(stderr,"bad keycode (%d,%d) in XkbAllocClientMap\n",
-				xkb->min_key_code,xkb->max_key_code);
+        fprintf(stderr, "bad keycode (%d,%d) in XkbAllocClientMap\n",
+                xkb->min_key_code, xkb->max_key_code);
 #endif
-	return BadValue;
+        return BadValue;
     }
 
-    if (xkb->map==NULL) {
-	map= _XkbTypedCalloc(1,XkbClientMapRec);
-	if (map==NULL)
-	    return BadAlloc;
-	xkb->map= map;
+    if (!xkb->map) {
+        map = _XkbTypedCalloc(1, XkbClientMapRec);
+        if (!map)
+            return BadAlloc;
+        xkb->map = map;
     }
-    else map= xkb->map;
+    else
+        map = xkb->map;
 
-    if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {
-	if (map->types==NULL) {
-	    map->types= _XkbTypedCalloc(nTotalTypes,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;
+    if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
+        if (!map->types) {
+            map->types = _XkbTypedCalloc(nTotalTypes, XkbKeyTypeRec);
+            if (!map->types)
+                return BadAlloc;
 
-	    map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);
-	    if (map->types==NULL) {
-		_XkbFree(prev_types);
-		map->num_types= map->size_types= 0;
-		return BadAlloc;
-	    }
-	    map->size_types= nTotalTypes;
-	    bzero(&map->types[map->num_types],
-		  ((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));
-	}
+            map->num_types = 0;
+            map->size_types = nTotalTypes;
+        }
+        else if (map->size_types < nTotalTypes) {
+            XkbKeyTypeRec *prev_types = map->types;
+
+            map->types = _XkbTypedRealloc(map->types, nTotalTypes,
+                                          XkbKeyTypeRec);
+            if (!map->types) {
+                _XkbFree(prev_types);
+                map->num_types = map->size_types = 0;
+                return BadAlloc;
+            }
+
+            map->size_types = nTotalTypes;
+            bzero(&map->types[map->num_types],
+                  (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= _XkbTypedCalloc(map->size_syms,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= _XkbTypedCalloc(i,XkbSymMapRec);
-	    if (map->key_sym_map==NULL)
-		return BadAlloc;
-	}
+
+    if (which & XkbKeySymsMask) {
+        int nKeys = XkbNumKeys(xkb);
+
+        if (!map->syms) {
+            map->size_syms = (nKeys * 15) / 10;
+            map->syms = _XkbTypedCalloc(map->size_syms, KeySym);
+            if (!map->syms) {
+                map->size_syms = 0;
+                return BadAlloc;
+            }
+            map->num_syms = 1;
+            map->syms[0] = NoSymbol;
+        }
+
+        if (!map->key_sym_map) {
+            i = xkb->max_key_code + 1;
+            map->key_sym_map = _XkbTypedCalloc(i, XkbSymMapRec);
+            if (!map->key_sym_map)
+                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= _XkbTypedCalloc(i,unsigned char);
-	    if (map->modmap==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) {
+            i = xkb->max_key_code + 1;
+            map->modmap = _XkbTypedCalloc(i, unsigned char);
+            if (!map->modmap)
+                return BadAlloc;
+        }
     }
+
     return Success;
 }
 
 int
-XkbcAllocServerMap(XkbcDescPtr xkb,unsigned which,unsigned nNewActions)
+XkbcAllocServerMap(XkbcDescPtr xkb, unsigned which, unsigned nNewActions)
 {
-register int	i;
-XkbServerMapPtr map;
+    int i;
+    XkbServerMapPtr map;
 
-    if (xkb==NULL)
-	return BadMatch;
-    if (xkb->server==NULL) {
-	map= _XkbTypedCalloc(1,XkbServerMapRec);
-	if (map==NULL)
-	    return BadAlloc;
-	for (i=0;i<XkbNumVirtualMods;i++) {
-	    map->vmods[i]= XkbNoModifierMask;
-	}
-	xkb->server= map;
+    if (!xkb)
+        return BadMatch;
+
+    if (!xkb->server) {
+        map = _XkbTypedCalloc(1, XkbServerMapRec);
+        if (!map)
+            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= _XkbTypedCalloc(i,unsigned char);
-	    if (map->explicit==NULL)
-		return BadAlloc;
-	}
+    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) {
+            i = xkb->max_key_code + 1;
+            map->explicit = _XkbTypedCalloc(i, unsigned char);
+            if (!map->explicit)
+                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= _XkbTypedCalloc((nNewActions+1),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= _XkbTypedRealloc(map->acts,need,XkbAction);
-	    if (map->acts==NULL) {
-		_XkbFree(prev_acts);
-	        map->num_acts= map->size_acts= 0;
-	        return BadAlloc;
-	    }
-	    map->size_acts= need;
-	    bzero(&map->acts[map->num_acts],
-		    ((map->size_acts-map->num_acts)*sizeof(XkbAction)));
-	}
-	if (map->key_acts==NULL) {
-	    i= xkb->max_key_code+1;
-	    map->key_acts= _XkbTypedCalloc(i,unsigned short);
-	    if (map->key_acts==NULL)
-		return BadAlloc;
-	}
+        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) {
+            map->acts = _XkbTypedCalloc(nNewActions + 1, XkbAction);
+            if (!map->acts)
+                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 = _XkbTypedRealloc(map->acts, need, XkbAction);
+            if (!map->acts) {
+                _XkbFree(prev_acts);
+                map->num_acts = map->size_acts = 0;
+                return BadAlloc;
+            }
+
+            map->size_acts = need;
+            bzero(&map->acts[map->num_acts],
+                  (map->size_acts - map->num_acts) * sizeof(XkbAction));
+        }
+
+        if (!map->key_acts) {
+            i = xkb->max_key_code + 1;
+            map->key_acts = _XkbTypedCalloc(i, unsigned short);
+            if (!map->key_acts)
+                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= _XkbTypedCalloc(i,XkbBehavior);
-	    if (map->behaviors==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) {
+            i = xkb->max_key_code + 1;
+            map->behaviors = _XkbTypedCalloc(i, XkbBehavior);
+            if (!map->behaviors)
+                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= _XkbTypedCalloc(i,unsigned short);
-	    if (map->vmodmap==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) {
+            i = xkb->max_key_code + 1;
+            map->vmodmap = _XkbTypedCalloc(i, unsigned short);
+            if (!map->vmodmap)
+                return BadAlloc;
+        }
     }
+
     return Success;
 }
 
 void
-XkbcFreeClientMap(XkbcDescPtr xkb,unsigned what,Bool freeMap)
+XkbcFreeClientMap(XkbcDescPtr xkb, unsigned what, Bool freeMap)
 {
-XkbClientMapPtr	map;
+    XkbClientMapPtr map;
+
+    if (!xkb || !xkb->map)
+        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++) {
-		    if (type->map!=NULL) {
-			_XkbFree(type->map);
-			type->map= NULL;
-		    }
-		    if (type->preserve!=NULL) {
-			_XkbFree(type->preserve);
-			type->preserve= NULL;
-		    }
-		    type->map_count= 0;
-		    if (type->level_names!=NULL) {
-			_XkbFree(type->level_names);
-			type->level_names= NULL;
-		    }
-		}
-	    }
-	    _XkbFree(map->types);
-	    map->num_types= map->size_types= 0;
-	    map->types= NULL;
-	}
+        what = XkbAllClientInfoMask;
+    map = xkb->map;
+
+    if (what & XkbKeyTypesMask) {
+        if (map->types) {
+            if (map->num_types > 0) {
+                int i;
+                XkbKeyTypePtr type;
+
+                for (i = 0, type = map->types; i < map->num_types; i++, type++) {
+                    if (type->map) {
+                        _XkbFree(type->map);
+                        type->map = NULL;
+                    }
+                    if (type->preserve) {
+                        _XkbFree(type->preserve);
+                        type->preserve = NULL;
+                    }
+                    type->map_count = 0;
+                    if (type->level_names) {
+                        _XkbFree(type->level_names);
+                        type->level_names = NULL;
+                    }
+                }
+            }
+            _XkbFree(map->types);
+            map->num_types = map->size_types = 0;
+            map->types = NULL;
+        }
     }
-    if (what&XkbKeySymsMask) {
-	if (map->key_sym_map!=NULL) {
-	    _XkbFree(map->key_sym_map);
-	    map->key_sym_map= NULL;
-	}
-	if (map->syms!=NULL) {
-	    _XkbFree(map->syms);
-	    map->size_syms= map->num_syms= 0;
-	    map->syms= NULL;
-	}
+
+    if (what & XkbKeySymsMask) {
+        if (map->key_sym_map) {
+            _XkbFree(map->key_sym_map);
+            map->key_sym_map = NULL;
+        }
+        if (map->syms) {
+            _XkbFree(map->syms);
+            map->size_syms = map->num_syms = 0;
+            map->syms = NULL;
+        }
     }
-    if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {
-	_XkbFree(map->modmap);
-	map->modmap= NULL;
+
+    if ((what & XkbModifierMapMask) && map->modmap) {
+        _XkbFree(map->modmap);
+        map->modmap = NULL;
     }
+
     if (freeMap) {
-	_XkbFree(xkb->map);
-	xkb->map= NULL;
+        _XkbFree(xkb->map);
+        xkb->map = NULL;
     }
-    return;
 }
 
 void
-XkbcFreeServerMap(XkbcDescPtr xkb,unsigned what,Bool freeMap)
+XkbcFreeServerMap(XkbcDescPtr xkb, unsigned what, Bool freeMap)
 {
-XkbServerMapPtr	map;
+    XkbServerMapPtr map;
+
+    if (!xkb || !xkb->server)
+        return;
 
-    if ((xkb==NULL)||(xkb->server==NULL))
-	return;
     if (freeMap)
-	what= XkbAllServerInfoMask;
-    map= xkb->server;
-    if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {
-	_XkbFree(map->explicit);
-	map->explicit= NULL;
+        what = XkbAllServerInfoMask;
+    map = xkb->server;
+
+    if ((what & XkbExplicitComponentsMask) && map->explicit) {
+        _XkbFree(map->explicit);
+        map->explicit = NULL;
     }
-    if (what&XkbKeyActionsMask) {
-	if (map->key_acts!=NULL) {
-	    _XkbFree(map->key_acts);
-	    map->key_acts= NULL;
-	}
-	if (map->acts!=NULL) {
-	    _XkbFree(map->acts);
-	    map->num_acts= map->size_acts= 0;
-	    map->acts= NULL;
-	}
+
+    if (what & XkbKeyActionsMask) {
+        if (map->key_acts) {
+            _XkbFree(map->key_acts);
+            map->key_acts = NULL;
+        }
+        if (map->acts) {
+            _XkbFree(map->acts);
+            map->num_acts = map->size_acts = 0;
+            map->acts = NULL;
+        }
     }
-    if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {
-	_XkbFree(map->behaviors);
-	map->behaviors= NULL;
+
+    if ((what & XkbKeyBehaviorsMask) && map->behaviors) {
+        _XkbFree(map->behaviors);
+        map->behaviors = NULL;
     }
-    if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {
-	_XkbFree(map->vmodmap);
-	map->vmodmap= NULL;
+
+    if ((what & XkbVirtualModMapMask) && map->vmodmap) {
+        _XkbFree(map->vmodmap);
+        map->vmodmap = NULL;
     }
 
     if (freeMap) {
-	_XkbFree(xkb->server);
-	xkb->server= NULL;
+        _XkbFree(xkb->server);
+        xkb->server = NULL;
     }
-    return;
 }
diff --git a/src/galloc.c b/src/galloc.c
index 31e2b53..67499d6 100644
--- a/src/galloc.c
+++ b/src/galloc.c
@@ -33,507 +33,489 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XKB.h>
 
 static void
-_XkbFreeGeomLeafElems(	Bool			freeAll,
-			int			first,
-			int 			count,
-			unsigned short *	num_inout,
-			unsigned short *	sz_inout,
-			char **			elems,
-			unsigned int		elem_sz)
+_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;
-	if (*elems!=NULL) {
-	    _XkbFree(*elems);
-	    *elems= NULL;
-	}
-	return;
+    if (freeAll || !(*elems)) {
+        *num_inout = *sz_inout = 0;
+        if (*elems) {
+            _XkbFree(*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 = *elems;
+        int 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)
+_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;
+    int i;
+    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))
+        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;
-	if (*elems) {
-	    _XkbFree(*elems);
-	    *elems= NULL;
-	}
+        *num_inout = *sz_inout = 0;
+        if (*elems) {
+            _XkbFree(*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;
 }
 
 static void
 _XkbClearProperty(char *prop_in)
 {
-XkbPropertyPtr	prop= (XkbPropertyPtr)prop_in;
+    XkbPropertyPtr prop = (XkbPropertyPtr)prop_in;
 
     if (prop->name) {
-	_XkbFree(prop->name);
-	prop->name= NULL;
+        _XkbFree(prop->name);
+        prop->name = NULL;
     }
     if (prop->value) {
-	_XkbFree(prop->value);
-	prop->value= NULL;
+        _XkbFree(prop->value);
+        prop->value = NULL;
     }
-    return;
 }
 
 void
-XkbcFreeGeomProperties(	XkbGeometryPtr	geom,
-			int		first,
-			int		count,
-			Bool		freeAll)
+XkbcFreeGeomProperties(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;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_properties, &geom->sz_properties,
+                             (char **)&geom->properties,
+                             sizeof(XkbPropertyRec),
+                             _XkbClearProperty);
 }
 
 void
-XkbcFreeGeomKeyAliases(	XkbGeometryPtr	geom,
-			int		first,
-			int		count,
-			Bool		freeAll)
+XkbcFreeGeomKeyAliases(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;
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &geom->num_key_aliases, &geom->sz_key_aliases,
+                          (char **)&geom->key_aliases,
+                          sizeof(XkbKeyAliasRec));
 }
 
 static void
 _XkbClearColor(char *color_in)
 {
-XkbColorPtr	color= (XkbColorPtr)color_in;
+    XkbColorPtr color = (XkbColorPtr)color_in;
 
     if (color->spec)
-	_XkbFree(color->spec);
-    return;
+        _XkbFree(color->spec);
 }
 
 void
-XkbcFreeGeomColors(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbcFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_colors,&geom->sz_colors,
-				(char **)&geom->colors,
-				sizeof(XkbColorRec),_XkbClearColor);
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_colors, &geom->sz_colors,
+                             (char **)&geom->colors, sizeof(XkbColorRec),
+                             _XkbClearColor);
 }
 
 void
-XkbcFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
+XkbcFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&outline->num_points,&outline->sz_points,
-				(char **)&outline->points,
-				sizeof(XkbPointRec));
-    return;
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &outline->num_points, &outline->sz_points,
+                          (char **)&outline->points, sizeof(XkbPointRec));
 }
 
 static void
 _XkbClearOutline(char *outline_in)
 {
-XkbOutlinePtr	outline= (XkbOutlinePtr)outline_in;
+    XkbOutlinePtr outline = (XkbOutlinePtr)outline_in;
 
-    if (outline->points!=NULL)
-	XkbcFreeGeomPoints(outline,0,outline->num_points,True);
-    return;
+    if (outline->points)
+        XkbcFreeGeomPoints(outline, 0, outline->num_points, True);
 }
 
 void
-XkbcFreeGeomOutlines(XkbShapePtr	shape,int first,int count,Bool freeAll)
+XkbcFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&shape->num_outlines,&shape->sz_outlines,
-				(char **)&shape->outlines,
-				sizeof(XkbOutlineRec),_XkbClearOutline);
-
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &shape->num_outlines, &shape->sz_outlines,
+                             (char **)&shape->outlines, sizeof(XkbOutlineRec),
+                             _XkbClearOutline);
 }
 
 static void
 _XkbClearShape(char *shape_in)
 {
-XkbShapePtr	shape= (XkbShapePtr)shape_in;
+    XkbShapePtr shape = (XkbShapePtr)shape_in;
 
     if (shape->outlines)
-	XkbcFreeGeomOutlines(shape,0,shape->num_outlines,True);
-    return;
+        XkbcFreeGeomOutlines(shape, 0, shape->num_outlines, True);
 }
 
 void
-XkbcFreeGeomShapes(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbcFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_shapes,&geom->sz_shapes,
-				(char **)&geom->shapes,
-				sizeof(XkbShapeRec),_XkbClearShape);
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_shapes, &geom->sz_shapes,
+                             (char **)&geom->shapes, sizeof(XkbShapeRec),
+                             _XkbClearShape);
 }
 
 void
-XkbcFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
+XkbcFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count,
+                        Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&row->num_keys,&row->sz_keys,
-				(char **)&row->keys,
-				sizeof(XkbOverlayKeyRec));
-    return;
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &row->num_keys, &row->sz_keys,
+                          (char **)&row->keys, sizeof(XkbOverlayKeyRec));
 }
 
 
 static void
 _XkbClearOverlayRow(char *row_in)
 {
-XkbOverlayRowPtr	row= (XkbOverlayRowPtr)row_in;
+    XkbOverlayRowPtr row = (XkbOverlayRowPtr)row_in;
 
-    if (row->keys!=NULL)
-	XkbcFreeGeomOverlayKeys(row,0,row->num_keys,True);
-    return;
+    if (row->keys)
+        XkbcFreeGeomOverlayKeys(row, 0, row->num_keys, True);
 }
 
 void
-XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
+XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count,
+                        Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&overlay->num_rows,&overlay->sz_rows,
-				(char **)&overlay->rows,
-				sizeof(XkbOverlayRowRec),_XkbClearOverlayRow);
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &overlay->num_rows, &overlay->sz_rows,
+                             (char **)&overlay->rows,
+                             sizeof(XkbOverlayRowRec),
+                             _XkbClearOverlayRow);
 }
 
 
 static void
 _XkbClearOverlay(char *overlay_in)
 {
-XkbOverlayPtr	overlay= (XkbOverlayPtr)overlay_in;
+    XkbOverlayPtr overlay = (XkbOverlayPtr)overlay_in;
 
-    if (overlay->rows!=NULL)
-	XkbcFreeGeomOverlayRows(overlay,0,overlay->num_rows,True);
-    return;
+    if (overlay->rows)
+        XkbcFreeGeomOverlayRows(overlay, 0, overlay->num_rows, True);
 }
 
 void
-XkbcFreeGeomOverlays(XkbSectionPtr section,int first,int	count,Bool freeAll)
+XkbcFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&section->num_overlays,&section->sz_overlays,
-				(char **)&section->overlays,
-				sizeof(XkbOverlayRec),_XkbClearOverlay);
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &section->num_overlays, &section->sz_overlays,
+                             (char **)&section->overlays,
+                             sizeof(XkbOverlayRec),
+                             _XkbClearOverlay);
 }
 
 
 void
-XkbcFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
+XkbcFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomLeafElems(freeAll,first,count,
-				&row->num_keys,&row->sz_keys,
-				(char **)&row->keys,
-				sizeof(XkbKeyRec));
-    return;
+    _XkbFreeGeomLeafElems(freeAll, first, count,
+                          &row->num_keys, &row->sz_keys,
+                          (char **)&row->keys, sizeof(XkbKeyRec));
 }
 
 
 static void
 _XkbClearRow(char *row_in)
 {
-XkbRowPtr	row= (XkbRowPtr)row_in;
+    XkbRowPtr row = (XkbRowPtr)row_in;
 
-    if (row->keys!=NULL)
-	XkbcFreeGeomKeys(row,0,row->num_keys,True);
-    return;
+    if (row->keys)
+        XkbcFreeGeomKeys(row, 0, row->num_keys, True);
 }
 
 void
-XkbcFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
+XkbcFreeGeomRows(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);
 }
 
 
 static void
 _XkbClearSection(char *section_in)
 {
-XkbSectionPtr	section= (XkbSectionPtr)section_in;
+    XkbSectionPtr section = (XkbSectionPtr)section_in;
 
-    if (section->rows!=NULL)
-	XkbcFreeGeomRows(section,0,section->num_rows,True);
-    if (section->doodads!=NULL) {
-	XkbcFreeGeomDoodads(section->doodads,section->num_doodads,True);
-	section->doodads= NULL;
+    if (section->rows)
+        XkbcFreeGeomRows(section, 0, section->num_rows, True);
+    if (section->doodads) {
+        XkbcFreeGeomDoodads(section->doodads, section->num_doodads, True);
+        section->doodads = NULL;
     }
-    return;
 }
 
 void
-XkbcFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
+XkbcFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
 {
-    _XkbFreeGeomNonLeafElems(freeAll,first,count,
-				&geom->num_sections,&geom->sz_sections,
-				(char **)&geom->sections,
-				sizeof(XkbSectionRec),_XkbClearSection);
-    return;
+    _XkbFreeGeomNonLeafElems(freeAll, first, count,
+                             &geom->num_sections, &geom->sz_sections,
+                             (char **)&geom->sections, sizeof(XkbSectionRec),
+                             _XkbClearSection);
 }
 
 
 static void
 _XkbClearDoodad(char *doodad_in)
 {
-XkbDoodadPtr	doodad= (XkbDoodadPtr)doodad_in;
+    XkbDoodadPtr doodad = (XkbDoodadPtr)doodad_in;
 
     switch (doodad->any.type) {
-   	case XkbTextDoodad:
-	    {
-		if (doodad->text.text!=NULL) {
-		    _XkbFree(doodad->text.text);
-		    doodad->text.text= NULL;
-		}
-		if (doodad->text.font!=NULL) {
-		    _XkbFree(doodad->text.font);
-		    doodad->text.font= NULL;
-		}
-	    }
-	    break;
-   	case XkbLogoDoodad:
-	    {
-		if (doodad->logo.logo_name!=NULL) {
-		    _XkbFree(doodad->logo.logo_name);
-		    doodad->logo.logo_name= NULL;
-		}
-	    }
-	    break;
+    case XkbTextDoodad:
+        if (doodad->text.text) {
+            _XkbFree(doodad->text.text);
+            doodad->text.text = NULL;
+        }
+        if (doodad->text.font) {
+            _XkbFree(doodad->text.font);
+            doodad->text.font = NULL;
+        }
+        break;
+
+    case XkbLogoDoodad:
+        if (doodad->logo.logo_name) {
+            _XkbFree(doodad->logo.logo_name);
+            doodad->logo.logo_name = NULL;
+        }
+        break;
     }
-    return;
 }
 
 void
-XkbcFreeGeomDoodads(XkbDoodadPtr doodads,int nDoodads,Bool freeAll)
+XkbcFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
 {
-register int 		i;
-register XkbDoodadPtr	doodad;
+    int i;
+    XkbDoodadPtr doodad;
 
     if (doodads) {
-	for (i=0,doodad= doodads;i<nDoodads;i++,doodad++) {
-	    _XkbClearDoodad((char *)doodad);
-	}
-	if (freeAll)
-	    _XkbFree(doodads);
+        for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++)
+            _XkbClearDoodad((char *)doodad);
+        if (freeAll)
+            _XkbFree(doodads);
     }
-    return;
 }
 
 void
-XkbcFreeGeometry(XkbGeometryPtr geom,unsigned which,Bool freeMap)
+XkbcFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
 {
-    if (geom==NULL)
-	return;
+    if (!geom)
+        return;
+
     if (freeMap)
-	which= XkbGeomAllMask;
-    if ((which&XkbGeomPropertiesMask)&&(geom->properties!=NULL))
-	XkbcFreeGeomProperties(geom,0,geom->num_properties,True);
-    if ((which&XkbGeomColorsMask)&&(geom->colors!=NULL))
-	XkbcFreeGeomColors(geom,0,geom->num_colors,True);
-    if ((which&XkbGeomShapesMask)&&(geom->shapes!=NULL))
-	XkbcFreeGeomShapes(geom,0,geom->num_shapes,True);
-    if ((which&XkbGeomSectionsMask)&&(geom->sections!=NULL))
-	XkbcFreeGeomSections(geom,0,geom->num_sections,True);
-    if ((which&XkbGeomDoodadsMask)&&(geom->doodads!= NULL)) {
-	XkbcFreeGeomDoodads(geom->doodads,geom->num_doodads,True);
-	geom->doodads= NULL;
-	geom->num_doodads= geom->sz_doodads= 0;
+        which = XkbGeomAllMask;
+
+    if ((which & XkbGeomPropertiesMask) && geom->properties)
+        XkbcFreeGeomProperties(geom, 0, geom->num_properties, True);
+
+    if ((which & XkbGeomColorsMask) && geom->colors)
+        XkbcFreeGeomColors(geom, 0, geom->num_colors, True);
+
+    if ((which & XkbGeomShapesMask) && geom->shapes)
+        XkbcFreeGeomShapes(geom, 0, geom->num_shapes, True);
+
+    if ((which & XkbGeomSectionsMask) && geom->sections)
+        XkbcFreeGeomSections(geom, 0, geom->num_sections, True);
+
+    if ((which & XkbGeomDoodadsMask) && geom->doodads) {
+        XkbcFreeGeomDoodads(geom->doodads, geom->num_doodads, True);
+        geom->doodads = NULL;
+        geom->num_doodads = geom->sz_doodads = 0;
     }
-    if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL))
-	XkbcFreeGeomKeyAliases(geom,0,geom->num_key_aliases,True);
+
+    if ((which & XkbGeomKeyAliasesMask) && geom->key_aliases)
+        XkbcFreeGeomKeyAliases(geom, 0, geom->num_key_aliases, True);
+
     if (freeMap) {
-	if (geom->label_font!=NULL) {
-	    _XkbFree(geom->label_font);
-	    geom->label_font= NULL;
-	}
-	_XkbFree(geom);
+        if (geom->label_font) {
+            _XkbFree(geom->label_font);
+            geom->label_font = NULL;
+        }
+        _XkbFree(geom);
     }
-    return;
 }
 
 static int
-_XkbGeomAlloc(	char **		old,
-		unsigned short *	num,
-		unsigned short *	total,
-		int			num_new,
-		size_t			sz_elem)
+_XkbGeomAlloc(char **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 ((*num)+num_new<=(*total))
-	return Success;
+    if (!(*old))
+        *num = *total = 0;
 
-    *total= (*num)+num_new;
-    if ((*old)!=NULL)
-	 (*old)= (char *)_XkbRealloc((*old),(*total)*sz_elem);
-    else (*old)= (char *)_XkbCalloc((*total),sz_elem);
-    if ((*old)==NULL) {
-	*total= *num= 0;
-	return BadAlloc;
+    if ((*num) + num_new <= (*total))
+        return Success;
+
+    *total = (*num) + num_new;
+
+    if (*old)
+        *old = (char *)_XkbRealloc(*old, (*total) * sz_elem);
+    else
+        *old = (char *)_XkbCalloc(*total, sz_elem);
+    if (!(*old)) {
+        *total = *num = 0;
+        return BadAlloc;
     }
 
-    if (*num>0) {
-	char *tmp= (char *)(*old);
-	bzero(&tmp[sz_elem*(*num)],(num_new*sz_elem));
+    if (*num > 0) {
+        char *tmp = *old;
+        bzero(&tmp[sz_elem * (*num)], num_new * sz_elem);
     }
+
     return Success;
 }
 
-#define	_XkbAllocProps(g,n) _XkbGeomAlloc((char **)&(g)->properties,\
-				&(g)->num_properties,&(g)->sz_properties,\
-				(n),sizeof(XkbPropertyRec))
-#define	_XkbAllocColors(g,n) _XkbGeomAlloc((char **)&(g)->colors,\
-				&(g)->num_colors,&(g)->sz_colors,\
-				(n),sizeof(XkbColorRec))
-#define	_XkbAllocShapes(g,n) _XkbGeomAlloc((char **)&(g)->shapes,\
-				&(g)->num_shapes,&(g)->sz_shapes,\
-				(n),sizeof(XkbShapeRec))
-#define	_XkbAllocSections(g,n) _XkbGeomAlloc((char **)&(g)->sections,\
-				&(g)->num_sections,&(g)->sz_sections,\
-				(n),sizeof(XkbSectionRec))
-#define	_XkbAllocDoodads(g,n) _XkbGeomAlloc((char **)&(g)->doodads,\
-				&(g)->num_doodads,&(g)->sz_doodads,\
-				(n),sizeof(XkbDoodadRec))
-#define	_XkbAllocKeyAliases(g,n) _XkbGeomAlloc((char **)&(g)->key_aliases,\
-				&(g)->num_key_aliases,&(g)->sz_key_aliases,\
-				(n),sizeof(XkbKeyAliasRec))
+#define _XkbAllocProps(g, n)    _XkbGeomAlloc((char **)&(g)->properties, \
+                                              &(g)->num_properties, \
+                                              &(g)->sz_properties, \
+                                              (n), sizeof(XkbPropertyRec))
+#define _XkbAllocColors(g, n)   _XkbGeomAlloc((char **)&(g)->colors, \
+                                              &(g)->num_colors, \
+                                              &(g)->sz_colors, \
+                                              (n), sizeof(XkbColorRec))
+#define _XkbAllocShapes(g, n)   _XkbGeomAlloc((char **)&(g)->shapes, \
+                                              &(g)->num_shapes, \
+                                              &(g)->sz_shapes, \
+                                              (n), sizeof(XkbShapeRec))
+#define _XkbAllocSections(g, n) _XkbGeomAlloc((char **)&(g)->sections, \
+                                              &(g)->num_sections, \
+                                              &(g)->sz_sections, \
+                                              (n), sizeof(XkbSectionRec))
+#define _XkbAllocDoodads(g, n)  _XkbGeomAlloc((char **)&(g)->doodads, \
+                                              &(g)->num_doodads, \
+                                              &(g)->sz_doodads, \
+                                              (n), sizeof(XkbDoodadRec))
+#define _XkbAllocKeyAliases(g, n)   _XkbGeomAlloc((char **)&(g)->key_aliases, \
+                                                  &(g)->num_key_aliases, \
+                                                  &(g)->sz_key_aliases, \
+                                                  (n), sizeof(XkbKeyAliasRec))
 
-#define	_XkbAllocOutlines(s,n) _XkbGeomAlloc((char **)&(s)->outlines,\
-				&(s)->num_outlines,&(s)->sz_outlines,\
-				(n),sizeof(XkbOutlineRec))
-#define	_XkbAllocRows(s,n) _XkbGeomAlloc((char **)&(s)->rows,\
-				&(s)->num_rows,&(s)->sz_rows,\
-				(n),sizeof(XkbRowRec))
-#define	_XkbAllocPoints(o,n) _XkbGeomAlloc((char **)&(o)->points,\
-				&(o)->num_points,&(o)->sz_points,\
-				(n),sizeof(XkbPointRec))
-#define	_XkbAllocKeys(r,n) _XkbGeomAlloc((char **)&(r)->keys,\
-				&(r)->num_keys,&(r)->sz_keys,\
-				(n),sizeof(XkbKeyRec))
-#define	_XkbAllocOverlays(s,n) _XkbGeomAlloc((char **)&(s)->overlays,\
-				&(s)->num_overlays,&(s)->sz_overlays,\
-				(n),sizeof(XkbOverlayRec))
-#define	_XkbAllocOverlayRows(o,n) _XkbGeomAlloc((char **)&(o)->rows,\
-				&(o)->num_rows,&(o)->sz_rows,\
-				(n),sizeof(XkbOverlayRowRec))
-#define	_XkbAllocOverlayKeys(r,n) _XkbGeomAlloc((char **)&(r)->keys,\
-				&(r)->num_keys,&(r)->sz_keys,\
-				(n),sizeof(XkbOverlayKeyRec))
+#define _XkbAllocOutlines(s, n) _XkbGeomAlloc((char **)&(s)->outlines, \
+                                              &(s)->num_outlines, \
+                                              &(s)->sz_outlines, \
+                                              (n), sizeof(XkbOutlineRec))
+#define _XkbAllocRows(s, n)     _XkbGeomAlloc((char **)&(s)->rows, \
+                                              &(s)->num_rows, \
+                                              &(s)->sz_rows, \
+                                              (n), sizeof(XkbRowRec))
+#define _XkbAllocPoints(o, n)   _XkbGeomAlloc((char **)&(o)->points, \
+                                              &(o)->num_points, \
+                                              &(o)->sz_points, \
+                                              (n), sizeof(XkbPointRec))
+#define _XkbAllocKeys(r, n)     _XkbGeomAlloc((char **)&(r)->keys, \
+                                              &(r)->num_keys, \
+                                              &(r)->sz_keys, \
+                                              (n), sizeof(XkbKeyRec))
+#define _XkbAllocOverlays(s, n) _XkbGeomAlloc((char **)&(s)->overlays, \
+                                              &(s)->num_overlays, \
+                                              &(s)->sz_overlays, \
+                                              (n), sizeof(XkbOverlayRec))
+#define _XkbAllocOverlayRows(o, n)  _XkbGeomAlloc((char **)&(o)->rows, \
+                                                  &(o)->num_rows, \
+                                                  &(o)->sz_rows, \
+                                                  (n), sizeof(XkbOverlayRowRec))
+#define _XkbAllocOverlayKeys(r, n)  _XkbGeomAlloc((char **)&(r)->keys, \
+                                                  &(r)->num_keys, \
+                                                  &(r)->sz_keys, \
+                                                  (n), sizeof(XkbOverlayKeyRec))
 
 int
-XkbcAllocGeometry(XkbcDescPtr xkb,XkbGeometrySizesPtr sizes)
+XkbcAllocGeometry(XkbcDescPtr xkb, XkbGeometrySizesPtr sizes)
 {
-XkbGeometryPtr	geom;
-int		rtrn;
+    XkbGeometryPtr geom;
+    int rtrn;
 
-    if (xkb->geom==NULL) {
-	xkb->geom= _XkbTypedCalloc(1,XkbGeometryRec);
-	if (!xkb->geom)
-	    return BadAlloc;
-    }
-    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&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&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 (!xkb->geom) {
+        xkb->geom = _XkbTypedCalloc(1, XkbGeometryRec);
+        if (!xkb->geom)
+            return BadAlloc;
     }
+    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 & 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 & XkbGeomDoodadsMask) &&
+        ((rtrn = _XkbAllocDoodads(geom, sizes->num_doodads)) != Success))
+        goto bail;
+
+    if ((sizes->which & XkbGeomKeyAliasesMask) &&
+        ((rtrn = _XkbAllocKeyAliases(geom, sizes->num_key_aliases)) != Success))
+        goto bail;
+
     return Success;
-BAIL:
-    XkbcFreeGeometry(geom,XkbGeomAllMask,True);
-    xkb->geom= NULL;
+bail:
+    XkbcFreeGeometry(geom, XkbGeomAllMask, True);
+    xkb->geom = NULL;
     return rtrn;
 }