kc3-lang/libxkbcommon

diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c
index 9c9c546..35fd6e5 100644
--- a/src/xkbcomp/action.c
+++ b/src/xkbcomp/action.c
@@ -427,7 +427,6 @@ static bool
 HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action,
               unsigned field, ExprDef *array_ndx, ExprDef *value)
 {
-    ExprResult rtrn;
     struct xkb_pointer_action *act;
     bool absolute;
 
@@ -435,23 +434,28 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action,
     if ((array_ndx != NULL) && ((field == F_X) || (field == F_Y)))
         return ReportActionNotArray(keymap, action->type, field);
 
-    if ((field == F_X) || (field == F_Y)) {
+    if (field == F_X || field == F_Y) {
+        int val;
+
         if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS)
             absolute = false;
         else
             absolute = true;
-        if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+
+        if (!ExprResolveInteger(keymap->ctx, value, &val))
             return ReportMismatch(keymap, action->type, field, "integer");
+
         if (field == F_X) {
             if (absolute)
                 act->flags |= XkbSA_MoveAbsoluteX;
-            act->x = rtrn.ival;
+            act->x = val;
         }
         else {
             if (absolute)
                 act->flags |= XkbSA_MoveAbsoluteY;
-            act->y = rtrn.ival;
+            act->y = val;
         }
+
         return true;
     }
     else if (field == F_Accel) {
@@ -673,8 +677,11 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
     act = (struct xkb_switch_screen_action *) action;
     if (field == F_Screen) {
         ExprDef *scrn;
-        if (array_ndx != NULL)
+        int val;
+
+        if (array_ndx)
             return ReportActionNotArray(keymap, action->type, field);
+
         if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS) {
             act->flags &= ~XkbSA_SwitchAbsolute;
             scrn = value->value.child;
@@ -684,19 +691,18 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
             scrn = value;
         }
 
-        if (!ExprResolveInteger(keymap->ctx, scrn, &rtrn))
+        if (!ExprResolveInteger(keymap->ctx, scrn, &val))
             return ReportMismatch(keymap, action->type, field,
                                   "integer (0..255)");
-        if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+        if (val < 0 || val > 255) {
             log_err(keymap->ctx,
                     "Screen index must be in the range 1..255; "
                     "Illegal screen value %d ignored\n", rtrn.ival);
             return false;
         }
-        if (value->op == EXPR_NEGATE)
-            act->screen = -rtrn.ival;
-        else
-            act->screen = rtrn.ival;
+
+        act->screen = (value->op == EXPR_NEGATE ? -val : val);
         return true;
     }
     else if (field == F_Same) {
@@ -826,32 +832,38 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action,
             return true;
         }
         else {
-            unsigned ndx;
-            if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) {
+            int ndx, datum;
+
+            if (!ExprResolveInteger(keymap->ctx, array_ndx, &ndx)) {
                 log_err(keymap->ctx,
                         "Array subscript must be integer; "
                         "Illegal subscript ignored\n");
                 return false;
             }
-            ndx = rtrn.uval;
-            if (ndx > 5) {
+
+            if (ndx < 0 || ndx > 5) {
                 log_err(keymap->ctx,
                         "An action message is at most 6 bytes long; "
                         "Attempt to use data[%d] ignored\n", ndx);
                 return false;
             }
-            if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+
+            if (!ExprResolveInteger(keymap->ctx, value, &datum))
                 return ReportMismatch(keymap, action->type, field, "integer");
-            if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+            if (datum < 0 || datum > 255) {
                 log_err(keymap->ctx,
                         "Message data must be in the range 0..255; "
-                        "Illegal datum %d ignored\n", rtrn.ival);
+                        "Illegal datum %d ignored\n", datum);
                 return false;
             }
-            act->message[ndx] = rtrn.uval;
+
+            act->message[ndx] = (uint8_t) datum;
         }
+
         return true;
     }
+
     return ReportIllegal(keymap, action->type, field);
 }
 
