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 <X11/keysym.h>
29 #include "xkbcomp-priv.h"
30 #include "parseutils.h"
36 /***====================================================================***/
40 #define RepeatUndefined ~((unsigned)0)
42 #define _Key_Syms (1<<0)
43 #define _Key_Acts (1<<1)
44 #define _Key_Repeat (1<<2)
45 #define _Key_Behavior (1<<3)
46 #define _Key_Type_Dflt (1<<4)
47 #define _Key_Types (1<<5)
48 #define _Key_GroupInfo (1<<6)
49 #define _Key_VModMap (1<<7)
51 typedef struct _KeyInfo
54 unsigned long name; /* the 4 chars of the key name, as long */
55 unsigned char groupInfo;
56 unsigned char typesDefined;
57 unsigned char symsDefined;
58 unsigned char actsDefined;
59 unsigned int numLevels[XkbNumKbdGroups];
61 /* syms[group] -> Single array for all the keysyms in the group. */
62 xkb_keysym_t *syms[XkbNumKbdGroups];
63 /* sizeSyms[group] -> The size of the syms[group] array. */
64 int sizeSyms[XkbNumKbdGroups];
66 * symsMapIndex[group][level] -> The index from which the syms for
67 * the level begin in the syms[group] array. Remember each keycode
68 * can have multiple keysyms in each level (that is, each key press
69 * can result in multiple keysyms).
71 int *symsMapIndex[XkbNumKbdGroups];
73 * symsMapNumEntries[group][level] -> How many syms are in
74 * syms[group][symsMapIndex[group][level]].
76 unsigned int *symsMapNumEntries[XkbNumKbdGroups];
78 union xkb_action *acts[XkbNumKbdGroups];
79 xkb_atom_t types[XkbNumKbdGroups];
81 struct xkb_behavior behavior;
82 unsigned short vmodmap;
83 unsigned long allowNone;
88 * Init the given key info to sane values.
91 InitKeyInfo(KeyInfo * info)
94 static char dflt[4] = "*";
96 info->defs.defined = 0;
97 info->defs.fileID = 0;
98 info->defs.merge = MergeOverride;
99 info->defs.next = NULL;
100 info->name = KeyNameToLong(dflt);
102 info->typesDefined = info->symsDefined = info->actsDefined = 0;
103 for (i = 0; i < XkbNumKbdGroups; i++)
105 info->numLevels[i] = 0;
106 info->types[i] = XKB_ATOM_NONE;
107 info->syms[i] = NULL;
108 info->sizeSyms[i] = 0;
109 info->symsMapIndex[i] = NULL;
110 info->symsMapNumEntries[i] = NULL;
111 info->acts[i] = NULL;
113 info->dfltType = XKB_ATOM_NONE;
114 info->behavior.type = XkbKB_Default;
115 info->behavior.data = 0;
117 info->repeat = RepeatUndefined;
122 * Free memory associated with this key info and reset to sane values.
125 FreeKeyInfo(KeyInfo * info)
129 info->defs.defined = 0;
130 info->defs.fileID = 0;
131 info->defs.merge = MergeOverride;
132 info->defs.next = NULL;
134 info->typesDefined = info->symsDefined = info->actsDefined = 0;
135 for (i = 0; i < XkbNumKbdGroups; i++)
137 info->numLevels[i] = 0;
138 info->types[i] = XKB_ATOM_NONE;
140 info->syms[i] = NULL;
141 info->sizeSyms[i] = 0;
142 free(info->symsMapIndex[i]);
143 info->symsMapIndex[i] = NULL;
144 free(info->symsMapNumEntries[i]);
145 info->symsMapNumEntries[i] = NULL;
147 info->acts[i] = NULL;
149 info->dfltType = XKB_ATOM_NONE;
150 info->behavior.type = XkbKB_Default;
151 info->behavior.data = 0;
153 info->repeat = RepeatUndefined;
158 * Copy old into new, optionally reset old to 0.
159 * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
160 * newly allocated and new points to the new memory areas.
163 CopyKeyInfo(KeyInfo * old, KeyInfo * new, bool clearOld)
168 new->defs.next = NULL;
171 for (i = 0; i < XkbNumKbdGroups; i++)
173 old->numLevels[i] = 0;
174 old->symsMapIndex[i] = NULL;
175 old->symsMapNumEntries[i] = NULL;
177 old->sizeSyms[i] = 0;
184 for (i = 0; i < XkbNumKbdGroups; i++)
186 width = new->numLevels[i];
187 if (old->syms[i] != NULL)
189 new->syms[i] = uTypedCalloc(new->sizeSyms[i], xkb_keysym_t);
193 new->sizeSyms[i] = 0;
194 new->numLevels[i] = 0;
198 memcpy(new->syms[i], old->syms[i],
199 new->sizeSyms[i] * sizeof(xkb_keysym_t));
200 new->symsMapIndex[i] = uTypedCalloc(width, int);
201 if (!new->symsMapIndex[i])
205 new->sizeSyms[i] = 0;
206 new->numLevels[i] = 0;
210 memcpy(new->symsMapIndex[i], old->symsMapIndex[i],
211 width * sizeof(int));
212 new->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
213 if (!new->symsMapNumEntries[i])
217 new->sizeSyms[i] = 0;
218 free(new->symsMapIndex[i]);
219 new->symsMapIndex[i] = NULL;
220 new->numLevels[i] = 0;
224 memcpy(new->symsMapNumEntries[i], old->symsMapNumEntries[i],
225 width * sizeof(unsigned int));
227 if (old->acts[i] != NULL)
229 new->acts[i] = uTypedCalloc(width, union xkb_action);
234 new->sizeSyms[i] = 0;
235 free(new->symsMapIndex[i]);
236 new->symsMapIndex[i] = NULL;
237 free(new->symsMapNumEntries[i]);
238 new->symsMapNumEntries[i] = NULL;
239 new->numLevels[i] = 0;
242 memcpy(new->acts[i], old->acts[i],
243 width * sizeof(union xkb_action));
250 /***====================================================================***/
252 typedef struct _ModMapEntry
259 unsigned long keyName;
264 #define SYMBOLS_INIT_SIZE 110
265 #define SYMBOLS_CHUNK 20
266 typedef struct _SymbolsInfo
268 char *name; /* e.g. pc+us+inet(evdev) */
272 unsigned explicit_group;
280 xkb_atom_t groupNames[XkbNumKbdGroups];
287 InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap)
292 info->explicit_group = 0;
293 info->errorCount = 0;
295 info->merge = MergeOverride;
297 info->szKeys = SYMBOLS_INIT_SIZE;
299 info->keys = uTypedCalloc(SYMBOLS_INIT_SIZE, KeyInfo);
301 for (i = 0; i < XkbNumKbdGroups; i++)
302 info->groupNames[i] = XKB_ATOM_NONE;
303 InitKeyInfo(&info->dflt);
304 InitVModInfo(&info->vmods, keymap);
306 info->aliases = NULL;
310 FreeSymbolsInfo(SymbolsInfo * info)
317 for (i = 0; i < info->nKeys; i++)
318 FreeKeyInfo(&info->keys[i]);
322 ClearCommonInfo(&info->modMap->defs);
324 ClearAliases(&info->aliases);
325 memset(info, 0, sizeof(SymbolsInfo));
329 ResizeKeyGroup(KeyInfo * key, unsigned int group, unsigned int numLevels,
330 unsigned sizeSyms, bool forceActions)
334 if (key->syms[group] == NULL || key->sizeSyms[group] < sizeSyms)
336 key->syms[group] = uTypedRecalloc(key->syms[group],
337 key->sizeSyms[group],
340 if (!key->syms[group]) {
341 key->sizeSyms[group] = 0;
344 key->sizeSyms[group] = sizeSyms;
346 if (!key->symsMapIndex[group] || key->numLevels[group] < numLevels)
348 key->symsMapIndex[group] = uTypedRealloc(key->symsMapIndex[group],
351 if (!key->symsMapIndex[group])
353 for (i = key->numLevels[group]; i < numLevels; i++)
354 key->symsMapIndex[group][i] = -1;
356 if (!key->symsMapNumEntries[group] || key->numLevels[group] < numLevels)
358 key->symsMapNumEntries[group] =
359 uTypedRecalloc(key->symsMapNumEntries[group],
360 key->numLevels[group],
363 if (!key->symsMapNumEntries[group])
367 (key->numLevels[group] < numLevels || (key->acts[group] == NULL))) ||
368 (key->numLevels[group] < numLevels && (key->acts[group] != NULL)))
370 key->acts[group] = uTypedRecalloc(key->acts[group],
371 key->numLevels[group],
374 if (!key->acts[group])
377 if (key->numLevels[group] < numLevels)
378 key->numLevels[group] = numLevels;
383 MergeKeyGroups(SymbolsInfo * info,
384 KeyInfo * into, KeyInfo * from, unsigned group)
386 xkb_keysym_t *resultSyms = NULL;
387 union xkb_action *resultActs;
388 unsigned int resultWidth;
389 unsigned int resultSize = 0;
392 bool report, clobber;
394 clobber = (from->defs.merge != MergeAugment);
395 report = (warningLevel > 9) ||
396 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
397 if (into->numLevels[group] >= from->numLevels[group])
399 resultActs = into->acts[group];
400 resultWidth = into->numLevels[group];
404 resultActs = from->acts[group];
405 resultWidth = from->numLevels[group];
406 into->symsMapIndex[group] = uTypedRealloc(into->symsMapIndex[group],
407 from->numLevels[group],
409 into->symsMapNumEntries[group] =
410 uTypedRecalloc(into->symsMapNumEntries[group],
411 into->numLevels[group],
412 from->numLevels[group],
414 if (!into->symsMapIndex[group] || !into->symsMapNumEntries[group])
416 WSGO("Could not allocate level indices for key info merge\n");
417 ACTION("Group %d of key %s not merged\n", group,
418 longText(into->name));
422 for (i = into->numLevels[group]; i < from->numLevels[group]; i++)
423 into->symsMapIndex[group][i] = -1;
426 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
428 resultActs = uTypedCalloc(resultWidth, union xkb_action);
431 WSGO("Could not allocate actions for group merge\n");
432 ACTION("Group %d of key %s not merged\n", group,
433 longText(into->name));
436 for (i = 0; i < resultWidth; i++)
438 union xkb_action *fromAct, *toAct;
439 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
440 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
441 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
444 resultActs[i] = *toAct;
446 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
447 && (fromAct != NULL))
449 resultActs[i] = *fromAct;
453 union xkb_action *use, *ignore;
467 ("Multiple actions for level %d/group %d on key %s\n",
468 i + 1, group + 1, longText(into->name));
469 ACTION("Using %s, ignoring %s\n",
470 XkbcActionTypeText(use->type),
471 XkbcActionTypeText(ignore->type));
474 resultActs[i] = *use;
479 for (i = 0; i < resultWidth; i++)
481 unsigned int fromSize = 0;
484 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
485 fromSize = from->symsMapNumEntries[group][i];
486 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
487 toSize = into->symsMapNumEntries[group][i];
489 if ((fromSize != 0 && toSize == 0) || clobber)
490 resultSize += fromSize;
492 resultSize += toSize;
498 resultSyms = uTypedCalloc(resultSize, xkb_keysym_t);
501 WSGO("Could not allocate symbols for group merge\n");
502 ACTION("Group %d of key %s not merged\n", group, longText(into->name));
506 for (i = 0; i < resultWidth; i++)
508 enum { NONE, FROM, TO } use;
509 unsigned int fromSize = 0;
510 unsigned int toSize = 0;
512 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
513 fromSize = from->symsMapNumEntries[group][i];
514 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
515 toSize = into->symsMapNumEntries[group][i];
517 if (!fromSize && !toSize)
519 into->symsMapIndex[group][i] = -1;
520 into->symsMapNumEntries[group][i] = 0;
524 if ((fromSize && !toSize) || clobber)
529 if (toSize && fromSize && report)
531 INFO("Multiple symbols for group %d, level %d on key %s\n",
532 group + 1, i + 1, longText(into->name));
533 ACTION("Using %s, ignoring %s\n",
534 (use == FROM ? "from" : "to"),
535 (use == FROM ? "to" : "from"));
540 memcpy(&resultSyms[cur_idx],
541 &from->syms[group][from->symsMapIndex[group][i]],
542 from->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
543 into->symsMapIndex[group][i] = cur_idx;
544 into->symsMapNumEntries[group][i] =
545 from->symsMapNumEntries[group][i];
549 memcpy(&resultSyms[cur_idx],
550 &into->syms[group][from->symsMapIndex[group][i]],
551 into->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
552 into->symsMapIndex[group][i] = cur_idx;
554 cur_idx += into->symsMapNumEntries[group][i];
558 if (resultActs != into->acts[group])
559 free(into->acts[group]);
560 if (resultActs != from->acts[group])
561 free(from->acts[group]);
562 into->numLevels[group] = resultWidth;
563 free(into->syms[group]);
564 into->syms[group] = resultSyms;
565 free(from->syms[group]);
566 from->syms[group] = NULL;
567 from->sizeSyms[group] = 0;
568 into->sizeSyms[group] = resultSize;
569 free(from->symsMapIndex[group]);
570 from->symsMapIndex[group] = NULL;
571 free(from->symsMapNumEntries[group]);
572 from->symsMapNumEntries[group] = NULL;
573 into->acts[group] = resultActs;
574 from->acts[group] = NULL;
575 into->symsDefined |= (1 << group);
576 from->symsDefined &= ~(1 << group);
577 into->actsDefined |= (1 << group);
578 from->actsDefined &= ~(1 << group);
584 MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap,
585 KeyInfo *into, KeyInfo *from)
588 unsigned collide = 0;
591 if (from->defs.merge == MergeReplace)
593 for (i = 0; i < XkbNumKbdGroups; i++)
595 if (into->numLevels[i] != 0)
602 memset(from, 0, sizeof(KeyInfo));
605 report = ((warningLevel > 9) ||
606 ((into->defs.fileID == from->defs.fileID)
607 && (warningLevel > 0)));
608 for (i = 0; i < XkbNumKbdGroups; i++)
610 if (from->numLevels[i] > 0)
612 if (into->numLevels[i] == 0)
614 into->numLevels[i] = from->numLevels[i];
615 into->syms[i] = from->syms[i];
616 into->sizeSyms[i] = from->sizeSyms[i];
617 into->symsMapIndex[i] = from->symsMapIndex[i];
618 into->symsMapNumEntries[i] = from->symsMapNumEntries[i];
619 into->acts[i] = from->acts[i];
620 into->symsDefined |= (1 << i);
621 from->syms[i] = NULL;
622 from->sizeSyms[i] = 0;
623 from->symsMapIndex[i] = NULL;
624 from->symsMapNumEntries[i] = NULL;
625 from->acts[i] = NULL;
626 from->numLevels[i] = 0;
627 from->symsDefined &= ~(1 << i);
629 into->defs.defined |= _Key_Syms;
631 into->defs.defined |= _Key_Acts;
638 collide |= _Key_Syms;
640 collide |= _Key_Acts;
642 MergeKeyGroups(info, into, from, (unsigned) i);
645 if (from->types[i] != XKB_ATOM_NONE)
647 if ((into->types[i] != XKB_ATOM_NONE) && report &&
648 (into->types[i] != from->types[i]))
650 xkb_atom_t use, ignore;
651 collide |= _Key_Types;
652 if (from->defs.merge != MergeAugment)
654 use = from->types[i];
655 ignore = into->types[i];
659 use = into->types[i];
660 ignore = from->types[i];
663 ("Multiple definitions for group %d type of key %s\n",
664 i, longText(into->name));
665 ACTION("Using %s, ignoring %s\n",
666 xkb_atom_text(keymap->context, use),
667 xkb_atom_text(keymap->context, ignore));
669 if ((from->defs.merge != MergeAugment)
670 || (into->types[i] == XKB_ATOM_NONE))
672 into->types[i] = from->types[i];
676 if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
678 into->behavior = from->behavior;
679 into->defs.defined |= _Key_Behavior;
681 if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
683 into->vmodmap = from->vmodmap;
684 into->defs.defined |= _Key_VModMap;
686 if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
688 into->repeat = from->repeat;
689 into->defs.defined |= _Key_Repeat;
691 if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
693 into->dfltType = from->dfltType;
694 into->defs.defined |= _Key_Type_Dflt;
696 if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
698 into->groupInfo = from->groupInfo;
699 into->defs.defined |= _Key_GroupInfo;
703 WARN("Symbol map for key %s redefined\n",
704 longText(into->name));
705 ACTION("Using %s definition for conflicting fields\n",
706 (from->defs.merge == MergeAugment ? "first" : "last"));
712 AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap)
715 unsigned long real_name;
717 for (i = 0; i < info->nKeys; i++)
719 if (info->keys[i].name == key->name)
720 return MergeKeys(info, keymap, &info->keys[i], key);
722 if (FindKeyNameForAlias(keymap, key->name, &real_name))
724 for (i = 0; i < info->nKeys; i++)
726 if (info->keys[i].name == real_name)
727 return MergeKeys(info, keymap, &info->keys[i], key);
730 if (info->nKeys >= info->szKeys)
732 info->szKeys += SYMBOLS_CHUNK;
734 uTypedRecalloc(info->keys, info->nKeys, info->szKeys, KeyInfo);
737 WSGO("Could not allocate key symbols descriptions\n");
738 ACTION("Some key symbols definitions may be lost\n");
742 return CopyKeyInfo(key, &info->keys[info->nKeys++], true);
746 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
751 clobber = (new->defs.merge != MergeAugment);
752 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
754 if (new->haveSymbol && mm->haveSymbol
755 && (new->u.keySym == mm->u.keySym))
757 unsigned use, ignore;
758 if (mm->modifier != new->modifier)
763 ignore = mm->modifier;
768 ignore = new->modifier;
771 ("%s added to symbol map for multiple modifiers\n",
772 XkbcKeysymText(new->u.keySym));
773 ACTION("Using %s, ignoring %s.\n",
774 XkbcModIndexText(use),
775 XkbcModIndexText(ignore));
780 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
781 (new->u.keyName == mm->u.keyName))
783 unsigned use, ignore;
784 if (mm->modifier != new->modifier)
789 ignore = mm->modifier;
794 ignore = new->modifier;
796 ERROR("Key %s added to map for multiple modifiers\n",
797 longText(new->u.keyName));
798 ACTION("Using %s, ignoring %s.\n",
799 XkbcModIndexText(use),
800 XkbcModIndexText(ignore));
806 mm = uTypedAlloc(ModMapEntry);
809 WSGO("Could not allocate modifier map entry\n");
810 ACTION("Modifier map for %s will be incomplete\n",
811 XkbcModIndexText(new->modifier));
815 mm->defs.next = &info->modMap->defs;
820 /***====================================================================***/
823 MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
824 unsigned merge, struct xkb_keymap *keymap)
829 if (from->errorCount > 0)
831 into->errorCount += from->errorCount;
834 if (into->name == NULL)
836 into->name = from->name;
839 for (i = 0; i < XkbNumKbdGroups; i++)
841 if (from->groupNames[i] != XKB_ATOM_NONE)
843 if ((merge != MergeAugment) ||
844 (into->groupNames[i] == XKB_ATOM_NONE))
845 into->groupNames[i] = from->groupNames[i];
848 for (i = 0, key = from->keys; i < from->nKeys; i++, key++)
850 if (merge != MergeDefault)
851 key->defs.merge = merge;
852 if (!AddKeySymbols(into, key, keymap))
855 if (from->modMap != NULL)
857 ModMapEntry *mm, *next;
858 for (mm = from->modMap; mm != NULL; mm = next)
860 if (merge != MergeDefault)
861 mm->defs.merge = merge;
862 if (!AddModMapEntry(into, mm))
864 next = (ModMapEntry *) mm->defs.next;
869 if (!MergeAliases(&into->aliases, &from->aliases, merge))
873 typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap,
874 unsigned merge, SymbolsInfo *included);
877 HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap,
878 SymbolsInfo *info, FileHandler hndlr)
882 SymbolsInfo included;
886 if ((stmt->file == NULL) && (stmt->map == NULL))
890 memset(info, 0, sizeof(SymbolsInfo));
892 else if (ProcessIncludeFile(keymap->context, stmt, XkmSymbolsIndex,
895 InitSymbolsInfo(&included, keymap);
896 included.fileID = included.dflt.defs.fileID = rtrn->id;
897 included.merge = included.dflt.defs.merge = MergeOverride;
900 included.explicit_group = atoi(stmt->modifier) - 1;
904 included.explicit_group = info->explicit_group;
906 (*hndlr) (rtrn, keymap, MergeOverride, &included);
907 if (stmt->stmt != NULL)
910 included.name = stmt->stmt;
917 info->errorCount += 10;
920 if ((stmt->next != NULL) && (included.errorCount < 1))
924 SymbolsInfo next_incl;
926 for (next = stmt->next; next != NULL; next = next->next)
928 if ((next->file == NULL) && (next->map == NULL))
931 MergeIncludedSymbols(&included, info, next->merge, keymap);
932 FreeSymbolsInfo(info);
934 else if (ProcessIncludeFile(keymap->context, next,
935 XkmSymbolsIndex, &rtrn, &op))
937 InitSymbolsInfo(&next_incl, keymap);
938 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
939 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
942 next_incl.explicit_group = atoi(next->modifier) - 1;
946 next_incl.explicit_group = info->explicit_group;
948 (*hndlr) (rtrn, keymap, MergeOverride, &next_incl);
949 MergeIncludedSymbols(&included, &next_incl, op, keymap);
950 FreeSymbolsInfo(&next_incl);
955 info->errorCount += 10;
956 FreeSymbolsInfo(&included);
963 info->errorCount += included.errorCount;
969 MergeIncludedSymbols(info, &included, newMerge, keymap);
970 FreeSymbolsInfo(&included);
972 return (info->errorCount == 0);
979 GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap,
980 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
990 if (arrayNdx == NULL)
995 defined = key->symsDefined;
997 defined = key->actsDefined;
999 for (i = 0; i < XkbNumKbdGroups; i++)
1001 if ((defined & (1 << i)) == 0)
1007 ERROR("Too many groups of %s for key %s (max %d)\n", name,
1008 longText(key->name), XkbNumKbdGroups + 1);
1009 ACTION("Ignoring %s defined for extra groups\n", name);
1012 if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp))
1014 ERROR("Illegal group index for %s of key %s\n", name,
1015 longText(key->name));
1016 ACTION("Definition with non-integer array index ignored\n");
1019 *ndx_rtrn = tmp.uval - 1;
1024 AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap,
1025 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1027 unsigned ndx, nSyms, nLevels;
1031 if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx))
1035 key->symsDefined |= (1 << ndx);
1038 if (value->op != ExprKeysymList)
1040 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
1041 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
1042 longText(key->name));
1045 if (key->sizeSyms[ndx] != 0)
1047 ERROR("Symbols for key %s, group %d already defined\n",
1048 longText(key->name), ndx + 1);
1049 ACTION("Ignoring duplicate definition\n");
1052 nSyms = value->value.list.nSyms;
1053 nLevels = value->value.list.nLevels;
1054 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
1055 (!ResizeKeyGroup(key, ndx, nLevels, nSyms, false)))
1057 WSGO("Could not resize group %d of key %s to contain %d levels\n",
1058 ndx + 1, longText(key->name), nSyms);
1059 ACTION("Symbols lost\n");
1062 key->symsDefined |= (1 << ndx);
1063 for (i = 0; i < nLevels; i++) {
1064 key->symsMapIndex[ndx][i] = value->value.list.symsMapIndex[i];
1065 key->symsMapNumEntries[ndx][i] = value->value.list.symsNumEntries[i];
1066 for (j = 0; j < key->symsMapNumEntries[ndx][i]; j++) {
1067 if (key->symsMapIndex[ndx][i] + j >= nSyms)
1069 if (!LookupKeysym(value->value.list.syms[value->value.list.symsMapIndex[i] + j],
1070 &key->syms[ndx][key->symsMapIndex[ndx][i] + j])) {
1071 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
1072 value->value.list.syms[i], longText(key->name), ndx + 1,
1073 xkb_atom_text(keymap->context, info->groupNames[ndx]), nSyms);
1075 key->syms[ndx][key->symsMapIndex[ndx][i] + j] = NoSymbol;
1076 key->symsMapIndex[ndx][i] = -1;
1077 key->symsMapNumEntries[ndx][i] = 0;
1082 for (j = key->numLevels[ndx] - 1;
1083 j >= 0 && key->symsMapNumEntries[ndx][j] == 0; j--)
1084 key->numLevels[ndx]--;
1089 AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1090 ExprDef *value, SymbolsInfo *info)
1093 unsigned ndx, nActs;
1095 struct xkb_any_action *toAct;
1097 if (!GetGroupIndex(key, keymap, arrayNdx, ACTIONS, &ndx))
1102 key->actsDefined |= (1 << ndx);
1105 if (value->op != ExprActionList)
1107 WSGO("Bad expression type (%d) for action list value\n", value->op);
1108 ACTION("Ignoring actions for group %d of %s\n", ndx,
1109 longText(key->name));
1112 if (key->acts[ndx] != NULL)
1114 WSGO("Actions for key %s, group %d already defined\n",
1115 longText(key->name), ndx);
1118 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
1120 act = (ExprDef *) act->common.next;
1124 WSGO("Action list but not actions in AddActionsToKey\n");
1127 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
1128 (!ResizeKeyGroup(key, ndx, nActs, nActs, true)))
1130 WSGO("Could not resize group %d of key %s\n", ndx,
1131 longText(key->name));
1132 ACTION("Actions lost\n");
1135 key->actsDefined |= (1 << ndx);
1137 toAct = (struct xkb_any_action *) key->acts[ndx];
1138 act = value->value.child;
1139 for (i = 0; i < nActs; i++, toAct++)
1141 if (!HandleActionDef(act, keymap, toAct, info->action))
1143 ERROR("Illegal action definition for %s\n",
1144 longText(key->name));
1145 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1147 act = (ExprDef *) act->common.next;
1152 static const LookupEntry lockingEntries[] = {
1153 {"true", XkbKB_Lock},
1154 {"yes", XkbKB_Lock},
1156 {"false", XkbKB_Default},
1157 {"no", XkbKB_Default},
1158 {"off", XkbKB_Default},
1159 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1163 static const LookupEntry repeatEntries[] = {
1164 {"true", RepeatYes},
1167 {"false", RepeatNo},
1170 {"default", RepeatUndefined},
1175 SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field,
1176 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1181 if (strcasecmp(field, "type") == 0)
1184 if ((!ExprResolveString(keymap->context, value, &tmp))
1185 && (warningLevel > 0))
1187 WARN("The type field of a key symbol map must be a string\n");
1188 ACTION("Ignoring illegal type definition\n");
1190 if (arrayNdx == NULL)
1192 key->dfltType = xkb_atom_intern(keymap->context, tmp.str);
1193 key->defs.defined |= _Key_Type_Dflt;
1195 else if (!ExprResolveGroup(keymap->context, arrayNdx, &ndx))
1197 ERROR("Illegal group index for type of key %s\n",
1198 longText(key->name));
1199 ACTION("Definition with non-integer array index ignored\n");
1205 key->types[ndx.uval - 1] = xkb_atom_intern(keymap->context,
1207 key->typesDefined |= (1 << (ndx.uval - 1));
1211 else if (strcasecmp(field, "symbols") == 0)
1212 return AddSymbolsToKey(key, keymap, arrayNdx, value, info);
1213 else if (strcasecmp(field, "actions") == 0)
1214 return AddActionsToKey(key, keymap, arrayNdx, value, info);
1215 else if ((strcasecmp(field, "vmods") == 0) ||
1216 (strcasecmp(field, "virtualmods") == 0) ||
1217 (strcasecmp(field, "virtualmodifiers") == 0))
1219 ok = ExprResolveVModMask(value, &tmp, keymap);
1222 key->vmodmap = (tmp.uval >> 8);
1223 key->defs.defined |= _Key_VModMap;
1227 ERROR("Expected a virtual modifier mask, found %s\n",
1228 exprOpText(value->op));
1229 ACTION("Ignoring virtual modifiers definition for key %s\n",
1230 longText(key->name));
1233 else if ((strcasecmp(field, "locking") == 0) ||
1234 (strcasecmp(field, "lock") == 0) ||
1235 (strcasecmp(field, "locks") == 0))
1237 ok = ExprResolveEnum(keymap->context, value, &tmp, lockingEntries);
1239 key->behavior.type = tmp.uval;
1240 key->defs.defined |= _Key_Behavior;
1242 else if ((strcasecmp(field, "radiogroup") == 0) ||
1243 (strcasecmp(field, "permanentradiogroup") == 0) ||
1244 (strcasecmp(field, "allownone") == 0))
1246 ERROR("Radio groups not supported\n");
1247 ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1250 else if (uStrCasePrefix("overlay", field) ||
1251 uStrCasePrefix("permanentoverlay", field))
1253 ERROR("Overlays not supported\n");
1254 ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1256 else if ((strcasecmp(field, "repeating") == 0) ||
1257 (strcasecmp(field, "repeats") == 0) ||
1258 (strcasecmp(field, "repeat") == 0))
1260 ok = ExprResolveEnum(keymap->context, value, &tmp, repeatEntries);
1263 ERROR("Illegal repeat setting for %s\n",
1264 longText(key->name));
1265 ACTION("Non-boolean repeat setting ignored\n");
1268 key->repeat = tmp.uval;
1269 key->defs.defined |= _Key_Repeat;
1271 else if ((strcasecmp(field, "groupswrap") == 0) ||
1272 (strcasecmp(field, "wrapgroups") == 0))
1274 ok = ExprResolveBoolean(keymap->context, value, &tmp);
1277 ERROR("Illegal groupsWrap setting for %s\n",
1278 longText(key->name));
1279 ACTION("Non-boolean value ignored\n");
1283 key->groupInfo = XkbWrapIntoRange;
1285 key->groupInfo = XkbClampIntoRange;
1286 key->defs.defined |= _Key_GroupInfo;
1288 else if ((strcasecmp(field, "groupsclamp") == 0) ||
1289 (strcasecmp(field, "clampgroups") == 0))
1291 ok = ExprResolveBoolean(keymap->context, value, &tmp);
1294 ERROR("Illegal groupsClamp setting for %s\n",
1295 longText(key->name));
1296 ACTION("Non-boolean value ignored\n");
1300 key->groupInfo = XkbClampIntoRange;
1302 key->groupInfo = XkbWrapIntoRange;
1303 key->defs.defined |= _Key_GroupInfo;
1305 else if ((strcasecmp(field, "groupsredirect") == 0) ||
1306 (strcasecmp(field, "redirectgroups") == 0))
1308 if (!ExprResolveGroup(keymap->context, value, &tmp))
1310 ERROR("Illegal group index for redirect of key %s\n",
1311 longText(key->name));
1312 ACTION("Definition with non-integer group ignored\n");
1316 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1317 key->defs.defined |= _Key_GroupInfo;
1321 ERROR("Unknown field %s in a symbol interpretation\n", field);
1322 ACTION("Definition ignored\n");
1329 SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1332 ExprResult tmp, name;
1334 if ((arrayNdx == NULL) && (warningLevel > 0))
1336 WARN("You must specify an index when specifying a group name\n");
1337 ACTION("Group name definition without array subscript ignored\n");
1340 if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp))
1342 ERROR("Illegal index in group name definition\n");
1343 ACTION("Definition with non-integer array index ignored\n");
1346 if (!ExprResolveString(keymap->context, value, &name))
1348 ERROR("Group name must be a string\n");
1349 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1352 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1353 xkb_atom_intern(keymap->context, name.str);
1360 HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info)
1362 ExprResult elem, field, tmp;
1366 if (ExprResolveLhs(keymap, stmt->name, &elem, &field, &arrayNdx) == 0)
1367 return 0; /* internal error, already reported */
1368 if (elem.str && (strcasecmp(elem.str, "key") == 0))
1370 ret = SetSymbolsField(&info->dflt, keymap, field.str, arrayNdx,
1373 else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) ||
1374 (strcasecmp(field.str, "groupname") ==
1377 ret = SetGroupName(info, keymap, arrayNdx, stmt->value);
1379 else if ((elem.str == NULL)
1380 && ((strcasecmp(field.str, "groupswrap") == 0) ||
1381 (strcasecmp(field.str, "wrapgroups") == 0)))
1383 if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp))
1385 ERROR("Illegal setting for global groupsWrap\n");
1386 ACTION("Non-boolean value ignored\n");
1391 info->groupInfo = XkbWrapIntoRange;
1393 info->groupInfo = XkbClampIntoRange;
1397 else if ((elem.str == NULL)
1398 && ((strcasecmp(field.str, "groupsclamp") == 0) ||
1399 (strcasecmp(field.str, "clampgroups") == 0)))
1401 if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp))
1403 ERROR("Illegal setting for global groupsClamp\n");
1404 ACTION("Non-boolean value ignored\n");
1409 info->groupInfo = XkbClampIntoRange;
1411 info->groupInfo = XkbWrapIntoRange;
1415 else if ((elem.str == NULL)
1416 && ((strcasecmp(field.str, "groupsredirect") == 0) ||
1417 (strcasecmp(field.str, "redirectgroups") == 0)))
1419 if (!ExprResolveGroup(keymap->context, stmt->value, &tmp))
1421 ERROR("Illegal group index for global groupsRedirect\n");
1422 ACTION("Definition with non-integer group ignored\n");
1426 info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1431 else if ((elem.str == NULL) && (strcasecmp(field.str, "allownone") == 0))
1433 ERROR("Radio groups not supported\n");
1434 ACTION("Ignoring \"allow none\" specification\n");
1438 ret = SetActionField(keymap, elem.str, field.str, arrayNdx,
1439 stmt->value, &info->action);
1448 HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key,
1452 ExprResult tmp, field;
1455 for (; def != NULL; def = (VarDef *) def->common.next)
1457 if ((def->name) && (def->name->type == ExprFieldRef))
1459 ok = HandleSymbolsVar(def, keymap, info);
1464 if (def->name == NULL)
1466 if ((def->value == NULL)
1467 || (def->value->op == ExprKeysymList))
1468 field.str = strdup("symbols");
1470 field.str = strdup("actions");
1475 ok = ExprResolveLhs(keymap, def->name, &tmp, &field,
1479 ok = SetSymbolsField(key, keymap, field.str, arrayNdx,
1488 SetExplicitGroup(SymbolsInfo *info, KeyInfo *key)
1490 unsigned group = info->explicit_group;
1495 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1498 WARN("For the map %s an explicit group specified\n", info->name);
1499 WARN("but key %s has more than one group defined\n",
1500 longText(key->name));
1501 ACTION("All groups except first one will be ignored\n");
1502 for (i = 1; i < XkbNumKbdGroups; i++)
1504 key->numLevels[i] = 0;
1506 key->syms[i] = NULL;
1508 key->acts[i] = NULL;
1512 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1514 key->numLevels[group] = key->numLevels[0];
1515 key->numLevels[0] = 0;
1516 key->syms[group] = key->syms[0];
1517 key->syms[0] = NULL;
1518 key->sizeSyms[group] = key->sizeSyms[0];
1519 key->sizeSyms[0] = 0;
1520 key->symsMapIndex[group] = key->symsMapIndex[0];
1521 key->symsMapIndex[0] = NULL;
1522 key->symsMapNumEntries[group] = key->symsMapNumEntries[0];
1523 key->symsMapNumEntries[0] = NULL;
1524 key->acts[group] = key->acts[0];
1525 key->acts[0] = NULL;
1526 key->types[group] = key->types[0];
1532 HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap,
1538 CopyKeyInfo(&info->dflt, &key, false);
1539 key.defs.merge = stmt->merge;
1540 key.name = KeyNameToLong(stmt->keyName);
1541 if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info))
1547 if (!SetExplicitGroup(info, &key))
1553 if (!AddKeySymbols(info, &key, keymap))
1562 HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info)
1569 if (!LookupModIndex(keymap->context, NULL, def->modifier, TypeInt, &rtrn))
1571 ERROR("Illegal modifier map definition\n");
1572 ACTION("Ignoring map for non-modifier \"%s\"\n",
1573 xkb_atom_text(keymap->context, def->modifier));
1577 tmp.modifier = rtrn.uval;
1578 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1580 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1582 tmp.haveSymbol = false;
1583 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1585 else if (ExprResolveKeySym(keymap->context, key, &rtrn))
1587 tmp.haveSymbol = true;
1588 tmp.u.keySym = rtrn.uval;
1592 ERROR("Modmap entries may contain only key names or keysyms\n");
1593 ACTION("Illegal definition for %s modifier ignored\n",
1594 XkbcModIndexText(tmp.modifier));
1598 ok = AddModMapEntry(info, &tmp) && ok;
1604 HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
1605 unsigned merge, SymbolsInfo *info)
1610 info->name = uDupString(file->name);
1614 switch (stmt->stmtType)
1617 if (!HandleIncludeSymbols((IncludeStmt *) stmt, keymap, info,
1621 case StmtSymbolsDef:
1622 if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info))
1626 if (!HandleSymbolsVar((VarDef *) stmt, keymap, info))
1630 if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
1634 ERROR("Interpretation files may not include other types\n");
1635 ACTION("Ignoring definition of symbol interpretation\n");
1638 case StmtKeycodeDef:
1639 ERROR("Interpretation files may not include other types\n");
1640 ACTION("Ignoring definition of key name\n");
1644 if (!HandleModMapDef((ModMapDef *) stmt, keymap, info))
1648 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1653 if (info->errorCount > 10)
1656 ERROR("Too many errors\n");
1658 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1665 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
1666 xkb_keycode_t *kc_rtrn)
1669 unsigned int group, level;
1671 for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
1673 for (group = 0; group < XkbKeyNumGroups(keymap, key); group++)
1675 for (level = 0; level < XkbKeyGroupWidth(keymap, key, group);
1678 if (XkbKeyNumSyms(keymap, key, group, level) != 1 ||
1679 (XkbKeySymEntry(keymap, key, group, level))[0] != sym)
1691 * Find the given name in the keymap->map->types and return its index.
1693 * @param atom The atom to search for.
1694 * @param type_rtrn Set to the index of the name if found.
1696 * @return true if found, false otherwise.
1699 FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
1702 const char *name = xkb_atom_text(keymap->context, atom);
1704 if (keymap && keymap->map && keymap->map->types)
1706 for (n = 0; n < keymap->map->num_types; n++)
1708 if (strcmp(keymap->map->types[n].name, name) == 0)
1719 * Assign a type to the given sym and return the Atom for the type assigned.
1722 * - ONE_LEVEL for width 0/1
1723 * - ALPHABETIC for 2 shift levels, with lower/upercase
1724 * - KEYPAD for keypad keys.
1725 * - TWO_LEVEL for other 2 shift level keys.
1726 * and the same for four level keys.
1728 * @param width Number of sysms in syms.
1729 * @param syms The keysyms for the given key (must be size width).
1730 * @param typeNameRtrn Set to the Atom of the type name.
1732 * @returns true if a type could be found, false otherwise.
1735 FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms,
1736 xkb_atom_t *typeNameRtrn, bool *autoType)
1739 if ((width == 1) || (width == 0))
1741 *typeNameRtrn = xkb_atom_intern(keymap->context, "ONE_LEVEL");
1744 else if (width == 2)
1746 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1748 *typeNameRtrn = xkb_atom_intern(keymap->context, "ALPHABETIC");
1750 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1752 *typeNameRtrn = xkb_atom_intern(keymap->context, "KEYPAD");
1757 *typeNameRtrn = xkb_atom_intern(keymap->context, "TWO_LEVEL");
1761 else if (width <= 4)
1763 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1764 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1766 xkb_atom_intern(keymap->context, "FOUR_LEVEL_ALPHABETIC");
1768 *typeNameRtrn = xkb_atom_intern(keymap->context,
1769 "FOUR_LEVEL_SEMIALPHABETIC");
1771 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1772 *typeNameRtrn = xkb_atom_intern(keymap->context, "FOUR_LEVEL_KEYPAD");
1774 *typeNameRtrn = xkb_atom_intern(keymap->context, "FOUR_LEVEL");
1775 /* XXX: why not set autoType here? */
1777 return ((width >= 0) && (width <= 4));
1781 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1782 * groups, and reduce to one group if all groups are identical anyway.
1785 PrepareKeyDef(KeyInfo * key)
1787 int i, j, width, defined, lastGroup;
1790 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1791 /* get highest group number */
1792 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1794 if (defined & (1 << i))
1802 /* If there are empty groups between non-empty ones fill them with data */
1803 /* from the first group. */
1804 /* We can make a wrong assumption here. But leaving gaps is worse. */
1805 for (i = lastGroup; i > 0; i--)
1807 if (defined & (1 << i))
1809 width = key->numLevels[0];
1810 if (key->typesDefined & 1)
1812 for (j = 0; j < width; j++)
1814 key->types[i] = key->types[0];
1816 key->typesDefined |= 1 << i;
1818 if ((key->actsDefined & 1) && key->acts[0])
1820 key->acts[i] = uTypedCalloc(width, union xkb_action);
1821 if (key->acts[i] == NULL)
1823 memcpy(key->acts[i], key->acts[0],
1824 width * sizeof(union xkb_action));
1825 key->actsDefined |= 1 << i;
1827 if ((key->symsDefined & 1) && key->sizeSyms[0])
1829 key->syms[i] = uTypedCalloc(key->sizeSyms[0], xkb_keysym_t);
1830 if (key->syms[i] == NULL)
1832 memcpy(key->syms[i], key->syms[0],
1833 key->sizeSyms[0] * sizeof(xkb_keysym_t));
1834 key->symsMapIndex[i] = uTypedCalloc(width, int);
1835 if (!key->symsMapIndex[i])
1838 key->syms[i] = NULL;
1841 memcpy(key->symsMapIndex[i], key->symsMapIndex[0],
1842 width * sizeof(int));
1843 key->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
1844 if (!key->symsMapNumEntries[i])
1847 key->syms[i] = NULL;
1848 free(key->symsMapIndex[i]);
1849 key->symsMapIndex[i] = NULL;
1852 memcpy(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1853 width * sizeof(int));
1854 key->sizeSyms[i] = key->sizeSyms[0];
1855 key->symsDefined |= 1 << i;
1859 key->numLevels[i] = key->numLevels[0];
1862 /* If all groups are completely identical remove them all */
1863 /* exept the first one. */
1865 for (i = lastGroup; i > 0; i--)
1867 if ((key->numLevels[i] != key->numLevels[0]) ||
1868 (key->types[i] != key->types[0]))
1873 if ((key->syms[i] != key->syms[0]) &&
1874 (key->syms[i] == NULL || key->syms[0] == NULL ||
1875 key->sizeSyms[i] != key->sizeSyms[0] ||
1876 memcmp(key->syms[i], key->syms[0],
1877 sizeof(xkb_keysym_t) * key->sizeSyms[0])))
1882 if ((key->symsMapIndex[i] != key->symsMapIndex[i]) &&
1883 (key->symsMapIndex[i] == NULL || key->symsMapIndex[0] == NULL ||
1884 memcmp(key->symsMapIndex[i], key->symsMapIndex[0],
1885 key->numLevels[0] * sizeof(int))))
1890 if ((key->symsMapNumEntries[i] != key->symsMapNumEntries[i]) &&
1891 (key->symsMapNumEntries[i] == NULL ||
1892 key->symsMapNumEntries[0] == NULL ||
1893 memcmp(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1894 key->numLevels[0] * sizeof(int))))
1899 if ((key->acts[i] != key->acts[0]) &&
1900 (key->acts[i] == NULL || key->acts[0] == NULL ||
1901 memcmp(key->acts[i], key->acts[0],
1902 sizeof(union xkb_action) * key->numLevels[0])))
1910 for (i = lastGroup; i > 0; i--)
1912 key->numLevels[i] = 0;
1914 key->syms[i] = NULL;
1915 key->sizeSyms[i] = 0;
1916 free(key->symsMapIndex[i]);
1917 key->symsMapIndex[i] = NULL;
1918 free(key->symsMapNumEntries[i]);
1919 key->symsMapNumEntries[i] = NULL;
1921 key->acts[i] = NULL;
1924 key->symsDefined &= 1;
1925 key->actsDefined &= 1;
1926 key->typesDefined &= 1;
1931 * Copy the KeyInfo into the keyboard description.
1933 * This function recurses.
1936 CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
1940 unsigned int sizeSyms = 0;
1941 unsigned width, tmp, nGroups;
1942 struct xkb_key_type * type;
1943 bool haveActions, autoType, useAlias;
1944 unsigned types[XkbNumKbdGroups];
1945 union xkb_action *outActs;
1946 unsigned int symIndex = 0;
1948 useAlias = (start_from == 0);
1950 /* get the keycode for the key. */
1951 if (!FindNamedKey(keymap, key->name, &kc, useAlias,
1952 CreateKeyNames(keymap), start_from))
1954 if ((start_from == 0) && (warningLevel >= 5))
1956 WARN("Key %s not found in keycodes\n", longText(key->name));
1957 ACTION("Symbols ignored\n");
1962 haveActions = false;
1963 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1965 if (((i + 1) > nGroups)
1966 && (((key->symsDefined | key->actsDefined) & (1 << i))
1967 || (key->typesDefined) & (1 << i)))
1972 /* Assign the type to the key, if it is missing. */
1973 if (key->types[i] == XKB_ATOM_NONE)
1975 if (key->dfltType != XKB_ATOM_NONE)
1976 key->types[i] = key->dfltType;
1977 else if (FindAutomaticType(keymap, key->numLevels[i], key->syms[i],
1978 &key->types[i], &autoType))
1983 if (warningLevel >= 5)
1985 WARN("No automatic type for %d symbols\n",
1986 (unsigned int) key->numLevels[i]);
1987 ACTION("Using %s for the %s key (keycode %d)\n",
1988 xkb_atom_text(keymap->context, key->types[i]),
1989 longText(key->name), kc);
1993 if (FindNamedType(keymap, key->types[i], &types[i]))
1995 if (!autoType || key->numLevels[i] > 2)
1996 keymap->server->explicit[kc] |= (1 << i);
2000 if (warningLevel >= 3)
2002 WARN("Type \"%s\" is not defined\n",
2003 xkb_atom_text(keymap->context, key->types[i]));
2004 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
2005 longText(key->name), kc);
2007 types[i] = XkbTwoLevelIndex;
2009 /* if the type specifies fewer levels than the key has, shrink the key */
2010 type = &keymap->map->types[types[i]];
2011 if (type->num_levels < key->numLevels[i])
2013 if (warningLevel > 0)
2015 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
2016 type->name, type->num_levels,
2017 xkb_atom_text(keymap->context, key->name), key->numLevels[i]);
2018 ACTION("Ignoring extra symbols\n");
2020 key->numLevels[i] = type->num_levels;
2022 if (key->numLevels[i] > width)
2023 width = key->numLevels[i];
2024 if (type->num_levels > width)
2025 width = type->num_levels;
2026 sizeSyms += key->sizeSyms[i];
2029 if (!XkbcResizeKeySyms(keymap, kc, sizeSyms))
2031 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
2032 longText(key->name), kc);
2037 outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups);
2038 if (outActs == NULL)
2040 WSGO("Could not enlarge actions for %s (key %d)\n",
2041 longText(key->name), kc);
2044 keymap->server->explicit[kc] |= XkbExplicitInterpretMask;
2048 if (key->defs.defined & _Key_GroupInfo)
2051 i = keymap->map->key_sym_map[kc].group_info;
2053 keymap->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
2054 keymap->map->key_sym_map[kc].width = width;
2055 keymap->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width,
2057 keymap->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width,
2059 for (i = 0; i < nGroups; i++)
2061 /* assign kt_index[i] to the index of the type in map->types.
2062 * kt_index[i] may have been set by a previous run (if we have two
2063 * layouts specified). Let's not overwrite it with the ONE_LEVEL
2064 * default group if we dont even have keys for this group anyway.
2066 * FIXME: There should be a better fix for this.
2068 if (key->numLevels[i])
2069 keymap->map->key_sym_map[kc].kt_index[i] = types[i];
2070 if (key->sizeSyms[i] != 0)
2072 /* fill key to "width" symbols*/
2073 for (tmp = 0; tmp < width; tmp++)
2075 if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp])
2077 memcpy(&keymap->map->key_sym_map[kc].syms[symIndex],
2078 &key->syms[i][key->symsMapIndex[i][tmp]],
2079 key->symsMapNumEntries[i][tmp] *
2080 sizeof(xkb_keysym_t));
2081 keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] =
2083 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] =
2084 key->symsMapNumEntries[i][tmp];
2086 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp];
2090 keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1;
2091 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0;
2093 if ((outActs != NULL) && (key->acts[i] != NULL))
2095 if (tmp < key->numLevels[i])
2096 outActs[tmp] = key->acts[i][tmp];
2098 outActs[tmp].type = XkbSA_NoAction;
2103 switch (key->behavior.type & XkbKB_OpMask)
2108 keymap->server->behaviors[kc] = key->behavior;
2109 keymap->server->explicit[kc] |= XkbExplicitBehaviorMask;
2112 if (key->defs.defined & _Key_VModMap)
2114 keymap->server->vmodmap[kc] = key->vmodmap;
2115 keymap->server->explicit[kc] |= XkbExplicitVModMapMask;
2117 if (key->repeat != RepeatUndefined)
2119 if (key->repeat == RepeatYes)
2120 keymap->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
2122 keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
2123 keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
2126 if (nGroups > keymap->ctrls->num_groups)
2127 keymap->ctrls->num_groups = nGroups;
2129 /* do the same thing for the next key */
2130 CopySymbolsDef(keymap, key, kc + 1);
2135 CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
2139 if (!entry->haveSymbol &&
2140 !FindNamedKey(keymap, entry->u.keyName, &kc, true,
2141 CreateKeyNames(keymap), 0))
2143 if (warningLevel >= 5)
2145 WARN("Key %s not found in keycodes\n",
2146 longText(entry->u.keyName));
2147 ACTION("Modifier map entry for %s not updated\n",
2148 XkbcModIndexText(entry->modifier));
2152 else if (entry->haveSymbol &&
2153 !FindKeyForSymbol(keymap, entry->u.keySym, &kc))
2155 if (warningLevel > 5)
2157 WARN("Key \"%s\" not found in symbol map\n",
2158 XkbcKeysymText(entry->u.keySym));
2159 ACTION("Modifier map entry for %s not updated\n",
2160 XkbcModIndexText(entry->modifier));
2164 keymap->map->modmap[kc] |= (1 << entry->modifier);
2169 * Handle the xkb_symbols section of an xkb file.
2171 * @param file The parsed xkb_symbols section of the xkb file.
2172 * @param keymap Handle to the keyboard description to store the symbols in.
2173 * @param merge Merge strategy (e.g. MergeOverride).
2176 CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
2182 InitSymbolsInfo(&info, keymap);
2183 info.dflt.defs.fileID = file->id;
2184 info.dflt.defs.merge = merge;
2186 HandleSymbolsFile(file, keymap, merge, &info);
2188 if (info.nKeys == 0)
2191 if (info.errorCount != 0)
2194 /* alloc memory in the xkb struct */
2195 if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) {
2196 WSGO("Can not allocate names in CompileSymbols\n");
2197 ACTION("Symbols not added\n");
2201 if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
2203 WSGO("Could not allocate client map in CompileSymbols\n");
2204 ACTION("Symbols not added\n");
2208 if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
2209 WSGO("Could not allocate server map in CompileSymbols\n");
2210 ACTION("Symbols not added\n");
2214 if (XkbcAllocControls(keymap) != Success) {
2215 WSGO("Could not allocate controls in CompileSymbols\n");
2216 ACTION("Symbols not added\n");
2220 /* now copy info into xkb. */
2221 ApplyAliases(keymap, &info.aliases);
2223 for (i = 0; i < XkbNumKbdGroups; i++) {
2224 if (info.groupNames[i] != XKB_ATOM_NONE) {
2225 free(UNCONSTIFY(keymap->names->groups[i]));
2226 keymap->names->groups[i] = xkb_atom_strdup(keymap->context,
2227 info.groupNames[i]);
2232 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2236 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2237 if (!CopySymbolsDef(keymap, key, 0))
2240 if (warningLevel > 3) {
2241 for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
2242 if (keymap->names->keys[i].name[0] == '\0')
2245 if (XkbKeyNumGroups(keymap, i) < 1) {
2247 memcpy(buf, keymap->names->keys[i].name, 4);
2249 WARN("No symbols defined for <%s> (keycode %d)\n", buf, i);
2255 ModMapEntry *mm, *next;
2256 for (mm = info.modMap; mm != NULL; mm = next) {
2257 if (!CopyModMapDef(keymap, mm))
2259 next = (ModMapEntry *) mm->defs.next;
2263 FreeSymbolsInfo(&info);
2267 FreeSymbolsInfo(&info);