kc3-lang/libxkbcommon/src/xkbcomp/expr.c

Branch - branch -master

• Show log

  Commit

• Hash : c0065c95
  Author :
  Date : 2023-09-21T20:06:27
  

  Messages: merge macros with and without message code Previously we had two types of macros for logging: with and without message code. They were intended to be merged afterwards. The idea is to use a special code – `XKB_LOG_MESSAGE_NO_ID = 0` – that should *not* be displayed. But we would like to avoid checking this special code at run time. This is achieved using macro tricks; they are detailed in the code (see: `PREPEND_MESSAGE_ID`). Now it is also easier to spot the remaining undocumented log entries: just search `XKB_LOG_MESSAGE_NO_ID`.

Download

• src/xkbcomp/expr.c

• /************************************************************
   * 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 "config.h"
  
  #include "xkbcomp-priv.h"
  #include "text.h"
  #include "expr.h"
  #include "keysym.h"
  
  typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
                                  xkb_atom_t field, enum expr_value_type type,
                                  unsigned int *val_rtrn);
  
  bool
  ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
                 const char **elem_rtrn, const char **field_rtrn,
                 ExprDef **index_rtrn)
  {
      switch (expr->expr.op) {
      case EXPR_IDENT:
          *elem_rtrn = NULL;
          *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
          *index_rtrn = NULL;
          return (*field_rtrn != NULL);
      case EXPR_FIELD_REF:
          *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
          *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
          *index_rtrn = NULL;
          return (*elem_rtrn != NULL && *field_rtrn != NULL);
      case EXPR_ARRAY_REF:
          *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
          *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
          *index_rtrn = expr->array_ref.entry;
          if (expr->array_ref.element != XKB_ATOM_NONE && *elem_rtrn == NULL)
              return false;
          if (*field_rtrn == NULL)
              return false;
          return true;
      default:
          break;
      }
      log_wsgo(ctx,
          XKB_ERROR_INVALID_SYNTAX,
          "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
      return false;
  }
  
  static bool
  SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
               enum expr_value_type type, unsigned int *val_rtrn)
  {
      const LookupEntry *entry;
      const char *str;
  
      if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
          return false;
  
      str = xkb_atom_text(ctx, field);
      for (entry = priv; entry && entry->name; entry++) {
          if (istreq(str, entry->name)) {
              *val_rtrn = entry->value;
              return true;
          }
      }
  
      return false;
  }
  
  /* Data passed in the *priv argument for LookupModMask. */
  typedef struct {
      const struct xkb_mod_set *mods;
      enum mod_type mod_type;
  } LookupModMaskPriv;
  
  static bool
  LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
                enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
  {
      const char *str;
      xkb_mod_index_t ndx;
      const LookupModMaskPriv *arg = priv;
      const struct xkb_mod_set *mods = arg->mods;
      enum mod_type mod_type = arg->mod_type;
  
      if (type != EXPR_TYPE_INT)
          return false;
  
      str = xkb_atom_text(ctx, field);
      if (!str)
          return false;
  
      if (istreq(str, "all")) {
          *val_rtrn  = MOD_REAL_MASK_ALL;
          return true;
      }
  
      if (istreq(str, "none")) {
          *val_rtrn = 0;
          return true;
      }
  
      ndx = XkbModNameToIndex(mods, field, mod_type);
      if (ndx == XKB_MOD_INVALID)
          return false;
  
      *val_rtrn = (1u << ndx);
      return true;
  }
  
  bool
  ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
                     bool *set_rtrn)
  {
      bool ok = false;
      const char *ident;
  
      switch (expr->expr.op) {
      case EXPR_VALUE:
          if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
              log_err(ctx,
                      XKB_ERROR_WRONG_FIELD_TYPE,
                      "Found constant of type %s where boolean was expected\n",
                      expr_value_type_to_string(expr->expr.value_type));
              return false;
          }
          *set_rtrn = expr->boolean.set;
          return true;
  
      case EXPR_IDENT:
          ident = xkb_atom_text(ctx, expr->ident.ident);
          if (ident) {
              if (istreq(ident, "true") ||
                  istreq(ident, "yes") ||
                  istreq(ident, "on")) {
                  *set_rtrn = true;
                  return true;
              }
              else if (istreq(ident, "false") ||
                       istreq(ident, "no") ||
                       istreq(ident, "off")) {
                  *set_rtrn = false;
                  return true;
              }
          }
          log_err(ctx,
              XKB_ERROR_INVALID_IDENTIFIER,
              "Identifier \"%s\" of type boolean is unknown\n", ident);
          return false;
  
      case EXPR_FIELD_REF:
          log_err(ctx,
                  XKB_ERROR_INVALID_EXPRESSION_TYPE,
                  "Default \"%s.%s\" of type boolean is unknown\n",
                  xkb_atom_text(ctx, expr->field_ref.element),
                  xkb_atom_text(ctx, expr->field_ref.field));
          return false;
  
      case EXPR_INVERT:
      case EXPR_NOT:
          ok = ExprResolveBoolean(ctx, expr->unary.child, set_rtrn);
          if (ok)
              *set_rtrn = !*set_rtrn;
          return ok;
      case EXPR_ADD:
      case EXPR_SUBTRACT:
      case EXPR_MULTIPLY:
      case EXPR_DIVIDE:
      case EXPR_ASSIGN:
      case EXPR_NEGATE:
      case EXPR_UNARY_PLUS:
      case EXPR_ACTION_DECL:
      case EXPR_ACTION_LIST:
      case EXPR_KEYSYM_LIST:
          log_err(ctx,
                  XKB_ERROR_INVALID_OPERATION,
                  "%s of boolean values not permitted\n",
                  expr_op_type_to_string(expr->expr.op));
          break;
  
      default:
          log_wsgo(ctx,
                   XKB_ERROR_UNKNOWN_OPERATOR,
                   "Unknown operator %d in ResolveBoolean\n",
                   expr->expr.op);
          break;
      }
  
      return false;
  }
  
  bool
  ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
                     xkb_keycode_t *kc)
  {
      xkb_keycode_t leftRtrn, rightRtrn;
  
      switch (expr->expr.op) {
      case EXPR_VALUE:
          if (expr->expr.value_type != EXPR_TYPE_INT) {
              log_err(ctx,
                      XKB_ERROR_WRONG_FIELD_TYPE,
                      "Found constant of type %s where an int was expected\n",
                      expr_value_type_to_string(expr->expr.value_type));
              return false;
          }
  
          *kc = (xkb_keycode_t) expr->integer.ival;
          return true;
  
      case EXPR_ADD:
      case EXPR_SUBTRACT:
      case EXPR_MULTIPLY:
      case EXPR_DIVIDE:
          if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
              !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
              return false;
  
          switch (expr->expr.op) {
          case EXPR_ADD:
              *kc = leftRtrn + rightRtrn;
              break;
          case EXPR_SUBTRACT:
              *kc = leftRtrn - rightRtrn;
              break;
          case EXPR_MULTIPLY:
              *kc = leftRtrn * rightRtrn;
              break;
          case 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 EXPR_NEGATE:
          if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
              return false;
  
          *kc = ~leftRtrn;
          return true;
  
      case 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->expr.op);
          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,
                           const void *lookupPriv)
  {
      bool ok = false;
      int l, r;
      unsigned u;
      ExprDef *left, *right;
  
      switch (expr->expr.op) {
      case EXPR_VALUE:
          if (expr->expr.value_type != EXPR_TYPE_INT) {
              log_err(ctx,
                      XKB_ERROR_WRONG_FIELD_TYPE,
                      "Found constant of type %s where an int was expected\n",
                      expr_value_type_to_string(expr->expr.value_type));
              return false;
          }
  
          *val_rtrn = expr->integer.ival;
          return true;
  
      case EXPR_IDENT:
          if (lookup)
              ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
  
          if (!ok)
              log_err(ctx,
                      XKB_ERROR_INVALID_IDENTIFIER,
                      "Identifier \"%s\" of type int is unknown\n",
                      xkb_atom_text(ctx, expr->ident.ident));
          else
              *val_rtrn = (int) u;
  
          return ok;
  
      case EXPR_FIELD_REF:
          log_err(ctx,
                  XKB_ERROR_INVALID_EXPRESSION_TYPE,
                  "Default \"%s.%s\" of type int is unknown\n",
                  xkb_atom_text(ctx, expr->field_ref.element),
                  xkb_atom_text(ctx, expr->field_ref.field));
          return false;
  
      case EXPR_ADD:
      case EXPR_SUBTRACT:
      case EXPR_MULTIPLY:
      case EXPR_DIVIDE:
          left = expr->binary.left;
          right = expr->binary.right;
          if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
              !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
              return false;
  
          switch (expr->expr.op) {
          case EXPR_ADD:
              *val_rtrn = l + r;
              break;
          case EXPR_SUBTRACT:
              *val_rtrn = l - r;
              break;
          case EXPR_MULTIPLY:
              *val_rtrn = l * r;
              break;
          case EXPR_DIVIDE:
              if (r == 0) {
                  log_err(ctx,
                      XKB_ERROR_INVALID_OPERATION,
                      "Cannot divide by zero: %d / %d\n", l, r);
                  return false;
              }
              *val_rtrn = l / r;
              break;
          default:
              log_err(ctx,
                      XKB_ERROR_INVALID_OPERATION,
                      "%s of integers not permitted\n",
                      expr_op_type_to_string(expr->expr.op));
              return false;
          }
  
          return true;
  
      case EXPR_ASSIGN:
          log_wsgo(ctx,
                   XKB_ERROR_INVALID_OPERATION,
                   "Assignment operator not implemented yet\n");
          break;
  
      case EXPR_NOT:
          log_err(ctx,
                  XKB_ERROR_INVALID_OPERATION,
                  "The ! operator cannot be applied to an integer\n");
          return false;
  
      case EXPR_INVERT:
      case EXPR_NEGATE:
          left = expr->unary.child;
          if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
              return false;
  
          *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
          return true;
  
      case EXPR_UNARY_PLUS:
          left = expr->unary.child;
          return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
                                          lookupPriv);
  
      default:
          log_wsgo(ctx,
                   XKB_ERROR_UNKNOWN_OPERATOR,
                   "Unknown operator %d in ResolveInteger\n",
                   expr->expr.op);
          break;
      }
  
      return false;
  }
  
  bool
  ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
                     int *val_rtrn)
  {
      return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
  }
  
  bool
  ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
                   xkb_layout_index_t *group_rtrn)
  {
      bool ok;
      int result;
  
      ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
                                    groupNames);
      if (!ok)
          return false;
  
      if (result <= 0 || result > XKB_MAX_GROUPS) {
          log_err(ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                            "Group index %u is out of range (1..%d)\n",
                            result, XKB_MAX_GROUPS);
          return false;
      }
  
      *group_rtrn = (xkb_layout_index_t) result;
      return true;
  }
  
  bool
  ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
                   xkb_level_index_t *level_rtrn)
  {
      bool ok;
      int result;
  
      ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
                                    levelNames);
      if (!ok)
          return false;
  
      if (result < 1) {
          log_err(ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL,
                            "Shift level %d is out of range\n", result);
          return false;
      }
  
      /* Level is zero-indexed from now on. */
      *level_rtrn = (unsigned int) (result - 1);
      return true;
  }
  
  bool
  ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
  {
      return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
                                      buttonNames);
  }
  
  bool
  ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
                    xkb_atom_t *val_rtrn)
  {
      switch (expr->expr.op) {
      case EXPR_VALUE:
          if (expr->expr.value_type != EXPR_TYPE_STRING) {
              log_err(ctx,
                      XKB_ERROR_WRONG_FIELD_TYPE,
                      "Found constant of type %s, expected a string\n",
                      expr_value_type_to_string(expr->expr.value_type));
              return false;
          }
  
          *val_rtrn = expr->string.str;
          return true;
  
      case EXPR_IDENT:
          log_err(ctx,
                  XKB_ERROR_INVALID_IDENTIFIER,
                  "Identifier \"%s\" of type string not found\n",
                  xkb_atom_text(ctx, expr->ident.ident));
          return false;
  
      case EXPR_FIELD_REF:
          log_err(ctx,
                  XKB_ERROR_INVALID_EXPRESSION_TYPE,
                  "Default \"%s.%s\" of type string not found\n",
                  xkb_atom_text(ctx, expr->field_ref.element),
                  xkb_atom_text(ctx, expr->field_ref.field));
          return false;
  
      case EXPR_ADD:
      case EXPR_SUBTRACT:
      case EXPR_MULTIPLY:
      case EXPR_DIVIDE:
      case EXPR_ASSIGN:
      case EXPR_NEGATE:
      case EXPR_INVERT:
      case EXPR_NOT:
      case EXPR_UNARY_PLUS:
      case EXPR_ACTION_DECL:
      case EXPR_ACTION_LIST:
      case EXPR_KEYSYM_LIST:
          log_err(ctx,
                  XKB_ERROR_INVALID_SYNTAX,
                  "%s of strings not permitted\n",
                  expr_op_type_to_string(expr->expr.op));
          return false;
  
      default:
          log_wsgo(ctx,
                   XKB_ERROR_UNKNOWN_OPERATOR,
                   "Unknown operator %d in ResolveString\n",
                   expr->expr.op);
          break;
      }
      return false;
  }
  
  bool
  ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
                  unsigned int *val_rtrn, const LookupEntry *values)
  {
      if (expr->expr.op != EXPR_IDENT) {
          log_err(ctx,
                  XKB_ERROR_WRONG_FIELD_TYPE,
                  "Found a %s where an enumerated value was expected\n",
                  expr_op_type_to_string(expr->expr.op));
          return false;
      }
  
      if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
                        val_rtrn)) {
          log_err(ctx,
                  XKB_ERROR_INVALID_IDENTIFIER,
                  "Illegal identifier %s; expected one of:\n",
                  xkb_atom_text(ctx, expr->ident.ident));
          while (values && values->name)
          {
              log_err(ctx, XKB_ERROR_INVALID_IDENTIFIER, "\t%s\n", values->name);
              values++;
          }
          return false;
      }
  
      return true;
  }
  
  static bool
  ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
                        unsigned int *val_rtrn, IdentLookupFunc lookup,
                        const void *lookupPriv)
  {
      bool ok = false;
      unsigned int l = 0, r = 0;
      int v;
      ExprDef *left, *right;
      const char *bogus = NULL;
  
      switch (expr->expr.op) {
      case EXPR_VALUE:
          if (expr->expr.value_type != EXPR_TYPE_INT) {
              log_err(ctx,
                      XKB_ERROR_WRONG_FIELD_TYPE,
                      "Found constant of type %s where a mask was expected\n",
                      expr_value_type_to_string(expr->expr.value_type));
              return false;
          }
          *val_rtrn = (unsigned int) expr->integer.ival;
          return true;
  
      case EXPR_IDENT:
          ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
                      val_rtrn);
          if (!ok)
              log_err(ctx,
                      XKB_ERROR_INVALID_IDENTIFIER,
                      "Identifier \"%s\" of type int is unknown\n",
                      xkb_atom_text(ctx, expr->ident.ident));
          return ok;
  
      case EXPR_FIELD_REF:
          log_err(ctx,
                  XKB_ERROR_INVALID_EXPRESSION_TYPE,
                  "Default \"%s.%s\" of type int is unknown\n",
                  xkb_atom_text(ctx, expr->field_ref.element),
                  xkb_atom_text(ctx, expr->field_ref.field));
          return false;
  
      case EXPR_ARRAY_REF:
          bogus = "array reference";
          /* fallthrough */
      case EXPR_ACTION_DECL:
          if (bogus == NULL)
              bogus = "function use";
          log_err(ctx,
                  XKB_ERROR_WRONG_FIELD_TYPE,
                  "Unexpected %s in mask expression; Expression Ignored\n",
                  bogus);
          return false;
  
      case EXPR_ADD:
      case EXPR_SUBTRACT:
      case EXPR_MULTIPLY:
      case EXPR_DIVIDE:
          left = expr->binary.left;
          right = expr->binary.right;
          if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
              !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
              return false;
  
          switch (expr->expr.op) {
          case EXPR_ADD:
              *val_rtrn = l | r;
              break;
          case EXPR_SUBTRACT:
              *val_rtrn = l & (~r);
              break;
          case EXPR_MULTIPLY:
          case EXPR_DIVIDE:
              log_err(ctx,
                      XKB_ERROR_INVALID_OPERATION,
                      "Cannot %s masks; Illegal operation ignored\n",
                      (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
              return false;
          default:
              break;
          }
  
          return true;
  
      case EXPR_ASSIGN:
          log_wsgo(ctx,
                   XKB_ERROR_INVALID_OPERATION,
                   "Assignment operator not implemented yet\n");
          break;
  
      case EXPR_INVERT:
          left = expr->unary.child;
          if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
              return false;
  
          *val_rtrn = ~v;
          return true;
  
      case EXPR_UNARY_PLUS:
      case EXPR_NEGATE:
      case EXPR_NOT:
          left = expr->unary.child;
          if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
              log_err(ctx,
                      XKB_ERROR_INVALID_OPERATION,
                      "The %s operator cannot be used with a mask\n",
                      (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
          return false;
  
      default:
          log_wsgo(ctx,
                   XKB_ERROR_UNKNOWN_OPERATOR,
                   "Unknown operator %d in ResolveMask\n",
                   expr->expr.op);
          break;
      }
  
      return false;
  }
  
  bool
  ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
                  unsigned int *mask_rtrn, const LookupEntry *values)
  {
      return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
  }
  
  bool
  ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
                     enum mod_type mod_type, const struct xkb_mod_set *mods,
                     xkb_mod_mask_t *mask_rtrn)
  {
      LookupModMaskPriv priv = { .mods = mods, .mod_type = mod_type };
      return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, &priv);
  }
  
  bool
  ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
                    xkb_keysym_t *sym_rtrn)
  {
      int val;
  
      if (expr->expr.op == EXPR_IDENT) {
          const char *str = xkb_atom_text(ctx, expr->ident.ident);
          *sym_rtrn = xkb_keysym_from_name(str, 0);
          if (*sym_rtrn != XKB_KEY_NoSymbol)
              return true;
      }
  
      if (!ExprResolveInteger(ctx, expr, &val))
          return false;
  
      if (val < XKB_KEYSYM_MIN) {
          log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
                             "unrecognized keysym \"-0x%x\" (%d)\n",
                             (unsigned int) -val, val);
          return false;
      }
  
      /* Special case for digits 0..9 */
      if (val < 10) {
          *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
          return true;
      }
  
      if (val <= XKB_KEYSYM_MAX) {
          log_warn(ctx, XKB_WARNING_NUMERIC_KEYSYM,
                             "numeric keysym \"0x%x\" (%d)",
                             (unsigned int) val, val);
          *sym_rtrn = (xkb_keysym_t) val;
          return true;
      }
  
      log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
                         "unrecognized keysym \"0x%x\" (%d)\n",
                         (unsigned int) val, val);
      return false;
  
  }
  
  bool
  ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
                 enum mod_type mod_type, const struct xkb_mod_set *mods,
                 xkb_mod_index_t *ndx_rtrn)
  {
      xkb_mod_index_t ndx;
      xkb_atom_t name;
  
      if (def->expr.op != EXPR_IDENT) {
          log_err(ctx,
                  XKB_ERROR_WRONG_FIELD_TYPE,
                  "Cannot resolve virtual modifier: "
                  "found %s where a virtual modifier name was expected\n",
                  expr_op_type_to_string(def->expr.op));
          return false;
      }
  
      name = def->ident.ident;
      ndx = XkbModNameToIndex(mods, name, mod_type);
      if (ndx == XKB_MOD_INVALID) {
          log_err(ctx,
                  XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER,
                  "Cannot resolve virtual modifier: "
                  "\"%s\" was not previously declared\n",
                  xkb_atom_text(ctx, name));
          return false;
      }
  
      *ndx_rtrn = ndx;
      return true;
  }
  

Download