xkbcomp/expr: remove unused ExprResolveKeyCode

src/xkbcomp/expr.c

@@ -186,89 +186,6 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
     return false;
 }
 
-bool
-ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
-                   xkb_keycode_t *kc)
-{
-    xkb_keycode_t leftRtrn, rightRtrn;
-
-    switch (expr->common.type) {
-    case STMT_EXPR_INTEGER_LITERAL:
-        *kc = (xkb_keycode_t) expr->integer.ival;
-        return true;
-
-    case STMT_EXPR_STRING_LITERAL:
-    case STMT_EXPR_FLOAT_LITERAL:
-    case STMT_EXPR_BOOLEAN_LITERAL:
-    case STMT_EXPR_KEYNAME_LITERAL:
-        log_err(ctx, XKB_ERROR_WRONG_FIELD_TYPE,
-                "Found %s where an int was expected\n",
-                stmt_type_to_string(expr->common.type));
-        return false;
-
-    case STMT_EXPR_ADD:
-    case STMT_EXPR_SUBTRACT:
-    case STMT_EXPR_MULTIPLY:
-    case STMT_EXPR_DIVIDE:
-        if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
-            !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
-            return false;
-
-        switch (expr->common.type) {
-        case STMT_EXPR_ADD:
-            *kc = leftRtrn + rightRtrn;
-            break;
-        case STMT_EXPR_SUBTRACT:
-            *kc = leftRtrn - rightRtrn;
-            break;
-        case STMT_EXPR_MULTIPLY:
-            *kc = leftRtrn * rightRtrn;
-            break;
-        case STMT_EXPR_DIVIDE:
-            if (rightRtrn == 0) {
-                log_err(ctx, XKB_ERROR_INVALID_OPERATION,
-                        "Cannot divide by zero: %d / %d\n",
-                        leftRtrn, rightRtrn);
-                return false;
-            }
-
-            *kc = leftRtrn / rightRtrn;
-            break;
-        default:
-            break;
-        }
-
-        return true;
-
-    case STMT_EXPR_NEGATE:
-        if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
-            return false;
-
-        *kc = ~leftRtrn;
-        return true;
-
-    case STMT_EXPR_UNARY_PLUS:
-        return ExprResolveKeyCode(ctx, expr->unary.child, kc);
-
-    default:
-        log_wsgo(ctx, XKB_ERROR_INVALID_SYNTAX,
-                 "Unknown operator %d in ResolveKeyCode\n", expr->common.type);
-        break;
-    }
-
-    return false;
-}
-
-/**
- * This function returns ... something.  It's a bit of a guess, really.
- *
- * If an integer is given in value ctx, it will be returned in ival.
- * If an ident or field reference is given, the lookup function (if given)
- * will be called.  At the moment, only SimpleLookup use this, and they both
- * return the results in uval.  And don't support field references.
- *
- * Cool.
- */
 static bool
 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
                          int *val_rtrn, IdentLookupFunc lookup,

src/xkbcomp/expr.h

@@ -27,10 +27,6 @@ bool
 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
                    bool *set_rtrn);
 
-bool
-ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
-                   xkb_keycode_t *kc);
-
 bool
 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
                    int *val_rtrn);