types: don't use canonical/required types
[platform/upstream/libxkbcommon.git] / 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 "vmod.h"
28
29 void
30 InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
31 {
32     ClearVModInfo(info, keymap);
33 }
34
35 void
36 ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap)
37 {
38     xkb_mod_index_t i;
39     xkb_mod_mask_t bit;
40
41     info->defined = info->available = 0;
42
43     for (i = 0; i < XkbNumVirtualMods; i++)
44         keymap->vmods[i] = XkbNoModifierMask;
45
46     for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
47         if (keymap->vmod_names[i])
48             info->defined |= bit;
49 }
50
51 /***====================================================================***/
52
53 /**
54  * Handle one entry in the virtualModifiers line (e.g. NumLock).
55  * If the entry is e.g. NumLock=Mod1, stmt->value is not NULL, and the
56  * XkbServerMap's vmod is set to the given modifier. Otherwise, the vmod is 0.
57  *
58  * @param stmt The statement specifying the name and (if any the value).
59  * @param mergeMode Merge strategy (e.g. MERGE_OVERRIDE)
60  */
61 bool
62 HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
63               enum merge_mode mergeMode, VModInfo *info)
64 {
65     xkb_mod_index_t i;
66     int nextFree;
67     xkb_mod_mask_t bit;
68     xkb_mod_mask_t mask;
69
70     nextFree = -1;
71     for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
72         const char *str1;
73         const char *str2 = "";
74
75         if (!(info->defined & bit)) {
76             if (nextFree < 0)
77                 nextFree = i;
78             continue;
79         }
80
81         /* already defined */
82         if (!keymap->vmod_names[i])
83             continue;
84
85         if (!streq(keymap->vmod_names[i],
86                    xkb_atom_text(keymap->ctx, stmt->name)))
87             continue;
88
89         info->available |= bit;
90
91         if (!stmt->value)
92             return true;
93
94         if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
95             log_err(keymap->ctx, "Declaration of %s ignored\n",
96                     xkb_atom_text(keymap->ctx, stmt->name));
97             return false;
98         }
99
100         if (mask == keymap->vmods[i])
101             return true;
102
103         str1 = ModMaskText(keymap->vmods[i], true);
104         if (mergeMode == MERGE_OVERRIDE) {
105             str2 = str1;
106             str1 = ModMaskText(mask, true);
107         }
108
109         log_warn(keymap->ctx,
110                  "Virtual modifier %s defined multiple times; "
111                  "Using %s, ignoring %s\n",
112                  xkb_atom_text(keymap->ctx, stmt->name), str1, str2);
113
114         if (mergeMode == MERGE_OVERRIDE)
115             keymap->vmods[i] = mask;
116
117         return true;
118     }
119
120     if (nextFree < 0) {
121         log_err(keymap->ctx,
122                 "Too many virtual modifiers defined (maximum %d)\n",
123                 XkbNumVirtualMods);
124         return false;
125     }
126
127     info->defined |= (1 << nextFree);
128     info->available |= (1 << nextFree);
129
130     keymap->vmod_names[nextFree] = xkb_atom_text(keymap->ctx, stmt->name);
131
132     if (!stmt->value)
133         return true;
134
135     if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
136         log_err(keymap->ctx, "Declaration of %s ignored\n",
137                 xkb_atom_text(keymap->ctx, stmt->name));
138         return false;
139     }
140
141     keymap->vmods[nextFree] = mask;
142     return true;
143 }
144
145 /**
146  * Returns the index of the given modifier in the keymap->vmod_names array.
147  *
148  * @param keymap Pointer to the xkb data structure.
149  * @param field The Atom of the modifier's name (e.g. Atom for LAlt)
150  * @param type Must be EXPR_TYPE_INT, otherwise return false.
151  * @param val_rtrn Set to the index of the modifier that matches.
152  *
153  * @return true on success, false otherwise. If false is returned, val_rtrn is
154  * undefined.
155  */
156 static bool
157 LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
158                 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
159 {
160     xkb_mod_index_t i;
161     const char *name = xkb_atom_text(keymap->ctx, field);
162
163     if (type != EXPR_TYPE_INT)
164         return false;
165
166     /* For each named modifier, get the name and compare it to the one passed
167      * in. If we get a match, return the index of the modifier.
168      * The order of modifiers is the same as in the virtual_modifiers line in
169      * the xkb_types section.
170      */
171     for (i = 0; i < XkbNumVirtualMods; i++) {
172         if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) {
173             *val_rtrn = i;
174             return true;
175         }
176     }
177
178     return false;
179 }
180
181 /**
182  * Get the mask for the given (virtual or core) modifier and set
183  * val_rtrn.uval to the mask value.
184  *
185  * @param priv Pointer to xkb data structure.
186  * @param val_rtrn Member uval is set to the mask returned.
187  *
188  * @return true on success, false otherwise. If false is returned, val_rtrn is
189  * undefined.
190  */
191 bool
192 LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
193                enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
194 {
195     xkb_mod_index_t ndx;
196
197     if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
198         return true;
199     }
200     else if (LookupVModIndex(priv, field, type, &ndx)) {
201         *val_rtrn = (1 << (XkbNumModifiers + ndx));
202         return true;
203     }
204
205     return false;
206 }
207
208 bool
209 ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
210                        xkb_mod_index_t *ndx_rtrn, VModInfo *info)
211 {
212     int val;
213
214     if (def->op == EXPR_IDENT) {
215         xkb_mod_index_t i;
216         xkb_mod_mask_t bit;
217         const char *name = xkb_atom_text(keymap->ctx, def->value.str);
218
219         for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
220             if ((info->available & bit) && keymap->vmod_names[i] &&
221                 streq(keymap->vmod_names[i], name)) {
222                 *ndx_rtrn = i;
223                 return true;
224             }
225         }
226     }
227
228     if (!ExprResolveInteger(keymap->ctx, def, &val))
229         return false;
230
231     if (val < 0 || val >= XkbNumVirtualMods) {
232         log_err(keymap->ctx,
233                 "Illegal virtual modifier %d (must be 0..%d inclusive)\n",
234                 val, XkbNumVirtualMods - 1);
235         return false;
236     }
237
238     *ndx_rtrn = (xkb_mod_index_t) val;
239     return true;
240 }