svn merge file:///D:/svnrepos/vcxsrv/branches/released .

1 files changed, 921 insertions, 832 deletions

diff --git a/xkbcomp/expr.c b/xkbcomp/expr.c
index 6e01d7daf..96fd95675 100644
--- a/xkbcomp/expr.c
+++ b/xkbcomp/expr.c
@@ -1,5 +1,3 @@
-/* $XdotOrg: expr.c,v 1.5 2000/08/17 19:54:30 cpqbld Exp $ */
-/* $Xorg: expr.c,v 1.5 2000/08/17 19:54:30 cpqbld Exp $ */
 /************************************************************
  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
 
@@ -25,7 +23,6 @@
  THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
  ********************************************************/
-/* $XFree86: xc/programs/xkbcomp/expr.c,v 3.7 2003/08/06 14:04:05 eich Exp $ */
 
 #include "xkbcomp.h"
 #include "tokens.h"
@@ -38,789 +35,868 @@
 char *
 exprOpText(unsigned type)
 {
-static char buf[32];
-
-     switch (type) {
-	case ExprValue:
-	    strcpy(buf,"literal");
-	    break;
-	case ExprIdent:
-	    strcpy(buf,"identifier");
-	    break;
-	case ExprActionDecl:
-	    strcpy(buf,"action declaration");
-	    break;
-	case ExprFieldRef:
-	    strcpy(buf,"field reference");
-	    break;
-	case ExprArrayRef:
-	    strcpy(buf,"array reference");
-	    break;
-	case ExprKeysymList:
-	    strcpy(buf,"list of keysyms");
-	    break;
-	case ExprActionList:
-	    strcpy(buf,"list of actions");
-	    break;
-	case OpAdd:
-	    strcpy(buf,"addition");
-	    break;
-	case OpSubtract:
-	    strcpy(buf,"subtraction");
-	    break;
-	case OpMultiply:
-	    strcpy(buf,"multiplication");
-	    break;
-	case OpDivide:
-	    strcpy(buf,"division");
-	    break;
-	case OpAssign:
-	    strcpy(buf,"assignment");
-	    break;
-	case OpNot:
-	    strcpy(buf,"logical not");
-	    break;
-	case OpNegate:
-	    strcpy(buf,"arithmetic negation");
-	    break;
-	case OpInvert:
-	    strcpy(buf,"bitwise inversion");
-	    break;
-	case OpUnaryPlus:
-	    strcpy(buf,"plus sign");
-	    break;
-	default:
-	    sprintf(buf,"illegal(%d)",type);
-	    break;
-     }
-     return buf;
+    static char buf[32];
+
+    switch (type)
+    {
+    case ExprValue:
+        strcpy(buf, "literal");
+        break;
+    case ExprIdent:
+        strcpy(buf, "identifier");
+        break;
+    case ExprActionDecl:
+        strcpy(buf, "action declaration");
+        break;
+    case ExprFieldRef:
+        strcpy(buf, "field reference");
+        break;
+    case ExprArrayRef:
+        strcpy(buf, "array reference");
+        break;
+    case ExprKeysymList:
+        strcpy(buf, "list of keysyms");
+        break;
+    case ExprActionList:
+        strcpy(buf, "list of actions");
+        break;
+    case OpAdd:
+        strcpy(buf, "addition");
+        break;
+    case OpSubtract:
+        strcpy(buf, "subtraction");
+        break;
+    case OpMultiply:
+        strcpy(buf, "multiplication");
+        break;
+    case OpDivide:
+        strcpy(buf, "division");
+        break;
+    case OpAssign:
+        strcpy(buf, "assignment");
+        break;
+    case OpNot:
+        strcpy(buf, "logical not");
+        break;
+    case OpNegate:
+        strcpy(buf, "arithmetic negation");
+        break;
+    case OpInvert:
+        strcpy(buf, "bitwise inversion");
+        break;
+    case OpUnaryPlus:
+        strcpy(buf, "plus sign");
+        break;
+    default:
+        snprintf(buf, sizeof(buf), "illegal(%d)", type);
+        break;
+    }
+    return buf;
 }
 
 char *
 exprTypeText(unsigned type)
 {
-static char buf[20];
-
-     switch (type) {
-	case TypeUnknown:
-	    strcpy(buf,"unknown");
-	    break;
-	case TypeBoolean:
-	    strcpy(buf,"boolean");
-	    break;
-	case TypeInt:
-	    strcpy(buf,"int");
-	    break;
-	case TypeString:
-	    strcpy(buf,"string");
-	    break;
-	case TypeAction:
-	    strcpy(buf,"action");
-	    break;
-	case TypeKeyName:
-	    strcpy(buf,"keyname");
-	    break;
-	default:
-	    sprintf(buf,"illegal(%d)",type);
-	    break;
-     }
-     return buf;
+    static char buf[20];
+
+    switch (type)
+    {
+    case TypeUnknown:
+        strcpy(buf, "unknown");
+        break;
+    case TypeBoolean:
+        strcpy(buf, "boolean");
+        break;
+    case TypeInt:
+        strcpy(buf, "int");
+        break;
+    case TypeString:
+        strcpy(buf, "string");
+        break;
+    case TypeAction:
+        strcpy(buf, "action");
+        break;
+    case TypeKeyName:
+        strcpy(buf, "keyname");
+        break;
+    default:
+        snprintf(buf, sizeof(buf), "illegal(%d)", type);
+        break;
+    }
+    return buf;
 }
 
 int
-ExprResolveLhs(	ExprDef *	expr,
-		ExprResult *	elem_rtrn,
-		ExprResult *	field_rtrn,
-		ExprDef **	index_rtrn)
+ExprResolveLhs(ExprDef * expr,
+               ExprResult * elem_rtrn,
+               ExprResult * field_rtrn, ExprDef ** index_rtrn)
 {
-    switch (expr->op) {
-	case ExprIdent:
-	    elem_rtrn->str=  NULL;
-	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.str);
-	    *index_rtrn= NULL;
-	    return True;
-	case ExprFieldRef:
-	    elem_rtrn->str= XkbAtomGetString(NULL,expr->value.field.element);
-	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.field.field);
-	    *index_rtrn= NULL;
-	    return True;
-	case ExprArrayRef:
-	    elem_rtrn->str= XkbAtomGetString(NULL,expr->value.array.element);
-	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.array.field);
-	    *index_rtrn= expr->value.array.entry;
-	    return True;
+    switch (expr->op)
+    {
+    case ExprIdent:
+        elem_rtrn->str = NULL;
+        field_rtrn->str = XkbAtomGetString(NULL, expr->value.str);
+        *index_rtrn = NULL;
+        return True;
+    case ExprFieldRef:
+        elem_rtrn->str = XkbAtomGetString(NULL, expr->value.field.element);
+        field_rtrn->str = XkbAtomGetString(NULL, expr->value.field.field);
+        *index_rtrn = NULL;
+        return True;
+    case ExprArrayRef:
+        elem_rtrn->str = XkbAtomGetString(NULL, expr->value.array.element);
+        field_rtrn->str = XkbAtomGetString(NULL, expr->value.array.field);
+        *index_rtrn = expr->value.array.entry;
+        return True;
     }
