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 unsigned int 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;
311 unsigned int resultWidth;
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)
893 if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx))
897 key->symsDefined |= (1 << ndx);
900 if (value->op != ExprKeysymList)
902 ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op));
903 ACTION("Ignoring symbols for group %d of %s\n", ndx + 1,
904 longText(key->name));
907 if (key->syms[ndx] != NULL)
909 ERROR("Symbols for key %s, group %d already defined\n",
910 longText(key->name), ndx + 1);
911 ACTION("Ignoring duplicate definition\n");
914 nSyms = value->value.list.nSyms;
915 if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
916 (!ResizeKeyGroup(key, ndx, nSyms, False)))
918 WSGO("Could not resize group %d of key %s to contain %d levels\n",
919 ndx + 1, longText(key->name), nSyms);
920 ACTION("Symbols lost\n");
923 key->symsDefined |= (1 << ndx);
924 for (i = 0; i < nSyms; i++) {
925 if (!LookupKeysym(value->value.list.syms[i], &key->syms[ndx][i])) {
926 WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
927 value->value.list.syms[i], longText(key->name), ndx + 1,
928 XkbcAtomText(info->groupNames[ndx]), nSyms);
929 key->syms[ndx][i] = NoSymbol;
932 for (j = key->numLevels[ndx] - 1;
933 (j >= 0) && (key->syms[ndx][j] == NoSymbol); j--)
935 key->numLevels[ndx]--;
941 AddActionsToKey(KeyInfo * key,
942 struct xkb_desc * xkb,
944 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
949 struct xkb_any_action *toAct;
951 if (!GetGroupIndex(key, arrayNdx, ACTIONS, &ndx))
956 key->actsDefined |= (1 << ndx);
959 if (value->op != ExprActionList)
961 WSGO("Bad expression type (%d) for action list value\n", value->op);
962 ACTION("Ignoring actions for group %d of %s\n", ndx,
963 longText(key->name));
966 if (key->acts[ndx] != NULL)
968 WSGO("Actions for key %s, group %d already defined\n",
969 longText(key->name), ndx);
972 for (nActs = 0, act = value->value.child; act != NULL; nActs++)
974 act = (ExprDef *) act->common.next;
978 WSGO("Action list but not actions in AddActionsToKey\n");
981 if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
982 (!ResizeKeyGroup(key, ndx, nActs, True)))
984 WSGO("Could not resize group %d of key %s\n", ndx,
985 longText(key->name));
986 ACTION("Actions lost\n");
989 key->actsDefined |= (1 << ndx);
991 toAct = (struct xkb_any_action *) key->acts[ndx];
992 act = value->value.child;
993 for (i = 0; i < nActs; i++, toAct++)
995 if (!HandleActionDef(act, xkb, toAct, MergeOverride, info->action))
997 ERROR("Illegal action definition for %s\n",
998 longText(key->name));
999 ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
1001 act = (ExprDef *) act->common.next;
1006 static const LookupEntry lockingEntries[] = {
1007 {"true", XkbKB_Lock},
1008 {"yes", XkbKB_Lock},
1010 {"false", XkbKB_Default},
1011 {"no", XkbKB_Default},
1012 {"off", XkbKB_Default},
1013 {"permanent", XkbKB_Lock | XkbKB_Permanent},
1017 static const LookupEntry repeatEntries[] = {
1018 {"true", RepeatYes},
1021 {"false", RepeatNo},
1024 {"default", RepeatUndefined},
1029 SetSymbolsField(KeyInfo * key,
1030 struct xkb_desc * xkb,
1032 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
1037 if (strcasecmp(field, "type") == 0)
1040 if ((!ExprResolveString(value, &tmp))
1041 && (warningLevel > 0))
1043 WARN("The type field of a key symbol map must be a string\n");
1044 ACTION("Ignoring illegal type definition\n");
1046 if (arrayNdx == NULL)
1048 key->dfltType = xkb_intern_atom(tmp.str);
1049 key->defs.defined |= _Key_Type_Dflt;
1051 else if (!ExprResolveGroup(arrayNdx, &ndx))
1053 ERROR("Illegal group index for type of key %s\n",
1054 longText(key->name));
1055 ACTION("Definition with non-integer array index ignored\n");
1061 key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
1062 key->typesDefined |= (1 << (ndx.uval - 1));
1066 else if (strcasecmp(field, "symbols") == 0)
1067 return AddSymbolsToKey(key, xkb, field, arrayNdx, value, info);
1068 else if (strcasecmp(field, "actions") == 0)
1069 return AddActionsToKey(key, xkb, field, arrayNdx, value, info);
1070 else if ((strcasecmp(field, "vmods") == 0) ||
1071 (strcasecmp(field, "virtualmods") == 0) ||
1072 (strcasecmp(field, "virtualmodifiers") == 0))
1074 ok = ExprResolveVModMask(value, &tmp, xkb);
1077 key->vmodmap = (tmp.uval >> 8);
1078 key->defs.defined |= _Key_VModMap;
1082 ERROR("Expected a virtual modifier mask, found %s\n",
1083 exprOpText(value->op));
1084 ACTION("Ignoring virtual modifiers definition for key %s\n",
1085 longText(key->name));
1088 else if ((strcasecmp(field, "locking") == 0) ||
1089 (strcasecmp(field, "lock") == 0) ||
1090 (strcasecmp(field, "locks") == 0))
1092 ok = ExprResolveEnum(value, &tmp, lockingEntries);
1094 key->behavior.type = tmp.uval;
1095 key->defs.defined |= _Key_Behavior;
1097 else if ((strcasecmp(field, "radiogroup") == 0) ||
1098 (strcasecmp(field, "permanentradiogroup") == 0) ||
1099 (strcasecmp(field, "allownone") == 0))
1101 ERROR("Radio groups not supported\n");
1102 ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1105 else if (uStrCasePrefix("overlay", field) ||
1106 uStrCasePrefix("permanentoverlay", field))
1108 ERROR("Overlays not supported\n");
1109 ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1111 else if ((strcasecmp(field, "repeating") == 0) ||
1112 (strcasecmp(field, "repeats") == 0) ||
1113 (strcasecmp(field, "repeat") == 0))
1115 ok = ExprResolveEnum(value, &tmp, repeatEntries);
1118 ERROR("Illegal repeat setting for %s\n",
1119 longText(key->name));
1120 ACTION("Non-boolean repeat setting ignored\n");
1123 key->repeat = tmp.uval;
1124 key->defs.defined |= _Key_Repeat;
1126 else if ((strcasecmp(field, "groupswrap") == 0) ||
1127 (strcasecmp(field, "wrapgroups") == 0))
1129 ok = ExprResolveBoolean(value, &tmp);
1132 ERROR("Illegal groupsWrap setting for %s\n",
1133 longText(key->name));
1134 ACTION("Non-boolean value ignored\n");
1138 key->groupInfo = XkbWrapIntoRange;
1140 key->groupInfo = XkbClampIntoRange;
1141 key->defs.defined |= _Key_GroupInfo;
1143 else if ((strcasecmp(field, "groupsclamp") == 0) ||
1144 (strcasecmp(field, "clampgroups") == 0))
1146 ok = ExprResolveBoolean(value, &tmp);
1149 ERROR("Illegal groupsClamp setting for %s\n",
1150 longText(key->name));
1151 ACTION("Non-boolean value ignored\n");
1155 key->groupInfo = XkbClampIntoRange;
1157 key->groupInfo = XkbWrapIntoRange;
1158 key->defs.defined |= _Key_GroupInfo;
1160 else if ((strcasecmp(field, "groupsredirect") == 0) ||
1161 (strcasecmp(field, "redirectgroups") == 0))
1163 if (!ExprResolveGroup(value, &tmp))
1165 ERROR("Illegal group index for redirect of key %s\n",
1166 longText(key->name));
1167 ACTION("Definition with non-integer group ignored\n");
1171 XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1172 key->defs.defined |= _Key_GroupInfo;
1176 ERROR("Unknown field %s in a symbol interpretation\n", field);
1177 ACTION("Definition ignored\n");
1184 SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
1186 ExprResult tmp, name;
1188 if ((arrayNdx == NULL) && (warningLevel > 0))
1190 WARN("You must specify an index when specifying a group name\n");
1191 ACTION("Group name definition without array subscript ignored\n");
1194 if (!ExprResolveGroup(arrayNdx, &tmp))
1196 ERROR("Illegal index in group name definition\n");
1197 ACTION("Definition with non-integer array index ignored\n");
1200 if (!ExprResolveString(value, &name))
1202 ERROR("Group name must be a string\n");
1203 ACTION("Illegal name for group %d ignored\n", tmp.uval);
1206 info->groupNames[tmp.uval - 1 + info->explicit_group] =
1207 xkb_intern_atom(name.str);
1214 HandleSymbolsVar(VarDef * stmt, struct xkb_desc * xkb, SymbolsInfo * info)
1216 ExprResult elem, field, tmp;
1220 if (ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx) == 0)
1221 return 0; /* internal error, already reported */
1222 if (elem.str && (strcasecmp(elem.str, "key") == 0))
1224 ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx,
1227 else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) ||
1228 (strcasecmp(field.str, "groupname") ==
1231 ret = SetGroupName(info, arrayNdx, stmt->value);
1233 else if ((elem.str == NULL)
1234 && ((strcasecmp(field.str, "groupswrap") == 0) ||
1235 (strcasecmp(field.str, "wrapgroups") == 0)))
1237 if (!ExprResolveBoolean(stmt->value, &tmp))
1239 ERROR("Illegal setting for global groupsWrap\n");
1240 ACTION("Non-boolean value ignored\n");
1245 info->groupInfo = XkbWrapIntoRange;
1247 info->groupInfo = XkbClampIntoRange;
1251 else if ((elem.str == NULL)
1252 && ((strcasecmp(field.str, "groupsclamp") == 0) ||
1253 (strcasecmp(field.str, "clampgroups") == 0)))
1255 if (!ExprResolveBoolean(stmt->value, &tmp))
1257 ERROR("Illegal setting for global groupsClamp\n");
1258 ACTION("Non-boolean value ignored\n");
1263 info->groupInfo = XkbClampIntoRange;
1265 info->groupInfo = XkbWrapIntoRange;
1269 else if ((elem.str == NULL)
1270 && ((strcasecmp(field.str, "groupsredirect") == 0) ||
1271 (strcasecmp(field.str, "redirectgroups") == 0)))
1273 if (!ExprResolveGroup(stmt->value, &tmp))
1275 ERROR("Illegal group index for global groupsRedirect\n");
1276 ACTION("Definition with non-integer group ignored\n");
1280 info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1285 else if ((elem.str == NULL) && (strcasecmp(field.str, "allownone") == 0))
1287 ERROR("Radio groups not supported\n");
1288 ACTION("Ignoring \"allow none\" specification\n");
1292 ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value,
1302 HandleSymbolsBody(VarDef * def,
1303 struct xkb_desc * xkb, KeyInfo * key, SymbolsInfo * info)
1306 ExprResult tmp, field;
1309 for (; def != NULL; def = (VarDef *) def->common.next)
1311 if ((def->name) && (def->name->type == ExprFieldRef))
1313 ok = HandleSymbolsVar(def, xkb, info);
1318 if (def->name == NULL)
1320 if ((def->value == NULL)
1321 || (def->value->op == ExprKeysymList))
1322 field.str = strdup("symbols");
1324 field.str = strdup("actions");
1329 ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
1332 ok = SetSymbolsField(key, xkb, field.str, arrayNdx,
1341 SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
1343 unsigned group = info->explicit_group;
1348 if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1351 WARN("For the map %s an explicit group specified\n", info->name);
1352 WARN("but key %s has more than one group defined\n",
1353 longText(key->name));
1354 ACTION("All groups except first one will be ignored\n");
1355 for (i = 1; i < XkbNumKbdGroups; i++)
1357 key->numLevels[i] = 0;
1359 key->syms[i] = NULL;
1361 key->acts[i] = NULL;
1365 key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1367 key->numLevels[group] = key->numLevels[0];
1368 key->numLevels[0] = 0;
1369 key->syms[group] = key->syms[0];
1370 key->syms[0] = NULL;
1371 key->acts[group] = key->acts[0];
1372 key->acts[0] = NULL;
1373 key->types[group] = key->types[0];
1379 HandleSymbolsDef(SymbolsDef * stmt,
1380 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1385 CopyKeyInfo(&info->dflt, &key, False);
1386 key.defs.merge = stmt->merge;
1387 key.name = KeyNameToLong(stmt->keyName);
1388 if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
1394 if (!SetExplicitGroup(info, &key))
1400 if (!AddKeySymbols(info, &key, xkb))
1409 HandleModMapDef(ModMapDef * def,
1410 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1417 if (!LookupModIndex(NULL, def->modifier, TypeInt, &rtrn))
1419 ERROR("Illegal modifier map definition\n");
1420 ACTION("Ignoring map for non-modifier \"%s\"\n",
1421 XkbcAtomText(def->modifier));
1425 tmp.modifier = rtrn.uval;
1426 for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1428 if ((key->op == ExprValue) && (key->type == TypeKeyName))
1430 tmp.haveSymbol = False;
1431 tmp.u.keyName = KeyNameToLong(key->value.keyName);
1433 else if (ExprResolveKeySym(key, &rtrn))
1435 tmp.haveSymbol = True;
1436 tmp.u.keySym = rtrn.uval;
1440 ERROR("Modmap entries may contain only key names or keysyms\n");
1441 ACTION("Illegal definition for %s modifier ignored\n",
1442 XkbcModIndexText(tmp.modifier));
1446 ok = AddModMapEntry(info, &tmp) && ok;
1452 HandleSymbolsFile(XkbFile * file,
1453 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1458 info->name = uDupString(file->name);
1462 switch (stmt->stmtType)
1465 if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info,
1469 case StmtSymbolsDef:
1470 if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, merge, info))
1474 if (!HandleSymbolsVar((VarDef *) stmt, xkb, info))
1478 if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
1482 ERROR("Interpretation files may not include other types\n");
1483 ACTION("Ignoring definition of symbol interpretation\n");
1486 case StmtKeycodeDef:
1487 ERROR("Interpretation files may not include other types\n");
1488 ACTION("Ignoring definition of key name\n");
1492 if (!HandleModMapDef((ModMapDef *) stmt, xkb, merge, info))
1496 WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1501 if (info->errorCount > 10)
1504 ERROR("Too many errors\n");
1506 ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1513 FindKeyForSymbol(struct xkb_desc * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn)
1522 for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++)
1524 if (j < (int) XkbKeyNumSyms(xkb, i))
1527 if (XkbKeySym(xkb, i, j) == sym)
1541 * Find the given name in the xkb->map->types and return its index.
1543 * @param atom The atom to search for.
1544 * @param type_rtrn Set to the index of the name if found.
1546 * @return True if found, False otherwise.
1549 FindNamedType(struct xkb_desc * xkb, xkb_atom_t atom, unsigned *type_rtrn)
1552 const char *name = XkbcAtomText(atom);
1554 if (xkb && xkb->map && xkb->map->types)
1556 for (n = 0; n < xkb->map->num_types; n++)
1558 if (strcmp(xkb->map->types[n].name, name) == 0)
1569 * Assign a type to the given sym and return the Atom for the type assigned.
1572 * - ONE_LEVEL for width 0/1
1573 * - ALPHABETIC for 2 shift levels, with lower/upercase
1574 * - KEYPAD for keypad keys.
1575 * - TWO_LEVEL for other 2 shift level keys.
1576 * and the same for four level keys.
1578 * @param width Number of sysms in syms.
1579 * @param syms The keysyms for the given key (must be size width).
1580 * @param typeNameRtrn Set to the Atom of the type name.
1582 * @returns True if a type could be found, False otherwise.
1585 FindAutomaticType(int width, xkb_keysym_t * syms, xkb_atom_t * typeNameRtrn,
1589 if ((width == 1) || (width == 0))
1591 *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
1594 else if (width == 2)
1596 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1598 *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
1600 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1602 *typeNameRtrn = xkb_intern_atom("KEYPAD");
1607 *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
1611 else if (width <= 4)
1613 if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1614 if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1616 xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
1618 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
1620 else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1621 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
1623 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
1624 /* XXX: why not set autoType here? */
1626 return ((width >= 0) && (width <= 4));
1630 * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1631 * groups, and reduce to one group if all groups are identical anyway.
1634 PrepareKeyDef(KeyInfo * key)
1636 int i, j, width, defined, lastGroup;
1639 defined = key->symsDefined | key->actsDefined | key->typesDefined;
1640 /* get highest group number */
1641 for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1643 if (defined & (1 << i))
1651 /* If there are empty groups between non-empty ones fill them with data */
1652 /* from the first group. */
1653 /* We can make a wrong assumption here. But leaving gaps is worse. */
1654 for (i = lastGroup; i > 0; i--)
1656 if (defined & (1 << i))
1658 width = key->numLevels[0];
1659 if (key->typesDefined & 1)
1661 for (j = 0; j < width; j++)
1663 key->types[i] = key->types[0];
1665 key->typesDefined |= 1 << i;
1667 if ((key->actsDefined & 1) && key->acts[0])
1669 key->acts[i] = uTypedCalloc(width, union xkb_action);
1670 if (key->acts[i] == NULL)
1672 memcpy(key->acts[i], key->acts[0],
1673 width * sizeof(union xkb_action));
1674 key->actsDefined |= 1 << i;
1676 if ((key->symsDefined & 1) && key->syms[0])
1678 key->syms[i] = uTypedCalloc(width, xkb_keysym_t);
1679 if (key->syms[i] == NULL)
1681 memcpy(key->syms[i], key->syms[0], width * sizeof(xkb_keysym_t));
1682 key->symsDefined |= 1 << i;
1686 key->numLevels[i] = key->numLevels[0];
1689 /* If all groups are completely identical remove them all */
1690 /* exept the first one. */
1692 for (i = lastGroup; i > 0; i--)
1694 if ((key->numLevels[i] != key->numLevels[0]) ||
1695 (key->types[i] != key->types[0]))
1700 if ((key->syms[i] != key->syms[0]) &&
1701 (key->syms[i] == NULL || key->syms[0] == NULL ||
1702 memcmp(key->syms[i], key->syms[0],
1703 sizeof(xkb_keysym_t) * key->numLevels[0])))
1708 if ((key->acts[i] != key->acts[0]) &&
1709 (key->acts[i] == NULL || key->acts[0] == NULL ||
1710 memcmp(key->acts[i], key->acts[0],
1711 sizeof(union xkb_action) * key->numLevels[0])))
1719 for (i = lastGroup; i > 0; i--)
1721 key->numLevels[i] = 0;
1723 key->syms[i] = NULL;
1725 key->acts[i] = NULL;
1728 key->symsDefined &= 1;
1729 key->actsDefined &= 1;
1730 key->typesDefined &= 1;
1735 * Copy the KeyInfo into the keyboard description.
1737 * This function recurses.
1740 CopySymbolsDef(struct xkb_desc * xkb, KeyInfo *key, int start_from)
1744 unsigned width, tmp, nGroups;
1745 struct xkb_key_type * type;
1746 Bool haveActions, autoType, useAlias;
1747 xkb_keysym_t *outSyms;
1748 union xkb_action *outActs;
1749 unsigned types[XkbNumKbdGroups];
1751 useAlias = (start_from == 0);
1753 /* get the keycode for the key. */
1754 if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb),
1757 if ((start_from == 0) && (warningLevel >= 5))
1759 WARN("Key %s not found in keycodes\n", longText(key->name));
1760 ACTION("Symbols ignored\n");
1765 haveActions = False;
1766 for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1768 if (((i + 1) > nGroups)
1769 && (((key->symsDefined | key->actsDefined) & (1 << i))
1770 || (key->typesDefined) & (1 << i)))
1775 /* Assign the type to the key, if it is missing. */
1776 if (key->types[i] == None)
1778 if (key->dfltType != None)
1779 key->types[i] = key->dfltType;
1780 else if (FindAutomaticType(key->numLevels[i], key->syms[i],
1781 &key->types[i], &autoType))
1786 if (warningLevel >= 5)
1788 WARN("No automatic type for %d symbols\n",
1789 (unsigned int) key->numLevels[i]);
1790 ACTION("Using %s for the %s key (keycode %d)\n",
1791 XkbcAtomText(key->types[i]),
1792 longText(key->name), kc);
1796 if (FindNamedType(xkb, key->types[i], &types[i]))
1798 if (!autoType || key->numLevels[i] > 2)
1799 xkb->server->explicit[kc] |= (1 << i);
1803 if (warningLevel >= 3)
1805 WARN("Type \"%s\" is not defined\n",
1806 XkbcAtomText(key->types[i]));
1807 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
1808 longText(key->name), kc);
1810 types[i] = XkbTwoLevelIndex;
1812 /* if the type specifies less syms than the key has, shrink the key */
1813 type = &xkb->map->types[types[i]];
1814 if (type->num_levels < key->numLevels[i])
1816 if (warningLevel > 0)
1818 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
1819 type->name, type->num_levels,
1820 XkbcAtomText(key->name), key->numLevels[i]);
1821 ACTION("Ignoring extra symbols\n");
1823 key->numLevels[i] = type->num_levels;
1825 if (key->numLevels[i] > width)
1826 width = key->numLevels[i];
1827 if (type->num_levels > width)
1828 width = type->num_levels;
1831 /* width is now the largest width found */
1833 i = width * nGroups;
1834 outSyms = XkbcResizeKeySyms(xkb, kc, i);
1835 if (outSyms == NULL)
1837 WSGO("Could not enlarge symbols for %s (keycode %d)\n",
1838 longText(key->name), kc);
1843 outActs = XkbcResizeKeyActions(xkb, kc, i);
1844 if (outActs == NULL)
1846 WSGO("Could not enlarge actions for %s (key %d)\n",
1847 longText(key->name), kc);
1850 xkb->server->explicit[kc] |= XkbExplicitInterpretMask;
1854 if (key->defs.defined & _Key_GroupInfo)
1857 i = xkb->map->key_sym_map[kc].group_info;
1859 xkb->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
1860 xkb->map->key_sym_map[kc].width = width;
1861 for (i = 0; i < nGroups; i++)
1863 /* assign kt_index[i] to the index of the type in map->types.
1864 * kt_index[i] may have been set by a previous run (if we have two
1865 * layouts specified). Let's not overwrite it with the ONE_LEVEL
1866 * default group if we dont even have keys for this group anyway.
1868 * FIXME: There should be a better fix for this.
1870 if (key->numLevels[i])
1871 xkb->map->key_sym_map[kc].kt_index[i] = types[i];
1872 if (key->syms[i] != NULL)
1874 /* fill key to "width" symbols*/
1875 for (tmp = 0; tmp < width; tmp++)
1877 if (tmp < key->numLevels[i])
1878 outSyms[tmp] = key->syms[i][tmp];
1880 outSyms[tmp] = NoSymbol;
1881 if ((outActs != NULL) && (key->acts[i] != NULL))
1883 if (tmp < key->numLevels[i])
1884 outActs[tmp] = key->acts[i][tmp];
1886 outActs[tmp].type = XkbSA_NoAction;
1894 switch (key->behavior.type & XkbKB_OpMask)
1899 xkb->server->behaviors[kc] = key->behavior;
1900 xkb->server->explicit[kc] |= XkbExplicitBehaviorMask;
1903 if (key->defs.defined & _Key_VModMap)
1905 xkb->server->vmodmap[kc] = key->vmodmap;
1906 xkb->server->explicit[kc] |= XkbExplicitVModMapMask;
1908 if (key->repeat != RepeatUndefined)
1910 if (key->repeat == RepeatYes)
1911 xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
1913 xkb->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
1914 xkb->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
1917 if (nGroups > xkb->ctrls->num_groups)
1918 xkb->ctrls->num_groups = nGroups;
1920 /* do the same thing for the next key */
1921 CopySymbolsDef(xkb, key, kc + 1);
1926 CopyModMapDef(struct xkb_desc * xkb, ModMapEntry *entry)
1930 if ((!entry->haveSymbol)
1933 (xkb, entry->u.keyName, &kc, True, CreateKeyNames(xkb), 0)))
1935 if (warningLevel >= 5)
1937 WARN("Key %s not found in keycodes\n",
1938 longText(entry->u.keyName));
1939 ACTION("Modifier map entry for %s not updated\n",
1940 XkbcModIndexText(entry->modifier));
1944 else if (entry->haveSymbol
1945 && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc)))
1947 if (warningLevel > 5)
1949 WARN("Key \"%s\" not found in symbol map\n",
1950 XkbcKeysymText(entry->u.keySym));
1951 ACTION("Modifier map entry for %s not updated\n",
1952 XkbcModIndexText(entry->modifier));
1956 xkb->map->modmap[kc] |= (1 << entry->modifier);
1961 * Handle the xkb_symbols section of an xkb file.
1963 * @param file The parsed xkb_symbols section of the xkb file.
1964 * @param xkb Handle to the keyboard description to store the symbols in.
1965 * @param merge Merge strategy (e.g. MergeOverride).
1968 CompileSymbols(XkbFile *file, struct xkb_desc * xkb, unsigned merge)
1973 InitSymbolsInfo(&info, xkb);
1974 info.dflt.defs.fileID = file->id;
1975 info.dflt.defs.merge = merge;
1976 HandleSymbolsFile(file, xkb, merge, &info);
1978 if (info.nKeys == 0) {
1979 FreeSymbolsInfo(&info);
1983 if (info.errorCount == 0)
1987 /* alloc memory in the xkb struct */
1988 if (XkbcAllocNames(xkb, XkbGroupNamesMask, 0) != Success)
1990 WSGO("Can not allocate names in CompileSymbols\n");
1991 ACTION("Symbols not added\n");
1994 if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
1997 WSGO("Could not allocate client map in CompileSymbols\n");
1998 ACTION("Symbols not added\n");
2001 if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success)
2003 WSGO("Could not allocate server map in CompileSymbols\n");
2004 ACTION("Symbols not added\n");
2007 if (XkbcAllocControls(xkb, XkbPerKeyRepeatMask) != Success)
2009 WSGO("Could not allocate controls in CompileSymbols\n");
2010 ACTION("Symbols not added\n");
2014 /* now copy info into xkb. */
2016 ApplyAliases(xkb, &info.aliases);
2017 for (i = 0; i < XkbNumKbdGroups; i++)
2019 if (info.groupNames[i] != None)
2021 free(UNCONSTIFY(xkb->names->groups[i]));
2022 xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
2026 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2031 for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2033 if (!CopySymbolsDef(xkb, key, 0))
2036 if (warningLevel > 3)
2038 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++)
2040 if (xkb->names->keys[i].name[0] == '\0')
2042 if (XkbKeyNumGroups(xkb, i) < 1)
2045 memcpy(buf, xkb->names->keys[i].name, 4);
2048 ("No symbols defined for <%s> (keycode %d)\n",
2055 ModMapEntry *mm, *next;
2056 for (mm = info.modMap; mm != NULL; mm = next)
2058 if (!CopyModMapDef(xkb, mm))
2060 next = (ModMapEntry *) mm->defs.next;
2063 FreeSymbolsInfo(&info);
2067 FreeSymbolsInfo(&info);