X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fxkbcomp%2Fsymbols.c;h=58f73e673b5149763e1fbc78c2c9e27a4b0e5d2a;hb=efb93c3632c1671a098293c8c79cd21f9fe7a985;hp=361263236a922bb8b45f1b2abbdeaadb83ee90d6;hpb=164cec663600703987010a20cad895ad5b9efd09;p=platform%2Fupstream%2Flibxkbcommon.git

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index 3612632..58f73e6 100644
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -51,15 +51,17 @@
  *         Ran Benita <ran234@gmail.com>
  */
 
+#include "config.h"
+
 #include "xkbcomp-priv.h"
 #include "text.h"
 #include "expr.h"
 #include "action.h"
 #include "vmod.h"
-#include "keycodes.h"
 #include "include.h"
 #include "keysym.h"
 
+
 enum key_repeat {
     KEY_REPEAT_UNDEFINED = 0,
     KEY_REPEAT_YES = 1,
@@ -73,10 +75,10 @@ enum group_field {
 };
 
 enum key_field {
-    KEY_FIELD_REPEAT    = (1 << 0),
-    KEY_FIELD_TYPE_DFLT = (1 << 1),
+    KEY_FIELD_REPEAT = (1 << 0),
+    KEY_FIELD_DEFAULT_TYPE = (1 << 1),
     KEY_FIELD_GROUPINFO = (1 << 2),
-    KEY_FIELD_VMODMAP   = (1 << 3),
+    KEY_FIELD_VMODMAP = (1 << 3),
 };
 
 typedef struct {
@@ -87,7 +89,6 @@ typedef struct {
 
 typedef struct {
     enum key_field defined;
-    unsigned file_id;
     enum merge_mode merge;
 
     xkb_atom_t name;
@@ -96,7 +97,7 @@ typedef struct {
 
     enum key_repeat repeat;
     xkb_mod_mask_t vmodmap;
-    xkb_atom_t dfltType;
+    xkb_atom_t default_type;
 
     enum xkb_range_exceed_type out_of_range_group_action;
     xkb_layout_index_t out_of_range_group_number;
@@ -127,12 +128,11 @@ ClearGroupInfo(GroupInfo *groupi)
 static void
 CopyGroupInfo(GroupInfo *to, const GroupInfo *from)
 {
-    xkb_level_index_t j;
     to->defined = from->defined;
     to->type = from->type;
     darray_init(to->levels);
     darray_copy(to->levels, from->levels);
-    for (j = 0; j < darray_size(to->levels); j++)
+    for (xkb_level_index_t j = 0; j < darray_size(to->levels); j++)
         if (darray_item(from->levels, j).num_syms > 1)
             darray_item(to->levels, j).u.syms =
                 memdup(darray_item(from->levels, j).u.syms,
@@ -141,12 +141,11 @@ CopyGroupInfo(GroupInfo *to, const GroupInfo *from)
 }
 
 static void
-InitKeyInfo(struct xkb_context *ctx, KeyInfo *keyi, unsigned file_id)
+InitKeyInfo(struct xkb_context *ctx, KeyInfo *keyi)
 {
     memset(keyi, 0, sizeof(*keyi));
-    keyi->file_id = file_id;
     keyi->merge = MERGE_OVERRIDE;
-    keyi->name = xkb_atom_intern(ctx, "*");
+    keyi->name = xkb_atom_intern_literal(ctx, "*");
     keyi->out_of_range_group_action = RANGE_WRAP;
 }
 
@@ -164,6 +163,8 @@ ClearKeyInfo(KeyInfo *keyi)
 typedef struct {
     enum merge_mode merge;
     bool haveSymbol;
+    // NOTE: Can also be XKB_MOD_NONE, meaning
+    //       “don’t add a modifier to the modmap”.
     xkb_mod_index_t modifier;
     union {
         xkb_atom_t keyName;
@@ -174,33 +175,36 @@ typedef struct {
 typedef struct {
     char *name;         /* e.g. pc+us+inet(evdev) */
     int errorCount;
-    unsigned file_id;
     enum merge_mode merge;
     xkb_layout_index_t explicit_group;
     darray(KeyInfo) keys;
-    KeyInfo dflt;
+    KeyInfo default_key;
     ActionsInfo *actions;
     darray(xkb_atom_t) group_names;
-    darray(ModMapEntry) modMaps;
+    darray(ModMapEntry) modmaps;
+    struct xkb_mod_set mods;
 
-    struct xkb_keymap *keymap;
+    struct xkb_context *ctx;
+    /* Needed for AddKeySymbols. */
+    const struct xkb_keymap *keymap;
 } SymbolsInfo;
 
 static void
-InitSymbolsInfo(SymbolsInfo *info, struct xkb_keymap *keymap,
-                unsigned file_id, ActionsInfo *actions)
+InitSymbolsInfo(SymbolsInfo *info, const struct xkb_keymap *keymap,
+                ActionsInfo *actions, const struct xkb_mod_set *mods)
 {
     memset(info, 0, sizeof(*info));
+    info->ctx = keymap->ctx;
     info->keymap = keymap;
-    info->file_id = file_id;
     info->merge = MERGE_OVERRIDE;
-    InitKeyInfo(keymap->ctx, &info->dflt, file_id);
+    InitKeyInfo(keymap->ctx, &info->default_key);
     info->actions = actions;
+    info->mods = *mods;
     info->explicit_group = XKB_LAYOUT_INVALID;
 }
 
 static void
-ClearSymbolsInfo(SymbolsInfo * info)
+ClearSymbolsInfo(SymbolsInfo *info)
 {
     KeyInfo *keyi;
     free(info->name);
@@ -208,14 +212,14 @@ ClearSymbolsInfo(SymbolsInfo * info)
         ClearKeyInfo(keyi);
     darray_free(info->keys);
     darray_free(info->group_names);
-    darray_free(info->modMaps);
-    ClearKeyInfo(&info->dflt);
+    darray_free(info->modmaps);
+    ClearKeyInfo(&info->default_key);
 }
 
 static const char *
 KeyInfoText(SymbolsInfo *info, KeyInfo *keyi)
 {
-    return KeyNameText(info->keymap->ctx, keyi->name);
+    return KeyNameText(info->ctx, keyi->name);
 }
 
 static bool
@@ -223,11 +227,12 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
             bool report, xkb_layout_index_t group, xkb_atom_t key_name)
 {
     xkb_level_index_t i, levels_in_both;
-    struct xkb_context *ctx = info->keymap->ctx;
+    struct xkb_level *level;
 
     /* First find the type of the merged group. */
     if (into->type != from->type) {
         if (from->type == XKB_ATOM_NONE) {
+            /* it's empty for consistency with other comparisons */
         }
         else if (into->type == XKB_ATOM_NONE) {
             into->type = from->type;
@@ -236,12 +241,15 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
             xkb_atom_t use = (clobber ? from->type : into->type);
             xkb_atom_t ignore = (clobber ? into->type : from->type);
 
-            if (report)
-                log_warn(info->keymap->ctx,
+            if (report) {
+                log_warn(info->ctx,
+                         XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS,
                          "Multiple definitions for group %d type of key %s; "
                          "Using %s, ignoring %s\n",
-                         group + 1, KeyNameText(ctx, key_name),
-                         xkb_atom_text(ctx, use), xkb_atom_text(ctx, ignore));
+                         group + 1, KeyNameText(info->ctx, key_name),
+                         xkb_atom_text(info->ctx, use),
+                         xkb_atom_text(info->ctx, ignore));
+            }
 
             into->type = use;
         }
@@ -269,6 +277,7 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
         struct xkb_level *fromLevel = &darray_item(from->levels, i);
 
         if (fromLevel->action.type == ACTION_TYPE_NONE) {
+            /* it's empty for consistency with other comparisons */
         }
         else if (intoLevel->action.type == ACTION_TYPE_NONE) {
             intoLevel->action = fromLevel->action;
@@ -278,18 +287,21 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
             use = (clobber ? &fromLevel->action : &intoLevel->action);
             ignore = (clobber ? &intoLevel->action : &fromLevel->action);
 
-            if (report)
-                log_warn(ctx,
+            if (report) {
+                log_warn(info->ctx,
+                         XKB_WARNING_CONFLICTING_KEY_ACTION,
                          "Multiple actions for level %d/group %u on key %s; "
                          "Using %s, ignoring %s\n",
-                         i + 1, group + 1, KeyNameText(ctx, key_name),
+                         i + 1, group + 1, KeyNameText(info->ctx, key_name),
                          ActionTypeText(use->type),
                          ActionTypeText(ignore->type));
+            }
 
             intoLevel->action = *use;
         }
 
         if (fromLevel->num_syms == 0) {
+            /* it's empty for consistency with other comparisons */
         }
         else if (intoLevel->num_syms == 0) {
             intoLevel->num_syms = fromLevel->num_syms;
@@ -299,14 +311,16 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
                 intoLevel->u.sym = fromLevel->u.sym;
             fromLevel->num_syms = 0;
         }
-        else {
-            if (report)
-                log_warn(ctx,
+        else if (!XkbLevelsSameSyms(fromLevel, intoLevel)) {
+            if (report) {
+                log_warn(info->ctx,
+                         XKB_WARNING_CONFLICTING_KEY_SYMBOL,
                          "Multiple symbols for level %d/group %u on key %s; "
                          "Using %s, ignoring %s\n",
-                         i + 1, group + 1, KeyNameText(ctx, key_name),
+                         i + 1, group + 1, KeyNameText(info->ctx, key_name),
                          (clobber ? "from" : "to"),
                          (clobber ? "to" : "from"));
+            }
 
             if (clobber) {
                 ClearLevelInfo(intoLevel);
@@ -320,9 +334,9 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
         }
     }
     /* If @from has extra levels, get them as well. */
-    for (i = levels_in_both; i < darray_size(from->levels); i++) {
-        darray_append(into->levels, darray_item(from->levels, i));
-        darray_item(from->levels, i).num_syms = 0;
+    darray_foreach_from(level, from->levels, levels_in_both) {
+        darray_append(into->levels, *level);
+        level->num_syms = 0;
     }
     into->defined |= (from->defined & GROUP_FIELD_ACTS);
     into->defined |= (from->defined & GROUP_FIELD_SYMS);
@@ -349,27 +363,23 @@ UseNewKeyField(enum key_field field, enum key_field old, enum key_field new,
 }
 
 static bool
-MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
+MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from, bool same_file)
 {
     xkb_layout_index_t i;
     xkb_layout_index_t groups_in_both;
     enum key_field collide = 0;
-    bool clobber, report;
-    int verbosity = xkb_context_get_log_verbosity(info->keymap->ctx);
+    const int verbosity = xkb_context_get_log_verbosity(info->ctx);
+    const bool clobber = (from->merge != MERGE_AUGMENT);
+    const bool report = (same_file && verbosity > 0) || verbosity > 9;
 
     if (from->merge == MERGE_REPLACE) {
         ClearKeyInfo(into);
         *into = *from;
-        InitKeyInfo(info->keymap->ctx, from, info->file_id);
+        InitKeyInfo(info->ctx, from);
         return true;
     }
 
-    clobber = (from->merge != MERGE_AUGMENT);
-    report = (verbosity > 9 ||
-              (into->file_id == from->file_id && verbosity > 0));
-
-    groups_in_both = MIN(darray_size(into->groups),
-                         darray_size(from->groups));
+    groups_in_both = MIN(darray_size(into->groups), darray_size(from->groups));
     for (i = 0; i < groups_in_both; i++)
         MergeGroups(info,
                     &darray_item(into->groups, i),
@@ -391,10 +401,10 @@ MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
         into->repeat = from->repeat;
         into->defined |= KEY_FIELD_REPEAT;
     }
-    if (UseNewKeyField(KEY_FIELD_TYPE_DFLT, into->defined, from->defined,
+    if (UseNewKeyField(KEY_FIELD_DEFAULT_TYPE, into->defined, from->defined,
                        clobber, report, &collide)) {
-        into->dfltType = from->dfltType;
-        into->defined |= KEY_FIELD_TYPE_DFLT;
+        into->default_type = from->default_type;
+        into->defined |= KEY_FIELD_DEFAULT_TYPE;
     }
     if (UseNewKeyField(KEY_FIELD_GROUPINFO, into->defined, from->defined,
                        clobber, report, &collide)) {
@@ -403,20 +413,23 @@ MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
         into->defined |= KEY_FIELD_GROUPINFO;
     }
 
-    if (collide)
-        log_warn(info->keymap->ctx,
+    if (collide) {
+        log_warn(info->ctx,
+                 XKB_WARNING_CONFLICTING_KEY_FIELDS,
                  "Symbol map for key %s redefined; "
                  "Using %s definition for conflicting fields\n",
-                 KeyNameText(info->keymap->ctx, into->name),
+                 KeyNameText(info->ctx, into->name),
                  (clobber ? "first" : "last"));
+    }
 
     ClearKeyInfo(from);
-    InitKeyInfo(info->keymap->ctx, from, info->file_id);
+    InitKeyInfo(info->ctx, from);
     return true;
 }
 
+/* TODO: Make it so this function doesn't need the entire keymap. */
 static bool
-AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi)
+AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi, bool same_file)
 {
     xkb_atom_t real_name;
     KeyInfo *iter;
@@ -427,15 +440,16 @@ AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi)
      * following loop) is enough, and we won't get multiple KeyInfo's
      * for the same key because of aliases.
      */
-    if (FindKeyNameForAlias(info->keymap, keyi->name, &real_name))
+    real_name = XkbResolveKeyAlias(info->keymap, keyi->name);
+    if (real_name != XKB_ATOM_NONE)
         keyi->name = real_name;
 
     darray_foreach(iter, info->keys)
         if (iter->name == keyi->name)
-            return MergeKeys(info, iter, keyi);
+            return MergeKeys(info, iter, keyi, same_file);
 
     darray_append(info->keys, *keyi);
-    InitKeyInfo(info->keymap->ctx, keyi, info->file_id);
+    InitKeyInfo(info->ctx, keyi);
     return true;
 }
 
@@ -445,7 +459,7 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
     ModMapEntry *old;
     bool clobber = (new->merge != MERGE_AUGMENT);
 
-    darray_foreach(old, info->modMaps) {
+    darray_foreach(old, info->modmaps) {
         xkb_mod_index_t use, ignore;
 
         if ((new->haveSymbol != old->haveSymbol) ||
@@ -459,26 +473,28 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
         use = (clobber ? new->modifier : old->modifier);
         ignore = (clobber ? old->modifier : new->modifier);
 
-        if (new->haveSymbol)
-            log_err(info->keymap->ctx,
-                    "Symbol \"%s\" added to modifier map for multiple modifiers; "
-                    "Using %s, ignoring %s\n",
-                    KeysymText(info->keymap->ctx, new->u.keySym),
-                    ModIndexText(info->keymap, use),
-                    ModIndexText(info->keymap, ignore));
-        else
-            log_err(info->keymap->ctx,
-                    "Key \"%s\" added to modifier map for multiple modifiers; "
-                    "Using %s, ignoring %s\n",
-                    KeyNameText(info->keymap->ctx, new->u.keyName),
-                    ModIndexText(info->keymap, use),
-                    ModIndexText(info->keymap, ignore));
-
+        if (new->haveSymbol) {
+            log_warn(info->ctx,
+                     XKB_WARNING_CONFLICTING_MODMAP,
+                     "Symbol \"%s\" added to modifier map for multiple modifiers; "
+                     "Using %s, ignoring %s\n",
+                     KeysymText(info->ctx, new->u.keySym),
+                     ModIndexText(info->ctx, &info->mods, use),
+                     ModIndexText(info->ctx, &info->mods, ignore));
+        } else {
+            log_warn(info->ctx,
+                     XKB_WARNING_CONFLICTING_MODMAP,
+                     "Key \"%s\" added to modifier map for multiple modifiers; "
+                     "Using %s, ignoring %s\n",
+                     KeyNameText(info->ctx, new->u.keyName),
+                     ModIndexText(info->ctx, &info->mods, use),
+                     ModIndexText(info->ctx, &info->mods, ignore));
+        }
         old->modifier = use;
         return true;
     }
 
-    darray_append(info->modMaps, *new);
+    darray_append(info->modmaps, *new);
     return true;
 }
 
@@ -488,9 +504,6 @@ static void
 MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
                      enum merge_mode merge)
 {
-    unsigned int i;
-    KeyInfo *keyi;
-    ModMapEntry *mm;
     xkb_atom_t *group_name;
     xkb_layout_index_t group_names_in_both;
 
@@ -499,6 +512,8 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
         return;
     }
 
+    into->mods = from->mods;
+
     if (into->name == NULL) {
         into->name = from->name;
         from->name = NULL;
@@ -506,7 +521,7 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
 
     group_names_in_both = MIN(darray_size(into->group_names),
                               darray_size(from->group_names));
-    for (i = 0; i < group_names_in_both; i++) {
+    for (xkb_layout_index_t i = 0; i < group_names_in_both; i++) {
         if (!darray_item(from->group_names, i))
             continue;
 
@@ -519,16 +534,30 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
     darray_foreach_from(group_name, from->group_names, group_names_in_both)
         darray_append(into->group_names, *group_name);
 
-    darray_foreach(keyi, from->keys) {
-        keyi->merge = (merge == MERGE_DEFAULT ? keyi->merge : merge);
-        if (!AddKeySymbols(into, keyi))
-            into->errorCount++;
+    if (darray_empty(into->keys)) {
+        into->keys = from->keys;
+        darray_init(from->keys);
+    }
+    else {
+        KeyInfo *keyi;
+        darray_foreach(keyi, from->keys) {
+            keyi->merge = (merge == MERGE_DEFAULT ? keyi->merge : merge);
+            if (!AddKeySymbols(into, keyi, false))
+                into->errorCount++;
+        }
     }
 
-    darray_foreach(mm, from->modMaps) {
-        mm->merge = (merge == MERGE_DEFAULT ? mm->merge : merge);
-        if (!AddModMapEntry(into, mm))
-            into->errorCount++;
+    if (darray_empty(into->modmaps)) {
+        into->modmaps = from->modmaps;
+        darray_init(from->modmaps);
+    }
+    else {
+        ModMapEntry *mm;
+        darray_foreach(mm, from->modmaps) {
+            mm->merge = (merge == MERGE_DEFAULT ? mm->merge : merge);
+            if (!AddModMapEntry(into, mm))
+                into->errorCount++;
+        }
     }
 }
 
@@ -536,33 +565,35 @@ static void
 HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge);
 
 static bool
-HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *stmt)
+HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *include)
 {
-    enum merge_mode merge = MERGE_DEFAULT;
-    XkbFile *rtrn;
-    SymbolsInfo included, next_incl;
+    SymbolsInfo included;
 
-    InitSymbolsInfo(&included, info->keymap, info->file_id, info->actions);
-    if (stmt->stmt) {
-        free(included.name);
-        included.name = stmt->stmt;
-        stmt->stmt = NULL;
-    }
+    if (!include)
+        return false;
 
-    for (; stmt; stmt = stmt->next_incl) {
-        if (!ProcessIncludeFile(info->keymap->ctx, stmt, FILE_TYPE_SYMBOLS,
-                                &rtrn, &merge)) {
+    InitSymbolsInfo(&included, info->keymap, info->actions, &info->mods);
+    included.name = include->stmt;
+    include->stmt = NULL;
+
+    for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
+        SymbolsInfo next_incl;
+        XkbFile *file;
+
+        file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_SYMBOLS);
+        if (!file) {
             info->errorCount += 10;
             ClearSymbolsInfo(&included);
             return false;
         }
 
-        InitSymbolsInfo(&next_incl, info->keymap, rtrn->id, info->actions);
-        next_incl.merge = next_incl.dflt.merge = MERGE_OVERRIDE;
+        InitSymbolsInfo(&next_incl, info->keymap, info->actions,
+                        &included.mods);
         if (stmt->modifier) {
             next_incl.explicit_group = atoi(stmt->modifier) - 1;
             if (next_incl.explicit_group >= XKB_MAX_GROUPS) {
-                log_err(info->keymap->ctx,
+                log_err(info->ctx,
+                        XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                         "Cannot set explicit group to %d - must be between 1..%d; "
                         "Ignoring group number\n",
                         next_incl.explicit_group + 1, XKB_MAX_GROUPS);
@@ -573,15 +604,15 @@ HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *stmt)
             next_incl.explicit_group = info->explicit_group;
         }
 
-        HandleSymbolsFile(&next_incl, rtrn, MERGE_OVERRIDE);
+        HandleSymbolsFile(&next_incl, file, MERGE_OVERRIDE);
 
-        MergeIncludedSymbols(&included, &next_incl, merge);
+        MergeIncludedSymbols(&included, &next_incl, stmt->merge);
 
         ClearSymbolsInfo(&next_incl);
-        FreeXkbFile(rtrn);
+        FreeXkbFile(file);
     }
 
-    MergeIncludedSymbols(info, &included, merge);
+    MergeIncludedSymbols(info, &included, include->merge);
     ClearSymbolsInfo(&included);
 
     return (info->errorCount == 0);
@@ -610,7 +641,8 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         }
 
         if (i >= XKB_MAX_GROUPS) {
-            log_err(info->keymap->ctx,
+            log_err(info->ctx,
+                    XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                     "Too many groups of %s for key %s (max %u); "
                     "Ignoring %s defined for extra groups\n",
                     name, KeyInfoText(info, keyi), XKB_MAX_GROUPS, name);
@@ -622,8 +654,8 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return true;
     }
 
-    if (!ExprResolveGroup(info->keymap->ctx, arrayNdx, ndx_rtrn)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveGroup(info->ctx, arrayNdx, ndx_rtrn)) {
+        log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                 "Illegal group index for %s of key %s\n"
                 "Definition with non-integer array index ignored\n",
                 name, KeyInfoText(info, keyi));
@@ -637,30 +669,6 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
     return true;
 }
 
-bool
-LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
-{
-    xkb_keysym_t sym;
-
-    if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
-        *sym_rtrn = XKB_KEY_NoSymbol;
-        return 1;
-    }
-
-    if (istreq(str, "none") || istreq(str, "voidsymbol")) {
-        *sym_rtrn = XKB_KEY_VoidSymbol;
-        return 1;
-    }
-
-    sym = xkb_keysym_from_name(str, 0);
-    if (sym != XKB_KEY_NoSymbol) {
-        *sym_rtrn = sym;
-        return 1;
-    }
-
-    return 0;
-}
-
 static bool
 AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
                 ExprDef *value)
@@ -668,8 +676,6 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
     xkb_layout_index_t ndx;
     GroupInfo *groupi;
     xkb_level_index_t nLevels;
-    xkb_level_index_t i;
-    int j;
 
     if (!GetGroupIndex(info, keyi, arrayNdx, SYMBOLS, &ndx))
         return false;
@@ -681,61 +687,48 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return true;
     }
 
-    if (value->op != EXPR_KEYSYM_LIST) {
-        log_err(info->keymap->ctx,
+    if (value->expr.op != EXPR_KEYSYM_LIST) {
+        log_err(info->ctx,
+                XKB_ERROR_WRONG_FIELD_TYPE,
                 "Expected a list of symbols, found %s; "
                 "Ignoring symbols for group %u of %s\n",
-                expr_op_type_to_string(value->op), ndx + 1,
+                expr_op_type_to_string(value->expr.op), ndx + 1,
                 KeyInfoText(info, keyi));
         return false;
     }
 
     if (groupi->defined & GROUP_FIELD_SYMS) {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY,
                 "Symbols for key %s, group %u already defined; "
                 "Ignoring duplicate definition\n",
                 KeyInfoText(info, keyi), ndx + 1);
         return false;
     }
 
-    nLevels = darray_size(value->value.list.symsMapIndex);
+    nLevels = darray_size(value->keysym_list.symsMapIndex);
     if (darray_size(groupi->levels) < nLevels)
         darray_resize0(groupi->levels, nLevels);
 
     groupi->defined |= GROUP_FIELD_SYMS;
 
-    for (i = 0; i < nLevels; i++) {
+    for (xkb_level_index_t i = 0; i < nLevels; i++) {
         unsigned int sym_index;
         struct xkb_level *leveli = &darray_item(groupi->levels, i);
 
-        sym_index = darray_item(value->value.list.symsMapIndex, i);
-        leveli->num_syms = darray_item(value->value.list.symsNumEntries, i);
-        if (leveli->num_syms > 1)
+        sym_index = darray_item(value->keysym_list.symsMapIndex, i);
+        leveli->num_syms = darray_item(value->keysym_list.symsNumEntries, i);
+        if (leveli->num_syms > 1) {
             leveli->u.syms = calloc(leveli->num_syms, sizeof(*leveli->u.syms));
-
-        for (j = 0; j < leveli->num_syms; j++) {
-            char *sym_name = darray_item(value->value.list.syms,
-                                         sym_index + j);
-            xkb_keysym_t keysym;
-
-            if (!LookupKeysym(sym_name, &keysym)) {
-                const char *group_name = "unnamed";
-
-                if (ndx < darray_size(info->group_names) &&
-                    darray_item(info->group_names, ndx))
-                    group_name = xkb_atom_text(info->keymap->ctx,
-                                               darray_item(info->group_names,
-                                                           ndx));
-
-                log_warn(info->keymap->ctx,
-                         "Could not resolve keysym %s for key %s, group %u (%s), level %u\n",
-                         sym_name, KeyInfoText(info, keyi), ndx + 1,
-                         group_name, i);
-
-                ClearLevelInfo(leveli);
-                leveli->num_syms = 0;
-                break;
+            if (!leveli->u.syms) {
+                log_err(info->ctx, "Failed to allocate memory for leveli->u.syms\n");
+                continue;
             }
+        }
+
+        for (unsigned j = 0; j < leveli->num_syms; j++) {
+            xkb_keysym_t keysym = darray_item(value->keysym_list.syms,
+                                              sym_index + j);
 
             if (leveli->num_syms == 1) {
                 if (keysym == XKB_KEY_NoSymbol)
@@ -756,12 +749,10 @@ static bool
 AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
                 ExprDef *value)
 {
-    unsigned int i;
     xkb_layout_index_t ndx;
     GroupInfo *groupi;
     unsigned int nActs;
     ExprDef *act;
-    union xkb_action *toAct;
 
     if (!GetGroupIndex(info, keyi, arrayNdx, ACTIONS, &ndx))
         return false;
@@ -773,23 +764,23 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return true;
     }
 
-    if (value->op != EXPR_ACTION_LIST) {
-        log_wsgo(info->keymap->ctx,
+    if (value->expr.op != EXPR_ACTION_LIST) {
+        log_wsgo(info->ctx, XKB_LOG_MESSAGE_NO_ID,
                  "Bad expression type (%d) for action list value; "
                  "Ignoring actions for group %u of %s\n",
-                 value->op, ndx, KeyInfoText(info, keyi));
+                 value->expr.op, ndx, KeyInfoText(info, keyi));
         return false;
     }
 
     if (groupi->defined & GROUP_FIELD_ACTS) {
-        log_wsgo(info->keymap->ctx,
+        log_wsgo(info->ctx, XKB_LOG_MESSAGE_NO_ID,
                  "Actions for key %s, group %u already defined\n",
                  KeyInfoText(info, keyi), ndx);
         return false;
     }
 
     nActs = 0;
-    for (act = value->value.child; act; act = (ExprDef *) act->common.next)
+    for (act = value->actions.actions; act; act = (ExprDef *) act->common.next)
         nActs++;
 
     if (darray_size(groupi->levels) < nActs)
@@ -797,12 +788,13 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
 
     groupi->defined |= GROUP_FIELD_ACTS;
 
-    act = value->value.child;
-    for (i = 0; i < nActs; i++) {
-        toAct = &darray_item(groupi->levels, i).action;
+    act = value->actions.actions;
+    for (unsigned i = 0; i < nActs; i++) {
+        union xkb_action *toAct = &darray_item(groupi->levels, i).action;
 
-        if (!HandleActionDef(act, info->keymap, toAct, info->actions))
-            log_err(info->keymap->ctx,
+        if (!HandleActionDef(info->ctx, info->actions, &info->mods, act, toAct))
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_VALUE,
                     "Illegal action definition for %s; "
                     "Action for group %u/level %u ignored\n",
                     KeyInfoText(info, keyi), ndx + 1, i + 1);
@@ -828,24 +820,24 @@ static bool
 SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
                 ExprDef *arrayNdx, ExprDef *value)
 {
-    bool ok = true;
-    struct xkb_context *ctx = info->keymap->ctx;
-
     if (istreq(field, "type")) {
         xkb_layout_index_t ndx;
         xkb_atom_t val;
 
-        if (!ExprResolveString(ctx, value, &val))
-            log_vrb(ctx, 1,
+        if (!ExprResolveString(info->ctx, value, &val)) {
+            log_err(info->ctx,
+                    XKB_ERROR_WRONG_FIELD_TYPE,
                     "The type field of a key symbol map must be a string; "
                     "Ignoring illegal type definition\n");
+            return false;
+        }
 
-        if (arrayNdx == NULL) {
-            keyi->dfltType = val;
-            keyi->defined |= KEY_FIELD_TYPE_DFLT;
+        if (!arrayNdx) {
+            keyi->default_type = val;
+            keyi->defined |= KEY_FIELD_DEFAULT_TYPE;
         }
-        else if (!ExprResolveGroup(ctx, arrayNdx, &ndx)) {
-            log_err(ctx,
+        else if (!ExprResolveGroup(info->ctx, arrayNdx, &ndx)) {
+            log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                     "Illegal group index for type of key %s; "
                     "Definition with non-integer array index ignored\n",
                     KeyInfoText(info, keyi));
@@ -859,32 +851,36 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
             darray_item(keyi->groups, ndx).defined |= GROUP_FIELD_TYPE;
         }
     }
-    else if (istreq(field, "symbols"))
+    else if (istreq(field, "symbols")) {
         return AddSymbolsToKey(info, keyi, arrayNdx, value);
-    else if (istreq(field, "actions"))
+    }
+    else if (istreq(field, "actions")) {
         return AddActionsToKey(info, keyi, arrayNdx, value);
+    }
     else if (istreq(field, "vmods") ||
              istreq(field, "virtualmods") ||
              istreq(field, "virtualmodifiers")) {
         xkb_mod_mask_t mask;
 
-        ok = ExprResolveModMask(info->keymap, value, MOD_VIRT, &mask);
-        if (ok) {
-            keyi->vmodmap = mask;
-            keyi->defined |= KEY_FIELD_VMODMAP;
-        }
-        else {
-            log_err(info->keymap->ctx,
+        if (!ExprResolveModMask(info->ctx, value, MOD_VIRT, &info->mods,
+                                &mask)) {
+            log_err(info->ctx,
+                    XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
                     "Expected a virtual modifier mask, found %s; "
                     "Ignoring virtual modifiers definition for key %s\n",
-                    expr_op_type_to_string(value->op),
+                    expr_op_type_to_string(value->expr.op),
                     KeyInfoText(info, keyi));
+            return false;
         }
+
+        keyi->vmodmap = mask;
+        keyi->defined |= KEY_FIELD_VMODMAP;
     }
     else if (istreq(field, "locking") ||
              istreq(field, "lock") ||
              istreq(field, "locks")) {
-        log_err(info->keymap->ctx,
+        log_vrb(info->ctx, 1,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Key behaviors not supported; "
                 "Ignoring locking specification for key %s\n",
                 KeyInfoText(info, keyi));
@@ -892,14 +888,16 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
     else if (istreq(field, "radiogroup") ||
              istreq(field, "permanentradiogroup") ||
              istreq(field, "allownone")) {
-        log_err(info->keymap->ctx,
+        log_vrb(info->ctx, 1,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Radio groups not supported; "
                 "Ignoring radio group specification for key %s\n",
                 KeyInfoText(info, keyi));
     }
     else if (istreq_prefix("overlay", field) ||
              istreq_prefix("permanentoverlay", field)) {
-        log_err(info->keymap->ctx,
+        log_vrb(info->ctx, 1,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Overlays not supported; "
                 "Ignoring overlay specification for key %s\n",
                 KeyInfoText(info, keyi));
@@ -909,14 +907,15 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
              istreq(field, "repeat")) {
         unsigned int val;
 
-        ok = ExprResolveEnum(ctx, value, &val, repeatEntries);
-        if (!ok) {
-            log_err(info->keymap->ctx,
+        if (!ExprResolveEnum(info->ctx, value, &val, repeatEntries)) {
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_VALUE,
                     "Illegal repeat setting for %s; "
                     "Non-boolean repeat setting ignored\n",
                     KeyInfoText(info, keyi));
             return false;
         }
+
         keyi->repeat = val;
         keyi->defined |= KEY_FIELD_REPEAT;
     }
@@ -924,46 +923,40 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
              istreq(field, "wrapgroups")) {
         bool set;
 
-        if (!ExprResolveBoolean(ctx, value, &set)) {
-            log_err(info->keymap->ctx,
+        if (!ExprResolveBoolean(info->ctx, value, &set)) {
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_VALUE,
                     "Illegal groupsWrap setting for %s; "
                     "Non-boolean value ignored\n",
                     KeyInfoText(info, keyi));
             return false;
         }
 
-        if (set)
-            keyi->out_of_range_group_action = RANGE_WRAP;
-        else
-            keyi->out_of_range_group_action = RANGE_SATURATE;
-
+        keyi->out_of_range_group_action = (set ? RANGE_WRAP : RANGE_SATURATE);
         keyi->defined |= KEY_FIELD_GROUPINFO;
     }
     else if (istreq(field, "groupsclamp") ||
              istreq(field, "clampgroups")) {
         bool set;
 
-        if (!ExprResolveBoolean(ctx, value, &set)) {
-            log_err(info->keymap->ctx,
+        if (!ExprResolveBoolean(info->ctx, value, &set)) {
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_VALUE,
                     "Illegal groupsClamp setting for %s; "
                     "Non-boolean value ignored\n",
                     KeyInfoText(info, keyi));
             return false;
         }
 
-        if (set)
-            keyi->out_of_range_group_action = RANGE_SATURATE;
-        else
-            keyi->out_of_range_group_action = RANGE_WRAP;
-
+        keyi->out_of_range_group_action = (set ? RANGE_SATURATE : RANGE_WRAP);
         keyi->defined |= KEY_FIELD_GROUPINFO;
     }
     else if (istreq(field, "groupsredirect") ||
              istreq(field, "redirectgroups")) {
         xkb_layout_index_t grp;
 
-        if (!ExprResolveGroup(ctx, value, &grp)) {
-            log_err(info->keymap->ctx,
+        if (!ExprResolveGroup(info->ctx, value, &grp)) {
+            log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                     "Illegal group index for redirect of key %s; "
                     "Definition with non-integer group ignored\n",
                     KeyInfoText(info, keyi));
@@ -975,78 +968,82 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
         keyi->defined |= KEY_FIELD_GROUPINFO;
     }
     else {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_ERROR_UNKNOWN_FIELD,
                 "Unknown field %s in a symbol interpretation; "
                 "Definition ignored\n",
                 field);
-        ok = false;
+        return false;
     }
 
-    return ok;
+    return true;
 }
 
-static int
+static bool
 SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
 {
-    xkb_layout_index_t grp, grp_to_use;
+    xkb_layout_index_t group, group_to_use;
     xkb_atom_t name;
 
     if (!arrayNdx) {
-        log_vrb(info->keymap->ctx, 1,
+        log_vrb(info->ctx, 1,
+                XKB_WARNING_MISSING_SYMBOLS_GROUP_NAME_INDEX,
                 "You must specify an index when specifying a group name; "
                 "Group name definition without array subscript ignored\n");
         return false;
     }
 
-    if (!ExprResolveGroup(info->keymap->ctx, arrayNdx, &grp)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveGroup(info->ctx, arrayNdx, &group)) {
+        log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
                 "Illegal index in group name definition; "
                 "Definition with non-integer array index ignored\n");
         return false;
     }
 
-    if (!ExprResolveString(info->keymap->ctx, value, &name)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveString(info->ctx, value, &name)) {
+        log_err(info->ctx,
+                XKB_ERROR_WRONG_FIELD_TYPE,
                 "Group name must be a string; "
-                "Illegal name for group %d ignored\n", grp);
+                "Illegal name for group %d ignored\n", group);
         return false;
     }
 
-    grp_to_use = XKB_LAYOUT_INVALID;
     if (info->explicit_group == XKB_LAYOUT_INVALID) {
-        grp_to_use = grp - 1;
+        group_to_use = group - 1;
     }
-    else if (grp - 1 == 0) {
-        grp_to_use = info->explicit_group;
+    else if (group - 1 == 0) {
+        group_to_use = info->explicit_group;
     }
     else {
-        log_warn(info->keymap->ctx,
+        log_warn(info->ctx,
+                 XKB_WARNING_NON_BASE_GROUP_NAME,
                  "An explicit group was specified for the '%s' map, "
                  "but it provides a name for a group other than Group1 (%d); "
                  "Ignoring group name '%s'\n",
-                 info->name, grp,
-                 xkb_atom_text(info->keymap->ctx, name));
+                 info->name, group,
+                 xkb_atom_text(info->ctx, name));
         return false;
     }
 
-    if (grp_to_use >= darray_size(info->group_names))
-        darray_resize0(info->group_names, grp_to_use + 1);
-    darray_item(info->group_names, grp_to_use) = name;
+    if (group_to_use >= darray_size(info->group_names))
+        darray_resize0(info->group_names, group_to_use + 1);
+    darray_item(info->group_names, group_to_use) = name;
+
     return true;
 }
 
-static int
+static bool
 HandleGlobalVar(SymbolsInfo *info, VarDef *stmt)
 {
     const char *elem, *field;
     ExprDef *arrayNdx;
     bool ret;
 
-    if (ExprResolveLhs(info->keymap->ctx, stmt->name, &elem, &field,
-                       &arrayNdx) == 0)
-        return 0;               /* internal error, already reported */
+    if (!ExprResolveLhs(info->ctx, stmt->name, &elem, &field, &arrayNdx))
+        return false;
+
     if (elem && istreq(elem, "key")) {
-        ret = SetSymbolsField(info, &info->dflt, field, arrayNdx,
+        ret = SetSymbolsField(info, &info->default_key, field, arrayNdx,
                               stmt->value);
     }
     else if (!elem && (istreq(field, "name") ||
@@ -1055,31 +1052,35 @@ HandleGlobalVar(SymbolsInfo *info, VarDef *stmt)
     }
     else if (!elem && (istreq(field, "groupswrap") ||
                        istreq(field, "wrapgroups"))) {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Global \"groupswrap\" not supported; Ignored\n");
         ret = true;
     }
     else if (!elem && (istreq(field, "groupsclamp") ||
                        istreq(field, "clampgroups"))) {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Global \"groupsclamp\" not supported; Ignored\n");
         ret = true;
     }
     else if (!elem && (istreq(field, "groupsredirect") ||
                        istreq(field, "redirectgroups"))) {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Global \"groupsredirect\" not supported; Ignored\n");
         ret = true;
     }
     else if (!elem && istreq(field, "allownone")) {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
+                XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
                 "Radio groups not supported; "
                 "Ignoring \"allownone\" specification\n");
         ret = true;
     }
     else {
-        ret = SetActionField(info->keymap, elem, field, arrayNdx, stmt->value,
-                             info->actions);
+        ret = SetActionField(info->ctx, info->actions, &info->mods,
+                             elem, field, arrayNdx, stmt->value);
     }
 
     return ret;
@@ -1093,22 +1094,23 @@ HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
     ExprDef *arrayNdx;
 
     for (; def; def = (VarDef *) def->common.next) {
-        if (def->name && def->name->op == EXPR_FIELD_REF) {
-            log_err(info->keymap->ctx,
+        if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
+            log_err(info->ctx,
+                    XKB_ERROR_WRONG_SCOPE,
                     "Cannot set a global default value from within a key statement; "
                     "Move statements to the global file scope\n");
             continue;
         }
 
         if (!def->name) {
-            if (!def->value || def->value->op == EXPR_KEYSYM_LIST)
+            if (!def->value || def->value->expr.op == EXPR_KEYSYM_LIST)
                 field = "symbols";
             else
                 field = "actions";
             arrayNdx = NULL;
         }
         else {
-            ok = ExprResolveLhs(info->keymap->ctx, def->name, &elem, &field,
+            ok = ExprResolveLhs(info->ctx, def->name, &elem, &field,
                                 &arrayNdx);
         }
 
@@ -1137,12 +1139,14 @@ SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
         }
     }
 
-    if (warn)
-        log_warn(info->keymap->ctx,
+    if (warn) {
+        log_warn(info->ctx,
+                 XKB_WARNING_MULTIPLE_GROUPS_AT_ONCE,
                  "For the map %s an explicit group specified, "
                  "but key %s has more than one group defined; "
                  "All groups except first one will be ignored\n",
                  info->name, KeyInfoText(info, keyi));
+    }
 
     darray_resize0(keyi->groups, info->explicit_group + 1);
     if (info->explicit_group > 0) {
@@ -1154,22 +1158,21 @@ SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
     return true;
 }
 
-static int
+static bool
 HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
 {
     KeyInfo keyi;
-    xkb_layout_index_t i;
 
-    keyi = info->dflt;
+    keyi = info->default_key;
     darray_init(keyi.groups);
-    darray_copy(keyi.groups, info->dflt.groups);
-    for (i = 0; i < darray_size(keyi.groups); i++)
+    darray_copy(keyi.groups, info->default_key.groups);
+    for (xkb_layout_index_t i = 0; i < darray_size(keyi.groups); i++)
         CopyGroupInfo(&darray_item(keyi.groups, i),
-                      &darray_item(info->dflt.groups, i));
+                      &darray_item(info->default_key.groups, i));
     keyi.merge = stmt->merge;
     keyi.name = stmt->keyName;
 
-    if (!HandleSymbolsBody(info, (VarDef *) stmt->symbols, &keyi)) {
+    if (!HandleSymbolsBody(info, stmt->symbols, &keyi)) {
         info->errorCount++;
         return false;
     }
@@ -1179,7 +1182,7 @@ HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
         return false;
     }
 
-    if (!AddKeySymbols(info, &keyi)) {
+    if (!AddKeySymbols(info, &keyi, true)) {
         info->errorCount++;
         return false;
     }
@@ -1190,40 +1193,50 @@ HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
 static bool
 HandleModMapDef(SymbolsInfo *info, ModMapDef *def)
 {
-    ExprDef *key;
     ModMapEntry tmp;
     xkb_mod_index_t ndx;
     bool ok;
-    struct xkb_context *ctx = info->keymap->ctx;
-
-    ndx = ModNameToIndex(info->keymap, def->modifier, MOD_REAL);
-    if (ndx == XKB_MOD_INVALID) {
-        log_err(info->keymap->ctx,
-                "Illegal modifier map definition; "
-                "Ignoring map for non-modifier \"%s\"\n",
-                xkb_atom_text(ctx, def->modifier));
-        return false;
+    struct xkb_context *ctx = info->ctx;
+    const char *modifier_name = xkb_atom_text(ctx, def->modifier);
+
+    if (istreq(modifier_name, "none")) {
+        // Handle special "None" entry
+        ndx = XKB_MOD_NONE;
+    } else {
+        // Handle normal entry
+        ndx = XkbModNameToIndex(&info->mods, def->modifier, MOD_REAL);
+        if (ndx == XKB_MOD_INVALID) {
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_REAL_MODIFIER,
+                    "Illegal modifier map definition; "
+                    "Ignoring map for non-modifier \"%s\"\n",
+                    xkb_atom_text(ctx, def->modifier));
+            return false;
+        }
     }
 
     ok = true;
     tmp.modifier = ndx;
+    tmp.merge = def->merge;
 
-    for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) {
+    for (ExprDef *key = def->keys; key; key = (ExprDef *) key->common.next) {
         xkb_keysym_t sym;
 
-        if (key->op == EXPR_VALUE && key->value_type == EXPR_TYPE_KEYNAME) {
+        if (key->expr.op == EXPR_VALUE &&
+            key->expr.value_type == EXPR_TYPE_KEYNAME) {
             tmp.haveSymbol = false;
-            tmp.u.keyName = key->value.keyName;
+            tmp.u.keyName = key->key_name.key_name;
         }
         else if (ExprResolveKeySym(ctx, key, &sym)) {
             tmp.haveSymbol = true;
             tmp.u.keySym = sym;
         }
         else {
-            log_err(info->keymap->ctx,
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_MODMAP_ENTRY,
                     "Modmap entries may contain only key names or keysyms; "
                     "Illegal definition for %s modifier ignored\n",
-                    ModIndexText(info->keymap, tmp.modifier));
+                    ModIndexText(info->ctx, &info->mods, tmp.modifier));
             continue;
         }
 
@@ -1236,13 +1249,11 @@ static void
 HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
 {
     bool ok;
-    ParseCommon *stmt;
 
     free(info->name);
     info->name = strdup_safe(file->name);
 
-    stmt = file->defs;
-    for (stmt = file->defs; stmt; stmt = stmt->next) {
+    for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
         switch (stmt->type) {
         case STMT_INCLUDE:
             ok = HandleIncludeSymbols(info, (IncludeStmt *) stmt);
@@ -1254,14 +1265,15 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
             ok = HandleGlobalVar(info, (VarDef *) stmt);
             break;
         case STMT_VMOD:
-            ok = HandleVModDef(info->keymap, (VModDef *) stmt);
+            ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge);
             break;
         case STMT_MODMAP:
             ok = HandleModMapDef(info, (ModMapDef *) stmt);
             break;
         default:
-            log_err(info->keymap->ctx,
-                    "Interpretation files may not include other types; "
+            log_err(info->ctx,
+                    XKB_ERROR_WRONG_STATEMENT_TYPE,
+                    "Symbols files may not include other types; "
                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
             ok = false;
             break;
@@ -1271,8 +1283,10 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
             info->errorCount++;
 
         if (info->errorCount > 10) {
-            log_err(info->keymap->ctx, "Abandoning symbols file \"%s\"\n",
-                    file->topName);
+            log_err(info->ctx,
+                    XKB_ERROR_INVALID_SYNTAX,
+                    "Abandoning symbols file \"%s\"\n",
+                    file->name);
             break;
         }
     }
@@ -1291,38 +1305,31 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
 static struct xkb_key *
 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym)
 {
-    struct xkb_key *key, *ret = NULL;
-    xkb_layout_index_t group, min_group = UINT32_MAX;
-    xkb_level_index_t level, min_level = UINT16_MAX;
-
-    xkb_foreach_key(key, keymap) {
-        for (group = 0; group < key->num_groups; group++) {
-            for (level = 0; level < XkbKeyGroupWidth(key, group); level++) {
-                if (key->groups[group].levels[level].num_syms != 1 ||
-                    key->groups[group].levels[level].u.sym != sym)
-                    continue;
-
-                /*
-                 * If the keysym was found in a group or level > 0, we must
-                 * keep looking since we might find a key in which the keysym
-                 * is in a lower group or level.
-                 */
-                if (group < min_group ||
-                    (group == min_group && level < min_level)) {
-                    ret = key;
-                    if (group == 0 && level == 0) {
-                        return ret;
-                    }
-                    else {
-                        min_group = group;
-                        min_level = level;
-                    }
+    struct xkb_key *key;
+    xkb_layout_index_t group;
+    bool got_one_group, got_one_level;
+
+    group = 0;
+    do {
+        xkb_level_index_t level = 0;
+        got_one_group = false;
+        do {
+            got_one_level = false;
+            xkb_keys_foreach(key, keymap) {
+                if (group < key->num_groups &&
+                    level < XkbKeyNumLevels(key, group)) {
+                    got_one_group = got_one_level = true;
+                    if (key->groups[group].levels[level].num_syms == 1 &&
+                        key->groups[group].levels[level].u.sym == sym)
+                        return key;
                 }
             }
-        }
-    }
+            level++;
+        } while (got_one_level);
+        group++;
+    } while (got_one_group);
 
-    return ret;
+    return NULL;
 }
 
 /*
@@ -1340,8 +1347,8 @@ FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym)
 static xkb_atom_t
 FindAutomaticType(struct xkb_context *ctx, GroupInfo *groupi)
 {
-    xkb_keysym_t sym0, sym1, sym2, sym3;
-    xkb_level_index_t width = darray_size(groupi->levels);
+    xkb_keysym_t sym0, sym1;
+    const xkb_level_index_t width = darray_size(groupi->levels);
 
 #define GET_SYM(level) \
     (darray_item(groupi->levels, level).num_syms == 0 ? \
@@ -1352,36 +1359,37 @@ FindAutomaticType(struct xkb_context *ctx, GroupInfo *groupi)
         darray_item(groupi->levels, level).u.syms[0])
 
     if (width == 1 || width <= 0)
-        return xkb_atom_intern(ctx, "ONE_LEVEL");
+        return xkb_atom_intern_literal(ctx, "ONE_LEVEL");
 
     sym0 = GET_SYM(0);
     sym1 = GET_SYM(1);
 
     if (width == 2) {
         if (xkb_keysym_is_lower(sym0) && xkb_keysym_is_upper(sym1))
-            return xkb_atom_intern(ctx, "ALPHABETIC");
+            return xkb_atom_intern_literal(ctx, "ALPHABETIC");
 
         if (xkb_keysym_is_keypad(sym0) || xkb_keysym_is_keypad(sym1))
-            return xkb_atom_intern(ctx, "KEYPAD");
+            return xkb_atom_intern_literal(ctx, "KEYPAD");
 
-        return xkb_atom_intern(ctx, "TWO_LEVEL");
+        return xkb_atom_intern_literal(ctx, "TWO_LEVEL");
     }
 
     if (width <= 4) {
         if (xkb_keysym_is_lower(sym0) && xkb_keysym_is_upper(sym1)) {
+            xkb_keysym_t sym2, sym3;
             sym2 = GET_SYM(2);
             sym3 = (width == 4 ? GET_SYM(3) : XKB_KEY_NoSymbol);
 
             if (xkb_keysym_is_lower(sym2) && xkb_keysym_is_upper(sym3))
-                return xkb_atom_intern(ctx, "FOUR_LEVEL_ALPHABETIC");
+                return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_ALPHABETIC");
 
-            return xkb_atom_intern(ctx, "FOUR_LEVEL_SEMIALPHABETIC");
+            return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_SEMIALPHABETIC");
         }
 
         if (xkb_keysym_is_keypad(sym0) || xkb_keysym_is_keypad(sym1))
-            return xkb_atom_intern(ctx, "FOUR_LEVEL_KEYPAD");
+            return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_KEYPAD");
 
-        return xkb_atom_intern(ctx, "FOUR_LEVEL");
+        return xkb_atom_intern_literal(ctx, "FOUR_LEVEL");
     }
 
     return XKB_ATOM_NONE;
@@ -1400,8 +1408,8 @@ FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
     *explicit_type = true;
 
     if (type_name == XKB_ATOM_NONE) {
-        if (keyi->dfltType != XKB_ATOM_NONE) {
-            type_name  = keyi->dfltType;
+        if (keyi->default_type != XKB_ATOM_NONE) {
+            type_name  = keyi->default_type;
         }
         else {
             type_name = FindAutomaticType(keymap->ctx, groupi);
@@ -1412,6 +1420,7 @@ FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
 
     if (type_name == XKB_ATOM_NONE) {
         log_warn(keymap->ctx,
+                 XKB_WARNING_CANNOT_INFER_KEY_TYPE,
                  "Couldn't find an automatic type for key '%s' group %d with %lu levels; "
                  "Using the default type\n",
                  KeyNameText(keymap->ctx, keyi->name), group + 1,
@@ -1425,6 +1434,7 @@ FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
 
     if (i >= keymap->num_types) {
         log_warn(keymap->ctx,
+                 XKB_WARNING_UNDEFINED_KEY_TYPE,
                  "The type \"%s\" for key '%s' group %d was not previously defined; "
                  "Using the default type\n",
                  xkb_atom_text(keymap->ctx, type_name),
@@ -1443,9 +1453,9 @@ use_default:
 }
 
 static bool
-CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
+CopySymbolsDefToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info,
+                       KeyInfo *keyi)
 {
-    struct xkb_keymap *keymap = info->keymap;
     struct xkb_key *key;
     GroupInfo *groupi;
     const GroupInfo *group0;
@@ -1455,9 +1465,10 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
      * The name is guaranteed to be real and not an alias (see
      * AddKeySymbols), so 'false' is safe here.
      */
-    key = FindNamedKey(keymap, keyi->name, false);
+    key = XkbKeyByName(keymap, keyi->name, false);
     if (!key) {
-        log_vrb(info->keymap->ctx, 5,
+        log_vrb(info->ctx, 5,
+                XKB_WARNING_UNDEFINED_KEYCODE,
                 "Key %s not found in keycodes; Symbols ignored\n",
                 KeyInfoText(info, keyi));
         return false;
@@ -1488,6 +1499,10 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
     }
 
     key->groups = calloc(key->num_groups, sizeof(*key->groups));
+    if (!key->groups) {
+        log_err(info->ctx, "Failed to allocate memory for key->groups\n");
+        return false;
+    }
 
     /* Find and assign the groups' types in the keymap. */
     darray_enumerate(i, groupi, keyi->groups) {
@@ -1500,7 +1515,8 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
         if (type->num_levels < darray_size(groupi->levels)) {
             struct xkb_level *leveli;
 
-            log_vrb(info->keymap->ctx, 1,
+            log_vrb(info->ctx, 1,
+                    XKB_WARNING_EXTRA_SYMBOLS_IGNORED,
                     "Type \"%s\" has %d levels, but %s has %d levels; "
                     "Ignoring extra symbols\n",
                     xkb_atom_text(keymap->ctx, type->name), type->num_levels,
@@ -1517,10 +1533,8 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
     }
 
     /* Copy levels. */
-    darray_enumerate(i, groupi, keyi->groups) {
-        key->groups[i].levels = darray_mem(groupi->levels, 0);
-        darray_init(groupi->levels);
-    }
+    darray_enumerate(i, groupi, keyi->groups)
+        darray_steal(groupi->levels, &key->groups[i].levels, NULL);
 
     key->out_of_range_group_number = keyi->out_of_range_group_number;
     key->out_of_range_group_action = keyi->out_of_range_group_action;
@@ -1546,35 +1560,42 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
 }
 
 static bool
-CopyModMapDef(SymbolsInfo *info, ModMapEntry *entry)
+CopyModMapDefToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info,
+                      ModMapEntry *entry)
 {
     struct xkb_key *key;
-    struct xkb_keymap *keymap = info->keymap;
 
     if (!entry->haveSymbol) {
-        key = FindNamedKey(keymap, entry->u.keyName, true);
+        key = XkbKeyByName(keymap, entry->u.keyName, true);
         if (!key) {
-            log_vrb(info->keymap->ctx, 5,
+            log_vrb(info->ctx, 5,
+                    XKB_WARNING_UNDEFINED_KEYCODE,
                     "Key %s not found in keycodes; "
                     "Modifier map entry for %s not updated\n",
-                    KeyNameText(keymap->ctx, entry->u.keyName),
-                    ModIndexText(info->keymap, entry->modifier));
+                    KeyNameText(info->ctx, entry->u.keyName),
+                    ModIndexText(info->ctx, &info->mods, entry->modifier));
             return false;
         }
     }
     else {
         key = FindKeyForSymbol(keymap, entry->u.keySym);
         if (!key) {
-            log_vrb(info->keymap->ctx, 5,
+            log_vrb(info->ctx, 5,
+                    XKB_WARNING_UNRESOLVED_KEYMAP_SYMBOL,
                     "Key \"%s\" not found in symbol map; "
                     "Modifier map entry for %s not updated\n",
-                    KeysymText(info->keymap->ctx, entry->u.keySym),
-                    ModIndexText(info->keymap, entry->modifier));
+                    KeysymText(info->ctx, entry->u.keySym),
+                    ModIndexText(info->ctx, &info->mods, entry->modifier));
             return false;
         }
     }
 
-    key->modmap |= (1 << entry->modifier);
+    // Handle modMap None
+    if (entry->modifier != XKB_MOD_NONE) {
+        // Convert modifier index to modifier mask
+        key->modmap |= (1u << entry->modifier);
+    }
+
     return true;
 }
 
@@ -1583,32 +1604,35 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
 {
     KeyInfo *keyi;
     ModMapEntry *mm;
-    struct xkb_key *key;
 
     keymap->symbols_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->symbols_section_name);
+
+    keymap->mods = info->mods;
 
-    keymap->num_group_names = darray_size(info->group_names);
-    keymap->group_names = darray_mem(info->group_names, 0);
-    darray_init(info->group_names);
+    darray_steal(info->group_names,
+                 &keymap->group_names, &keymap->num_group_names);
 
     darray_foreach(keyi, info->keys)
-        if (!CopySymbolsDef(info, keyi))
+        if (!CopySymbolsDefToKeymap(keymap, info, keyi))
             info->errorCount++;
 
     if (xkb_context_get_log_verbosity(keymap->ctx) > 3) {
-        xkb_foreach_key(key, keymap) {
+        struct xkb_key *key;
+
+        xkb_keys_foreach(key, keymap) {
             if (key->name == XKB_ATOM_NONE)
                 continue;
 
             if (key->num_groups < 1)
-                log_info(keymap->ctx,
+                log_info(info->ctx, XKB_LOG_MESSAGE_NO_ID,
                          "No symbols defined for %s\n",
-                         KeyNameText(keymap->ctx, key->name));
+                         KeyNameText(info->ctx, key->name));
         }
     }
 
-    darray_foreach(mm, info->modMaps)
-        if (!CopyModMapDef(info, mm))
+    darray_foreach(mm, info->modmaps)
+        if (!CopyModMapDefToKeymap(keymap, info, mm))
             info->errorCount++;
 
     /* XXX: If we don't ignore errorCount, things break. */
@@ -1626,14 +1650,11 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
     if (!actions)
         return false;
 
-    InitSymbolsInfo(&info, keymap, file->id, actions);
-    info.dflt.merge = merge;
+    InitSymbolsInfo(&info, keymap, actions, &keymap->mods);
+    info.default_key.merge = merge;
 
     HandleSymbolsFile(&info, file, merge);
 
-    if (darray_empty(info.keys))
-        goto err_info;
-
     if (info.errorCount != 0)
         goto err_info;