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 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
260 #define SYMBOLS_CHUNK 20
261 typedef struct _SymbolsInfo
263 char *name; /* e.g. pc+us+inet(evdev) */
267 unsigned explicit_group;
275 xkb_atom_t groupNames[XkbNumKbdGroups];
282 InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap)
287 info->explicit_group = 0;
288 info->errorCount = 0;
290 info->merge = MergeOverride;
292 info->szKeys = SYMBOLS_INIT_SIZE;
294 info->keys = uTypedCalloc(SYMBOLS_INIT_SIZE, KeyInfo);
296 for (i = 0; i < XkbNumKbdGroups; i++)
297 info->groupNames[i] = XKB_ATOM_NONE;
298 InitKeyInfo(&info->dflt);
299 InitVModInfo(&info->vmods, keymap);
301 info->aliases = NULL;
305 FreeSymbolsInfo(SymbolsInfo * info)
312 for (i = 0; i < info->nKeys; i++)
313 FreeKeyInfo(&info->keys[i]);
317 ClearCommonInfo(&info->modMap->defs);
319 ClearAliases(&info->aliases);
320 memset(info, 0, sizeof(SymbolsInfo));
324 ResizeKeyGroup(KeyInfo * key, unsigned int group, unsigned int numLevels,
325 unsigned sizeSyms, bool forceActions)
329 if (key->syms[group] == NULL || key->sizeSyms[group] < sizeSyms)
331 key->syms[group] = uTypedRecalloc(key->syms[group],
332 key->sizeSyms[group],
335 if (!key->syms[group]) {
336 key->sizeSyms[group] = 0;
339 key->sizeSyms[group] = sizeSyms;
341 if (!key->symsMapIndex[group] || key->numLevels[group] < numLevels)
343 key->symsMapIndex[group] = uTypedRealloc(key->symsMapIndex[group],
346 if (!key->symsMapIndex[group])
348 for (i = key->numLevels[group]; i < numLevels; i++)
349 key->symsMapIndex[group][i] = -1;
351 if (!key->symsMapNumEntries[group] || key->numLevels[group] < numLevels)
353 key->symsMapNumEntries[group] =
354 uTypedRecalloc(key->symsMapNumEntries[group],
355 key->numLevels[group],
358 if (!key->symsMapNumEntries[group])
362 (key->numLevels[group] < numLevels || (key->acts[group] == NULL))) ||
363 (key->numLevels[group] < numLevels && (key->acts[group] != NULL)))
365 key->acts[group] = uTypedRecalloc(key->acts[group],
366 key->numLevels[group],
369 if (!key->acts[group])
372 if (key->numLevels[group] < numLevels)
373 key->numLevels[group] = numLevels;
378 MergeKeyGroups(SymbolsInfo * info,
379 KeyInfo * into, KeyInfo * from, unsigned group)
381 xkb_keysym_t *resultSyms = NULL;
382 union xkb_action *resultActs;
383 unsigned int resultWidth;
384 unsigned int resultSize = 0;
387 bool report, clobber;
389 clobber = (from->defs.merge != MergeAugment);
390 report = (warningLevel > 9) ||
391 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
392 if (into->numLevels[group] >= from->numLevels[group])
394 resultActs = into->acts[group];
395 resultWidth = into->numLevels[group];
399 resultActs = from->acts[group];
400 resultWidth = from->numLevels[group];
401 into->symsMapIndex[group] = uTypedRealloc(into->symsMapIndex[group],
402 from->numLevels[group],
404 into->symsMapNumEntries[group] =
405 uTypedRecalloc(into->symsMapNumEntries[group],
406 into->numLevels[group],
407 from->numLevels[group],
409 if (!into->symsMapIndex[group] || !into->symsMapNumEntries[group])
411 WSGO("Could not allocate level indices for key info merge\n");
412 ACTION("Group %d of key %s not merged\n", group,
413 longText(into->name));
417 for (i = into->numLevels[group]; i < from->numLevels[group]; i++)
418 into->symsMapIndex[group][i] = -1;
421 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
423 resultActs = uTypedCalloc(resultWidth, union xkb_action);
426 WSGO("Could not allocate actions for group merge\n");
427 ACTION("Group %d of key %s not merged\n", group,
428 longText(into->name));
431 for (i = 0; i < resultWidth; i++)
433 union xkb_action *fromAct, *toAct;
434 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
435 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
436 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
439 resultActs[i] = *toAct;
441 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
442 && (fromAct != NULL))
444 resultActs[i] = *fromAct;
448 union xkb_action *use, *ignore;
462 ("Multiple actions for level %d/group %d on key %s\n",
463 i + 1, group + 1, longText(into->name));
464 ACTION("Using %s, ignoring %s\n",
465 XkbcActionTypeText(use->type),
466 XkbcActionTypeText(ignore->type));
469 resultActs[i] = *use;
474 for (i = 0; i < resultWidth; i++)
476 unsigned int fromSize = 0;
479 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
480 fromSize = from->symsMapNumEntries[group][i];
481 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
482 toSize = into->symsMapNumEntries[group][i];
484 if (fromSize == 0 || fromSize == toSize || clobber)
488 else if (toSize == 0)
490 resultSize += fromSize;
497 resultSyms = uTypedCalloc(resultSize, xkb_keysym_t);
500 WSGO("Could not allocate symbols for group merge\n");
501 ACTION("Group %d of key %s not merged\n", group, longText(into->name));
505 for (i = 0; i < resultWidth; i++)
507 enum { NONE, FROM, TO } use;
508 unsigned int fromSize = 0;
509 unsigned int toSize = 0;
511 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
512 fromSize = from->symsMapNumEntries[group][i];
513 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
514 toSize = into->symsMapNumEntries[group][i];
516 if (!fromSize && !toSize)
518 into->symsMapIndex[group][i] = -1;
519 into->symsMapNumEntries[group][i] = 0;
523 if ((fromSize && !toSize) || 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][from->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)
714 unsigned long real_name;
716 for (i = 0; i < info->nKeys; i++)
718 if (info->keys[i].name == key->name)
719 return MergeKeys(info, keymap, &info->keys[i], key);
721 if (FindKeyNameForAlias(keymap, key->name, &real_name))
723 for (i = 0; i < info->nKeys; i++)
725 if (info->keys[i].name == real_name)
726 return MergeKeys(info, keymap, &info->keys[i], key);
729 if (info->nKeys >= info->szKeys)
731 info->szKeys += SYMBOLS_CHUNK;
733 uTypedRecalloc(info->keys, info->nKeys, info->szKeys, KeyInfo);
736 WSGO("Could not allocate key symbols descriptions\n");
737 ACTION("Some key symbols definitions may be lost\n");
741 return CopyKeyInfo(key, &info->keys[info->nKeys++], true);
745 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
750 clobber = (new->defs.merge != MergeAugment);
751 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
753 if (new->haveSymbol && mm->haveSymbol
754 && (new->u.keySym == mm->u.keySym))
756 unsigned use, ignore;
757 if (mm->modifier != new->modifier)
762 ignore = mm->modifier;
767 ignore = new->modifier;
770 ("%s added to symbol map for multiple modifiers\n",
771 XkbcKeysymText(new->u.keySym));
772 ACTION("Using %s, ignoring %s.\n",
773 XkbcModIndexText(use),
774 XkbcModIndexText(ignore));
779 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
780 (new->u.keyName == mm->u.keyName))
782 unsigned use, ignore;
783 if (mm->modifier != new->modifier)
788 ignore = mm->modifier;
793 ignore = new->modifier;
795 ERROR("Key %s added to map for multiple modifiers\n",
796 longText(new->u.keyName));
797 ACTION("Using %s, ignoring %s.\n",
798 XkbcModIndexText(use),
799 XkbcModIndexText(ignore));
805 mm = uTypedAlloc(ModMapEntry);
808 WSGO("Could not allocate modifier map entry\n");
809 ACTION("Modifier map for %s will be incomplete\n",
810 XkbcModIndexText(new->modifier));
814 mm->defs.next = &info->modMap->defs;
819 /***====================================================================***/
822 MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
823 unsigned merge, struct xkb_keymap *keymap)
828 if (from->errorCount > 0)
830 into->errorCount += from->errorCount;
833 if (into->name == NULL)
835 into->name = from->name;
838 for (i = 0; i < XkbNumKbdGroups; i++)
840 if (from->groupNames[i] != XKB_ATOM_NONE)
842 if ((merge != MergeAugment) ||
843 (into->groupNames[i] == XKB_ATOM_NONE))
844 into->groupNames[i] = from->groupNames[i];
847 for (i = 0, key = from->keys; i < from->nKeys; i++, key++)
849 if (merge != MergeDefault)
850 key->defs.merge = merge;
851 if (!AddKeySymbols(into, key, keymap))
854 if (from->modMap != NULL)
856 ModMapEntry *mm, *next;
857 for (mm = from->modMap; mm != NULL; mm = next)
859 if (merge != MergeDefault)
860 mm->defs.merge = merge;
861 if (!AddModMapEntry(into, mm))
863 next = (ModMapEntry *) mm->defs.next;
868 if (!MergeAliases(&into->aliases, &from->aliases, merge))
872 typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap,
873 unsigned merge, SymbolsInfo *included);
876 HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap,
877 SymbolsInfo *info, FileHandler hndlr)
881 SymbolsInfo included;
885 if ((stmt->file == NULL) && (stmt->map == NULL))
889 memset(info, 0, sizeof(SymbolsInfo));
891 else if (ProcessIncludeFile(keymap->ctx, stmt, XkmSymbolsIndex, &rtrn,
894 InitSymbolsInfo(&included, keymap);
895 included.fileID = included.dflt.defs.fileID = rtrn->id;
896 included.merge = included.dflt.defs.merge = MergeOverride;
899 included.explicit_group = atoi(stmt->modifier) - 1;
903 included.explicit_group = info->explicit_group;
905 (*hndlr) (rtrn, keymap, MergeOverride, &included);
906 if (stmt->stmt != NULL)
909 included.name = stmt->stmt;
916 info->errorCount += 10;
919 if ((stmt->next != NULL) && (included.errorCount < 1))
923 SymbolsInfo next_incl;
925 for (next = stmt->next; next != NULL; next = next->next)
927 if ((next->file == NULL) && (next->map == NULL))
930 MergeIncludedSymbols(&included, info, next->merge, keymap);
931 FreeSymbolsInfo(info);
933 else if (ProcessIncludeFile(keymap->ctx, next, XkmSymbolsIndex,
936 InitSymbolsInfo(&next_incl, keymap);
937 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
938 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
941 next_incl.explicit_group = atoi(next->modifier) - 1;
945 next_incl.explicit_group = info->explicit_group;
947 (*hndlr) (rtrn, keymap, MergeOverride, &next_incl);
948 MergeIncludedSymbols(&included, &next_incl, op, keymap);
949 FreeSymbolsInfo(&next_incl);
954 info->errorCount += 10;
955 FreeSymbolsInfo(&included);
962 info->errorCount += included.errorCount;
968 MergeIncludedSymbols(info, &included, newMerge, keymap);
969 FreeSymbolsInfo(&included);
971 return (info->errorCount == 0);
978 GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap,
979 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
989 if (arrayNdx == NULL)
994 defined = key->symsDefined;
996 defined = key->actsDefined;
998 for (i = 0; i < XkbNumKbdGroups; i++)
1000 if ((defined & (1 << i)) == 0)
1006 ERROR("Too many groups of %s for key %s (max %d)\n", name,
1007 longText(key->name), XkbNumKbdGroups + 1);
1008 ACTION("Ignoring %s defined for extra groups\n", name);
1011 if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp))
1013 ERROR("Illegal group index for %s of key %s\n", name,
1014 longText(key->name));
1015 ACTION("Definition with non-integer array index ignored\n");
1018 *ndx_rtrn = tmp.uval - 1;
1023 AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap,
1024 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1026 unsigned ndx, nSyms, nLevels;
1030 if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx))
1034 key->symsDefined |= (1 << ndx);
1037 if (value->op != ExprKeysymList)
1039 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
1040 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
1041 longText(key->name));
1044 if (key->sizeSyms[ndx] != 0)
1046 ERROR("Symbols for key %s, group %d already defined\n",
1047 longText(key->name), ndx + 1);
1048 ACTION("Ignoring duplicate definition\n");
1051 nSyms = value->value.list.nSyms;
1052 nLevels = value->value.list.nLevels;
1053 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
1054 (!ResizeKeyGroup(key, ndx, nLevels, nSyms, false)))
1056 WSGO("Could not resize group %d of key %s to contain %d levels\n",
1057 ndx + 1, longText(key->name), nSyms);
1058 ACTION("Symbols lost\n");
1061 key->symsDefined |= (1 << ndx);
1062 for (i = 0; i < nLevels; i++) {
1063 key->symsMapIndex[ndx][i] = value->value.list.symsMapIndex[i];
1064 key->symsMapNumEntries[ndx][i] = value->value.list.symsNumEntries[i];
1065 for (j = 0; j < key->symsMapNumEntries[ndx][i]; j++) {
1066 if (key->symsMapIndex[ndx][i] + j >= nSyms)
1068 if (!LookupKeysym(value->value.list.syms[value->value.list.symsMapIndex[i] + j],
1069 &key->syms[ndx][key->symsMapIndex[ndx][i] + j])) {
1070 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
1071 value->value.list.syms[i], longText(key->name), ndx + 1,
1072 xkb_atom_text(keymap->ctx, info->groupNames[ndx]), nSyms);
1074 key->syms[ndx][key->symsMapIndex[ndx][i] + j] = XKB_KEY_NoSymbol;
1075 key->symsMapIndex[ndx][i] = -1;
1076 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,
1619 case StmtSymbolsDef:
1620 if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info))
1624 if (!HandleSymbolsVar((VarDef *) stmt, keymap, info))
1628 if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
1632 ERROR("Interpretation files may not include other types\n");
1633 ACTION("Ignoring definition of symbol interpretation\n");
1636 case StmtKeycodeDef:
1637 ERROR("Interpretation files may not include other types\n");
1638 ACTION("Ignoring definition of key name\n");
1642 if (!HandleModMapDef((ModMapDef *) stmt, keymap, info))
1646 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1651 if (info->errorCount > 10)
1654 ERROR("Too many errors\n");
1656 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1663 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
1664 xkb_keycode_t *kc_rtrn)
1667 unsigned int group, level;
1669 for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
1671 for (group = 0; group < XkbKeyNumGroups(keymap, key); group++)
1673 for (level = 0; level < XkbKeyGroupWidth(keymap, key, group);
1676 if (XkbKeyNumSyms(keymap, key, group, level) != 1 ||
1677 (XkbKeySymEntry(keymap, key, group, level))[0] != sym)
1689 * Find the given name in the keymap->map->types and return its index.
1691 * @param atom The atom to search for.
1692 * @param type_rtrn Set to the index of the name if found.
1694 * @return true if found, false otherwise.
1697 FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
1700 const char *name = xkb_atom_text(keymap->ctx, atom);
1702 if (keymap && keymap->map && keymap->map->types)
1704 for (n = 0; n < keymap->map->num_types; n++)
1706 if (strcmp(keymap->map->types[n].name, name) == 0)
1717 * Assign a type to the given sym and return the Atom for the type assigned.
1720 * - ONE_LEVEL for width 0/1
1721 * - ALPHABETIC for 2 shift levels, with lower/upercase
1722 * - KEYPAD for keypad keys.
1723 * - TWO_LEVEL for other 2 shift level keys.
1724 * and the same for four level keys.
1726 * @param width Number of sysms in syms.
1727 * @param syms The keysyms for the given key (must be size width).
1728 * @param typeNameRtrn Set to the Atom of the type name.
1730 * @returns true if a type could be found, false otherwise.
1733 FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms,
1734 xkb_atom_t *typeNameRtrn, bool *autoType)
1737 if ((width == 1) || (width == 0))
1739 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ONE_LEVEL");
1742 else if (width == 2)
1744 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1746 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ALPHABETIC");
1748 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1750 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "KEYPAD");
1755 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "TWO_LEVEL");
1759 else if (width <= 4)
1761 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1762 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1764 xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_ALPHABETIC");
1766 *typeNameRtrn = xkb_atom_intern(keymap->ctx,
1767 "FOUR_LEVEL_SEMIALPHABETIC");
1769 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1770 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_KEYPAD");
1772 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL");
1773 /* XXX: why not set autoType here? */
1775 return ((width >= 0) && (width <= 4));
1779 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1780 * groups, and reduce to one group if all groups are identical anyway.
1783 PrepareKeyDef(KeyInfo * key)
1785 int i, j, width, defined, lastGroup;
1788 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1789 /* get highest group number */
1790 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1792 if (defined & (1 << i))
1800 /* If there are empty groups between non-empty ones fill them with data */
1801 /* from the first group. */
1802 /* We can make a wrong assumption here. But leaving gaps is worse. */
1803 for (i = lastGroup; i > 0; i--)
1805 if (defined & (1 << i))
1807 width = key->numLevels[0];
1808 if (key->typesDefined & 1)
1810 for (j = 0; j < width; j++)
1812 key->types[i] = key->types[0];
1814 key->typesDefined |= 1 << i;
1816 if ((key->actsDefined & 1) && key->acts[0])
1818 key->acts[i] = uTypedCalloc(width, union xkb_action);
1819 if (key->acts[i] == NULL)
1821 memcpy(key->acts[i], key->acts[0],
1822 width * sizeof(union xkb_action));
1823 key->actsDefined |= 1 << i;
1825 if ((key->symsDefined & 1) && key->sizeSyms[0])
1827 key->syms[i] = uTypedCalloc(key->sizeSyms[0], xkb_keysym_t);
1828 if (key->syms[i] == NULL)
1830 memcpy(key->syms[i], key->syms[0],
1831 key->sizeSyms[0] * sizeof(xkb_keysym_t));
1832 key->symsMapIndex[i] = uTypedCalloc(width, int);
1833 if (!key->symsMapIndex[i])
1836 key->syms[i] = NULL;
1839 memcpy(key->symsMapIndex[i], key->symsMapIndex[0],
1840 width * sizeof(int));
1841 key->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
1842 if (!key->symsMapNumEntries[i])
1845 key->syms[i] = NULL;
1846 free(key->symsMapIndex[i]);
1847 key->symsMapIndex[i] = NULL;
1850 memcpy(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1851 width * sizeof(int));
1852 key->sizeSyms[i] = key->sizeSyms[0];
1853 key->symsDefined |= 1 << i;
1857 key->numLevels[i] = key->numLevels[0];
1860 /* If all groups are completely identical remove them all */
1861 /* exept the first one. */
1863 for (i = lastGroup; i > 0; i--)
1865 if ((key->numLevels[i] != key->numLevels[0]) ||
1866 (key->types[i] != key->types[0]))
1871 if ((key->syms[i] != key->syms[0]) &&
1872 (key->syms[i] == NULL || key->syms[0] == NULL ||
1873 key->sizeSyms[i] != key->sizeSyms[0] ||
1874 memcmp(key->syms[i], key->syms[0],
1875 sizeof(xkb_keysym_t) * key->sizeSyms[0])))
1880 if ((key->symsMapIndex[i] != key->symsMapIndex[i]) &&
1881 (key->symsMapIndex[i] == NULL || key->symsMapIndex[0] == NULL ||
1882 memcmp(key->symsMapIndex[i], key->symsMapIndex[0],
1883 key->numLevels[0] * sizeof(int))))
1888 if ((key->symsMapNumEntries[i] != key->symsMapNumEntries[i]) &&
1889 (key->symsMapNumEntries[i] == NULL ||
1890 key->symsMapNumEntries[0] == NULL ||
1891 memcmp(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1892 key->numLevels[0] * sizeof(int))))
1897 if ((key->acts[i] != key->acts[0]) &&
1898 (key->acts[i] == NULL || key->acts[0] == NULL ||
1899 memcmp(key->acts[i], key->acts[0],
1900 sizeof(union xkb_action) * key->numLevels[0])))
1908 for (i = lastGroup; i > 0; i--)
1910 key->numLevels[i] = 0;
1912 key->syms[i] = NULL;
1913 key->sizeSyms[i] = 0;
1914 free(key->symsMapIndex[i]);
1915 key->symsMapIndex[i] = NULL;
1916 free(key->symsMapNumEntries[i]);
1917 key->symsMapNumEntries[i] = NULL;
1919 key->acts[i] = NULL;
1922 key->symsDefined &= 1;
1923 key->actsDefined &= 1;
1924 key->typesDefined &= 1;
1929 * Copy the KeyInfo into the keyboard description.
1931 * This function recurses.
1934 CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
1938 unsigned int sizeSyms = 0;
1939 unsigned width, tmp, nGroups;
1940 struct xkb_key_type * type;
1941 bool haveActions, autoType, useAlias;
1942 unsigned types[XkbNumKbdGroups];
1943 union xkb_action *outActs;
1944 unsigned int symIndex = 0;
1946 useAlias = (start_from == 0);
1948 /* get the keycode for the key. */
1949 if (!FindNamedKey(keymap, key->name, &kc, useAlias,
1950 CreateKeyNames(keymap), start_from))
1952 if ((start_from == 0) && (warningLevel >= 5))
1954 WARN("Key %s not found in keycodes\n", longText(key->name));
1955 ACTION("Symbols ignored\n");
1960 haveActions = false;
1961 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1963 if (((i + 1) > nGroups)
1964 && (((key->symsDefined | key->actsDefined) & (1 << i))
1965 || (key->typesDefined) & (1 << i)))
1970 /* Assign the type to the key, if it is missing. */
1971 if (key->types[i] == XKB_ATOM_NONE)
1973 if (key->dfltType != XKB_ATOM_NONE)
1974 key->types[i] = key->dfltType;
1975 else if (FindAutomaticType(keymap, key->numLevels[i], key->syms[i],
1976 &key->types[i], &autoType))
1981 if (warningLevel >= 5)
1983 WARN("No automatic type for %d symbols\n",
1984 (unsigned int) key->numLevels[i]);
1985 ACTION("Using %s for the %s key (keycode %d)\n",
1986 xkb_atom_text(keymap->ctx, key->types[i]),
1987 longText(key->name), kc);
1991 if (FindNamedType(keymap, key->types[i], &types[i]))
1993 if (!autoType || key->numLevels[i] > 2)
1994 keymap->server->explicit[kc] |= (1 << i);
1998 if (warningLevel >= 3)
2000 WARN("Type \"%s\" is not defined\n",
2001 xkb_atom_text(keymap->ctx, key->types[i]));
2002 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
2003 longText(key->name), kc);
2005 types[i] = XkbTwoLevelIndex;
2007 /* if the type specifies fewer levels than the key has, shrink the key */
2008 type = &keymap->map->types[types[i]];
2009 if (type->num_levels < key->numLevels[i])
2011 if (warningLevel > 0)
2013 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
2014 type->name, type->num_levels,
2015 xkb_atom_text(keymap->ctx, key->name), key->numLevels[i]);
2016 ACTION("Ignoring extra symbols\n");
2018 key->numLevels[i] = type->num_levels;
2020 if (key->numLevels[i] > width)
2021 width = key->numLevels[i];
2022 if (type->num_levels > width)
2023 width = type->num_levels;
2024 sizeSyms += key->sizeSyms[i];
2027 if (!XkbcResizeKeySyms(keymap, kc, sizeSyms))
2029 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
2030 longText(key->name), kc);
2035 outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups);
2036 if (outActs == NULL)
2038 WSGO("Could not enlarge actions for %s (key %d)\n",
2039 longText(key->name), kc);
2042 keymap->server->explicit[kc] |= XkbExplicitInterpretMask;
2046 if (key->defs.defined & _Key_GroupInfo)
2049 i = keymap->map->key_sym_map[kc].group_info;
2051 keymap->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
2052 keymap->map->key_sym_map[kc].width = width;
2053 keymap->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width,
2055 keymap->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width,
2057 for (i = 0; i < nGroups; i++)
2059 /* assign kt_index[i] to the index of the type in map->types.
2060 * kt_index[i] may have been set by a previous run (if we have two
2061 * layouts specified). Let's not overwrite it with the ONE_LEVEL
2062 * default group if we dont even have keys for this group anyway.
2064 * FIXME: There should be a better fix for this.
2066 if (key->numLevels[i])
2067 keymap->map->key_sym_map[kc].kt_index[i] = types[i];
2068 if (key->sizeSyms[i] != 0)
2070 /* fill key to "width" symbols*/
2071 for (tmp = 0; tmp < width; tmp++)
2073 if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp])
2075 memcpy(&keymap->map->key_sym_map[kc].syms[symIndex],
2076 &key->syms[i][key->symsMapIndex[i][tmp]],
2077 key->symsMapNumEntries[i][tmp] *
2078 sizeof(xkb_keysym_t));
2079 keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] =
2081 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] =
2082 key->symsMapNumEntries[i][tmp];
2084 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp];
2088 keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1;
2089 keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0;
2091 if ((outActs != NULL) && (key->acts[i] != NULL))
2093 if (tmp < key->numLevels[i])
2094 outActs[tmp] = key->acts[i][tmp];
2096 outActs[tmp].type = XkbSA_NoAction;
2101 switch (key->behavior.type & XkbKB_OpMask)
2106 keymap->server->behaviors[kc] = key->behavior;
2107 keymap->server->explicit[kc] |= XkbExplicitBehaviorMask;
2110 if (key->defs.defined & _Key_VModMap)
2112 keymap->server->vmodmap[kc] = key->vmodmap;
2113 keymap->server->explicit[kc] |= XkbExplicitVModMapMask;
2115 if (key->repeat != RepeatUndefined)
2117 if (key->repeat == RepeatYes)
2118 keymap->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
2120 keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
2121 keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
2124 if (nGroups > keymap->ctrls->num_groups)
2125 keymap->ctrls->num_groups = nGroups;
2127 /* do the same thing for the next key */
2128 CopySymbolsDef(keymap, key, kc + 1);
2133 CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
2137 if (!entry->haveSymbol &&
2138 !FindNamedKey(keymap, entry->u.keyName, &kc, true,
2139 CreateKeyNames(keymap), 0))
2141 if (warningLevel >= 5)
2143 WARN("Key %s not found in keycodes\n",
2144 longText(entry->u.keyName));
2145 ACTION("Modifier map entry for %s not updated\n",
2146 XkbcModIndexText(entry->modifier));
2150 else if (entry->haveSymbol &&
2151 !FindKeyForSymbol(keymap, entry->u.keySym, &kc))
2153 if (warningLevel > 5)
2155 WARN("Key \"%s\" not found in symbol map\n",
2156 XkbcKeysymText(entry->u.keySym));
2157 ACTION("Modifier map entry for %s not updated\n",
2158 XkbcModIndexText(entry->modifier));
2162 keymap->map->modmap[kc] |= (1 << entry->modifier);
2167 * Handle the xkb_symbols section of an xkb file.
2169 * @param file The parsed xkb_symbols section of the xkb file.
2170 * @param keymap Handle to the keyboard description to store the symbols in.
2171 * @param merge Merge strategy (e.g. MergeOverride).
2174 CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
2180 InitSymbolsInfo(&info, keymap);
2181 info.dflt.defs.fileID = file->id;
2182 info.dflt.defs.merge = merge;
2184 HandleSymbolsFile(file, keymap, merge, &info);
2186 if (info.nKeys == 0)
2189 if (info.errorCount != 0)
2192 /* alloc memory in the xkb struct */
2193 if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) {
2194 WSGO("Can not allocate names in CompileSymbols\n");
2195 ACTION("Symbols not added\n");
2199 if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
2201 WSGO("Could not allocate client map in CompileSymbols\n");
2202 ACTION("Symbols not added\n");
2206 if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
2207 WSGO("Could not allocate server map in CompileSymbols\n");
2208 ACTION("Symbols not added\n");
2212 if (XkbcAllocControls(keymap) != Success) {
2213 WSGO("Could not allocate controls in CompileSymbols\n");
2214 ACTION("Symbols not added\n");
2218 /* now copy info into xkb. */
2219 ApplyAliases(keymap, &info.aliases);
2221 for (i = 0; i < XkbNumKbdGroups; i++) {
2222 if (info.groupNames[i] != XKB_ATOM_NONE) {
2223 free(UNCONSTIFY(keymap->names->groups[i]));
2224 keymap->names->groups[i] = xkb_atom_strdup(keymap->ctx,
2225 info.groupNames[i]);
2230 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2234 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2235 if (!CopySymbolsDef(keymap, key, 0))
2238 if (warningLevel > 3) {
2239 for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
2240 if (keymap->names->keys[i].name[0] == '\0')
2243 if (XkbKeyNumGroups(keymap, i) < 1) {
2245 memcpy(buf, keymap->names->keys[i].name, 4);
2247 WARN("No symbols defined for <%s> (keycode %d)\n", buf, i);
2253 ModMapEntry *mm, *next;
2254 for (mm = info.modMap; mm != NULL; mm = next) {
2255 if (!CopyModMapDef(keymap, mm))
2257 next = (ModMapEntry *) mm->defs.next;
2261 FreeSymbolsInfo(&info);
2265 FreeSymbolsInfo(&info);