Add libxkbcommon to 3rd party libs

This library is required by the XCB platform plugin. As we depend on
very recent version of this library and it might not be available
in base repositories of distributions, users can use -qt-xkbcommom
switch to build Qt with the bundled version.

Change-Id: I0ed2a5cc2f1df98b0e7cc926cabfa69818674e08
Reviewed-by: Samuel Rødal <samuel.rodal@digia.com>

1 files changed, 1638 insertions, 0 deletions

diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c b/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c
new file mode 100644
index 0000000000..a2970f5004
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c
@@ -0,0 +1,1638 @@
+/************************************************************
+ * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of Silicon Graphics not be
+ * used in advertising or publicity pertaining to distribution
+ * of the software without specific prior written permission.
+ * Silicon Graphics makes no representation about the suitability
+ * of this software for any purpose. It is provided "as is"
+ * without any express or implied warranty.
+ *
+ * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ * THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ ********************************************************/
+
+/*
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2012 Ran Benita <ran234@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ *         Ran Benita <ran234@gmail.com>
+ */
+
+#include "xkbcomp-priv.h"
+#include "text.h"
+#include "expr.h"
+#include "action.h"
+#include "vmod.h"
+#include "include.h"
+#include "keysym.h"
+
+enum key_repeat {
+    KEY_REPEAT_UNDEFINED = 0,
+    KEY_REPEAT_YES = 1,
+    KEY_REPEAT_NO = 2,
+};
+
+enum group_field {
+    GROUP_FIELD_SYMS = (1 << 0),
+    GROUP_FIELD_ACTS = (1 << 1),
+    GROUP_FIELD_TYPE = (1 << 2),
+};
+
+enum key_field {
+    KEY_FIELD_REPEAT    = (1 << 0),
+    KEY_FIELD_DEFAULT_TYPE = (1 << 1),
+    KEY_FIELD_GROUPINFO = (1 << 2),
+    KEY_FIELD_VMODMAP   = (1 << 3),
+};
+
+typedef struct {
+    enum group_field defined;
+    darray(struct xkb_level) levels;
+    xkb_atom_t type;
+} GroupInfo;
+
+typedef struct {
+    enum key_field defined;
+    enum merge_mode merge;
+
+    xkb_atom_t name;
+
+    darray(GroupInfo) groups;
+
+    enum key_repeat repeat;
+    xkb_mod_mask_t vmodmap;
+    xkb_atom_t default_type;
+
+    enum xkb_range_exceed_type out_of_range_group_action;
+    xkb_layout_index_t out_of_range_group_number;
+} KeyInfo;
+
+static void
+ClearLevelInfo(struct xkb_level *leveli)
+{
+    if (leveli->num_syms > 1)
+        free(leveli->u.syms);
+}
+
+static void
+InitGroupInfo(GroupInfo *groupi)
+{
+    memset(groupi, 0, sizeof(*groupi));
+}
+
+static void
+ClearGroupInfo(GroupInfo *groupi)
+{
+    struct xkb_level *leveli;
+    darray_foreach(leveli, groupi->levels)
+        ClearLevelInfo(leveli);
+    darray_free(groupi->levels);
+}
+
+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++)
+        if (darray_item(from->levels, j).num_syms > 1)
+            darray_item(to->levels, j).u.syms =
+                memdup(darray_item(from->levels, j).u.syms,
+                       darray_item(from->levels, j).num_syms,
+                       sizeof(xkb_keysym_t));
+}
+
+static void
+InitKeyInfo(struct xkb_context *ctx, KeyInfo *keyi)
+{
+    memset(keyi, 0, sizeof(*keyi));
+    keyi->merge = MERGE_OVERRIDE;
+    keyi->name = xkb_atom_intern(ctx, "*");
+    keyi->out_of_range_group_action = RANGE_WRAP;
+}
+
+static void
+ClearKeyInfo(KeyInfo *keyi)
+{
+    GroupInfo *groupi;
+    darray_foreach(groupi, keyi->groups)
+        ClearGroupInfo(groupi);
+    darray_free(keyi->groups);
+}
+
+/***====================================================================***/
+
+typedef struct {
+    enum merge_mode merge;
+    bool haveSymbol;
+    xkb_mod_index_t modifier;
+    union {
+        xkb_atom_t keyName;
+        xkb_keysym_t keySym;
+    } u;
+} ModMapEntry;
+
+typedef struct {
+    char *name;         /* e.g. pc+us+inet(evdev) */
+    int errorCount;
+    enum merge_mode merge;
+    xkb_layout_index_t explicit_group;
+    darray(KeyInfo) keys;
+    KeyInfo default_key;
+    ActionsInfo *actions;
+    darray(xkb_atom_t) group_names;
+    darray(ModMapEntry) modMaps;
+
+    struct xkb_keymap *keymap;
+} SymbolsInfo;
+
+static void
+InitSymbolsInfo(SymbolsInfo *info, struct xkb_keymap *keymap,
+                ActionsInfo *actions)
+{
+    memset(info, 0, sizeof(*info));
+    info->keymap = keymap;
+    info->merge = MERGE_OVERRIDE;
+    InitKeyInfo(keymap->ctx, &info->default_key);
+    info->actions = actions;
+    info->explicit_group = XKB_LAYOUT_INVALID;
+}
+
+static void
+ClearSymbolsInfo(SymbolsInfo *info)
+{
+    KeyInfo *keyi;
+    free(info->name);
+    darray_foreach(keyi, info->keys)
+        ClearKeyInfo(keyi);
+    darray_free(info->keys);
+    darray_free(info->group_names);
+    darray_free(info->modMaps);
+    ClearKeyInfo(&info->default_key);
+}
+
+static const char *
+KeyInfoText(SymbolsInfo *info, KeyInfo *keyi)
+{
+    return KeyNameText(info->keymap->ctx, keyi->name);
+}
+
+static bool
+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;
+
+    /* First find the type of the merged group. */
+    if (into->type != from->type) {
+        if (from->type == XKB_ATOM_NONE) {
+        }
+        else if (into->type == XKB_ATOM_NONE) {
+            into->type = from->type;
+        }
+        else {
+            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,
+                         "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));
+
+            into->type = use;
+        }
+    }
+    into->defined |= (from->defined & GROUP_FIELD_TYPE);
+
+    /* Now look at the levels. */
+
+    if (darray_empty(from->levels)) {
+        InitGroupInfo(from);
+        return true;
+    }
+
+    if (darray_empty(into->levels)) {
+        from->type = into->type;
+        *into = *from;
+        InitGroupInfo(from);
+        return true;
+    }
+
+    /* Merge the actions and syms. */
+    levels_in_both = MIN(darray_size(into->levels), darray_size(from->levels));
+    for (i = 0; i < levels_in_both; i++) {
+        struct xkb_level *intoLevel = &darray_item(into->levels, i);
+        struct xkb_level *fromLevel = &darray_item(from->levels, i);
+
+        if (fromLevel->action.type == ACTION_TYPE_NONE) {
+        }
+        else if (intoLevel->action.type == ACTION_TYPE_NONE) {
+            intoLevel->action = fromLevel->action;
+        }
+        else {
+            union xkb_action *use, *ignore;
+            use = (clobber ? &fromLevel->action : &intoLevel->action);
+            ignore = (clobber ? &intoLevel->action : &fromLevel->action);
+
+            if (report)
+                log_warn(ctx,
+                         "Multiple actions for level %d/group %u on key %s; "
+                         "Using %s, ignoring %s\n",
+                         i + 1, group + 1, KeyNameText(ctx, key_name),
+                         ActionTypeText(use->type),
+                         ActionTypeText(ignore->type));
+
+            intoLevel->action = *use;
+        }
+
+        if (fromLevel->num_syms == 0) {
+        }
+        else if (intoLevel->num_syms == 0) {
+            intoLevel->num_syms = fromLevel->num_syms;
+            if (fromLevel->num_syms > 1)
+                intoLevel->u.syms = fromLevel->u.syms;
+            else
+                intoLevel->u.sym = fromLevel->u.sym;
+            fromLevel->num_syms = 0;
+        }
+        else {
+            if (report)
+                log_warn(ctx,
+                         "Multiple symbols for level %d/group %u on key %s; "
+                         "Using %s, ignoring %s\n",
+                         i + 1, group + 1, KeyNameText(ctx, key_name),
+                         (clobber ? "from" : "to"),
+                         (clobber ? "to" : "from"));
+
+            if (clobber) {
+                ClearLevelInfo(intoLevel);
+                intoLevel->num_syms = fromLevel->num_syms;
+                if (fromLevel->num_syms > 1)
+                    intoLevel->u.syms = fromLevel->u.syms;
+                else
+                    intoLevel->u.sym = fromLevel->u.sym;
+                fromLevel->num_syms = 0;
+            }
+        }
+    }
+    /* 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;
+    }
+    into->defined |= (from->defined & GROUP_FIELD_ACTS);
+    into->defined |= (from->defined & GROUP_FIELD_SYMS);
+
+    return true;
+}
+
+static bool
+UseNewKeyField(enum key_field field, enum key_field old, enum key_field new,
+               bool clobber, bool report, enum key_field *collide)
+{
+    if (!(old & field))
+        return (new & field);
+
+    if (new & field) {
+        if (report)
+            *collide |= field;
+
+        if (clobber)
+            return true;
+    }
+
+    return false;
+}
+
+static bool
+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;
+    const int verbosity = xkb_context_get_log_verbosity(info->keymap->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);
+        return true;
+    }
+
+    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),
+                    &darray_item(from->groups, i),
+                    clobber, report, i, into->name);
+    /* If @from has extra groups, just move them to @into. */
+    for (i = groups_in_both; i < darray_size(from->groups); i++) {
+        darray_append(into->groups, darray_item(from->groups, i));
+        InitGroupInfo(&darray_item(from->groups, i));
+    }
+
+    if (UseNewKeyField(KEY_FIELD_VMODMAP, into->defined, from->defined,
+                       clobber, report, &collide)) {
+        into->vmodmap = from->vmodmap;
+        into->defined |= KEY_FIELD_VMODMAP;
+    }
+    if (UseNewKeyField(KEY_FIELD_REPEAT, into->defined, from->defined,
+                       clobber, report, &collide)) {
+        into->repeat = from->repeat;
+        into->defined |= KEY_FIELD_REPEAT;
+    }
+    if (UseNewKeyField(KEY_FIELD_DEFAULT_TYPE, into->defined, from->defined,
+                       clobber, report, &collide)) {
+        into->default_type = from->default_type;
+        into->defined |= KEY_FIELD_DEFAULT_TYPE;
+    }
+    if (UseNewKeyField(KEY_FIELD_GROUPINFO, into->defined, from->defined,
+                       clobber, report, &collide)) {
+        into->out_of_range_group_action = from->out_of_range_group_action;
+        into->out_of_range_group_number = from->out_of_range_group_number;
+        into->defined |= KEY_FIELD_GROUPINFO;
+    }
+
+    if (collide)
+        log_warn(info->keymap->ctx,
+                 "Symbol map for key %s redefined; "
+                 "Using %s definition for conflicting fields\n",
+                 KeyNameText(info->keymap->ctx, into->name),
+                 (clobber ? "first" : "last"));
+
+    ClearKeyInfo(from);
+    InitKeyInfo(info->keymap->ctx, from);
+    return true;
+}
+
+static bool
+AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi, bool same_file)
+{
+    xkb_atom_t real_name;
+    KeyInfo *iter;
+
+    /*
+     * Don't keep aliases in the keys array; this guarantees that
+     * searching for keys to merge with by straight comparison (see the
+     * following loop) is enough, and we won't get multiple KeyInfo's
+     * for the same key because of aliases.
+     */
+    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, same_file);
+
+    darray_append(info->keys, *keyi);
+    InitKeyInfo(info->keymap->ctx, keyi);
+    return true;
+}
+
+static bool
+AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
+{
+    ModMapEntry *old;
+    bool clobber = (new->merge != MERGE_AUGMENT);
+
+    darray_foreach(old, info->modMaps) {
+        xkb_mod_index_t use, ignore;
+
+        if ((new->haveSymbol != old->haveSymbol) ||
+            (new->haveSymbol && new->u.keySym != old->u.keySym) ||
+            (!new->haveSymbol && new->u.keyName != old->u.keyName))
+            continue;
+
+        if (new->modifier == old->modifier)
+            return true;
+
+        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));
+
+        old->modifier = use;
+        return true;
+    }
+
+    darray_append(info->modMaps, *new);
+    return true;
+}
+
+/***====================================================================***/
+
+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;
+
+    if (from->errorCount > 0) {
+        into->errorCount += from->errorCount;
+        return;
+    }
+
+    if (into->name == NULL) {
+        into->name = from->name;
+        from->name = NULL;
+    }
+
+    group_names_in_both = MIN(darray_size(into->group_names),
+                              darray_size(from->group_names));
+    for (i = 0; i < group_names_in_both; i++) {
+        if (!darray_item(from->group_names, i))
+            continue;
+
+        if (merge == MERGE_AUGMENT && darray_item(into->group_names, i))
+            continue;
+
+        darray_item(into->group_names, i) = darray_item(from->group_names, i);
+    }
+    /* If @from has more, get them as well. */
+    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, false))
+            into->errorCount++;
+    }
+
+    darray_foreach(mm, from->modMaps) {
+        mm->merge = (merge == MERGE_DEFAULT ? mm->merge : merge);
+        if (!AddModMapEntry(into, mm))
+            into->errorCount++;
+    }
+}
+
+static void
+HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge);
+
+static bool
+HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *include)
+{
+    SymbolsInfo included;
+
+    InitSymbolsInfo(&included, info->keymap, info->actions);
+    included.name = include->stmt;
+    include->stmt = NULL;
+
+    for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
+        SymbolsInfo next_incl;
+        XkbFile *file;
+
+        file = ProcessIncludeFile(info->keymap->ctx, stmt, FILE_TYPE_SYMBOLS);
+        if (!file) {
+            info->errorCount += 10;
+            ClearSymbolsInfo(&included);
+            return false;
+        }
+
+        InitSymbolsInfo(&next_incl, info->keymap, info->actions);
+        if (stmt->modifier) {
+            next_incl.explicit_group = atoi(stmt->modifier) - 1;
+            if (next_incl.explicit_group >= XKB_MAX_GROUPS) {
+                log_err(info->keymap->ctx,
+                        "Cannot set explicit group to %d - must be between 1..%d; "
+                        "Ignoring group number\n",
+                        next_incl.explicit_group + 1, XKB_MAX_GROUPS);
+                next_incl.explicit_group = info->explicit_group;
+            }
+        }
+        else {
+            next_incl.explicit_group = info->explicit_group;
+        }
+
+        HandleSymbolsFile(&next_incl, file, MERGE_OVERRIDE);
+
+        MergeIncludedSymbols(&included, &next_incl, stmt->merge);
+
+        ClearSymbolsInfo(&next_incl);
+        FreeXkbFile(file);
+    }
+
+    MergeIncludedSymbols(info, &included, include->merge);
+    ClearSymbolsInfo(&included);
+
+    return (info->errorCount == 0);
+}
+
+#define SYMBOLS 1
+#define ACTIONS 2
+
+static bool
+GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
+              unsigned what, xkb_layout_index_t *ndx_rtrn)
+{
+    const char *name = (what == SYMBOLS ? "symbols" : "actions");
+
+    if (arrayNdx == NULL) {
+        xkb_layout_index_t i;
+        GroupInfo *groupi;
+        enum group_field field = (what == SYMBOLS ?
+                                  GROUP_FIELD_SYMS : GROUP_FIELD_ACTS);
+
+        darray_enumerate(i, groupi, keyi->groups) {
+            if (!(groupi->defined & field)) {
+                *ndx_rtrn = i;
+                return true;
+            }
+        }
+
+        if (i >= XKB_MAX_GROUPS) {
+            log_err(info->keymap->ctx,
+                    "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);
+            return false;
+        }
+
+        darray_resize0(keyi->groups, darray_size(keyi->groups) + 1);
+        *ndx_rtrn = darray_size(keyi->groups) - 1;
+        return true;
+    }
+
+    if (!ExprResolveGroup(info->keymap->ctx, arrayNdx, ndx_rtrn)) {
+        log_err(info->keymap->ctx,
+                "Illegal group index for %s of key %s\n"
+                "Definition with non-integer array index ignored\n",
+                name, KeyInfoText(info, keyi));
+        return false;
+    }
+
+    (*ndx_rtrn)--;
+    if (*ndx_rtrn >= darray_size(keyi->groups))
+        darray_resize0(keyi->groups, *ndx_rtrn + 1);
+
+    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)
+{
+    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;
+
+    groupi = &darray_item(keyi->groups, ndx);
+
+    if (value == NULL) {
+        groupi->defined |= GROUP_FIELD_SYMS;
+        return true;
+    }
+
+    if (value->op != EXPR_KEYSYM_LIST) {
+        log_err(info->keymap->ctx,
+                "Expected a list of symbols, found %s; "
+                "Ignoring symbols for group %u of %s\n",
+                expr_op_type_to_string(value->op), ndx + 1,
+                KeyInfoText(info, keyi));
+        return false;
+    }
+
+    if (groupi->defined & GROUP_FIELD_SYMS) {
+        log_err(info->keymap->ctx,
+                "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);
+    if (darray_size(groupi->levels) < nLevels)
+        darray_resize0(groupi->levels, nLevels);
+
+    groupi->defined |= GROUP_FIELD_SYMS;
+
+    for (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)
+            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->num_syms == 1) {
+                if (keysym == XKB_KEY_NoSymbol)
+                    leveli->num_syms = 0;
+                else
+                    leveli->u.sym = keysym;
+            }
+            else if (leveli->num_syms > 1) {
+                leveli->u.syms[j] = keysym;
+            }
+        }
+    }
+
+    return true;
+}
+
+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;
+
+    groupi = &darray_item(keyi->groups, ndx);
+
+    if (value == NULL) {
+        groupi->defined |= GROUP_FIELD_ACTS;
+        return true;
+    }
+
+    if (value->op != EXPR_ACTION_LIST) {
+        log_wsgo(info->keymap->ctx,
+                 "Bad expression type (%d) for action list value; "
+                 "Ignoring actions for group %u of %s\n",
+                 value->op, ndx, KeyInfoText(info, keyi));
+        return false;
+    }
+
+    if (groupi->defined & GROUP_FIELD_ACTS) {
+        log_wsgo(info->keymap->ctx,
+                 "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)
+        nActs++;
+
+    if (darray_size(groupi->levels) < nActs)
+        darray_resize0(groupi->levels, nActs);
+
+    groupi->defined |= GROUP_FIELD_ACTS;
+
+    act = value->value.child;
+    for (i = 0; i < nActs; i++) {
+        toAct = &darray_item(groupi->levels, i).action;
+
+        if (!HandleActionDef(act, info->keymap, toAct, info->actions))
+            log_err(info->keymap->ctx,
+                    "Illegal action definition for %s; "
+                    "Action for group %u/level %u ignored\n",
+                    KeyInfoText(info, keyi), ndx + 1, i + 1);
+
+        act = (ExprDef *) act->common.next;
+    }
+
+    return true;
+}
+
+static const LookupEntry repeatEntries[] = {
+    { "true", KEY_REPEAT_YES },
+    { "yes", KEY_REPEAT_YES },
+    { "on", KEY_REPEAT_YES },
+    { "false", KEY_REPEAT_NO },
+    { "no", KEY_REPEAT_NO },
+    { "off", KEY_REPEAT_NO },
+    { "default", KEY_REPEAT_UNDEFINED },
+    { NULL, 0 }
+};
+
+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,
+                    "The type field of a key symbol map must be a string; "
+                    "Ignoring illegal type definition\n");
+
+        if (arrayNdx == NULL) {
+            keyi->default_type = val;
+            keyi->defined |= KEY_FIELD_DEFAULT_TYPE;
+        }
+        else if (!ExprResolveGroup(ctx, arrayNdx, &ndx)) {
+            log_err(ctx,
+                    "Illegal group index for type of key %s; "
+                    "Definition with non-integer array index ignored\n",
+                    KeyInfoText(info, keyi));
+            return false;
+        }
+        else {
+            ndx--;
+            if (ndx >= darray_size(keyi->groups))
+                darray_resize0(keyi->groups, ndx + 1);
+            darray_item(keyi->groups, ndx).type = val;
+            darray_item(keyi->groups, ndx).defined |= GROUP_FIELD_TYPE;
+        }
+    }
+    else if (istreq(field, "symbols"))
+        return AddSymbolsToKey(info, keyi, arrayNdx, value);
+    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,
+                    "Expected a virtual modifier mask, found %s; "
+                    "Ignoring virtual modifiers definition for key %s\n",
+                    expr_op_type_to_string(value->op),
+                    KeyInfoText(info, keyi));
+        }
+    }
+    else if (istreq(field, "locking") ||
+             istreq(field, "lock") ||
+             istreq(field, "locks")) {
+        log_err(info->keymap->ctx,
+                "Key behaviors not supported; "
+                "Ignoring locking specification for key %s\n",
+                KeyInfoText(info, keyi));
+    }
+    else if (istreq(field, "radiogroup") ||
+             istreq(field, "permanentradiogroup") ||
+             istreq(field, "allownone")) {
+        log_err(info->keymap->ctx,
+                "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,
+                "Overlays not supported; "
+                "Ignoring overlay specification for key %s\n",
+                KeyInfoText(info, keyi));
+    }
+    else if (istreq(field, "repeating") ||
+             istreq(field, "repeats") ||
+             istreq(field, "repeat")) {
+        unsigned int val;
+
+        ok = ExprResolveEnum(ctx, value, &val, repeatEntries);
+        if (!ok) {
+            log_err(info->keymap->ctx,
+                    "Illegal repeat setting for %s; "
+                    "Non-boolean repeat setting ignored\n",
+                    KeyInfoText(info, keyi));
+            return false;
+        }
+        keyi->repeat = val;
+        keyi->defined |= KEY_FIELD_REPEAT;
+    }
+    else if (istreq(field, "groupswrap") ||
+             istreq(field, "wrapgroups")) {
+        bool set;
+
+        if (!ExprResolveBoolean(ctx, value, &set)) {
+            log_err(info->keymap->ctx,
+                    "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->defined |= KEY_FIELD_GROUPINFO;
+    }
+    else if (istreq(field, "groupsclamp") ||
+             istreq(field, "clampgroups")) {
+        bool set;
+
+        if (!ExprResolveBoolean(ctx, value, &set)) {
+            log_err(info->keymap->ctx,
+                    "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->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,
+                    "Illegal group index for redirect of key %s; "
+                    "Definition with non-integer group ignored\n",
+                    KeyInfoText(info, keyi));
+            return false;
+        }
+
+        keyi->out_of_range_group_action = RANGE_REDIRECT;
+        keyi->out_of_range_group_number = grp - 1;
+        keyi->defined |= KEY_FIELD_GROUPINFO;
+    }
+    else {
+        log_err(info->keymap->ctx,
+                "Unknown field %s in a symbol interpretation; "
+                "Definition ignored\n",
+                field);
+        ok = false;
+    }
+
+    return ok;
+}
+
+static int
+SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
+{
+    xkb_layout_index_t group, group_to_use;
+    xkb_atom_t name;
+
+    if (!arrayNdx) {
+        log_vrb(info->keymap->ctx, 1,
+                "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, &group)) {
+        log_err(info->keymap->ctx,
+                "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,
+                "Group name must be a string; "
+                "Illegal name for group %d ignored\n", group);
+        return false;
+    }
+
+    if (info->explicit_group == XKB_LAYOUT_INVALID) {
+        group_to_use = group - 1;
+    }
+    else if (group - 1 == 0) {
+        group_to_use = info->explicit_group;
+    }
+    else {
+        log_warn(info->keymap->ctx,
+                 "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, group,
+                 xkb_atom_text(info->keymap->ctx, name));
+        return false;
+    }
+
+    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
+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 (elem && istreq(elem, "key")) {
+        ret = SetSymbolsField(info, &info->default_key, field, arrayNdx,
+                              stmt->value);
+    }
+    else if (!elem && (istreq(field, "name") ||
+                       istreq(field, "groupname"))) {
+        ret = SetGroupName(info, arrayNdx, stmt->value);
+    }
+    else if (!elem && (istreq(field, "groupswrap") ||
+                       istreq(field, "wrapgroups"))) {
+        log_err(info->keymap->ctx,
+                "Global \"groupswrap\" not supported; Ignored\n");
+        ret = true;
+    }
+    else if (!elem && (istreq(field, "groupsclamp") ||
+                       istreq(field, "clampgroups"))) {
+        log_err(info->keymap->ctx,
+                "Global \"groupsclamp\" not supported; Ignored\n");
+        ret = true;
+    }
+    else if (!elem && (istreq(field, "groupsredirect") ||
+                       istreq(field, "redirectgroups"))) {
+        log_err(info->keymap->ctx,
+                "Global \"groupsredirect\" not supported; Ignored\n");
+        ret = true;
+    }
+    else if (!elem && istreq(field, "allownone")) {
+        log_err(info->keymap->ctx,
+                "Radio groups not supported; "
+                "Ignoring \"allownone\" specification\n");
+        ret = true;
+    }
+    else {
+        ret = SetActionField(info->keymap, elem, field, arrayNdx, stmt->value,
+                             info->actions);
+    }
+
+    return ret;
+}
+
+static bool
+HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
+{
+    bool ok = true;
+    const char *elem, *field;
+    ExprDef *arrayNdx;
+
+    for (; def; def = (VarDef *) def->common.next) {
+        if (def->name && def->name->op == EXPR_FIELD_REF) {
+            log_err(info->keymap->ctx,
+                    "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)
+                field = "symbols";
+            else
+                field = "actions";
+            arrayNdx = NULL;
+        }
+        else {
+            ok = ExprResolveLhs(info->keymap->ctx, def->name, &elem, &field,
+                                &arrayNdx);
+        }
+
+        if (ok)
+            ok = SetSymbolsField(info, keyi, field, arrayNdx, def->value);
+    }
+
+    return ok;
+}
+
+static bool
+SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
+{
+    xkb_layout_index_t i;
+    GroupInfo *groupi;
+    bool warn = false;
+
+    if (info->explicit_group == XKB_LAYOUT_INVALID)
+        return true;
+
+    darray_enumerate_from(i, groupi, keyi->groups, 1) {
+        if (groupi->defined) {
+            warn = true;
+            ClearGroupInfo(groupi);
+            InitGroupInfo(groupi);
+        }
+    }
+
+    if (warn)
+        log_warn(info->keymap->ctx,
+                 "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) {
+        darray_item(keyi->groups, info->explicit_group) =
+            darray_item(keyi->groups, 0);
+        InitGroupInfo(&darray_item(keyi->groups, 0));
+    }
+
+    return true;
+}
+
+static int
+HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
+{
+    KeyInfo keyi;
+    xkb_layout_index_t i;
+
+    keyi = info->default_key;
+    darray_init(keyi.groups);
+    darray_copy(keyi.groups, info->default_key.groups);
+    for (i = 0; i < darray_size(keyi.groups); i++)
+        CopyGroupInfo(&darray_item(keyi.groups, i),
+                      &darray_item(info->default_key.groups, i));
+    keyi.merge = stmt->merge;
+    keyi.name = stmt->keyName;
+
+    if (!HandleSymbolsBody(info, (VarDef *) stmt->symbols, &keyi)) {
+        info->errorCount++;
+        return false;
+    }
+
+    if (!SetExplicitGroup(info, &keyi)) {
+        info->errorCount++;
+        return false;
+    }
+
+    if (!AddKeySymbols(info, &keyi, true)) {
+        info->errorCount++;
+        return false;
+    }
+
+    return true;
+}
+
+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;
+    }
+
+    ok = true;
+    tmp.modifier = ndx;
+
+    for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) {
+        xkb_keysym_t sym;
+
+        if (key->op == EXPR_VALUE && key->value_type == EXPR_TYPE_KEYNAME) {
+            tmp.haveSymbol = false;
+            tmp.u.keyName = key->value.keyName;
+        }
+        else if (ExprResolveKeySym(ctx, key, &sym)) {
+            tmp.haveSymbol = true;
+            tmp.u.keySym = sym;
+        }
+        else {
+            log_err(info->keymap->ctx,
+                    "Modmap entries may contain only key names or keysyms; "
+                    "Illegal definition for %s modifier ignored\n",
+                    ModIndexText(info->keymap, tmp.modifier));
+            continue;
+        }
+
+        ok = AddModMapEntry(info, &tmp) && ok;
+    }
+    return ok;
+}
+
+static void
+HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
+{
+    bool ok;
+
+    free(info->name);
+    info->name = strdup_safe(file->name);
+
+    for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
+        switch (stmt->type) {
+        case STMT_INCLUDE:
+            ok = HandleIncludeSymbols(info, (IncludeStmt *) stmt);
+            break;
+        case STMT_SYMBOLS:
+            ok = HandleSymbolsDef(info, (SymbolsDef *) stmt);
+            break;
+        case STMT_VAR:
+            ok = HandleGlobalVar(info, (VarDef *) stmt);
+            break;
+        case STMT_VMOD:
+            ok = HandleVModDef(info->keymap, (VModDef *) stmt);
+            break;
+        case STMT_MODMAP:
+            ok = HandleModMapDef(info, (ModMapDef *) stmt);
+            break;
+        default:
+            log_err(info->keymap->ctx,
+                    "Interpretation files may not include other types; "
+                    "Ignoring %s\n", stmt_type_to_string(stmt->type));
+            ok = false;
+            break;
+        }
+
+        if (!ok)
+            info->errorCount++;
+
+        if (info->errorCount > 10) {
+            log_err(info->keymap->ctx, "Abandoning symbols file \"%s\"\n",
+                    file->topName);
+            break;
+        }
+    }
+}
+
+/**
+ * Given a keysym @sym, return a key which generates it, or NULL.
+ * This is used for example in a modifier map definition, such as:
+ *      modifier_map Lock           { Caps_Lock };
+ * where we want to add the Lock modifier to the modmap of the key
+ * which matches the keysym Caps_Lock.
+ * Since there can be many keys which generates the keysym, the key
+ * is chosen first by lowest group in which the keysym appears, than
+ * by lowest level and than by lowest key code.
+ */
+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;
+                    }
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+/*
+ * Find an appropriate type for a group and return its name.
+ *
+ * Simple recipe:
+ * - ONE_LEVEL for width 0/1
+ * - ALPHABETIC for 2 shift levels, with lower/upercase keysyms
+ * - KEYPAD for keypad keys.
+ * - TWO_LEVEL for other 2 shift level keys.
+ * and the same for four level keys.
+ *
+ * FIXME: Decide how to handle multiple-syms-per-level, and do it.
+ */
+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);
+
+#define GET_SYM(level) \
+    (darray_item(groupi->levels, level).num_syms == 0 ? \
+        XKB_KEY_NoSymbol : \
+     darray_item(groupi->levels, level).num_syms == 1 ? \
+        darray_item(groupi->levels, level).u.sym : \
+     /* num_syms > 1 */ \
+        darray_item(groupi->levels, level).u.syms[0])
+
+    if (width == 1 || width <= 0)
+        return xkb_atom_intern(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");
+
+        if (xkb_keysym_is_keypad(sym0) || xkb_keysym_is_keypad(sym1))
+            return xkb_atom_intern(ctx, "KEYPAD");
+
+        return xkb_atom_intern(ctx, "TWO_LEVEL");
+    }
+
+    if (width <= 4) {
+        if (xkb_keysym_is_lower(sym0) && xkb_keysym_is_upper(sym1)) {
+            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(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(ctx, "FOUR_LEVEL");
+    }
+
+    return XKB_ATOM_NONE;
+
+#undef GET_SYM
+}
+
+static const struct xkb_key_type *
+FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
+                 xkb_layout_index_t group, bool *explicit_type)
+{
+    unsigned int i;
+    GroupInfo *groupi = &darray_item(keyi->groups, group);
+    xkb_atom_t type_name = groupi->type;
+
+    *explicit_type = true;
+
+    if (type_name == XKB_ATOM_NONE) {
+        if (keyi->default_type != XKB_ATOM_NONE) {
+            type_name  = keyi->default_type;
+        }
+        else {
+            type_name = FindAutomaticType(keymap->ctx, groupi);
+            if (type_name != XKB_ATOM_NONE)
+                *explicit_type = false;
+        }
+    }
+
+    if (type_name == XKB_ATOM_NONE) {
+        log_warn(keymap->ctx,
+                 "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,
+                 (unsigned long) darray_size(groupi->levels));
+        goto use_default;
+    }
+
+    for (i = 0; i < keymap->num_types; i++)
+        if (keymap->types[i].name == type_name)
+            break;
+
+    if (i >= keymap->num_types) {
+        log_warn(keymap->ctx,
+                 "The type \"%s\" for key '%s' group %d was not previously defined; "
+                 "Using the default type\n",
+                 xkb_atom_text(keymap->ctx, type_name),
+                 KeyNameText(keymap->ctx, keyi->name), group + 1);
+        goto use_default;
+    }
+
+    return &keymap->types[i];
+
+use_default:
+    /*
+     * Index 0 is guaranteed to contain something, usually
+     * ONE_LEVEL or at least some default one-level type.
+     */
+    return &keymap->types[0];
+}
+
+static bool
+CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
+{
+    struct xkb_keymap *keymap = info->keymap;
+    struct xkb_key *key;
+    GroupInfo *groupi;
+    const GroupInfo *group0;
+    xkb_layout_index_t i;
+
+    /*
+     * The name is guaranteed to be real and not an alias (see
+     * AddKeySymbols), so 'false' is safe here.
+     */
+    key = XkbKeyByName(keymap, keyi->name, false);
+    if (!key) {
+        log_vrb(info->keymap->ctx, 5,
+                "Key %s not found in keycodes; Symbols ignored\n",
+                KeyInfoText(info, keyi));
+        return false;
+    }
+
+    /* Find the range of groups we need. */
+    key->num_groups = 0;
+    darray_enumerate(i, groupi, keyi->groups)
+        if (groupi->defined)
+            key->num_groups = i + 1;
+
+    if (key->num_groups <= 0)
+        return false; /* WSGO */
+
+    darray_resize(keyi->groups, key->num_groups);
+
+    /*
+     * If there are empty groups between non-empty ones, fill them with data
+     * from the first group.
+     * We can make a wrong assumption here. But leaving gaps is worse.
+     */
+    group0 = &darray_item(keyi->groups, 0);
+    darray_foreach_from(groupi, keyi->groups, 1) {
+        if (groupi->defined)
+            continue;
+
+        CopyGroupInfo(groupi, group0);
+    }
+
+    key->groups = calloc(key->num_groups, sizeof(*key->groups));
+
+    /* Find and assign the groups' types in the keymap. */
+    darray_enumerate(i, groupi, keyi->groups) {
+        const struct xkb_key_type *type;
+        bool explicit_type;
+
+        type = FindTypeForGroup(keymap, keyi, i, &explicit_type);
+
+        /* Always have as many levels as the type specifies. */
+        if (type->num_levels < darray_size(groupi->levels)) {
+            struct xkb_level *leveli;
+
+            log_vrb(info->keymap->ctx, 1,
+                    "Type \"%s\" has %d levels, but %s has %d levels; "
+                    "Ignoring extra symbols\n",
+                    xkb_atom_text(keymap->ctx, type->name), type->num_levels,
+                    KeyInfoText(info, keyi),
+                    (int) darray_size(groupi->levels));
+
+            darray_foreach_from(leveli, groupi->levels, type->num_levels)
+                ClearLevelInfo(leveli);
+        }
+        darray_resize0(groupi->levels, type->num_levels);
+
+        key->groups[i].explicit_type = explicit_type;
+        key->groups[i].type = type;
+    }
+
+    /* Copy levels. */
+    darray_enumerate(i, groupi, keyi->groups) {
+        key->groups[i].levels = darray_mem(groupi->levels, 0);
+        darray_init(groupi->levels);
+    }
+
+    key->out_of_range_group_number = keyi->out_of_range_group_number;
+    key->out_of_range_group_action = keyi->out_of_range_group_action;
+
+    if (keyi->defined & KEY_FIELD_VMODMAP) {
+        key->vmodmap = keyi->vmodmap;
+        key->explicit |= EXPLICIT_VMODMAP;
+    }
+
+    if (keyi->repeat != KEY_REPEAT_UNDEFINED) {
+        key->repeats = (keyi->repeat == KEY_REPEAT_YES);
+        key->explicit |= EXPLICIT_REPEAT;
+    }
+
+    darray_foreach(groupi, keyi->groups) {
+        if (groupi->defined & GROUP_FIELD_ACTS) {
+            key->explicit |= EXPLICIT_INTERP;
+            break;
+        }
+    }
+
+    return true;
+}
+
+static bool
+CopyModMapDef(SymbolsInfo *info, ModMapEntry *entry)
+{
+    struct xkb_key *key;
+    struct xkb_keymap *keymap = info->keymap;
+
+    if (!entry->haveSymbol) {
+        key = XkbKeyByName(keymap, entry->u.keyName, true);
+        if (!key) {
+            log_vrb(info->keymap->ctx, 5,
+                    "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));
+            return false;
+        }
+    }
+    else {
+        key = FindKeyForSymbol(keymap, entry->u.keySym);
+        if (!key) {
+            log_vrb(info->keymap->ctx, 5,
+                    "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));
+            return false;
+        }
+    }
+
+    key->modmap |= (1 << entry->modifier);
+    return true;
+}
+
+static bool
+CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
+{
+    KeyInfo *keyi;
+    ModMapEntry *mm;
+    struct xkb_key *key;
+
+    keymap->symbols_section_name = strdup_safe(info->name);
+
+    keymap->num_group_names = darray_size(info->group_names);
+    keymap->group_names = darray_mem(info->group_names, 0);
+    darray_init(info->group_names);
+
+    darray_foreach(keyi, info->keys)
+        if (!CopySymbolsDef(info, keyi))
+            info->errorCount++;
+
+    if (xkb_context_get_log_verbosity(keymap->ctx) > 3) {
+        xkb_foreach_key(key, keymap) {
+            if (key->name == XKB_ATOM_NONE)
+                continue;
+
+            if (key->num_groups < 1)
+                log_info(keymap->ctx,
+                         "No symbols defined for %s\n",
+                         KeyNameText(keymap->ctx, key->name));
+        }
+    }
+
+    darray_foreach(mm, info->modMaps)
+        if (!CopyModMapDef(info, mm))
+            info->errorCount++;
+
+    /* XXX: If we don't ignore errorCount, things break. */
+    return true;
+}
+
+bool
+CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
+               enum merge_mode merge)
+{
+    SymbolsInfo info;
+    ActionsInfo *actions;
+
+    actions = NewActionsInfo();
+    if (!actions)
+        return false;
+
+    InitSymbolsInfo(&info, keymap, actions);
+    info.default_key.merge = merge;
+
+    HandleSymbolsFile(&info, file, merge);
+
+    if (darray_empty(info.keys))
+        goto err_info;
+
+    if (info.errorCount != 0)
+        goto err_info;
+
+    if (!CopySymbolsToKeymap(keymap, &info))
+        goto err_info;
+
+    ClearSymbolsInfo(&info);
+    FreeActionsInfo(actions);
+    return true;
+
+err_info:
+    FreeActionsInfo(actions);
+    ClearSymbolsInfo(&info);
+    return false;
+}