1 /************************************************************
2 Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
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.
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.
25 ********************************************************/
27 #include "xkbcomp-priv.h"
28 #include "parseutils.h"
34 /***====================================================================***/
38 #define RepeatUndefined ~((unsigned)0)
40 #define _Key_Syms (1<<0)
41 #define _Key_Acts (1<<1)
42 #define _Key_Repeat (1<<2)
43 #define _Key_Behavior (1<<3)
44 #define _Key_Type_Dflt (1<<4)
45 #define _Key_Types (1<<5)
46 #define _Key_GroupInfo (1<<6)
47 #define _Key_VModMap (1<<7)
49 typedef struct _KeyInfo
52 unsigned long name; /* the 4 chars of the key name, as long */
53 unsigned char groupInfo;
54 unsigned char typesDefined;
55 unsigned char symsDefined;
56 unsigned char actsDefined;
57 unsigned int numLevels[XkbNumKbdGroups];
59 /* syms[group] -> Single array for all the keysyms in the group. */
60 xkb_keysym_t *syms[XkbNumKbdGroups];
61 /* sizeSyms[group] -> The size of the syms[group] array. */
62 int sizeSyms[XkbNumKbdGroups];
64 * symsMapIndex[group][level] -> The index from which the syms for
65 * the level begin in the syms[group] array. Remember each keycode
66 * can have multiple keysyms in each level (that is, each key press
67 * can result in multiple keysyms).
69 int *symsMapIndex[XkbNumKbdGroups];
71 * symsMapNumEntries[group][level] -> How many syms are in
72 * syms[group][symsMapIndex[group][level]].
74 unsigned int *symsMapNumEntries[XkbNumKbdGroups];
76 union xkb_action *acts[XkbNumKbdGroups];
77 xkb_atom_t types[XkbNumKbdGroups];
79 struct xkb_behavior behavior;
80 unsigned short vmodmap;
85 * Init the given key info to sane values.
88 InitKeyInfo(KeyInfo * info)
91 static const char dflt[4] = "*";
93 info->defs.defined = 0;
94 info->defs.fileID = 0;
95 info->defs.merge = MergeOverride;
96 info->defs.next = NULL;
97 info->name = KeyNameToLong(dflt);
99 info->typesDefined = info->symsDefined = info->actsDefined = 0;
100 for (i = 0; i < XkbNumKbdGroups; i++)
102 info->numLevels[i] = 0;
103 info->types[i] = XKB_ATOM_NONE;
104 info->syms[i] = NULL;
105 info->sizeSyms[i] = 0;
106 info->symsMapIndex[i] = NULL;
107 info->symsMapNumEntries[i] = NULL;
108 info->acts[i] = NULL;
110 info->dfltType = XKB_ATOM_NONE;
111 info->behavior.type = XkbKB_Default;
112 info->behavior.data = 0;
114 info->repeat = RepeatUndefined;
118 * Free memory associated with this key info and reset to sane values.
121 FreeKeyInfo(KeyInfo * info)
125 info->defs.defined = 0;
126 info->defs.fileID = 0;
127 info->defs.merge = MergeOverride;
128 info->defs.next = NULL;
130 info->typesDefined = info->symsDefined = info->actsDefined = 0;
131 for (i = 0; i < XkbNumKbdGroups; i++)
133 info->numLevels[i] = 0;
134 info->types[i] = XKB_ATOM_NONE;
136 info->syms[i] = NULL;
137 info->sizeSyms[i] = 0;
138 free(info->symsMapIndex[i]);
139 info->symsMapIndex[i] = NULL;
140 free(info->symsMapNumEntries[i]);
141 info->symsMapNumEntries[i] = NULL;
143 info->acts[i] = NULL;
145 info->dfltType = XKB_ATOM_NONE;
146 info->behavior.type = XkbKB_Default;
147 info->behavior.data = 0;
149 info->repeat = RepeatUndefined;
153 * Copy old into new, optionally reset old to 0.
154 * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
155 * newly allocated and new points to the new memory areas.
158 CopyKeyInfo(KeyInfo * old, KeyInfo * new, bool clearOld)
163 new->defs.next = NULL;
166 for (i = 0; i < XkbNumKbdGroups; i++)
168 old->numLevels[i] = 0;
169 old->symsMapIndex[i] = NULL;
170 old->symsMapNumEntries[i] = NULL;
172 old->sizeSyms[i] = 0;
179 for (i = 0; i < XkbNumKbdGroups; i++)
181 width = new->numLevels[i];
182 if (old->syms[i] != NULL)
184 new->syms[i] = uTypedCalloc(new->sizeSyms[i], xkb_keysym_t);
188 new->sizeSyms[i] = 0;
189 new->numLevels[i] = 0;
193 memcpy(new->syms[i], old->syms[i],
194 new->sizeSyms[i] * sizeof(xkb_keysym_t));
195 new->symsMapIndex[i] = uTypedCalloc(width, int);
196 if (!new->symsMapIndex[i])
200 new->sizeSyms[i] = 0;
201 new->numLevels[i] = 0;
205 memcpy(new->symsMapIndex[i], old->symsMapIndex[i],
206 width * sizeof(int));
207 new->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
208 if (!new->symsMapNumEntries[i])
212 new->sizeSyms[i] = 0;
213 free(new->symsMapIndex[i]);
214 new->symsMapIndex[i] = NULL;
215 new->numLevels[i] = 0;
219 memcpy(new->symsMapNumEntries[i], old->symsMapNumEntries[i],
220 width * sizeof(unsigned int));
222 if (old->acts[i] != NULL)
224 new->acts[i] = uTypedCalloc(width, union xkb_action);
229 new->sizeSyms[i] = 0;
230 free(new->symsMapIndex[i]);
231 new->symsMapIndex[i] = NULL;
232 free(new->symsMapNumEntries[i]);
233 new->symsMapNumEntries[i] = NULL;
234 new->numLevels[i] = 0;
237 memcpy(new->acts[i], old->acts[i],
238 width * sizeof(union xkb_action));
245 /***====================================================================***/
247 typedef struct _ModMapEntry
254 unsigned long keyName;
259 #define SYMBOLS_INIT_SIZE 110
261 typedef struct _SymbolsInfo
263 char *name; /* e.g. pc+us+inet(evdev) */
267 unsigned explicit_group;
269 darray(KeyInfo) keys;
273 xkb_atom_t groupNames[XkbNumKbdGroups];
280 InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap)
285 info->explicit_group = 0;
286 info->errorCount = 0;
288 info->merge = MergeOverride;
290 darray_init(info->keys);
291 darray_growalloc(info->keys, SYMBOLS_INIT_SIZE);
293 for (i = 0; i < XkbNumKbdGroups; i++)
294 info->groupNames[i] = XKB_ATOM_NONE;
295 InitKeyInfo(&info->dflt);
296 InitVModInfo(&info->vmods, keymap);
298 info->aliases = NULL;
302 FreeSymbolsInfo(SymbolsInfo * info)
307 darray_foreach(key, info->keys)
309 darray_free(info->keys);
311 ClearCommonInfo(&info->modMap->defs);
313 ClearAliases(&info->aliases);
314 memset(info, 0, sizeof(SymbolsInfo));
318 ResizeKeyGroup(KeyInfo * key, unsigned int group, unsigned int numLevels,
319 unsigned sizeSyms, bool forceActions)
323 if (key->syms[group] == NULL || key->sizeSyms[group] < sizeSyms)
325 key->syms[group] = uTypedRecalloc(key->syms[group],
326 key->sizeSyms[group],
329 if (!key->syms[group]) {
330 key->sizeSyms[group] = 0;
333 key->sizeSyms[group] = sizeSyms;
335 if (!key->symsMapIndex[group] || key->numLevels[group] < numLevels)
337 key->symsMapIndex[group] = uTypedRealloc(key->symsMapIndex[group],
340 if (!key->symsMapIndex[group])
342 for (i = key->numLevels[group]; i < numLevels; i++)
343 key->symsMapIndex[group][i] = -1;
345 if (!key->symsMapNumEntries[group] || key->numLevels[group] < numLevels)
347 key->symsMapNumEntries[group] =
348 uTypedRecalloc(key->symsMapNumEntries[group],
349 key->numLevels[group],
352 if (!key->symsMapNumEntries[group])
356 (key->numLevels[group] < numLevels || (key->acts[group] == NULL))) ||
357 (key->numLevels[group] < numLevels && (key->acts[group] != NULL)))
359 key->acts[group] = uTypedRecalloc(key->acts[group],
360 key->numLevels[group],
363 if (!key->acts[group])
366 if (key->numLevels[group] < numLevels)
367 key->numLevels[group] = numLevels;
372 MergeKeyGroups(SymbolsInfo * info,
373 KeyInfo * into, KeyInfo * from, unsigned group)
375 xkb_keysym_t *resultSyms = NULL;
376 union xkb_action *resultActs;
377 unsigned int resultWidth;
378 unsigned int resultSize = 0;
381 bool report, clobber;
383 clobber = (from->defs.merge != MergeAugment);
384 report = (warningLevel > 9) ||
385 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
386 if (into->numLevels[group] >= from->numLevels[group])
388 resultActs = into->acts[group];
389 resultWidth = into->numLevels[group];
393 resultActs = from->acts[group];
394 resultWidth = from->numLevels[group];
395 into->symsMapIndex[group] = uTypedRealloc(into->symsMapIndex[group],
396 from->numLevels[group],
398 into->symsMapNumEntries[group] =
399 uTypedRecalloc(into->symsMapNumEntries[group],
400 into->numLevels[group],
401 from->numLevels[group],
403 if (!into->symsMapIndex[group] || !into->symsMapNumEntries[group])
405 WSGO("Could not allocate level indices for key info merge\n");
406 ACTION("Group %d of key %s not merged\n", group,
407 longText(into->name));
411 for (i = into->numLevels[group]; i < from->numLevels[group]; i++)
412 into->symsMapIndex[group][i] = -1;
415 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
417 resultActs = uTypedCalloc(resultWidth, union xkb_action);
420 WSGO("Could not allocate actions for group merge\n");
421 ACTION("Group %d of key %s not merged\n", group,
422 longText(into->name));
425 for (i = 0; i < resultWidth; i++)
427 union xkb_action *fromAct, *toAct;
428 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
429 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
430 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
433 resultActs[i] = *toAct;
435 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
436 && (fromAct != NULL))
438 resultActs[i] = *fromAct;
442 union xkb_action *use, *ignore;
456 ("Multiple actions for level %d/group %d on key %s\n",
457 i + 1, group + 1, longText(into->name));
458 ACTION("Using %s, ignoring %s\n",
459 XkbcActionTypeText(use->type),
460 XkbcActionTypeText(ignore->type));
463 resultActs[i] = *use;
468 for (i = 0; i < resultWidth; i++)
470 unsigned int fromSize = 0;
473 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
474 fromSize = from->symsMapNumEntries[group][i];
475 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
476 toSize = into->symsMapNumEntries[group][i];
480 resultSize += toSize;
482 else if (toSize == 0 || clobber)
484 resultSize += fromSize;
488 resultSize += toSize;
495 resultSyms = uTypedCalloc(resultSize, xkb_keysym_t);
498 WSGO("Could not allocate symbols for group merge\n");
499 ACTION("Group %d of key %s not merged\n", group, longText(into->name));
503 for (i = 0; i < resultWidth; i++)
505 enum { NONE, FROM, TO } use;
506 unsigned int fromSize = 0;
507 unsigned int toSize = 0;
509 if (i < from->numLevels[group])
510 fromSize = from->symsMapNumEntries[group][i];
511 if (i < into->numLevels[group])
512 toSize = into->symsMapNumEntries[group][i];
514 if (fromSize == 0 && toSize == 0)
516 into->symsMapIndex[group][i] = -1;
517 into->symsMapNumEntries[group][i] = 0;
523 else if (toSize == 0 || clobber)
528 if (toSize && fromSize && report)
530 INFO("Multiple symbols for group %d, level %d on key %s\n",
531 group + 1, i + 1, longText(into->name));
532 ACTION("Using %s, ignoring %s\n",
533 (use == FROM ? "from" : "to"),
534 (use == FROM ? "to" : "from"));
539 memcpy(&resultSyms[cur_idx],
540 &from->syms[group][from->symsMapIndex[group][i]],
541 from->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
542 into->symsMapIndex[group][i] = cur_idx;
543 into->symsMapNumEntries[group][i] =
544 from->symsMapNumEntries[group][i];
548 memcpy(&resultSyms[cur_idx],
549 &into->syms[group][into->symsMapIndex[group][i]],
550 into->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
551 into->symsMapIndex[group][i] = cur_idx;
553 cur_idx += into->symsMapNumEntries[group][i];
557 if (resultActs != into->acts[group])
558 free(into->acts[group]);
559 if (resultActs != from->acts[group])
560 free(from->acts[group]);
561 into->numLevels[group] = resultWidth;
562 free(into->syms[group]);
563 into->syms[group] = resultSyms;
564 free(from->syms[group]);
565 from->syms[group] = NULL;
566 from->sizeSyms[group] = 0;
567 into->sizeSyms[group] = resultSize;
568 free(from->symsMapIndex[group]);
569 from->symsMapIndex[group] = NULL;
570 free(from->symsMapNumEntries[group]);
571 from->symsMapNumEntries[group] = NULL;
572 into->acts[group] = resultActs;
573 from->acts[group] = NULL;
574 into->symsDefined |= (1 << group);
575 from->symsDefined &= ~(1 << group);
576 into->actsDefined |= (1 << group);
577 from->actsDefined &= ~(1 << group);
583 MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap,
584 KeyInfo *into, KeyInfo *from)
587 unsigned collide = 0;
590 if (from->defs.merge == MergeReplace)
592 for (i = 0; i < XkbNumKbdGroups; i++)
594 if (into->numLevels[i] != 0)
601 memset(from, 0, sizeof(KeyInfo));
604 report = ((warningLevel > 9) ||
605 ((into->defs.fileID == from->defs.fileID)
606 && (warningLevel > 0)));
607 for (i = 0; i < XkbNumKbdGroups; i++)
609 if (from->numLevels[i] > 0)
611 if (into->numLevels[i] == 0)
613 into->numLevels[i] = from->numLevels[i];
614 into->syms[i] = from->syms[i];
615 into->sizeSyms[i] = from->sizeSyms[i];
616 into->symsMapIndex[i] = from->symsMapIndex[i];
617 into->symsMapNumEntries[i] = from->symsMapNumEntries[i];
618 into->acts[i] = from->acts[i];
619 into->symsDefined |= (1 << i);
620 from->syms[i] = NULL;
621 from->sizeSyms[i] = 0;
622 from->symsMapIndex[i] = NULL;
623 from->symsMapNumEntries[i] = NULL;
624 from->acts[i] = NULL;
625 from->numLevels[i] = 0;
626 from->symsDefined &= ~(1 << i);
628 into->defs.defined |= _Key_Syms;
630 into->defs.defined |= _Key_Acts;
637 collide |= _Key_Syms;
639 collide |= _Key_Acts;
641 MergeKeyGroups(info, into, from, (unsigned) i);
644 if (from->types[i] != XKB_ATOM_NONE)
646 if ((into->types[i] != XKB_ATOM_NONE) && report &&
647 (into->types[i] != from->types[i]))
649 xkb_atom_t use, ignore;
650 collide |= _Key_Types;
651 if (from->defs.merge != MergeAugment)
653 use = from->types[i];
654 ignore = into->types[i];
658 use = into->types[i];
659 ignore = from->types[i];
662 ("Multiple definitions for group %d type of key %s\n",
663 i, longText(into->name));
664 ACTION("Using %s, ignoring %s\n",
665 xkb_atom_text(keymap->ctx, use),
666 xkb_atom_text(keymap->ctx, ignore));
668 if ((from->defs.merge != MergeAugment)
669 || (into->types[i] == XKB_ATOM_NONE))
671 into->types[i] = from->types[i];
675 if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
677 into->behavior = from->behavior;
678 into->defs.defined |= _Key_Behavior;
680 if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
682 into->vmodmap = from->vmodmap;
683 into->defs.defined |= _Key_VModMap;
685 if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
687 into->repeat = from->repeat;
688 into->defs.defined |= _Key_Repeat;
690 if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
692 into->dfltType = from->dfltType;
693 into->defs.defined |= _Key_Type_Dflt;
695 if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
697 into->groupInfo = from->groupInfo;
698 into->defs.defined |= _Key_GroupInfo;
702 WARN("Symbol map for key %s redefined\n",
703 longText(into->name));
704 ACTION("Using %s definition for conflicting fields\n",
705 (from->defs.merge == MergeAugment ? "first" : "last"));
711 AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap)
713 unsigned long real_name;
716 darray_foreach(iter, info->keys)
717 if (iter->name == key->name)
718 return MergeKeys(info, keymap, iter, key);
720 if (FindKeyNameForAlias(keymap, key->name, &real_name))
721 darray_foreach(iter, info->keys)
722 if (iter->name == real_name)
723 return MergeKeys(info, keymap, iter, key);
725 darray_resize0(info->keys, darray_size(info->keys) + 1);
726 new = &darray_item(info->keys, darray_size(info->keys) - 1);
727 return CopyKeyInfo(key, new, true);
731 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
736 clobber = (new->defs.merge != MergeAugment);
737 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
739 if (new->haveSymbol && mm->haveSymbol
740 && (new->u.keySym == mm->u.keySym))
742 unsigned use, ignore;
743 if (mm->modifier != new->modifier)
748 ignore = mm->modifier;
753 ignore = new->modifier;
756 ("%s added to symbol map for multiple modifiers\n",
757 XkbcKeysymText(new->u.keySym));
758 ACTION("Using %s, ignoring %s.\n",
759 XkbcModIndexText(use),
760 XkbcModIndexText(ignore));
765 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
766 (new->u.keyName == mm->u.keyName))
768 unsigned use, ignore;
769 if (mm->modifier != new->modifier)
774 ignore = mm->modifier;
779 ignore = new->modifier;
781 ERROR("Key %s added to map for multiple modifiers\n",
782 longText(new->u.keyName));
783 ACTION("Using %s, ignoring %s.\n",
784 XkbcModIndexText(use),
785 XkbcModIndexText(ignore));
791 mm = uTypedAlloc(ModMapEntry);
794 WSGO("Could not allocate modifier map entry\n");
795 ACTION("Modifier map for %s will be incomplete\n",
796 XkbcModIndexText(new->modifier));
800 mm->defs.next = &info->modMap->defs;
805 /***====================================================================***/
808 MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
809 unsigned merge, struct xkb_keymap *keymap)
814 if (from->errorCount > 0)
816 into->errorCount += from->errorCount;
819 if (into->name == NULL)
821 into->name = from->name;
824 for (i = 0; i < XkbNumKbdGroups; i++)
826 if (from->groupNames[i] != XKB_ATOM_NONE)
828 if ((merge != MergeAugment) ||
829 (into->groupNames[i] == XKB_ATOM_NONE))
830 into->groupNames[i] = from->groupNames[i];
834 darray_foreach(key, from->keys) {
835 if (merge != MergeDefault)
836 key->defs.merge = merge;
838 if (!AddKeySymbols(into, key, keymap))
842 if (from->modMap != NULL)
844 ModMapEntry *mm, *next;
845 for (mm = from->modMap; mm != NULL; mm = next)
847 if (merge != MergeDefault)
848 mm->defs.merge = merge;
849 if (!AddModMapEntry(into, mm))
851 next = (ModMapEntry *) mm->defs.next;
856 if (!MergeAliases(&into->aliases, &from->aliases, merge))
861 HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
862 unsigned merge, SymbolsInfo *info);
865 HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap,
870 SymbolsInfo included;
874 if ((stmt->file == NULL) && (stmt->map == NULL))
878 memset(info, 0, sizeof(SymbolsInfo));
880 else if (ProcessIncludeFile(keymap->ctx, stmt, XkmSymbolsIndex, &rtrn,
883 InitSymbolsInfo(&included, keymap);
884 included.fileID = included.dflt.defs.fileID = rtrn->id;
885 included.merge = included.dflt.defs.merge = MergeOverride;
888 included.explicit_group = atoi(stmt->modifier) - 1;
892 included.explicit_group = info->explicit_group;
894 HandleSymbolsFile(rtrn, keymap, MergeOverride, &included);
895 if (stmt->stmt != NULL)
898 included.name = stmt->stmt;
905 info->errorCount += 10;
908 if ((stmt->next != NULL) && (included.errorCount < 1))
912 SymbolsInfo next_incl;
914 for (next = stmt->next; next != NULL; next = next->next)
916 if ((next->file == NULL) && (next->map == NULL))
919 MergeIncludedSymbols(&included, info, next->merge, keymap);
920 FreeSymbolsInfo(info);
922 else if (ProcessIncludeFile(keymap->ctx, next, XkmSymbolsIndex,
925 InitSymbolsInfo(&next_incl, keymap);
926 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
927 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
930 next_incl.explicit_group = atoi(next->modifier) - 1;
934 next_incl.explicit_group = info->explicit_group;
936 HandleSymbolsFile(rtrn, keymap, MergeOverride, &next_incl);
937 MergeIncludedSymbols(&included, &next_incl, op, keymap);
938 FreeSymbolsInfo(&next_incl);
943 info->errorCount += 10;
944 FreeSymbolsInfo(&included);
951 info->errorCount += included.errorCount;
957 MergeIncludedSymbols(info, &included, newMerge, keymap);
958 FreeSymbolsInfo(&included);
960 return (info->errorCount == 0);
967 GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap,
968 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
978 if (arrayNdx == NULL)
983 defined = key->symsDefined;
985 defined = key->actsDefined;
987 for (i = 0; i < XkbNumKbdGroups; i++)
989 if ((defined & (1 << i)) == 0)
995 ERROR("Too many groups of %s for key %s (max %d)\n", name,
996 longText(key->name), XkbNumKbdGroups + 1);
997 ACTION("Ignoring %s defined for extra groups\n", name);
1000 if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp))
1002 ERROR("Illegal group index for %s of key %s\n", name,
1003 longText(key->name));
1004 ACTION("Definition with non-integer array index ignored\n");
1007 *ndx_rtrn = tmp.uval - 1;
1012 AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap,
1013 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1015 unsigned ndx, nSyms, nLevels;
1019 if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx))
1023 key->symsDefined |= (1 << ndx);
1026 if (value->op != ExprKeysymList)
1028 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
1029 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
1030 longText(key->name));
1033 if (key->sizeSyms[ndx] != 0)
1035 ERROR("Symbols for key %s, group %d already defined\n",
1036 longText(key->name), ndx + 1);
1037 ACTION("Ignoring duplicate definition\n");
1040 nSyms = darray_size(value->value.list.syms);
1041 nLevels = darray_size(value->value.list.symsMapIndex);
1042 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
1043 (!ResizeKeyGroup(key, ndx, nLevels, nSyms, false)))
1045 WSGO("Could not resize group %d of key %s to contain %d levels\n",
1046 ndx + 1, longText(key->name), nSyms);
1047 ACTION("Symbols lost\n");
1050 key->symsDefined |= (1 << ndx);
1051 for (i = 0; i < nLevels; i++) {
1052 key->symsMapIndex[ndx][i] =
1053 darray_item(value->value.list.symsMapIndex, i);
1054 key->symsMapNumEntries[ndx][i] =
1055 darray_item(value->value.list.symsNumEntries, i);
1057 for (j = 0; j < key->symsMapNumEntries[ndx][i]; j++) {
1058 if (key->symsMapIndex[ndx][i] + j >= nSyms)
1060 if (!LookupKeysym(darray_item(value->value.list.syms,
1061 darray_item(value->value.list.symsMapIndex, i) + j),
1062 &key->syms[ndx][key->symsMapIndex[ndx][i] + j])) {
1063 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
1064 darray_item(value->value.list.syms, i),
1065 longText(key->name),
1067 xkb_atom_text(keymap->ctx, info->groupNames[ndx]), nSyms);
1069 key->syms[ndx][key->symsMapIndex[ndx][i] + j] = XKB_KEY_NoSymbol;
1070 key->symsMapIndex[ndx][i] = -1;
1071 key->symsMapNumEntries[ndx][i] = 0;
1074 if (key->symsMapNumEntries[ndx][i] == 1 &&
1075 key->syms[ndx][key->symsMapIndex[ndx][i] + j] == XKB_KEY_NoSymbol) {
1076 key->symsMapIndex[ndx][i] = -1;
1077 key->symsMapNumEntries[ndx][i] = 0;
1081 for (j = key->numLevels[ndx] - 1;
1082 j >= 0 && key->symsMapNumEntries[ndx][j] == 0; j--)
1083 key->numLevels[ndx]--;
1088 AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1089 ExprDef *value, SymbolsInfo *info)
1092 unsigned ndx, nActs;
1094 struct xkb_any_action *toAct;
1096 if (!GetGroupIndex(key, keymap, arrayNdx, ACTIONS, &ndx))
1101 key->actsDefined |= (1 << ndx);
1104 if (value->op != ExprActionList)
1106 WSGO("Bad expression type (%d) for action list value\n", value->op);
1107 ACTION("Ignoring actions for group %d of %s\n", ndx,
1108 longText(key->name));
1111 if (key->acts[ndx] != NULL)
1113 WSGO("Actions for key %s, group %d already defined\n",
1114 longText(key->name), ndx);
1117 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
1119 act = (ExprDef *) act->common.next;
1123 WSGO("Action list but not actions in AddActionsToKey\n");
1126 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
1127 (!ResizeKeyGroup(key, ndx, nActs, nActs, true)))
1129 WSGO("Could not resize group %d of key %s\n", ndx,
1130 longText(key->name));
1131 ACTION("Actions lost\n");
1134 key->actsDefined |= (1 << ndx);
1136 toAct = (struct xkb_any_action *) key->acts[ndx];
1137 act = value->value.child;
1138 for (i = 0; i < nActs; i++, toAct++)
1140 if (!HandleActionDef(act, keymap, toAct, info->action))
1142 ERROR("Illegal action definition for %s\n",
1143 longText(key->name));
1144 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1146 act = (ExprDef *) act->common.next;
1151 static const LookupEntry lockingEntries[] = {
1152 {"true", XkbKB_Lock},
1153 {"yes", XkbKB_Lock},
1155 {"false", XkbKB_Default},
1156 {"no", XkbKB_Default},
1157 {"off", XkbKB_Default},
1158 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1162 static const LookupEntry repeatEntries[] = {
1163 {"true", RepeatYes},
1166 {"false", RepeatNo},
1169 {"default", RepeatUndefined},
1174 SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field,
1175 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1180 if (strcasecmp(field, "type") == 0)
1183 if ((!ExprResolveString(keymap->ctx, value, &tmp))
1184 && (warningLevel > 0))
1186 WARN("The type field of a key symbol map must be a string\n");
1187 ACTION("Ignoring illegal type definition\n");
1189 if (arrayNdx == NULL)
1191 key->dfltType = xkb_atom_intern(keymap->ctx, tmp.str);
1192 key->defs.defined |= _Key_Type_Dflt;
1194 else if (!ExprResolveGroup(keymap->ctx, arrayNdx, &ndx))
1196 ERROR("Illegal group index for type of key %s\n",
1197 longText(key->name));
1198 ACTION("Definition with non-integer array index ignored\n");
1204 key->types[ndx.uval - 1] = xkb_atom_intern(keymap->ctx, tmp.str);
1205 key->typesDefined |= (1 << (ndx.uval - 1));
1209 else if (strcasecmp(field, "symbols") == 0)
1210 return AddSymbolsToKey(key, keymap, arrayNdx, value, info);
1211 else if (strcasecmp(field, "actions") == 0)
1212 return AddActionsToKey(key, keymap, arrayNdx, value, info);
1213 else if ((strcasecmp(field, "vmods") == 0) ||
1214 (strcasecmp(field, "virtualmods") == 0) ||
1215 (strcasecmp(field, "virtualmodifiers") == 0))
1217 ok = ExprResolveVModMask(value, &tmp, keymap);
1220 key->vmodmap = (tmp.uval >> 8);
1221 key->defs.defined |= _Key_VModMap;
1225 ERROR("Expected a virtual modifier mask, found %s\n",
1226 exprOpText(value->op));
1227 ACTION("Ignoring virtual modifiers definition for key %s\n",
1228 longText(key->name));
1231 else if ((strcasecmp(field, "locking") == 0) ||
1232 (strcasecmp(field, "lock") == 0) ||
1233 (strcasecmp(field, "locks") == 0))
1235 ok = ExprResolveEnum(keymap->ctx, value, &tmp, lockingEntries);
1237 key->behavior.type = tmp.uval;
1238 key->defs.defined |= _Key_Behavior;
1240 else if ((strcasecmp(field, "radiogroup") == 0) ||
1241 (strcasecmp(field, "permanentradiogroup") == 0) ||
1242 (strcasecmp(field, "allownone") == 0))
1244 ERROR("Radio groups not supported\n");
1245 ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1248 else if (uStrCasePrefix("overlay", field) ||
1249 uStrCasePrefix("permanentoverlay", field))
1251 ERROR("Overlays not supported\n");
1252 ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1254 else if ((strcasecmp(field, "repeating") == 0) ||
1255 (strcasecmp(field, "repeats") == 0) ||
1256 (strcasecmp(field, "repeat") == 0))
1258 ok = ExprResolveEnum(keymap->ctx, value, &tmp, repeatEntries);
1261 ERROR("Illegal repeat setting for %s\n",
1262 longText(key->name));
1263 ACTION("Non-boolean repeat setting ignored\n");
1266 key->repeat = tmp.uval;
1267 key->defs.defined |= _Key_Repeat;
1269 else if ((strcasecmp(field, "groupswrap") == 0) ||
1270 (strcasecmp(field, "wrapgroups") == 0))
1272 ok = ExprResolveBoolean(keymap->ctx, value, &tmp);
1275 ERROR("Illegal groupsWrap setting for %s\n",
1276 longText(key->name));
1277 ACTION("Non-boolean value ignored\n");
1281 key->groupInfo = XkbWrapIntoRange;
1283 key->groupInfo = XkbClampIntoRange;
1284 key->defs.defined |= _Key_GroupInfo;
1286 else if ((strcasecmp(field, "groupsclamp") == 0) ||
1287 (strcasecmp(field, "clampgroups") == 0))
1289 ok = ExprResolveBoolean(keymap->ctx, value, &tmp);
1292 ERROR("Illegal groupsClamp setting for %s\n",
1293 longText(key->name));
1294 ACTION("Non-boolean value ignored\n");
1298 key->groupInfo = XkbClampIntoRange;
1300 key->groupInfo = XkbWrapIntoRange;
1301 key->defs.defined |= _Key_GroupInfo;
1303 else if ((strcasecmp(field, "groupsredirect") == 0) ||
1304 (strcasecmp(field, "redirectgroups") == 0))
1306 if (!ExprResolveGroup(keymap->ctx, value, &tmp))
1308 ERROR("Illegal group index for redirect of key %s\n",
1309 longText(key->name));
1310 ACTION("Definition with non-integer group ignored\n");
1314 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1315 key->defs.defined |= _Key_GroupInfo;
1319 ERROR("Unknown field %s in a symbol interpretation\n", field);
1320 ACTION("Definition ignored\n");
1327 SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1330 ExprResult tmp, name;
1332 if ((arrayNdx == NULL) && (warningLevel > 0))
1334 WARN("You must specify an index when specifying a group name\n");
1335 ACTION("Group name definition without array subscript ignored\n");
1338 if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp))
1340 ERROR("Illegal index in group name definition\n");
1341 ACTION("Definition with non-integer array index ignored\n");
1344 if (!ExprResolveString(keymap->ctx, value, &name))
1346 ERROR("Group name must be a string\n");
1347 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1350 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1351 xkb_atom_intern(keymap->ctx, name.str);
1358 HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info)
1360 ExprResult elem, field, tmp;
1364 if (ExprResolveLhs(keymap, stmt->name, &elem, &field, &arrayNdx) == 0)
1365 return 0; /* internal error, already reported */
1366 if (elem.str && (strcasecmp(elem.str, "key") == 0))
1368 ret = SetSymbolsField(&info->dflt, keymap, field.str, arrayNdx,
1371 else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) ||
1372 (strcasecmp(field.str, "groupname") ==
1375 ret = SetGroupName(info, keymap, arrayNdx, stmt->value);
1377 else if ((elem.str == NULL)
1378 && ((strcasecmp(field.str, "groupswrap") == 0) ||
1379 (strcasecmp(field.str, "wrapgroups") == 0)))
1381 if (!ExprResolveBoolean(keymap->ctx, stmt->value, &tmp))
1383 ERROR("Illegal setting for global groupsWrap\n");
1384 ACTION("Non-boolean value ignored\n");
1389 info->groupInfo = XkbWrapIntoRange;
1391 info->groupInfo = XkbClampIntoRange;
1395 else if ((elem.str == NULL)
1396 && ((strcasecmp(field.str, "groupsclamp") == 0) ||
1397 (strcasecmp(field.str, "clampgroups") == 0)))
1399 if (!ExprResolveBoolean(keymap->ctx, stmt->value, &tmp))
1401 ERROR("Illegal setting for global groupsClamp\n");
1402 ACTION("Non-boolean value ignored\n");
1407 info->groupInfo = XkbClampIntoRange;
1409 info->groupInfo = XkbWrapIntoRange;
1413 else if ((elem.str == NULL)
1414 && ((strcasecmp(field.str, "groupsredirect") == 0) ||
1415 (strcasecmp(field.str, "redirectgroups") == 0)))
1417 if (!ExprResolveGroup(keymap->ctx, stmt->value, &tmp))
1419 ERROR("Illegal group index for global groupsRedirect\n");
1420 ACTION("Definition with non-integer group ignored\n");
1424 info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1429 else if ((elem.str == NULL) && (strcasecmp(field.str, "allownone") == 0))
1431 ERROR("Radio groups not supported\n");
1432 ACTION("Ignoring \"allow none\" specification\n");
1436 ret = SetActionField(keymap, elem.str, field.str, arrayNdx,
1437 stmt->value, &info->action);
1446 HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key,
1450 ExprResult tmp, field;
1453 for (; def != NULL; def = (VarDef *) def->common.next)
1455 if ((def->name) && (def->name->type == ExprFieldRef))
1457 ok = HandleSymbolsVar(def, keymap, info);
1462 if (def->name == NULL)
1464 if ((def->value == NULL)
1465 || (def->value->op == ExprKeysymList))
1466 field.str = strdup("symbols");
1468 field.str = strdup("actions");
1473 ok = ExprResolveLhs(keymap, def->name, &tmp, &field,
1477 ok = SetSymbolsField(key, keymap, field.str, arrayNdx,
1486 SetExplicitGroup(SymbolsInfo *info, KeyInfo *key)
1488 unsigned group = info->explicit_group;
1493 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1496 WARN("For the map %s an explicit group specified\n", info->name);
1497 WARN("but key %s has more than one group defined\n",
1498 longText(key->name));
1499 ACTION("All groups except first one will be ignored\n");
1500 for (i = 1; i < XkbNumKbdGroups; i++)
1502 key->numLevels[i] = 0;
1504 key->syms[i] = NULL;
1506 key->acts[i] = NULL;
1510 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1512 key->numLevels[group] = key->numLevels[0];
1513 key->numLevels[0] = 0;
1514 key->syms[group] = key->syms[0];
1515 key->syms[0] = NULL;
1516 key->sizeSyms[group] = key->sizeSyms[0];
1517 key->sizeSyms[0] = 0;
1518 key->symsMapIndex[group] = key->symsMapIndex[0];
1519 key->symsMapIndex[0] = NULL;
1520 key->symsMapNumEntries[group] = key->symsMapNumEntries[0];
1521 key->symsMapNumEntries[0] = NULL;
1522 key->acts[group] = key->acts[0];
1523 key->acts[0] = NULL;
1524 key->types[group] = key->types[0];
1530 HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap,
1536 CopyKeyInfo(&info->dflt, &key, false);
1537 key.defs.merge = stmt->merge;
1538 key.name = KeyNameToLong(stmt->keyName);
1539 if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info))
1545 if (!SetExplicitGroup(info, &key))
1551 if (!AddKeySymbols(info, &key, keymap))
1560 HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info)
1567 if (!LookupModIndex(keymap->ctx, NULL, def->modifier, TypeInt, &rtrn))
1569 ERROR("Illegal modifier map definition\n");
1570 ACTION("Ignoring map for non-modifier \"%s\"\n",
1571 xkb_atom_text(keymap->ctx, def->modifier));
1575 tmp.modifier = rtrn.uval;
1576 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1578 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1580 tmp.haveSymbol = false;
1581 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1583 else if (ExprResolveKeySym(keymap->ctx, key, &rtrn))
1585 tmp.haveSymbol = true;
1586 tmp.u.keySym = rtrn.uval;
1590 ERROR("Modmap entries may contain only key names or keysyms\n");
1591 ACTION("Illegal definition for %s modifier ignored\n",
1592 XkbcModIndexText(tmp.modifier));
1596 ok = AddModMapEntry(info, &tmp) && ok;
1602 HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
1603 unsigned merge, SymbolsInfo *info)
1608 info->name = uDupString(file->name);
1612 switch (stmt->stmtType)
1615 if (!HandleIncludeSymbols((IncludeStmt *) stmt, keymap, info))
1618 case StmtSymbolsDef:
1619 if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info))
1623 if (!HandleSymbolsVar((VarDef *) stmt, keymap, info))
1627 if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
1631 ERROR("Interpretation files may not include other types\n");
1632 ACTION("Ignoring definition of symbol interpretation\n");
1635 case StmtKeycodeDef:
1636 ERROR("Interpretation files may not include other types\n");
1637 ACTION("Ignoring definition of key name\n");
1641 if (!HandleModMapDef((ModMapDef *) stmt, keymap, info))
1645 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1650 if (info->errorCount > 10)
1653 ERROR("Too many errors\n");
1655 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1662 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
1663 xkb_keycode_t *kc_rtrn)
1666 unsigned int group, level;
1668 for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
1670 for (group = 0; group < XkbKeyNumGroups(keymap, key); group++)
1672 for (level = 0; level < XkbKeyGroupWidth(keymap, key, group);
1675 if (XkbKeyNumSyms(keymap, key, group, level) != 1 ||
1676 (XkbKeySymEntry(keymap, key, group, level))[0] != sym)
1688 * Find the given name in the keymap->map->types and return its index.
1690 * @param atom The atom to search for.
1691 * @param type_rtrn Set to the index of the name if found.
1693 * @return true if found, false otherwise.
1696 FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
1699 const char *name = xkb_atom_text(keymap->ctx, atom);
1700 struct xkb_key_type *type;
1702 if (keymap && keymap->map) {
1703 darray_foreach(type, keymap->map->types) {
1704 if (strcmp(type->name, name) == 0) {
1715 * Assign a type to the given sym and return the Atom for the type assigned.
1718 * - ONE_LEVEL for width 0/1
1719 * - ALPHABETIC for 2 shift levels, with lower/upercase
1720 * - KEYPAD for keypad keys.
1721 * - TWO_LEVEL for other 2 shift level keys.
1722 * and the same for four level keys.
1724 * @param width Number of sysms in syms.
1725 * @param syms The keysyms for the given key (must be size width).
1726 * @param typeNameRtrn Set to the Atom of the type name.
1728 * @returns true if a type could be found, false otherwise.
1731 FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms,
1732 xkb_atom_t *typeNameRtrn, bool *autoType)
1735 if ((width == 1) || (width == 0))
1737 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ONE_LEVEL");
1740 else if (width == 2)
1742 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1744 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ALPHABETIC");
1746 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1748 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "KEYPAD");
1753 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "TWO_LEVEL");
1757 else if (width <= 4)
1759 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1760 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1762 xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_ALPHABETIC");
1764 *typeNameRtrn = xkb_atom_intern(keymap->ctx,
1765 "FOUR_LEVEL_SEMIALPHABETIC");
1767 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1768 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_KEYPAD");
1770 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL");
1771 /* XXX: why not set autoType here? */
1773 return ((width >= 0) && (width <= 4));
1777 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1778 * groups, and reduce to one group if all groups are identical anyway.
1781 PrepareKeyDef(KeyInfo * key)
1783 int i, j, width, defined, lastGroup;
1786 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1787 /* get highest group number */
1788 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1790 if (defined & (1 << i))
1798 /* If there are empty groups between non-empty ones fill them with data */
1799 /* from the first group. */
1800 /* We can make a wrong assumption here. But leaving gaps is worse. */
1801 for (i = lastGroup; i > 0; i--)
1803 if (defined & (1 << i))
1805 width = key->numLevels[0];
1806 if (key->typesDefined & 1)
1808 for (j = 0; j < width; j++)
1810 key->types[i] = key->types[0];
1812 key->typesDefined |= 1 << i;
1814 if ((key->actsDefined & 1) && key->acts[0])
1816 key->acts[i] = uTypedCalloc(width, union xkb_action);
1817 if (key->acts[i] == NULL)
1819 memcpy(key->acts[i], key->acts[0],
1820 width * sizeof(union xkb_action));
1821 key->actsDefined |= 1 << i;
1823 if ((key->symsDefined & 1) && key->sizeSyms[0])
1825 key->syms[i] = uTypedCalloc(key->sizeSyms[0], xkb_keysym_t);
1826 if (key->syms[i] == NULL)
1828 memcpy(key->syms[i], key->syms[0],
1829 key->sizeSyms[0] * sizeof(xkb_keysym_t));
1830 key->symsMapIndex[i] = uTypedCalloc(width, int);
1831 if (!key->symsMapIndex[i])
1834 key->syms[i] = NULL;
1837 memcpy(key->symsMapIndex[i], key->symsMapIndex[0],
1838 width * sizeof(int));
1839 key->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
1840 if (!key->symsMapNumEntries[i])
1843 key->syms[i] = NULL;
1844 free(key->symsMapIndex[i]);
1845 key->symsMapIndex[i] = NULL;
1848 memcpy(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1849 width * sizeof(int));
1850 key->sizeSyms[i] = key->sizeSyms[0];
1851 key->symsDefined |= 1 << i;
1855 key->numLevels[i] = key->numLevels[0];
1858 /* If all groups are completely identical remove them all */
1859 /* exept the first one. */
1861 for (i = lastGroup; i > 0; i--)
1863 if ((key->numLevels[i] != key->numLevels[0]) ||
1864 (key->types[i] != key->types[0]))
1869 if ((key->syms[i] != key->syms[0]) &&
1870 (key->syms[i] == NULL || key->syms[0] == NULL ||
1871 key->sizeSyms[i] != key->sizeSyms[0] ||
1872 memcmp(key->syms[i], key->syms[0],
1873 sizeof(xkb_keysym_t) * key->sizeSyms[0])))
1878 if ((key->symsMapIndex[i] != key->symsMapIndex[0]) &&
1879 (key->symsMapIndex[i] == NULL || key->symsMapIndex[0] == NULL ||
1880 memcmp(key->symsMapIndex[i], key->symsMapIndex[0],
1881 key->numLevels[0] * sizeof(int))))
1886 if ((key->symsMapNumEntries[i] != key->symsMapNumEntries[0]) &&
1887 (key->symsMapNumEntries[i] == NULL ||
1888 key->symsMapNumEntries[0] == NULL ||
1889 memcmp(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1890 key->numLevels[0] * sizeof(int))))
1895 if ((key->acts[i] != key->acts[0]) &&
1896 (key->acts[i] == NULL || key->acts[0] == NULL ||
1897 memcmp(key->acts[i], key->acts[0],
1898 sizeof(union xkb_action) * key->numLevels[0])))
1906 for (i = lastGroup; i > 0; i--)
1908 key->numLevels[i] = 0;
1910 key->syms[i] = NULL;
1911 key->sizeSyms[i] = 0;
1912 free(key->symsMapIndex[i]);
1913 key->symsMapIndex[i] = NULL;
1914 free(key->symsMapNumEntries[i]);
1915 key->symsMapNumEntries[i] = NULL;
1917 key->acts[i] = NULL;
1920 key->symsDefined &= 1;
1921 key->actsDefined &= 1;
1922 key->typesDefined &= 1;
1927 * Copy the KeyInfo into the keyboard description.
1929 * This function recurses.
1932 CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
1936 unsigned int sizeSyms = 0;
1937 unsigned width, tmp, nGroups;
1938 struct xkb_key_type * type;
1939 bool haveActions, autoType, useAlias;
1940 unsigned types[XkbNumKbdGroups];
1941 union xkb_action *outActs;
1942 unsigned int symIndex = 0;
1943 struct xkb_sym_map *sym_map;
1945 useAlias = (start_from == 0);
1947 /* get the keycode for the key. */
1948 if (!FindNamedKey(keymap, key->name, &kc, useAlias,
1949 CreateKeyNames(keymap), start_from))
1951 if ((start_from == 0) && (warningLevel >= 5))
1953 WARN("Key %s not found in keycodes\n", longText(key->name));
1954 ACTION("Symbols ignored\n");
1959 haveActions = false;
1960 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1962 if (((i + 1) > nGroups)
1963 && (((key->symsDefined | key->actsDefined) & (1 << i))
1964 || (key->typesDefined) & (1 << i)))
1969 /* Assign the type to the key, if it is missing. */
1970 if (key->types[i] == XKB_ATOM_NONE)
1972 if (key->dfltType != XKB_ATOM_NONE)
1973 key->types[i] = key->dfltType;
1974 else if (FindAutomaticType(keymap, key->numLevels[i], key->syms[i],
1975 &key->types[i], &autoType))
1980 if (warningLevel >= 5)
1982 WARN("No automatic type for %d symbols\n",
1983 (unsigned int) key->numLevels[i]);
1984 ACTION("Using %s for the %s key (keycode %d)\n",
1985 xkb_atom_text(keymap->ctx, key->types[i]),
1986 longText(key->name), kc);
1990 if (FindNamedType(keymap, key->types[i], &types[i]))
1992 if (!autoType || key->numLevels[i] > 2)
1993 keymap->server->explicit[kc] |= (1 << i);
1997 if (warningLevel >= 3)
1999 WARN("Type \"%s\" is not defined\n",
2000 xkb_atom_text(keymap->ctx, key->types[i]));
2001 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
2002 longText(key->name), kc);
2004 types[i] = XkbTwoLevelIndex;
2006 /* if the type specifies fewer levels than the key has, shrink the key */
2007 type = &darray_item(keymap->map->types, types[i]);
2008 if (type->num_levels < key->numLevels[i])
2010 if (warningLevel > 0)
2012 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
2013 type->name, type->num_levels,
2014 xkb_atom_text(keymap->ctx, key->name), key->numLevels[i]);
2015 ACTION("Ignoring extra symbols\n");
2017 key->numLevels[i] = type->num_levels;
2019 if (key->numLevels[i] > width)
2020 width = key->numLevels[i];
2021 if (type->num_levels > width)
2022 width = type->num_levels;
2023 sizeSyms += key->sizeSyms[i];
2026 if (!XkbcResizeKeySyms(keymap, kc, sizeSyms))
2028 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
2029 longText(key->name), kc);
2034 outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups);
2035 if (outActs == NULL)
2037 WSGO("Could not enlarge actions for %s (key %d)\n",
2038 longText(key->name), kc);
2041 keymap->server->explicit[kc] |= XkbExplicitInterpretMask;
2046 sym_map = &darray_item(keymap->map->key_sym_map, kc);
2048 if (key->defs.defined & _Key_GroupInfo)
2051 i = sym_map->group_info;
2053 sym_map->group_info = XkbSetNumGroups(i, nGroups);
2054 sym_map->width = width;
2055 sym_map->sym_index = uTypedCalloc(nGroups * width, int);
2056 sym_map->num_syms = uTypedCalloc(nGroups * width, unsigned int);
2058 for (i = 0; i < nGroups; i++)
2060 /* assign kt_index[i] to the index of the type in map->types.
2061 * kt_index[i] may have been set by a previous run (if we have two
2062 * layouts specified). Let's not overwrite it with the ONE_LEVEL
2063 * default group if we dont even have keys for this group anyway.
2065 * FIXME: There should be a better fix for this.
2067 if (key->numLevels[i])
2068 sym_map->kt_index[i] = types[i];
2069 if (key->sizeSyms[i] != 0)
2071 /* fill key to "width" symbols*/
2072 for (tmp = 0; tmp < width; tmp++)
2074 if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp])
2076 memcpy(&sym_map->syms[symIndex],
2077 &key->syms[i][key->symsMapIndex[i][tmp]],
2078 key->symsMapNumEntries[i][tmp] *
2079 sizeof(xkb_keysym_t));
2080 sym_map->sym_index[(i * width) + tmp] = symIndex;
2081 sym_map->num_syms[(i * width) + tmp] =
2082 key->symsMapNumEntries[i][tmp];
2083 symIndex += sym_map->num_syms[(i * width) + tmp];
2087 sym_map->sym_index[(i * width) + tmp] = -1;
2088 sym_map->num_syms[(i * width) + tmp] = 0;
2090 if ((outActs != NULL) && (key->acts[i] != NULL))
2092 if (tmp < key->numLevels[i])
2093 outActs[tmp] = key->acts[i][tmp];
2095 outActs[tmp].type = XkbSA_NoAction;
2100 switch (key->behavior.type & XkbKB_OpMask)
2105 keymap->server->behaviors[kc] = key->behavior;
2106 keymap->server->explicit[kc] |= XkbExplicitBehaviorMask;
2109 if (key->defs.defined & _Key_VModMap)
2111 keymap->server->vmodmap[kc] = key->vmodmap;
2112 keymap->server->explicit[kc] |= XkbExplicitVModMapMask;
2114 if (key->repeat != RepeatUndefined)
2116 if (key->repeat == RepeatYes)
2117 keymap->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
2119 keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
2120 keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
2123 if (nGroups > keymap->ctrls->num_groups)
2124 keymap->ctrls->num_groups = nGroups;
2126 /* do the same thing for the next key */
2127 CopySymbolsDef(keymap, key, kc + 1);
2132 CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
2136 if (!entry->haveSymbol &&
2137 !FindNamedKey(keymap, entry->u.keyName, &kc, true,
2138 CreateKeyNames(keymap), 0))
2140 if (warningLevel >= 5)
2142 WARN("Key %s not found in keycodes\n",
2143 longText(entry->u.keyName));
2144 ACTION("Modifier map entry for %s not updated\n",
2145 XkbcModIndexText(entry->modifier));
2149 else if (entry->haveSymbol &&
2150 !FindKeyForSymbol(keymap, entry->u.keySym, &kc))
2152 if (warningLevel > 5)
2154 WARN("Key \"%s\" not found in symbol map\n",
2155 XkbcKeysymText(entry->u.keySym));
2156 ACTION("Modifier map entry for %s not updated\n",
2157 XkbcModIndexText(entry->modifier));
2161 keymap->map->modmap[kc] |= (1 << entry->modifier);
2166 * Handle the xkb_symbols section of an xkb file.
2168 * @param file The parsed xkb_symbols section of the xkb file.
2169 * @param keymap Handle to the keyboard description to store the symbols in.
2170 * @param merge Merge strategy (e.g. MergeOverride).
2173 CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
2179 InitSymbolsInfo(&info, keymap);
2180 info.dflt.defs.fileID = file->id;
2181 info.dflt.defs.merge = merge;
2183 HandleSymbolsFile(file, keymap, merge, &info);
2185 if (darray_empty(info.keys))
2188 if (info.errorCount != 0)
2191 /* alloc memory in the xkb struct */
2192 if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) {
2193 WSGO("Can not allocate names in CompileSymbols\n");
2194 ACTION("Symbols not added\n");
2198 if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
2200 WSGO("Could not allocate client map in CompileSymbols\n");
2201 ACTION("Symbols not added\n");
2205 if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
2206 WSGO("Could not allocate server map in CompileSymbols\n");
2207 ACTION("Symbols not added\n");
2211 if (XkbcAllocControls(keymap) != Success) {
2212 WSGO("Could not allocate controls in CompileSymbols\n");
2213 ACTION("Symbols not added\n");
2217 /* now copy info into xkb. */
2218 ApplyAliases(keymap, &info.aliases);
2220 for (i = 0; i < XkbNumKbdGroups; i++) {
2221 if (info.groupNames[i] != XKB_ATOM_NONE) {
2222 free(UNCONSTIFY(keymap->names->groups[i]));
2223 keymap->names->groups[i] = xkb_atom_strdup(keymap->ctx,
2224 info.groupNames[i]);
2229 darray_foreach(key, info.keys)
2233 darray_foreach(key, info.keys)
2234 if (!CopySymbolsDef(keymap, key, 0))
2237 if (warningLevel > 3) {
2238 for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
2239 if (darray_item(keymap->names->keys, i).name[0] == '\0')
2242 if (XkbKeyNumGroups(keymap, i) < 1) {
2244 memcpy(buf, darray_item(keymap->names->keys, i).name, 4);
2246 WARN("No symbols defined for <%s> (keycode %d)\n", buf, i);
2252 ModMapEntry *mm, *next;
2253 for (mm = info.modMap; mm != NULL; mm = next) {
2254 if (!CopyModMapDef(keymap, mm))
2256 next = (ModMapEntry *) mm->defs.next;
2260 FreeSymbolsInfo(&info);
2264 FreeSymbolsInfo(&info);