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 ********************************************************/
31 #include "parseutils.h"
33 #include <X11/keysym.h>
43 /***====================================================================***/
47 #define RepeatUndefined ~((unsigned)0)
49 #define _Key_Syms (1<<0)
50 #define _Key_Acts (1<<1)
51 #define _Key_Repeat (1<<2)
52 #define _Key_Behavior (1<<3)
53 #define _Key_Type_Dflt (1<<4)
54 #define _Key_Types (1<<5)
55 #define _Key_GroupInfo (1<<6)
56 #define _Key_VModMap (1<<7)
58 typedef struct _KeyInfo
61 unsigned long name; /* the 4 chars of the key name, as long */
62 unsigned char groupInfo;
63 unsigned char typesDefined;
64 unsigned char symsDefined;
65 unsigned char actsDefined;
66 short numLevels[XkbNumKbdGroups];
67 xkb_keysym_t *syms[XkbNumKbdGroups];
68 union xkb_action *acts[XkbNumKbdGroups];
69 xkb_atom_t types[XkbNumKbdGroups];
71 struct xkb_behavior behavior;
72 unsigned short vmodmap;
73 unsigned long allowNone;
78 * Init the given key info to sane values.
81 InitKeyInfo(KeyInfo * info)
84 static char dflt[4] = "*";
86 info->defs.defined = 0;
87 info->defs.fileID = 0;
88 info->defs.merge = MergeOverride;
89 info->defs.next = NULL;
90 info->name = KeyNameToLong(dflt);
92 info->typesDefined = info->symsDefined = info->actsDefined = 0;
93 for (i = 0; i < XkbNumKbdGroups; i++)
95 info->numLevels[i] = 0;
96 info->types[i] = None;
100 info->dfltType = None;
101 info->behavior.type = XkbKB_Default;
102 info->behavior.data = 0;
104 info->repeat = RepeatUndefined;
109 * Free memory associated with this key info and reset to sane values.
112 FreeKeyInfo(KeyInfo * info)
116 info->defs.defined = 0;
117 info->defs.fileID = 0;
118 info->defs.merge = MergeOverride;
119 info->defs.next = NULL;
121 info->typesDefined = info->symsDefined = info->actsDefined = 0;
122 for (i = 0; i < XkbNumKbdGroups; i++)
124 info->numLevels[i] = 0;
125 info->types[i] = None;
127 info->syms[i] = NULL;
129 info->acts[i] = NULL;
131 info->dfltType = None;
132 info->behavior.type = XkbKB_Default;
133 info->behavior.data = 0;
135 info->repeat = RepeatUndefined;
140 * Copy old into new, optionally reset old to 0.
141 * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
142 * newly allocated and new points to the new memory areas.
145 CopyKeyInfo(KeyInfo * old, KeyInfo * new, Bool clearOld)
150 new->defs.next = NULL;
153 for (i = 0; i < XkbNumKbdGroups; i++)
155 old->numLevels[i] = 0;
163 for (i = 0; i < XkbNumKbdGroups; i++)
165 width = new->numLevels[i];
166 if (old->syms[i] != NULL)
168 new->syms[i] = uTypedCalloc(width, xkb_keysym_t);
172 new->numLevels[i] = 0;
175 memcpy(new->syms[i], old->syms[i], width * sizeof(xkb_keysym_t));
177 if (old->acts[i] != NULL)
179 new->acts[i] = uTypedCalloc(width, union xkb_action);
185 memcpy(new->acts[i], old->acts[i],
186 width * sizeof(union xkb_action));
193 /***====================================================================***/
195 typedef struct _ModMapEntry
202 unsigned long keyName;
207 #define SYMBOLS_INIT_SIZE 110
208 #define SYMBOLS_CHUNK 20
209 typedef struct _SymbolsInfo
211 char *name; /* e.g. pc+us+inet(evdev) */
215 unsigned explicit_group;
223 xkb_atom_t groupNames[XkbNumKbdGroups];
230 InitSymbolsInfo(SymbolsInfo * info, struct xkb_desc * xkb)
235 info->explicit_group = 0;
236 info->errorCount = 0;
238 info->merge = MergeOverride;
240 info->szKeys = SYMBOLS_INIT_SIZE;
242 info->keys = uTypedCalloc(SYMBOLS_INIT_SIZE, KeyInfo);
244 for (i = 0; i < XkbNumKbdGroups; i++)
245 info->groupNames[i] = None;
246 InitKeyInfo(&info->dflt);
247 InitVModInfo(&info->vmods, xkb);
249 info->aliases = NULL;
253 FreeSymbolsInfo(SymbolsInfo * info)
260 for (i = 0; i < info->nKeys; i++)
261 FreeKeyInfo(&info->keys[i]);
265 ClearCommonInfo(&info->modMap->defs);
267 ClearAliases(&info->aliases);
268 memset(info, 0, sizeof(SymbolsInfo));
272 ResizeKeyGroup(KeyInfo * key,
273 unsigned group, unsigned atLeastSize, Bool forceActions)
278 tooSmall = (key->numLevels[group] < atLeastSize);
280 newWidth = atLeastSize;
282 newWidth = key->numLevels[group];
284 if ((key->syms[group] == NULL) || tooSmall)
286 key->syms[group] = uTypedRecalloc(key->syms[group],
287 key->numLevels[group], newWidth,
289 if (!key->syms[group])
292 if (((forceActions) && (tooSmall || (key->acts[group] == NULL))) ||
293 (tooSmall && (key->acts[group] != NULL)))
295 key->acts[group] = uTypedRecalloc(key->acts[group],
296 key->numLevels[group], newWidth,
298 if (!key->acts[group])
301 key->numLevels[group] = newWidth;
306 MergeKeyGroups(SymbolsInfo * info,
307 KeyInfo * into, KeyInfo * from, unsigned group)
309 xkb_keysym_t *resultSyms;
310 union xkb_action *resultActs;
313 Bool report, clobber;
315 clobber = (from->defs.merge != MergeAugment);
316 report = (warningLevel > 9) ||
317 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
318 if (into->numLevels[group] >= from->numLevels[group])
320 resultSyms = into->syms[group];
321 resultActs = into->acts[group];
322 resultWidth = into->numLevels[group];
326 resultSyms = from->syms[group];
327 resultActs = from->acts[group];
328 resultWidth = from->numLevels[group];
330 if (resultSyms == NULL)
332 resultSyms = uTypedCalloc(resultWidth, xkb_keysym_t);
335 WSGO("Could not allocate symbols for group merge\n");
336 ACTION("Group %d of key %s not merged\n", group,
337 longText(into->name));
341 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
343 resultActs = uTypedCalloc(resultWidth, union xkb_action);
346 WSGO("Could not allocate actions for group merge\n");
347 ACTION("Group %d of key %s not merged\n", group,
348 longText(into->name));
349 if (resultSyms != into->syms[group] &&
350 resultSyms != from->syms[group])
355 for (i = 0; i < resultWidth; i++)
357 xkb_keysym_t fromSym, toSym;
358 if (from->syms[group] && (i < from->numLevels[group]))
359 fromSym = from->syms[group][i];
362 if (into->syms[group] && (i < into->numLevels[group]))
363 toSym = into->syms[group][i];
366 if ((fromSym == NoSymbol) || (fromSym == toSym))
367 resultSyms[i] = toSym;
368 else if (toSym == NoSymbol)
369 resultSyms[i] = fromSym;
372 xkb_keysym_t use, ignore;
386 ("Multiple symbols for level %d/group %d on key %s\n",
387 i + 1, group + 1, longText(into->name));
388 ACTION("Using %s, ignoring %s\n",
389 XkbcKeysymText(use), XkbcKeysymText(ignore));
393 if (resultActs != NULL)
395 union xkb_action *fromAct, *toAct;
396 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
397 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
398 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
401 resultActs[i] = *toAct;
403 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
404 && (fromAct != NULL))
406 resultActs[i] = *fromAct;
410 union xkb_action *use, *ignore;
424 ("Multiple actions for level %d/group %d on key %s\n",
425 i + 1, group + 1, longText(into->name));
426 ACTION("Using %s, ignoring %s\n",
427 XkbcActionTypeText(use->type),
428 XkbcActionTypeText(ignore->type));
431 resultActs[i] = *use;
435 if (resultSyms != into->syms[group])
436 free(into->syms[group]);
437 if (resultSyms != from->syms[group])
438 free(from->syms[group]);
439 if (resultActs != into->acts[group])
440 free(into->acts[group]);
441 if (resultActs != from->acts[group])
442 free(from->acts[group]);
443 into->numLevels[group] = resultWidth;
444 into->syms[group] = resultSyms;
445 from->syms[group] = NULL;
446 into->acts[group] = resultActs;
447 from->acts[group] = NULL;
448 into->symsDefined |= (1 << group);
449 from->symsDefined &= ~(1 << group);
450 into->actsDefined |= (1 << group);
451 from->actsDefined &= ~(1 << group);
456 MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from)
459 unsigned collide = 0;
462 if (from->defs.merge == MergeReplace)
464 for (i = 0; i < XkbNumKbdGroups; i++)
466 if (into->numLevels[i] != 0)
473 memset(from, 0, sizeof(KeyInfo));
476 report = ((warningLevel > 9) ||
477 ((into->defs.fileID == from->defs.fileID)
478 && (warningLevel > 0)));
479 for (i = 0; i < XkbNumKbdGroups; i++)
481 if (from->numLevels[i] > 0)
483 if (into->numLevels[i] == 0)
485 into->numLevels[i] = from->numLevels[i];
486 into->syms[i] = from->syms[i];
487 into->acts[i] = from->acts[i];
488 into->symsDefined |= (1 << i);
489 from->syms[i] = NULL;
490 from->acts[i] = NULL;
491 from->numLevels[i] = 0;
492 from->symsDefined &= ~(1 << i);
494 into->defs.defined |= _Key_Syms;
496 into->defs.defined |= _Key_Acts;
503 collide |= _Key_Syms;
505 collide |= _Key_Acts;
507 MergeKeyGroups(info, into, from, (unsigned) i);
510 if (from->types[i] != None)
512 if ((into->types[i] != None) && (report) &&
513 (into->types[i] != from->types[i]))
515 xkb_atom_t use, ignore;
516 collide |= _Key_Types;
517 if (from->defs.merge != MergeAugment)
519 use = from->types[i];
520 ignore = into->types[i];
524 use = into->types[i];
525 ignore = from->types[i];
528 ("Multiple definitions for group %d type of key %s\n",
529 i, longText(into->name));
530 ACTION("Using %s, ignoring %s\n",
532 XkbcAtomText(ignore));
534 if ((from->defs.merge != MergeAugment)
535 || (into->types[i] == None))
537 into->types[i] = from->types[i];
541 if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
543 into->behavior = from->behavior;
544 into->defs.defined |= _Key_Behavior;
546 if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
548 into->vmodmap = from->vmodmap;
549 into->defs.defined |= _Key_VModMap;
551 if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
553 into->repeat = from->repeat;
554 into->defs.defined |= _Key_Repeat;
556 if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
558 into->dfltType = from->dfltType;
559 into->defs.defined |= _Key_Type_Dflt;
561 if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
563 into->groupInfo = from->groupInfo;
564 into->defs.defined |= _Key_GroupInfo;
568 WARN("Symbol map for key %s redefined\n",
569 longText(into->name));
570 ACTION("Using %s definition for conflicting fields\n",
571 (from->defs.merge == MergeAugment ? "first" : "last"));
577 AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_desc * xkb)
580 unsigned long real_name;
582 for (i = 0; i < info->nKeys; i++)
584 if (info->keys[i].name == key->name)
585 return MergeKeys(info, &info->keys[i], key);
587 if (FindKeyNameForAlias(xkb, key->name, &real_name))
589 for (i = 0; i < info->nKeys; i++)
591 if (info->keys[i].name == real_name)
592 return MergeKeys(info, &info->keys[i], key);
595 if (info->nKeys >= info->szKeys)
597 info->szKeys += SYMBOLS_CHUNK;
599 uTypedRecalloc(info->keys, info->nKeys, info->szKeys, KeyInfo);
602 WSGO("Could not allocate key symbols descriptions\n");
603 ACTION("Some key symbols definitions may be lost\n");
607 return CopyKeyInfo(key, &info->keys[info->nKeys++], True);
611 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
616 clobber = (new->defs.merge != MergeAugment);
617 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
619 if (new->haveSymbol && mm->haveSymbol
620 && (new->u.keySym == mm->u.keySym))
622 unsigned use, ignore;
623 if (mm->modifier != new->modifier)
628 ignore = mm->modifier;
633 ignore = new->modifier;
636 ("%s added to symbol map for multiple modifiers\n",
637 XkbcKeysymText(new->u.keySym));
638 ACTION("Using %s, ignoring %s.\n",
639 XkbcModIndexText(use),
640 XkbcModIndexText(ignore));
645 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
646 (new->u.keyName == mm->u.keyName))
648 unsigned use, ignore;
649 if (mm->modifier != new->modifier)
654 ignore = mm->modifier;
659 ignore = new->modifier;
661 ERROR("Key %s added to map for multiple modifiers\n",
662 longText(new->u.keyName));
663 ACTION("Using %s, ignoring %s.\n",
664 XkbcModIndexText(use),
665 XkbcModIndexText(ignore));
671 mm = uTypedAlloc(ModMapEntry);
674 WSGO("Could not allocate modifier map entry\n");
675 ACTION("Modifier map for %s will be incomplete\n",
676 XkbcModIndexText(new->modifier));
680 mm->defs.next = &info->modMap->defs;
685 /***====================================================================***/
688 MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
689 unsigned merge, struct xkb_desc * xkb)
694 if (from->errorCount > 0)
696 into->errorCount += from->errorCount;
699 if (into->name == NULL)
701 into->name = from->name;
704 for (i = 0; i < XkbNumKbdGroups; i++)
706 if (from->groupNames[i] != None)
708 if ((merge != MergeAugment) || (into->groupNames[i] == None))
709 into->groupNames[i] = from->groupNames[i];
712 for (i = 0, key = from->keys; i < from->nKeys; i++, key++)
714 if (merge != MergeDefault)
715 key->defs.merge = merge;
716 if (!AddKeySymbols(into, key, xkb))
719 if (from->modMap != NULL)
721 ModMapEntry *mm, *next;
722 for (mm = from->modMap; mm != NULL; mm = next)
724 if (merge != MergeDefault)
725 mm->defs.merge = merge;
726 if (!AddModMapEntry(into, mm))
728 next = (ModMapEntry *) mm->defs.next;
733 if (!MergeAliases(&into->aliases, &from->aliases, merge))
737 typedef void (*FileHandler) (XkbFile * /* rtrn */ ,
738 struct xkb_desc * /* xkb */ ,
739 unsigned /* merge */ ,
740 SymbolsInfo * /* included */
744 HandleIncludeSymbols(IncludeStmt * stmt,
745 struct xkb_desc * xkb, SymbolsInfo * info, FileHandler hndlr)
749 SymbolsInfo included;
753 if ((stmt->file == NULL) && (stmt->map == NULL))
757 memset(info, 0, sizeof(SymbolsInfo));
759 else if (ProcessIncludeFile(stmt, XkmSymbolsIndex, &rtrn, &newMerge))
761 InitSymbolsInfo(&included, xkb);
762 included.fileID = included.dflt.defs.fileID = rtrn->id;
763 included.merge = included.dflt.defs.merge = MergeOverride;
766 included.explicit_group = atoi(stmt->modifier) - 1;
770 included.explicit_group = info->explicit_group;
772 (*hndlr) (rtrn, xkb, MergeOverride, &included);
773 if (stmt->stmt != NULL)
776 included.name = stmt->stmt;
783 info->errorCount += 10;
786 if ((stmt->next != NULL) && (included.errorCount < 1))
790 SymbolsInfo next_incl;
792 for (next = stmt->next; next != NULL; next = next->next)
794 if ((next->file == NULL) && (next->map == NULL))
797 MergeIncludedSymbols(&included, info, next->merge, xkb);
798 FreeSymbolsInfo(info);
800 else if (ProcessIncludeFile(next, XkmSymbolsIndex, &rtrn, &op))
802 InitSymbolsInfo(&next_incl, xkb);
803 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
804 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
807 next_incl.explicit_group = atoi(next->modifier) - 1;
811 next_incl.explicit_group = info->explicit_group;
813 (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
814 MergeIncludedSymbols(&included, &next_incl, op, xkb);
815 FreeSymbolsInfo(&next_incl);
820 info->errorCount += 10;
829 MergeIncludedSymbols(info, &included, newMerge, xkb);
830 FreeSymbolsInfo(&included);
832 return (info->errorCount == 0);
839 GetGroupIndex(KeyInfo * key,
840 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
850 if (arrayNdx == NULL)
855 defined = key->symsDefined;
857 defined = key->actsDefined;
859 for (i = 0; i < XkbNumKbdGroups; i++)
861 if ((defined & (1 << i)) == 0)
867 ERROR("Too many groups of %s for key %s (max %d)\n", name,
868 longText(key->name), XkbNumKbdGroups + 1);
869 ACTION("Ignoring %s defined for extra groups\n", name);
872 if (!ExprResolveGroup(arrayNdx, &tmp))
874 ERROR("Illegal group index for %s of key %s\n", name,
875 longText(key->name));
876 ACTION("Definition with non-integer array index ignored\n");
879 *ndx_rtrn = tmp.uval - 1;
884 AddSymbolsToKey(KeyInfo * key,
885 struct xkb_desc * xkb,
887 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
892 if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx))
896 key->symsDefined |= (1 << ndx);
899 if (value->op != ExprKeysymList)
901 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
902 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
903 longText(key->name));
906 if (key->syms[ndx] != NULL)
908 ERROR("Symbols for key %s, group %d already defined\n",
909 longText(key->name), ndx + 1);
910 ACTION("Ignoring duplicate definition\n");
913 nSyms = value->value.list.nSyms;
914 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
915 (!ResizeKeyGroup(key, ndx, nSyms, False)))
917 WSGO("Could not resize group %d of key %s to contain %d levels\n",
918 ndx + 1, longText(key->name), nSyms);
919 ACTION("Symbols lost\n");
922 key->symsDefined |= (1 << ndx);
923 for (i = 0; i < nSyms; i++) {
924 if (!LookupKeysym(value->value.list.syms[i], &key->syms[ndx][i])) {
925 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
926 value->value.list.syms[i], longText(key->name), ndx + 1,
927 XkbcAtomText(info->groupNames[ndx]), nSyms);
928 key->syms[ndx][i] = NoSymbol;
931 for (i = key->numLevels[ndx] - 1;
932 (i >= 0) && (key->syms[ndx][i] == NoSymbol); i--)
934 key->numLevels[ndx]--;
940 AddActionsToKey(KeyInfo * key,
941 struct xkb_desc * xkb,
943 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
948 struct xkb_any_action *toAct;
950 if (!GetGroupIndex(key, arrayNdx, ACTIONS, &ndx))
955 key->actsDefined |= (1 << ndx);
958 if (value->op != ExprActionList)
960 WSGO("Bad expression type (%d) for action list value\n", value->op);
961 ACTION("Ignoring actions for group %d of %s\n", ndx,
962 longText(key->name));
965 if (key->acts[ndx] != NULL)
967 WSGO("Actions for key %s, group %d already defined\n",
968 longText(key->name), ndx);
971 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
973 act = (ExprDef *) act->common.next;
977 WSGO("Action list but not actions in AddActionsToKey\n");
980 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
981 (!ResizeKeyGroup(key, ndx, nActs, True)))
983 WSGO("Could not resize group %d of key %s\n", ndx,
984 longText(key->name));
985 ACTION("Actions lost\n");
988 key->actsDefined |= (1 << ndx);
990 toAct = (struct xkb_any_action *) key->acts[ndx];
991 act = value->value.child;
992 for (i = 0; i < nActs; i++, toAct++)
994 if (!HandleActionDef(act, xkb, toAct, MergeOverride, info->action))
996 ERROR("Illegal action definition for %s\n",
997 longText(key->name));
998 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1000 act = (ExprDef *) act->common.next;
1005 static const LookupEntry lockingEntries[] = {
1006 {"true", XkbKB_Lock},
1007 {"yes", XkbKB_Lock},
1009 {"false", XkbKB_Default},
1010 {"no", XkbKB_Default},
1011 {"off", XkbKB_Default},
1012 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1016 static const LookupEntry repeatEntries[] = {
1017 {"true", RepeatYes},
1020 {"false", RepeatNo},
1023 {"default", RepeatUndefined},
1028 SetSymbolsField(KeyInfo * key,
1029 struct xkb_desc * xkb,
1031 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
1036 if (uStrCaseCmp(field, "type") == 0)
1039 if ((!ExprResolveString(value, &tmp))
1040 && (warningLevel > 0))
1042 WARN("The type field of a key symbol map must be a string\n");
1043 ACTION("Ignoring illegal type definition\n");
1045 if (arrayNdx == NULL)
1047 key->dfltType = xkb_intern_atom(tmp.str);
1048 key->defs.defined |= _Key_Type_Dflt;
1050 else if (!ExprResolveGroup(arrayNdx, &ndx))
1052 ERROR("Illegal group index for type of key %s\n",
1053 longText(key->name));
1054 ACTION("Definition with non-integer array index ignored\n");
1060 key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
1061 key->typesDefined |= (1 << (ndx.uval - 1));
1065 else if (uStrCaseCmp(field, "symbols") == 0)
1066 return AddSymbolsToKey(key, xkb, field, arrayNdx, value, info);
1067 else if (uStrCaseCmp(field, "actions") == 0)
1068 return AddActionsToKey(key, xkb, field, arrayNdx, value, info);
1069 else if ((uStrCaseCmp(field, "vmods") == 0) ||
1070 (uStrCaseCmp(field, "virtualmods") == 0) ||
1071 (uStrCaseCmp(field, "virtualmodifiers") == 0))
1073 ok = ExprResolveVModMask(value, &tmp, xkb);
1076 key->vmodmap = (tmp.uval >> 8);
1077 key->defs.defined |= _Key_VModMap;
1081 ERROR("Expected a virtual modifier mask, found %s\n",
1082 exprOpText(value->op));
1083 ACTION("Ignoring virtual modifiers definition for key %s\n",
1084 longText(key->name));
1087 else if ((uStrCaseCmp(field, "locking") == 0)
1088 || (uStrCaseCmp(field, "lock") == 0)
1089 || (uStrCaseCmp(field, "locks") == 0))
1091 ok = ExprResolveEnum(value, &tmp, lockingEntries);
1093 key->behavior.type = tmp.uval;
1094 key->defs.defined |= _Key_Behavior;
1096 else if ((uStrCaseCmp(field, "radiogroup") == 0) ||
1097 (uStrCaseCmp(field, "permanentradiogroup") == 0) ||
1098 (uStrCaseEqual(field, "allownone")))
1100 ERROR("Radio groups not supported\n");
1101 ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1104 else if (uStrCasePrefix("overlay", field) ||
1105 uStrCasePrefix("permanentoverlay", field))
1107 ERROR("Overlays not supported\n");
1108 ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1110 else if ((uStrCaseCmp(field, "repeating") == 0) ||
1111 (uStrCaseCmp(field, "repeats") == 0) ||
1112 (uStrCaseCmp(field, "repeat") == 0))
1114 ok = ExprResolveEnum(value, &tmp, repeatEntries);
1117 ERROR("Illegal repeat setting for %s\n",
1118 longText(key->name));
1119 ACTION("Non-boolean repeat setting ignored\n");
1122 key->repeat = tmp.uval;
1123 key->defs.defined |= _Key_Repeat;
1125 else if ((uStrCaseCmp(field, "groupswrap") == 0) ||
1126 (uStrCaseCmp(field, "wrapgroups") == 0))
1128 ok = ExprResolveBoolean(value, &tmp);
1131 ERROR("Illegal groupsWrap setting for %s\n",
1132 longText(key->name));
1133 ACTION("Non-boolean value ignored\n");
1137 key->groupInfo = XkbWrapIntoRange;
1139 key->groupInfo = XkbClampIntoRange;
1140 key->defs.defined |= _Key_GroupInfo;
1142 else if ((uStrCaseCmp(field, "groupsclamp") == 0) ||
1143 (uStrCaseCmp(field, "clampgroups") == 0))
1145 ok = ExprResolveBoolean(value, &tmp);
1148 ERROR("Illegal groupsClamp setting for %s\n",
1149 longText(key->name));
1150 ACTION("Non-boolean value ignored\n");
1154 key->groupInfo = XkbClampIntoRange;
1156 key->groupInfo = XkbWrapIntoRange;
1157 key->defs.defined |= _Key_GroupInfo;
1159 else if ((uStrCaseCmp(field, "groupsredirect") == 0) ||
1160 (uStrCaseCmp(field, "redirectgroups") == 0))
1162 if (!ExprResolveGroup(value, &tmp))
1164 ERROR("Illegal group index for redirect of key %s\n",
1165 longText(key->name));
1166 ACTION("Definition with non-integer group ignored\n");
1170 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1171 key->defs.defined |= _Key_GroupInfo;
1175 ERROR("Unknown field %s in a symbol interpretation\n", field);
1176 ACTION("Definition ignored\n");
1183 SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
1185 ExprResult tmp, name;
1187 if ((arrayNdx == NULL) && (warningLevel > 0))
1189 WARN("You must specify an index when specifying a group name\n");
1190 ACTION("Group name definition without array subscript ignored\n");
1193 if (!ExprResolveGroup(arrayNdx, &tmp))
1195 ERROR("Illegal index in group name definition\n");
1196 ACTION("Definition with non-integer array index ignored\n");
1199 if (!ExprResolveString(value, &name))
1201 ERROR("Group name must be a string\n");
1202 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1205 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1206 xkb_intern_atom(name.str);
1213 HandleSymbolsVar(VarDef * stmt, struct xkb_desc * xkb, SymbolsInfo * info)
1215 ExprResult elem, field, tmp;
1219 if (ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx) == 0)
1220 return 0; /* internal error, already reported */
1221 if (elem.str && (uStrCaseCmp(elem.str, "key") == 0))
1223 ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx,
1226 else if ((elem.str == NULL) && ((uStrCaseCmp(field.str, "name") == 0) ||
1227 (uStrCaseCmp(field.str, "groupname") ==
1230 ret = SetGroupName(info, arrayNdx, stmt->value);
1232 else if ((elem.str == NULL)
1233 && ((uStrCaseCmp(field.str, "groupswrap") == 0)
1234 || (uStrCaseCmp(field.str, "wrapgroups") == 0)))
1236 if (!ExprResolveBoolean(stmt->value, &tmp))
1238 ERROR("Illegal setting for global groupsWrap\n");
1239 ACTION("Non-boolean value ignored\n");
1244 info->groupInfo = XkbWrapIntoRange;
1246 info->groupInfo = XkbClampIntoRange;
1250 else if ((elem.str == NULL)
1251 && ((uStrCaseCmp(field.str, "groupsclamp") == 0)
1252 || (uStrCaseCmp(field.str, "clampgroups") == 0)))
1254 if (!ExprResolveBoolean(stmt->value, &tmp))
1256 ERROR("Illegal setting for global groupsClamp\n");
1257 ACTION("Non-boolean value ignored\n");
1262 info->groupInfo = XkbClampIntoRange;
1264 info->groupInfo = XkbWrapIntoRange;
1268 else if ((elem.str == NULL)
1269 && ((uStrCaseCmp(field.str, "groupsredirect") == 0)
1270 || (uStrCaseCmp(field.str, "redirectgroups") == 0)))
1272 if (!ExprResolveGroup(stmt->value, &tmp))
1274 ERROR("Illegal group index for global groupsRedirect\n");
1275 ACTION("Definition with non-integer group ignored\n");
1279 info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1284 else if ((elem.str == NULL) && (uStrCaseCmp(field.str, "allownone") == 0))
1286 ERROR("Radio groups not supported\n");
1287 ACTION("Ignoring \"allow none\" specification\n");
1291 ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value,
1301 HandleSymbolsBody(VarDef * def,
1302 struct xkb_desc * xkb, KeyInfo * key, SymbolsInfo * info)
1305 ExprResult tmp, field;
1308 for (; def != NULL; def = (VarDef *) def->common.next)
1310 if ((def->name) && (def->name->type == ExprFieldRef))
1312 ok = HandleSymbolsVar(def, xkb, info);
1317 if (def->name == NULL)
1319 if ((def->value == NULL)
1320 || (def->value->op == ExprKeysymList))
1321 field.str = strdup("symbols");
1323 field.str = strdup("actions");
1328 ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
1331 ok = SetSymbolsField(key, xkb, field.str, arrayNdx,
1340 SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
1342 unsigned group = info->explicit_group;
1347 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1350 WARN("For the map %s an explicit group specified\n", info->name);
1351 WARN("but key %s has more than one group defined\n",
1352 longText(key->name));
1353 ACTION("All groups except first one will be ignored\n");
1354 for (i = 1; i < XkbNumKbdGroups; i++)
1356 key->numLevels[i] = 0;
1358 key->syms[i] = NULL;
1360 key->acts[i] = NULL;
1364 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1366 key->numLevels[group] = key->numLevels[0];
1367 key->numLevels[0] = 0;
1368 key->syms[group] = key->syms[0];
1369 key->syms[0] = NULL;
1370 key->acts[group] = key->acts[0];
1371 key->acts[0] = NULL;
1372 key->types[group] = key->types[0];
1378 HandleSymbolsDef(SymbolsDef * stmt,
1379 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1384 CopyKeyInfo(&info->dflt, &key, False);
1385 key.defs.merge = stmt->merge;
1386 key.name = KeyNameToLong(stmt->keyName);
1387 if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
1393 if (!SetExplicitGroup(info, &key))
1399 if (!AddKeySymbols(info, &key, xkb))
1408 HandleModMapDef(ModMapDef * def,
1409 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1416 if (!LookupModIndex(NULL, def->modifier, TypeInt, &rtrn))
1418 ERROR("Illegal modifier map definition\n");
1419 ACTION("Ignoring map for non-modifier \"%s\"\n",
1420 XkbcAtomText(def->modifier));
1424 tmp.modifier = rtrn.uval;
1425 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1427 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1429 tmp.haveSymbol = False;
1430 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1432 else if (ExprResolveKeySym(key, &rtrn))
1434 tmp.haveSymbol = True;
1435 tmp.u.keySym = rtrn.uval;
1439 ERROR("Modmap entries may contain only key names or keysyms\n");
1440 ACTION("Illegal definition for %s modifier ignored\n",
1441 XkbcModIndexText(tmp.modifier));
1445 ok = AddModMapEntry(info, &tmp) && ok;
1451 HandleSymbolsFile(XkbFile * file,
1452 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1457 info->name = _XkbDupString(file->name);
1461 switch (stmt->stmtType)
1464 if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info,
1468 case StmtSymbolsDef:
1469 if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, merge, info))
1473 if (!HandleSymbolsVar((VarDef *) stmt, xkb, info))
1477 if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
1481 ERROR("Interpretation files may not include other types\n");
1482 ACTION("Ignoring definition of symbol interpretation\n");
1485 case StmtKeycodeDef:
1486 ERROR("Interpretation files may not include other types\n");
1487 ACTION("Ignoring definition of key name\n");
1491 if (!HandleModMapDef((ModMapDef *) stmt, xkb, merge, info))
1495 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1500 if (info->errorCount > 10)
1503 ERROR("Too many errors\n");
1505 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1512 FindKeyForSymbol(struct xkb_desc * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn)
1521 for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++)
1523 if (j < (int) XkbKeyNumSyms(xkb, i))
1526 if (XkbKeySym(xkb, i, j) == sym)
1540 * Find the given name in the xkb->map->types and return its index.
1542 * @param atom The atom to search for.
1543 * @param type_rtrn Set to the index of the name if found.
1545 * @return True if found, False otherwise.
1548 FindNamedType(struct xkb_desc * xkb, xkb_atom_t atom, unsigned *type_rtrn)
1551 const char *name = XkbcAtomText(atom);
1553 if (xkb && xkb->map && xkb->map->types)
1555 for (n = 0; n < xkb->map->num_types; n++)
1557 if (strcmp(xkb->map->types[n].name, name) == 0)
1568 * Assign a type to the given sym and return the Atom for the type assigned.
1571 * - ONE_LEVEL for width 0/1
1572 * - ALPHABETIC for 2 shift levels, with lower/upercase
1573 * - KEYPAD for keypad keys.
1574 * - TWO_LEVEL for other 2 shift level keys.
1575 * and the same for four level keys.
1577 * @param width Number of sysms in syms.
1578 * @param syms The keysyms for the given key (must be size width).
1579 * @param typeNameRtrn Set to the Atom of the type name.
1581 * @returns True if a type could be found, False otherwise.
1584 FindAutomaticType(int width, xkb_keysym_t * syms, xkb_atom_t * typeNameRtrn,
1588 if ((width == 1) || (width == 0))
1590 *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
1593 else if (width == 2)
1595 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1597 *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
1599 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1601 *typeNameRtrn = xkb_intern_atom("KEYPAD");
1606 *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
1610 else if (width <= 4)
1612 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1613 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1615 xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
1617 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
1619 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1620 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
1622 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
1623 /* XXX: why not set autoType here? */
1625 return ((width >= 0) && (width <= 4));
1629 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1630 * groups, and reduce to one group if all groups are identical anyway.
1633 PrepareKeyDef(KeyInfo * key)
1635 int i, j, width, defined, lastGroup;
1638 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1639 /* get highest group number */
1640 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1642 if (defined & (1 << i))
1650 /* If there are empty groups between non-empty ones fill them with data */
1651 /* from the first group. */
1652 /* We can make a wrong assumption here. But leaving gaps is worse. */
1653 for (i = lastGroup; i > 0; i--)
1655 if (defined & (1 << i))
1657 width = key->numLevels[0];
1658 if (key->typesDefined & 1)
1660 for (j = 0; j < width; j++)
1662 key->types[i] = key->types[0];
1664 key->typesDefined |= 1 << i;
1666 if ((key->actsDefined & 1) && key->acts[0])
1668 key->acts[i] = uTypedCalloc(width, union xkb_action);
1669 if (key->acts[i] == NULL)
1671 memcpy(key->acts[i], key->acts[0],
1672 width * sizeof(union xkb_action));
1673 key->actsDefined |= 1 << i;
1675 if ((key->symsDefined & 1) && key->syms[0])
1677 key->syms[i] = uTypedCalloc(width, xkb_keysym_t);
1678 if (key->syms[i] == NULL)
1680 memcpy(key->syms[i], key->syms[0], width * sizeof(xkb_keysym_t));
1681 key->symsDefined |= 1 << i;
1685 key->numLevels[i] = key->numLevels[0];
1688 /* If all groups are completely identical remove them all */
1689 /* exept the first one. */
1691 for (i = lastGroup; i > 0; i--)
1693 if ((key->numLevels[i] != key->numLevels[0]) ||
1694 (key->types[i] != key->types[0]))
1699 if ((key->syms[i] != key->syms[0]) &&
1700 (key->syms[i] == NULL || key->syms[0] == NULL ||
1701 memcmp(key->syms[i], key->syms[0],
1702 sizeof(xkb_keysym_t) * key->numLevels[0])))
1707 if ((key->acts[i] != key->acts[0]) &&
1708 (key->acts[i] == NULL || key->acts[0] == NULL ||
1709 memcmp(key->acts[i], key->acts[0],
1710 sizeof(union xkb_action) * key->numLevels[0])))
1718 for (i = lastGroup; i > 0; i--)
1720 key->numLevels[i] = 0;
1722 key->syms[i] = NULL;
1724 key->acts[i] = NULL;
1727 key->symsDefined &= 1;
1728 key->actsDefined &= 1;
1729 key->typesDefined &= 1;
1734 * Copy the KeyInfo into the keyboard description.
1736 * This function recurses.
1739 CopySymbolsDef(struct xkb_desc * xkb, KeyInfo *key, int start_from)
1743 unsigned width, tmp, nGroups;
1744 struct xkb_key_type * type;
1745 Bool haveActions, autoType, useAlias;
1746 xkb_keysym_t *outSyms;
1747 union xkb_action *outActs;
1748 unsigned types[XkbNumKbdGroups];
1750 useAlias = (start_from == 0);
1752 /* get the keycode for the key. */
1753 if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb),
1756 if ((start_from == 0) && (warningLevel >= 5))
1758 WARN("Key %s not found in keycodes\n", longText(key->name));
1759 ACTION("Symbols ignored\n");
1764 haveActions = False;
1765 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1767 if (((i + 1) > nGroups)
1768 && (((key->symsDefined | key->actsDefined) & (1 << i))
1769 || (key->typesDefined) & (1 << i)))
1774 /* Assign the type to the key, if it is missing. */
1775 if (key->types[i] == None)
1777 if (key->dfltType != None)
1778 key->types[i] = key->dfltType;
1779 else if (FindAutomaticType(key->numLevels[i], key->syms[i],
1780 &key->types[i], &autoType))
1785 if (warningLevel >= 5)
1787 WARN("No automatic type for %d symbols\n",
1788 (unsigned int) key->numLevels[i]);
1789 ACTION("Using %s for the %s key (keycode %d)\n",
1790 XkbcAtomText(key->types[i]),
1791 longText(key->name), kc);
1795 if (FindNamedType(xkb, key->types[i], &types[i]))
1797 if (!autoType || key->numLevels[i] > 2)
1798 xkb->server->explicit[kc] |= (1 << i);
1802 if (warningLevel >= 3)
1804 WARN("Type \"%s\" is not defined\n",
1805 XkbcAtomText(key->types[i]));
1806 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
1807 longText(key->name), kc);
1809 types[i] = XkbTwoLevelIndex;
1811 /* if the type specifies less syms than the key has, shrink the key */
1812 type = &xkb->map->types[types[i]];
1813 if (type->num_levels < key->numLevels[i])
1815 if (warningLevel > 0)
1817 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
1818 type->name, type->num_levels,
1819 XkbcAtomText(key->name), key->numLevels[i]);
1820 ACTION("Ignoring extra symbols\n");
1822 key->numLevels[i] = type->num_levels;
1824 if (key->numLevels[i] > width)
1825 width = key->numLevels[i];
1826 if (type->num_levels > width)
1827 width = type->num_levels;
1830 /* width is now the largest width found */
1832 i = width * nGroups;
1833 outSyms = XkbcResizeKeySyms(xkb, kc, i);
1834 if (outSyms == NULL)
1836 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
1837 longText(key->name), kc);
1842 outActs = XkbcResizeKeyActions(xkb, kc, i);
1843 if (outActs == NULL)
1845 WSGO("Could not enlarge actions for %s (key %d)\n",
1846 longText(key->name), kc);
1849 xkb->server->explicit[kc] |= XkbExplicitInterpretMask;
1853 if (key->defs.defined & _Key_GroupInfo)
1856 i = xkb->map->key_sym_map[kc].group_info;
1858 xkb->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
1859 xkb->map->key_sym_map[kc].width = width;
1860 for (i = 0; i < nGroups; i++)
1862 /* assign kt_index[i] to the index of the type in map->types.
1863 * kt_index[i] may have been set by a previous run (if we have two
1864 * layouts specified). Let's not overwrite it with the ONE_LEVEL
1865 * default group if we dont even have keys for this group anyway.
1867 * FIXME: There should be a better fix for this.
1869 if (key->numLevels[i])
1870 xkb->map->key_sym_map[kc].kt_index[i] = types[i];
1871 if (key->syms[i] != NULL)
1873 /* fill key to "width" symbols*/
1874 for (tmp = 0; tmp < width; tmp++)
1876 if (tmp < key->numLevels[i])
1877 outSyms[tmp] = key->syms[i][tmp];
1879 outSyms[tmp] = NoSymbol;
1880 if ((outActs != NULL) && (key->acts[i] != NULL))
1882 if (tmp < key->numLevels[i])
1883 outActs[tmp] = key->acts[i][tmp];
1885 outActs[tmp].type = XkbSA_NoAction;
1893 switch (key->behavior.type & XkbKB_OpMask)
1898 xkb->server->behaviors[kc] = key->behavior;
1899 xkb->server->explicit[kc] |= XkbExplicitBehaviorMask;
1902 if (key->defs.defined & _Key_VModMap)
1904 xkb->server->vmodmap[kc] = key->vmodmap;
1905 xkb->server->explicit[kc] |= XkbExplicitVModMapMask;
1907 if (key->repeat != RepeatUndefined)
1909 if (key->repeat == RepeatYes)
1910 xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
1912 xkb->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
1913 xkb->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
1916 if (nGroups > xkb->ctrls->num_groups)
1917 xkb->ctrls->num_groups = nGroups;
1919 /* do the same thing for the next key */
1920 CopySymbolsDef(xkb, key, kc + 1);
1925 CopyModMapDef(struct xkb_desc * xkb, ModMapEntry *entry)
1929 if ((!entry->haveSymbol)
1932 (xkb, entry->u.keyName, &kc, True, CreateKeyNames(xkb), 0)))
1934 if (warningLevel >= 5)
1936 WARN("Key %s not found in keycodes\n",
1937 longText(entry->u.keyName));
1938 ACTION("Modifier map entry for %s not updated\n",
1939 XkbcModIndexText(entry->modifier));
1943 else if (entry->haveSymbol
1944 && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc)))
1946 if (warningLevel > 5)
1948 WARN("Key \"%s\" not found in symbol map\n",
1949 XkbcKeysymText(entry->u.keySym));
1950 ACTION("Modifier map entry for %s not updated\n",
1951 XkbcModIndexText(entry->modifier));
1955 xkb->map->modmap[kc] |= (1 << entry->modifier);
1960 * Handle the xkb_symbols section of an xkb file.
1962 * @param file The parsed xkb_symbols section of the xkb file.
1963 * @param xkb Handle to the keyboard description to store the symbols in.
1964 * @param merge Merge strategy (e.g. MergeOverride).
1967 CompileSymbols(XkbFile *file, struct xkb_desc * xkb, unsigned merge)
1972 InitSymbolsInfo(&info, xkb);
1973 info.dflt.defs.fileID = file->id;
1974 info.dflt.defs.merge = merge;
1975 HandleSymbolsFile(file, xkb, merge, &info);
1977 if (info.nKeys == 0) {
1978 FreeSymbolsInfo(&info);
1982 if (info.errorCount == 0)
1986 /* alloc memory in the xkb struct */
1987 if (XkbcAllocNames(xkb, XkbGroupNamesMask, 0) != Success)
1989 WSGO("Can not allocate names in CompileSymbols\n");
1990 ACTION("Symbols not added\n");
1993 if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
1996 WSGO("Could not allocate client map in CompileSymbols\n");
1997 ACTION("Symbols not added\n");
2000 if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success)
2002 WSGO("Could not allocate server map in CompileSymbols\n");
2003 ACTION("Symbols not added\n");
2006 if (XkbcAllocControls(xkb, XkbPerKeyRepeatMask) != Success)
2008 WSGO("Could not allocate controls in CompileSymbols\n");
2009 ACTION("Symbols not added\n");
2013 /* now copy info into xkb. */
2015 ApplyAliases(xkb, &info.aliases);
2016 for (i = 0; i < XkbNumKbdGroups; i++)
2018 if (info.groupNames[i] != None)
2020 free((char *) xkb->names->groups[i]);
2021 xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
2025 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2030 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2032 if (!CopySymbolsDef(xkb, key, 0))
2035 if (warningLevel > 3)
2037 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++)
2039 if (xkb->names->keys[i].name[0] == '\0')
2041 if (XkbKeyNumGroups(xkb, i) < 1)
2044 memcpy(buf, xkb->names->keys[i].name, 4);
2047 ("No symbols defined for <%s> (keycode %d)\n",
2054 ModMapEntry *mm, *next;
2055 for (mm = info.modMap; mm != NULL; mm = next)
2057 if (!CopyModMapDef(xkb, mm))
2059 next = (ModMapEntry *) mm->defs.next;
2062 FreeSymbolsInfo(&info);
2066 FreeSymbolsInfo(&info);