@@ -915,18 +927,23 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
 
     act = (struct xkb_device_button_action *) action;
     if (field == F_Button) {
-        if (array_ndx != NULL)
+        int val;
+
+        if (array_ndx)
             return ReportActionNotArray(keymap, action->type, field);
-        if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+
+        if (!ExprResolveInteger(keymap->ctx, value, &val))
             return ReportMismatch(keymap, action->type, field,
                                   "integer (range 1..255)");
-        if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+        if (val < 0 || val > 255) {
             log_err(keymap->ctx,
                     "Button must specify default or be in the range 1..255; "
-                    "Illegal button value %d ignored\n", rtrn.ival);
+                    "Illegal button value %d ignored\n", val);
             return false;
         }
-        act->button = rtrn.ival;
+
+        act->button = val;
         return true;
     }
     else if ((action->type == XkbSA_LockDeviceBtn) && (field == F_Affect)) {
@@ -960,20 +977,26 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
         return true;
     }
     else if (field == F_Device) {
-        if (array_ndx != NULL)
+        int val;
+
+        if (array_ndx)
             return ReportActionNotArray(keymap, action->type, field);
-        if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+
+        if (!ExprResolveInteger(keymap->ctx, value, &val))
             return ReportMismatch(keymap, action->type, field,
                                   "integer (range 1..255)");
-        if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+        if (val < 0 || val > 255) {
             log_err(keymap->ctx,
                     "Device must specify default or be in the range 1..255; "
-                    "Illegal device value %d ignored\n", rtrn.ival);
+                    "Illegal device value %d ignored\n", val);
             return false;
         }
-        act->device = rtrn.ival;
+
+        act->device = val;
         return true;
     }
+
     return ReportIllegal(keymap, action->type, field);
 }
 
@@ -995,22 +1018,23 @@ static bool
 HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action,
               unsigned field, ExprDef *array_ndx, ExprDef *value)
 {
-    ExprResult rtrn;
+    if (field == F_Type) {
+        int type;
 
-    switch (field) {
-    case F_Type:
-        if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+        if (!ExprResolveInteger(keymap->ctx, value, &type))
             return ReportMismatch(keymap, PrivateAction, field, "integer");
-        if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+        if (type < 0 || type > 255) {
             log_err(keymap->ctx,
                     "Private action type must be in the range 0..255; "
-                    "Illegal type %d ignored\n", rtrn.ival);
+                    "Illegal type %d ignored\n", type);
             return false;
         }
-        action->type = rtrn.uval;
-        return true;
 
-    case F_Data:
+        action->type = (uint8_t) type;
+        return true;
+    }
+    else if (field == F_Data) {
         if (array_ndx == NULL) {
             const char *str;
             int len;
@@ -1030,32 +1054,38 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action,
             return true;
         }
         else {
-            unsigned ndx;
-            if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) {
+            int ndx, datum;
+
+            if (!ExprResolveInteger(keymap->ctx, array_ndx, &ndx)) {
                 log_err(keymap->ctx,
                         "Array subscript must be integer; "
                         "Illegal subscript ignored\n");
                 return false;
             }
-            ndx = rtrn.uval;
-            if (ndx >= sizeof action->data) {
+
+            if (ndx < 0 || ndx >= sizeof(action->data)) {
                 log_err(keymap->ctx,
-                        "The data for a private action is 18 bytes long; "
-                        "Attempt to use data[%d] ignored\n", ndx);
+                        "The data for a private action is %zu bytes long; "
+                        "Attempt to use data[%d] ignored\n",
+                        sizeof(action->data), ndx);
                 return false;
             }
-            if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+
+            if (!ExprResolveInteger(keymap->ctx, value, &datum))
                 return ReportMismatch(keymap, action->type, field, "integer");
-            if ((rtrn.ival < 0) || (rtrn.ival > 255)) {
+
+            if (datum < 0 || datum > 255) {
                 log_err(keymap->ctx,
                         "All data for a private action must be 0..255; "
-                        "Illegal datum %d ignored\n", rtrn.ival);
+                        "Illegal datum %d ignored\n", datum);
                 return false;
             }
-            action->data[ndx] = rtrn.uval;
+
+            action->data[ndx] = (uint8_t) datum;
             return true;
         }
     }
+
     return ReportIllegal(keymap, PrivateAction, field);
 }
 
diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index ea42f21..c7b07f9 100644
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -851,14 +851,16 @@ SetIndicatorMapField(CompatInfo *info, LEDInfo *led,
         led->defined |= _LED_DrivesKbd;
     }
     else if (istreq(field, "index")) {
-        if (arrayNdx != NULL)
+        int ndx;
+
+        if (arrayNdx)
             return ReportIndicatorNotArray(info, led, field);
 
-        if (!ExprResolveInteger(keymap->ctx, value, &rtrn))
+        if (!ExprResolveInteger(keymap->ctx, value, &ndx))
             return ReportIndicatorBadType(info, led, field,
                                           "indicator index");
 
-        if (rtrn.uval < 1 || rtrn.uval > 32) {
+        if (ndx < 1 || ndx > 32) {
             log_err(info->keymap->ctx,
                     "Illegal indicator index %d (range 1..%d); "
                     "Index definition for %s indicator ignored\n",
@@ -867,7 +869,7 @@ SetIndicatorMapField(CompatInfo *info, LEDInfo *led,
             return false;
         }
 
-        led->indicator = rtrn.uval;
+        led->indicator = (unsigned char) ndx;
         led->defined |= _LED_Index;
     }
     else {
diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c
index 0d67c2d..c73d5c7 100644
--- a/src/xkbcomp/expr.c
+++ b/src/xkbcomp/expr.c
@@ -488,11 +488,15 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
     return false;
 }
 
-int
-ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr,
-                   ExprResult *val_rtrn)
+bool
+ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn)
 {
-    return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
+    ExprResult result;
+    bool ok;
+    ok = ExprResolveIntegerLookup(ctx, expr, &result, NULL, NULL);
+    if (ok)
+        *val_rtrn = result.ival;
+    return ok;
 }
 
 bool
@@ -835,8 +839,7 @@ bool
 ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
                   xkb_keysym_t *sym_rtrn)
 {
-    bool ok = false;
-    ExprResult result;
+    int val;
 
     if (expr->op == EXPR_IDENT) {
         const char *str;
@@ -846,9 +849,12 @@ ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
             return true;
     }
 
-    ok = ExprResolveInteger(ctx, expr, &result);
-    if (ok && result.uval < 10)
-        *sym_rtrn = result.uval + '0';
+    if (!ExprResolveInteger(ctx, expr, &val))
+        return false;
 
-    return ok;
+    if (val < 0 || val >= 10)
+        return false;
+
+    *sym_rtrn = ((xkb_keysym_t) val) + '0';
+    return true;
 }
diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h
index d4a0560..abdd514 100644
--- a/src/xkbcomp/expr.h
+++ b/src/xkbcomp/expr.h
@@ -72,9 +72,8 @@ ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn);
 bool
 ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr, xkb_keycode_t *kc);
 
-extern int
-ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr,
-                   ExprResult *val_rtrn);
+bool
+ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn);
 
 bool
 ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c
index 9a18424..d6cac95 100644
--- a/src/xkbcomp/vmod.c
+++ b/src/xkbcomp/vmod.c
@@ -222,6 +222,8 @@ bool
 ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
                        ExprResult *val_rtrn, VModInfo *info)
 {
+    int val;
+
     if (def->op == EXPR_IDENT) {
         xkb_mod_index_t i;
         xkb_mod_mask_t bit;
@@ -235,12 +237,17 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
             }
         }
     }
-    if (ExprResolveInteger(keymap->ctx, def, val_rtrn)) {
-        if (val_rtrn->uval < XkbNumVirtualMods)
-            return true;
+
+    if (!ExprResolveInteger(keymap->ctx, def, &val))
+        return false;
+
+    if (val < 0 || val >= XkbNumVirtualMods) {
         log_err(keymap->ctx,
                 "Illegal virtual modifier %d (must be 0..%d inclusive)\n",
-                val_rtrn->uval, XkbNumVirtualMods - 1);
+                val, XkbNumVirtualMods - 1);
+        return false;
     }
-    return false;
+
+    val_rtrn->uval = (unsigned int) val;
+    return true;
 }