src/xkbcomp/vmod.c

   1 /************************************************************
   2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of Silicon Graphics not be
  10  * used in advertising or publicity pertaining to distribution
  11  * of the software without specific prior written permission.
  12  * Silicon Graphics makes no representation about the suitability
  13  * of this software for any purpose. It is provided "as is"
  14  * without any express or implied warranty.
  15  *
  16  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  ********************************************************/
  26
  27 #include "xkbcomp-priv.h"
  28 #include "text.h"
  29 #include "expr.h"
  30 #include "vmod.h"
  31
  32 void
  33 InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
  34 {
  35     xkb_mod_index_t i;
  36
  37     memset(info, 0, sizeof(*info));
  38     for (i = 0; i < darray_size(keymap->vmods); i++)
  39         info->defined |= (1 << i);
  40 }
  41
  42 bool
  43 HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, VModInfo *info)
  44 {
  45     xkb_mod_index_t i;
  46     const char *name;
  47     const struct xkb_vmod *vmod;
  48     struct xkb_vmod new;
  49
  50     if (stmt->value)
  51         log_err(keymap->ctx,
  52                 "Support for setting a value in a virtual_modifiers statement has been removed; "
  53                 "Value ignored\n");
  54
  55     name = xkb_atom_text(keymap->ctx, stmt->name);
  56     if (ModNameToIndex(name) != XKB_MOD_INVALID) {
  57         log_err(keymap->ctx,
  58                 "Can't add a virtual modifier named \"%s\"; "
  59                 "there is already a non-virtual modifier with this name! Ignored\n",
  60                 name);
  61         return false;
  62     }
  63
  64     darray_enumerate(i, vmod, keymap->vmods) {
  65         if (vmod->name == stmt->name) {
  66             info->available |= 1 << i;
  67             return true;
  68         }
  69     }
  70
  71     if (darray_size(keymap->vmods) >= XKB_MAX_VIRTUAL_MODS) {
  72         log_err(keymap->ctx,
  73                 "Too many virtual modifiers defined (maximum %d)\n",
  74                 XKB_MAX_VIRTUAL_MODS);
  75         return false;
  76     }
  77
  78     new.name = stmt->name;
  79     new.mapping = 0;
  80     darray_append(keymap->vmods, new);
  81     info->available |= (1 << (darray_size(keymap->vmods) - 1));
  82     return true;
  83 }
  84
  85 static bool
  86 LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
  87                 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
  88 {
  89     const struct xkb_vmod *vmod;
  90     xkb_mod_index_t i;
  91
  92     if (type != EXPR_TYPE_INT)
  93         return false;
  94
  95     darray_enumerate(i, vmod, keymap->vmods) {
  96         if (vmod->name == field) {
  97             *val_rtrn = i;
  98             return true;
  99         }
 100     }
 101
 102     return false;
 103 }
 104
 105 bool
 106 LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 107                enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
 108 {
 109     xkb_mod_index_t ndx;
 110
 111     if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
 112         return true;
 113     }
 114     else if (LookupVModIndex(priv, field, type, &ndx)) {
 115         *val_rtrn = (1 << (XKB_NUM_CORE_MODS + ndx));
 116         return true;
 117     }
 118
 119     return false;
 120 }
 121
 122 bool
 123 ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
 124                        xkb_mod_index_t *ndx_rtrn, VModInfo *info)
 125 {
 126     const struct xkb_vmod *vmod;
 127     xkb_mod_index_t i;
 128     xkb_atom_t name = def->value.str;
 129
 130     if (def->op != EXPR_IDENT) {
 131         log_err(keymap->ctx,
 132                 "Cannot resolve virtual modifier: "
 133                 "found %s where a virtual modifier name was expected\n",
 134                 expr_op_type_to_string(def->op));
 135         return false;
 136     }
 137
 138     darray_enumerate(i, vmod, keymap->vmods) {
 139         if ((info->available & (1 << i)) && vmod->name == name) {
 140             *ndx_rtrn = i;
 141             return true;
 142         }
 143     }
 144
 145     log_err(keymap->ctx,
 146             "Cannot resolve virtual modifier: "
 147             "\"%s\" was not previously declared\n",
 148             xkb_atom_text(keymap->ctx, name));
 149     return false;
 150 }