-    WSGO1("Unexpected operator %d in ResolveLhs\n",expr->op);
+    WSGO1("Unexpected operator %d in ResolveLhs\n", expr->op);
     return False;
 }
 
 Bool
-SimpleLookup(	XPointer 	priv,
-		Atom		elem,
-		Atom		field,
-		unsigned	type,
-		ExprResult *	val_rtrn)
+SimpleLookup(XPointer priv,
+             Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
 {
-LookupEntry *	entry;
-register char *	str;
+    LookupEntry *entry;
+    register char *str;
 
-    if ((priv==NULL)||
-	(field==None)||(elem!=None)||
-	((type!=TypeInt)&&(type!=TypeFloat))) {
-	return False;
+    if ((priv == NULL) ||
+        (field == None) || (elem != None) ||
+        ((type != TypeInt) && (type != TypeFloat)))
+    {
+        return False;
     }
-    str= XkbAtomGetString(NULL,field);
-    for (entry=(LookupEntry *)priv;(entry!=NULL)&&(entry->name!=NULL);entry++) {
-	if (uStrCaseCmp(str,entry->name)==0) {
-	    val_rtrn->uval= entry->result;
-	    if (type==TypeFloat)
-		val_rtrn->uval*= XkbGeomPtsPerMM;
-	    return True;
-	}
+    str = XkbAtomGetString(NULL, field);
+    for (entry = (LookupEntry *) priv;
+         (entry != NULL) && (entry->name != NULL); entry++)
+    {
+        if (uStrCaseCmp(str, entry->name) == 0)
+        {
+            val_rtrn->uval = entry->result;
+            if (type == TypeFloat)
+                val_rtrn->uval *= XkbGeomPtsPerMM;
+            return True;
+        }
     }
     return False;
 }
 
 Bool
-RadioLookup(	XPointer 	priv,
-		Atom		elem,
-		Atom		field,
-		unsigned	type,
-		ExprResult *	val_rtrn)
+RadioLookup(XPointer priv,
+            Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
 {
-register char *	str;
-int		rg;
-
-    if ((field==None)||(elem!=None)||(type!=TypeInt))
-	return False;
-    str= XkbAtomGetString(NULL,field);
-    if (str) {
-	if (uStrCasePrefix("group",str))
-	    str+= strlen("group");
-	else if (uStrCasePrefix("radiogroup",str))
-	    str+= strlen("radiogroup");
-	else if (uStrCasePrefix("rg",str))
-	    str+= strlen("rg");
-	else if (!isdigit(str[0]))
-	    str= NULL;
+    register char *str;
+    int rg;
+
+    if ((field == None) || (elem != None) || (type != TypeInt))
+        return False;
+    str = XkbAtomGetString(NULL, field);
+    if (str)
+    {
+        if (uStrCasePrefix("group", str))
+            str += strlen("group");
+        else if (uStrCasePrefix("radiogroup", str))
+            str += strlen("radiogroup");
+        else if (uStrCasePrefix("rg", str))
+            str += strlen("rg");
+        else if (!isdigit(str[0]))
+            str = NULL;
     }
-    if ((!str)||(sscanf(str,"%i",&rg)<1)||(rg<1)||(rg>XkbMaxRadioGroups))
-	return False;
-    val_rtrn->uval= rg;
+    if ((!str) || (sscanf(str, "%i", &rg) < 1) || (rg < 1)
+        || (rg > XkbMaxRadioGroups))
+        return False;
+    val_rtrn->uval = rg;
     return True;
 }
 
 int
-TableLookup(	XPointer 	priv,
-		Atom		elem,
-		Atom		field,
-		unsigned	type,
-		ExprResult *	val_rtrn)
+TableLookup(XPointer priv,
+            Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
 {
-LookupTable *	tbl= (LookupTable *)priv;
-register char *	str;
-
-    if ((priv==NULL)||(field==None)||(type!=TypeInt))
-	return False;
-    str= XkbAtomGetString(NULL,elem);
-    while (tbl) {
-	if (((str==NULL)&&(tbl->element==NULL))||
-	    ((str!=NULL)&&(tbl->element!=NULL)&&
-			  (uStrCaseCmp(str,tbl->element)==0))) {
-	    break;
-	}
-	tbl= tbl->nextElement;
+    LookupTable *tbl = (LookupTable *) priv;
+    register char *str;
+
+    if ((priv == NULL) || (field == None) || (type != TypeInt))
+        return False;
+    str = XkbAtomGetString(NULL, elem);
+    while (tbl)
+    {
+        if (((str == NULL) && (tbl->element == NULL)) ||
+            ((str != NULL) && (tbl->element != NULL) &&
+             (uStrCaseCmp(str, tbl->element) == 0)))
+        {
+            break;
+        }
+        tbl = tbl->nextElement;
     }
-    if (tbl==NULL)	/* didn't find a matching element */
-	return False;
-    priv= (XPointer)tbl->entries;
-    return SimpleLookup(priv,(Atom)None,field,type,val_rtrn);
+    if (tbl == NULL)            /* didn't find a matching element */
+        return False;
+    priv = (XPointer) tbl->entries;
+    return SimpleLookup(priv, (Atom) None, field, type, val_rtrn);
 }
 
 static LookupEntry modIndexNames[] = {
-	{	"shift",	ShiftMapIndex 	},
-	{	"control",	ControlMapIndex	},
-	{	"lock",		LockMapIndex	},
-	{	"mod1",		Mod1MapIndex	},
-	{	"mod2",		Mod2MapIndex	},
-	{	"mod3",		Mod3MapIndex	},
-	{	"mod4",		Mod4MapIndex	},
-	{	"mod5",		Mod5MapIndex	},
-	{	"none",		XkbNoModifier	},
-	{	NULL,		0		}
+    {"shift", ShiftMapIndex},
+    {"control", ControlMapIndex},
+    {"lock", LockMapIndex},
+    {"mod1", Mod1MapIndex},
+    {"mod2", Mod2MapIndex},
+    {"mod3", Mod3MapIndex},
+    {"mod4", Mod4MapIndex},
+    {"mod5", Mod5MapIndex},
+    {"none", XkbNoModifier},
+    {NULL, 0}
 };
 
 int
-LookupModIndex(	XPointer 	priv,
-		Atom		elem,
-		Atom		field,
-		unsigned	type,
-		ExprResult *	val_rtrn)
+LookupModIndex(XPointer priv,
+               Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
 {
-    return SimpleLookup((XPointer)modIndexNames,elem,field,type,val_rtrn);
+    return SimpleLookup((XPointer) modIndexNames, elem, field, type,
+                        val_rtrn);
 }
 
 int
-LookupModMask(	XPointer 	priv,
-		Atom		elem,
-		Atom		field,
-		unsigned	type,
-    		ExprResult *	val_rtrn)
+LookupModMask(XPointer priv,
+              Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
 {
-char *str;
-
-    if ((elem!=None)||(type!=TypeInt))
-	return False;
-    str= XkbAtomGetString(NULL,field);
-    if (str==NULL)
-	 return False;
-    if (uStrCaseCmp(str,"all")==0)
-	 val_rtrn->uval= 0xff;
-    else if (uStrCaseCmp(str,"none")==0)
-	 val_rtrn->uval= 0;
-    else if (LookupModIndex(priv,elem,field,type,val_rtrn))
-	 val_rtrn->uval= (1<<val_rtrn->uval);
-    else if (priv != NULL) {
-	LookupPriv *lpriv= (LookupPriv *)priv;
-	if ((lpriv->chain==NULL)||
-	    (!(*lpriv->chain)(lpriv->chainPriv,elem,field,type,val_rtrn)))
-	    return False;
+    char *str;
+
+    if ((elem != None) || (type != TypeInt))
+        return False;
+    str = XkbAtomGetString(NULL, field);
+    if (str == NULL)
+        return False;
+    if (uStrCaseCmp(str, "all") == 0)
+        val_rtrn->uval = 0xff;
+    else if (uStrCaseCmp(str, "none") == 0)
+        val_rtrn->uval = 0;
+    else if (LookupModIndex(priv, elem, field, type, val_rtrn))
+        val_rtrn->uval = (1 << val_rtrn->uval);
+    else if (priv != NULL)
+    {
+        LookupPriv *lpriv = (LookupPriv *) priv;
+        if ((lpriv->chain == NULL) ||
+            (!(*lpriv->chain) (lpriv->chainPriv, elem, field, type,
+                               val_rtrn)))
+            return False;
     }
-    else return False;
+    else
+        return False;
     return True;
 }
 
 int
-ExprResolveModIndex(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveModIndex(ExprDef * expr,
+                    ExprResult * val_rtrn,
+                    IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-char		*bogus= NULL;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type!=TypeInt) {
-		ERROR1("Found constant of type %s where a modifier mask was expected\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    else if ((expr->value.ival>=XkbNumModifiers)||(expr->value.ival<0)){
-		ERROR2("Illegal modifier index (%d, must be 0..%d)\n",
-					expr->value.ival,XkbNumModifiers-1);
-		return False;
-	    }
-	    val_rtrn->ival= expr->value.ival;
-	    return True;
-	case ExprIdent:
-	    if (LookupModIndex(lookupPriv,(Atom)None,expr->value.str,
-				 		(unsigned)TypeInt,val_rtrn)) {
-		return True;
-	    }
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeInt,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Cannot determine modifier index for \"%s\"\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    break;
-	case ExprFieldRef:
-	    bogus= "field reference";
-	    break;
-	case ExprArrayRef:
-	    bogus= "array reference";
-	    break;
-	case ExprActionDecl:
-	    bogus= "function";
-	    break;
-	case OpAdd:
-	case OpSubtract:
-	case OpMultiply:
-	case OpDivide:
-	case OpInvert:
-	case OpNegate:
-	case OpNot:
-	case OpUnaryPlus:
-	    bogus= "arithmetic operations";
-	    break;
-	case OpAssign:
-	    bogus= "assignment";
-	    break;
-	default:
-	    WSGO1("Unknown operator %d in ResolveModIndex\n",expr->op);
-	    return False;
+    int ok = 0;
+    char *bogus = NULL;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type != TypeInt)
+        {
+            ERROR1
+                ("Found constant of type %s where a modifier mask was expected\n",
+                 exprTypeText(expr->type));
+            return False;
+        }
+        else if ((expr->value.ival >= XkbNumModifiers)
+                 || (expr->value.ival < 0))
+        {
+            ERROR2("Illegal modifier index (%d, must be 0..%d)\n",
+                   expr->value.ival, XkbNumModifiers - 1);
+            return False;
+        }
+        val_rtrn->ival = expr->value.ival;
+        return True;
+    case ExprIdent:
+        if (LookupModIndex(lookupPriv, (Atom) None, expr->value.str,
+                           (unsigned) TypeInt, val_rtrn))
+        {
+            return True;
+        }
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeInt, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Cannot determine modifier index for \"%s\"\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        break;
+    case ExprFieldRef:
+        bogus = "field reference";
+        break;
+    case ExprArrayRef:
+        bogus = "array reference";
+        break;
+    case ExprActionDecl:
+        bogus = "function";
+        break;
+    case OpAdd:
+    case OpSubtract:
+    case OpMultiply:
+    case OpDivide:
+    case OpInvert:
+    case OpNegate:
+    case OpNot:
+    case OpUnaryPlus:
+        bogus = "arithmetic operations";
+        break;
+    case OpAssign:
+        bogus = "assignment";
+        break;
+    default:
+        WSGO1("Unknown operator %d in ResolveModIndex\n", expr->op);
+        return False;
     }
-    if (bogus) {
-	ERROR1("Modifier index must be a name or number, %s ignored\n",bogus);
-	return False;
+    if (bogus)
+    {
+        ERROR1("Modifier index must be a name or number, %s ignored\n",
+               bogus);
+        return False;
     }
     return ok;
 }
 
 int
-ExprResolveModMask(	ExprDef *		expr,
-			ExprResult *		val_rtrn,
-			IdentLookupFunc		lookup,
-			XPointer		lookupPriv)
+ExprResolveModMask(ExprDef * expr,
+                   ExprResult * val_rtrn,
+                   IdentLookupFunc lookup, XPointer lookupPriv)
 {
-LookupPriv	priv;
+    LookupPriv priv;
 
-    priv.priv= NULL;
-    priv.chain= lookup;
-    priv.chainPriv= lookupPriv;
-    return ExprResolveMask(expr,val_rtrn,LookupModMask,(XPointer)&priv);
+    priv.priv = NULL;
+    priv.chain = lookup;
+    priv.chainPriv = lookupPriv;
+    return ExprResolveMask(expr, val_rtrn, LookupModMask, (XPointer) & priv);
 }
 
 int
-ExprResolveBoolean(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveBoolean(ExprDef * expr,
+                   ExprResult * val_rtrn,
+                   IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-char *	bogus= NULL;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type!=TypeBoolean) {
-		ERROR1("Found constant of type %s where boolean was expected\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    val_rtrn->ival= expr->value.ival;
-	    return True;
-	case ExprIdent:
-	    bogus= XkbAtomGetString(NULL,expr->value.str);
-	    if (bogus) {
-		if ((uStrCaseCmp(bogus,"true")==0)||
-				(uStrCaseCmp(bogus,"yes")==0)||
-				(uStrCaseCmp(bogus,"on")==0)) {
-		    val_rtrn->uval= 1;
-		    return True;
-		}
-		else if ((uStrCaseCmp(bogus,"false")==0)||
-				(uStrCaseCmp(bogus,"no")==0)||
-				(uStrCaseCmp(bogus,"off")==0)) {
-		    val_rtrn->uval= 0;
-		    return True;
-		}
-	    }
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeBoolean,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Identifier \"%s\" of type int is unknown\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeBoolean,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Default \"%s.%s\" of type boolean is unknown\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case OpInvert: 
-	case OpNot:
-	    ok= ExprResolveBoolean(expr,val_rtrn,lookup,lookupPriv);
-	    if (ok)
-		val_rtrn->uval= !val_rtrn->uval;
-	    return ok;
-	case OpAdd:	 if (bogus==NULL) 	bogus= "Addition";
-	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
-	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
-	case OpDivide:   if (bogus==NULL)	bogus= "Division";
-	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
-	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
-	    ERROR1("%s of boolean values not permitted\n",bogus);
-	    break;
-	case OpUnaryPlus:
-	    ERROR("Unary \"+\" operator not permitted for boolean values\n");
-	    break;
-	default:
-	    WSGO1("Unknown operator %d in ResolveBoolean\n",expr->op);
-	    break;
+    int ok = 0;
+    char *bogus = NULL;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type != TypeBoolean)
+        {
+            ERROR1
+                ("Found constant of type %s where boolean was expected\n",
+                 exprTypeText(expr->type));
+            return False;
+        }
+        val_rtrn->ival = expr->value.ival;
+        return True;
+    case ExprIdent:
+        bogus = XkbAtomGetString(NULL, expr->value.str);
+        if (bogus)
+        {
+            if ((uStrCaseCmp(bogus, "true") == 0) ||
+                (uStrCaseCmp(bogus, "yes") == 0) ||
+                (uStrCaseCmp(bogus, "on") == 0))
+            {
+                val_rtrn->uval = 1;
+                return True;
+            }
+            else if ((uStrCaseCmp(bogus, "false") == 0) ||
+                     (uStrCaseCmp(bogus, "no") == 0) ||
+                     (uStrCaseCmp(bogus, "off") == 0))
+            {
+                val_rtrn->uval = 0;
+                return True;
+            }
+        }
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeBoolean, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Identifier \"%s\" of type int is unknown\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeBoolean, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Default \"%s.%s\" of type boolean is unknown\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case OpInvert:
+    case OpNot:
+        ok = ExprResolveBoolean(expr, val_rtrn, lookup, lookupPriv);
+        if (ok)
+            val_rtrn->uval = !val_rtrn->uval;
+        return ok;
+    case OpAdd:
+        if (bogus == NULL)
+            bogus = "Addition";
+    case OpSubtract:
+        if (bogus == NULL)
+            bogus = "Subtraction";
+    case OpMultiply:
+        if (bogus == NULL)
+            bogus = "Multiplication";
+    case OpDivide:
+        if (bogus == NULL)
+            bogus = "Division";
+    case OpAssign:
+        if (bogus == NULL)
+            bogus = "Assignment";
+    case OpNegate:
+        if (bogus == NULL)
+            bogus = "Negation";
+        ERROR1("%s of boolean values not permitted\n", bogus);
+        break;
+    case OpUnaryPlus:
+        ERROR("Unary \"+\" operator not permitted for boolean values\n");
+        break;
+    default:
+        WSGO1("Unknown operator %d in ResolveBoolean\n", expr->op);
+        break;
     }
     return False;
 }
 
 int
-ExprResolveFloat(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveFloat(ExprDef * expr,
+                 ExprResult * val_rtrn,
+                 IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-ExprResult	leftRtrn,rightRtrn;
-ExprDef		*left,*right;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type==TypeString) {
-		register char *str;
-		str= XkbAtomGetString(NULL,expr->value.str);
-		if ((str!=None)&&(strlen(str)==1)) {
-		    val_rtrn->uval= str[0]*XkbGeomPtsPerMM;
-		    return True;
-		}
-	    }
-	    if ((expr->type!=TypeInt)&&(expr->type!=TypeFloat)) {
-		ERROR1("Found constant of type %s, expected a number\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    val_rtrn->ival= expr->value.ival;
-	    if (expr->type==TypeInt)
-		val_rtrn->ival*= XkbGeomPtsPerMM;
-	    return True;
-	case ExprIdent:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeFloat,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Numeric identifier \"%s\" unknown\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeFloat,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Numeric default \"%s.%s\" unknown\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case OpAdd:
-	case OpSubtract:
-	case OpMultiply:
-	case OpDivide:
-	    left= expr->value.binary.left;
-	    right= expr->value.binary.right;
-	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)&&
-		ExprResolveFloat(right,&rightRtrn,lookup,lookupPriv)) {
-		switch (expr->op) {
-		    case OpAdd: 
-			val_rtrn->ival= leftRtrn.ival+rightRtrn.ival;
-			break;
-		    case OpSubtract: 
-			val_rtrn->ival= leftRtrn.ival-rightRtrn.ival;
-			break;
-		    case OpMultiply: 
-			val_rtrn->ival= leftRtrn.ival*rightRtrn.ival;
-			break;
-		    case OpDivide: 
-			val_rtrn->ival= leftRtrn.ival/rightRtrn.ival;
-			break;
-		}
-		return True;
-	    }
-	    return False;
-	case OpAssign:
-	    WSGO("Assignment operator not implemented yet\n");
-	    break;
-	case OpNot:
-	    left= expr->value.child;
-	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The ! operator cannot be applied to a number\n");
-	    }
-	    return False;
-	case OpInvert:
-	case OpNegate:
-	    left= expr->value.child;
-	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)) {
-		if (expr->op==OpNegate)	
-		     val_rtrn->ival= -leftRtrn.ival;
-		else val_rtrn->ival= ~leftRtrn.ival;
-		return True;
-	    }
-	    return False;
-	case OpUnaryPlus:
-	    left= expr->value.child;
-	    return ExprResolveFloat(left,val_rtrn,lookup,lookupPriv);
-	default:
-	    WSGO1("Unknown operator %d in ResolveFloat\n",expr->op);
-	    break;
+    int ok = 0;
+    ExprResult leftRtrn, rightRtrn;
+    ExprDef *left, *right;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type == TypeString)
+        {
+            register char *str;
+            str = XkbAtomGetString(NULL, expr->value.str);
+            if ((str != NULL) && (strlen(str) == 1))
+            {
+                val_rtrn->uval = str[0] * XkbGeomPtsPerMM;
+                return True;
+            }
+        }
+        if ((expr->type != TypeInt) && (expr->type != TypeFloat))
+        {
+            ERROR1("Found constant of type %s, expected a number\n",
+                   exprTypeText(expr->type));
+            return False;
+        }
+        val_rtrn->ival = expr->value.ival;
+        if (expr->type == TypeInt)
+            val_rtrn->ival *= XkbGeomPtsPerMM;
+        return True;
+    case ExprIdent:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeFloat, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Numeric identifier \"%s\" unknown\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeFloat, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Numeric default \"%s.%s\" unknown\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case OpAdd:
+    case OpSubtract:
+    case OpMultiply:
+    case OpDivide:
+        left = expr->value.binary.left;
+        right = expr->value.binary.right;
+        if (ExprResolveFloat(left, &leftRtrn, lookup, lookupPriv) &&
+            ExprResolveFloat(right, &rightRtrn, lookup, lookupPriv))
+        {
+            switch (expr->op)
+            {
+            case OpAdd:
+                val_rtrn->ival = leftRtrn.ival + rightRtrn.ival;
+                break;
+            case OpSubtract:
+                val_rtrn->ival = leftRtrn.ival - rightRtrn.ival;
+                break;
+            case OpMultiply:
+                val_rtrn->ival = leftRtrn.ival * rightRtrn.ival;
+                break;
+            case OpDivide:
+                val_rtrn->ival = leftRtrn.ival / rightRtrn.ival;
+                break;
+            }
+            return True;
+        }
+        return False;
+    case OpAssign:
+        WSGO("Assignment operator not implemented yet\n");
+        break;
+    case OpNot:
+        left = expr->value.child;
+        if (ExprResolveFloat(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The ! operator cannot be applied to a number\n");
+        }
+        return False;
+    case OpInvert:
+    case OpNegate:
+        left = expr->value.child;
+        if (ExprResolveFloat(left, &leftRtrn, lookup, lookupPriv))
+        {
+            if (expr->op == OpNegate)
+                val_rtrn->ival = -leftRtrn.ival;
+            else
+                val_rtrn->ival = ~leftRtrn.ival;
+            return True;
+        }
+        return False;
+    case OpUnaryPlus:
+        left = expr->value.child;
+        return ExprResolveFloat(left, val_rtrn, lookup, lookupPriv);
+    default:
+        WSGO1("Unknown operator %d in ResolveFloat\n", expr->op);
+        break;
     }
     return False;
 }
 
 int
-ExprResolveInteger(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveInteger(ExprDef * expr,
+                   ExprResult * val_rtrn,
+                   IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-ExprResult	leftRtrn,rightRtrn;
-ExprDef		*left,*right;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type==TypeString) {
-		register char *str;
-		str= XkbAtomGetString(NULL,expr->value.str);
-		if (str!=None)
-		    switch (strlen(str)) {
-			case 0:
-			    val_rtrn->uval= 0;
-			    return True;
-			case 1:
-			    val_rtrn->uval= str[0];
-			    return True;
-			default:
-			    break;
-		}
-	    }
-	    if ((expr->type!=TypeInt)&&(expr->type!=TypeFloat)) {
-		ERROR1("Found constant of type %s where an int was expected\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    val_rtrn->ival= expr->value.ival;
-	    if (expr->type==TypeFloat)
-		val_rtrn->ival/= XkbGeomPtsPerMM;
-	    return True;
-	case ExprIdent:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeInt,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Identifier \"%s\" of type int is unknown\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeInt,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Default \"%s.%s\" of type int is unknown\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case OpAdd:
-	case OpSubtract:
-	case OpMultiply:
-	case OpDivide:
-	    left= expr->value.binary.left;
-	    right= expr->value.binary.right;
-	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)&&
-		ExprResolveInteger(right,&rightRtrn,lookup,lookupPriv)) {
-		switch (expr->op) {
-		    case OpAdd: 
-			val_rtrn->ival= leftRtrn.ival+rightRtrn.ival;
-			break;
-		    case OpSubtract: 
-			val_rtrn->ival= leftRtrn.ival-rightRtrn.ival;
-			break;
-		    case OpMultiply: 
-			val_rtrn->ival= leftRtrn.ival*rightRtrn.ival;
-			break;
-		    case OpDivide: 
-			val_rtrn->ival= leftRtrn.ival/rightRtrn.ival;
-			break;
-		}
-		return True;
-	    }
-	    return False;
-	case OpAssign:
-	    WSGO("Assignment operator not implemented yet\n");
-	    break;
-	case OpNot:
-	    left= expr->value.child;
-	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The ! operator cannot be applied to an integer\n");
-	    }
-	    return False;
-	case OpInvert:
-	case OpNegate:
-	    left= expr->value.child;
-	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
-		if (expr->op==OpNegate)	
-		     val_rtrn->ival= -leftRtrn.ival;
-		else val_rtrn->ival= ~leftRtrn.ival;
-		return True;
-	    }
-	    return False;
-	case OpUnaryPlus:
-	    left= expr->value.child;
-	    return ExprResolveInteger(left,val_rtrn,lookup,lookupPriv);
-	default:
-	    WSGO1("Unknown operator %d in ResolveInteger\n",expr->op);
-	    break;
+    int ok = 0;
+    ExprResult leftRtrn, rightRtrn;
+    ExprDef *left, *right;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type == TypeString)
+        {
+            register char *str;
+            str = XkbAtomGetString(NULL, expr->value.str);
+            if (str != NULL)
+                switch (strlen(str))
+                {
+                case 0:
+                    val_rtrn->uval = 0;
+                    return True;
+                case 1:
+                    val_rtrn->uval = str[0];
+                    return True;
+                default:
+                    break;
+                }
+        }
+        if ((expr->type != TypeInt) && (expr->type != TypeFloat))
+        {
+            ERROR1
+                ("Found constant of type %s where an int was expected\n",
+                 exprTypeText(expr->type));
+            return False;
+        }
+        val_rtrn->ival = expr->value.ival;
+        if (expr->type == TypeFloat)
+            val_rtrn->ival /= XkbGeomPtsPerMM;
+        return True;
+    case ExprIdent:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeInt, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Identifier \"%s\" of type int is unknown\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeInt, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Default \"%s.%s\" of type int is unknown\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case OpAdd:
+    case OpSubtract:
+    case OpMultiply:
+    case OpDivide:
+        left = expr->value.binary.left;
+        right = expr->value.binary.right;
+        if (ExprResolveInteger(left, &leftRtrn, lookup, lookupPriv) &&
+            ExprResolveInteger(right, &rightRtrn, lookup, lookupPriv))
+        {
+            switch (expr->op)
+            {
+            case OpAdd:
+                val_rtrn->ival = leftRtrn.ival + rightRtrn.ival;
+                break;
+            case OpSubtract:
+                val_rtrn->ival = leftRtrn.ival - rightRtrn.ival;
+                break;
+            case OpMultiply:
+                val_rtrn->ival = leftRtrn.ival * rightRtrn.ival;
+                break;
+            case OpDivide:
+                val_rtrn->ival = leftRtrn.ival / rightRtrn.ival;
+                break;
+            }
+            return True;
+        }
+        return False;
+    case OpAssign:
+        WSGO("Assignment operator not implemented yet\n");
+        break;
+    case OpNot:
+        left = expr->value.child;
+        if (ExprResolveInteger(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The ! operator cannot be applied to an integer\n");
+        }
+        return False;
+    case OpInvert:
+    case OpNegate:
+        left = expr->value.child;
+        if (ExprResolveInteger(left, &leftRtrn, lookup, lookupPriv))
+        {
+            if (expr->op == OpNegate)
+                val_rtrn->ival = -leftRtrn.ival;
+            else
+                val_rtrn->ival = ~leftRtrn.ival;
+            return True;
+        }
+        return False;
+    case OpUnaryPlus:
+        left = expr->value.child;
+        return ExprResolveInteger(left, val_rtrn, lookup, lookupPriv);
+    default:
+        WSGO1("Unknown operator %d in ResolveInteger\n", expr->op);
+        break;
     }
     return False;
 }
 
 int
-ExprResolveString(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveString(ExprDef * expr,
+                  ExprResult * val_rtrn,
+                  IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int		ok= 0;
-ExprResult	leftRtrn,rightRtrn;
-ExprDef	*	left;
-ExprDef *	right;
-char *		bogus= NULL;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type!=TypeString) {
-		ERROR1("Found constant of type %s, expected a string\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    val_rtrn->str= XkbAtomGetString(NULL,expr->value.str);
-	    if (val_rtrn->str==NULL) {
-		static char *empty= "";
-		val_rtrn->str= empty;
-	    }
-	    return True;
-	case ExprIdent:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeString,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Identifier \"%s\" of type string not found\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeString,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Default \"%s.%s\" of type string not found\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case OpAdd:
-	    left= expr->value.binary.left;
-	    right= expr->value.binary.right;
-	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)&&
-		ExprResolveString(right,&rightRtrn,lookup,lookupPriv)) {
-		int len;
-		char *new;
-		len= strlen(leftRtrn.str)+strlen(rightRtrn.str)+1;
-		new= (char *)uAlloc(len);
-		if (new) {
-		    sprintf(new,"%s%s",leftRtrn.str,rightRtrn.str);
-		    val_rtrn->str= new;
-		    return True;
-		}
-	    }
-	    return False;
-	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
-	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
-	case OpDivide:   if (bogus==NULL)	bogus= "Division";
-	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
-	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
-	case OpInvert:	 if (bogus==NULL)	bogus= "Bitwise complement";
-	    ERROR1("%s of string values not permitted\n",bogus);
-	    return False;
-	case OpNot:	 
-	    left= expr->value.child;
-	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The ! operator cannot be applied to a string\n");
-	    }
-	    return False;
-	case OpUnaryPlus:
-	    left= expr->value.child;
-	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The + operator cannot be applied to a string\n");
-	    }
-	    return False;
-	default:
-	    WSGO1("Unknown operator %d in ResolveString\n",expr->op);
-	    break;
+    int ok = 0;
+    ExprResult leftRtrn, rightRtrn;
+    ExprDef *left;
+    ExprDef *right;
+    char *bogus = NULL;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type != TypeString)
+        {
+            ERROR1("Found constant of type %s, expected a string\n",
+                   exprTypeText(expr->type));
+            return False;
+        }
+        val_rtrn->str = XkbAtomGetString(NULL, expr->value.str);
+        if (val_rtrn->str == NULL)
+        {
+            static char *empty = "";
+            val_rtrn->str = empty;
+        }
+        return True;
+    case ExprIdent:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeString, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Identifier \"%s\" of type string not found\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeString, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Default \"%s.%s\" of type string not found\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case OpAdd:
+        left = expr->value.binary.left;
+        right = expr->value.binary.right;
+        if (ExprResolveString(left, &leftRtrn, lookup, lookupPriv) &&
+            ExprResolveString(right, &rightRtrn, lookup, lookupPriv))
+        {
+            int len;
+            char *new;
+            len = strlen(leftRtrn.str) + strlen(rightRtrn.str) + 1;
+            new = (char *) uAlloc(len);
+            if (new)
+            {
+                sprintf(new, "%s%s", leftRtrn.str, rightRtrn.str);
+                val_rtrn->str = new;
+                return True;
+            }
+        }
+        return False;
+    case OpSubtract:
+        if (bogus == NULL)
+            bogus = "Subtraction";
+    case OpMultiply:
+        if (bogus == NULL)
+            bogus = "Multiplication";
+    case OpDivide:
+        if (bogus == NULL)
+            bogus = "Division";
+    case OpAssign:
+        if (bogus == NULL)
+            bogus = "Assignment";
+    case OpNegate:
+        if (bogus == NULL)
+            bogus = "Negation";
+    case OpInvert:
+        if (bogus == NULL)
+            bogus = "Bitwise complement";
+        ERROR1("%s of string values not permitted\n", bogus);
+        return False;
+    case OpNot:
+        left = expr->value.child;
+        if (ExprResolveString(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The ! operator cannot be applied to a string\n");
+        }
+        return False;
+    case OpUnaryPlus:
+        left = expr->value.child;
+        if (ExprResolveString(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The + operator cannot be applied to a string\n");
+        }
+        return False;
+    default:
+        WSGO1("Unknown operator %d in ResolveString\n", expr->op);
+        break;
     }
     return False;
 }
 
 int
-ExprResolveKeyName(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveKeyName(ExprDef * expr,
+                   ExprResult * val_rtrn,
+                   IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int		ok= 0;
-ExprDef	*	left;
-ExprResult 	leftRtrn;
-char *		bogus= NULL;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type!=TypeKeyName) {
-		ERROR1("Found constant of type %s, expected a key name\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    memcpy(val_rtrn->keyName.name,expr->value.keyName,XkbKeyNameLength);
-	    return True;
-	case ExprIdent:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeString,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Identifier \"%s\" of type string not found\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeString,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Default \"%s.%s\" of type key name not found\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case OpAdd:	 if (bogus==NULL)	bogus= "Addition";
-	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
-	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
-	case OpDivide:   if (bogus==NULL)	bogus= "Division";
-	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
-	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
-	case OpInvert:	 if (bogus==NULL)	bogus= "Bitwise complement";
-	    ERROR1("%s of key name values not permitted\n",bogus);
-	    return False;
-	case OpNot:	 
-	    left= expr->value.binary.left;
-	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The ! operator cannot be applied to a key name\n");
-	    }
-	    return False;
-	case OpUnaryPlus:
-	    left= expr->value.binary.left;
-	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR("The + operator cannot be applied to a key name\n");
-	    }
-	    return False;
-	default:
-	    WSGO1("Unknown operator %d in ResolveKeyName\n",expr->op);
-	    break;
+    int ok = 0;
+    ExprDef *left;
+    ExprResult leftRtrn;
+    char *bogus = NULL;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type != TypeKeyName)
+        {
+            ERROR1("Found constant of type %s, expected a key name\n",
+                   exprTypeText(expr->type));
+            return False;
+        }
+        memcpy(val_rtrn->keyName.name, expr->value.keyName, XkbKeyNameLength);
+        return True;
+    case ExprIdent:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeString, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Identifier \"%s\" of type string not found\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeString, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Default \"%s.%s\" of type key name not found\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case OpAdd:
+        if (bogus == NULL)
+            bogus = "Addition";
+    case OpSubtract:
+        if (bogus == NULL)
+            bogus = "Subtraction";
+    case OpMultiply:
+        if (bogus == NULL)
+            bogus = "Multiplication";
+    case OpDivide:
+        if (bogus == NULL)
+            bogus = "Division";
+    case OpAssign:
+        if (bogus == NULL)
+            bogus = "Assignment";
+    case OpNegate:
+        if (bogus == NULL)
+            bogus = "Negation";
+    case OpInvert:
+        if (bogus == NULL)
+            bogus = "Bitwise complement";
+        ERROR1("%s of key name values not permitted\n", bogus);
+        return False;
+    case OpNot:
+        left = expr->value.binary.left;
+        if (ExprResolveString(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The ! operator cannot be applied to a key name\n");
+        }
+        return False;
+    case OpUnaryPlus:
+        left = expr->value.binary.left;
+        if (ExprResolveString(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR("The + operator cannot be applied to a key name\n");
+        }
+        return False;
+    default:
+        WSGO1("Unknown operator %d in ResolveKeyName\n", expr->op);
+        break;
     }
     return False;
 }
@@ -828,149 +904,162 @@ char *		bogus= NULL;
 /***====================================================================***/
 
 int
-ExprResolveEnum(ExprDef *expr,ExprResult *val_rtrn,LookupEntry	*values)
+ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, LookupEntry * values)
 {
-    if (expr->op!=ExprIdent) {
-	ERROR1("Found a %s where an enumerated value was expected\n",
-							exprOpText(expr->op));
-	return False;
+    if (expr->op != ExprIdent)
+    {
+        ERROR1("Found a %s where an enumerated value was expected\n",
+               exprOpText(expr->op));
+        return False;
     }
-    if (!SimpleLookup((XPointer)values,(Atom)None,expr->value.str,
-						(unsigned)TypeInt,val_rtrn)) {
-	int	nOut=0;
-	ERROR1("Illegal identifier %s (expected one of: ",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	while (values && values->name) {
-	    if (nOut!=0)	INFO1(", %s",values->name);
-	    else		INFO1("%s",values->name);
-	    values++;
-	    nOut++;
-	}
-	INFO(")\n");
-	return False;
+    if (!SimpleLookup((XPointer) values, (Atom) None, expr->value.str,
+                      (unsigned) TypeInt, val_rtrn))
+    {
+        int nOut = 0;
+        ERROR1("Illegal identifier %s (expected one of: ",
+               XkbAtomText(NULL, expr->value.str, XkbMessage));
+        while (values && values->name)
+        {
+            if (nOut != 0)
+                INFO1(", %s", values->name);
+            else
+                INFO1("%s", values->name);
+            values++;
+            nOut++;
+        }
+        INFO(")\n");
+        return False;
     }
     return True;
 }
 
 int
-ExprResolveMask(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveMask(ExprDef * expr,
+                ExprResult * val_rtrn,
+                IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-ExprResult	leftRtrn,rightRtrn;
-ExprDef		*left,*right;
-char *		bogus= NULL;
-
-    switch (expr->op) {
-	case ExprValue:
-	    if (expr->type!=TypeInt) {
-		ERROR1("Found constant of type %s where a mask was expected\n",
-						exprTypeText(expr->type));
-		return False;
-	    }
-	    val_rtrn->ival= expr->value.ival;
-	    return True;
-	case ExprIdent:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-				 None,expr->value.str,
-				 TypeInt,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR1("Identifier \"%s\" of type int is unknown\n",
-				XkbAtomText(NULL,expr->value.str,XkbMessage));
-	    return ok;
-	case ExprFieldRef:
-	    if (lookup) {
-		ok= (*lookup)(lookupPriv,
-			 expr->value.field.element,expr->value.field.field,
-			 TypeInt,val_rtrn);
-	    }
-	    if (!ok)
-		ERROR2("Default \"%s.%s\" of type int is unknown\n",
-			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
-			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
-	    return ok;
-	case ExprArrayRef:
-	    bogus= "array reference";
-	case ExprActionDecl:
-	    if (bogus==NULL)
-		bogus= "function use";
-	    ERROR1("Unexpected %s in mask expression\n",bogus);
-	    ACTION("Expression ignored\n");
-	    return False;
-	case OpAdd:
-	case OpSubtract:
-	case OpMultiply:
-	case OpDivide:
-	    left= expr->value.binary.left;
-	    right= expr->value.binary.right;
-	    if (ExprResolveMask(left,&leftRtrn,lookup,lookupPriv)&&
-		ExprResolveMask(right,&rightRtrn,lookup,lookupPriv)) {
-		switch (expr->op) {
-		    case OpAdd: 
-			val_rtrn->ival= leftRtrn.ival|rightRtrn.ival;
-			break;
-		    case OpSubtract: 
-			val_rtrn->ival= leftRtrn.ival&(~rightRtrn.ival);
-			break;
-		    case OpMultiply: 
-		    case OpDivide: 
-			ERROR1("Cannot %s masks\n",
-					expr->op==OpDivide?"divide":"multiply");
-			ACTION("Illegal operation ignored\n");
-			return False;
-		}
-		return True;
-	    }
-	    return False;
-	case OpAssign:
-	    WSGO("Assignment operator not implemented yet\n");
-	    break;
-	case OpInvert:
-	    left= expr->value.child;
-	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
-		val_rtrn->ival= ~leftRtrn.ival;
-		return True;
-	    }
-	    return False;
-	case OpUnaryPlus:
-	case OpNegate:
-	case OpNot:
-	    left= expr->value.child;
-	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
-		ERROR1("The %s operator cannot be used with a mask\n",
-					(expr->op==OpNegate?"-":"!"));
-	    }
-	    return False;
-	default:
-	    WSGO1("Unknown operator %d in ResolveMask\n",expr->op);
-	    break;
+    int ok = 0;
+    ExprResult leftRtrn, rightRtrn;
+    ExprDef *left, *right;
+    char *bogus = NULL;
+
+    switch (expr->op)
+    {
+    case ExprValue:
+        if (expr->type != TypeInt)
+        {
+            ERROR1
+                ("Found constant of type %s where a mask was expected\n",
+                 exprTypeText(expr->type));
+            return False;
+        }
+        val_rtrn->ival = expr->value.ival;
+        return True;
+    case ExprIdent:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            None, expr->value.str, TypeInt, val_rtrn);
+        }
+        if (!ok)
+            ERROR1("Identifier \"%s\" of type int is unknown\n",
+                   XkbAtomText(NULL, expr->value.str, XkbMessage));
+        return ok;
+    case ExprFieldRef:
+        if (lookup)
+        {
+            ok = (*lookup) (lookupPriv,
+                            expr->value.field.element,
+                            expr->value.field.field, TypeInt, val_rtrn);
+        }
+        if (!ok)
+            ERROR2("Default \"%s.%s\" of type int is unknown\n",
+                   XkbAtomText(NULL, expr->value.field.element, XkbMessage),
+                   XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+        return ok;
+    case ExprArrayRef:
+        bogus = "array reference";
+    case ExprActionDecl:
+        if (bogus == NULL)
+            bogus = "function use";
+        ERROR1("Unexpected %s in mask expression\n", bogus);
+        ACTION("Expression ignored\n");
+        return False;
+    case OpAdd:
+    case OpSubtract:
+    case OpMultiply:
+    case OpDivide:
+        left = expr->value.binary.left;
+        right = expr->value.binary.right;
+        if (ExprResolveMask(left, &leftRtrn, lookup, lookupPriv) &&
+            ExprResolveMask(right, &rightRtrn, lookup, lookupPriv))
+        {
+            switch (expr->op)
+            {
+            case OpAdd:
+                val_rtrn->ival = leftRtrn.ival | rightRtrn.ival;
+                break;
+            case OpSubtract:
+                val_rtrn->ival = leftRtrn.ival & (~rightRtrn.ival);
+                break;
+            case OpMultiply:
+            case OpDivide:
+                ERROR1("Cannot %s masks\n",
+                       expr->op == OpDivide ? "divide" : "multiply");
+                ACTION("Illegal operation ignored\n");
+                return False;
+            }
+            return True;
+        }
+        return False;
+    case OpAssign:
+        WSGO("Assignment operator not implemented yet\n");
+        break;
+    case OpInvert:
+        left = expr->value.child;
+        if (ExprResolveInteger(left, &leftRtrn, lookup, lookupPriv))
+        {
+            val_rtrn->ival = ~leftRtrn.ival;
+            return True;
+        }
+        return False;
+    case OpUnaryPlus:
+    case OpNegate:
+    case OpNot:
+        left = expr->value.child;
+        if (ExprResolveInteger(left, &leftRtrn, lookup, lookupPriv))
+        {
+            ERROR1("The %s operator cannot be used with a mask\n",
+                   (expr->op == OpNegate ? "-" : "!"));
+        }
+        return False;
+    default:
+        WSGO1("Unknown operator %d in ResolveMask\n", expr->op);
+        break;
     }
     return False;
 }
 
 int
-ExprResolveKeySym(	ExprDef *	expr,
-			ExprResult *	val_rtrn,
-			IdentLookupFunc	lookup,
-			XPointer	lookupPriv)
+ExprResolveKeySym(ExprDef * expr,
+                  ExprResult * val_rtrn,
+                  IdentLookupFunc lookup, XPointer lookupPriv)
 {
-int	ok= 0;
-KeySym	sym;
-
-    if (expr->op==ExprIdent) {
-	char *str;
-	str= XkbAtomGetString(NULL,expr->value.str);
-	if ((str!=NULL)&&((sym= XStringToKeysym(str))!=NoSymbol)) {
-	    val_rtrn->uval= sym;
-	    return True;
-	}
+    int ok = 0;
+    KeySym sym;
+
+    if (expr->op == ExprIdent)
+    {
+        char *str;
+        str = XkbAtomGetString(NULL, expr->value.str);
+        if ((str != NULL) && ((sym = XStringToKeysym(str)) != NoSymbol))
+        {
+            val_rtrn->uval = sym;
+            return True;
+        }
     }
-    ok= ExprResolveInteger(expr,val_rtrn,lookup,lookupPriv);
-    if ((ok)&&(val_rtrn->uval<10))
-	val_rtrn->uval+= '0';
+    ok = ExprResolveInteger(expr, val_rtrn, lookup, lookupPriv);
+    if ((ok) && (val_rtrn->uval < 10))
+        val_rtrn->uval += '0';
     return ok;
 }