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 ********************************************************/
34 #include "parseutils.h"
36 typedef struct _PreserveInfo
39 short matchingMapIndex;
40 unsigned char indexMods;
41 unsigned char preMods;
42 unsigned short indexVMods;
43 unsigned short preVMods;
46 #define _KT_Name (1<<0)
47 #define _KT_Mask (1<<1)
48 #define _KT_Map (1<<2)
49 #define _KT_Preserve (1<<3)
50 #define _KT_LevelNames (1<<4)
52 typedef struct _KeyTypeInfo
63 struct xkb_kt_map_entry * entries;
64 PreserveInfo *preserve;
69 typedef struct _KeyTypesInfo
81 static xkb_atom_t tok_ONE_LEVEL;
82 static xkb_atom_t tok_TWO_LEVEL;
83 static xkb_atom_t tok_ALPHABETIC;
84 static xkb_atom_t tok_KEYPAD;
86 /***====================================================================***/
88 #define ReportTypeShouldBeArray(t, f) \
89 ReportShouldBeArray("key type", (f), TypeTxt(t))
90 #define ReportTypeBadType(t, f, w) \
91 ReportBadType("key type", (f), TypeTxt(t), (w))
93 /***====================================================================***/
95 #define MapEntryTxt(x, e) \
96 XkbcVModMaskText((x), (e)->mods.real_mods, (e)->mods.vmods)
97 #define PreserveIndexTxt(x, p) \
98 XkbcVModMaskText((x), (p)->indexMods, (p)->indexVMods)
99 #define PreserveTxt(x, p) \
100 XkbcVModMaskText((x), (p)->preMods, (p)->preVMods)
102 XkbcAtomText((t)->name)
103 #define TypeMaskTxt(t, x) \
104 XkbcVModMaskText((x), (t)->mask, (t)->vmask)
106 /***====================================================================***/
109 InitKeyTypesInfo(KeyTypesInfo * info, struct xkb_keymap * xkb, KeyTypesInfo * from)
111 tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
112 tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
113 tok_ALPHABETIC = xkb_intern_atom("ALPHABETIC");
114 tok_KEYPAD = xkb_intern_atom("KEYPAD");
115 info->name = strdup("default");
116 info->errorCount = 0;
117 info->stdPresent = 0;
120 info->dflt.defs.defined = 0;
121 info->dflt.defs.fileID = 0;
122 info->dflt.defs.merge = MergeOverride;
123 info->dflt.defs.next = NULL;
124 info->dflt.name = XKB_ATOM_NONE;
126 info->dflt.vmask = 0;
127 info->dflt.groupInfo = false;
128 info->dflt.numLevels = 1;
129 info->dflt.nEntries = info->dflt.szEntries = 0;
130 info->dflt.entries = NULL;
131 info->dflt.szNames = 0;
132 info->dflt.lvlNames = NULL;
133 info->dflt.preserve = NULL;
134 InitVModInfo(&info->vmods, xkb);
137 info->dflt = from->dflt;
138 if (from->dflt.entries)
140 info->dflt.entries = uTypedCalloc(from->dflt.szEntries,
141 struct xkb_kt_map_entry);
142 if (info->dflt.entries)
144 unsigned sz = from->dflt.nEntries * sizeof(struct xkb_kt_map_entry);
145 memcpy(info->dflt.entries, from->dflt.entries, sz);
148 if (from->dflt.lvlNames)
150 info->dflt.lvlNames = uTypedCalloc(from->dflt.szNames, xkb_atom_t);
151 if (info->dflt.lvlNames)
153 unsigned sz = from->dflt.szNames * sizeof(xkb_atom_t);
154 memcpy(info->dflt.lvlNames, from->dflt.lvlNames, sz);
157 if (from->dflt.preserve)
159 PreserveInfo *old, *new, *last;
161 old = from->dflt.preserve;
162 for (; old; old = (PreserveInfo *) old->defs.next)
164 new = uTypedAlloc(PreserveInfo);
168 new->defs.next = NULL;
170 last->defs.next = (CommonInfo *) new;
172 info->dflt.preserve = new;
180 FreeKeyTypeInfo(KeyTypeInfo * type)
183 type->entries = NULL;
184 free(type->lvlNames);
185 type->lvlNames = NULL;
186 if (type->preserve != NULL)
188 ClearCommonInfo(&type->preserve->defs);
189 type->preserve = NULL;
194 FreeKeyTypesInfo(KeyTypesInfo * info)
201 for (type = info->types; type; type = (KeyTypeInfo *) type->defs.next)
203 FreeKeyTypeInfo(type);
205 info->types = (KeyTypeInfo *) ClearCommonInfo(&info->types->defs);
207 FreeKeyTypeInfo(&info->dflt);
211 NextKeyType(KeyTypesInfo * info)
215 type = uTypedAlloc(KeyTypeInfo);
218 memset(type, 0, sizeof(KeyTypeInfo));
219 type->defs.fileID = info->fileID;
220 info->types = (KeyTypeInfo *) AddCommonInfo(&info->types->defs,
221 (CommonInfo *) type);
228 FindMatchingKeyType(KeyTypesInfo * info, KeyTypeInfo * new)
232 for (old = info->types; old; old = (KeyTypeInfo *) old->defs.next)
234 if (old->name == new->name)
241 ReportTypeBadWidth(const char *type, int has, int needs)
243 ERROR("Key type \"%s\" has %d levels, must have %d\n", type, has, needs);
244 ACTION("Illegal type definition ignored\n");
249 AddKeyType(struct xkb_keymap * xkb, KeyTypesInfo * info, KeyTypeInfo * new)
253 if (new->name == tok_ONE_LEVEL)
255 if (new->numLevels > 1)
256 return ReportTypeBadWidth("ONE_LEVEL", new->numLevels, 1);
257 info->stdPresent |= XkbOneLevelMask;
259 else if (new->name == tok_TWO_LEVEL)
261 if (new->numLevels > 2)
262 return ReportTypeBadWidth("TWO_LEVEL", new->numLevels, 2);
263 else if (new->numLevels < 2)
265 info->stdPresent |= XkbTwoLevelMask;
267 else if (new->name == tok_ALPHABETIC)
269 if (new->numLevels > 2)
270 return ReportTypeBadWidth("ALPHABETIC", new->numLevels, 2);
271 else if (new->numLevels < 2)
273 info->stdPresent |= XkbAlphabeticMask;
275 else if (new->name == tok_KEYPAD)
277 if (new->numLevels > 2)
278 return ReportTypeBadWidth("KEYPAD", new->numLevels, 2);
279 else if (new->numLevels < 2)
281 info->stdPresent |= XkbKeypadMask;
284 old = FindMatchingKeyType(info, new);
288 if ((new->defs.merge == MergeReplace)
289 || (new->defs.merge == MergeOverride))
291 KeyTypeInfo *next = (KeyTypeInfo *) old->defs.next;
292 if (((old->defs.fileID == new->defs.fileID)
293 && (warningLevel > 0)) || (warningLevel > 9))
295 WARN("Multiple definitions of the %s key type\n",
296 XkbcAtomText(new->name));
297 ACTION("Earlier definition ignored\n");
299 FreeKeyTypeInfo(old);
301 new->szEntries = new->nEntries = 0;
303 new->preserve = NULL;
304 new->lvlNames = NULL;
305 old->defs.next = &next->defs;
308 report = (old->defs.fileID == new->defs.fileID) && (warningLevel > 0);
311 WARN("Multiple definitions of the %s key type\n",
312 XkbcAtomText(new->name));
313 ACTION("Later definition ignored\n");
315 FreeKeyTypeInfo(new);
318 old = NextKeyType(info);
322 old->defs.next = NULL;
323 new->nEntries = new->szEntries = 0;
326 new->lvlNames = NULL;
327 new->preserve = NULL;
331 /***====================================================================***/
334 MergeIncludedKeyTypes(KeyTypesInfo * into,
335 KeyTypesInfo * from, unsigned merge, struct xkb_keymap * xkb)
339 if (from->errorCount > 0)
341 into->errorCount += from->errorCount;
344 if (into->name == NULL)
346 into->name = from->name;
349 for (type = from->types; type; type = (KeyTypeInfo *) type->defs.next)
351 if (merge != MergeDefault)
352 type->defs.merge = merge;
353 if (!AddKeyType(xkb, into, type))
356 into->stdPresent |= from->stdPresent;
359 typedef void (*FileHandler) (XkbFile *file, struct xkb_keymap *xkb,
360 unsigned merge, KeyTypesInfo *included);
363 HandleIncludeKeyTypes(IncludeStmt * stmt,
364 struct xkb_keymap * xkb, KeyTypesInfo * info, FileHandler hndlr)
368 KeyTypesInfo included;
372 if ((stmt->file == NULL) && (stmt->map == NULL))
376 memset(info, 0, sizeof(KeyTypesInfo));
378 else if (ProcessIncludeFile(xkb->context, stmt, XkmTypesIndex, &rtrn,
381 InitKeyTypesInfo(&included, xkb, info);
382 included.fileID = included.dflt.defs.fileID = rtrn->id;
383 included.dflt.defs.merge = newMerge;
385 (*hndlr) (rtrn, xkb, newMerge, &included);
386 if (stmt->stmt != NULL)
389 included.name = stmt->stmt;
396 info->errorCount += 10;
399 if ((stmt->next != NULL) && (included.errorCount < 1))
403 KeyTypesInfo next_incl;
405 for (next = stmt->next; next != NULL; next = next->next)
407 if ((next->file == NULL) && (next->map == NULL))
410 MergeIncludedKeyTypes(&included, info, next->merge, xkb);
411 FreeKeyTypesInfo(info);
413 else if (ProcessIncludeFile(xkb->context, next, XkmTypesIndex,
416 InitKeyTypesInfo(&next_incl, xkb, &included);
417 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
418 next_incl.dflt.defs.merge = op;
419 (*hndlr) (rtrn, xkb, op, &next_incl);
420 MergeIncludedKeyTypes(&included, &next_incl, op, xkb);
421 FreeKeyTypesInfo(&next_incl);
426 info->errorCount += 10;
427 FreeKeyTypesInfo(&included);
436 MergeIncludedKeyTypes(info, &included, newMerge, xkb);
437 FreeKeyTypesInfo(&included);
439 return (info->errorCount == 0);
442 /***====================================================================***/
444 static struct xkb_kt_map_entry *
445 FindMatchingMapEntry(KeyTypeInfo * type, unsigned mask, unsigned vmask)
448 struct xkb_kt_map_entry * entry;
450 for (i = 0, entry = type->entries; i < type->nEntries; i++, entry++)
452 if ((entry->mods.real_mods == mask) && (entry->mods.vmods == vmask))
459 DeleteLevel1MapEntries(KeyTypeInfo * type)
463 for (i = 0; i < type->nEntries; i++)
465 if (type->entries[i].level == 0)
467 for (n = i; n < type->nEntries - 1; n++)
469 type->entries[n] = type->entries[n + 1];
477 * Return a pointer to the next free XkbcKTMapEntry, reallocating space if
480 static struct xkb_kt_map_entry *
481 NextMapEntry(KeyTypeInfo * type)
483 if (type->entries == NULL)
485 type->entries = uTypedCalloc(2, struct xkb_kt_map_entry);
486 if (type->entries == NULL)
488 ERROR("Couldn't allocate map entries for %s\n", TypeTxt(type));
489 ACTION("Map entries lost\n");
495 else if (type->nEntries >= type->szEntries)
497 type->szEntries *= 2;
498 type->entries = uTypedRecalloc(type->entries,
499 type->nEntries, type->szEntries,
500 struct xkb_kt_map_entry);
501 if (type->entries == NULL)
503 ERROR("Couldn't reallocate map entries for %s\n", TypeTxt(type));
504 ACTION("Map entries lost\n");
508 return &type->entries[type->nEntries++];
512 AddPreserve(struct xkb_keymap * xkb,
513 KeyTypeInfo * type, PreserveInfo * new, bool clobber, bool report)
517 old = type->preserve;
520 if ((old->indexMods != new->indexMods) ||
521 (old->indexVMods != new->indexVMods))
523 old = (PreserveInfo *) old->defs.next;
526 if ((old->preMods == new->preMods)
527 && (old->preVMods == new->preVMods))
529 if (warningLevel > 9)
531 WARN("Identical definitions for preserve[%s] in %s\n",
532 PreserveIndexTxt(xkb, old), TypeTxt(type));
537 if (report && (warningLevel > 0))
540 WARN("Multiple definitions for preserve[%s] in %s\n",
541 PreserveIndexTxt(xkb, old), TypeTxt(type));
544 str = PreserveTxt(xkb, new);
546 str = PreserveTxt(xkb, old);
547 ACTION("Using %s, ", str);
549 str = PreserveTxt(xkb, old);
551 str = PreserveTxt(xkb, new);
552 INFO("ignoring %s\n", str);
556 old->preMods = new->preMods;
557 old->preVMods = new->preVMods;
561 old = uTypedAlloc(PreserveInfo);
564 WSGO("Couldn't allocate preserve in %s\n", TypeTxt(type));
565 ACTION("Preserve[%s] lost\n", PreserveIndexTxt(xkb, new));
569 old->matchingMapIndex = -1;
571 (PreserveInfo *) AddCommonInfo(&type->preserve->defs, &old->defs);
576 * Add a new KTMapEntry to the given key type. If an entry with the same mods
577 * already exists, the level is updated (if clobber is TRUE). Otherwise, a new
580 * @param clobber Overwrite existing entry.
581 * @param report true if a warning is to be printed on.
584 AddMapEntry(struct xkb_keymap * xkb,
586 struct xkb_kt_map_entry * new, bool clobber, bool report)
588 struct xkb_kt_map_entry * old;
591 FindMatchingMapEntry(type, new->mods.real_mods, new->mods.vmods)))
593 if (report && (old->level != new->level))
595 unsigned use, ignore;
598 use = new->level + 1;
599 ignore = old->level + 1;
603 use = old->level + 1;
604 ignore = new->level + 1;
606 WARN("Multiple map entries for %s in %s\n",
607 MapEntryTxt(xkb, new), TypeTxt(type));
608 ACTION("Using %d, ignoring %d\n", use, ignore);
610 else if (warningLevel > 9)
612 WARN("Multiple occurences of map[%s]= %d in %s\n",
613 MapEntryTxt(xkb, new), new->level + 1, TypeTxt(type));
618 old->level = new->level;
621 if ((old = NextMapEntry(type)) == NULL)
622 return false; /* allocation failure, already reported */
623 if (new->level >= type->numLevels)
624 type->numLevels = new->level + 1;
625 if (new->mods.vmods == 0)
629 old->mods.mask = new->mods.real_mods;
630 old->mods.real_mods = new->mods.real_mods;
631 old->mods.vmods = new->mods.vmods;
632 old->level = new->level;
637 SetMapEntry(KeyTypeInfo * type,
638 struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value)
641 struct xkb_kt_map_entry entry;
643 if (arrayNdx == NULL)
644 return ReportTypeShouldBeArray(type, "map entry");
645 if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb))
646 return ReportTypeBadType(type, "map entry", "modifier mask");
647 entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
648 entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
649 if ((entry.mods.real_mods & (~type->mask)) ||
650 ((entry.mods.vmods & (~type->vmask)) != 0))
652 if (warningLevel > 0)
654 WARN("Map entry for unused modifiers in %s\n", TypeTxt(type));
655 ACTION("Using %s instead of ",
656 XkbcVModMaskText(xkb,
657 entry.mods.real_mods & type->mask,
658 entry.mods.vmods & type->vmask));
659 INFO("%s\n", MapEntryTxt(xkb, &entry));
661 entry.mods.real_mods &= type->mask;
662 entry.mods.vmods &= type->vmask;
664 if (!ExprResolveLevel(value, &rtrn))
666 ERROR("Level specifications in a key type must be integer\n");
667 ACTION("Ignoring malformed level specification\n");
670 entry.level = rtrn.ival - 1;
671 return AddMapEntry(xkb, type, &entry, true, true);
675 SetPreserve(KeyTypeInfo * type,
676 struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value)
681 if (arrayNdx == NULL)
682 return ReportTypeShouldBeArray(type, "preserve entry");
683 if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb))
684 return ReportTypeBadType(type, "preserve entry", "modifier mask");
685 new.defs = type->defs;
686 new.defs.next = NULL;
687 new.indexMods = rtrn.uval & 0xff;
688 new.indexVMods = (rtrn.uval >> 8) & 0xffff;
689 if ((new.indexMods & (~type->mask)) || (new.indexVMods & (~type->vmask)))
691 if (warningLevel > 0)
693 WARN("Preserve for modifiers not used by the %s type\n",
695 ACTION("Index %s converted to ", PreserveIndexTxt(xkb, &new));
697 new.indexMods &= type->mask;
698 new.indexVMods &= type->vmask;
699 if (warningLevel > 0)
700 INFO("%s\n", PreserveIndexTxt(xkb, &new));
702 if (!ExprResolveVModMask(value, &rtrn, xkb))
704 ERROR("Preserve value in a key type is not a modifier mask\n");
705 ACTION("Ignoring preserve[%s] in type %s\n",
706 PreserveIndexTxt(xkb, &new), TypeTxt(type));
709 new.preMods = rtrn.uval & 0xff;
710 new.preVMods = (rtrn.uval >> 16) & 0xffff;
711 if ((new.preMods & (~new.indexMods))
712 || (new.preVMods & (~new.indexVMods)))
714 if (warningLevel > 0)
716 WARN("Illegal value for preserve[%s] in type %s\n",
717 PreserveTxt(xkb, &new), TypeTxt(type));
718 ACTION("Converted %s to ", PreserveIndexTxt(xkb, &new));
720 new.preMods &= new.indexMods;
721 new.preVMods &= new.indexVMods;
722 if (warningLevel > 0)
724 INFO("%s\n", PreserveIndexTxt(xkb, &new));
727 return AddPreserve(xkb, type, &new, true, true);
730 /***====================================================================***/
733 AddLevelName(KeyTypeInfo * type,
734 unsigned level, xkb_atom_t name, bool clobber, bool report)
736 if ((type->lvlNames == NULL) || (type->szNames <= level))
739 uTypedRecalloc(type->lvlNames, type->szNames, level + 1, xkb_atom_t);
740 if (type->lvlNames == NULL)
742 ERROR("Couldn't allocate level names for type %s\n",
744 ACTION("Level names lost\n");
748 type->szNames = level + 1;
750 else if (type->lvlNames[level] == name)
752 if (warningLevel > 9)
754 WARN("Duplicate names for level %d of key type %s\n",
755 level + 1, TypeTxt(type));
760 else if (type->lvlNames[level] != XKB_ATOM_NONE)
762 if (warningLevel > 0)
764 const char *old, *new;
765 old = XkbcAtomText(type->lvlNames[level]);
766 new = XkbcAtomText(name);
767 WARN("Multiple names for level %d of key type %s\n",
768 level + 1, TypeTxt(type));
770 ACTION("Using %s, ignoring %s\n", new, old);
772 ACTION("Using %s, ignoring %s\n", old, new);
777 if (level >= type->numLevels)
778 type->numLevels = level + 1;
779 type->lvlNames[level] = name;
784 SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value)
788 xkb_atom_t level_name;
790 if (arrayNdx == NULL)
791 return ReportTypeShouldBeArray(type, "level name");
792 if (!ExprResolveLevel(arrayNdx, &rtrn))
793 return ReportTypeBadType(type, "level name", "integer");
794 level = rtrn.ival - 1;
795 if (!ExprResolveString(value, &rtrn))
797 ERROR("Non-string name for level %d in key type %s\n", level + 1,
798 XkbcAtomText(type->name));
799 ACTION("Ignoring illegal level name definition\n");
802 level_name = xkb_intern_atom(rtrn.str);
804 return AddLevelName(type, level, level_name, true, true);
807 /***====================================================================***/
810 * Parses the fields in a type "..." { } description.
812 * @param field The field to parse (e.g. modifiers, map, level_name)
815 SetKeyTypeField(KeyTypeInfo * type,
816 struct xkb_keymap * xkb,
818 ExprDef * arrayNdx, ExprDef * value, KeyTypesInfo * info)
822 if (strcasecmp(field, "modifiers") == 0)
824 unsigned mods, vmods;
825 if (arrayNdx != NULL)
827 WARN("The modifiers field of a key type is not an array\n");
828 ACTION("Illegal array subscript ignored\n");
830 /* get modifier mask for current type */
831 if (!ExprResolveVModMask(value, &tmp, xkb))
833 ERROR("Key type mask field must be a modifier mask\n");
834 ACTION("Key type definition ignored\n");
837 mods = tmp.uval & 0xff; /* core mods */
838 vmods = (tmp.uval >> 8) & 0xffff; /* xkb virtual mods */
839 if (type->defs.defined & _KT_Mask)
841 WARN("Multiple modifier mask definitions for key type %s\n",
842 XkbcAtomText(type->name));
843 ACTION("Using %s, ", TypeMaskTxt(type, xkb));
844 INFO("ignoring %s\n", XkbcVModMaskText(xkb, mods, vmods));
849 type->defs.defined |= _KT_Mask;
852 else if (strcasecmp(field, "map") == 0)
854 type->defs.defined |= _KT_Map;
855 return SetMapEntry(type, xkb, arrayNdx, value);
857 else if (strcasecmp(field, "preserve") == 0)
859 type->defs.defined |= _KT_Preserve;
860 return SetPreserve(type, xkb, arrayNdx, value);
862 else if ((strcasecmp(field, "levelname") == 0) ||
863 (strcasecmp(field, "level_name") == 0))
865 type->defs.defined |= _KT_LevelNames;
866 return SetLevelName(type, arrayNdx, value);
868 ERROR("Unknown field %s in key type %s\n", field, TypeTxt(type));
869 ACTION("Definition ignored\n");
874 HandleKeyTypeVar(VarDef * stmt, struct xkb_keymap * xkb, KeyTypesInfo * info)
876 ExprResult elem, field;
879 if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx))
880 return false; /* internal error, already reported */
881 if (elem.str && (strcasecmp(elem.str, "type") == 0))
882 return SetKeyTypeField(&info->dflt, xkb, field.str, arrayNdx,
884 if (elem.str != NULL)
886 ERROR("Default for unknown element %s\n", uStringText(elem.str));
887 ACTION("Value for field %s ignored\n", uStringText(field.str));
889 else if (field.str != NULL)
891 ERROR("Default defined for unknown field %s\n",
892 uStringText(field.str));
899 HandleKeyTypeBody(VarDef * def,
900 struct xkb_keymap * xkb, KeyTypeInfo * type, KeyTypesInfo * info)
903 ExprResult tmp, field;
906 for (; def != NULL; def = (VarDef *) def->common.next)
908 if ((def->name) && (def->name->type == ExprFieldRef))
910 ok = HandleKeyTypeVar(def, xkb, info);
913 ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
915 ok = SetKeyTypeField(type, xkb, field.str, arrayNdx, def->value,
924 * Process a type "XYZ" { } specification in the xkb_types section.
928 HandleKeyTypeDef(KeyTypeDef * def,
929 struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info)
934 if (def->merge != MergeDefault)
937 type.defs.defined = 0;
938 type.defs.fileID = info->fileID;
939 type.defs.merge = merge;
940 type.defs.next = NULL;
941 type.name = def->name;
942 type.mask = info->dflt.mask;
943 type.vmask = info->dflt.vmask;
944 type.groupInfo = info->dflt.groupInfo;
946 type.nEntries = type.szEntries = 0;
949 type.lvlNames = NULL;
950 type.preserve = NULL;
952 /* Parse the actual content. */
953 if (!HandleKeyTypeBody(def->body, xkb, &type, info))
959 /* now copy any appropriate map, preserve or level names from the */
961 for (i = 0; i < info->dflt.nEntries; i++)
963 struct xkb_kt_map_entry * dflt;
964 dflt = &info->dflt.entries[i];
965 if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) &&
966 ((dflt->mods.vmods & type.vmask) == dflt->mods.vmods))
968 AddMapEntry(xkb, &type, dflt, false, false);
971 if (info->dflt.preserve)
973 PreserveInfo *dflt = info->dflt.preserve;
976 if (((dflt->indexMods & type.mask) == dflt->indexMods) &&
977 ((dflt->indexVMods & type.vmask) == dflt->indexVMods))
979 AddPreserve(xkb, &type, dflt, false, false);
981 dflt = (PreserveInfo *) dflt->defs.next;
984 for (i = 0; i < info->dflt.szNames; i++)
986 if ((i < type.numLevels) && (info->dflt.lvlNames[i] != XKB_ATOM_NONE))
988 AddLevelName(&type, i, info->dflt.lvlNames[i], false, false);
991 /* Now add the new keytype to the info struct */
992 if (!AddKeyType(xkb, info, &type))
1001 * Process an xkb_types section.
1003 * @param file The parsed xkb_types section.
1004 * @param merge Merge Strategy (e.g. MergeOverride)
1005 * @param info Pointer to memory where the outcome will be stored.
1008 HandleKeyTypesFile(XkbFile * file,
1009 struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info)
1014 info->name = uDupString(file->name);
1018 switch (stmt->stmtType)
1021 if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, xkb, info,
1022 HandleKeyTypesFile))
1025 case StmtKeyTypeDef: /* e.g. type "ONE_LEVEL" */
1026 if (!HandleKeyTypeDef((KeyTypeDef *) stmt, xkb, merge, info))
1030 if (!HandleKeyTypeVar((VarDef *) stmt, xkb, info))
1033 case StmtVModDef: /* virtual_modifiers NumLock, ... */
1034 if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
1037 case StmtKeyAliasDef:
1038 ERROR("Key type files may not include other declarations\n");
1039 ACTION("Ignoring definition of key alias\n");
1042 case StmtKeycodeDef:
1043 ERROR("Key type files may not include other declarations\n");
1044 ACTION("Ignoring definition of key name\n");
1048 ERROR("Key type files may not include other declarations\n");
1049 ACTION("Ignoring definition of symbol interpretation\n");
1053 WSGO("Unexpected statement type %d in HandleKeyTypesFile\n",
1058 if (info->errorCount > 10)
1061 ERROR("Too many errors\n");
1063 ACTION("Abandoning keytypes file \"%s\"\n", file->topName);
1070 CopyDefToKeyType(struct xkb_keymap * xkb, struct xkb_key_type * type, KeyTypeInfo * def)
1075 for (pre = def->preserve; pre != NULL;
1076 pre = (PreserveInfo *) pre->defs.next)
1078 struct xkb_kt_map_entry * match;
1079 struct xkb_kt_map_entry tmp;
1080 tmp.mods.real_mods = pre->indexMods;
1081 tmp.mods.vmods = pre->indexVMods;
1083 AddMapEntry(xkb, def, &tmp, false, false);
1084 match = FindMatchingMapEntry(def, pre->indexMods, pre->indexVMods);
1087 WSGO("Couldn't find matching entry for preserve\n");
1088 ACTION("Aborting\n");
1091 pre->matchingMapIndex = match - def->entries;
1093 type->mods.real_mods = def->mask;
1094 type->mods.vmods = def->vmask;
1095 type->num_levels = def->numLevels;
1096 type->map_count = def->nEntries;
1097 type->map = def->entries;
1100 type->preserve = uTypedCalloc(type->map_count, struct xkb_mods);
1101 if (!type->preserve)
1103 WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");
1104 ACTION("Preserve setting for type %s lost\n",
1105 XkbcAtomText(def->name));
1109 pre = def->preserve;
1110 for (; pre != NULL; pre = (PreserveInfo *) pre->defs.next)
1112 int ndx = pre->matchingMapIndex;
1113 type->preserve[ndx].mask = pre->preMods;
1114 type->preserve[ndx].real_mods = pre->preMods;
1115 type->preserve[ndx].vmods = pre->preVMods;
1120 type->preserve = NULL;
1121 type->name = XkbcAtomGetString(def->name);
1122 if (def->szNames > 0)
1124 type->level_names = uTypedCalloc(def->numLevels, const char *);
1126 /* assert def->szNames<=def->numLevels */
1127 for (i = 0; i < def->szNames; i++)
1129 type->level_names[i] = XkbcAtomGetString(def->lvlNames[i]);
1134 type->level_names = NULL;
1137 def->nEntries = def->szEntries = 0;
1138 def->entries = NULL;
1139 return XkbcComputeEffectiveMap(xkb, type, NULL);
1143 CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge)
1147 InitKeyTypesInfo(&info, xkb, NULL);
1148 info.fileID = file->id;
1149 HandleKeyTypesFile(file, xkb, merge, &info);
1151 if (info.errorCount == 0)
1155 struct xkb_key_type *type, *next;
1158 if ((info.stdPresent & XkbOneLevelMask) == 0)
1160 if ((info.stdPresent & XkbTwoLevelMask) == 0)
1162 if ((info.stdPresent & XkbKeypadMask) == 0)
1164 if ((info.stdPresent & XkbAlphabeticMask) == 0)
1166 if (XkbcAllocClientMap(xkb, XkbKeyTypesMask, i) != Success)
1168 FreeKeyTypesInfo(&info);
1169 WSGO("Couldn't allocate client map\n");
1172 xkb->map->num_types = i;
1173 if (XkbAllRequiredTypes & (~info.stdPresent))
1175 unsigned missing, keypadVMod;
1177 missing = XkbAllRequiredTypes & (~info.stdPresent);
1178 keypadVMod = FindKeypadVMod(xkb);
1179 if (XkbcInitCanonicalKeyTypes(xkb, missing, keypadVMod) != Success)
1181 FreeKeyTypesInfo(&info);
1182 WSGO("Couldn't initialize canonical key types\n");
1185 if (missing & XkbOneLevelMask)
1186 xkb->map->types[XkbOneLevelIndex].name =
1187 XkbcAtomGetString(tok_ONE_LEVEL);
1188 if (missing & XkbTwoLevelMask)
1189 xkb->map->types[XkbTwoLevelIndex].name =
1190 XkbcAtomGetString(tok_TWO_LEVEL);
1191 if (missing & XkbAlphabeticMask)
1192 xkb->map->types[XkbAlphabeticIndex].name =
1193 XkbcAtomGetString(tok_ALPHABETIC);
1194 if (missing & XkbKeypadMask)
1195 xkb->map->types[XkbKeypadIndex].name =
1196 XkbcAtomGetString(tok_KEYPAD);
1198 next = &xkb->map->types[XkbLastRequiredType + 1];
1199 for (i = 0, def = info.types; i < info.nTypes; i++)
1201 if (def->name == tok_ONE_LEVEL)
1202 type = &xkb->map->types[XkbOneLevelIndex];
1203 else if (def->name == tok_TWO_LEVEL)
1204 type = &xkb->map->types[XkbTwoLevelIndex];
1205 else if (def->name == tok_ALPHABETIC)
1206 type = &xkb->map->types[XkbAlphabeticIndex];
1207 else if (def->name == tok_KEYPAD)
1208 type = &xkb->map->types[XkbKeypadIndex];
1211 DeleteLevel1MapEntries(def);
1212 if (!CopyDefToKeyType(xkb, type, def)) {
1213 FreeKeyTypesInfo(&info);
1216 def = (KeyTypeInfo *) def->defs.next;
1218 FreeKeyTypesInfo(&info);
1222 FreeKeyTypesInfo(&info);