1 /************************************************************
2 Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
4 Permission to use, copy, modify, and distribute this
5 software and its documentation for any purpose and without
6 fee is hereby granted, provided that the above copyright
7 notice appear in all copies and that both that copyright
8 notice and this permission notice appear in supporting
9 documentation, and that the name of Silicon Graphics not be
10 used in advertising or publicity pertaining to distribution
11 of the software without specific prior written permission.
12 Silicon Graphics makes no representation about the suitability
13 of this software for any purpose. It is provided "as is"
14 without any express or implied warranty.
16 SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18 AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19 GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23 THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 ********************************************************/
27 #include "xkbcomp-priv.h"
28 #include "parseutils.h"
34 /***====================================================================***/
38 #define RepeatUndefined ~((unsigned)0)
40 #define _Key_Syms (1<<0)
41 #define _Key_Acts (1<<1)
42 #define _Key_Repeat (1<<2)
43 #define _Key_Behavior (1<<3)
44 #define _Key_Type_Dflt (1<<4)
45 #define _Key_Types (1<<5)
46 #define _Key_GroupInfo (1<<6)
47 #define _Key_VModMap (1<<7)
49 typedef struct _KeyInfo
52 unsigned long name; /* the 4 chars of the key name, as long */
53 unsigned char groupInfo;
54 unsigned char typesDefined;
55 unsigned char symsDefined;
56 unsigned char actsDefined;
57 unsigned int numLevels[XkbNumKbdGroups];
59 /* syms[group] -> Single array for all the keysyms in the group. */
60 xkb_keysym_t *syms[XkbNumKbdGroups];
61 /* sizeSyms[group] -> The size of the syms[group] array. */
62 int sizeSyms[XkbNumKbdGroups];
64 * symsMapIndex[group][level] -> The index from which the syms for
65 * the level begin in the syms[group] array. Remember each keycode
66 * can have multiple keysyms in each level (that is, each key press
67 * can result in multiple keysyms).
69 int *symsMapIndex[XkbNumKbdGroups];
71 * symsMapNumEntries[group][level] -> How many syms are in
72 * syms[group][symsMapIndex[group][level]].
74 unsigned int *symsMapNumEntries[XkbNumKbdGroups];
76 union xkb_action *acts[XkbNumKbdGroups];
77 xkb_atom_t types[XkbNumKbdGroups];
79 struct xkb_behavior behavior;
80 unsigned short vmodmap;
85 * Init the given key info to sane values.
88 InitKeyInfo(KeyInfo * info)
91 static const char dflt[4] = "*";
93 info->defs.defined = 0;
94 info->defs.fileID = 0;
95 info->defs.merge = MergeOverride;
96 info->defs.next = NULL;
97 info->name = KeyNameToLong(dflt);
99 info->typesDefined = info->symsDefined = info->actsDefined = 0;
100 for (i = 0; i < XkbNumKbdGroups; i++)
102 info->numLevels[i] = 0;
103 info->types[i] = XKB_ATOM_NONE;
104 info->syms[i] = NULL;
105 info->sizeSyms[i] = 0;
106 info->symsMapIndex[i] = NULL;
107 info->symsMapNumEntries[i] = NULL;
108 info->acts[i] = NULL;
110 info->dfltType = XKB_ATOM_NONE;
111 info->behavior.type = XkbKB_Default;
112 info->behavior.data = 0;
114 info->repeat = RepeatUndefined;
118 * Free memory associated with this key info and reset to sane values.
121 FreeKeyInfo(KeyInfo * info)
125 info->defs.defined = 0;
126 info->defs.fileID = 0;
127 info->defs.merge = MergeOverride;
128 info->defs.next = NULL;
130 info->typesDefined = info->symsDefined = info->actsDefined = 0;
131 for (i = 0; i < XkbNumKbdGroups; i++)
133 info->numLevels[i] = 0;
134 info->types[i] = XKB_ATOM_NONE;
136 info->syms[i] = NULL;
137 info->sizeSyms[i] = 0;
138 free(info->symsMapIndex[i]);
139 info->symsMapIndex[i] = NULL;
140 free(info->symsMapNumEntries[i]);
141 info->symsMapNumEntries[i] = NULL;
143 info->acts[i] = NULL;
145 info->dfltType = XKB_ATOM_NONE;
146 info->behavior.type = XkbKB_Default;
147 info->behavior.data = 0;
149 info->repeat = RepeatUndefined;
153 * Copy old into new, optionally reset old to 0.
154 * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
155 * newly allocated and new points to the new memory areas.
158 CopyKeyInfo(KeyInfo * old, KeyInfo * new, bool clearOld)
163 new->defs.next = NULL;
166 for (i = 0; i < XkbNumKbdGroups; i++)
168 old->numLevels[i] = 0;
169 old->symsMapIndex[i] = NULL;
170 old->symsMapNumEntries[i] = NULL;
172 old->sizeSyms[i] = 0;
179 for (i = 0; i < XkbNumKbdGroups; i++)
181 width = new->numLevels[i];
182 if (old->syms[i] != NULL)
184 new->syms[i] = uTypedCalloc(new->sizeSyms[i], xkb_keysym_t);
188 new->sizeSyms[i] = 0;
189 new->numLevels[i] = 0;
193 memcpy(new->syms[i], old->syms[i],
194 new->sizeSyms[i] * sizeof(xkb_keysym_t));
195 new->symsMapIndex[i] = uTypedCalloc(width, int);
196 if (!new->symsMapIndex[i])
200 new->sizeSyms[i] = 0;
201 new->numLevels[i] = 0;
205 memcpy(new->symsMapIndex[i], old->symsMapIndex[i],
206 width * sizeof(int));
207 new->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
208 if (!new->symsMapNumEntries[i])
212 new->sizeSyms[i] = 0;
213 free(new->symsMapIndex[i]);
214 new->symsMapIndex[i] = NULL;
215 new->numLevels[i] = 0;
219 memcpy(new->symsMapNumEntries[i], old->symsMapNumEntries[i],
220 width * sizeof(unsigned int));
222 if (old->acts[i] != NULL)
224 new->acts[i] = uTypedCalloc(width, union xkb_action);
229 new->sizeSyms[i] = 0;
230 free(new->symsMapIndex[i]);
231 new->symsMapIndex[i] = NULL;
232 free(new->symsMapNumEntries[i]);
233 new->symsMapNumEntries[i] = NULL;
234 new->numLevels[i] = 0;
237 memcpy(new->acts[i], old->acts[i],
238 width * sizeof(union xkb_action));
245 /***====================================================================***/
247 typedef struct _ModMapEntry
254 unsigned long keyName;
259 #define SYMBOLS_INIT_SIZE 110
261 typedef struct _SymbolsInfo
263 char *name; /* e.g. pc+us+inet(evdev) */
267 unsigned explicit_group;
268 darray(KeyInfo) keys;
272 xkb_atom_t groupNames[XkbNumKbdGroups];
279 InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap)
284 info->explicit_group = 0;
285 info->errorCount = 0;
287 info->merge = MergeOverride;
288 darray_init(info->keys);
289 darray_growalloc(info->keys, SYMBOLS_INIT_SIZE);
291 for (i = 0; i < XkbNumKbdGroups; i++)
292 info->groupNames[i] = XKB_ATOM_NONE;
293 InitKeyInfo(&info->dflt);
294 InitVModInfo(&info->vmods, keymap);
296 info->aliases = NULL;
300 FreeSymbolsInfo(SymbolsInfo * info)
305 darray_foreach(key, info->keys)
307 darray_free(info->keys);
309 ClearCommonInfo(&info->modMap->defs);
311 ClearAliases(&info->aliases);
312 memset(info, 0, sizeof(SymbolsInfo));
316 ResizeKeyGroup(KeyInfo * key, unsigned int group, unsigned int numLevels,
317 unsigned sizeSyms, bool forceActions)
321 if (key->syms[group] == NULL || key->sizeSyms[group] < sizeSyms)
323 key->syms[group] = uTypedRecalloc(key->syms[group],
324 key->sizeSyms[group],
327 if (!key->syms[group]) {
328 key->sizeSyms[group] = 0;
331 key->sizeSyms[group] = sizeSyms;
333 if (!key->symsMapIndex[group] || key->numLevels[group] < numLevels)
335 key->symsMapIndex[group] = uTypedRealloc(key->symsMapIndex[group],
338 if (!key->symsMapIndex[group])
340 for (i = key->numLevels[group]; i < numLevels; i++)
341 key->symsMapIndex[group][i] = -1;
343 if (!key->symsMapNumEntries[group] || key->numLevels[group] < numLevels)
345 key->symsMapNumEntries[group] =
346 uTypedRecalloc(key->symsMapNumEntries[group],
347 key->numLevels[group],
350 if (!key->symsMapNumEntries[group])
354 (key->numLevels[group] < numLevels || (key->acts[group] == NULL))) ||
355 (key->numLevels[group] < numLevels && (key->acts[group] != NULL)))
357 key->acts[group] = uTypedRecalloc(key->acts[group],
358 key->numLevels[group],
361 if (!key->acts[group])
364 if (key->numLevels[group] < numLevels)
365 key->numLevels[group] = numLevels;
370 MergeKeyGroups(SymbolsInfo * info,
371 KeyInfo * into, KeyInfo * from, unsigned group)
373 xkb_keysym_t *resultSyms = NULL;
374 union xkb_action *resultActs;
375 unsigned int resultWidth;
376 unsigned int resultSize = 0;
379 bool report, clobber;
381 clobber = (from->defs.merge != MergeAugment);
382 report = (warningLevel > 9) ||
383 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
384 if (into->numLevels[group] >= from->numLevels[group])
386 resultActs = into->acts[group];
387 resultWidth = into->numLevels[group];
391 resultActs = from->acts[group];
392 resultWidth = from->numLevels[group];
393 into->symsMapIndex[group] = uTypedRealloc(into->symsMapIndex[group],
394 from->numLevels[group],
396 into->symsMapNumEntries[group] =
397 uTypedRecalloc(into->symsMapNumEntries[group],
398 into->numLevels[group],
399 from->numLevels[group],
401 if (!into->symsMapIndex[group] || !into->symsMapNumEntries[group])
403 WSGO("Could not allocate level indices for key info merge\n");
404 ACTION("Group %d of key %s not merged\n", group,
405 longText(into->name));
409 for (i = into->numLevels[group]; i < from->numLevels[group]; i++)
410 into->symsMapIndex[group][i] = -1;
413 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
415 resultActs = uTypedCalloc(resultWidth, union xkb_action);
418 WSGO("Could not allocate actions for group merge\n");
419 ACTION("Group %d of key %s not merged\n", group,
420 longText(into->name));
423 for (i = 0; i < resultWidth; i++)
425 union xkb_action *fromAct, *toAct;
426 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
427 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
428 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
431 resultActs[i] = *toAct;
433 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
434 && (fromAct != NULL))
436 resultActs[i] = *fromAct;
440 union xkb_action *use, *ignore;
454 ("Multiple actions for level %d/group %d on key %s\n",
455 i + 1, group + 1, longText(into->name));
456 ACTION("Using %s, ignoring %s\n",
457 XkbcActionTypeText(use->type),
458 XkbcActionTypeText(ignore->type));
461 resultActs[i] = *use;
466 for (i = 0; i < resultWidth; i++)
468 unsigned int fromSize = 0;
471 if (from->symsMapNumEntries[group] && (i < from->numLevels[group]))
472 fromSize = from->symsMapNumEntries[group][i];
473 if (into->symsMapNumEntries[group] && (i < into->numLevels[group]))
474 toSize = into->symsMapNumEntries[group][i];
478 resultSize += toSize;
480 else if (toSize == 0 || clobber)
482 resultSize += fromSize;
486 resultSize += toSize;
493 resultSyms = uTypedCalloc(resultSize, xkb_keysym_t);
496 WSGO("Could not allocate symbols for group merge\n");
497 ACTION("Group %d of key %s not merged\n", group, longText(into->name));
501 for (i = 0; i < resultWidth; i++)
503 enum { NONE, FROM, TO } use;
504 unsigned int fromSize = 0;
505 unsigned int toSize = 0;
507 if (i < from->numLevels[group])
508 fromSize = from->symsMapNumEntries[group][i];
509 if (i < into->numLevels[group])
510 toSize = into->symsMapNumEntries[group][i];
512 if (fromSize == 0 && toSize == 0)
514 into->symsMapIndex[group][i] = -1;
515 into->symsMapNumEntries[group][i] = 0;
521 else if (toSize == 0 || clobber)
526 if (toSize && fromSize && report)
528 INFO("Multiple symbols for group %d, level %d on key %s\n",
529 group + 1, i + 1, longText(into->name));
530 ACTION("Using %s, ignoring %s\n",
531 (use == FROM ? "from" : "to"),
532 (use == FROM ? "to" : "from"));
537 memcpy(&resultSyms[cur_idx],
538 &from->syms[group][from->symsMapIndex[group][i]],
539 from->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
540 into->symsMapIndex[group][i] = cur_idx;
541 into->symsMapNumEntries[group][i] =
542 from->symsMapNumEntries[group][i];
546 memcpy(&resultSyms[cur_idx],
547 &into->syms[group][into->symsMapIndex[group][i]],
548 into->symsMapNumEntries[group][i] * sizeof(xkb_keysym_t));
549 into->symsMapIndex[group][i] = cur_idx;
551 cur_idx += into->symsMapNumEntries[group][i];
555 if (resultActs != into->acts[group])
556 free(into->acts[group]);
557 if (resultActs != from->acts[group])
558 free(from->acts[group]);
559 into->numLevels[group] = resultWidth;
560 free(into->syms[group]);
561 into->syms[group] = resultSyms;
562 free(from->syms[group]);
563 from->syms[group] = NULL;
564 from->sizeSyms[group] = 0;
565 into->sizeSyms[group] = resultSize;
566 free(from->symsMapIndex[group]);
567 from->symsMapIndex[group] = NULL;
568 free(from->symsMapNumEntries[group]);
569 from->symsMapNumEntries[group] = NULL;
570 into->acts[group] = resultActs;
571 from->acts[group] = NULL;
572 into->symsDefined |= (1 << group);
573 from->symsDefined &= ~(1 << group);
574 into->actsDefined |= (1 << group);
575 from->actsDefined &= ~(1 << group);
581 MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap,
582 KeyInfo *into, KeyInfo *from)
585 unsigned collide = 0;
588 if (from->defs.merge == MergeReplace)
590 for (i = 0; i < XkbNumKbdGroups; i++)
592 if (into->numLevels[i] != 0)
599 memset(from, 0, sizeof(KeyInfo));
602 report = ((warningLevel > 9) ||
603 ((into->defs.fileID == from->defs.fileID)
604 && (warningLevel > 0)));
605 for (i = 0; i < XkbNumKbdGroups; i++)
607 if (from->numLevels[i] > 0)
609 if (into->numLevels[i] == 0)
611 into->numLevels[i] = from->numLevels[i];
612 into->syms[i] = from->syms[i];
613 into->sizeSyms[i] = from->sizeSyms[i];
614 into->symsMapIndex[i] = from->symsMapIndex[i];
615 into->symsMapNumEntries[i] = from->symsMapNumEntries[i];
616 into->acts[i] = from->acts[i];
617 into->symsDefined |= (1 << i);
618 from->syms[i] = NULL;
619 from->sizeSyms[i] = 0;
620 from->symsMapIndex[i] = NULL;
621 from->symsMapNumEntries[i] = NULL;
622 from->acts[i] = NULL;
623 from->numLevels[i] = 0;
624 from->symsDefined &= ~(1 << i);
626 into->defs.defined |= _Key_Syms;
628 into->defs.defined |= _Key_Acts;
635 collide |= _Key_Syms;
637 collide |= _Key_Acts;
639 MergeKeyGroups(info, into, from, (unsigned) i);
642 if (from->types[i] != XKB_ATOM_NONE)
644 if ((into->types[i] != XKB_ATOM_NONE) && report &&
645 (into->types[i] != from->types[i]))
647 xkb_atom_t use, ignore;
648 collide |= _Key_Types;
649 if (from->defs.merge != MergeAugment)
651 use = from->types[i];
652 ignore = into->types[i];
656 use = into->types[i];
657 ignore = from->types[i];
660 ("Multiple definitions for group %d type of key %s\n",
661 i, longText(into->name));
662 ACTION("Using %s, ignoring %s\n",
663 xkb_atom_text(keymap->ctx, use),
664 xkb_atom_text(keymap->ctx, ignore));
666 if ((from->defs.merge != MergeAugment)
667 || (into->types[i] == XKB_ATOM_NONE))
669 into->types[i] = from->types[i];
673 if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
675 into->behavior = from->behavior;
676 into->defs.defined |= _Key_Behavior;
678 if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
680 into->vmodmap = from->vmodmap;
681 into->defs.defined |= _Key_VModMap;
683 if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
685 into->repeat = from->repeat;
686 into->defs.defined |= _Key_Repeat;
688 if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
690 into->dfltType = from->dfltType;
691 into->defs.defined |= _Key_Type_Dflt;
693 if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
695 into->groupInfo = from->groupInfo;
696 into->defs.defined |= _Key_GroupInfo;
700 WARN("Symbol map for key %s redefined\n",
701 longText(into->name));
702 ACTION("Using %s definition for conflicting fields\n",
703 (from->defs.merge == MergeAugment ? "first" : "last"));
709 AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap)
711 unsigned long real_name;
714 darray_foreach(iter, info->keys)
715 if (iter->name == key->name)
716 return MergeKeys(info, keymap, iter, key);
718 if (FindKeyNameForAlias(keymap, key->name, &real_name))
719 darray_foreach(iter, info->keys)
720 if (iter->name == real_name)
721 return MergeKeys(info, keymap, iter, key);
723 darray_resize0(info->keys, darray_size(info->keys) + 1);
724 new = &darray_item(info->keys, darray_size(info->keys) - 1);
725 return CopyKeyInfo(key, new, true);
729 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
734 clobber = (new->defs.merge != MergeAugment);
735 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
737 if (new->haveSymbol && mm->haveSymbol
738 && (new->u.keySym == mm->u.keySym))
740 unsigned use, ignore;
741 if (mm->modifier != new->modifier)
746 ignore = mm->modifier;
751 ignore = new->modifier;
754 ("%s added to symbol map for multiple modifiers\n",
755 XkbcKeysymText(new->u.keySym));
756 ACTION("Using %s, ignoring %s.\n",
757 XkbcModIndexText(use),
758 XkbcModIndexText(ignore));
763 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
764 (new->u.keyName == mm->u.keyName))
766 unsigned use, ignore;
767 if (mm->modifier != new->modifier)
772 ignore = mm->modifier;
777 ignore = new->modifier;
779 ERROR("Key %s added to map for multiple modifiers\n",
780 longText(new->u.keyName));
781 ACTION("Using %s, ignoring %s.\n",
782 XkbcModIndexText(use),
783 XkbcModIndexText(ignore));
789 mm = uTypedAlloc(ModMapEntry);
792 WSGO("Could not allocate modifier map entry\n");
793 ACTION("Modifier map for %s will be incomplete\n",
794 XkbcModIndexText(new->modifier));
798 mm->defs.next = &info->modMap->defs;
803 /***====================================================================***/
806 MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
807 unsigned merge, struct xkb_keymap *keymap)
812 if (from->errorCount > 0)
814 into->errorCount += from->errorCount;
817 if (into->name == NULL)
819 into->name = from->name;
822 for (i = 0; i < XkbNumKbdGroups; i++)
824 if (from->groupNames[i] != XKB_ATOM_NONE)
826 if ((merge != MergeAugment) ||
827 (into->groupNames[i] == XKB_ATOM_NONE))
828 into->groupNames[i] = from->groupNames[i];
832 darray_foreach(key, from->keys) {
833 if (merge != MergeDefault)
834 key->defs.merge = merge;
836 if (!AddKeySymbols(into, key, keymap))
840 if (from->modMap != NULL)
842 ModMapEntry *mm, *next;
843 for (mm = from->modMap; mm != NULL; mm = next)
845 if (merge != MergeDefault)
846 mm->defs.merge = merge;
847 if (!AddModMapEntry(into, mm))
849 next = (ModMapEntry *) mm->defs.next;
854 if (!MergeAliases(&into->aliases, &from->aliases, merge))
859 HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
860 unsigned merge, SymbolsInfo *info);
863 HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap,
868 SymbolsInfo included;
872 if ((stmt->file == NULL) && (stmt->map == NULL))
876 memset(info, 0, sizeof(SymbolsInfo));
878 else if (ProcessIncludeFile(keymap->ctx, stmt, XkmSymbolsIndex, &rtrn,
881 InitSymbolsInfo(&included, keymap);
882 included.fileID = included.dflt.defs.fileID = rtrn->id;
883 included.merge = included.dflt.defs.merge = MergeOverride;
886 included.explicit_group = atoi(stmt->modifier) - 1;
890 included.explicit_group = info->explicit_group;
892 HandleSymbolsFile(rtrn, keymap, MergeOverride, &included);
893 if (stmt->stmt != NULL)
896 included.name = stmt->stmt;
903 info->errorCount += 10;
906 if ((stmt->next != NULL) && (included.errorCount < 1))
910 SymbolsInfo next_incl;
912 for (next = stmt->next; next != NULL; next = next->next)
914 if ((next->file == NULL) && (next->map == NULL))
917 MergeIncludedSymbols(&included, info, next->merge, keymap);
918 FreeSymbolsInfo(info);
920 else if (ProcessIncludeFile(keymap->ctx, next, XkmSymbolsIndex,
923 InitSymbolsInfo(&next_incl, keymap);
924 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
925 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
928 next_incl.explicit_group = atoi(next->modifier) - 1;
932 next_incl.explicit_group = info->explicit_group;
934 HandleSymbolsFile(rtrn, keymap, MergeOverride, &next_incl);
935 MergeIncludedSymbols(&included, &next_incl, op, keymap);
936 FreeSymbolsInfo(&next_incl);
941 info->errorCount += 10;
942 FreeSymbolsInfo(&included);
949 info->errorCount += included.errorCount;
955 MergeIncludedSymbols(info, &included, newMerge, keymap);
956 FreeSymbolsInfo(&included);
958 return (info->errorCount == 0);
965 GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap,
966 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
976 if (arrayNdx == NULL)
981 defined = key->symsDefined;
983 defined = key->actsDefined;
985 for (i = 0; i < XkbNumKbdGroups; i++)
987 if ((defined & (1 << i)) == 0)
993 ERROR("Too many groups of %s for key %s (max %d)\n", name,
994 longText(key->name), XkbNumKbdGroups + 1);
995 ACTION("Ignoring %s defined for extra groups\n", name);
998 if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp))
1000 ERROR("Illegal group index for %s of key %s\n", name,
1001 longText(key->name));
1002 ACTION("Definition with non-integer array index ignored\n");
1005 *ndx_rtrn = tmp.uval - 1;
1010 AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap,
1011 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1013 unsigned ndx, nSyms, nLevels;
1017 if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx))
1021 key->symsDefined |= (1 << ndx);
1024 if (value->op != ExprKeysymList)
1026 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
1027 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
1028 longText(key->name));
1031 if (key->sizeSyms[ndx] != 0)
1033 ERROR("Symbols for key %s, group %d already defined\n",
1034 longText(key->name), ndx + 1);
1035 ACTION("Ignoring duplicate definition\n");
1038 nSyms = darray_size(value->value.list.syms);
1039 nLevels = darray_size(value->value.list.symsMapIndex);
1040 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
1041 (!ResizeKeyGroup(key, ndx, nLevels, nSyms, false)))
1043 WSGO("Could not resize group %d of key %s to contain %d levels\n",
1044 ndx + 1, longText(key->name), nSyms);
1045 ACTION("Symbols lost\n");
1048 key->symsDefined |= (1 << ndx);
1049 for (i = 0; i < nLevels; i++) {
1050 key->symsMapIndex[ndx][i] =
1051 darray_item(value->value.list.symsMapIndex, i);
1052 key->symsMapNumEntries[ndx][i] =
1053 darray_item(value->value.list.symsNumEntries, i);
1055 for (j = 0; j < key->symsMapNumEntries[ndx][i]; j++) {
1056 if (key->symsMapIndex[ndx][i] + j >= nSyms)
1058 if (!LookupKeysym(darray_item(value->value.list.syms,
1059 darray_item(value->value.list.symsMapIndex, i) + j),
1060 &key->syms[ndx][key->symsMapIndex[ndx][i] + j])) {
1061 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
1062 darray_item(value->value.list.syms, i),
1063 longText(key->name),
1065 xkb_atom_text(keymap->ctx, info->groupNames[ndx]), nSyms);
1067 key->syms[ndx][key->symsMapIndex[ndx][i] + j] = XKB_KEY_NoSymbol;
1068 key->symsMapIndex[ndx][i] = -1;
1069 key->symsMapNumEntries[ndx][i] = 0;
1072 if (key->symsMapNumEntries[ndx][i] == 1 &&
1073 key->syms[ndx][key->symsMapIndex[ndx][i] + j] == XKB_KEY_NoSymbol) {
1074 key->symsMapIndex[ndx][i] = -1;
1075 key->symsMapNumEntries[ndx][i] = 0;
1079 for (j = key->numLevels[ndx] - 1;
1080 j >= 0 && key->symsMapNumEntries[ndx][j] == 0; j--)
1081 key->numLevels[ndx]--;
1086 AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1087 ExprDef *value, SymbolsInfo *info)
1090 unsigned ndx, nActs;
1092 struct xkb_any_action *toAct;
1094 if (!GetGroupIndex(key, keymap, arrayNdx, ACTIONS, &ndx))
1099 key->actsDefined |= (1 << ndx);
1102 if (value->op != ExprActionList)
1104 WSGO("Bad expression type (%d) for action list value\n", value->op);
1105 ACTION("Ignoring actions for group %d of %s\n", ndx,
1106 longText(key->name));
1109 if (key->acts[ndx] != NULL)
1111 WSGO("Actions for key %s, group %d already defined\n",
1112 longText(key->name), ndx);
1115 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
1117 act = (ExprDef *) act->common.next;
1121 WSGO("Action list but not actions in AddActionsToKey\n");
1124 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
1125 (!ResizeKeyGroup(key, ndx, nActs, nActs, true)))
1127 WSGO("Could not resize group %d of key %s\n", ndx,
1128 longText(key->name));
1129 ACTION("Actions lost\n");
1132 key->actsDefined |= (1 << ndx);
1134 toAct = (struct xkb_any_action *) key->acts[ndx];
1135 act = value->value.child;
1136 for (i = 0; i < nActs; i++, toAct++)
1138 if (!HandleActionDef(act, keymap, toAct, info->action))
1140 ERROR("Illegal action definition for %s\n",
1141 longText(key->name));
1142 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1144 act = (ExprDef *) act->common.next;
1149 static const LookupEntry lockingEntries[] = {
1150 {"true", XkbKB_Lock},
1151 {"yes", XkbKB_Lock},
1153 {"false", XkbKB_Default},
1154 {"no", XkbKB_Default},
1155 {"off", XkbKB_Default},
1156 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1160 static const LookupEntry repeatEntries[] = {
1161 {"true", RepeatYes},
1164 {"false", RepeatNo},
1167 {"default", RepeatUndefined},
1172 SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field,
1173 ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
1178 if (strcasecmp(field, "type") == 0)
1181 if ((!ExprResolveString(keymap->ctx, value, &tmp))
1182 && (warningLevel > 0))
1184 WARN("The type field of a key symbol map must be a string\n");
1185 ACTION("Ignoring illegal type definition\n");
1187 if (arrayNdx == NULL)
1189 key->dfltType = xkb_atom_intern(keymap->ctx, tmp.str);
1190 key->defs.defined |= _Key_Type_Dflt;
1192 else if (!ExprResolveGroup(keymap->ctx, arrayNdx, &ndx))
1194 ERROR("Illegal group index for type of key %s\n",
1195 longText(key->name));
1196 ACTION("Definition with non-integer array index ignored\n");
1202 key->types[ndx.uval - 1] = xkb_atom_intern(keymap->ctx, tmp.str);
1203 key->typesDefined |= (1 << (ndx.uval - 1));
1207 else if (strcasecmp(field, "symbols") == 0)
1208 return AddSymbolsToKey(key, keymap, arrayNdx, value, info);
1209 else if (strcasecmp(field, "actions") == 0)
1210 return AddActionsToKey(key, keymap, arrayNdx, value, info);
1211 else if ((strcasecmp(field, "vmods") == 0) ||
1212 (strcasecmp(field, "virtualmods") == 0) ||
1213 (strcasecmp(field, "virtualmodifiers") == 0))
1215 ok = ExprResolveVModMask(value, &tmp, keymap);
1218 key->vmodmap = (tmp.uval >> 8);
1219 key->defs.defined |= _Key_VModMap;
1223 ERROR("Expected a virtual modifier mask, found %s\n",
1224 exprOpText(value->op));
1225 ACTION("Ignoring virtual modifiers definition for key %s\n",
1226 longText(key->name));
1229 else if ((strcasecmp(field, "locking") == 0) ||
1230 (strcasecmp(field, "lock") == 0) ||
1231 (strcasecmp(field, "locks") == 0))
1233 ok = ExprResolveEnum(keymap->ctx, value, &tmp, lockingEntries);
1235 key->behavior.type = tmp.uval;
1236 key->defs.defined |= _Key_Behavior;
1238 else if ((strcasecmp(field, "radiogroup") == 0) ||
1239 (strcasecmp(field, "permanentradiogroup") == 0) ||
1240 (strcasecmp(field, "allownone") == 0))
1242 ERROR("Radio groups not supported\n");
1243 ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1246 else if (uStrCasePrefix("overlay", field) ||
1247 uStrCasePrefix("permanentoverlay", field))
1249 ERROR("Overlays not supported\n");
1250 ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1252 else if ((strcasecmp(field, "repeating") == 0) ||
1253 (strcasecmp(field, "repeats") == 0) ||
1254 (strcasecmp(field, "repeat") == 0))
1256 ok = ExprResolveEnum(keymap->ctx, value, &tmp, repeatEntries);
1259 ERROR("Illegal repeat setting for %s\n",
1260 longText(key->name));
1261 ACTION("Non-boolean repeat setting ignored\n");
1264 key->repeat = tmp.uval;
1265 key->defs.defined |= _Key_Repeat;
1267 else if ((strcasecmp(field, "groupswrap") == 0) ||
1268 (strcasecmp(field, "wrapgroups") == 0))
1270 ok = ExprResolveBoolean(keymap->ctx, value, &tmp);
1273 ERROR("Illegal groupsWrap setting for %s\n",
1274 longText(key->name));
1275 ACTION("Non-boolean value ignored\n");
1279 key->groupInfo = XkbWrapIntoRange;
1281 key->groupInfo = XkbClampIntoRange;
1282 key->defs.defined |= _Key_GroupInfo;
1284 else if ((strcasecmp(field, "groupsclamp") == 0) ||
1285 (strcasecmp(field, "clampgroups") == 0))
1287 ok = ExprResolveBoolean(keymap->ctx, value, &tmp);
1290 ERROR("Illegal groupsClamp setting for %s\n",
1291 longText(key->name));
1292 ACTION("Non-boolean value ignored\n");
1296 key->groupInfo = XkbClampIntoRange;
1298 key->groupInfo = XkbWrapIntoRange;
1299 key->defs.defined |= _Key_GroupInfo;
1301 else if ((strcasecmp(field, "groupsredirect") == 0) ||
1302 (strcasecmp(field, "redirectgroups") == 0))
1304 if (!ExprResolveGroup(keymap->ctx, value, &tmp))
1306 ERROR("Illegal group index for redirect of key %s\n",
1307 longText(key->name));
1308 ACTION("Definition with non-integer group ignored\n");
1312 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1313 key->defs.defined |= _Key_GroupInfo;
1317 ERROR("Unknown field %s in a symbol interpretation\n", field);
1318 ACTION("Definition ignored\n");
1325 SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx,
1328 ExprResult tmp, name;
1330 if ((arrayNdx == NULL) && (warningLevel > 0))
1332 WARN("You must specify an index when specifying a group name\n");
1333 ACTION("Group name definition without array subscript ignored\n");
1336 if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp))
1338 ERROR("Illegal index in group name definition\n");
1339 ACTION("Definition with non-integer array index ignored\n");
1342 if (!ExprResolveString(keymap->ctx, value, &name))
1344 ERROR("Group name must be a string\n");
1345 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1348 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1349 xkb_atom_intern(keymap->ctx, name.str);
1356 HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info)
1358 ExprResult elem, field;
1362 if (ExprResolveLhs(keymap, stmt->name, &elem, &field, &arrayNdx) == 0)
1363 return 0; /* internal error, already reported */
1364 if (elem.str && (strcasecmp(elem.str, "key") == 0))
1366 ret = SetSymbolsField(&info->dflt, keymap, field.str, arrayNdx,
1369 else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) ||
1370 (strcasecmp(field.str, "groupname") ==
1373 ret = SetGroupName(info, keymap, arrayNdx, stmt->value);
1375 else if ((elem.str == NULL)
1376 && ((strcasecmp(field.str, "groupswrap") == 0) ||
1377 (strcasecmp(field.str, "wrapgroups") == 0)))
1379 ERROR("Global \"groupswrap\" not supported\n");
1380 ACTION("Ignored\n");
1383 else if ((elem.str == NULL)
1384 && ((strcasecmp(field.str, "groupsclamp") == 0) ||
1385 (strcasecmp(field.str, "clampgroups") == 0)))
1387 ERROR("Global \"groupsclamp\" not supported\n");
1388 ACTION("Ignored\n");
1391 else if ((elem.str == NULL)
1392 && ((strcasecmp(field.str, "groupsredirect") == 0) ||
1393 (strcasecmp(field.str, "redirectgroups") == 0)))
1395 ERROR("Global \"groupsredirect\" not supported\n");
1396 ACTION("Ignored\n");
1399 else if ((elem.str == NULL) && (strcasecmp(field.str, "allownone") == 0))
1401 ERROR("Radio groups not supported\n");
1402 ACTION("Ignoring \"allownone\" specification\n");
1406 ret = SetActionField(keymap, elem.str, field.str, arrayNdx,
1407 stmt->value, &info->action);
1416 HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key,
1420 ExprResult tmp, field;
1423 for (; def != NULL; def = (VarDef *) def->common.next)
1425 if ((def->name) && (def->name->type == ExprFieldRef))
1427 ok = HandleSymbolsVar(def, keymap, info);
1432 if (def->name == NULL)
1434 if ((def->value == NULL)
1435 || (def->value->op == ExprKeysymList))
1436 field.str = strdup("symbols");
1438 field.str = strdup("actions");
1443 ok = ExprResolveLhs(keymap, def->name, &tmp, &field,
1447 ok = SetSymbolsField(key, keymap, field.str, arrayNdx,
1456 SetExplicitGroup(SymbolsInfo *info, KeyInfo *key)
1458 unsigned group = info->explicit_group;
1463 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1466 WARN("For the map %s an explicit group specified\n", info->name);
1467 WARN("but key %s has more than one group defined\n",
1468 longText(key->name));
1469 ACTION("All groups except first one will be ignored\n");
1470 for (i = 1; i < XkbNumKbdGroups; i++)
1472 key->numLevels[i] = 0;
1474 key->syms[i] = NULL;
1476 key->acts[i] = NULL;
1480 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1482 key->numLevels[group] = key->numLevels[0];
1483 key->numLevels[0] = 0;
1484 key->syms[group] = key->syms[0];
1485 key->syms[0] = NULL;
1486 key->sizeSyms[group] = key->sizeSyms[0];
1487 key->sizeSyms[0] = 0;
1488 key->symsMapIndex[group] = key->symsMapIndex[0];
1489 key->symsMapIndex[0] = NULL;
1490 key->symsMapNumEntries[group] = key->symsMapNumEntries[0];
1491 key->symsMapNumEntries[0] = NULL;
1492 key->acts[group] = key->acts[0];
1493 key->acts[0] = NULL;
1494 key->types[group] = key->types[0];
1500 HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap,
1506 CopyKeyInfo(&info->dflt, &key, false);
1507 key.defs.merge = stmt->merge;
1508 key.name = KeyNameToLong(stmt->keyName);
1509 if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info))
1515 if (!SetExplicitGroup(info, &key))
1521 if (!AddKeySymbols(info, &key, keymap))
1530 HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info)
1537 if (!LookupModIndex(keymap->ctx, NULL, def->modifier, TypeInt, &rtrn))
1539 ERROR("Illegal modifier map definition\n");
1540 ACTION("Ignoring map for non-modifier \"%s\"\n",
1541 xkb_atom_text(keymap->ctx, def->modifier));
1545 tmp.modifier = rtrn.uval;
1546 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1548 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1550 tmp.haveSymbol = false;
1551 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1553 else if (ExprResolveKeySym(keymap->ctx, key, &rtrn))
1555 tmp.haveSymbol = true;
1556 tmp.u.keySym = rtrn.uval;
1560 ERROR("Modmap entries may contain only key names or keysyms\n");
1561 ACTION("Illegal definition for %s modifier ignored\n",
1562 XkbcModIndexText(tmp.modifier));
1566 ok = AddModMapEntry(info, &tmp) && ok;
1572 HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
1573 unsigned merge, SymbolsInfo *info)
1578 info->name = uDupString(file->name);
1582 switch (stmt->stmtType)
1585 if (!HandleIncludeSymbols((IncludeStmt *) stmt, keymap, info))
1588 case StmtSymbolsDef:
1589 if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info))
1593 if (!HandleSymbolsVar((VarDef *) stmt, keymap, info))
1597 if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
1601 ERROR("Interpretation files may not include other types\n");
1602 ACTION("Ignoring definition of symbol interpretation\n");
1605 case StmtKeycodeDef:
1606 ERROR("Interpretation files may not include other types\n");
1607 ACTION("Ignoring definition of key name\n");
1611 if (!HandleModMapDef((ModMapDef *) stmt, keymap, info))
1615 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1620 if (info->errorCount > 10)
1623 ERROR("Too many errors\n");
1625 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1632 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
1633 xkb_keycode_t *kc_rtrn)
1636 unsigned int group, level;
1638 for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
1640 for (group = 0; group < XkbKeyNumGroups(keymap, key); group++)
1642 for (level = 0; level < XkbKeyGroupWidth(keymap, key, group);
1645 if (XkbKeyNumSyms(keymap, key, group, level) != 1 ||
1646 (XkbKeySymEntry(keymap, key, group, level))[0] != sym)
1658 * Find the given name in the keymap->map->types and return its index.
1660 * @param atom The atom to search for.
1661 * @param type_rtrn Set to the index of the name if found.
1663 * @return true if found, false otherwise.
1666 FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
1669 const char *name = xkb_atom_text(keymap->ctx, atom);
1670 struct xkb_key_type *type;
1672 if (keymap && keymap->map) {
1673 darray_foreach(type, keymap->map->types) {
1674 if (strcmp(type->name, name) == 0) {
1685 * Assign a type to the given sym and return the Atom for the type assigned.
1688 * - ONE_LEVEL for width 0/1
1689 * - ALPHABETIC for 2 shift levels, with lower/upercase
1690 * - KEYPAD for keypad keys.
1691 * - TWO_LEVEL for other 2 shift level keys.
1692 * and the same for four level keys.
1694 * @param width Number of sysms in syms.
1695 * @param syms The keysyms for the given key (must be size width).
1696 * @param typeNameRtrn Set to the Atom of the type name.
1698 * @returns true if a type could be found, false otherwise.
1701 FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms,
1702 xkb_atom_t *typeNameRtrn, bool *autoType)
1705 if ((width == 1) || (width == 0))
1707 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ONE_LEVEL");
1710 else if (width == 2)
1712 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1714 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ALPHABETIC");
1716 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1718 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "KEYPAD");
1723 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "TWO_LEVEL");
1727 else if (width <= 4)
1729 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1730 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1732 xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_ALPHABETIC");
1734 *typeNameRtrn = xkb_atom_intern(keymap->ctx,
1735 "FOUR_LEVEL_SEMIALPHABETIC");
1737 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1738 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_KEYPAD");
1740 *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL");
1741 /* XXX: why not set autoType here? */
1743 return ((width >= 0) && (width <= 4));
1747 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1748 * groups, and reduce to one group if all groups are identical anyway.
1751 PrepareKeyDef(KeyInfo * key)
1753 int i, j, width, defined, lastGroup;
1756 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1757 /* get highest group number */
1758 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1760 if (defined & (1 << i))
1768 /* If there are empty groups between non-empty ones fill them with data */
1769 /* from the first group. */
1770 /* We can make a wrong assumption here. But leaving gaps is worse. */
1771 for (i = lastGroup; i > 0; i--)
1773 if (defined & (1 << i))
1775 width = key->numLevels[0];
1776 if (key->typesDefined & 1)
1778 for (j = 0; j < width; j++)
1780 key->types[i] = key->types[0];
1782 key->typesDefined |= 1 << i;
1784 if ((key->actsDefined & 1) && key->acts[0])
1786 key->acts[i] = uTypedCalloc(width, union xkb_action);
1787 if (key->acts[i] == NULL)
1789 memcpy(key->acts[i], key->acts[0],
1790 width * sizeof(union xkb_action));
1791 key->actsDefined |= 1 << i;
1793 if ((key->symsDefined & 1) && key->sizeSyms[0])
1795 key->syms[i] = uTypedCalloc(key->sizeSyms[0], xkb_keysym_t);
1796 if (key->syms[i] == NULL)
1798 memcpy(key->syms[i], key->syms[0],
1799 key->sizeSyms[0] * sizeof(xkb_keysym_t));
1800 key->symsMapIndex[i] = uTypedCalloc(width, int);
1801 if (!key->symsMapIndex[i])
1804 key->syms[i] = NULL;
1807 memcpy(key->symsMapIndex[i], key->symsMapIndex[0],
1808 width * sizeof(int));
1809 key->symsMapNumEntries[i] = uTypedCalloc(width, unsigned int);
1810 if (!key->symsMapNumEntries[i])
1813 key->syms[i] = NULL;
1814 free(key->symsMapIndex[i]);
1815 key->symsMapIndex[i] = NULL;
1818 memcpy(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1819 width * sizeof(int));
1820 key->sizeSyms[i] = key->sizeSyms[0];
1821 key->symsDefined |= 1 << i;
1825 key->numLevels[i] = key->numLevels[0];
1828 /* If all groups are completely identical remove them all */
1829 /* exept the first one. */
1831 for (i = lastGroup; i > 0; i--)
1833 if ((key->numLevels[i] != key->numLevels[0]) ||
1834 (key->types[i] != key->types[0]))
1839 if ((key->syms[i] != key->syms[0]) &&
1840 (key->syms[i] == NULL || key->syms[0] == NULL ||
1841 key->sizeSyms[i] != key->sizeSyms[0] ||
1842 memcmp(key->syms[i], key->syms[0],
1843 sizeof(xkb_keysym_t) * key->sizeSyms[0])))
1848 if ((key->symsMapIndex[i] != key->symsMapIndex[0]) &&
1849 (key->symsMapIndex[i] == NULL || key->symsMapIndex[0] == NULL ||
1850 memcmp(key->symsMapIndex[i], key->symsMapIndex[0],
1851 key->numLevels[0] * sizeof(int))))
1856 if ((key->symsMapNumEntries[i] != key->symsMapNumEntries[0]) &&
1857 (key->symsMapNumEntries[i] == NULL ||
1858 key->symsMapNumEntries[0] == NULL ||
1859 memcmp(key->symsMapNumEntries[i], key->symsMapNumEntries[0],
1860 key->numLevels[0] * sizeof(int))))
1865 if ((key->acts[i] != key->acts[0]) &&
1866 (key->acts[i] == NULL || key->acts[0] == NULL ||
1867 memcmp(key->acts[i], key->acts[0],
1868 sizeof(union xkb_action) * key->numLevels[0])))
1876 for (i = lastGroup; i > 0; i--)
1878 key->numLevels[i] = 0;
1880 key->syms[i] = NULL;
1881 key->sizeSyms[i] = 0;
1882 free(key->symsMapIndex[i]);
1883 key->symsMapIndex[i] = NULL;
1884 free(key->symsMapNumEntries[i]);
1885 key->symsMapNumEntries[i] = NULL;
1887 key->acts[i] = NULL;
1890 key->symsDefined &= 1;
1891 key->actsDefined &= 1;
1892 key->typesDefined &= 1;
1897 * Copy the KeyInfo into the keyboard description.
1899 * This function recurses.
1902 CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
1906 unsigned int sizeSyms = 0;
1907 unsigned width, tmp, nGroups;
1908 struct xkb_key_type * type;
1909 bool haveActions, autoType, useAlias;
1910 unsigned types[XkbNumKbdGroups];
1911 union xkb_action *outActs;
1912 unsigned int symIndex = 0;
1913 struct xkb_sym_map *sym_map;
1915 useAlias = (start_from == 0);
1917 /* get the keycode for the key. */
1918 if (!FindNamedKey(keymap, key->name, &kc, useAlias,
1919 CreateKeyNames(keymap), start_from))
1921 if ((start_from == 0) && (warningLevel >= 5))
1923 WARN("Key %s not found in keycodes\n", longText(key->name));
1924 ACTION("Symbols ignored\n");
1929 haveActions = false;
1930 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1932 if (((i + 1) > nGroups)
1933 && (((key->symsDefined | key->actsDefined) & (1 << i))
1934 || (key->typesDefined) & (1 << i)))
1939 /* Assign the type to the key, if it is missing. */
1940 if (key->types[i] == XKB_ATOM_NONE)
1942 if (key->dfltType != XKB_ATOM_NONE)
1943 key->types[i] = key->dfltType;
1944 else if (FindAutomaticType(keymap, key->numLevels[i], key->syms[i],
1945 &key->types[i], &autoType))
1950 if (warningLevel >= 5)
1952 WARN("No automatic type for %d symbols\n",
1953 (unsigned int) key->numLevels[i]);
1954 ACTION("Using %s for the %s key (keycode %d)\n",
1955 xkb_atom_text(keymap->ctx, key->types[i]),
1956 longText(key->name), kc);
1960 if (FindNamedType(keymap, key->types[i], &types[i]))
1962 if (!autoType || key->numLevels[i] > 2)
1963 keymap->server->explicit[kc] |= (1 << i);
1967 if (warningLevel >= 3)
1969 WARN("Type \"%s\" is not defined\n",
1970 xkb_atom_text(keymap->ctx, key->types[i]));
1971 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
1972 longText(key->name), kc);
1974 types[i] = XkbTwoLevelIndex;
1976 /* if the type specifies fewer levels than the key has, shrink the key */
1977 type = &darray_item(keymap->map->types, types[i]);
1978 if (type->num_levels < key->numLevels[i])
1980 if (warningLevel > 0)
1982 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
1983 type->name, type->num_levels,
1984 xkb_atom_text(keymap->ctx, key->name), key->numLevels[i]);
1985 ACTION("Ignoring extra symbols\n");
1987 key->numLevels[i] = type->num_levels;
1989 if (key->numLevels[i] > width)
1990 width = key->numLevels[i];
1991 if (type->num_levels > width)
1992 width = type->num_levels;
1993 sizeSyms += key->sizeSyms[i];
1996 if (!XkbcResizeKeySyms(keymap, kc, sizeSyms))
1998 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
1999 longText(key->name), kc);
2004 outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups);
2005 if (outActs == NULL)
2007 WSGO("Could not enlarge actions for %s (key %d)\n",
2008 longText(key->name), kc);
2011 keymap->server->explicit[kc] |= XkbExplicitInterpretMask;
2016 sym_map = &darray_item(keymap->map->key_sym_map, kc);
2018 if (key->defs.defined & _Key_GroupInfo)
2021 i = sym_map->group_info;
2023 sym_map->group_info = XkbSetNumGroups(i, nGroups);
2024 sym_map->width = width;
2025 sym_map->sym_index = uTypedCalloc(nGroups * width, int);
2026 sym_map->num_syms = uTypedCalloc(nGroups * width, unsigned int);
2028 for (i = 0; i < nGroups; i++)
2030 /* assign kt_index[i] to the index of the type in map->types.
2031 * kt_index[i] may have been set by a previous run (if we have two
2032 * layouts specified). Let's not overwrite it with the ONE_LEVEL
2033 * default group if we dont even have keys for this group anyway.
2035 * FIXME: There should be a better fix for this.
2037 if (key->numLevels[i])
2038 sym_map->kt_index[i] = types[i];
2039 if (key->sizeSyms[i] != 0)
2041 /* fill key to "width" symbols*/
2042 for (tmp = 0; tmp < width; tmp++)
2044 if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp])
2046 memcpy(&sym_map->syms[symIndex],
2047 &key->syms[i][key->symsMapIndex[i][tmp]],
2048 key->symsMapNumEntries[i][tmp] *
2049 sizeof(xkb_keysym_t));
2050 sym_map->sym_index[(i * width) + tmp] = symIndex;
2051 sym_map->num_syms[(i * width) + tmp] =
2052 key->symsMapNumEntries[i][tmp];
2053 symIndex += sym_map->num_syms[(i * width) + tmp];
2057 sym_map->sym_index[(i * width) + tmp] = -1;
2058 sym_map->num_syms[(i * width) + tmp] = 0;
2060 if ((outActs != NULL) && (key->acts[i] != NULL))
2062 if (tmp < key->numLevels[i])
2063 outActs[tmp] = key->acts[i][tmp];
2065 outActs[tmp].type = XkbSA_NoAction;
2070 switch (key->behavior.type & XkbKB_OpMask)
2075 keymap->server->behaviors[kc] = key->behavior;
2076 keymap->server->explicit[kc] |= XkbExplicitBehaviorMask;
2079 if (key->defs.defined & _Key_VModMap)
2081 keymap->server->vmodmap[kc] = key->vmodmap;
2082 keymap->server->explicit[kc] |= XkbExplicitVModMapMask;
2084 if (key->repeat != RepeatUndefined)
2086 if (key->repeat == RepeatYes)
2087 keymap->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
2089 keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
2090 keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
2093 if (nGroups > keymap->ctrls->num_groups)
2094 keymap->ctrls->num_groups = nGroups;
2096 /* do the same thing for the next key */
2097 CopySymbolsDef(keymap, key, kc + 1);
2102 CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
2106 if (!entry->haveSymbol &&
2107 !FindNamedKey(keymap, entry->u.keyName, &kc, true,
2108 CreateKeyNames(keymap), 0))
2110 if (warningLevel >= 5)
2112 WARN("Key %s not found in keycodes\n",
2113 longText(entry->u.keyName));
2114 ACTION("Modifier map entry for %s not updated\n",
2115 XkbcModIndexText(entry->modifier));
2119 else if (entry->haveSymbol &&
2120 !FindKeyForSymbol(keymap, entry->u.keySym, &kc))
2122 if (warningLevel > 5)
2124 WARN("Key \"%s\" not found in symbol map\n",
2125 XkbcKeysymText(entry->u.keySym));
2126 ACTION("Modifier map entry for %s not updated\n",
2127 XkbcModIndexText(entry->modifier));
2131 keymap->map->modmap[kc] |= (1 << entry->modifier);
2136 * Handle the xkb_symbols section of an xkb file.
2138 * @param file The parsed xkb_symbols section of the xkb file.
2139 * @param keymap Handle to the keyboard description to store the symbols in.
2140 * @param merge Merge strategy (e.g. MergeOverride).
2143 CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
2149 InitSymbolsInfo(&info, keymap);
2150 info.dflt.defs.fileID = file->id;
2151 info.dflt.defs.merge = merge;
2153 HandleSymbolsFile(file, keymap, merge, &info);
2155 if (darray_empty(info.keys))
2158 if (info.errorCount != 0)
2161 /* alloc memory in the xkb struct */
2162 if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) {
2163 WSGO("Can not allocate names in CompileSymbols\n");
2164 ACTION("Symbols not added\n");
2168 if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
2170 WSGO("Could not allocate client map in CompileSymbols\n");
2171 ACTION("Symbols not added\n");
2175 if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
2176 WSGO("Could not allocate server map in CompileSymbols\n");
2177 ACTION("Symbols not added\n");
2181 if (XkbcAllocControls(keymap) != Success) {
2182 WSGO("Could not allocate controls in CompileSymbols\n");
2183 ACTION("Symbols not added\n");
2187 /* now copy info into xkb. */
2188 ApplyAliases(keymap, &info.aliases);
2190 for (i = 0; i < XkbNumKbdGroups; i++) {
2191 if (info.groupNames[i] != XKB_ATOM_NONE) {
2192 free(UNCONSTIFY(keymap->names->groups[i]));
2193 keymap->names->groups[i] = xkb_atom_strdup(keymap->ctx,
2194 info.groupNames[i]);
2199 darray_foreach(key, info.keys)
2203 darray_foreach(key, info.keys)
2204 if (!CopySymbolsDef(keymap, key, 0))
2207 if (warningLevel > 3) {
2208 for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
2209 if (darray_item(keymap->names->keys, i).name[0] == '\0')
2212 if (XkbKeyNumGroups(keymap, i) < 1) {
2214 memcpy(buf, darray_item(keymap->names->keys, i).name, 4);
2216 WARN("No symbols defined for <%s> (keycode %d)\n", buf, i);
2222 ModMapEntry *mm, *next;
2223 for (mm = info.modMap; mm != NULL; mm = next) {
2224 if (!CopyModMapDef(keymap, mm))
2226 next = (ModMapEntry *) mm->defs.next;
2230 FreeSymbolsInfo(&info);
2234 FreeSymbolsInfo(&info);