Indent fixes.

indent -cbi 0 -nprs -nut -npcs -i4 -bli 0 *.c *.h

1 files changed, 707 insertions, 607 deletions

diff --git a/compat.c b/compat.c
index b1ab121..b20610b 100644
--- a/compat.c
+++ b/compat.c
@@ -33,9 +33,10 @@
 #include "indicators.h"
 #include "action.h"
 
-typedef struct _SymInterpInfo {
-    CommonInfo		defs;
-    XkbSymInterpretRec	interp;
+typedef struct _SymInterpInfo
+{
+    CommonInfo defs;
+    XkbSymInterpretRec interp;
 } SymInterpInfo;
 
 #define	_SI_VirtualMod		(1<<0)
@@ -44,26 +45,28 @@ typedef struct _SymInterpInfo {
 #define	_SI_LockingKey		(1<<3)
 #define	_SI_LevelOneOnly	(1<<4)
 
-typedef struct _GroupCompatInfo {
-    unsigned char	fileID;
-    unsigned char	merge;
-    unsigned char	real_mods;
-    unsigned short	vmods;
+typedef struct _GroupCompatInfo
+{
+    unsigned char fileID;
+    unsigned char merge;
+    unsigned char real_mods;
+    unsigned short vmods;
 } GroupCompatInfo;
 
-typedef struct _CompatInfo {
-    char *		name;
-    unsigned 		fileID;
-    int			errorCount;
-    int			nInterps;
-    SymInterpInfo *	interps;
-    SymInterpInfo 	dflt;
-    LEDInfo		ledDflt;
-    GroupCompatInfo	groupCompat[XkbNumKbdGroups];
-    LEDInfo *		leds;
-    VModInfo		vmods;
-    ActionInfo *	act;
-    XkbDescPtr		xkb;
+typedef struct _CompatInfo
+{
+    char *name;
+    unsigned fileID;
+    int errorCount;
+    int nInterps;
+    SymInterpInfo *interps;
+    SymInterpInfo dflt;
+    LEDInfo ledDflt;
+    GroupCompatInfo groupCompat[XkbNumKbdGroups];
+    LEDInfo *leds;
+    VModInfo vmods;
+    ActionInfo *act;
+    XkbDescPtr xkb;
 } CompatInfo;
 
 /***====================================================================***/
@@ -76,234 +79,264 @@ typedef struct _CompatInfo {
 /***====================================================================***/
 
 static char *
-siText(SymInterpInfo *	si,CompatInfo *	info)
+siText(SymInterpInfo * si, CompatInfo * info)
 {
-static char buf[128];
+    static char buf[128];
 
-    if (si==&info->dflt) {
-	sprintf(buf,"default");
+    if (si == &info->dflt)
+    {
+        sprintf(buf, "default");
     }
-    else {
-	sprintf(buf,"%s+%s(%s)",XkbKeysymText(si->interp.sym,XkbMessage),
-				XkbSIMatchText(si->interp.match,XkbMessage),
-				XkbModMaskText(si->interp.mods,XkbMessage));
+    else
+    {
+        sprintf(buf, "%s+%s(%s)", XkbKeysymText(si->interp.sym, XkbMessage),
+                XkbSIMatchText(si->interp.match, XkbMessage),
+                XkbModMaskText(si->interp.mods, XkbMessage));
     }
     return buf;
 }
 
 static void
-InitCompatInfo(CompatInfo *info,XkbDescPtr xkb)
+InitCompatInfo(CompatInfo * info, XkbDescPtr xkb)
 {
-register int i;
-
-    info->xkb= xkb;
-    info->name= NULL;
-    info->fileID= 0;
-    info->errorCount= 0;
-    info->nInterps= 0;
-    info->interps= NULL;
-    info->act= NULL;
-    info->dflt.defs.fileID= info->fileID;
-    info->dflt.defs.defined= 0;
-    info->dflt.defs.merge= MergeOverride;
-    info->dflt.interp.flags=	0;
-    info->dflt.interp.virtual_mod= XkbNoModifier;
-    info->dflt.interp.act.type= XkbSA_NoAction;
-    for (i=0;i<XkbAnyActionDataSize;i++) {
-	info->dflt.interp.act.data[i]= 0;
-    }
-    ClearIndicatorMapInfo(xkb->dpy,&info->ledDflt);
-    info->ledDflt.defs.fileID= info->fileID;
-    info->ledDflt.defs.defined= 0;
-    info->ledDflt.defs.merge= MergeOverride;
-    bzero((char *)&info->groupCompat[0],XkbNumKbdGroups*sizeof(GroupCompatInfo));
-    info->leds= NULL;
-    InitVModInfo(&info->vmods,xkb);
+    register int i;
+
+    info->xkb = xkb;
+    info->name = NULL;
+    info->fileID = 0;
+    info->errorCount = 0;
+    info->nInterps = 0;
+    info->interps = NULL;
+    info->act = NULL;
+    info->dflt.defs.fileID = info->fileID;
+    info->dflt.defs.defined = 0;
+    info->dflt.defs.merge = MergeOverride;
+    info->dflt.interp.flags = 0;
+    info->dflt.interp.virtual_mod = XkbNoModifier;
+    info->dflt.interp.act.type = XkbSA_NoAction;
+    for (i = 0; i < XkbAnyActionDataSize; i++)
+    {
+        info->dflt.interp.act.data[i] = 0;
+    }
+    ClearIndicatorMapInfo(xkb->dpy, &info->ledDflt);
+    info->ledDflt.defs.fileID = info->fileID;
+    info->ledDflt.defs.defined = 0;
+    info->ledDflt.defs.merge = MergeOverride;
+    bzero((char *) &info->groupCompat[0],
+          XkbNumKbdGroups * sizeof(GroupCompatInfo));
+    info->leds = NULL;
+    InitVModInfo(&info->vmods, xkb);
     return;
 }
 
 static void
-ClearCompatInfo(CompatInfo *info,XkbDescPtr xkb)
+ClearCompatInfo(CompatInfo * info, XkbDescPtr xkb)
 {
-register int i;
-
-    if (info->name!=NULL)
-	uFree(info->name);
-    info->name= NULL;
-    info->dflt.defs.defined= 0;
-    info->dflt.defs.merge= MergeAugment;
-    info->dflt.interp.flags= 0;
-    info->dflt.interp.virtual_mod= XkbNoModifier;
-    info->dflt.interp.act.type= XkbSA_NoAction;
-    for (i=0;i<XkbAnyActionDataSize;i++) {
-	info->dflt.interp.act.data[i]= 0;
-    }
-    ClearIndicatorMapInfo(xkb->dpy,&info->ledDflt);
-    info->nInterps= 0;
-    info->interps= (SymInterpInfo *)ClearCommonInfo(&info->interps->defs);
-    bzero((char *)&info->groupCompat[0],XkbNumKbdGroups*sizeof(GroupCompatInfo));
-    info->leds= (LEDInfo *)ClearCommonInfo(&info->leds->defs);
+    register int i;
+
+    if (info->name != NULL)
+        uFree(info->name);
+    info->name = NULL;
+    info->dflt.defs.defined = 0;
+    info->dflt.defs.merge = MergeAugment;
+    info->dflt.interp.flags = 0;
+    info->dflt.interp.virtual_mod = XkbNoModifier;
+    info->dflt.interp.act.type = XkbSA_NoAction;
+    for (i = 0; i < XkbAnyActionDataSize; i++)
+    {
+        info->dflt.interp.act.data[i] = 0;
+    }
+    ClearIndicatorMapInfo(xkb->dpy, &info->ledDflt);
+    info->nInterps = 0;
+    info->interps = (SymInterpInfo *) ClearCommonInfo(&info->interps->defs);
+    bzero((char *) &info->groupCompat[0],
+          XkbNumKbdGroups * sizeof(GroupCompatInfo));
+    info->leds = (LEDInfo *) ClearCommonInfo(&info->leds->defs);
     /* 3/30/94 (ef) -- XXX! Should free action info here */
-    ClearVModInfo(&info->vmods,xkb);
+    ClearVModInfo(&info->vmods, xkb);
     return;
 }
 
 static SymInterpInfo *
-NextInterp(CompatInfo *info)
+NextInterp(CompatInfo * info)
 {
-SymInterpInfo *	si;
+    SymInterpInfo *si;
 
-    si= uTypedAlloc(SymInterpInfo);
-    if (si) {
-	bzero((char *)si,sizeof(SymInterpInfo));
-	info->interps= (SymInterpInfo *)AddCommonInfo(&info->interps->defs,
-							(CommonInfo *)si);
-	info->nInterps++;
+    si = uTypedAlloc(SymInterpInfo);
+    if (si)
+    {
+        bzero((char *) si, sizeof(SymInterpInfo));
+        info->interps =
+            (SymInterpInfo *) AddCommonInfo(&info->interps->defs,
+                                            (CommonInfo *) si);
+        info->nInterps++;
     }
     return si;
 }
 
 static SymInterpInfo *
-FindMatchingInterp(CompatInfo *info,SymInterpInfo *new)
+FindMatchingInterp(CompatInfo * info, SymInterpInfo * new)
 {
-SymInterpInfo *	old;
-
-    for (old= info->interps;old!=NULL;old=(SymInterpInfo *)old->defs.next) {
-	if ((old->interp.sym==new->interp.sym)&&
-				(old->interp.mods==new->interp.mods)&&
-				(old->interp.match==new->interp.match)) {
-	    return  old;
-	}
+    SymInterpInfo *old;
+
+    for (old = info->interps; old != NULL;
+         old = (SymInterpInfo *) old->defs.next)
+    {
+        if ((old->interp.sym == new->interp.sym) &&
+            (old->interp.mods == new->interp.mods) &&
+            (old->interp.match == new->interp.match))
+        {
+            return old;
+        }
     }
     return NULL;
 }
 
 static Bool
-AddInterp(CompatInfo *info,SymInterpInfo *new)
+AddInterp(CompatInfo * info, SymInterpInfo * new)
 {
-unsigned		collide;
-SymInterpInfo	*	old;
-
-    collide= 0;
-    old= FindMatchingInterp(info,new);
-    if (old!=NULL) {
-	if (new->defs.merge==MergeReplace) {
-	    SymInterpInfo *next= (SymInterpInfo *)old->defs.next;
-	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
-		    					(warningLevel>9)) {
-		WARN1("Multiple definitions for \"%s\"\n",siText(new,info));
-		ACTION("Earlier interpretation ignored\n");
-	    }
-	    *old= *new;
-	    old->defs.next= &next->defs;
-	    return True;
-	}
-	if (UseNewField(_SI_VirtualMod,&old->defs,&new->defs,&collide)) {
-	    old->interp.virtual_mod= new->interp.virtual_mod;
-	    old->defs.defined|= _SI_VirtualMod;
-	}
-	if (UseNewField(_SI_Action,&old->defs,&new->defs,&collide)) {
-	    old->interp.act= new->interp.act;
-	    old->defs.defined|= _SI_Action;
-	}
-	if (UseNewField(_SI_AutoRepeat,&old->defs,&new->defs,&collide)) {
-	    old->interp.flags&= ~XkbSI_AutoRepeat;
-	    old->interp.flags|= (new->interp.flags&XkbSI_AutoRepeat);
-	    old->defs.defined|= _SI_AutoRepeat;
-	}
-	if (UseNewField(_SI_LockingKey,&old->defs,&new->defs,&collide)) {
-	    old->interp.flags&= ~XkbSI_LockingKey;
-	    old->interp.flags|= (new->interp.flags&XkbSI_LockingKey);
-	    old->defs.defined|= _SI_LockingKey;
-	}
-	if (UseNewField(_SI_LevelOneOnly,&old->defs,&new->defs,&collide)) {
-	    old->interp.match&= ~XkbSI_LevelOneOnly;
-	    old->interp.match|= (new->interp.match&XkbSI_LevelOneOnly);
-	    old->defs.defined|= _SI_LevelOneOnly;
-	}
-	if (collide) {
-	    WARN1("Multiple interpretations of \"%s\"\n",siText(new,info));
-	    ACTION1("Using %s definition for duplicate fields\n",
-				(new->defs.merge!=MergeAugment?"last":"first"));
-	}
-	return True;
-    }
-    old= new;
-    if ((new= NextInterp(info))==NULL)
-	return False;
-    *new= *old;
-    new->defs.next= NULL;
+    unsigned collide;
+    SymInterpInfo *old;
+
+    collide = 0;
+    old = FindMatchingInterp(info, new);
+    if (old != NULL)
+    {
+        if (new->defs.merge == MergeReplace)
+        {
+            SymInterpInfo *next = (SymInterpInfo *) old->defs.next;
+            if (((old->defs.fileID == new->defs.fileID)
+                 && (warningLevel > 0)) || (warningLevel > 9))
+            {
+                WARN1("Multiple definitions for \"%s\"\n", siText(new, info));
+                ACTION("Earlier interpretation ignored\n");
+            }
+            *old = *new;
+            old->defs.next = &next->defs;
+            return True;
+        }
+        if (UseNewField(_SI_VirtualMod, &old->defs, &new->defs, &collide))
+        {
+            old->interp.virtual_mod = new->interp.virtual_mod;
+            old->defs.defined |= _SI_VirtualMod;
+        }
+        if (UseNewField(_SI_Action, &old->defs, &new->defs, &collide))
+        {
+            old->interp.act = new->interp.act;
+            old->defs.defined |= _SI_Action;
+        }
+        if (UseNewField(_SI_AutoRepeat, &old->defs, &new->defs, &collide))
+        {
+            old->interp.flags &= ~XkbSI_AutoRepeat;
+            old->interp.flags |= (new->interp.flags & XkbSI_AutoRepeat);
+            old->defs.defined |= _SI_AutoRepeat;
+        }
+        if (UseNewField(_SI_LockingKey, &old->defs, &new->defs, &collide))
+        {
+            old->interp.flags &= ~XkbSI_LockingKey;
+            old->interp.flags |= (new->interp.flags & XkbSI_LockingKey);
+            old->defs.defined |= _SI_LockingKey;
+        }
+        if (UseNewField(_SI_LevelOneOnly, &old->defs, &new->defs, &collide))
+        {
+            old->interp.match &= ~XkbSI_LevelOneOnly;
+            old->interp.match |= (new->interp.match & XkbSI_LevelOneOnly);
+            old->defs.defined |= _SI_LevelOneOnly;
+        }
+        if (collide)
+        {
+            WARN1("Multiple interpretations of \"%s\"\n", siText(new, info));
+            ACTION1("Using %s definition for duplicate fields\n",
+                    (new->defs.merge != MergeAugment ? "last" : "first"));
+        }
+        return True;
+    }
+    old = new;
+    if ((new = NextInterp(info)) == NULL)
+        return False;
+    *new = *old;
+    new->defs.next = NULL;
     return True;
 }
 
 static Bool
-AddGroupCompat(CompatInfo *info,unsigned group,GroupCompatInfo *newGC)
+AddGroupCompat(CompatInfo * info, unsigned group, GroupCompatInfo * newGC)
 {
-GroupCompatInfo *	gc;
-unsigned		merge;
-
-    merge= newGC->merge;
-    gc= &info->groupCompat[group];
-    if (((gc->real_mods==newGC->real_mods)&&(gc->vmods==newGC->vmods))) {
-	return True;
-    }
-    if (((gc->fileID==newGC->fileID)&&(warningLevel>0))||(warningLevel>9)) {
-	WARN1("Compat map for group %d redefined\n",group+1);
-	ACTION1("Using %s definition\n",(merge==MergeAugment?"old":"new"));
-    }
-    if (merge!=MergeAugment)
-	*gc= *newGC;
+    GroupCompatInfo *gc;
+    unsigned merge;
+
+    merge = newGC->merge;
+    gc = &info->groupCompat[group];
+    if (((gc->real_mods == newGC->real_mods) && (gc->vmods == newGC->vmods)))
+    {
+        return True;
+    }
+    if (((gc->fileID == newGC->fileID) && (warningLevel > 0))
+        || (warningLevel > 9))
+    {
+        WARN1("Compat map for group %d redefined\n", group + 1);
+        ACTION1("Using %s definition\n",
+                (merge == MergeAugment ? "old" : "new"));
+    }
+    if (merge != MergeAugment)
+        *gc = *newGC;
     return True;
 }
 
 /***====================================================================***/
 
 static Bool
-ResolveStateAndPredicate(	ExprDef *	expr,
-				unsigned *	pred_rtrn,
-				unsigned *	mods_rtrn,
-				CompatInfo *	info)
+ResolveStateAndPredicate(ExprDef * expr,
+                         unsigned *pred_rtrn,
+                         unsigned *mods_rtrn, CompatInfo * info)
 {
-ExprResult	result;
-
-    if (expr==NULL) {
-	*pred_rtrn= XkbSI_AnyOfOrNone;
-	*mods_rtrn= ~0;
-	return True;
-    }
-
-    *pred_rtrn= XkbSI_Exactly;
-    if (expr->op==ExprActionDecl) {
-	char *pred_txt= XkbAtomText(NULL,expr->value.action.name,XkbMessage);
-	if (uStrCaseCmp(pred_txt,"noneof")==0)
-	     *pred_rtrn= XkbSI_NoneOf;
-	else if (uStrCaseCmp(pred_txt,"anyofornone")==0)
-	     *pred_rtrn= XkbSI_AnyOfOrNone;
-	else if (uStrCaseCmp(pred_txt,"anyof")==0)
-	     *pred_rtrn= XkbSI_AnyOf;
-	else if (uStrCaseCmp(pred_txt,"allof")==0)
-	     *pred_rtrn= XkbSI_AllOf;
-	else if (uStrCaseCmp(pred_txt,"exactly")==0)
-	     *pred_rtrn= XkbSI_Exactly;
-	else {
-	     ERROR1("Illegal modifier predicate \"%s\"\n",pred_txt);
-	     ACTION("Ignored\n");
-	     return False;
-	}
-	expr= expr->value.action.args;
-    }
-    else if (expr->op==ExprIdent) {
-	char *pred_txt= XkbAtomText(NULL,expr->value.str,XkbMessage);
-	if ((pred_txt)&&(uStrCaseCmp(pred_txt,"any")==0)) {
-	    *pred_rtrn= XkbSI_AnyOf;
-	    *mods_rtrn= 0xff;
-	    return True;
-	}
-    }
-
-    if (ExprResolveModMask(expr,&result,NULL,NULL)) {
-	*mods_rtrn= result.uval;
-	return True;
+    ExprResult result;
+
+    if (expr == NULL)
+    {
+        *pred_rtrn = XkbSI_AnyOfOrNone;
+        *mods_rtrn = ~0;
+        return True;
+    }
+
+    *pred_rtrn = XkbSI_Exactly;
+    if (expr->op == ExprActionDecl)
+    {
+        char *pred_txt =
+            XkbAtomText(NULL, expr->value.action.name, XkbMessage);
+        if (uStrCaseCmp(pred_txt, "noneof") == 0)
+            *pred_rtrn = XkbSI_NoneOf;
+        else if (uStrCaseCmp(pred_txt, "anyofornone") == 0)
+            *pred_rtrn = XkbSI_AnyOfOrNone;
+        else if (uStrCaseCmp(pred_txt, "anyof") == 0)
+            *pred_rtrn = XkbSI_AnyOf;
+        else if (uStrCaseCmp(pred_txt, "allof") == 0)
+            *pred_rtrn = XkbSI_AllOf;
+        else if (uStrCaseCmp(pred_txt, "exactly") == 0)
+            *pred_rtrn = XkbSI_Exactly;
+        else
+        {
+            ERROR1("Illegal modifier predicate \"%s\"\n", pred_txt);
+            ACTION("Ignored\n");
+            return False;
+        }
+        expr = expr->value.action.args;
+    }
+    else if (expr->op == ExprIdent)
+    {
+        char *pred_txt = XkbAtomText(NULL, expr->value.str, XkbMessage);
+        if ((pred_txt) && (uStrCaseCmp(pred_txt, "any") == 0))
+        {
+            *pred_rtrn = XkbSI_AnyOf;
+            *mods_rtrn = 0xff;
+            return True;
+        }
+    }
+
+    if (ExprResolveModMask(expr, &result, NULL, NULL))
+    {
+        *mods_rtrn = result.uval;
+        return True;
     }
     return False;
 }
@@ -311,468 +344,535 @@ ExprResult	result;
 /***====================================================================***/
 
 static void
-MergeIncludedCompatMaps(	CompatInfo *	into,
-				CompatInfo *	from,
-				unsigned	merge)
+MergeIncludedCompatMaps(CompatInfo * into, CompatInfo * from, unsigned merge)
 {
-SymInterpInfo * 	si;
-LEDInfo *		led,*rtrn,*next;
-GroupCompatInfo *	gcm;
-register int		i;
-
-    if (from->errorCount>0) {
-	into->errorCount+= from->errorCount;
-	return;
-    }
-    if (into->name==NULL) {
-	into->name= from->name;
-	from->name= NULL;
-    }
-    for (si=from->interps;si;si=(SymInterpInfo *)si->defs.next) {
-	if (merge!=MergeDefault)
-	    si->defs.merge= merge;
-	if (!AddInterp(into,si))
-	    into->errorCount++;
-    }
-    for (i=0,gcm=&from->groupCompat[0];i<XkbNumKbdGroups;i++,gcm++) {
-	if (merge!=MergeDefault)
-	    gcm->merge= merge;
-	if (!AddGroupCompat(into,i,gcm))
-	    into->errorCount++;
-    }
-    for (led=from->leds;led!=NULL;led=next) {
-	next= (LEDInfo *)led->defs.next;
-	if (merge!=MergeDefault)
-	    led->defs.merge= merge;
-	rtrn= AddIndicatorMap(into->leds,led);
-	if (rtrn!=NULL) 
-	     into->leds= rtrn;
-	else into->errorCount++;
+    SymInterpInfo *si;
+    LEDInfo *led, *rtrn, *next;
+    GroupCompatInfo *gcm;
+    register int i;
+
+    if (from->errorCount > 0)
+    {
+        into->errorCount += from->errorCount;
+        return;
+    }
+    if (into->name == NULL)
+    {
+        into->name = from->name;
+        from->name = NULL;
+    }
+    for (si = from->interps; si; si = (SymInterpInfo *) si->defs.next)
+    {
+        if (merge != MergeDefault)
+            si->defs.merge = merge;
+        if (!AddInterp(into, si))
+            into->errorCount++;
+    }
+    for (i = 0, gcm = &from->groupCompat[0]; i < XkbNumKbdGroups; i++, gcm++)
+    {
+        if (merge != MergeDefault)
+            gcm->merge = merge;
+        if (!AddGroupCompat(into, i, gcm))
+            into->errorCount++;
+    }
+    for (led = from->leds; led != NULL; led = next)
+    {
+        next = (LEDInfo *) led->defs.next;
+        if (merge != MergeDefault)
+            led->defs.merge = merge;
+        rtrn = AddIndicatorMap(into->leds, led);
+        if (rtrn != NULL)
+            into->leds = rtrn;
+        else
+            into->errorCount++;
     }
     return;
 }
 
-typedef void	(*FileHandler)(
-	XkbFile *	/* rtrn */,
-	XkbDescPtr	/* xkb */,
-	unsigned	/* merge */,
-	CompatInfo *	/* info */
-);
+typedef void (*FileHandler) (XkbFile * /* rtrn */ ,
+                             XkbDescPtr /* xkb */ ,
+                             unsigned /* merge */ ,
+                             CompatInfo *       /* info */
+    );
 
 static Bool
-HandleIncludeCompatMap(	IncludeStmt *	  stmt,
-			XkbDescPtr	  xkb,
-			CompatInfo *	  info,
-			FileHandler	  hndlr)
+HandleIncludeCompatMap(IncludeStmt * stmt,
+                       XkbDescPtr xkb, CompatInfo * info, FileHandler hndlr)
 {
-unsigned 	newMerge;
-XkbFile	*	rtrn;
-CompatInfo	included;
-Bool		haveSelf;
-
-    haveSelf= False;
-    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
-	haveSelf= True;
-	included= *info;
-	bzero(info,sizeof(CompatInfo));
-    }
-    else if (ProcessIncludeFile(stmt,XkmCompatMapIndex,&rtrn,&newMerge)) {
-	InitCompatInfo(&included,xkb);
-	included.fileID= rtrn->id;
-	included.dflt= info->dflt;
-	included.dflt.defs.fileID= rtrn->id;
-	included.dflt.defs.merge= newMerge;
-	included.ledDflt.defs.fileID= rtrn->id;
-	included.ledDflt.defs.merge= newMerge;
-	included.act= info->act;
-	(*hndlr)(rtrn,xkb,MergeOverride,&included);
-	if (stmt->stmt!=NULL) {
-	    if (included.name!=NULL)
-		uFree(included.name);
-	    included.name= stmt->stmt;
-	    stmt->stmt= NULL;
-	}
-    }
-    else {
-	info->errorCount+= 10;
-	return False;
-    }
-    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
-	IncludeStmt *	next;
-	unsigned	op;
-	CompatInfo	next_incl;
-
-	for (next=stmt->next;next!=NULL;next=next->next) {
-	    if ((next->file==NULL)&&(next->map==NULL)) {
-		haveSelf= True;
-		MergeIncludedCompatMaps(&included,info,next->merge);
-		ClearCompatInfo(info,xkb);
-	    }
-	    else if (ProcessIncludeFile(next,XkmCompatMapIndex,&rtrn,&op)) {
-		InitCompatInfo(&next_incl,xkb);
-		next_incl.fileID= rtrn->id;
-		next_incl.dflt= info->dflt;
-		next_incl.dflt.defs.fileID= rtrn->id;
-		next_incl.dflt.defs.merge= op;
-		next_incl.ledDflt.defs.fileID= rtrn->id;
-		next_incl.ledDflt.defs.merge= op;
-		next_incl.act= info->act;
-		(*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
-		MergeIncludedCompatMaps(&included,&next_incl,op);
-		ClearCompatInfo(&next_incl,xkb);
-	    }
-	    else {
-		info->errorCount+= 10;
-		return False;
-	    }
-	}
+    unsigned newMerge;
+    XkbFile *rtrn;
+    CompatInfo included;
+    Bool haveSelf;
+
+    haveSelf = False;
+    if ((stmt->file == NULL) && (stmt->map == NULL))
+    {
+        haveSelf = True;
+        included = *info;
+        bzero(info, sizeof(CompatInfo));
+    }
+    else if (ProcessIncludeFile(stmt, XkmCompatMapIndex, &rtrn, &newMerge))
+    {
+        InitCompatInfo(&included, xkb);
+        included.fileID = rtrn->id;
+        included.dflt = info->dflt;
+        included.dflt.defs.fileID = rtrn->id;
+        included.dflt.defs.merge = newMerge;
+        included.ledDflt.defs.fileID = rtrn->id;
+        included.ledDflt.defs.merge = newMerge;
+        included.act = info->act;
+        (*hndlr) (rtrn, xkb, MergeOverride, &included);
+        if (stmt->stmt != NULL)
+        {
+            if (included.name != NULL)
+                uFree(included.name);
+            included.name = stmt->stmt;
+            stmt->stmt = NULL;
+        }
+    }
+    else
+    {
+        info->errorCount += 10;
+        return False;
+    }
+    if ((stmt->next != NULL) && (included.errorCount < 1))
+    {
+        IncludeStmt *next;
+        unsigned op;
+        CompatInfo next_incl;
+
+        for (next = stmt->next; next != NULL; next = next->next)
+        {
+            if ((next->file == NULL) && (next->map == NULL))
+            {
+                haveSelf = True;
+                MergeIncludedCompatMaps(&included, info, next->merge);
+                ClearCompatInfo(info, xkb);
+            }
+            else if (ProcessIncludeFile(next, XkmCompatMapIndex, &rtrn, &op))
+            {
+                InitCompatInfo(&next_incl, xkb);
+                next_incl.fileID = rtrn->id;
+                next_incl.dflt = info->dflt;
+                next_incl.dflt.defs.fileID = rtrn->id;
+                next_incl.dflt.defs.merge = op;
+                next_incl.ledDflt.defs.fileID = rtrn->id;
+                next_incl.ledDflt.defs.merge = op;
+                next_incl.act = info->act;
+                (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
+                MergeIncludedCompatMaps(&included, &next_incl, op);
+                ClearCompatInfo(&next_incl, xkb);
+            }
+            else
+            {
+                info->errorCount += 10;
+                return False;
+            }
+        }
     }
     if (haveSelf)
-	*info= included;
-    else {
-	MergeIncludedCompatMaps(info,&included,newMerge);
-	ClearCompatInfo(&included,xkb);
+        *info = included;
+    else
+    {
+        MergeIncludedCompatMaps(info, &included, newMerge);
+        ClearCompatInfo(&included, xkb);
     }
-    return (info->errorCount==0);
+    return (info->errorCount == 0);
 }
 
 static LookupEntry useModMapValues[] = {
-	{	"levelone",	1	},
-	{	"level1",	1	},
-	{	"anylevel",	0	},
-	{	"any",		0	},
-	{	NULL,		0	}
+    {"levelone", 1},
+    {"level1", 1},
+    {"anylevel", 0},
+    {"any", 0},
+    {NULL, 0}
 };
 
 static int
-SetInterpField(	SymInterpInfo *	si,
-		XkbDescPtr	xkb,
-		char *		field,
-		ExprDef *	arrayNdx,
-		ExprDef *	value,
-		CompatInfo *	info)
+SetInterpField(SymInterpInfo * si,
+               XkbDescPtr xkb,
+               char *field,
+               ExprDef * arrayNdx, ExprDef * value, CompatInfo * info)
 {
-int 		ok= 1;
-ExprResult	tmp;
-
-    if (uStrCaseCmp(field,"action")==0) {
-	if (arrayNdx!=NULL)
-	    return ReportSINotArray(si,field,info);
-	ok= HandleActionDef(value,xkb,&si->interp.act,si->defs.merge,info->act);
-	if (ok) 
-	     si->defs.defined|= _SI_Action;
-    }
-    else if ((uStrCaseCmp(field,"virtualmodifier")==0)||
-	     (uStrCaseCmp(field,"virtualmod")==0)) {
-	if (arrayNdx!=NULL)
-	    return ReportSINotArray(si,field,info);
-	ok= ResolveVirtualModifier(value,&tmp,&info->vmods);
-	if (ok) {
-	    si->interp.virtual_mod= tmp.uval;
-	    si->defs.defined|= _SI_VirtualMod;
-	}
-	else return ReportSIBadType(si,field,"virtual modifier",info);
-    }
-    else if (uStrCaseCmp(field,"repeat")==0) {
-	if (arrayNdx!=NULL)
-	    return ReportSINotArray(si,field,info);
-	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
-	if (ok) {
-	    if (tmp.uval)	si->interp.flags|= XkbSI_AutoRepeat;
-	    else		si->interp.flags&= ~XkbSI_AutoRepeat;
-	    si->defs.defined|= _SI_AutoRepeat;
-	}
-	else return ReportSIBadType(si,field,"boolean",info);
-    }
-    else if (uStrCaseCmp(field,"locking")==0) {
-	if (arrayNdx!=NULL)
-	    return ReportSINotArray(si,field,info);
-	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
-	if (ok) {
-	    if (tmp.uval)	si->interp.flags|= XkbSI_LockingKey;
-	    else		si->interp.flags&= ~XkbSI_LockingKey;
-	    si->defs.defined|= _SI_LockingKey;
-	}
-	else return ReportSIBadType(si,field,"boolean",info);
-    }
-    else if ((uStrCaseCmp(field,"usemodmap")==0)||
-	 	(uStrCaseCmp(field,"usemodmapmods")==0)) {
-	if (arrayNdx!=NULL)
-	    return ReportSINotArray(si,field,info);
-	ok= ExprResolveEnum(value,&tmp,useModMapValues);
-	if (ok) {
-	    if (tmp.uval)	si->interp.match|= XkbSI_LevelOneOnly;
-	    else		si->interp.match&= ~XkbSI_LevelOneOnly;
-	    si->defs.defined|= _SI_LevelOneOnly;
-	}
-	else return ReportSIBadType(si,field,"level specification",info);
-    }
-    else {
-	ok= ReportBadField("symbol interpretation",field,siText(si,info));
+    int ok = 1;
+    ExprResult tmp;
+
+    if (uStrCaseCmp(field, "action") == 0)
+    {
+        if (arrayNdx != NULL)
+            return ReportSINotArray(si, field, info);
+        ok = HandleActionDef(value, xkb, &si->interp.act, si->defs.merge,
+                             info->act);
+        if (ok)
+            si->defs.defined |= _SI_Action;
+    }
+    else if ((uStrCaseCmp(field, "virtualmodifier") == 0) ||
+             (uStrCaseCmp(field, "virtualmod") == 0))
+    {
+        if (arrayNdx != NULL)
+            return ReportSINotArray(si, field, info);
+        ok = ResolveVirtualModifier(value, &tmp, &info->vmods);
+        if (ok)
+        {
+            si->interp.virtual_mod = tmp.uval;
+            si->defs.defined |= _SI_VirtualMod;
+        }
+        else
+            return ReportSIBadType(si, field, "virtual modifier", info);
+    }
+    else if (uStrCaseCmp(field, "repeat") == 0)
+    {
+        if (arrayNdx != NULL)
+            return ReportSINotArray(si, field, info);
+        ok = ExprResolveBoolean(value, &tmp, NULL, NULL);
+        if (ok)
+        {
+            if (tmp.uval)
+                si->interp.flags |= XkbSI_AutoRepeat;
+            else
+                si->interp.flags &= ~XkbSI_AutoRepeat;
+            si->defs.defined |= _SI_AutoRepeat;
+        }
+        else
+            return ReportSIBadType(si, field, "boolean", info);
+    }
+    else if (uStrCaseCmp(field, "locking") == 0)
+    {
+        if (arrayNdx != NULL)
+            return ReportSINotArray(si, field, info);
+        ok = ExprResolveBoolean(value, &tmp, NULL, NULL);
+        if (ok)
+        {
+            if (tmp.uval)
+                si->interp.flags |= XkbSI_LockingKey;
+            else
+                si->interp.flags &= ~XkbSI_LockingKey;
+            si->defs.defined |= _SI_LockingKey;
+        }
+        else
+            return ReportSIBadType(si, field, "boolean", info);
+    }
+    else if ((uStrCaseCmp(field, "usemodmap") == 0) ||
+             (uStrCaseCmp(field, "usemodmapmods") == 0))
+    {
+        if (arrayNdx != NULL)
+            return ReportSINotArray(si, field, info);
+        ok = ExprResolveEnum(value, &tmp, useModMapValues);
+        if (ok)
+        {
+            if (tmp.uval)
+                si->interp.match |= XkbSI_LevelOneOnly;
+            else
+                si->interp.match &= ~XkbSI_LevelOneOnly;
+            si->defs.defined |= _SI_LevelOneOnly;
+        }
+        else
+            return ReportSIBadType(si, field, "level specification", info);
+    }
+    else
+    {
+        ok = ReportBadField("symbol interpretation", field, siText(si, info));
     }
     return ok;
 }
 
-LookupEntry groupNames[]= {
-	{	"group1",	0x01	},
-	{	"group2",	0x02	},
-	{	"group3",	0x04	},
-	{	"group4",	0x08	},
-	{	"group5",	0x10	},
-	{	"group6",	0x20	},
-	{	"group7",	0x40	},
-	{	"group8",	0x80	},
-	{	"none",		0x00	},
-	{	"all",		0xff	},
-	{	NULL,		0	}
+LookupEntry groupNames[] = {
+    {"group1", 0x01}
+    ,
+    {"group2", 0x02}
+    ,
+    {"group3", 0x04}
+    ,
+    {"group4", 0x08}
+    ,
+    {"group5", 0x10}
+    ,
+    {"group6", 0x20}
+    ,
+    {"group7", 0x40}
+    ,
+    {"group8", 0x80}
+    ,
+    {"none", 0x00}
+    ,
+    {"all", 0xff}
+    ,
+    {NULL, 0}
 };
 
 static int
-HandleInterpVar(VarDef *stmt,XkbDescPtr xkb,CompatInfo *info)
+HandleInterpVar(VarDef * stmt, XkbDescPtr xkb, CompatInfo * info)
 {
-ExprResult	elem,field;
-ExprDef *	ndx;
-
-    if (ExprResolveLhs(stmt->name,&elem,&field,&ndx)==0) 
-	return 0; /* internal error, already reported */
-    if (elem.str&&(uStrCaseCmp(elem.str,"interpret")==0))
-	return SetInterpField(&info->dflt,xkb,field.str,ndx,stmt->value,info);	
-    if (elem.str&&(uStrCaseCmp(elem.str,"indicator")==0)) {
-	return SetIndicatorMapField(&info->ledDflt,xkb,field.str,ndx,
-								stmt->value);
-    }
-    return SetActionField(xkb,elem.str,field.str,ndx,stmt->value,&info->act);
+    ExprResult elem, field;
+    ExprDef *ndx;
+
+    if (ExprResolveLhs(stmt->name, &elem, &field, &ndx) == 0)
+        return 0;               /* internal error, already reported */
+    if (elem.str && (uStrCaseCmp(elem.str, "interpret") == 0))
+        return SetInterpField(&info->dflt, xkb, field.str, ndx, stmt->value,
+                              info);
+    if (elem.str && (uStrCaseCmp(elem.str, "indicator") == 0))
+    {
+        return SetIndicatorMapField(&info->ledDflt, xkb, field.str, ndx,
+                                    stmt->value);
+    }
+    return SetActionField(xkb, elem.str, field.str, ndx, stmt->value,
+                          &info->act);
 }
 
 static int
-HandleInterpBody(VarDef *def,XkbDescPtr xkb,SymInterpInfo *si,CompatInfo *info)
+HandleInterpBody(VarDef * def, XkbDescPtr xkb, SymInterpInfo * si,
+                 CompatInfo * info)
 {
-int		ok= 1;
-ExprResult	tmp,field;
-ExprDef *	arrayNdx;
-
-    for (;def!=NULL;def= (VarDef *)def->common.next) {
-	if ((def->name)&&(def->name->type==ExprFieldRef)) {
-	    ok= HandleInterpVar(def,xkb,info);
-	    continue;
-	}
-	ok= ExprResolveLhs(def->name,&tmp,&field,&arrayNdx);
-	if (ok)
-	    ok= SetInterpField(si,xkb,field.str,arrayNdx,def->value,info);
+    int ok = 1;
+    ExprResult tmp, field;
+    ExprDef *arrayNdx;
+
+    for (; def != NULL; def = (VarDef *) def->common.next)
+    {
+        if ((def->name) && (def->name->type == ExprFieldRef))
+        {
+            ok = HandleInterpVar(def, xkb, info);
+            continue;
+        }
+        ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
+        if (ok)
+            ok = SetInterpField(si, xkb, field.str, arrayNdx, def->value,
+                                info);
     }
     return ok;
 }
 
 static int
-HandleInterpDef(InterpDef *def,XkbDescPtr xkb,unsigned merge,CompatInfo *info)
+HandleInterpDef(InterpDef * def, XkbDescPtr xkb, unsigned merge,
+                CompatInfo * info)
 {
-unsigned		pred,mods;
-SymInterpInfo		si;
- 
-    if (!ResolveStateAndPredicate(def->match,&pred,&mods,info)) {
-	ERROR("Couldn't determine matching modifiers\n");
-	ACTION("Symbol interpretation ignored\n");
-	return False;
-    }
-    if (def->merge!=MergeDefault)
-	merge= def->merge;
-
-    si= info->dflt;
-    si.defs.merge= merge;
-    si.interp.sym= def->sym;
-    si.interp.match= pred & XkbSI_OpMask;
-    si.interp.mods= mods;
-    if (!HandleInterpBody(def->def,xkb,&si,info)) {
-	info->errorCount++;
-	return False;
-    }
-
-    if (!AddInterp(info,&si)) {
-	info->errorCount++;
-	return False;
+    unsigned pred, mods;
+    SymInterpInfo si;
+
+    if (!ResolveStateAndPredicate(def->match, &pred, &mods, info))
+    {
+        ERROR("Couldn't determine matching modifiers\n");
+        ACTION("Symbol interpretation ignored\n");
+        return False;
+    }
+    if (def->merge != MergeDefault)
+        merge = def->merge;
+
+    si = info->dflt;
+    si.defs.merge = merge;
+    si.interp.sym = def->sym;
+    si.interp.match = pred & XkbSI_OpMask;
+    si.interp.mods = mods;
+    if (!HandleInterpBody(def->def, xkb, &si, info))
+    {
+        info->errorCount++;
+        return False;
+    }
+
+    if (!AddInterp(info, &si))
+    {
+        info->errorCount++;
+        return False;
     }
     return True;
 }
 
 static int
-HandleGroupCompatDef(	GroupCompatDef *	def,
-			XkbDescPtr		xkb,
-			unsigned 		merge,
-			CompatInfo *		info)
+HandleGroupCompatDef(GroupCompatDef * def,
+                     XkbDescPtr xkb, unsigned merge, CompatInfo * info)
 {
-ExprResult	val;
-GroupCompatInfo	tmp;
-
-    if (def->merge!=MergeDefault)
-	merge= def->merge;
-    if (!XkbIsLegalGroup(def->group-1)) {
-	ERROR1("Keyboard group must be in the range 1..%d\n",XkbNumKbdGroups+1);
-	ACTION1("Compatibility map for illegal group %d ignored\n",def->group);
-	return False;
-    }
-    tmp.fileID= info->fileID;
-    tmp.merge= merge;
-    if (!ExprResolveModMask(def->def,&val,LookupVModMask,(XPointer)xkb)) {
-	ERROR("Expected a modifier mask in group compatibility definition\n");
-	ACTION1("Ignoring illegal compatibility map for group %d\n",def->group);
-	return False;
-    }
-    tmp.real_mods= val.uval&0xff;
-    tmp.vmods= (val.uval>>8)&0xffff;
-    return AddGroupCompat(info,def->group-1,&tmp);
+    ExprResult val;
+    GroupCompatInfo tmp;
+
+    if (def->merge != MergeDefault)
+        merge = def->merge;
+    if (!XkbIsLegalGroup(def->group - 1))
+    {
+        ERROR1("Keyboard group must be in the range 1..%d\n",
+               XkbNumKbdGroups + 1);
+        ACTION1("Compatibility map for illegal group %d ignored\n",
+                def->group);
+        return False;
+    }
+    tmp.fileID = info->fileID;
+    tmp.merge = merge;
+    if (!ExprResolveModMask(def->def, &val, LookupVModMask, (XPointer) xkb))
+    {
+        ERROR("Expected a modifier mask in group compatibility definition\n");
+        ACTION1("Ignoring illegal compatibility map for group %d\n",
+                def->group);
+        return False;
+    }
+    tmp.real_mods = val.uval & 0xff;
+    tmp.vmods = (val.uval >> 8) & 0xffff;
+    return AddGroupCompat(info, def->group - 1, &tmp);
 }
 
 static void
-HandleCompatMapFile(	XkbFile	*	file,
-			XkbDescPtr 	 xkb,
-			unsigned	 merge,
-			CompatInfo *	info)
+HandleCompatMapFile(XkbFile * file,
+                    XkbDescPtr xkb, unsigned merge, CompatInfo * info)
 {
-ParseCommon	*stmt;
-
-    if (merge==MergeDefault)
-	merge= MergeAugment;
-    info->name= uStringDup(file->name);
-    stmt= file->defs;
-    while (stmt) {
-	switch (stmt->stmtType) {
-	    case StmtInclude:
-		if (!HandleIncludeCompatMap((IncludeStmt *)stmt,xkb,info,
-						HandleCompatMapFile))
-		    info->errorCount++;
-		break;
-	    case StmtInterpDef:
-		if (!HandleInterpDef((InterpDef *)stmt,xkb,merge,info))
-		    info->errorCount++;
-		break;
-	    case StmtGroupCompatDef:
-		if (!HandleGroupCompatDef((GroupCompatDef*)stmt,xkb,merge,info))
-		    info->errorCount++;
-		break;
-	    case StmtIndicatorMapDef:
-		{
-		    LEDInfo *rtrn;
-		    rtrn= HandleIndicatorMapDef((IndicatorMapDef *)stmt,xkb,
-						&info->ledDflt,info->leds,
-						merge);
-		    if (rtrn!=NULL)
-		 	 info->leds= rtrn;
-		    else info->errorCount++;
-		}
-		break;
-	    case StmtVarDef:
-		if (!HandleInterpVar((VarDef *)stmt,xkb,info))
-		    info->errorCount++;
-		break;
-	    case StmtVModDef:
-		if (!HandleVModDef((VModDef *)stmt,merge,&info->vmods))
-		    info->errorCount++;
-		break;
-	    case StmtKeycodeDef:
-		ERROR("Interpretation files may not include other types\n");
-		ACTION("Ignoring definition of key name\n");
-		info->errorCount++;
-		break;
-	    default:
-		WSGO1("Unexpected statement type %d in HandleCompatMapFile\n",
-								stmt->stmtType);
-		break;
-	}
-	stmt= stmt->next;
-	if (info->errorCount>10) {
+    ParseCommon *stmt;
+
+    if (merge == MergeDefault)
+        merge = MergeAugment;
+    info->name = uStringDup(file->name);
+    stmt = file->defs;
+    while (stmt)
+    {
+        switch (stmt->stmtType)
+        {
+        case StmtInclude:
+            if (!HandleIncludeCompatMap((IncludeStmt *) stmt, xkb, info,
+                                        HandleCompatMapFile))
+                info->errorCount++;
+            break;
+        case StmtInterpDef:
+            if (!HandleInterpDef((InterpDef *) stmt, xkb, merge, info))
+                info->errorCount++;
+            break;
+        case StmtGroupCompatDef:
+            if (!HandleGroupCompatDef
+                ((GroupCompatDef *) stmt, xkb, merge, info))
+                info->errorCount++;
+            break;
+        case StmtIndicatorMapDef:
+        {
+            LEDInfo *rtrn;
+            rtrn = HandleIndicatorMapDef((IndicatorMapDef *) stmt, xkb,
+                                         &info->ledDflt, info->leds, merge);
+            if (rtrn != NULL)
+                info->leds = rtrn;
+            else
+                info->errorCount++;
+        }
+            break;
+        case StmtVarDef:
+            if (!HandleInterpVar((VarDef *) stmt, xkb, info))
+                info->errorCount++;
+            break;
+        case StmtVModDef:
+            if (!HandleVModDef((VModDef *) stmt, merge, &info->vmods))
+                info->errorCount++;
+            break;
+        case StmtKeycodeDef:
+            ERROR("Interpretation files may not include other types\n");
+            ACTION("Ignoring definition of key name\n");
+            info->errorCount++;
+            break;
+        default:
+            WSGO1("Unexpected statement type %d in HandleCompatMapFile\n",
+                  stmt->stmtType);
+            break;
+        }
+        stmt = stmt->next;
+        if (info->errorCount > 10)
+        {
 #ifdef NOISY
-	    ERROR("Too many errors\n");
+            ERROR("Too many errors\n");
 #endif
-	    ACTION1("Abandoning compatibility map \"%s\"\n",file->topName);
-	    break;
-	}
+            ACTION1("Abandoning compatibility map \"%s\"\n", file->topName);
+            break;
+        }
     }
     return;
 }
 
 static void
-CopyInterps(	CompatInfo *	info,
-		XkbCompatMapPtr	compat,
-		Bool		needSymbol,
-		unsigned	pred)
+CopyInterps(CompatInfo * info,
+            XkbCompatMapPtr compat, Bool needSymbol, unsigned pred)
 {
-SymInterpInfo *		si;
-
-    for (si=info->interps;si;si=(SymInterpInfo *)si->defs.next) {
-	if (((si->interp.match&XkbSI_OpMask)!=pred)||
-		(needSymbol&&(si->interp.sym==NoSymbol))||
-		((!needSymbol)&&(si->interp.sym!=NoSymbol)))
-	    continue;
-	if (compat->num_si>=compat->size_si) {
-	    WSGO("No room to merge symbol interpretations\n");
-	    ACTION("Symbol interpretations lost\n");
-	    return;
-	}
-	compat->sym_interpret[compat->num_si++]= si->interp;
+    SymInterpInfo *si;
+
+    for (si = info->interps; si; si = (SymInterpInfo *) si->defs.next)
+    {
+        if (((si->interp.match & XkbSI_OpMask) != pred) ||
+            (needSymbol && (si->interp.sym == NoSymbol)) ||
+            ((!needSymbol) && (si->interp.sym != NoSymbol)))
+            continue;
+        if (compat->num_si >= compat->size_si)
+        {
+            WSGO("No room to merge symbol interpretations\n");
+            ACTION("Symbol interpretations lost\n");
+            return;
+        }
+        compat->sym_interpret[compat->num_si++] = si->interp;
     }
     return;
 }
 
 Bool
-CompileCompatMap(	XkbFile *	file,
-			XkbFileInfo *	result,
-			unsigned	merge,
-			LEDInfo **	unboundLEDs)
+CompileCompatMap(XkbFile * file,
+                 XkbFileInfo * result, unsigned merge, LEDInfo ** unboundLEDs)
 {
-int			i;
-CompatInfo		info;
-XkbDescPtr		xkb;
-GroupCompatInfo *	gcm;
-
-    xkb= result->xkb;
-    InitCompatInfo(&info,xkb);
-    info.dflt.defs.merge= merge;
-    info.ledDflt.defs.merge= merge;
-    HandleCompatMapFile(file,xkb,merge,&info);
-
-    if (info.errorCount==0) {
-	int size;
-	if (XkbAllocCompatMap(xkb,XkbAllCompatMask,info.nInterps)!=Success) {
-	    WSGO("Couldn't allocate compatibility map\n");
-	    ACTION("Exiting\n");
-	    return False;
-	}
-	if (info.name!=NULL) {
-	    if (XkbAllocNames(xkb,XkbCompatNameMask,0,0)==Success)
-		xkb->names->compat= XkbInternAtom(xkb->dpy,info.name,False);
-	    else {
-		WSGO("Couldn't allocate space for compat name\n");
-		ACTION2("Name \"%s\" (from %s) NOT assigned\n",scanFile,
-								info.name);
-	    }
-	}
-	size= info.nInterps*sizeof(XkbSymInterpretRec);
-	if (size>0) {
-	    CopyInterps(&info,xkb->compat,True,XkbSI_Exactly);
-	    CopyInterps(&info,xkb->compat,True,XkbSI_AllOf|XkbSI_NoneOf);
-	    CopyInterps(&info,xkb->compat,True,XkbSI_AnyOf);
-	    CopyInterps(&info,xkb->compat,True,XkbSI_AnyOfOrNone);
-	    CopyInterps(&info,xkb->compat,False,XkbSI_Exactly);
-	    CopyInterps(&info,xkb->compat,False,XkbSI_AllOf|XkbSI_NoneOf);
-	    CopyInterps(&info,xkb->compat,False,XkbSI_AnyOf);
-	    CopyInterps(&info,xkb->compat,False,XkbSI_AnyOfOrNone);
-	}
-	for (i=0,gcm=&info.groupCompat[0];i<XkbNumKbdGroups;i++,gcm++) {
-	    if ((gcm->fileID!=0)||(gcm->real_mods!=0)||(gcm->vmods!=0)) {
-	 	xkb->compat->groups[i].mask= gcm->real_mods;
-	 	xkb->compat->groups[i].real_mods= gcm->real_mods;
-	 	xkb->compat->groups[i].vmods= gcm->vmods;
-	    }
-	}
-	if (info.leds!=NULL) {
-	    if (!CopyIndicatorMapDefs(result,info.leds,unboundLEDs))
-		info.errorCount++;
-	    info.leds= NULL;
-	}
-	ClearCompatInfo(&info,xkb);
-	return True;
-    }
-    if (info.interps!=NULL)
-	uFree(info.interps);
+    int i;
+    CompatInfo info;
+    XkbDescPtr xkb;
+    GroupCompatInfo *gcm;
+
+    xkb = result->xkb;
+    InitCompatInfo(&info, xkb);
+    info.dflt.defs.merge = merge;
+    info.ledDflt.defs.merge = merge;
+    HandleCompatMapFile(file, xkb, merge, &info);
+
+    if (info.errorCount == 0)
+    {
+        int size;
+        if (XkbAllocCompatMap(xkb, XkbAllCompatMask, info.nInterps) !=
+            Success)
+        {
+            WSGO("Couldn't allocate compatibility map\n");
+            ACTION("Exiting\n");
+            return False;
+        }
+        if (info.name != NULL)
+        {
+            if (XkbAllocNames(xkb, XkbCompatNameMask, 0, 0) == Success)
+                xkb->names->compat =
+                    XkbInternAtom(xkb->dpy, info.name, False);
+            else
+            {
+                WSGO("Couldn't allocate space for compat name\n");
+                ACTION2("Name \"%s\" (from %s) NOT assigned\n",
+                        scanFile, info.name);
+            }
+        }
+        size = info.nInterps * sizeof(XkbSymInterpretRec);
+        if (size > 0)
+        {
+            CopyInterps(&info, xkb->compat, True, XkbSI_Exactly);
+            CopyInterps(&info, xkb->compat, True, XkbSI_AllOf | XkbSI_NoneOf);
+            CopyInterps(&info, xkb->compat, True, XkbSI_AnyOf);
+            CopyInterps(&info, xkb->compat, True, XkbSI_AnyOfOrNone);
+            CopyInterps(&info, xkb->compat, False, XkbSI_Exactly);
+            CopyInterps(&info, xkb->compat, False,
+                        XkbSI_AllOf | XkbSI_NoneOf);
+            CopyInterps(&info, xkb->compat, False, XkbSI_AnyOf);
+            CopyInterps(&info, xkb->compat, False, XkbSI_AnyOfOrNone);
+        }
+        for (i = 0, gcm = &info.groupCompat[0]; i < XkbNumKbdGroups;
+             i++, gcm++)
+        {
+            if ((gcm->fileID != 0) || (gcm->real_mods != 0)
+                || (gcm->vmods != 0))
+            {
+                xkb->compat->groups[i].mask = gcm->real_mods;
+                xkb->compat->groups[i].real_mods = gcm->real_mods;
+                xkb->compat->groups[i].vmods = gcm->vmods;
+            }
+        }
+        if (info.leds != NULL)
+        {
+            if (!CopyIndicatorMapDefs(result, info.leds, unboundLEDs))
+                info.errorCount++;
+            info.leds = NULL;
+        }
+        ClearCompatInfo(&info, xkb);
+        return True;
+    }
+    if (info.interps != NULL)
+        uFree(info.interps);
     return False;
 }