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 ********************************************************/
32 #include "parseutils.h"
34 #include <X11/keysym.h>
44 extern uint32_t tok_ONE_LEVEL;
45 extern uint32_t tok_TWO_LEVEL;
46 extern uint32_t tok_KEYPAD;
48 /***====================================================================***/
52 #define RepeatUndefined ~((unsigned)0)
54 #define _Key_Syms (1<<0)
55 #define _Key_Acts (1<<1)
56 #define _Key_Repeat (1<<2)
57 #define _Key_Behavior (1<<3)
58 #define _Key_Type_Dflt (1<<4)
59 #define _Key_Types (1<<5)
60 #define _Key_GroupInfo (1<<6)
61 #define _Key_VModMap (1<<7)
63 typedef struct _KeyInfo
66 unsigned long name; /* the 4 chars of the key name, as long */
67 unsigned char groupInfo;
68 unsigned char typesDefined;
69 unsigned char symsDefined;
70 unsigned char actsDefined;
71 short numLevels[XkbNumKbdGroups];
72 uint32_t *syms[XkbNumKbdGroups];
73 union xkb_action *acts[XkbNumKbdGroups];
74 uint32_t types[XkbNumKbdGroups];
76 struct xkb_behavior behavior;
77 unsigned short vmodmap;
78 unsigned long nameForOverlayKey;
79 unsigned long allowNone;
84 * Init the given key info to sane values.
87 InitKeyInfo(KeyInfo * info)
90 static char dflt[4] = "*";
92 info->defs.defined = 0;
93 info->defs.fileID = 0;
94 info->defs.merge = MergeOverride;
95 info->defs.next = NULL;
96 info->name = KeyNameToLong(dflt);
98 info->typesDefined = info->symsDefined = info->actsDefined = 0;
99 for (i = 0; i < XkbNumKbdGroups; i++)
101 info->numLevels[i] = 0;
102 info->types[i] = None;
103 info->syms[i] = NULL;
104 info->acts[i] = NULL;
106 info->dfltType = None;
107 info->behavior.type = XkbKB_Default;
108 info->behavior.data = 0;
110 info->nameForOverlayKey = 0;
111 info->repeat = RepeatUndefined;
117 * Free memory associated with this key info and reset to sane values.
120 FreeKeyInfo(KeyInfo * info)
124 info->defs.defined = 0;
125 info->defs.fileID = 0;
126 info->defs.merge = MergeOverride;
127 info->defs.next = NULL;
129 info->typesDefined = info->symsDefined = info->actsDefined = 0;
130 for (i = 0; i < XkbNumKbdGroups; i++)
132 info->numLevels[i] = 0;
133 info->types[i] = None;
134 if (info->syms[i] != NULL)
136 info->syms[i] = NULL;
137 if (info->acts[i] != NULL)
139 info->acts[i] = NULL;
141 info->dfltType = None;
142 info->behavior.type = XkbKB_Default;
143 info->behavior.data = 0;
145 info->nameForOverlayKey = 0;
146 info->repeat = RepeatUndefined;
152 * Copy old into new, optionally reset old to 0.
153 * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
154 * newly allocated and new points to the new memory areas.
157 CopyKeyInfo(KeyInfo * old, KeyInfo * new, Bool clearOld)
162 new->defs.next = NULL;
165 for (i = 0; i < XkbNumKbdGroups; i++)
167 old->numLevels[i] = 0;
175 for (i = 0; i < XkbNumKbdGroups; i++)
177 width = new->numLevels[i];
178 if (old->syms[i] != NULL)
180 new->syms[i] = uTypedCalloc(width, uint32_t);
184 new->numLevels[i] = 0;
187 memcpy((char *) new->syms[i], (char *) old->syms[i],
188 width * sizeof(uint32_t));
190 if (old->acts[i] != NULL)
192 new->acts[i] = uTypedCalloc(width, union xkb_action);
198 memcpy((char *) new->acts[i], (char *) old->acts[i],
199 width * sizeof(union xkb_action));
206 /***====================================================================***/
208 typedef struct _ModMapEntry
215 unsigned long keyName;
220 #define SYMBOLS_INIT_SIZE 110
221 #define SYMBOLS_CHUNK 20
222 typedef struct _SymbolsInfo
224 char *name; /* e.g. pc+us+inet(evdev) */
228 unsigned explicit_group;
236 uint32_t groupNames[XkbNumKbdGroups];
243 InitSymbolsInfo(SymbolsInfo * info, struct xkb_desc * xkb)
247 tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
248 tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
249 tok_KEYPAD = xkb_intern_atom("KEYPAD");
251 info->explicit_group = 0;
252 info->errorCount = 0;
254 info->merge = MergeOverride;
256 info->szKeys = SYMBOLS_INIT_SIZE;
258 info->keys = uTypedCalloc(SYMBOLS_INIT_SIZE, KeyInfo);
260 for (i = 0; i < XkbNumKbdGroups; i++)
261 info->groupNames[i] = None;
262 InitKeyInfo(&info->dflt);
263 InitVModInfo(&info->vmods, xkb);
265 info->aliases = NULL;
270 FreeSymbolsInfo(SymbolsInfo * info)
279 for (i = 0; i < info->nKeys; i++)
281 FreeKeyInfo(&info->keys[i]);
288 ClearCommonInfo(&info->modMap->defs);
293 ClearAliases(&info->aliases);
294 info->aliases = NULL;
296 bzero((char *) info, sizeof(SymbolsInfo));
301 ResizeKeyGroup(KeyInfo * key,
302 unsigned group, unsigned atLeastSize, Bool forceActions)
307 tooSmall = (key->numLevels[group] < atLeastSize);
309 newWidth = atLeastSize;
311 newWidth = key->numLevels[group];
313 if ((key->syms[group] == NULL) || tooSmall)
315 key->syms[group] = uTypedRecalloc(key->syms[group],
316 key->numLevels[group], newWidth,
318 if (!key->syms[group])
321 if (((forceActions) && (tooSmall || (key->acts[group] == NULL))) ||
322 (tooSmall && (key->acts[group] != NULL)))
324 key->acts[group] = uTypedRecalloc(key->acts[group],
325 key->numLevels[group], newWidth,
327 if (!key->acts[group])
330 key->numLevels[group] = newWidth;
335 MergeKeyGroups(SymbolsInfo * info,
336 KeyInfo * into, KeyInfo * from, unsigned group)
338 uint32_t *resultSyms;
339 union xkb_action *resultActs;
342 Bool report, clobber;
344 clobber = (from->defs.merge != MergeAugment);
345 report = (warningLevel > 9) ||
346 ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
347 if (into->numLevels[group] >= from->numLevels[group])
349 resultSyms = into->syms[group];
350 resultActs = into->acts[group];
351 resultWidth = into->numLevels[group];
355 resultSyms = from->syms[group];
356 resultActs = from->acts[group];
357 resultWidth = from->numLevels[group];
359 if (resultSyms == NULL)
361 resultSyms = uTypedCalloc(resultWidth, uint32_t);
364 WSGO("Could not allocate symbols for group merge\n");
365 ACTION("Group %d of key %s not merged\n", group,
366 longText(into->name));
370 if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
372 resultActs = uTypedCalloc(resultWidth, union xkb_action);
375 WSGO("Could not allocate actions for group merge\n");
376 ACTION("Group %d of key %s not merged\n", group,
377 longText(into->name));
381 for (i = 0; i < resultWidth; i++)
383 uint32_t fromSym, toSym;
384 if (from->syms[group] && (i < from->numLevels[group]))
385 fromSym = from->syms[group][i];
388 if (into->syms[group] && (i < into->numLevels[group]))
389 toSym = into->syms[group][i];
392 if ((fromSym == NoSymbol) || (fromSym == toSym))
393 resultSyms[i] = toSym;
394 else if (toSym == NoSymbol)
395 resultSyms[i] = fromSym;
398 uint32_t use, ignore;
412 ("Multiple symbols for level %d/group %d on key %s\n",
413 i + 1, group + 1, longText(into->name));
414 ACTION("Using %s, ignoring %s\n",
415 XkbcKeysymText(use), XkbcKeysymText(ignore));
419 if (resultActs != NULL)
421 union xkb_action *fromAct, *toAct;
422 fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
423 toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
424 if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
427 resultActs[i] = *toAct;
429 else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
430 && (fromAct != NULL))
432 resultActs[i] = *fromAct;
436 union xkb_action *use, *ignore;
450 ("Multiple actions for level %d/group %d on key %s\n",
451 i + 1, group + 1, longText(into->name));
452 ACTION("Using %s, ignoring %s\n",
453 XkbcActionTypeText(use->type),
454 XkbcActionTypeText(ignore->type));
456 resultActs[i] = *use;
460 if ((into->syms[group] != NULL) && (resultSyms != into->syms[group]))
461 free(into->syms[group]);
462 if ((from->syms[group] != NULL) && (resultSyms != from->syms[group]))
463 free(from->syms[group]);
464 if ((into->acts[group] != NULL) && (resultActs != into->acts[group]))
465 free(into->acts[group]);
466 if ((from->acts[group] != NULL) && (resultActs != from->acts[group]))
467 free(from->acts[group]);
468 into->numLevels[group] = resultWidth;
469 into->syms[group] = resultSyms;
470 from->syms[group] = NULL;
471 into->acts[group] = resultActs;
472 from->acts[group] = NULL;
473 into->symsDefined |= (1 << group);
474 from->symsDefined &= ~(1 << group);
475 into->actsDefined |= (1 << group);
476 from->actsDefined &= ~(1 << group);
481 MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from)
484 unsigned collide = 0;
487 if (from->defs.merge == MergeReplace)
489 for (i = 0; i < XkbNumKbdGroups; i++)
491 if (into->numLevels[i] != 0)
500 bzero(from, sizeof(KeyInfo));
503 report = ((warningLevel > 9) ||
504 ((into->defs.fileID == from->defs.fileID)
505 && (warningLevel > 0)));
506 for (i = 0; i < XkbNumKbdGroups; i++)
508 if (from->numLevels[i] > 0)
510 if (into->numLevels[i] == 0)
512 into->numLevels[i] = from->numLevels[i];
513 into->syms[i] = from->syms[i];
514 into->acts[i] = from->acts[i];
515 into->symsDefined |= (1 << i);
516 from->syms[i] = NULL;
517 from->acts[i] = NULL;
518 from->numLevels[i] = 0;
519 from->symsDefined &= ~(1 << i);
521 into->defs.defined |= _Key_Syms;
523 into->defs.defined |= _Key_Acts;
530 collide |= _Key_Syms;
532 collide |= _Key_Acts;
534 MergeKeyGroups(info, into, from, (unsigned) i);
537 if (from->types[i] != None)
539 if ((into->types[i] != None) && (report) &&
540 (into->types[i] != from->types[i]))
542 uint32_t use, ignore;
543 collide |= _Key_Types;
544 if (from->defs.merge != MergeAugment)
546 use = from->types[i];
547 ignore = into->types[i];
551 use = into->types[i];
552 ignore = from->types[i];
555 ("Multiple definitions for group %d type of key %s\n",
556 i, longText(into->name));
557 ACTION("Using %s, ignoring %s\n",
559 XkbcAtomText(ignore));
561 if ((from->defs.merge != MergeAugment)
562 || (into->types[i] == None))
564 into->types[i] = from->types[i];
568 if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
570 into->behavior = from->behavior;
571 into->nameForOverlayKey = from->nameForOverlayKey;
572 into->defs.defined |= _Key_Behavior;
574 if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
576 into->vmodmap = from->vmodmap;
577 into->defs.defined |= _Key_VModMap;
579 if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
581 into->repeat = from->repeat;
582 into->defs.defined |= _Key_Repeat;
584 if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
586 into->dfltType = from->dfltType;
587 into->defs.defined |= _Key_Type_Dflt;
589 if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
591 into->groupInfo = from->groupInfo;
592 into->defs.defined |= _Key_GroupInfo;
596 WARN("Symbol map for key %s redefined\n",
597 longText(into->name));
598 ACTION("Using %s definition for conflicting fields\n",
599 (from->defs.merge == MergeAugment ? "first" : "last"));
605 AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_desc * xkb)
608 unsigned long real_name;
610 for (i = 0; i < info->nKeys; i++)
612 if (info->keys[i].name == key->name)
613 return MergeKeys(info, &info->keys[i], key);
615 if (FindKeyNameForAlias(xkb, key->name, &real_name))
617 for (i = 0; i < info->nKeys; i++)
619 if (info->keys[i].name == real_name)
620 return MergeKeys(info, &info->keys[i], key);
623 if (info->nKeys >= info->szKeys)
625 info->szKeys += SYMBOLS_CHUNK;
627 uTypedRecalloc(info->keys, info->nKeys, info->szKeys, KeyInfo);
630 WSGO("Could not allocate key symbols descriptions\n");
631 ACTION("Some key symbols definitions may be lost\n");
635 return CopyKeyInfo(key, &info->keys[info->nKeys++], True);
639 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
644 clobber = (new->defs.merge != MergeAugment);
645 for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
647 if (new->haveSymbol && mm->haveSymbol
648 && (new->u.keySym == mm->u.keySym))
650 unsigned use, ignore;
651 if (mm->modifier != new->modifier)
656 ignore = mm->modifier;
661 ignore = new->modifier;
664 ("%s added to symbol map for multiple modifiers\n",
665 XkbcKeysymText(new->u.keySym));
666 ACTION("Using %s, ignoring %s.\n",
667 XkbcModIndexText(use),
668 XkbcModIndexText(ignore));
673 if ((!new->haveSymbol) && (!mm->haveSymbol) &&
674 (new->u.keyName == mm->u.keyName))
676 unsigned use, ignore;
677 if (mm->modifier != new->modifier)
682 ignore = mm->modifier;
687 ignore = new->modifier;
689 ERROR("Key %s added to map for multiple modifiers\n",
690 longText(new->u.keyName));
691 ACTION("Using %s, ignoring %s.\n",
692 XkbcModIndexText(use),
693 XkbcModIndexText(ignore));
699 mm = uTypedAlloc(ModMapEntry);
702 WSGO("Could not allocate modifier map entry\n");
703 ACTION("Modifier map for %s will be incomplete\n",
704 XkbcModIndexText(new->modifier));
708 mm->defs.next = &info->modMap->defs;
713 /***====================================================================***/
716 MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
717 unsigned merge, struct xkb_desc * xkb)
722 if (from->errorCount > 0)
724 into->errorCount += from->errorCount;
727 if (into->name == NULL)
729 into->name = from->name;
732 for (i = 0; i < XkbNumKbdGroups; i++)
734 if (from->groupNames[i] != None)
736 if ((merge != MergeAugment) || (into->groupNames[i] == None))
737 into->groupNames[i] = from->groupNames[i];
740 for (i = 0, key = from->keys; i < from->nKeys; i++, key++)
742 if (merge != MergeDefault)
743 key->defs.merge = merge;
744 if (!AddKeySymbols(into, key, xkb))
747 if (from->modMap != NULL)
749 ModMapEntry *mm, *next;
750 for (mm = from->modMap; mm != NULL; mm = next)
752 if (merge != MergeDefault)
753 mm->defs.merge = merge;
754 if (!AddModMapEntry(into, mm))
756 next = (ModMapEntry *) mm->defs.next;
761 if (!MergeAliases(&into->aliases, &from->aliases, merge))
766 typedef void (*FileHandler) (XkbFile * /* rtrn */ ,
767 struct xkb_desc * /* xkb */ ,
768 unsigned /* merge */ ,
769 SymbolsInfo * /* included */
773 HandleIncludeSymbols(IncludeStmt * stmt,
774 struct xkb_desc * xkb, SymbolsInfo * info, FileHandler hndlr)
778 SymbolsInfo included;
782 if ((stmt->file == NULL) && (stmt->map == NULL))
786 bzero(info, sizeof(SymbolsInfo));
788 else if (ProcessIncludeFile(stmt, XkmSymbolsIndex, &rtrn, &newMerge))
790 InitSymbolsInfo(&included, xkb);
791 included.fileID = included.dflt.defs.fileID = rtrn->id;
792 included.merge = included.dflt.defs.merge = MergeOverride;
795 included.explicit_group = atoi(stmt->modifier) - 1;
799 included.explicit_group = info->explicit_group;
801 (*hndlr) (rtrn, xkb, MergeOverride, &included);
802 if (stmt->stmt != NULL)
804 if (included.name != NULL)
806 included.name = stmt->stmt;
812 info->errorCount += 10;
815 if ((stmt->next != NULL) && (included.errorCount < 1))
819 SymbolsInfo next_incl;
821 for (next = stmt->next; next != NULL; next = next->next)
823 if ((next->file == NULL) && (next->map == NULL))
826 MergeIncludedSymbols(&included, info, next->merge, xkb);
827 FreeSymbolsInfo(info);
829 else if (ProcessIncludeFile(next, XkmSymbolsIndex, &rtrn, &op))
831 InitSymbolsInfo(&next_incl, xkb);
832 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
833 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
836 next_incl.explicit_group = atoi(next->modifier) - 1;
840 next_incl.explicit_group = info->explicit_group;
842 (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
843 MergeIncludedSymbols(&included, &next_incl, op, xkb);
844 FreeSymbolsInfo(&next_incl);
848 info->errorCount += 10;
857 MergeIncludedSymbols(info, &included, newMerge, xkb);
858 FreeSymbolsInfo(&included);
860 return (info->errorCount == 0);
867 GetGroupIndex(KeyInfo * key,
868 ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
878 if (arrayNdx == NULL)
883 defined = key->symsDefined;
885 defined = key->actsDefined;
887 for (i = 0; i < XkbNumKbdGroups; i++)
889 if ((defined & (1 << i)) == 0)
895 ERROR("Too many groups of %s for key %s (max %d)\n", name,
896 longText(key->name), XkbNumKbdGroups + 1);
897 ACTION("Ignoring %s defined for extra groups\n", name);
900 if (!ExprResolveGroup(arrayNdx, &tmp))
902 ERROR("Illegal group index for %s of key %s\n", name,
903 longText(key->name));
904 ACTION("Definition with non-integer array index ignored\n");
907 if ((tmp.uval < 1) || (tmp.uval > XkbNumKbdGroups))
909 ERROR("Group index for %s of key %s is out of range (1..%d)\n",
910 name, longText(key->name), XkbNumKbdGroups + 1);
911 ACTION("Ignoring %s for group %d\n", name, tmp.uval);
914 *ndx_rtrn = tmp.uval - 1;
919 AddSymbolsToKey(KeyInfo * key,
920 struct xkb_desc * xkb,
922 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
927 if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx))
931 key->symsDefined |= (1 << ndx);
934 if (value->op != ExprKeysymList)
936 ERROR("Expected a list of symbols, found %s\n",
937 exprOpText(value->op));
938 ACTION("Ignoring symbols for group %d of %s\n", ndx,
939 longText(key->name));
942 if (key->syms[ndx] != NULL)
944 WSGO("Symbols for key %s, group %d already defined\n",
945 longText(key->name), ndx);
948 nSyms = value->value.list.nSyms;
949 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
950 (!ResizeKeyGroup(key, ndx, nSyms, False)))
952 WSGO("Could not resize group %d of key %s\n", ndx,
953 longText(key->name));
954 ACTION("Symbols lost\n");
957 key->symsDefined |= (1 << ndx);
958 for (i = 0; i < nSyms; i++) {
959 if (!LookupKeysym(value->value.list.syms[i], &key->syms[ndx][i])) {
960 WSGO("Could not resolve keysym %s\n", value->value.list.syms[i]);
961 key->syms[ndx][i] = NoSymbol;
964 for (i = key->numLevels[ndx] - 1;
965 (i >= 0) && (key->syms[ndx][i] == NoSymbol); i--)
967 key->numLevels[ndx]--;
973 AddActionsToKey(KeyInfo * key,
974 struct xkb_desc * xkb,
976 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
981 struct xkb_any_action *toAct;
983 if (!GetGroupIndex(key, arrayNdx, ACTIONS, &ndx))
988 key->actsDefined |= (1 << ndx);
991 if (value->op != ExprActionList)
993 WSGO("Bad expression type (%d) for action list value\n", value->op);
994 ACTION("Ignoring actions for group %d of %s\n", ndx,
995 longText(key->name));
998 if (key->acts[ndx] != NULL)
1000 WSGO("Actions for key %s, group %d already defined\n",
1001 longText(key->name), ndx);
1004 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
1006 act = (ExprDef *) act->common.next;
1010 WSGO("Action list but not actions in AddActionsToKey\n");
1013 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
1014 (!ResizeKeyGroup(key, ndx, nActs, True)))
1016 WSGO("Could not resize group %d of key %s\n", ndx,
1017 longText(key->name));
1018 ACTION("Actions lost\n");
1021 key->actsDefined |= (1 << ndx);
1023 toAct = (struct xkb_any_action *) key->acts[ndx];
1024 act = value->value.child;
1025 for (i = 0; i < nActs; i++, toAct++)
1027 if (!HandleActionDef(act, xkb, toAct, MergeOverride, info->action))
1029 ERROR("Illegal action definition for %s\n",
1030 longText(key->name));
1031 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1033 act = (ExprDef *) act->common.next;
1039 SetAllowNone(KeyInfo * key, ExprDef * arrayNdx, ExprDef * value)
1042 unsigned radio_groups = 0;
1044 if (arrayNdx == NULL)
1046 radio_groups = XkbAllRadioGroupsMask;
1050 if (!ExprResolveRadioGroup(arrayNdx, &tmp))
1052 ERROR("Illegal index in group name definition\n");
1053 ACTION("Definition with non-integer array index ignored\n");
1056 if ((tmp.uval < 1) || (tmp.uval > XkbMaxRadioGroups))
1058 ERROR("Illegal radio group specified (must be 1..%d)\n",
1059 XkbMaxRadioGroups + 1);
1060 ACTION("Value of \"allow none\" for group %d ignored\n",
1064 radio_groups |= (1 << (tmp.uval - 1));
1066 if (!ExprResolveBoolean(value, &tmp))
1068 ERROR("Illegal \"allow none\" value for %s\n",
1069 longText(key->name));
1070 ACTION("Non-boolean value ignored\n");
1074 key->allowNone |= radio_groups;
1076 key->allowNone &= ~radio_groups;
1081 static LookupEntry lockingEntries[] = {
1082 {"true", XkbKB_Lock},
1083 {"yes", XkbKB_Lock},
1085 {"false", XkbKB_Default},
1086 {"no", XkbKB_Default},
1087 {"off", XkbKB_Default},
1088 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1092 static LookupEntry repeatEntries[] = {
1093 {"true", RepeatYes},
1096 {"false", RepeatNo},
1099 {"default", RepeatUndefined},
1104 SetSymbolsField(KeyInfo * key,
1105 struct xkb_desc * xkb,
1107 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
1112 if (uStrCaseCmp(field, "type") == 0)
1115 if ((!ExprResolveString(value, &tmp))
1116 && (warningLevel > 0))
1118 WARN("The type field of a key symbol map must be a string\n");
1119 ACTION("Ignoring illegal type definition\n");
1121 if (arrayNdx == NULL)
1123 key->dfltType = xkb_intern_atom(tmp.str);
1124 key->defs.defined |= _Key_Type_Dflt;
1126 else if (!ExprResolveGroup(arrayNdx, &ndx))
1128 ERROR("Illegal group index for type of key %s\n",
1129 longText(key->name));
1130 ACTION("Definition with non-integer array index ignored\n");
1134 else if ((ndx.uval < 1) || (ndx.uval > XkbNumKbdGroups))
1137 ("Group index for type of key %s is out of range (1..%d)\n",
1138 longText(key->name), XkbNumKbdGroups + 1);
1139 ACTION("Ignoring type for group %d\n", ndx.uval);
1145 key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
1146 key->typesDefined |= (1 << (ndx.uval - 1));
1150 else if (uStrCaseCmp(field, "symbols") == 0)
1151 return AddSymbolsToKey(key, xkb, field, arrayNdx, value, info);
1152 else if (uStrCaseCmp(field, "actions") == 0)
1153 return AddActionsToKey(key, xkb, field, arrayNdx, value, info);
1154 else if ((uStrCaseCmp(field, "vmods") == 0) ||
1155 (uStrCaseCmp(field, "virtualmods") == 0) ||
1156 (uStrCaseCmp(field, "virtualmodifiers") == 0))
1158 ok = ExprResolveVModMask(value, &tmp, xkb);
1161 key->vmodmap = (tmp.uval >> 8);
1162 key->defs.defined |= _Key_VModMap;
1166 ERROR("Expected a virtual modifier mask, found %s\n",
1167 exprOpText(value->op));
1168 ACTION("Ignoring virtual modifiers definition for key %s\n",
1169 longText(key->name));
1172 else if ((uStrCaseCmp(field, "locking") == 0)
1173 || (uStrCaseCmp(field, "lock") == 0)
1174 || (uStrCaseCmp(field, "locks") == 0))
1176 ok = ExprResolveEnum(value, &tmp, lockingEntries);
1178 key->behavior.type = tmp.uval;
1179 key->defs.defined |= _Key_Behavior;
1181 else if ((uStrCaseCmp(field, "radiogroup") == 0) ||
1182 (uStrCaseCmp(field, "permanentradiogroup") == 0))
1184 Bool permanent = False;
1185 if (uStrCaseCmp(field, "permanentradiogroup") == 0)
1187 if (ExprResolveString(value, &tmp)) {
1188 ok = (strcmp(tmp.str, "none") == 0);
1194 ok = ExprResolveInteger(value, &tmp);
1198 ERROR("Illegal radio group specification for %s\n",
1199 longText(key->name));
1200 ACTION("Non-integer radio group ignored\n");
1205 key->behavior.type = XkbKB_Default;
1206 key->behavior.data = 0;
1209 if ((tmp.uval < 1) || (tmp.uval > XkbMaxRadioGroups))
1212 ("Radio group specification for %s out of range (1..32)\n",
1213 longText(key->name));
1214 ACTION("Illegal radio group %d ignored\n", tmp.uval);
1217 key->behavior.type =
1218 XkbKB_RadioGroup | (permanent ? XkbKB_Permanent : 0);
1219 key->behavior.data = tmp.uval - 1;
1220 if (key->allowNone & (1 << (tmp.uval - 1)))
1221 key->behavior.data |= XkbKB_RGAllowNone;
1222 key->defs.defined |= _Key_Behavior;
1224 else if (uStrCaseEqual(field, "allownone"))
1226 ok = SetAllowNone(key, arrayNdx, value);
1228 else if (uStrCasePrefix("overlay", field) ||
1229 uStrCasePrefix("permanentoverlay", field))
1231 Bool permanent = False;
1234 if (uStrCasePrefix("permanent", field))
1237 which = &field[sizeof("permanentoverlay") - 1];
1241 which = &field[sizeof("overlay") - 1];
1243 if (sscanf(which, "%d", &overlayNdx) == 1)
1245 if (((overlayNdx < 1) || (overlayNdx > 2)) && (warningLevel > 0))
1247 ERROR("Illegal overlay %d specified for %s\n",
1248 overlayNdx, longText(key->name));
1249 ACTION("Ignored\n");
1253 else if (*which == '\0')
1255 else if (warningLevel > 0)
1257 ERROR("Illegal overlay \"%s\" specified for %s\n",
1258 which, longText(key->name));
1259 ACTION("Ignored\n");
1262 ok = ExprResolveKeyName(value, &tmp);
1265 ERROR("Illegal overlay key specification for %s\n",
1266 longText(key->name));
1267 ACTION("Overlay key must be specified by name\n");
1270 if (overlayNdx == 1)
1271 key->behavior.type = XkbKB_Overlay1;
1273 key->behavior.type = XkbKB_Overlay2;
1275 key->behavior.type |= XkbKB_Permanent;
1277 key->behavior.data = 0;
1278 key->nameForOverlayKey = KeyNameToLong(tmp.keyName.name);
1279 key->defs.defined |= _Key_Behavior;
1281 else if ((uStrCaseCmp(field, "repeating") == 0) ||
1282 (uStrCaseCmp(field, "repeats") == 0) ||
1283 (uStrCaseCmp(field, "repeat") == 0))
1285 ok = ExprResolveEnum(value, &tmp, repeatEntries);
1288 ERROR("Illegal repeat setting for %s\n",
1289 longText(key->name));
1290 ACTION("Non-boolean repeat setting ignored\n");
1293 key->repeat = tmp.uval;
1294 key->defs.defined |= _Key_Repeat;
1296 else if ((uStrCaseCmp(field, "groupswrap") == 0) ||
1297 (uStrCaseCmp(field, "wrapgroups") == 0))
1299 ok = ExprResolveBoolean(value, &tmp);
1302 ERROR("Illegal groupsWrap setting for %s\n",
1303 longText(key->name));
1304 ACTION("Non-boolean value ignored\n");
1308 key->groupInfo = XkbWrapIntoRange;
1310 key->groupInfo = XkbClampIntoRange;
1311 key->defs.defined |= _Key_GroupInfo;
1313 else if ((uStrCaseCmp(field, "groupsclamp") == 0) ||
1314 (uStrCaseCmp(field, "clampgroups") == 0))
1316 ok = ExprResolveBoolean(value, &tmp);
1319 ERROR("Illegal groupsClamp setting for %s\n",
1320 longText(key->name));
1321 ACTION("Non-boolean value ignored\n");
1325 key->groupInfo = XkbClampIntoRange;
1327 key->groupInfo = XkbWrapIntoRange;
1328 key->defs.defined |= _Key_GroupInfo;
1330 else if ((uStrCaseCmp(field, "groupsredirect") == 0) ||
1331 (uStrCaseCmp(field, "redirectgroups") == 0))
1333 if (!ExprResolveGroup(value, &tmp))
1335 ERROR("Illegal group index for redirect of key %s\n",
1336 longText(key->name));
1337 ACTION("Definition with non-integer group ignored\n");
1340 if ((tmp.uval < 1) || (tmp.uval > XkbNumKbdGroups))
1342 ERROR("Out-of-range (1..%d) group for redirect of key %s\n",
1343 XkbNumKbdGroups, longText(key->name));
1344 ERROR("Ignoring illegal group %d\n", tmp.uval);
1348 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1349 key->defs.defined |= _Key_GroupInfo;
1353 ERROR("Unknown field %s in a symbol interpretation\n", field);
1354 ACTION("Definition ignored\n");
1361 SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
1363 ExprResult tmp, name;
1365 if ((arrayNdx == NULL) && (warningLevel > 0))
1367 WARN("You must specify an index when specifying a group name\n");
1368 ACTION("Group name definition without array subscript ignored\n");
1371 if (!ExprResolveGroup(arrayNdx, &tmp))
1373 ERROR("Illegal index in group name definition\n");
1374 ACTION("Definition with non-integer array index ignored\n");
1377 if ((tmp.uval < 1) || (tmp.uval > XkbNumKbdGroups))
1380 ("Attempt to specify name for illegal group (must be 1..%d)\n",
1381 XkbNumKbdGroups + 1);
1382 ACTION("Name for group %d ignored\n", tmp.uval);
1385 if (!ExprResolveString(value, &name))
1387 ERROR("Group name must be a string\n");
1388 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1391 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1392 xkb_intern_atom(name.str);
1399 HandleSymbolsVar(VarDef * stmt, struct xkb_desc * xkb, SymbolsInfo * info)
1401 ExprResult elem, field, tmp;
1405 if (ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx) == 0)
1406 return 0; /* internal error, already reported */
1407 if (elem.str && (uStrCaseCmp(elem.str, "key") == 0))
1409 ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx,
1412 else if ((elem.str == NULL) && ((uStrCaseCmp(field.str, "name") == 0) ||
1413 (uStrCaseCmp(field.str, "groupname") ==
1416 ret = SetGroupName(info, arrayNdx, stmt->value);
1418 else if ((elem.str == NULL)
1419 && ((uStrCaseCmp(field.str, "groupswrap") == 0)
1420 || (uStrCaseCmp(field.str, "wrapgroups") == 0)))
1422 if (!ExprResolveBoolean(stmt->value, &tmp))
1424 ERROR("Illegal setting for global groupsWrap\n");
1425 ACTION("Non-boolean value ignored\n");
1430 info->groupInfo = XkbWrapIntoRange;
1432 info->groupInfo = XkbClampIntoRange;
1436 else if ((elem.str == NULL)
1437 && ((uStrCaseCmp(field.str, "groupsclamp") == 0)
1438 || (uStrCaseCmp(field.str, "clampgroups") == 0)))
1440 if (!ExprResolveBoolean(stmt->value, &tmp))
1442 ERROR("Illegal setting for global groupsClamp\n");
1443 ACTION("Non-boolean value ignored\n");
1448 info->groupInfo = XkbClampIntoRange;
1450 info->groupInfo = XkbWrapIntoRange;
1454 else if ((elem.str == NULL)
1455 && ((uStrCaseCmp(field.str, "groupsredirect") == 0)
1456 || (uStrCaseCmp(field.str, "redirectgroups") == 0)))
1458 if (!ExprResolveGroup(stmt->value, &tmp))
1460 ERROR("Illegal group index for global groupsRedirect\n");
1461 ACTION("Definition with non-integer group ignored\n");
1465 if ((tmp.uval < 1) || (tmp.uval > XkbNumKbdGroups))
1468 ("Out-of-range (1..%d) group for global groupsRedirect\n",
1470 ACTION("Ignoring illegal group %d\n", tmp.uval);
1474 info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1480 else if ((elem.str == NULL) && (uStrCaseCmp(field.str, "allownone") == 0))
1482 ret = SetAllowNone(&info->dflt, arrayNdx, stmt->value);
1485 ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value,
1495 HandleSymbolsBody(VarDef * def,
1496 struct xkb_desc * xkb, KeyInfo * key, SymbolsInfo * info)
1499 ExprResult tmp, field;
1502 for (; def != NULL; def = (VarDef *) def->common.next)
1504 if ((def->name) && (def->name->type == ExprFieldRef))
1506 ok = HandleSymbolsVar(def, xkb, info);
1511 if (def->name == NULL)
1513 if ((def->value == NULL)
1514 || (def->value->op == ExprKeysymList))
1515 field.str = strdup("symbols");
1517 field.str = strdup("actions");
1522 ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
1525 ok = SetSymbolsField(key, xkb, field.str, arrayNdx,
1534 SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
1536 unsigned group = info->explicit_group;
1541 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1544 WARN("For the map %s an explicit group specified\n", info->name);
1545 WARN("but key %s has more than one group defined\n",
1546 longText(key->name));
1547 ACTION("All groups except first one will be ignored\n");
1548 for (i = 1; i < XkbNumKbdGroups; i++)
1550 key->numLevels[i] = 0;
1551 if (key->syms[i] != NULL)
1553 key->syms[i] = (uint32_t *) NULL;
1554 if (key->acts[i] != NULL)
1556 key->acts[i] = (union xkb_action *) NULL;
1557 key->types[i] = (uint32_t) 0;
1560 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1562 key->numLevels[group] = key->numLevels[0];
1563 key->numLevels[0] = 0;
1564 key->syms[group] = key->syms[0];
1565 key->syms[0] = (uint32_t *) NULL;
1566 key->acts[group] = key->acts[0];
1567 key->acts[0] = (union xkb_action *) NULL;
1568 key->types[group] = key->types[0];
1569 key->types[0] = (uint32_t) 0;
1574 HandleSymbolsDef(SymbolsDef * stmt,
1575 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1580 CopyKeyInfo(&info->dflt, &key, False);
1581 key.defs.merge = stmt->merge;
1582 key.name = KeyNameToLong(stmt->keyName);
1583 if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
1589 if (!SetExplicitGroup(info, &key))
1595 if (!AddKeySymbols(info, &key, xkb))
1604 HandleModMapDef(ModMapDef * def,
1605 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1612 if (!LookupModIndex(NULL, None, def->modifier, TypeInt, &rtrn))
1614 ERROR("Illegal modifier map definition\n");
1615 ACTION("Ignoring map for non-modifier \"%s\"\n",
1616 XkbcAtomText(def->modifier));
1620 tmp.modifier = rtrn.uval;
1621 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1623 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1625 tmp.haveSymbol = False;
1626 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1628 else if (ExprResolveKeySym(key, &rtrn))
1630 tmp.haveSymbol = True;
1631 tmp.u.keySym = rtrn.uval;
1635 ERROR("Modmap entries may contain only key names or keysyms\n");
1636 ACTION("Illegal definition for %s modifier ignored\n",
1637 XkbcModIndexText(tmp.modifier));
1641 ok = AddModMapEntry(info, &tmp) && ok;
1647 HandleSymbolsFile(XkbFile * file,
1648 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1652 info->name = _XkbDupString(file->name);
1656 switch (stmt->stmtType)
1659 if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info,
1663 case StmtSymbolsDef:
1664 if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, merge, info))
1668 if (!HandleSymbolsVar((VarDef *) stmt, xkb, info))
1672 if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
1676 ERROR("Interpretation files may not include other types\n");
1677 ACTION("Ignoring definition of symbol interpretation\n");
1680 case StmtKeycodeDef:
1681 ERROR("Interpretation files may not include other types\n");
1682 ACTION("Ignoring definition of key name\n");
1686 if (!HandleModMapDef((ModMapDef *) stmt, xkb, merge, info))
1690 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1695 if (info->errorCount > 10)
1698 ERROR("Too many errors\n");
1700 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1708 FindKeyForSymbol(struct xkb_desc * xkb, uint32_t sym, xkb_keycode_t *kc_rtrn)
1711 register Bool gotOne;
1717 for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++)
1719 if (j < (int) XkbKeyNumSyms(xkb, i))
1722 if ((XkbKeySym(xkb, i, j) == sym))
1736 * Find the given name in the xkb->map->types and return its index.
1738 * @param name The atom to search for.
1739 * @param type_rtrn Set to the index of the name if found.
1741 * @return True if found, False otherwise.
1744 FindNamedType(struct xkb_desc * xkb, uint32_t name, unsigned *type_rtrn)
1746 register unsigned n;
1748 if (xkb && xkb->map && xkb->map->types)
1750 for (n = 0; n < xkb->map->num_types; n++)
1752 if (xkb->map->types[n].name == (uint32_t) name)
1763 * Assign a type to the given sym and return the Atom for the type assigned.
1766 * - ONE_LEVEL for width 0/1
1767 * - ALPHABETIC for 2 shift levels, with lower/upercase
1768 * - KEYPAD for keypad keys.
1769 * - TWO_LEVEL for other 2 shift level keys.
1770 * and the same for four level keys.
1772 * @param width Number of sysms in syms.
1773 * @param syms The keysyms for the given key (must be size width).
1774 * @param typeNameRtrn Set to the Atom of the type name.
1776 * @returns True if a type could be found, False otherwise.
1779 FindAutomaticType(int width, uint32_t * syms, uint32_t * typeNameRtrn,
1783 if ((width == 1) || (width == 0))
1785 *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
1788 else if (width == 2)
1790 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1792 *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
1794 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1796 *typeNameRtrn = xkb_intern_atom("KEYPAD");
1801 *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
1805 else if (width <= 4)
1807 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1808 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1810 xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
1812 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
1814 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1815 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
1817 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
1818 /* XXX: why not set autoType here? */
1820 return ((width >= 0) && (width <= 4));
1824 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1825 * groups, and reduce to one group if all groups are identical anyway.
1828 PrepareKeyDef(KeyInfo * key)
1830 int i, j, width, defined, lastGroup;
1833 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1834 /* get highest group number */
1835 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1837 if (defined & (1 << i))
1845 /* If there are empty groups between non-empty ones fill them with data */
1846 /* from the first group. */
1847 /* We can make a wrong assumption here. But leaving gaps is worse. */
1848 for (i = lastGroup; i > 0; i--)
1850 if (defined & (1 << i))
1852 width = key->numLevels[0];
1853 if (key->typesDefined & 1)
1855 for (j = 0; j < width; j++)
1857 key->types[i] = key->types[0];
1859 key->typesDefined |= 1 << i;
1861 if ((key->actsDefined & 1) && key->acts[0])
1863 key->acts[i] = uTypedCalloc(width, union xkb_action);
1864 if (key->acts[i] == NULL)
1866 memcpy((void *) key->acts[i], (void *) key->acts[0],
1867 width * sizeof(union xkb_action));
1868 key->actsDefined |= 1 << i;
1870 if ((key->symsDefined & 1) && key->syms[0])
1872 key->syms[i] = uTypedCalloc(width, uint32_t);
1873 if (key->syms[i] == NULL)
1875 memcpy((void *) key->syms[i], (void *) key->syms[0],
1876 width * sizeof(uint32_t));
1877 key->symsDefined |= 1 << i;
1881 key->numLevels[i] = key->numLevels[0];
1884 /* If all groups are completely identical remove them all */
1885 /* exept the first one. */
1887 for (i = lastGroup; i > 0; i--)
1889 if ((key->numLevels[i] != key->numLevels[0]) ||
1890 (key->types[i] != key->types[0]))
1895 if ((key->syms[i] != key->syms[0]) &&
1896 (key->syms[i] == NULL || key->syms[0] == NULL ||
1897 memcmp((void *) key->syms[i], (void *) key->syms[0],
1898 sizeof(uint32_t) * key->numLevels[0])))
1903 if ((key->acts[i] != key->acts[0]) &&
1904 (key->acts[i] == NULL || key->acts[0] == NULL ||
1905 memcmp((void *) key->acts[i], (void *) key->acts[0],
1906 sizeof(union xkb_action) * key->numLevels[0])))
1914 for (i = lastGroup; i > 0; i--)
1916 key->numLevels[i] = 0;
1917 if (key->syms[i] != NULL)
1919 key->syms[i] = (uint32_t *) NULL;
1920 if (key->acts[i] != NULL)
1922 key->acts[i] = (union xkb_action *) NULL;
1923 key->types[i] = (uint32_t) 0;
1925 key->symsDefined &= 1;
1926 key->actsDefined &= 1;
1927 key->typesDefined &= 1;
1933 * Copy the KeyInfo into the keyboard description.
1935 * This function recurses.
1938 CopySymbolsDef(struct xkb_desc * xkb, KeyInfo *key, int start_from)
1941 xkb_keycode_t okc, kc;
1942 unsigned width, tmp, nGroups;
1943 struct xkb_key_type * type;
1944 Bool haveActions, autoType, useAlias;
1946 union xkb_action *outActs;
1947 unsigned types[XkbNumKbdGroups];
1949 useAlias = (start_from == 0);
1951 /* get the keycode for the key. */
1952 if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb),
1955 if ((start_from == 0) && (warningLevel >= 5))
1957 WARN("Key %s not found in %s keycodes\n",
1958 longText(key->name),
1959 XkbcAtomText(xkb->names->keycodes));
1960 ACTION("Symbols ignored\n");
1965 haveActions = False;
1966 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1968 if (((i + 1) > nGroups)
1969 && (((key->symsDefined | key->actsDefined) & (1 << i))
1970 || (key->typesDefined) & (1 << i)))
1975 /* Assign the type to the key, if it is missing. */
1976 if (key->types[i] == None)
1978 if (key->dfltType != None)
1979 key->types[i] = key->dfltType;
1980 else if (FindAutomaticType(key->numLevels[i], key->syms[i],
1981 &key->types[i], &autoType))
1986 if (warningLevel >= 5)
1988 WARN("No automatic type for %d symbols\n",
1989 (unsigned int) key->numLevels[i]);
1990 ACTION("Using %s for the %s key (keycode %d)\n",
1991 XkbcAtomText(key->types[i]),
1992 longText(key->name), kc);
1996 if (FindNamedType(xkb, key->types[i], &types[i]))
1998 if (!autoType || key->numLevels[i] > 2)
1999 xkb->server->explicit[kc] |= (1 << i);
2003 if (warningLevel >= 3)
2005 WARN("Type \"%s\" is not defined\n",
2006 XkbcAtomText(key->types[i]));
2007 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
2008 longText(key->name), kc);
2010 types[i] = XkbTwoLevelIndex;
2012 /* if the type specifies less syms than the key has, shrink the key */
2013 type = &xkb->map->types[types[i]];
2014 if (type->num_levels < key->numLevels[i])
2016 if (warningLevel > 0)
2019 ("Type \"%s\" has %d levels, but %s has %d symbols\n",
2020 XkbcAtomText(type->name),
2021 (unsigned int) type->num_levels,
2022 longText(key->name),
2023 (unsigned int) key->numLevels[i]);
2024 ACTION("Ignoring extra symbols\n");
2026 key->numLevels[i] = type->num_levels;
2028 if (key->numLevels[i] > width)
2029 width = key->numLevels[i];
2030 if (type->num_levels > width)
2031 width = type->num_levels;
2034 /* width is now the largest width found */
2036 i = width * nGroups;
2037 outSyms = XkbcResizeKeySyms(xkb, kc, i);
2038 if (outSyms == NULL)
2040 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
2041 longText(key->name), kc);
2046 outActs = XkbcResizeKeyActions(xkb, kc, i);
2047 if (outActs == NULL)
2049 WSGO("Could not enlarge actions for %s (key %d)\n",
2050 longText(key->name), kc);
2053 xkb->server->explicit[kc] |= XkbExplicitInterpretMask;
2057 if (key->defs.defined & _Key_GroupInfo)
2060 i = xkb->map->key_sym_map[kc].group_info;
2062 xkb->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
2063 xkb->map->key_sym_map[kc].width = width;
2064 for (i = 0; i < nGroups; i++)
2066 /* assign kt_index[i] to the index of the type in map->types.
2067 * kt_index[i] may have been set by a previous run (if we have two
2068 * layouts specified). Let's not overwrite it with the ONE_LEVEL
2069 * default group if we dont even have keys for this group anyway.
2071 * FIXME: There should be a better fix for this.
2073 if (key->numLevels[i])
2074 xkb->map->key_sym_map[kc].kt_index[i] = types[i];
2075 if (key->syms[i] != NULL)
2077 /* fill key to "width" symbols*/
2078 for (tmp = 0; tmp < width; tmp++)
2080 if (tmp < key->numLevels[i])
2081 outSyms[tmp] = key->syms[i][tmp];
2083 outSyms[tmp] = NoSymbol;
2084 if ((outActs != NULL) && (key->acts[i] != NULL))
2086 if (tmp < key->numLevels[i])
2087 outActs[tmp] = key->acts[i][tmp];
2089 outActs[tmp].type = XkbSA_NoAction;
2097 switch (key->behavior.type & XkbKB_OpMask)
2101 case XkbKB_Overlay1:
2102 case XkbKB_Overlay2:
2103 /* find key by name! */
2104 if (!FindNamedKey(xkb, key->nameForOverlayKey, &okc, True,
2105 CreateKeyNames(xkb), 0))
2107 if (warningLevel >= 1)
2109 WARN("Key %s not found in %s keycodes\n",
2110 longText(key->nameForOverlayKey),
2111 XkbcAtomText(xkb->names->keycodes));
2112 ACTION("Not treating %s as an overlay key \n",
2113 longText(key->name));
2117 key->behavior.data = okc;
2119 xkb->server->behaviors[kc] = key->behavior;
2120 xkb->server->explicit[kc] |= XkbExplicitBehaviorMask;
2123 if (key->defs.defined & _Key_VModMap)
2125 xkb->server->vmodmap[kc] = key->vmodmap;
2126 xkb->server->explicit[kc] |= XkbExplicitVModMapMask;
2128 if (key->repeat != RepeatUndefined)
2130 if (key->repeat == RepeatYes)
2131 xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
2133 xkb->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
2134 xkb->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
2137 if (nGroups > xkb->ctrls->num_groups)
2138 xkb->ctrls->num_groups = nGroups;
2140 /* do the same thing for the next key */
2141 CopySymbolsDef(xkb, key, kc + 1);
2146 CopyModMapDef(struct xkb_desc * xkb, ModMapEntry *entry)
2150 if ((!entry->haveSymbol)
2153 (xkb, entry->u.keyName, &kc, True, CreateKeyNames(xkb), 0)))
2155 if (warningLevel >= 5)
2157 WARN("Key %s not found in %s keycodes\n",
2158 longText(entry->u.keyName),
2159 XkbcAtomText(xkb->names->keycodes));
2160 ACTION("Modifier map entry for %s not updated\n",
2161 XkbcModIndexText(entry->modifier));
2165 else if (entry->haveSymbol
2166 && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc)))
2168 if (warningLevel > 5)
2170 WARN("Key \"%s\" not found in %s symbol map\n",
2171 XkbcKeysymText(entry->u.keySym),
2172 XkbcAtomText(xkb->names->symbols));
2173 ACTION("Modifier map entry for %s not updated\n",
2174 XkbcModIndexText(entry->modifier));
2178 xkb->map->modmap[kc] |= (1 << entry->modifier);
2183 * Handle the xkb_symbols section of an xkb file.
2185 * @param file The parsed xkb_symbols section of the xkb file.
2186 * @param xkb Handle to the keyboard description to store the symbols in.
2187 * @param merge Merge strategy (e.g. MergeOverride).
2190 CompileSymbols(XkbFile *file, struct xkb_desc * xkb, unsigned merge)
2195 InitSymbolsInfo(&info, xkb);
2196 info.dflt.defs.fileID = file->id;
2197 info.dflt.defs.merge = merge;
2198 HandleSymbolsFile(file, xkb, merge, &info);
2200 if (info.nKeys == 0) {
2201 FreeSymbolsInfo(&info);
2205 if (info.errorCount == 0)
2209 /* alloc memory in the xkb struct */
2210 if (XkbcAllocNames(xkb, XkbSymbolsNameMask | XkbGroupNamesMask, 0, 0)
2213 WSGO("Can not allocate names in CompileSymbols\n");
2214 ACTION("Symbols not added\n");
2217 if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
2220 WSGO("Could not allocate client map in CompileSymbols\n");
2221 ACTION("Symbols not added\n");
2224 if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success)
2226 WSGO("Could not allocate server map in CompileSymbols\n");
2227 ACTION("Symbols not added\n");
2230 if (XkbcAllocControls(xkb, XkbPerKeyRepeatMask) != Success)
2232 WSGO("Could not allocate controls in CompileSymbols\n");
2233 ACTION("Symbols not added\n");
2237 /* now copy info into xkb. */
2238 xkb->names->symbols = xkb_intern_atom(info.name);
2240 ApplyAliases(xkb, False, &info.aliases);
2241 for (i = 0; i < XkbNumKbdGroups; i++)
2243 if (info.groupNames[i] != None)
2244 xkb->names->groups[i] = info.groupNames[i];
2247 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2252 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2254 if (!CopySymbolsDef(xkb, key, 0))
2257 if (warningLevel > 3)
2259 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++)
2261 if (xkb->names->keys[i].name[0] == '\0')
2263 if (XkbKeyNumGroups(xkb, i) < 1)
2266 memcpy(buf, xkb->names->keys[i].name, 4);
2269 ("No symbols defined for <%s> (keycode %d)\n",
2276 ModMapEntry *mm, *next;
2277 for (mm = info.modMap; mm != NULL; mm = next)
2279 if (!CopyModMapDef(xkb, mm))
2281 next = (ModMapEntry *) mm->defs.next;
2284 FreeSymbolsInfo(&info);
2288 FreeSymbolsInfo(&info);