Convert to X.Org standard indentation style

Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>

1 files changed, 1085 insertions, 1044 deletions

diff --git a/src/xkmread.c b/src/xkmread.c
index 5df95aa..55a4436 100644
--- a/src/xkmread.c
+++ b/src/xkmread.c
@@ -60,11 +60,11 @@
 #include <X11/extensions/XKBgeom.h>
 
 Atom
-XkbInternAtom(Display *dpy,char *str,Bool only_if_exists)
+XkbInternAtom(Display * dpy, 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);
 }
 
 #endif
@@ -76,24 +76,25 @@ XkbInternAtom(Display *dpy,char *str,Bool only_if_exists)
 /***====================================================================***/
 
 static XPointer
-XkmInsureSize(XPointer oldPtr,int oldCount,int *newCountRtrn,int elemSize)
+XkmInsureSize(XPointer oldPtr, int oldCount, int *newCountRtrn, int elemSize)
 {
-int	newCount= *newCountRtrn;
+    int newCount = *newCountRtrn;
 
-    if (oldPtr==NULL) {
-	if (newCount==0)
-	    return NULL;
-	oldPtr= (XPointer)_XkbCalloc(newCount,elemSize);
+    if (oldPtr == NULL) {
+        if (newCount == 0)
+            return NULL;
+        oldPtr = (XPointer) _XkbCalloc(newCount, elemSize);
     }
-    else if (oldCount<newCount) {
-	oldPtr= (XPointer)_XkbRealloc(oldPtr,newCount*elemSize);
-	if (oldPtr!=NULL) {
-	    char *tmp= (char *)oldPtr;
-	    bzero(&tmp[oldCount*elemSize],(newCount-oldCount)*elemSize);
-	}
+    else if (oldCount < newCount) {
+        oldPtr = (XPointer) _XkbRealloc(oldPtr, newCount * elemSize);
+        if (oldPtr != NULL) {
+            char *tmp = (char *) oldPtr;
+
+            bzero(&tmp[oldCount * elemSize], (newCount - oldCount) * elemSize);
+        }
     }
-    else if (newCount<oldCount) {
-	*newCountRtrn= oldCount;
+    else if (newCount < oldCount) {
+        *newCountRtrn = oldCount;
     }
     return oldPtr;
 }
@@ -101,116 +102,122 @@ 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;
-    }
-    if (count>=max_len)	str[max_len-1]= '\0';
-    else		str[count]= '\0';
-    count= XkbPaddedSize(nRead)-nRead;
-    if (count>0)
-	nRead+= XkmSkipPadding(file,count);
+    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);
     return nRead;
 }
 
 /***====================================================================***/
 
 static int
-ReadXkmVirtualMods(FILE *file,XkbFileInfo *result,XkbChangesPtr changes)
+ReadXkmVirtualMods(FILE *file, XkbFileInfo *result, XkbChangesPtr changes)
 {
-register unsigned int i,bit;
-unsigned int	bound,named,tmp;
-int		nRead=0;
-XkbDescPtr	xkb;
-
-    xkb= result->xkb;
-    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++;
-	}
-    }
-    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(xkb->dpy,name,False);
-		if (changes)
-		    changes->names.changed_vmods|= bit;
-	    }
-	}
+    register unsigned int i, bit;
+    unsigned int bound, named, tmp;
+    int nRead = 0;
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    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++;
+        }
+    }
+    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(xkb->dpy, name, False);
+                if (changes)
+                    changes->names.changed_vmods |= bit;
+            }
+        }
     }
     return nRead;
 }
@@ -218,204 +225,212 @@ XkbDescPtr	xkb;
 /***====================================================================***/
 
 static int
-ReadXkmKeycodes(FILE *file,XkbFileInfo *result,XkbChangesPtr changes)
+ReadXkmKeycodes(FILE *file, XkbFileInfo *result, XkbChangesPtr changes)
 {
-register int	i;
-unsigned	minKC,maxKC,nAl;
-int		nRead=0;
-char 		name[100];
-XkbKeyNamePtr	pN;
-XkbDescPtr	xkb;
-
-    xkb= result->xkb;
-    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;
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    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 (name[0]!='\0') {
-	xkb->names->keycodes= XkbInternAtom(xkb->dpy,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;
-    }
-    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 (XkbAllocNames(xkb, WANTED, 0, nAl) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmKeycodes", 0);
+        return -1;
+    }
+    if (name[0] != '\0') {
+        xkb->names->keycodes = XkbInternAtom(xkb->dpy, 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;
+    }
+    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,XkbFileInfo *result,XkbChangesPtr changes)
+ReadXkmKeyTypes(FILE *file, XkbFileInfo *result, 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];
-XkbDescPtr		xkb;
-
-    xkb= result->xkb;
-    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];
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    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(xkb->dpy, 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;
+    }
+    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;
         }
