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 "expr.h"
  29 #include "vmod.h"
  30
  31 void
  32 InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
  33 {
  34     xkb_group_index_t i;
  35
  36     info->defined = info->available = 0;
  37
  38     for (i = 0; i < XkbNumVirtualMods; i++)
  39         if (keymap->vmod_names[i])
  40             info->defined |= (1 << i);
  41 }
  42
  43 void
  44 ClearVModInfo(VModInfo *info)
  45 {
  46     info->defined = info->available = 0;
  47 }
  48
  49 bool
  50 HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
  51               enum merge_mode mergeMode, VModInfo *info)
  52 {
  53     xkb_mod_index_t i;
  54     int nextFree;
  55     xkb_mod_mask_t bit;
  56
  57     if (stmt->value)
  58         log_err(keymap->ctx,
  59                 "Support for setting a value in a virtual_modifiers statement has been removed; "
  60                 "Value ignored\n");
  61
  62     nextFree = -1;
  63     for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
  64         if (!(info->defined & bit)) {
  65             if (nextFree < 0)
  66                 nextFree = i;
  67             continue;
  68         }
  69
  70         /* Already defined. */
  71         if (!keymap->vmod_names[i])
  72             continue;
  73
  74         if (!streq(keymap->vmod_names[i],
  75                    xkb_atom_text(keymap->ctx, stmt->name)))
  76             continue;
  77
  78         info->available |= bit;
  79         return true;
  80     }
  81
  82     if (nextFree < 0) {
  83         log_err(keymap->ctx,
  84                 "Too many virtual modifiers defined (maximum %d)\n",
  85                 XkbNumVirtualMods);
  86         return false;
  87     }
  88
  89     info->defined |= (1 << nextFree);
  90     info->available |= (1 << nextFree);
  91
  92     keymap->vmod_names[nextFree] = xkb_atom_text(keymap->ctx, stmt->name);
  93     return true;
  94 }
  95
  96 static bool
  97 LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
  98                 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
  99 {
 100     xkb_mod_index_t i;
 101     const char *name = xkb_atom_text(keymap->ctx, field);
 102
 103     if (type != EXPR_TYPE_INT)
 104         return false;
 105
 106     for (i = 0; i < XkbNumVirtualMods; i++) {
 107         if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) {
 108             *val_rtrn = i;
 109             return true;
 110         }
 111     }
 112
 113     return false;
 114 }
 115
 116 bool
 117 LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 118                enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
 119 {
 120     xkb_mod_index_t ndx;
 121
 122     if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
 123         return true;
 124     }
 125     else if (LookupVModIndex(priv, field, type, &ndx)) {
 126         *val_rtrn = (1 << (XkbNumModifiers + ndx));
 127         return true;
 128     }
 129
 130     return false;
 131 }
 132
 133 bool
 134 ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
 135                        xkb_mod_index_t *ndx_rtrn, VModInfo *info)
 136 {
 137     xkb_mod_index_t i;
 138     const char *name;
 139
 140     if (def->op != EXPR_IDENT) {
 141         log_err(keymap->ctx,
 142                 "Cannot resolve virtual modifier: "
 143                 "found %s where a virtual modifier name was expected\n",
 144                 expr_op_type_to_string(def->op));
 145         return false;
 146     }
 147
 148     name = xkb_atom_text(keymap->ctx, def->value.str);
 149
 150     for (i = 0; i < XkbNumVirtualMods; i++) {
 151         if ((info->available & (1 << i)) &&
 152             streq_not_null(keymap->vmod_names[i], name)) {
 153             *ndx_rtrn = i;
 154             return true;
 155         }
 156     }
 157
 158     log_err(keymap->ctx,
 159             "Cannot resolve virtual modifier: "
 160             "\"%s\" was not previously declared\n", name);
 161     return false;
 162 }