dos -> unix

1 files changed, 1065 insertions, 1065 deletions

diff --git a/xkbcomp/expr.c b/xkbcomp/expr.c
index 33a2dddee..96fd95675 100644
--- a/xkbcomp/expr.c
+++ b/xkbcomp/expr.c
@@ -1,1065 +1,1065 @@
-/************************************************************

- Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.

-

- Permission to use, copy, modify, and distribute this

- software and its documentation for any purpose and without

- fee is hereby granted, provided that the above copyright

- notice appear in all copies and that both that copyright

- notice and this permission notice appear in supporting

- documentation, and that the name of Silicon Graphics not be 

- used in advertising or publicity pertaining to distribution 

- of the software without specific prior written permission.

- Silicon Graphics makes no representation about the suitability 

- of this software for any purpose. It is provided "as is"

- without any express or implied warranty.

- 

- SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 

- SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 

- AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON

- GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 

- DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 

- DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 

- OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH

- THE USE OR PERFORMANCE OF THIS SOFTWARE.

-

- ********************************************************/

-

-#include "xkbcomp.h"

-#include "tokens.h"

-#include "expr.h"

-

-#include <ctype.h>

-

-/***====================================================================***/

-

-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:

-        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:

-        snprintf(buf, sizeof(buf), "illegal(%d)", type);

-        break;

-    }

-    return buf;

-}

-

-int

-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;

-    }

-    WSGO1("Unexpected operator %d in ResolveLhs\n", expr->op);

-    return False;

-}

-

-Bool

-SimpleLookup(XPointer priv,

-             Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)

-{

-    LookupEntry *entry;

-    register char *str;

-

-    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;

-        }

-    }

-    return False;

-}

-

-Bool

-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;

-    }

-    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)

-{

-    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);

-}

-

-static LookupEntry modIndexNames[] = {

-    {"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)

-{

-    return SimpleLookup((XPointer) modIndexNames, elem, field, type,

-                        val_rtrn);

-}

-

-int

-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;

-    }

-    else

-        return False;

-    return True;

-}

-

-int

-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;

-    }

-    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)

-{

-    LookupPriv 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)

-{

-    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)

-{

-    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)

-{

-    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)

-{

-    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)

-{

-    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;

-}

-

-/***====================================================================***/

-

-int

-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 (!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)

-{

-    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)

-{

-    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';

-    return ok;

-}

+/************************************************************
+ Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
+
+ Permission to use, copy, modify, and distribute this
+ software and its documentation for any purpose and without
+ fee is hereby granted, provided that the above copyright
+ notice appear in all copies and that both that copyright
+ notice and this permission notice appear in supporting
+ documentation, and that the name of Silicon Graphics not be 
+ used in advertising or publicity pertaining to distribution 
+ of the software without specific prior written permission.
+ Silicon Graphics makes no representation about the suitability 
+ of this software for any purpose. It is provided "as is"
+ without any express or implied warranty.
+ 
+ SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+ OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+
+#include <ctype.h>
+
+/***====================================================================***/
+
+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:
+        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:
+        snprintf(buf, sizeof(buf), "illegal(%d)", type);
+        break;
+    }
+    return buf;
+}
+
+int
+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;
+    }
+    WSGO1("Unexpected operator %d in ResolveLhs\n", expr->op);
+    return False;
+}
+
+Bool
+SimpleLookup(XPointer priv,
+             Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
+{
+    LookupEntry *entry;
+    register char *str;
+
+    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;
+        }
+    }
+    return False;
+}
+
+Bool
+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;
+    }
+    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)
+{
+    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);
+}
+
+static LookupEntry modIndexNames[] = {
+    {"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)
+{
+    return SimpleLookup((XPointer) modIndexNames, elem, field, type,
+                        val_rtrn);
+}
+
+int
+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;
+    }
+    else
+        return False;
+    return True;
+}
+
+int
+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;
+    }
+    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)
+{
+    LookupPriv 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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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;
+}
+
+/***====================================================================***/
+
+int
+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 (!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)
+{
+    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)
+{
+    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';
+    return ok;
+}