-	xkb->names->types= XkbInternAtom(xkb->dpy,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;
-    }
-    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(xkb->dpy,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(xkb->dpy,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;
+        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(xkb->dpy, 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(xkb->dpy, 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;
 }
@@ -423,631 +438,655 @@ XkbDescPtr		xkb;
 /***====================================================================***/
 
 static int
-ReadXkmCompatMap(FILE *file,XkbFileInfo *result,XkbChangesPtr changes)
+ReadXkmCompatMap(FILE *file, XkbFileInfo *result, XkbChangesPtr changes)
 {
-register int		i;
-unsigned		num_si,groups;
-char 			name[100];
-XkbSymInterpretPtr	interp;
-xkmSymInterpretDesc	wire;
-unsigned		tmp;
-int			nRead=0;
-XkbDescPtr		xkb;
-XkbCompatMapPtr		compat;
-
-    xkb= result->xkb;
-    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(xkb->dpy,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= num_si;
-    interp= compat->sym_interpret;
-    for (i=0;i<num_si;i++,interp++) {
-	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;
-	interp->act.data[0]= wire.actionData[0];
-	interp->act.data[1]= wire.actionData[1];
-	interp->act.data[2]= wire.actionData[2];
-	interp->act.data[3]= wire.actionData[3];
-	interp->act.data[4]= wire.actionData[4];
-	interp->act.data[5]= wire.actionData[5];
-	interp->act.data[6]= wire.actionData[6];
-    }
-    if ((num_si>0)&&(changes)) {
-	changes->compat.first_si= 0;
-	changes->compat.num_si= num_si;
+    register int i;
+    unsigned num_si, groups;
+    char name[100];
+    XkbSymInterpretPtr interp;
+    xkmSymInterpretDesc wire;
+    unsigned tmp;
+    int nRead = 0;
+    XkbDescPtr xkb;
+    XkbCompatMapPtr compat;
+
+    xkb = result->xkb;
+    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(xkb->dpy, 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 = num_si;
+    interp = compat->sym_interpret;
+    for (i = 0; i < num_si; i++, interp++) {
+        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;
+        interp->act.data[0] = wire.actionData[0];
+        interp->act.data[1] = wire.actionData[1];
+        interp->act.data[2] = wire.actionData[2];
+        interp->act.data[3] = wire.actionData[3];
+        interp->act.data[4] = wire.actionData[4];
+        interp->act.data[5] = wire.actionData[5];
+        interp->act.data[6] = wire.actionData[6];
+    }
+    if ((num_si > 0) && (changes)) {
+        changes->compat.first_si = 0;
+        changes->compat.num_si = 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,XkbFileInfo *result,XkbChangesPtr changes)
+ReadXkmIndicators(FILE *file, XkbFileInfo *result, XkbChangesPtr changes)
 {
-register unsigned	nLEDs;
-xkmIndicatorMapDesc	wire;
-char			buf[100];
-unsigned		tmp;
-int			nRead=0;
-XkbDescPtr		xkb;
-
-    xkb= result->xkb;
-    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;
-    }
-    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(xkb->dpy,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;
+    register unsigned nLEDs;
+    xkmIndicatorMapDesc wire;
+    char buf[100];
+    unsigned tmp;
+    int nRead = 0;
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    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;
+    }
+    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(xkb->dpy, 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) || (!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) {
 #ifdef DEBUG
-		if (xkb->map->types[i].num_levels!=width)
-		    fprintf(stderr,"Group width mismatch between key and type\n");
+                if (xkb->map->types[i].num_levels != width)
+                    fprintf(stderr,
+                            "Group width mismatch between key and type\n");
 #endif
-		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];
+                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];
     }
     return &xkb->map->types[XkbTwoLevelIndex];
 }
 
 static int
-ReadXkmSymbols(FILE *file,XkbFileInfo *result)
+ReadXkmSymbols(FILE *file, XkbFileInfo *result)
 {
-register int		i,g,s,totalVModMaps;
-xkmKeySymMapDesc 	wireMap;
-char 			buf[100];
-unsigned		minKC,maxKC,groupNames,tmp;
-int			nRead=0;
-XkbDescPtr		xkb;
-
-    xkb= result->xkb;
-    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;
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    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;
-    }
-    if ((buf[0]!='\0')&&(xkb->names)) {
-	Atom name;
-	name= XkbInternAtom(xkb->dpy,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 ((buf[0]!='\0')&&(xkb->names)) {
-		Atom name;
-		name= XkbInternAtom(xkb->dpy,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 (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"client map",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;
-    }
-    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);
-	bzero((char *)typeName,XkbNumKbdGroups*sizeof(Atom));
-	bzero((char *)type,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(xkb->dpy,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;
-	}
+                      XkbSymbolsNameMask | XkbPhysSymbolsNameMask |
+                      XkbGroupNamesMask, 0, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "physical names", 0);
+        return -1;
+    }
+    if ((buf[0] != '\0') && (xkb->names)) {
+        Atom name;
+
+        name = XkbInternAtom(xkb->dpy, 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 ((buf[0] != '\0') && (xkb->names)) {
+                Atom name;
+
+                name = XkbInternAtom(xkb->dpy, 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 (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "client map", 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;
+    }
+    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);
+        bzero((char *) typeName, XkbNumKbdGroups * sizeof(Atom));
+        bzero((char *) type, 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(xkb->dpy, 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;
+        }
     }
     return nRead;
 }
 
 static int
-ReadXkmGeomDoodad(
-    FILE *		file,
-    Display *		dpy,
-    XkbGeometryPtr	geom,
-    XkbSectionPtr	section)
+ReadXkmGeomDoodad(FILE *file, Display *dpy,
+                  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(dpy,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(dpy, 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= _XkbDupString(buf);
-	    nRead+= XkmGetCountedString(file,buf,100);
-	    doodad->text.font= _XkbDupString(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= _XkbDupString(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 = _XkbDupString(buf);
+        nRead += XkmGetCountedString(file, buf, 100);
+        doodad->text.font = _XkbDupString(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 = _XkbDupString(buf);
+        break;
+    default:
+        /* report error? */
+        return nRead;
     }
     return nRead;
 }
 
 static int
-ReadXkmGeomOverlay(	FILE *		file,
-			Display *	dpy,
-			XkbGeometryPtr	geom,
-			XkbSectionPtr	section)
+ReadXkmGeomOverlay(FILE *file, Display *dpy,
+                   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(dpy,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(dpy, 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,
-			Display *	dpy,
-			XkbGeometryPtr	geom)
+ReadXkmGeomSection(FILE *file, Display *dpy, 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(dpy,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(dpy, 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;
-    }
-    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,dpy,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,dpy,geom,section);
-	    nRead+= tmp;
-	    if (tmp<1)
-		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;
+            }
+        }
+    }
+    if (sectionWire.num_doodads > 0) {
+        for (i = 0; i < sectionWire.num_doodads; i++) {
+            tmp = ReadXkmGeomDoodad(file, dpy, 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, dpy, geom, section);
+            nRead += tmp;
+            if (tmp < 1)
+                return nRead;
+        }
     }
     return nRead;
 }
 
 static int
-ReadXkmGeometry(FILE *file,XkbFileInfo *result)
+ReadXkmGeometry(FILE *file, XkbFileInfo *result)
 {
-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(result->xkb,&sizes)!=Success) {
-	_XkbLibError(_XkbErrBadAlloc,"ReadXkmGeometry",0);
-	return nRead;
-    }
-    geom= result->xkb->geom;
-    geom->name= XkbInternAtom(result->xkb->dpy,buf,False);
-    geom->width_mm= wireGeom.width_mm;
-    geom->height_mm= wireGeom.height_mm;
-    nRead+= XkmGetCountedString(file,buf,100);
-    geom->label_font= _XkbDupString(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;
-	    }
-	}
-    }
-    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(result->xkb->dpy,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,result->xkb->dpy,geom);
-	    nRead+= tmp;
-	    if (tmp==0)
-		return nRead;
-	}
-    }
-    if (wireGeom.num_doodads>0) {
-	for (i=0;i<wireGeom.num_doodads;i++) {
-	    tmp= ReadXkmGeomDoodad(file,result->xkb->dpy,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;
+    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(result->xkb, &sizes) != Success) {
+        _XkbLibError(_XkbErrBadAlloc, "ReadXkmGeometry", 0);
+        return nRead;
+    }
+    geom = result->xkb->geom;
+    geom->name = XkbInternAtom(result->xkb->dpy, buf, False);
+    geom->width_mm = wireGeom.width_mm;
+    geom->height_mm = wireGeom.height_mm;
+    nRead += XkmGetCountedString(file, buf, 100);
+    geom->label_font = _XkbDupString(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;
+            }
+        }
+    }
+    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(result->xkb->dpy, 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, result->xkb->dpy, geom);
+            nRead += tmp;
+            if (tmp == 0)
+                return nRead;
+        }
+    }
+    if (wireGeom.num_doodads > 0) {
+        for (i = 0; i < wireGeom.num_doodads; i++) {
+            tmp = ReadXkmGeomDoodad(file, result->xkb->dpy, 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;
     }
     return nRead;
 }
@@ -1055,167 +1094,168 @@ XkbGeometrySizesRec	sizes;
 Bool
 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;
 }
 
 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;
-    }
-    fread(file_info,SIZEOF(xkmFileInfo),1,file);
-    size_toc= file_info->num_toc;
-    if (size_toc>max_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;
+    }
+    fread(file_info, SIZEOF(xkmFileInfo), 1, file);
+    size_toc = file_info->num_toc;
+    if (size_toc > max_toc) {
 #ifdef DEBUG
-	fprintf(stderr,"Warning! Too many TOC entries; last %d ignored\n",
-							size_toc-max_toc);
+        fprintf(stderr, "Warning! Too many TOC entries; last %d ignored\n",
+                size_toc - max_toc);
 #endif
-	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;
 }
 
 xkmSectionInfo *
-XkmFindTOCEntry(xkmFileInfo *finfo,xkmSectionInfo *toc,unsigned type)
+XkmFindTOCEntry(xkmFileInfo *finfo, xkmSectionInfo *toc, unsigned type)
 {
-register int i;
+    register int i;
 
-    for (i=0;i<finfo->num_toc;i++) {
-	if (toc[i].type==type)
-	    return &toc[i];
+    for (i = 0; i < finfo->num_toc; i++) {
+        if (toc[i].type == type)
+            return &toc[i];
     }
     return NULL;
 }
 
 Bool
-XkmReadFileSection(	FILE *			file,
-			xkmSectionInfo *	toc,
-			XkbFileInfo *		result,
-			unsigned *		loaded_rtrn)
+XkmReadFileSection(FILE *           file,
+                   xkmSectionInfo * toc,
+                   XkbFileInfo *    result,
+                   unsigned *       loaded_rtrn)
 {
-xkmSectionInfo		tmpTOC;
-int			nRead;
+    xkmSectionInfo tmpTOC;
+    int nRead;
 
-    if ((!result)||(!result->xkb)) {
-	_XkbLibError(_XkbErrBadMatch,"XkmReadFileSection",0);
-	return 0;
+    if ((!result) || (!result->xkb)) {
+        _XkbLibError(_XkbErrBadMatch, "XkmReadFileSection", 0);
+        return 0;
     }
-    fseek(file,toc->offset,SEEK_SET);
-    fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file);
-    nRead= SIZEOF(xkmSectionInfo);
-    if ((tmpTOC.type!=toc->type)||(tmpTOC.format!=toc->format)||
-	(tmpTOC.size!=toc->size)||(tmpTOC.offset!=toc->offset)) {
-	_XkbLibError(_XkbErrIllegalContents,"XkmReadFileSection",0);
-	return 0;
+    fseek(file, toc->offset, SEEK_SET);
+    fread(&tmpTOC, SIZEOF(xkmSectionInfo), 1, file);
+    nRead = SIZEOF(xkmSectionInfo);
+    if ((tmpTOC.type != toc->type) || (tmpTOC.format != toc->format) ||
+        (tmpTOC.size != toc->size) || (tmpTOC.offset != toc->offset)) {
+        _XkbLibError(_XkbErrIllegalContents, "XkmReadFileSection", 0);
+        return 0;
     }
     switch (tmpTOC.type) {
-	case XkmVirtualModsIndex:
-	    nRead+= ReadXkmVirtualMods(file,result,NULL);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmVirtualModsMask;
-	    break;
-	case XkmTypesIndex:
-	    nRead+= ReadXkmKeyTypes(file,result,NULL);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmTypesMask;
-	    break;
-	case XkmCompatMapIndex:
-	    nRead+= ReadXkmCompatMap(file,result,NULL);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmCompatMapMask;
-	    break;
-	case XkmKeyNamesIndex:
-	    nRead+= ReadXkmKeycodes(file,result,NULL);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmKeyNamesMask;
-	    break;
-	case XkmSymbolsIndex:
-	    nRead+= ReadXkmSymbols(file,result);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmSymbolsMask;
-	    break;
-	case XkmIndicatorsIndex:
-	    nRead+= ReadXkmIndicators(file,result,NULL);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmIndicatorsMask;
-	    break;
-	case XkmGeometryIndex:
-	    nRead+= ReadXkmGeometry(file,result);
-	    if ((loaded_rtrn)&&(nRead>=0))
-		*loaded_rtrn|= XkmGeometryMask;
-	    break;
-	default:
-	    _XkbLibError(_XkbErrBadImplementation,
-	    			XkbConfigText(tmpTOC.type,XkbMessage),0);
-	    nRead= 0;
-	    break;
-    }
-    if (nRead!=tmpTOC.size) {
-	_XkbLibError(_XkbErrBadLength,XkbConfigText(tmpTOC.type,XkbMessage),
-						nRead-tmpTOC.size);
-	return 0;
-    }
-    return (nRead>=0);
+    case XkmVirtualModsIndex:
+        nRead += ReadXkmVirtualMods(file, result, NULL);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmVirtualModsMask;
+        break;
+    case XkmTypesIndex:
+        nRead += ReadXkmKeyTypes(file, result, NULL);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmTypesMask;
+        break;
+    case XkmCompatMapIndex:
+        nRead += ReadXkmCompatMap(file, result, NULL);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmCompatMapMask;
+        break;
+    case XkmKeyNamesIndex:
+        nRead += ReadXkmKeycodes(file, result, NULL);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmKeyNamesMask;
+        break;
+    case XkmSymbolsIndex:
+        nRead += ReadXkmSymbols(file, result);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmSymbolsMask;
+        break;
+    case XkmIndicatorsIndex:
+        nRead += ReadXkmIndicators(file, result, NULL);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmIndicatorsMask;
+        break;
+    case XkmGeometryIndex:
+        nRead += ReadXkmGeometry(file, result);
+        if ((loaded_rtrn) && (nRead >= 0))
+            *loaded_rtrn |= XkmGeometryMask;
+        break;
+    default:
+        _XkbLibError(_XkbErrBadImplementation,
+                     XkbConfigText(tmpTOC.type, XkbMessage), 0);
+        nRead = 0;
+        break;
+    }
+    if (nRead != tmpTOC.size) {
+        _XkbLibError(_XkbErrBadLength, XkbConfigText(tmpTOC.type, XkbMessage),
+                     nRead - tmpTOC.size);
+        return 0;
+    }
+    return (nRead >= 0);
 }
 
 char *
-XkmReadFileSectionName(FILE *file,xkmSectionInfo *toc)
+XkmReadFileSectionName(FILE *file, xkmSectionInfo *toc)
 {
-xkmSectionInfo	tmpTOC;
-char 		name[100];
+    xkmSectionInfo tmpTOC;
+    char name[100];
 
-    if ((!file)||(!toc))
-	return NULL;
+    if ((!file) || (!toc))
+        return NULL;
     switch (toc->type) {
-	case XkmVirtualModsIndex:
-	case XkmIndicatorsIndex:
-	    break;
-	case XkmTypesIndex:
-	case XkmCompatMapIndex:
-	case XkmKeyNamesIndex:
-	case XkmSymbolsIndex:
-	case XkmGeometryIndex:
-	    fseek(file,toc->offset,SEEK_SET);
-	    fread(&tmpTOC,SIZEOF(xkmSectionInfo),1,file);
-	    if ((tmpTOC.type!=toc->type)||(tmpTOC.format!=toc->format)||
-		(tmpTOC.size!=toc->size)||(tmpTOC.offset!=toc->offset)) {
-		_XkbLibError(_XkbErrIllegalContents,"XkmReadFileSectionName",0);
-		return NULL;
-	    }
-	    if (XkmGetCountedString(file,name,100)>0)
-		return _XkbDupString(name);
-	    break;
-	default:
-	    _XkbLibError(_XkbErrBadImplementation,
-				XkbConfigText(tmpTOC.type,XkbMessage),0);
-	    break;
+    case XkmVirtualModsIndex:
+    case XkmIndicatorsIndex:
+        break;
+    case XkmTypesIndex:
+    case XkmCompatMapIndex:
+    case XkmKeyNamesIndex:
+    case XkmSymbolsIndex:
+    case XkmGeometryIndex:
+        fseek(file, toc->offset, SEEK_SET);
+        fread(&tmpTOC, SIZEOF(xkmSectionInfo), 1, file);
+        if ((tmpTOC.type != toc->type) || (tmpTOC.format != toc->format) ||
+            (tmpTOC.size != toc->size) || (tmpTOC.offset != toc->offset)) {
+            _XkbLibError(_XkbErrIllegalContents, "XkmReadFileSectionName", 0);
+            return NULL;
+        }
+        if (XkmGetCountedString(file, name, 100) > 0)
+            return _XkbDupString(name);
+        break;
+    default:
+        _XkbLibError(_XkbErrBadImplementation,
+                     XkbConfigText(tmpTOC.type, XkbMessage), 0);
+        break;
     }
     return NULL;
 }
@@ -1224,76 +1264,77 @@ char 		name[100];
 
 #define	MAX_TOC	16
 unsigned
-XkmReadFile(FILE *file,unsigned need,unsigned want,XkbFileInfo *result)
+XkmReadFile(FILE *file, unsigned need, unsigned want, XkbFileInfo *result)
 {
-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;
-    }
-    result->type= fileInfo.type;
-    if (result->xkb==NULL)
-	result->xkb= XkbAllocKeyboard();
-    for (i=0;i<fileInfo.num_toc;i++) {
+    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;
+    }
+    result->type = fileInfo.type;
+    if (result->xkb == NULL)
+        result->xkb = XkbAllocKeyboard();
+    for (i = 0; i < fileInfo.num_toc; i++) {
 #ifdef SEEK_SET
-	fseek(file,toc[i].offset,SEEK_SET);
+        fseek(file, toc[i].offset, SEEK_SET);
 #else
-	fseek(file,toc[i].offset,0);
+        fseek(file, toc[i].offset, 0);
 #endif
-	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,result,NULL);
-		break;
-	    case XkmTypesIndex:
-		tmp= ReadXkmKeyTypes(file,result,NULL);
-		break;
-	    case XkmCompatMapIndex:
-		tmp= ReadXkmCompatMap(file,result,NULL);
-		break;
-	    case XkmKeyNamesIndex:
-		tmp= ReadXkmKeycodes(file,result,NULL);
-		break;
-	    case XkmIndicatorsIndex:
-		tmp= ReadXkmIndicators(file,result,NULL);
-		break;
-	    case XkmSymbolsIndex:
-		tmp= ReadXkmSymbols(file,result);
-		break;
-	    case XkmGeometryIndex:
-		tmp= ReadXkmGeometry(file,result);
-		break;
-	    default:
-		_XkbLibError(_XkbErrBadImplementation,
-				XkbConfigText(tmpTOC.type,XkbMessage),0);
-		tmp= 0;
-		break;
-	}
-	if (tmp>0) {
-	    nRead+= tmp;
-	    which&= ~(1<<toc[i].type);
-	    result->defined|= (1<<toc[i].type);
-	}
-	if (nRead!=tmpTOC.size) {
-	    _XkbLibError(_XkbErrBadLength,XkbConfigText(tmpTOC.type,XkbMessage),
-	    						nRead-tmpTOC.size);
-	}
+        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, result, NULL);
+            break;
+        case XkmTypesIndex:
+            tmp = ReadXkmKeyTypes(file, result, NULL);
+            break;
+        case XkmCompatMapIndex:
+            tmp = ReadXkmCompatMap(file, result, NULL);
+            break;
+        case XkmKeyNamesIndex:
+            tmp = ReadXkmKeycodes(file, result, NULL);
+            break;
+        case XkmIndicatorsIndex:
+            tmp = ReadXkmIndicators(file, result, NULL);
+            break;
+        case XkmSymbolsIndex:
+            tmp = ReadXkmSymbols(file, result);
+            break;
+        case XkmGeometryIndex:
+            tmp = ReadXkmGeometry(file, result);
+            break;
+        default:
+            _XkbLibError(_XkbErrBadImplementation,
+                         XkbConfigText(tmpTOC.type, XkbMessage), 0);
+            tmp = 0;
+            break;
+        }
+        if (tmp > 0) {
+            nRead += tmp;
+            which &= ~(1 << toc[i].type);
+            result->defined |= (1 << toc[i].type);
+        }
+        if (nRead != tmpTOC.size) {
+            _XkbLibError(_XkbErrBadLength,
+                         XkbConfigText(tmpTOC.type, XkbMessage),
+                         nRead - tmpTOC.size);
+        }
     }
     return which;
 }