dos -> unix

1 files changed, 1293 insertions, 1293 deletions

diff --git a/xkbcomp/keytypes.c b/xkbcomp/keytypes.c
index d0d5302f9..da55d755d 100644
--- a/xkbcomp/keytypes.c
+++ b/xkbcomp/keytypes.c
@@ -1,1293 +1,1293 @@
-/************************************************************

- 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.

-

- ********************************************************/

-

-#include "xkbcomp.h"

-#include "tokens.h"

-#include "expr.h"

-#include "vmod.h"

-#include "action.h"

-#include "misc.h"

-

-typedef struct _PreserveInfo

-{

-    CommonInfo defs;

-    short matchingMapIndex;

-    unsigned char indexMods;

-    unsigned char preMods;

-    unsigned short indexVMods;

-    unsigned short preVMods;

-} PreserveInfo;

-

-#define	_KT_Name	(1<<0)

-#define	_KT_Mask	(1<<1)

-#define	_KT_Map		(1<<2)

-#define	_KT_Preserve	(1<<3)

-#define	_KT_LevelNames	(1<<4)

-

-typedef struct _KeyTypeInfo

-{

-    CommonInfo defs;

-    Display *dpy;

-    Atom name;

-    int fileID;

-    unsigned mask;

-    unsigned vmask;

-    Bool groupInfo;

-    int numLevels;

-    int nEntries;

-    int szEntries;

-    XkbKTMapEntryPtr entries;

-    PreserveInfo *preserve;

-    int szNames;

-    Atom *lvlNames;

-} KeyTypeInfo;

-

-typedef struct _KeyTypesInfo

-{

-    Display *dpy;

-    char *name;

-    int errorCount;

-    int fileID;

-    unsigned stdPresent;

-    int nTypes;

-    KeyTypeInfo *types;

-    KeyTypeInfo dflt;

-    VModInfo vmods;

-} KeyTypesInfo;

-

-Atom tok_ONE_LEVEL;

-Atom tok_TWO_LEVEL;

-Atom tok_ALPHABETIC;

-Atom tok_KEYPAD;

-

-/***====================================================================***/

-

-#define	ReportTypeShouldBeArray(t,f) \

-	ReportShouldBeArray("key type",(f),TypeTxt(t))

-#define	ReportTypeBadType(t,f,w) \

-	ReportBadType("key type",(f),TypeTxt(t),(w))

-

-/***====================================================================***/

-

-extern Bool AddMapEntry(XkbDescPtr /* xkb */ ,

-                        KeyTypeInfo * /* type */ ,

-                        XkbKTMapEntryPtr /* new */ ,

-                        Bool /* clobber */ ,

-                        Bool    /* report */

-    );

-

-extern Bool AddPreserve(XkbDescPtr /* xkb */ ,

-                        KeyTypeInfo * /* type */ ,

-                        PreserveInfo * /* new */ ,

-                        Bool /* clobber */ ,

-                        Bool    /* report */

-    );

-

-extern Bool AddLevelName(KeyTypeInfo * /* type */ ,

-                         unsigned /* level */ ,

-                         Atom /* name */ ,

-                         Bool /* clobber */ ,

-                         Bool   /* report */

-    );

-

-#define	MapEntryTxt(t,x,e)	\

-    XkbVModMaskText((t)->dpy,(x),(e)->mods.real_mods,(e)->mods.vmods,XkbMessage)

-#define	PreserveIndexTxt(t,x,p)	\

-	XkbVModMaskText((t)->dpy,(x),(p)->indexMods,(p)->indexVMods,XkbMessage)

-#define	PreserveTxt(t,x,p)	\

-	XkbVModMaskText((t)->dpy,(x),(p)->preMods,(p)->preVMods,XkbMessage)

-#define	TypeTxt(t)	XkbAtomText((t)->dpy,(t)->name,XkbMessage)

-#define	TypeMaskTxt(t,x)	\

-	XkbVModMaskText((t)->dpy,(x),(t)->mask,(t)->vmask,XkbMessage)

-

-/***====================================================================***/

-

-static void

-InitKeyTypesInfo(KeyTypesInfo * info, XkbDescPtr xkb, KeyTypesInfo * from)

-{

-    tok_ONE_LEVEL = XkbInternAtom(NULL, "ONE_LEVEL", False);

-    tok_TWO_LEVEL = XkbInternAtom(NULL, "TWO_LEVEL", False);

-    tok_ALPHABETIC = XkbInternAtom(NULL, "ALPHABETIC", False);

-    tok_KEYPAD = XkbInternAtom(NULL, "KEYPAD", False);

-    info->dpy = NULL;

-    info->name = uStringDup("default");

-    info->errorCount = 0;

-    info->stdPresent = 0;

-    info->nTypes = 0;

-    info->types = NULL;

-    info->dflt.defs.defined = 0;

-    info->dflt.defs.fileID = 0;

-    info->dflt.defs.merge = MergeOverride;

-    info->dflt.defs.next = NULL;

-    info->dflt.name = None;

-    info->dflt.mask = 0;

-    info->dflt.vmask = 0;

-    info->dflt.groupInfo = False;

-    info->dflt.numLevels = 1;

-    info->dflt.nEntries = info->dflt.szEntries = 0;

-    info->dflt.entries = NULL;

-    info->dflt.szNames = 0;

-    info->dflt.lvlNames = NULL;

-    info->dflt.preserve = NULL;

-    InitVModInfo(&info->vmods, xkb);

-    if (from != NULL)

-    {

-        info->dpy = from->dpy;

-        info->dflt = from->dflt;

-        if (from->dflt.entries)

-        {

-            info->dflt.entries = uTypedCalloc(from->dflt.szEntries,

-                                              XkbKTMapEntryRec);

-            if (info->dflt.entries)

-            {

-                unsigned sz = from->dflt.nEntries * sizeof(XkbKTMapEntryRec);

-                memcpy(info->dflt.entries, from->dflt.entries, sz);

-            }

-        }

-        if (from->dflt.lvlNames)

-        {

-            info->dflt.lvlNames = uTypedCalloc(from->dflt.szNames, Atom);

-            if (info->dflt.lvlNames)

-            {

-                register unsigned sz = from->dflt.szNames * sizeof(Atom);

-                memcpy(info->dflt.lvlNames, from->dflt.lvlNames, sz);

-            }

-        }

-        if (from->dflt.preserve)

-        {

-            PreserveInfo *old, *new, *last;

-            last = NULL;

-            old = from->dflt.preserve;

-            for (; old; old = (PreserveInfo *) old->defs.next)

-            {

-                new = uTypedAlloc(PreserveInfo);

-                if (!new)

-                    return;

-                *new = *old;

-                new->defs.next = NULL;

-                if (last)

-                    last->defs.next = (CommonInfo *) new;

-                else

-                    info->dflt.preserve = new;

-                last = new;

-            }

-        }

-    }

-    return;

-}

-

-static void

-FreeKeyTypeInfo(KeyTypeInfo * type)

-{

-    if (type->entries != NULL)

-    {

-        uFree(type->entries);

-        type->entries = NULL;

-    }

-    if (type->lvlNames != NULL)

-    {

-        uFree(type->lvlNames);

-        type->lvlNames = NULL;

-    }

-    if (type->preserve != NULL)

-    {

-        ClearCommonInfo(&type->preserve->defs);

-        type->preserve = NULL;

-    }

-    return;

-}

-

-static void

-FreeKeyTypesInfo(KeyTypesInfo * info)

-{

-    info->dpy = NULL;

-    if (info->name)

-        uFree(info->name);

-    info->name = NULL;

-    if (info->types)

-    {

-        register KeyTypeInfo *type;

-        for (type = info->types; type; type = (KeyTypeInfo *) type->defs.next)

-        {

-            FreeKeyTypeInfo(type);

-        }

-        info->types = (KeyTypeInfo *) ClearCommonInfo(&info->types->defs);

-    }

-    FreeKeyTypeInfo(&info->dflt);

-    return;

-}

-

-static KeyTypeInfo *

-NextKeyType(KeyTypesInfo * info)

-{

-    KeyTypeInfo *type;

-

-    type = uTypedAlloc(KeyTypeInfo);

-    if (type != NULL)

-    {

-        bzero(type, sizeof(KeyTypeInfo));

-        type->defs.fileID = info->fileID;

-        type->dpy = info->dpy;

-        info->types = (KeyTypeInfo *) AddCommonInfo(&info->types->defs,

-                                                    (CommonInfo *) type);

-        info->nTypes++;

-    }

-    return type;

-}

-

-static KeyTypeInfo *

-FindMatchingKeyType(KeyTypesInfo * info, KeyTypeInfo * new)

-{

-    KeyTypeInfo *old;

-

-    for (old = info->types; old; old = (KeyTypeInfo *) old->defs.next)

-    {

-        if (old->name == new->name)

-            return old;

-    }

-    return NULL;

-}

-

-static Bool

-ReportTypeBadWidth(const char *type, int has, int needs)

-{

-    ERROR3("Key type \"%s\" has %d levels, must have %d\n", type, has, needs);

-    ACTION("Illegal type definition ignored\n");

-    return False;

-}

-

-static Bool

-AddKeyType(XkbDescPtr xkb, KeyTypesInfo * info, KeyTypeInfo * new)

-{

-    KeyTypeInfo *old;

-

-    if (new->name == tok_ONE_LEVEL)

-    {

-        if (new->numLevels > 1)

-            return ReportTypeBadWidth("ONE_LEVEL", new->numLevels, 1);

-        info->stdPresent |= XkbOneLevelMask;

-    }

-    else if (new->name == tok_TWO_LEVEL)

-    {

-        if (new->numLevels > 2)

-            return ReportTypeBadWidth("TWO_LEVEL", new->numLevels, 2);

-        else if (new->numLevels < 2)

-            new->numLevels = 2;

-        info->stdPresent |= XkbTwoLevelMask;

-    }

-    else if (new->name == tok_ALPHABETIC)

-    {

-        if (new->numLevels > 2)

-            return ReportTypeBadWidth("ALPHABETIC", new->numLevels, 2);

-        else if (new->numLevels < 2)

-            new->numLevels = 2;

-        info->stdPresent |= XkbAlphabeticMask;

-    }

-    else if (new->name == tok_KEYPAD)

-    {

-        if (new->numLevels > 2)

-            return ReportTypeBadWidth("KEYPAD", new->numLevels, 2);

-        else if (new->numLevels < 2)

-            new->numLevels = 2;

-        info->stdPresent |= XkbKeypadMask;

-    }

-

-    old = FindMatchingKeyType(info, new);

-    if (old != NULL)

-    {

-        Bool report;

-        if ((new->defs.merge == MergeReplace)

-            || (new->defs.merge == MergeOverride))

-        {

-            KeyTypeInfo *next = (KeyTypeInfo *) old->defs.next;

-            if (((old->defs.fileID == new->defs.fileID)

-                 && (warningLevel > 0)) || (warningLevel > 9))

-            {

-                WARN1("Multiple definitions of the %s key type\n",

-                      XkbAtomGetString(NULL, new->name));

-                ACTION("Earlier definition ignored\n");

-            }

-            FreeKeyTypeInfo(old);

-            *old = *new;

-            new->szEntries = new->nEntries = 0;

-            new->entries = NULL;

-            new->preserve = NULL;

-            new->lvlNames = NULL;

-            old->defs.next = &next->defs;

-            return True;

-        }

-        report = (old->defs.fileID == new->defs.fileID) && (warningLevel > 0);

-        if (report)

-        {

-            WARN1("Multiple definitions of the %s key type\n",

-                  XkbAtomGetString(NULL, new->name));

-            ACTION("Later definition ignored\n");

-        }

-        FreeKeyTypeInfo(new);

-        return True;

-    }

-    old = NextKeyType(info);

-    if (old == NULL)

-        return False;

-    *old = *new;

-    old->defs.next = NULL;

-    new->nEntries = new->szEntries = 0;

-    new->entries = NULL;

-    new->szNames = 0;

-    new->lvlNames = NULL;

-    new->preserve = NULL;

-    return True;

-}

-

-/***====================================================================***/

-

-static void

-MergeIncludedKeyTypes(KeyTypesInfo * into,

-                      KeyTypesInfo * from, unsigned merge, XkbDescPtr xkb)

-{

-    KeyTypeInfo *type;

-

-    if (from->errorCount > 0)

-    {

-        into->errorCount += from->errorCount;

-        return;

-    }

-    if (into->name == NULL)

-    {

-        into->name = from->name;

-        from->name = NULL;

-    }

-    for (type = from->types; type; type = (KeyTypeInfo *) type->defs.next)

-    {

-        if (merge != MergeDefault)

-            type->defs.merge = merge;

-        if (!AddKeyType(xkb, into, type))

-            into->errorCount++;

-    }

-    into->stdPresent |= from->stdPresent;

-    return;

-}

-

-typedef void (*FileHandler) (XkbFile * /* file */ ,

-                             XkbDescPtr /* xkb */ ,

-                             unsigned /* merge */ ,

-                             KeyTypesInfo *     /* included */

-    );

-

-static Bool

-HandleIncludeKeyTypes(IncludeStmt * stmt,

-                      XkbDescPtr xkb, KeyTypesInfo * info, FileHandler hndlr)

-{

-    unsigned newMerge;

-    XkbFile *rtrn;

-    KeyTypesInfo included;

-    Bool haveSelf;

-

-    haveSelf = False;

-    if ((stmt->file == NULL) && (stmt->map == NULL))

-    {

-        haveSelf = True;

-        included = *info;

-        bzero(info, sizeof(KeyTypesInfo));

-    }

-    else if (ProcessIncludeFile(stmt, XkmTypesIndex, &rtrn, &newMerge))

-    {

-        InitKeyTypesInfo(&included, xkb, info);

-        included.fileID = included.dflt.defs.fileID = rtrn->id;

-        included.dflt.defs.merge = newMerge;

-

-        (*hndlr) (rtrn, xkb, newMerge, &included);

-        if (stmt->stmt != NULL)

-        {

-            if (included.name != NULL)

-                uFree(included.name);

-            included.name = stmt->stmt;

-            stmt->stmt = NULL;

-        }

-    }

-    else

-    {

-        info->errorCount += 10;

-        return False;

-    }

-    if ((stmt->next != NULL) && (included.errorCount < 1))

-    {

-        IncludeStmt *next;

-        unsigned op;

-        KeyTypesInfo next_incl;

-

-        for (next = stmt->next; next != NULL; next = next->next)

-        {

-            if ((next->file == NULL) && (next->map == NULL))

-            {

-                haveSelf = True;

-                MergeIncludedKeyTypes(&included, info, next->merge, xkb);

-                FreeKeyTypesInfo(info);

-            }

-            else if (ProcessIncludeFile(next, XkmTypesIndex, &rtrn, &op))

-            {

-                InitKeyTypesInfo(&next_incl, xkb, &included);

-                next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;

-                next_incl.dflt.defs.merge = op;

-                (*hndlr) (rtrn, xkb, op, &next_incl);

-                MergeIncludedKeyTypes(&included, &next_incl, op, xkb);

-                FreeKeyTypesInfo(&next_incl);

-            }

-            else

-            {

-                info->errorCount += 10;

-                return False;

-            }

-        }

-    }

-    if (haveSelf)

-        *info = included;

-    else

-    {

-        MergeIncludedKeyTypes(info, &included, newMerge, xkb);

-        FreeKeyTypesInfo(&included);

-    }

-    return (info->errorCount == 0);

-}

-

-/***====================================================================***/

-

-static XkbKTMapEntryPtr

-FindMatchingMapEntry(KeyTypeInfo * type, unsigned mask, unsigned vmask)

-{

-    register int i;

-    XkbKTMapEntryPtr entry;

-

-    for (i = 0, entry = type->entries; i < type->nEntries; i++, entry++)

-    {

-        if ((entry->mods.real_mods == mask) && (entry->mods.vmods == vmask))

-            return entry;

-    }

-    return NULL;

-}

-

-static void

-DeleteLevel1MapEntries(KeyTypeInfo * type)

-{

-    register int i, n;

-

-    for (i = 0; i < type->nEntries; i++)

-    {

-        if (type->entries[i].level == 0)

-        {

-            for (n = i; n < type->nEntries - 1; n++)

-            {

-                type->entries[n] = type->entries[n + 1];

-            }

-            type->nEntries--;

-        }

-    }

-    return;

-}

-

-/**

- * Return a pointer to the next free XkbKTMapEntry, reallocating space if

- * necessary.

- */

-static XkbKTMapEntryPtr

-NextMapEntry(KeyTypeInfo * type)

-{

-    if (type->entries == NULL)

-    {

-        type->entries = uTypedCalloc(2, XkbKTMapEntryRec);

-        if (type->entries == NULL)

-        {

-            ERROR1("Couldn't allocate map entries for %s\n", TypeTxt(type));

-            ACTION("Map entries lost\n");

-            return NULL;

-        }

-        type->szEntries = 2;

-        type->nEntries = 0;

-    }

-    else if (type->nEntries >= type->szEntries)

-    {

-        type->szEntries *= 2;

-        type->entries = uTypedRecalloc(type->entries,

-                                       type->nEntries, type->szEntries,

-                                       XkbKTMapEntryRec);

-        if (type->entries == NULL)

-        {

-            ERROR1("Couldn't reallocate map entries for %s\n", TypeTxt(type));

-            ACTION("Map entries lost\n");

-            return NULL;

-        }

-    }

-    return &type->entries[type->nEntries++];

-}

-

-Bool

-AddPreserve(XkbDescPtr xkb,

-            KeyTypeInfo * type, PreserveInfo * new, Bool clobber, Bool report)

-{

-    PreserveInfo *old;

-

-    old = type->preserve;

-    while (old != NULL)

-    {

-        if ((old->indexMods != new->indexMods) ||

-            (old->indexVMods != new->indexVMods))

-        {

-            old = (PreserveInfo *) old->defs.next;

-            continue;

-        }

-        if ((old->preMods == new->preMods)

-            && (old->preVMods == new->preVMods))

-        {

-            if (warningLevel > 9)

-            {

-                WARN2("Identical definitions for preserve[%s] in %s\n",

-                      PreserveIndexTxt(type, xkb, old), TypeTxt(type));

-                ACTION("Ignored\n");

-            }

-            return True;

-        }

-        if (report && (warningLevel > 0))

-        {

-            char *str;

-            WARN2("Multiple definitions for preserve[%s] in %s\n",

-                  PreserveIndexTxt(type, xkb, old), TypeTxt(type));

-

-            if (clobber)

-                str = PreserveTxt(type, xkb, new);

-            else

-                str = PreserveTxt(type, xkb, old);

-            ACTION1("Using %s, ", str);

-            if (clobber)

-                str = PreserveTxt(type, xkb, old);

-            else

-                str = PreserveTxt(type, xkb, new);

-            INFO1("ignoring %s\n", str);

-        }

-        if (clobber)

-        {

-            old->preMods = new->preMods;

-            old->preVMods = new->preVMods;

-        }

-        return True;

-    }

-    old = uTypedAlloc(PreserveInfo);

-    if (!old)

-    {

-        WSGO1("Couldn't allocate preserve in %s\n", TypeTxt(type));

-        ACTION1("Preserve[%s] lost\n", PreserveIndexTxt(type, xkb, old));

-        return False;

-    }

-    *old = *new;

-    old->matchingMapIndex = -1;

-    type->preserve =

-        (PreserveInfo *) AddCommonInfo(&type->preserve->defs, &old->defs);

-    return True;

-}

-

-/**

- * Add a new KTMapEntry to the given key type. If an entry with the same mods

- * already exists, the level is updated (if clobber is TRUE). Otherwise, a new

- * entry is created.

- *

- * @param clobber Overwrite existing entry.

- * @param report True if a warning is to be printed on.

- */

-Bool

-AddMapEntry(XkbDescPtr xkb,

-            KeyTypeInfo * type,

-            XkbKTMapEntryPtr new, Bool clobber, Bool report)

-{

-    XkbKTMapEntryPtr old;

-

-    if ((old =

-         FindMatchingMapEntry(type, new->mods.real_mods, new->mods.vmods)))

-    {

-        if (report && (old->level != new->level))

-        {

-            unsigned use, ignore;

-            if (clobber)

-            {

-                use = new->level + 1;

-                ignore = old->level + 1;

-            }

-            else

-            {

-                use = old->level + 1;

-                ignore = new->level + 1;

-            }

-            WARN2("Multiple map entries for %s in %s\n",

-                  MapEntryTxt(type, xkb, new), TypeTxt(type));

-            ACTION2("Using %d, ignoring %d\n", use, ignore);

-        }

-        else if (warningLevel > 9)

-        {

-            WARN3("Multiple occurences of map[%s]= %d in %s\n",

-                  MapEntryTxt(type, xkb, new), new->level + 1, TypeTxt(type));

-            ACTION("Ignored\n");

-            return True;

-        }

-        if (clobber)

-            old->level = new->level;

-        return True;

-    }

-    if ((old = NextMapEntry(type)) == NULL)

-        return False;           /* allocation failure, already reported */

-    if (new->level >= type->numLevels)

-        type->numLevels = new->level + 1;

-    if (new->mods.vmods == 0)

-        old->active = True;

-    else

-        old->active = False;

-    old->mods.mask = new->mods.real_mods;

-    old->mods.real_mods = new->mods.real_mods;

-    old->mods.vmods = new->mods.vmods;

-    old->level = new->level;

-    return True;

-}

-

-static LookupEntry lnames[] = {

-    {"level1", 1},

-    {"level2", 2},

-    {"level3", 3},

-    {"level4", 4},

-    {"level5", 5},

-    {"level6", 6},

-    {"level7", 7},

-    {"level8", 8},

-    {NULL, 0}

-};

-

-static Bool

-SetMapEntry(KeyTypeInfo * type,

-            XkbDescPtr xkb, ExprDef * arrayNdx, ExprDef * value)

-{

-    ExprResult rtrn;

-    XkbKTMapEntryRec entry;

-

-    if (arrayNdx == NULL)

-        return ReportTypeShouldBeArray(type, "map entry");

-    if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))

-        return ReportTypeBadType(type, "map entry", "modifier mask");

-    entry.mods.real_mods = rtrn.uval & 0xff;      /* modifiers < 512 */

-    entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */

-    if ((entry.mods.real_mods & (~type->mask)) ||

-        ((entry.mods.vmods & (~type->vmask)) != 0))

-    {

-        if (warningLevel > 0)

-        {

-            WARN1("Map entry for unused modifiers in %s\n", TypeTxt(type));

-            ACTION1("Using %s instead of ",

-                    XkbVModMaskText(type->dpy, xkb,

-                                    entry.mods.real_mods & type->mask,

-                                    entry.mods.vmods & type->vmask,

-                                    XkbMessage));

-            INFO1("%s\n", MapEntryTxt(type, xkb, &entry));

-        }

-        entry.mods.real_mods &= type->mask;

-        entry.mods.vmods &= type->vmask;

-    }

-    if (!ExprResolveInteger(value, &rtrn, SimpleLookup, (XPointer) lnames))

-    {

-        ERROR("Level specifications in a key type must be integer\n");

-        ACTION("Ignoring malformed level specification\n");

-        return False;

-    }

-    if ((rtrn.ival < 1) || (rtrn.ival > XkbMaxShiftLevel + 1))

-    {

-        ERROR3("Shift level %d out of range (1..%d) in key type %s\n",

-               XkbMaxShiftLevel + 1, rtrn.ival, TypeTxt(type));

-        ACTION1("Ignoring illegal definition of map[%s]\n",

-                MapEntryTxt(type, xkb, &entry));

-        return False;

-    }

-    entry.level = rtrn.ival - 1;

-    return AddMapEntry(xkb, type, &entry, True, True);

-}

-

-static Bool

-SetPreserve(KeyTypeInfo * type,

-            XkbDescPtr xkb, ExprDef * arrayNdx, ExprDef * value)

-{

-    ExprResult rtrn;

-    PreserveInfo new;

-

-    if (arrayNdx == NULL)

-        return ReportTypeShouldBeArray(type, "preserve entry");

-    if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))

-        return ReportTypeBadType(type, "preserve entry", "modifier mask");

-    new.defs = type->defs;

-    new.defs.next = NULL;

-    new.indexMods = rtrn.uval & 0xff;

-    new.indexVMods = (rtrn.uval >> 8) & 0xffff;

-    if ((new.indexMods & (~type->mask)) || (new.indexVMods & (~type->vmask)))

-    {

-        if (warningLevel > 0)

-        {

-            WARN1("Preserve for modifiers not used by the %s type\n",

-                  TypeTxt(type));

-            ACTION1("Index %s converted to ",

-                    PreserveIndexTxt(type, xkb, &new));

-        }

-        new.indexMods &= type->mask;

-        new.indexVMods &= type->vmask;

-        if (warningLevel > 0)

-            INFO1("%s\n", PreserveIndexTxt(type, xkb, &new));

-    }

-    if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (XPointer) xkb))

-    {

-        ERROR("Preserve value in a key type is not a modifier mask\n");

-        ACTION2("Ignoring preserve[%s] in type %s\n",

-                PreserveIndexTxt(type, xkb, &new), TypeTxt(type));

-        return False;

-    }

-    new.preMods = rtrn.uval & 0xff;

-    new.preVMods = (rtrn.uval >> 16) & 0xffff;

-    if ((new.preMods & (~new.indexMods))

-        || (new.preVMods && (~new.indexVMods)))

-    {

-        if (warningLevel > 0)

-        {

-            WARN2("Illegal value for preserve[%s] in type %s\n",

-                  PreserveTxt(type, xkb, &new), TypeTxt(type));

-            ACTION1("Converted %s to ", PreserveIndexTxt(type, xkb, &new));

-        }

-        new.preMods &= new.indexMods;

-        new.preVMods &= new.indexVMods;

-        if (warningLevel > 0)

-        {

-            INFO1("%s\n", PreserveIndexTxt(type, xkb, &new));

-        }

-    }

-    return AddPreserve(xkb, type, &new, True, True);

-}

-

-/***====================================================================***/

-

-Bool

-AddLevelName(KeyTypeInfo * type,

-             unsigned level, Atom name, Bool clobber, Bool report)

-{

-    if ((type->lvlNames == NULL) || (type->szNames <= level))

-    {

-        type->lvlNames =

-            uTypedRecalloc(type->lvlNames, type->szNames, level + 1, Atom);

-        if (type->lvlNames == NULL)

-        {

-            ERROR1("Couldn't allocate level names for type %s\n",

-                   TypeTxt(type));

-            ACTION("Level names lost\n");

-            type->szNames = 0;

-            return False;

-        }

-        type->szNames = level + 1;

-    }

-    else if (type->lvlNames[level] == name)

-    {

-        if (warningLevel > 9)

-        {

-            WARN2("Duplicate names for level %d of key type %s\n",

-                  level + 1, TypeTxt(type));

-            ACTION("Ignored\n");

-        }

-        return True;

-    }

-    else if (type->lvlNames[level] != None)

-    {

-        if (warningLevel > 0)

-        {

-            char *old, *new;

-            old = XkbAtomText(type->dpy, type->lvlNames[level], XkbMessage);

-            new = XkbAtomText(type->dpy, name, XkbMessage);

-            WARN2("Multiple names for level %d of key type %s\n",

-                  level + 1, TypeTxt(type));

-            if (clobber)

-                ACTION2("Using %s, ignoring %s\n", new, old);

-            else

-                ACTION2("Using %s, ignoring %s\n", old, new);

-        }

-        if (!clobber)

-            return True;

-    }

-    if (level >= type->numLevels)

-        type->numLevels = level + 1;

-    type->lvlNames[level] = name;

-    return True;

-}

-

-static Bool

-SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value)

-{

-    ExprResult rtrn;

-    unsigned level;

-

-    if (arrayNdx == NULL)

-        return ReportTypeShouldBeArray(type, "level name");

-    if (!ExprResolveInteger(arrayNdx, &rtrn, SimpleLookup, (XPointer) lnames))

-        return ReportTypeBadType(type, "level name", "integer");

-    if ((rtrn.ival < 1) || (rtrn.ival > XkbMaxShiftLevel + 1))

-    {

-        ERROR3("Level name %d out of range (1..%d) in key type %s\n",

-               rtrn.ival,

-               XkbMaxShiftLevel + 1,

-               XkbAtomText(type->dpy, type->name, XkbMessage));

-        ACTION("Ignoring illegal level name definition\n");

-        return False;

-    }

-    level = rtrn.ival - 1;

-    if (!ExprResolveString(value, &rtrn, NULL, NULL))

-    {

-        ERROR2("Non-string name for level %d in key type %s\n", level + 1,

-               XkbAtomText(type->dpy, type->name, XkbMessage));

-        ACTION("Ignoring illegal level name definition\n");

-        return False;

-    }

-    return

-        AddLevelName(type, level, XkbInternAtom(NULL, rtrn.str, False), True,

-                     True);

-}

-

-/***====================================================================***/

-

-/**

- * Parses the fields in a type "..." { } description.

- *

- * @param field The field to parse (e.g. modifiers, map, level_name)

- */

-static Bool

-SetKeyTypeField(KeyTypeInfo * type,

-                XkbDescPtr xkb,

-                char *field,

-                ExprDef * arrayNdx, ExprDef * value, KeyTypesInfo * info)

-{

-    ExprResult tmp;

-

-    if (uStrCaseCmp(field, "modifiers") == 0)

-    {

-        unsigned mods, vmods;

-        if (arrayNdx != NULL)

-        {

-            WARN("The modifiers field of a key type is not an array\n");

-            ACTION("Illegal array subscript ignored\n");

-        }

-        /* get modifier mask for current type */

-        if (!ExprResolveModMask(value, &tmp, LookupVModMask, (XPointer) xkb))

-        {

-            ERROR("Key type mask field must be a modifier mask\n");

-            ACTION("Key type definition ignored\n");

-            return False;

-        }

-        mods = tmp.uval & 0xff; /* core mods */

-        vmods = (tmp.uval >> 8) & 0xffff; /* xkb virtual mods */

-        if (type->defs.defined & _KT_Mask)

-        {

-            WARN1("Multiple modifier mask definitions for key type %s\n",

-                  XkbAtomText(type->dpy, type->name, XkbMessage));

-            ACTION1("Using %s, ", TypeMaskTxt(type, xkb));

-            INFO1("ignoring %s\n", XkbVModMaskText(type->dpy, xkb, mods,

-                                                   vmods, XkbMessage));

-            return False;

-        }

-        type->mask = mods;

-        type->vmask = vmods;

-        type->defs.defined |= _KT_Mask;

-        return True;

-    }

-    else if (uStrCaseCmp(field, "map") == 0)

-    {

-        type->defs.defined |= _KT_Map;

-        return SetMapEntry(type, xkb, arrayNdx, value);

-    }

-    else if (uStrCaseCmp(field, "preserve") == 0)

-    {

-        type->defs.defined |= _KT_Preserve;

-        return SetPreserve(type, xkb, arrayNdx, value);

-    }

-    else if ((uStrCaseCmp(field, "levelname") == 0) ||

-             (uStrCaseCmp(field, "level_name") == 0))

-    {

-        type->defs.defined |= _KT_LevelNames;

-        return SetLevelName(type, arrayNdx, value);

-    }

-    ERROR2("Unknown field %s in key type %s\n", field, TypeTxt(type));

-    ACTION("Definition ignored\n");

-    return False;

-}

-

-static Bool

-HandleKeyTypeVar(VarDef * stmt, XkbDescPtr xkb, KeyTypesInfo * info)

-{

-    ExprResult elem, field;

-    ExprDef *arrayNdx;

-

-    if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx))

-        return False;           /* internal error, already reported */

-    if (elem.str && (uStrCaseCmp(elem.str, "type") == 0))

-        return SetKeyTypeField(&info->dflt, xkb, field.str, arrayNdx,

-                               stmt->value, info);

-    if (elem.str != NULL)

-    {

-        ERROR1("Default for unknown element %s\n", uStringText(elem.str));

-        ACTION1("Value for field %s ignored\n", uStringText(field.str));

-    }

-    else if (field.str != NULL)

-    {

-        ERROR1("Default defined for unknown field %s\n",

-               uStringText(field.str));

-        ACTION("Ignored\n");

-    }

-    return False;

-}

-

-static int

-HandleKeyTypeBody(VarDef * def,

-                  XkbDescPtr xkb, KeyTypeInfo * type, KeyTypesInfo * info)

-{

-    int ok = 1;

-    ExprResult tmp, field;

-    ExprDef *arrayNdx;

-

-    for (; def != NULL; def = (VarDef *) def->common.next)

-    {

-        if ((def->name) && (def->name->type == ExprFieldRef))

-        {

-            ok = HandleKeyTypeVar(def, xkb, info);

-            continue;

-        }

-        ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);

-        if (ok)

-            ok = SetKeyTypeField(type, xkb, field.str, arrayNdx, def->value,

-                                 info);

-    }

-    return ok;

-}

-

-/**

- * Process a type "XYZ" { } specification in the xkb_types section.

- *

- */

-static int

-HandleKeyTypeDef(KeyTypeDef * def,

-                 XkbDescPtr xkb, unsigned merge, KeyTypesInfo * info)

-{

-    register int i;

-    KeyTypeInfo type;

-

-    if (def->merge != MergeDefault)

-        merge = def->merge;

-

-    type.defs.defined = 0;

-    type.defs.fileID = info->fileID;

-    type.defs.merge = merge;

-    type.defs.next = NULL;

-    type.dpy = info->dpy;

-    type.name = def->name;

-    type.mask = info->dflt.mask;

-    type.vmask = info->dflt.vmask;

-    type.groupInfo = info->dflt.groupInfo;

-    type.numLevels = 1;

-    type.nEntries = type.szEntries = 0;

-    type.entries = NULL;

-    type.szNames = 0;

-    type.lvlNames = NULL;

-    type.preserve = NULL;

-

-    /* Parse the actual content. */

-    if (!HandleKeyTypeBody(def->body, xkb, &type, info))

-    {

-        info->errorCount++;

-        return False;

-    }

-

-    /* now copy any appropriate map, preserve or level names from the */

-    /* default type */

-    for (i = 0; i < info->dflt.nEntries; i++)

-    {

-        XkbKTMapEntryPtr dflt;

-        dflt = &info->dflt.entries[i];

-        if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) &&

-            ((dflt->mods.vmods & type.vmask) == dflt->mods.vmods))

-        {

-            AddMapEntry(xkb, &type, dflt, False, False);

-        }

-    }

-    if (info->dflt.preserve)

-    {

-        PreserveInfo *dflt = info->dflt.preserve;

-        while (dflt)

-        {

-            if (((dflt->indexMods & type.mask) == dflt->indexMods) &&

-                ((dflt->indexVMods & type.vmask) == dflt->indexVMods))

-            {

-                AddPreserve(xkb, &type, dflt, False, False);

-            }

-            dflt = (PreserveInfo *) dflt->defs.next;

-        }

-    }

-    for (i = 0; i < info->dflt.szNames; i++)

-    {

-        if ((i < type.numLevels) && (info->dflt.lvlNames[i] != None))

-        {

-            AddLevelName(&type, i, info->dflt.lvlNames[i], False, False);

-        }

-    }

-    /* Now add the new keytype to the info struct */

-    if (!AddKeyType(xkb, info, &type))

-    {

-        info->errorCount++;

-        return False;

-    }

-    return True;

-}

-

-/**

- * Process an xkb_types section.

- *

- * @param file The parsed xkb_types section.

- * @param merge Merge Strategy (e.g. MergeOverride)

- * @param info Pointer to memory where the outcome will be stored.

- */

-static void

-HandleKeyTypesFile(XkbFile * file,

-                   XkbDescPtr xkb, unsigned merge, KeyTypesInfo * info)

-{

-    ParseCommon *stmt;

-

-    info->name = uStringDup(file->name);

-    stmt = file->defs;

-    while (stmt)

-    {

-        switch (stmt->stmtType)

-        {

-        case StmtInclude:

-            if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, xkb, info,

-                                       HandleKeyTypesFile))

-                info->errorCount++;

-            break;

-        case StmtKeyTypeDef: /* e.g. type "ONE_LEVEL" */

-            if (!HandleKeyTypeDef((KeyTypeDef *) stmt, xkb, merge, info))

-                info->errorCount++;

-            break;

-        case StmtVarDef:

-            if (!HandleKeyTypeVar((VarDef *) stmt, xkb, info))

-                info->errorCount++;

-            break;

-        case StmtVModDef: /* virtual_modifiers NumLock, ... */

-            if (!HandleVModDef((VModDef *) stmt, merge, &info->vmods))

-                info->errorCount++;

-            break;

-        case StmtKeyAliasDef:

-            ERROR("Key type files may not include other declarations\n");

-            ACTION("Ignoring definition of key alias\n");

-            info->errorCount++;

-            break;

-        case StmtKeycodeDef:

-            ERROR("Key type files may not include other declarations\n");

-            ACTION("Ignoring definition of key name\n");

-            info->errorCount++;

-            break;

-        case StmtInterpDef:

-            ERROR("Key type files may not include other declarations\n");

-            ACTION("Ignoring definition of symbol interpretation\n");

-            info->errorCount++;

-            break;

-        default:

-            WSGO1("Unexpected statement type %d in HandleKeyTypesFile\n",

-                  stmt->stmtType);

-            break;

-        }

-        stmt = stmt->next;

-        if (info->errorCount > 10)

-        {

-#ifdef NOISY

-            ERROR("Too many errors\n");

-#endif

-            ACTION1("Abandoning keytypes file \"%s\"\n", file->topName);

-            break;

-        }

-    }

-    return;

-}

-

-static Bool

-CopyDefToKeyType(XkbDescPtr xkb, XkbKeyTypePtr type, KeyTypeInfo * def)

-{

-    register int i;

-    PreserveInfo *pre;

-

-    for (pre = def->preserve; pre != NULL;

-         pre = (PreserveInfo *) pre->defs.next)

-    {

-        XkbKTMapEntryPtr match;

-        XkbKTMapEntryRec tmp;

-        tmp.mods.real_mods = pre->indexMods;

-        tmp.mods.vmods = pre->indexVMods;

-        tmp.level = 0;

-        AddMapEntry(xkb, def, &tmp, False, False);

-        match = FindMatchingMapEntry(def, pre->indexMods, pre->indexVMods);

-        if (!match)

-        {

-            WSGO("Couldn't find matching entry for preserve\n");

-            ACTION("Aborting\n");

-            return False;

-        }

-        pre->matchingMapIndex = match - def->entries;

-    }

-    type->mods.real_mods = def->mask;

-    type->mods.vmods = def->vmask;

-    type->num_levels = def->numLevels;

-    type->map_count = def->nEntries;

-    type->map = def->entries;

-    if (def->preserve)

-    {

-        type->preserve = uTypedCalloc(type->map_count, XkbModsRec);

-        if (!type->preserve)

-        {

-            WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");

-            ACTION1("Preserve setting for type %s lost\n",

-                    XkbAtomText(def->dpy, def->name, XkbMessage));

-        }

-        else

-        {

-            pre = def->preserve;

-            for (; pre != NULL; pre = (PreserveInfo *) pre->defs.next)

-            {

-                int ndx = pre->matchingMapIndex;

-                type->preserve[ndx].mask = pre->preMods;

-                type->preserve[ndx].real_mods = pre->preMods;

-                type->preserve[ndx].vmods = pre->preVMods;

-            }

-        }

-    }

-    else

-        type->preserve = NULL;

-    type->name = (Atom) def->name;

-    if (def->szNames > 0)

-    {

-        type->level_names = uTypedCalloc(def->numLevels, Atom);

-

-        /* assert def->szNames<=def->numLevels */

-        for (i = 0; i < def->szNames; i++)

-        {

-            type->level_names[i] = (Atom) def->lvlNames[i];

-        }

-    }

-    else

-    {

-        type->level_names = NULL;

-    }

-

-    def->nEntries = def->szEntries = 0;

-    def->entries = NULL;

-    return XkbComputeEffectiveMap(xkb, type, NULL);

-}

-

-Bool

-CompileKeyTypes(XkbFile * file, XkbFileInfo * result, unsigned merge)

-{

-    KeyTypesInfo info;

-    XkbDescPtr xkb;

-

-    xkb = result->xkb;

-    InitKeyTypesInfo(&info, xkb, NULL);

-    info.fileID = file->id;

-    HandleKeyTypesFile(file, xkb, merge, &info);

-

-    if (info.errorCount == 0)

-    {

-        register int i;

-        register KeyTypeInfo *def;

-        register XkbKeyTypePtr type, next;

-

-        if (info.name != NULL)

-        {

-            if (XkbAllocNames(xkb, XkbTypesNameMask, 0, 0) == Success)

-                xkb->names->types = XkbInternAtom(xkb->dpy, info.name, False);

-            else

-            {

-                WSGO("Couldn't allocate space for types name\n");

-                ACTION2("Name \"%s\" (from %s) NOT assigned\n",

-                        scanFile, info.name);

-            }

-        }

-        i = info.nTypes;

-        if ((info.stdPresent & XkbOneLevelMask) == 0)

-            i++;

-        if ((info.stdPresent & XkbTwoLevelMask) == 0)

-            i++;

-        if ((info.stdPresent & XkbKeypadMask) == 0)

-            i++;

-        if ((info.stdPresent & XkbAlphabeticMask) == 0)

-            i++;

-        if (XkbAllocClientMap(xkb, XkbKeyTypesMask, i) != Success)

-        {

-            WSGO("Couldn't allocate client map\n");

-            ACTION("Exiting\n");

-            return False;

-        }

-        xkb->map->num_types = i;

-        if (XkbAllRequiredTypes & (~info.stdPresent))

-        {

-            unsigned missing, keypadVMod;

-

-            missing = XkbAllRequiredTypes & (~info.stdPresent);

-            keypadVMod = FindKeypadVMod(xkb);

-            if (XkbInitCanonicalKeyTypes(xkb, missing, keypadVMod) != Success)

-            {

-                WSGO("Couldn't initialize canonical key types\n");

-                ACTION("Exiting\n");

-                return False;

-            }

-            if (missing & XkbOneLevelMask)

-                xkb->map->types[XkbOneLevelIndex].name = tok_ONE_LEVEL;

-            if (missing & XkbTwoLevelMask)

-                xkb->map->types[XkbTwoLevelIndex].name = tok_TWO_LEVEL;

-            if (missing & XkbAlphabeticMask)

-                xkb->map->types[XkbAlphabeticIndex].name = tok_ALPHABETIC;

-            if (missing & XkbKeypadMask)

-                xkb->map->types[XkbKeypadIndex].name = tok_KEYPAD;

-        }

-        next = &xkb->map->types[XkbLastRequiredType + 1];

-        for (i = 0, def = info.types; i < info.nTypes; i++)

-        {

-            if (def->name == tok_ONE_LEVEL)

-                type = &xkb->map->types[XkbOneLevelIndex];

-            else if (def->name == tok_TWO_LEVEL)

-                type = &xkb->map->types[XkbTwoLevelIndex];

-            else if (def->name == tok_ALPHABETIC)

-                type = &xkb->map->types[XkbAlphabeticIndex];

-            else if (def->name == tok_KEYPAD)

-                type = &xkb->map->types[XkbKeypadIndex];

-            else

-                type = next++;

-            DeleteLevel1MapEntries(def);

-            if (!CopyDefToKeyType(xkb, type, def))

-                return False;

-            def = (KeyTypeInfo *) def->defs.next;

-        }

-        return True;

-    }

-    return False;

-}

+/************************************************************
+ 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "action.h"
+#include "misc.h"
+
+typedef struct _PreserveInfo
+{
+    CommonInfo defs;
+    short matchingMapIndex;
+    unsigned char indexMods;
+    unsigned char preMods;
+    unsigned short indexVMods;
+    unsigned short preVMods;
+} PreserveInfo;
+
+#define	_KT_Name	(1<<0)
+#define	_KT_Mask	(1<<1)
+#define	_KT_Map		(1<<2)
+#define	_KT_Preserve	(1<<3)
+#define	_KT_LevelNames	(1<<4)
+
+typedef struct _KeyTypeInfo
+{
+    CommonInfo defs;
+    Display *dpy;
+    Atom name;
+    int fileID;
+    unsigned mask;
+    unsigned vmask;
+    Bool groupInfo;
+    int numLevels;
+    int nEntries;
+    int szEntries;
+    XkbKTMapEntryPtr entries;
+    PreserveInfo *preserve;
+    int szNames;
+    Atom *lvlNames;
+} KeyTypeInfo;
+
+typedef struct _KeyTypesInfo
+{
+    Display *dpy;
+    char *name;
+    int errorCount;
+    int fileID;
+    unsigned stdPresent;
+    int nTypes;
+    KeyTypeInfo *types;
+    KeyTypeInfo dflt;
+    VModInfo vmods;
+} KeyTypesInfo;
+
+Atom tok_ONE_LEVEL;
+Atom tok_TWO_LEVEL;
+Atom tok_ALPHABETIC;
+Atom tok_KEYPAD;
+
+/***====================================================================***/
+
+#define	ReportTypeShouldBeArray(t,f) \
+	ReportShouldBeArray("key type",(f),TypeTxt(t))
+#define	ReportTypeBadType(t,f,w) \
+	ReportBadType("key type",(f),TypeTxt(t),(w))
+
+/***====================================================================***/
+
+extern Bool AddMapEntry(XkbDescPtr /* xkb */ ,
+                        KeyTypeInfo * /* type */ ,
+                        XkbKTMapEntryPtr /* new */ ,
+                        Bool /* clobber */ ,
+                        Bool    /* report */
+    );
+
+extern Bool AddPreserve(XkbDescPtr /* xkb */ ,
+                        KeyTypeInfo * /* type */ ,
+                        PreserveInfo * /* new */ ,
+                        Bool /* clobber */ ,
+                        Bool    /* report */
+    );
+
+extern Bool AddLevelName(KeyTypeInfo * /* type */ ,
+                         unsigned /* level */ ,
+                         Atom /* name */ ,
+                         Bool /* clobber */ ,
+                         Bool   /* report */
+    );
+
+#define	MapEntryTxt(t,x,e)	\
+    XkbVModMaskText((t)->dpy,(x),(e)->mods.real_mods,(e)->mods.vmods,XkbMessage)
+#define	PreserveIndexTxt(t,x,p)	\
+	XkbVModMaskText((t)->dpy,(x),(p)->indexMods,(p)->indexVMods,XkbMessage)
+#define	PreserveTxt(t,x,p)	\
+	XkbVModMaskText((t)->dpy,(x),(p)->preMods,(p)->preVMods,XkbMessage)
+#define	TypeTxt(t)	XkbAtomText((t)->dpy,(t)->name,XkbMessage)
+#define	TypeMaskTxt(t,x)	\
+	XkbVModMaskText((t)->dpy,(x),(t)->mask,(t)->vmask,XkbMessage)
+
+/***====================================================================***/
+
+static void
+InitKeyTypesInfo(KeyTypesInfo * info, XkbDescPtr xkb, KeyTypesInfo * from)
+{
+    tok_ONE_LEVEL = XkbInternAtom(NULL, "ONE_LEVEL", False);
+    tok_TWO_LEVEL = XkbInternAtom(NULL, "TWO_LEVEL", False);
+    tok_ALPHABETIC = XkbInternAtom(NULL, "ALPHABETIC", False);
+    tok_KEYPAD = XkbInternAtom(NULL, "KEYPAD", False);
+    info->dpy = NULL;
+    info->name = uStringDup("default");
+    info->errorCount = 0;
+    info->stdPresent = 0;
+    info->nTypes = 0;
+    info->types = NULL;
+    info->dflt.defs.defined = 0;
+    info->dflt.defs.fileID = 0;
+    info->dflt.defs.merge = MergeOverride;
+    info->dflt.defs.next = NULL;
+    info->dflt.name = None;
+    info->dflt.mask = 0;
+    info->dflt.vmask = 0;
+    info->dflt.groupInfo = False;
+    info->dflt.numLevels = 1;
+    info->dflt.nEntries = info->dflt.szEntries = 0;
+    info->dflt.entries = NULL;
+    info->dflt.szNames = 0;
+    info->dflt.lvlNames = NULL;
+    info->dflt.preserve = NULL;
+    InitVModInfo(&info->vmods, xkb);
+    if (from != NULL)
+    {
+        info->dpy = from->dpy;
+        info->dflt = from->dflt;
+        if (from->dflt.entries)
+        {
+            info->dflt.entries = uTypedCalloc(from->dflt.szEntries,
+                                              XkbKTMapEntryRec);
+            if (info->dflt.entries)
+            {
+                unsigned sz = from->dflt.nEntries * sizeof(XkbKTMapEntryRec);
+                memcpy(info->dflt.entries, from->dflt.entries, sz);
+            }
+        }
+        if (from->dflt.lvlNames)
+        {
+            info->dflt.lvlNames = uTypedCalloc(from->dflt.szNames, Atom);
+            if (info->dflt.lvlNames)
+            {
+                register unsigned sz = from->dflt.szNames * sizeof(Atom);
+                memcpy(info->dflt.lvlNames, from->dflt.lvlNames, sz);
+            }
+        }
+        if (from->dflt.preserve)
+        {
+            PreserveInfo *old, *new, *last;
+            last = NULL;
+            old = from->dflt.preserve;
+            for (; old; old = (PreserveInfo *) old->defs.next)
+            {
+                new = uTypedAlloc(PreserveInfo);
+                if (!new)
+                    return;
+                *new = *old;
+                new->defs.next = NULL;
+                if (last)
+                    last->defs.next = (CommonInfo *) new;
+                else
+                    info->dflt.preserve = new;
+                last = new;
+            }
+        }
+    }
+    return;
+}
+
+static void
+FreeKeyTypeInfo(KeyTypeInfo * type)
+{
+    if (type->entries != NULL)
+    {
+        uFree(type->entries);
+        type->entries = NULL;
+    }
+    if (type->lvlNames != NULL)
+    {
+        uFree(type->lvlNames);
+        type->lvlNames = NULL;
+    }
+    if (type->preserve != NULL)
+    {
+        ClearCommonInfo(&type->preserve->defs);
+        type->preserve = NULL;
+    }
+    return;
+}
+
+static void
+FreeKeyTypesInfo(KeyTypesInfo * info)
+{
+    info->dpy = NULL;
+    if (info->name)
+        uFree(info->name);
+    info->name = NULL;
+    if (info->types)
+    {
+        register KeyTypeInfo *type;
+        for (type = info->types; type; type = (KeyTypeInfo *) type->defs.next)
+        {
+            FreeKeyTypeInfo(type);
+        }
+        info->types = (KeyTypeInfo *) ClearCommonInfo(&info->types->defs);
+    }
+    FreeKeyTypeInfo(&info->dflt);
+    return;
+}
+
+static KeyTypeInfo *
+NextKeyType(KeyTypesInfo * info)
+{
+    KeyTypeInfo *type;
+
+    type = uTypedAlloc(KeyTypeInfo);
+    if (type != NULL)
+    {
+        bzero(type, sizeof(KeyTypeInfo));
+        type->defs.fileID = info->fileID;
+        type->dpy = info->dpy;
+        info->types = (KeyTypeInfo *) AddCommonInfo(&info->types->defs,
+                                                    (CommonInfo *) type);
+        info->nTypes++;
+    }
+    return type;
+}
+
+static KeyTypeInfo *
+FindMatchingKeyType(KeyTypesInfo * info, KeyTypeInfo * new)
+{
+    KeyTypeInfo *old;
+
+    for (old = info->types; old; old = (KeyTypeInfo *) old->defs.next)
+    {
+        if (old->name == new->name)
+            return old;
+    }
+    return NULL;
+}
+
+static Bool
+ReportTypeBadWidth(const char *type, int has, int needs)
+{
+    ERROR3("Key type \"%s\" has %d levels, must have %d\n", type, has, needs);
+    ACTION("Illegal type definition ignored\n");
+    return False;
+}
+
+static Bool
+AddKeyType(XkbDescPtr xkb, KeyTypesInfo * info, KeyTypeInfo * new)
+{
+    KeyTypeInfo *old;
+
+    if (new->name == tok_ONE_LEVEL)
+    {
+        if (new->numLevels > 1)
+            return ReportTypeBadWidth("ONE_LEVEL", new->numLevels, 1);
+        info->stdPresent |= XkbOneLevelMask;
+    }
+    else if (new->name == tok_TWO_LEVEL)
+    {
+        if (new->numLevels > 2)
+            return ReportTypeBadWidth("TWO_LEVEL", new->numLevels, 2);
+        else if (new->numLevels < 2)
+            new->numLevels = 2;
+        info->stdPresent |= XkbTwoLevelMask;
+    }
+    else if (new->name == tok_ALPHABETIC)
+    {
+        if (new->numLevels > 2)
+            return ReportTypeBadWidth("ALPHABETIC", new->numLevels, 2);
+        else if (new->numLevels < 2)
+            new->numLevels = 2;
+        info->stdPresent |= XkbAlphabeticMask;
+    }
+    else if (new->name == tok_KEYPAD)
+    {
+        if (new->numLevels > 2)
+            return ReportTypeBadWidth("KEYPAD", new->numLevels, 2);
+        else if (new->numLevels < 2)
+            new->numLevels = 2;
+        info->stdPresent |= XkbKeypadMask;
+    }
+
+    old = FindMatchingKeyType(info, new);
+    if (old != NULL)
+    {
+        Bool report;
+        if ((new->defs.merge == MergeReplace)
+            || (new->defs.merge == MergeOverride))
+        {
+            KeyTypeInfo *next = (KeyTypeInfo *) old->defs.next;
+            if (((old->defs.fileID == new->defs.fileID)
+                 && (warningLevel > 0)) || (warningLevel > 9))
+            {
+                WARN1("Multiple definitions of the %s key type\n",
+                      XkbAtomGetString(NULL, new->name));
+                ACTION("Earlier definition ignored\n");
+            }
+            FreeKeyTypeInfo(old);
+            *old = *new;
+            new->szEntries = new->nEntries = 0;
+            new->entries = NULL;
+            new->preserve = NULL;
+            new->lvlNames = NULL;
+            old->defs.next = &next->defs;
+            return True;
+        }
+        report = (old->defs.fileID == new->defs.fileID) && (warningLevel > 0);
+        if (report)
+        {
+            WARN1("Multiple definitions of the %s key type\n",
+                  XkbAtomGetString(NULL, new->name));
+            ACTION("Later definition ignored\n");
+        }
+        FreeKeyTypeInfo(new);
+        return True;
+    }
+    old = NextKeyType(info);
+    if (old == NULL)
+        return False;
+    *old = *new;
+    old->defs.next = NULL;
+    new->nEntries = new->szEntries = 0;
+    new->entries = NULL;
+    new->szNames = 0;
+    new->lvlNames = NULL;
+    new->preserve = NULL;
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+MergeIncludedKeyTypes(KeyTypesInfo * into,
+                      KeyTypesInfo * from, unsigned merge, XkbDescPtr xkb)
+{
+    KeyTypeInfo *type;
+
+    if (from->errorCount > 0)
+    {
+        into->errorCount += from->errorCount;
+        return;
+    }
+    if (into->name == NULL)
+    {
+        into->name = from->name;
+        from->name = NULL;
+    }
+    for (type = from->types; type; type = (KeyTypeInfo *) type->defs.next)
+    {
+        if (merge != MergeDefault)
+            type->defs.merge = merge;
+        if (!AddKeyType(xkb, into, type))
+            into->errorCount++;
+    }
+    into->stdPresent |= from->stdPresent;
+    return;
+}
+
+typedef void (*FileHandler) (XkbFile * /* file */ ,
+                             XkbDescPtr /* xkb */ ,
+                             unsigned /* merge */ ,
+                             KeyTypesInfo *     /* included */
+    );
+
+static Bool
+HandleIncludeKeyTypes(IncludeStmt * stmt,
+                      XkbDescPtr xkb, KeyTypesInfo * info, FileHandler hndlr)
+{
+    unsigned newMerge;
+    XkbFile *rtrn;
+    KeyTypesInfo included;
+    Bool haveSelf;
+
+    haveSelf = False;
+    if ((stmt->file == NULL) && (stmt->map == NULL))
+    {
+        haveSelf = True;
+        included = *info;
+        bzero(info, sizeof(KeyTypesInfo));
+    }
+    else if (ProcessIncludeFile(stmt, XkmTypesIndex, &rtrn, &newMerge))
+    {
+        InitKeyTypesInfo(&included, xkb, info);
+        included.fileID = included.dflt.defs.fileID = rtrn->id;
+        included.dflt.defs.merge = newMerge;
+
+        (*hndlr) (rtrn, xkb, newMerge, &included);
+        if (stmt->stmt != NULL)
+        {
+            if (included.name != NULL)
+                uFree(included.name);
+            included.name = stmt->stmt;
+            stmt->stmt = NULL;
+        }
+    }
+    else
+    {
+        info->errorCount += 10;
+        return False;
+    }
+    if ((stmt->next != NULL) && (included.errorCount < 1))
+    {
+        IncludeStmt *next;
+        unsigned op;
+        KeyTypesInfo next_incl;
+
+        for (next = stmt->next; next != NULL; next = next->next)
+        {
+            if ((next->file == NULL) && (next->map == NULL))
+            {
+                haveSelf = True;
+                MergeIncludedKeyTypes(&included, info, next->merge, xkb);
+                FreeKeyTypesInfo(info);
+            }
+            else if (ProcessIncludeFile(next, XkmTypesIndex, &rtrn, &op))
+            {
+                InitKeyTypesInfo(&next_incl, xkb, &included);
+                next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
+                next_incl.dflt.defs.merge = op;
+                (*hndlr) (rtrn, xkb, op, &next_incl);
+                MergeIncludedKeyTypes(&included, &next_incl, op, xkb);
+                FreeKeyTypesInfo(&next_incl);
+            }
+            else
+            {
+                info->errorCount += 10;
+                return False;
+            }
+        }
+    }
+    if (haveSelf)
+        *info = included;
+    else
+    {
+        MergeIncludedKeyTypes(info, &included, newMerge, xkb);
+        FreeKeyTypesInfo(&included);
+    }
+    return (info->errorCount == 0);
+}
+
+/***====================================================================***/
+
+static XkbKTMapEntryPtr
+FindMatchingMapEntry(KeyTypeInfo * type, unsigned mask, unsigned vmask)
+{
+    register int i;
+    XkbKTMapEntryPtr entry;
+
+    for (i = 0, entry = type->entries; i < type->nEntries; i++, entry++)
+    {
+        if ((entry->mods.real_mods == mask) && (entry->mods.vmods == vmask))
+            return entry;
+    }
+    return NULL;
+}
+
+static void
+DeleteLevel1MapEntries(KeyTypeInfo * type)
+{
+    register int i, n;
+
+    for (i = 0; i < type->nEntries; i++)
+    {
+        if (type->entries[i].level == 0)
+        {
+            for (n = i; n < type->nEntries - 1; n++)
+            {
+                type->entries[n] = type->entries[n + 1];
+            }
+            type->nEntries--;
+        }
+    }
+    return;
+}
+
+/**
+ * Return a pointer to the next free XkbKTMapEntry, reallocating space if
+ * necessary.
+ */
+static XkbKTMapEntryPtr
+NextMapEntry(KeyTypeInfo * type)
+{
+    if (type->entries == NULL)
+    {
+        type->entries = uTypedCalloc(2, XkbKTMapEntryRec);
+        if (type->entries == NULL)
+        {
+            ERROR1("Couldn't allocate map entries for %s\n", TypeTxt(type));
+            ACTION("Map entries lost\n");
+            return NULL;
+        }
+        type->szEntries = 2;
+        type->nEntries = 0;
+    }
+    else if (type->nEntries >= type->szEntries)
+    {
+        type->szEntries *= 2;
+        type->entries = uTypedRecalloc(type->entries,
+                                       type->nEntries, type->szEntries,
+                                       XkbKTMapEntryRec);
+        if (type->entries == NULL)
+        {
+            ERROR1("Couldn't reallocate map entries for %s\n", TypeTxt(type));
+            ACTION("Map entries lost\n");
+            return NULL;
+        }
+    }
+    return &type->entries[type->nEntries++];
+}
+
+Bool
+AddPreserve(XkbDescPtr xkb,
+            KeyTypeInfo * type, PreserveInfo * new, Bool clobber, Bool report)
+{
+    PreserveInfo *old;
+
+    old = type->preserve;
+    while (old != NULL)
+    {
+        if ((old->indexMods != new->indexMods) ||
+            (old->indexVMods != new->indexVMods))
+        {
+            old = (PreserveInfo *) old->defs.next;
+            continue;
+        }
+        if ((old->preMods == new->preMods)
+            && (old->preVMods == new->preVMods))
+        {
+            if (warningLevel > 9)
+            {
+                WARN2("Identical definitions for preserve[%s] in %s\n",
+                      PreserveIndexTxt(type, xkb, old), TypeTxt(type));
+                ACTION("Ignored\n");
+            }
+            return True;
+        }
+        if (report && (warningLevel > 0))
+        {
+            char *str;
+            WARN2("Multiple definitions for preserve[%s] in %s\n",
+                  PreserveIndexTxt(type, xkb, old), TypeTxt(type));
+
+            if (clobber)
+                str = PreserveTxt(type, xkb, new);
+            else
+                str = PreserveTxt(type, xkb, old);
+            ACTION1("Using %s, ", str);
+            if (clobber)
+                str = PreserveTxt(type, xkb, old);
+            else
+                str = PreserveTxt(type, xkb, new);
+            INFO1("ignoring %s\n", str);
+        }
+        if (clobber)
+        {
+            old->preMods = new->preMods;
+            old->preVMods = new->preVMods;
+        }
+        return True;
+    }
+    old = uTypedAlloc(PreserveInfo);
+    if (!old)
+    {
+        WSGO1("Couldn't allocate preserve in %s\n", TypeTxt(type));
+        ACTION1("Preserve[%s] lost\n", PreserveIndexTxt(type, xkb, old));
+        return False;
+    }
+    *old = *new;
+    old->matchingMapIndex = -1;
+    type->preserve =
+        (PreserveInfo *) AddCommonInfo(&type->preserve->defs, &old->defs);
+    return True;
+}
+
+/**
+ * Add a new KTMapEntry to the given key type. If an entry with the same mods
+ * already exists, the level is updated (if clobber is TRUE). Otherwise, a new
+ * entry is created.
+ *
+ * @param clobber Overwrite existing entry.
+ * @param report True if a warning is to be printed on.
+ */
+Bool
+AddMapEntry(XkbDescPtr xkb,
+            KeyTypeInfo * type,
+            XkbKTMapEntryPtr new, Bool clobber, Bool report)
+{
+    XkbKTMapEntryPtr old;
+
+    if ((old =
+         FindMatchingMapEntry(type, new->mods.real_mods, new->mods.vmods)))
+    {
+        if (report && (old->level != new->level))
+        {
+            unsigned use, ignore;
+            if (clobber)
+            {
+                use = new->level + 1;
+                ignore = old->level + 1;
+            }
+            else
+            {
+                use = old->level + 1;
+                ignore = new->level + 1;
+            }
+            WARN2("Multiple map entries for %s in %s\n",
+                  MapEntryTxt(type, xkb, new), TypeTxt(type));
+            ACTION2("Using %d, ignoring %d\n", use, ignore);
+        }
+        else if (warningLevel > 9)
+        {
+            WARN3("Multiple occurences of map[%s]= %d in %s\n",
+                  MapEntryTxt(type, xkb, new), new->level + 1, TypeTxt(type));
+            ACTION("Ignored\n");
+            return True;
+        }
+        if (clobber)
+            old->level = new->level;
+        return True;
+    }
+    if ((old = NextMapEntry(type)) == NULL)
+        return False;           /* allocation failure, already reported */
+    if (new->level >= type->numLevels)
+        type->numLevels = new->level + 1;
+    if (new->mods.vmods == 0)
+        old->active = True;
+    else
+        old->active = False;
+    old->mods.mask = new->mods.real_mods;
+    old->mods.real_mods = new->mods.real_mods;
+    old->mods.vmods = new->mods.vmods;
+    old->level = new->level;
+    return True;
+}
+
+static LookupEntry lnames[] = {
+    {"level1", 1},
+    {"level2", 2},
+    {"level3", 3},
+    {"level4", 4},
+    {"level5", 5},
+    {"level6", 6},
+    {"level7", 7},
+    {"level8", 8},
+    {NULL, 0}
+};
+
+static Bool
+SetMapEntry(KeyTypeInfo * type,
+            XkbDescPtr xkb, ExprDef * arrayNdx, ExprDef * value)
+{
+    ExprResult rtrn;
+    XkbKTMapEntryRec entry;
+
+    if (arrayNdx == NULL)
+        return ReportTypeShouldBeArray(type, "map entry");
+    if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))
+        return ReportTypeBadType(type, "map entry", "modifier mask");
+    entry.mods.real_mods = rtrn.uval & 0xff;      /* modifiers < 512 */
+    entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
+    if ((entry.mods.real_mods & (~type->mask)) ||
+        ((entry.mods.vmods & (~type->vmask)) != 0))
+    {
+        if (warningLevel > 0)
+        {
+            WARN1("Map entry for unused modifiers in %s\n", TypeTxt(type));
+            ACTION1("Using %s instead of ",
+                    XkbVModMaskText(type->dpy, xkb,
+                                    entry.mods.real_mods & type->mask,
+                                    entry.mods.vmods & type->vmask,
+                                    XkbMessage));
+            INFO1("%s\n", MapEntryTxt(type, xkb, &entry));
+        }
+        entry.mods.real_mods &= type->mask;
+        entry.mods.vmods &= type->vmask;
+    }
+    if (!ExprResolveInteger(value, &rtrn, SimpleLookup, (XPointer) lnames))
+    {
+        ERROR("Level specifications in a key type must be integer\n");
+        ACTION("Ignoring malformed level specification\n");
+        return False;
+    }
+    if ((rtrn.ival < 1) || (rtrn.ival > XkbMaxShiftLevel + 1))
+    {
+        ERROR3("Shift level %d out of range (1..%d) in key type %s\n",
+               XkbMaxShiftLevel + 1, rtrn.ival, TypeTxt(type));
+        ACTION1("Ignoring illegal definition of map[%s]\n",
+                MapEntryTxt(type, xkb, &entry));
+        return False;
+    }
+    entry.level = rtrn.ival - 1;
+    return AddMapEntry(xkb, type, &entry, True, True);
+}
+
+static Bool
+SetPreserve(KeyTypeInfo * type,
+            XkbDescPtr xkb, ExprDef * arrayNdx, ExprDef * value)
+{
+    ExprResult rtrn;
+    PreserveInfo new;
+
+    if (arrayNdx == NULL)
+        return ReportTypeShouldBeArray(type, "preserve entry");
+    if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))
+        return ReportTypeBadType(type, "preserve entry", "modifier mask");
+    new.defs = type->defs;
+    new.defs.next = NULL;
+    new.indexMods = rtrn.uval & 0xff;
+    new.indexVMods = (rtrn.uval >> 8) & 0xffff;
+    if ((new.indexMods & (~type->mask)) || (new.indexVMods & (~type->vmask)))
+    {
+        if (warningLevel > 0)
+        {
+            WARN1("Preserve for modifiers not used by the %s type\n",
+                  TypeTxt(type));
+            ACTION1("Index %s converted to ",
+                    PreserveIndexTxt(type, xkb, &new));
+        }
+        new.indexMods &= type->mask;
+        new.indexVMods &= type->vmask;
+        if (warningLevel > 0)
+            INFO1("%s\n", PreserveIndexTxt(type, xkb, &new));
+    }
+    if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (XPointer) xkb))
+    {
+        ERROR("Preserve value in a key type is not a modifier mask\n");
+        ACTION2("Ignoring preserve[%s] in type %s\n",
+                PreserveIndexTxt(type, xkb, &new), TypeTxt(type));
+        return False;
+    }
+    new.preMods = rtrn.uval & 0xff;
+    new.preVMods = (rtrn.uval >> 16) & 0xffff;
+    if ((new.preMods & (~new.indexMods))
+        || (new.preVMods && (~new.indexVMods)))
+    {
+        if (warningLevel > 0)
+        {
+            WARN2("Illegal value for preserve[%s] in type %s\n",
+                  PreserveTxt(type, xkb, &new), TypeTxt(type));
+            ACTION1("Converted %s to ", PreserveIndexTxt(type, xkb, &new));
+        }
+        new.preMods &= new.indexMods;
+        new.preVMods &= new.indexVMods;
+        if (warningLevel > 0)
+        {
+            INFO1("%s\n", PreserveIndexTxt(type, xkb, &new));
+        }
+    }
+    return AddPreserve(xkb, type, &new, True, True);
+}
+
+/***====================================================================***/
+
+Bool
+AddLevelName(KeyTypeInfo * type,
+             unsigned level, Atom name, Bool clobber, Bool report)
+{
+    if ((type->lvlNames == NULL) || (type->szNames <= level))
+    {
+        type->lvlNames =
+            uTypedRecalloc(type->lvlNames, type->szNames, level + 1, Atom);
+        if (type->lvlNames == NULL)
+        {
+            ERROR1("Couldn't allocate level names for type %s\n",
+                   TypeTxt(type));
+            ACTION("Level names lost\n");
+            type->szNames = 0;
+            return False;
+        }
+        type->szNames = level + 1;
+    }
+    else if (type->lvlNames[level] == name)
+    {
+        if (warningLevel > 9)
+        {
+            WARN2("Duplicate names for level %d of key type %s\n",
+                  level + 1, TypeTxt(type));
+            ACTION("Ignored\n");
+        }
+        return True;
+    }
+    else if (type->lvlNames[level] != None)
+    {
+        if (warningLevel > 0)
+        {
+            char *old, *new;
+            old = XkbAtomText(type->dpy, type->lvlNames[level], XkbMessage);
+            new = XkbAtomText(type->dpy, name, XkbMessage);
+            WARN2("Multiple names for level %d of key type %s\n",
+                  level + 1, TypeTxt(type));
+            if (clobber)
+                ACTION2("Using %s, ignoring %s\n", new, old);
+            else
+                ACTION2("Using %s, ignoring %s\n", old, new);
+        }
+        if (!clobber)
+            return True;
+    }
+    if (level >= type->numLevels)
+        type->numLevels = level + 1;
+    type->lvlNames[level] = name;
+    return True;
+}
+
+static Bool
+SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value)
+{
+    ExprResult rtrn;
+    unsigned level;
+
+    if (arrayNdx == NULL)
+        return ReportTypeShouldBeArray(type, "level name");
+    if (!ExprResolveInteger(arrayNdx, &rtrn, SimpleLookup, (XPointer) lnames))
+        return ReportTypeBadType(type, "level name", "integer");
+    if ((rtrn.ival < 1) || (rtrn.ival > XkbMaxShiftLevel + 1))
+    {
+        ERROR3("Level name %d out of range (1..%d) in key type %s\n",
+               rtrn.ival,
+               XkbMaxShiftLevel + 1,
+               XkbAtomText(type->dpy, type->name, XkbMessage));
+        ACTION("Ignoring illegal level name definition\n");
+        return False;
+    }
+    level = rtrn.ival - 1;
+    if (!ExprResolveString(value, &rtrn, NULL, NULL))
+    {
+        ERROR2("Non-string name for level %d in key type %s\n", level + 1,
+               XkbAtomText(type->dpy, type->name, XkbMessage));
+        ACTION("Ignoring illegal level name definition\n");
+        return False;
+    }
+    return
+        AddLevelName(type, level, XkbInternAtom(NULL, rtrn.str, False), True,
+                     True);
+}
+
+/***====================================================================***/
+
+/**
+ * Parses the fields in a type "..." { } description.
+ *
+ * @param field The field to parse (e.g. modifiers, map, level_name)
+ */
+static Bool
+SetKeyTypeField(KeyTypeInfo * type,
+                XkbDescPtr xkb,
+                char *field,
+                ExprDef * arrayNdx, ExprDef * value, KeyTypesInfo * info)
+{
+    ExprResult tmp;
+
+    if (uStrCaseCmp(field, "modifiers") == 0)
+    {
+        unsigned mods, vmods;
+        if (arrayNdx != NULL)
+        {
+            WARN("The modifiers field of a key type is not an array\n");
+            ACTION("Illegal array subscript ignored\n");
+        }
+        /* get modifier mask for current type */
+        if (!ExprResolveModMask(value, &tmp, LookupVModMask, (XPointer) xkb))
+        {
+            ERROR("Key type mask field must be a modifier mask\n");
+            ACTION("Key type definition ignored\n");
+            return False;
+        }
+        mods = tmp.uval & 0xff; /* core mods */
+        vmods = (tmp.uval >> 8) & 0xffff; /* xkb virtual mods */
+        if (type->defs.defined & _KT_Mask)
+        {
+            WARN1("Multiple modifier mask definitions for key type %s\n",
+                  XkbAtomText(type->dpy, type->name, XkbMessage));
+            ACTION1("Using %s, ", TypeMaskTxt(type, xkb));
+            INFO1("ignoring %s\n", XkbVModMaskText(type->dpy, xkb, mods,
+                                                   vmods, XkbMessage));
+            return False;
+        }
+        type->mask = mods;
+        type->vmask = vmods;
+        type->defs.defined |= _KT_Mask;
+        return True;
+    }
+    else if (uStrCaseCmp(field, "map") == 0)
+    {
+        type->defs.defined |= _KT_Map;
+        return SetMapEntry(type, xkb, arrayNdx, value);
+    }
+    else if (uStrCaseCmp(field, "preserve") == 0)
+    {
+        type->defs.defined |= _KT_Preserve;
+        return SetPreserve(type, xkb, arrayNdx, value);
+    }
+    else if ((uStrCaseCmp(field, "levelname") == 0) ||
+             (uStrCaseCmp(field, "level_name") == 0))
+    {
+        type->defs.defined |= _KT_LevelNames;
+        return SetLevelName(type, arrayNdx, value);
+    }
+    ERROR2("Unknown field %s in key type %s\n", field, TypeTxt(type));
+    ACTION("Definition ignored\n");
+    return False;
+}
+
+static Bool
+HandleKeyTypeVar(VarDef * stmt, XkbDescPtr xkb, KeyTypesInfo * info)
+{
+    ExprResult elem, field;
+    ExprDef *arrayNdx;
+
+    if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx))
+        return False;           /* internal error, already reported */
+    if (elem.str && (uStrCaseCmp(elem.str, "type") == 0))
+        return SetKeyTypeField(&info->dflt, xkb, field.str, arrayNdx,
+                               stmt->value, info);
+    if (elem.str != NULL)
+    {
+        ERROR1("Default for unknown element %s\n", uStringText(elem.str));
+        ACTION1("Value for field %s ignored\n", uStringText(field.str));
+    }
+    else if (field.str != NULL)
+    {
+        ERROR1("Default defined for unknown field %s\n",
+               uStringText(field.str));
+        ACTION("Ignored\n");
+    }
+    return False;
+}
+
+static int
+HandleKeyTypeBody(VarDef * def,
+                  XkbDescPtr xkb, KeyTypeInfo * type, KeyTypesInfo * info)
+{
+    int ok = 1;
+    ExprResult tmp, field;
+    ExprDef *arrayNdx;
+
+    for (; def != NULL; def = (VarDef *) def->common.next)
+    {
+        if ((def->name) && (def->name->type == ExprFieldRef))
+        {
+            ok = HandleKeyTypeVar(def, xkb, info);
+            continue;
+        }
+        ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
+        if (ok)
+            ok = SetKeyTypeField(type, xkb, field.str, arrayNdx, def->value,
+                                 info);
+    }
+    return ok;
+}
+
+/**
+ * Process a type "XYZ" { } specification in the xkb_types section.
+ *
+ */
+static int
+HandleKeyTypeDef(KeyTypeDef * def,
+                 XkbDescPtr xkb, unsigned merge, KeyTypesInfo * info)
+{
+    register int i;
+    KeyTypeInfo type;
+
+    if (def->merge != MergeDefault)
+        merge = def->merge;
+
+    type.defs.defined = 0;
+    type.defs.fileID = info->fileID;
+    type.defs.merge = merge;
+    type.defs.next = NULL;
+    type.dpy = info->dpy;
+    type.name = def->name;
+    type.mask = info->dflt.mask;
+    type.vmask = info->dflt.vmask;
+    type.groupInfo = info->dflt.groupInfo;
+    type.numLevels = 1;
+    type.nEntries = type.szEntries = 0;
+    type.entries = NULL;
+    type.szNames = 0;
+    type.lvlNames = NULL;
+    type.preserve = NULL;
+
+    /* Parse the actual content. */
+    if (!HandleKeyTypeBody(def->body, xkb, &type, info))
+    {
+        info->errorCount++;
+        return False;
+    }
+
+    /* now copy any appropriate map, preserve or level names from the */
+    /* default type */
+    for (i = 0; i < info->dflt.nEntries; i++)
+    {
+        XkbKTMapEntryPtr dflt;
+        dflt = &info->dflt.entries[i];
+        if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) &&
+            ((dflt->mods.vmods & type.vmask) == dflt->mods.vmods))
+        {
+            AddMapEntry(xkb, &type, dflt, False, False);
+        }
+    }
+    if (info->dflt.preserve)
+    {
+        PreserveInfo *dflt = info->dflt.preserve;
+        while (dflt)
+        {
+            if (((dflt->indexMods & type.mask) == dflt->indexMods) &&
+                ((dflt->indexVMods & type.vmask) == dflt->indexVMods))
+            {
+                AddPreserve(xkb, &type, dflt, False, False);
+            }
+            dflt = (PreserveInfo *) dflt->defs.next;
+        }
+    }
+    for (i = 0; i < info->dflt.szNames; i++)
+    {
+        if ((i < type.numLevels) && (info->dflt.lvlNames[i] != None))
+        {
+            AddLevelName(&type, i, info->dflt.lvlNames[i], False, False);
+        }
+    }
+    /* Now add the new keytype to the info struct */
+    if (!AddKeyType(xkb, info, &type))
+    {
+        info->errorCount++;
+        return False;
+    }
+    return True;
+}
+
+/**
+ * Process an xkb_types section.
+ *
+ * @param file The parsed xkb_types section.
+ * @param merge Merge Strategy (e.g. MergeOverride)
+ * @param info Pointer to memory where the outcome will be stored.
+ */
+static void
+HandleKeyTypesFile(XkbFile * file,
+                   XkbDescPtr xkb, unsigned merge, KeyTypesInfo * info)
+{
+    ParseCommon *stmt;
+
+    info->name = uStringDup(file->name);
+    stmt = file->defs;
+    while (stmt)
+    {
+        switch (stmt->stmtType)
+        {
+        case StmtInclude:
+            if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, xkb, info,
+                                       HandleKeyTypesFile))
+                info->errorCount++;
+            break;
+        case StmtKeyTypeDef: /* e.g. type "ONE_LEVEL" */
+            if (!HandleKeyTypeDef((KeyTypeDef *) stmt, xkb, merge, info))
+                info->errorCount++;
+            break;
+        case StmtVarDef:
+            if (!HandleKeyTypeVar((VarDef *) stmt, xkb, info))
+                info->errorCount++;
+            break;
+        case StmtVModDef: /* virtual_modifiers NumLock, ... */
+            if (!HandleVModDef((VModDef *) stmt, merge, &info->vmods))
+                info->errorCount++;
+            break;
+        case StmtKeyAliasDef:
+            ERROR("Key type files may not include other declarations\n");
+            ACTION("Ignoring definition of key alias\n");
+            info->errorCount++;
+            break;
+        case StmtKeycodeDef:
+            ERROR("Key type files may not include other declarations\n");
+            ACTION("Ignoring definition of key name\n");
+            info->errorCount++;
+            break;
+        case StmtInterpDef:
+            ERROR("Key type files may not include other declarations\n");
+            ACTION("Ignoring definition of symbol interpretation\n");
+            info->errorCount++;
+            break;
+        default:
+            WSGO1("Unexpected statement type %d in HandleKeyTypesFile\n",
+                  stmt->stmtType);
+            break;
+        }
+        stmt = stmt->next;
+        if (info->errorCount > 10)
+        {
+#ifdef NOISY
+            ERROR("Too many errors\n");
+#endif
+            ACTION1("Abandoning keytypes file \"%s\"\n", file->topName);
+            break;
+        }
+    }
+    return;
+}
+
+static Bool
+CopyDefToKeyType(XkbDescPtr xkb, XkbKeyTypePtr type, KeyTypeInfo * def)
+{
+    register int i;
+    PreserveInfo *pre;
+
+    for (pre = def->preserve; pre != NULL;
+         pre = (PreserveInfo *) pre->defs.next)
+    {
+        XkbKTMapEntryPtr match;
+        XkbKTMapEntryRec tmp;
+        tmp.mods.real_mods = pre->indexMods;
+        tmp.mods.vmods = pre->indexVMods;
+        tmp.level = 0;
+        AddMapEntry(xkb, def, &tmp, False, False);
+        match = FindMatchingMapEntry(def, pre->indexMods, pre->indexVMods);
+        if (!match)
+        {
+            WSGO("Couldn't find matching entry for preserve\n");
+            ACTION("Aborting\n");
+            return False;
+        }
+        pre->matchingMapIndex = match - def->entries;
+    }
+    type->mods.real_mods = def->mask;
+    type->mods.vmods = def->vmask;
+    type->num_levels = def->numLevels;
+    type->map_count = def->nEntries;
+    type->map = def->entries;
+    if (def->preserve)
+    {
+        type->preserve = uTypedCalloc(type->map_count, XkbModsRec);
+        if (!type->preserve)
+        {
+            WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");
+            ACTION1("Preserve setting for type %s lost\n",
+                    XkbAtomText(def->dpy, def->name, XkbMessage));
+        }
+        else
+        {
+            pre = def->preserve;
+            for (; pre != NULL; pre = (PreserveInfo *) pre->defs.next)
+            {
+                int ndx = pre->matchingMapIndex;
+                type->preserve[ndx].mask = pre->preMods;
+                type->preserve[ndx].real_mods = pre->preMods;
+                type->preserve[ndx].vmods = pre->preVMods;
+            }
+        }
+    }
+    else
+        type->preserve = NULL;
+    type->name = (Atom) def->name;
+    if (def->szNames > 0)
+    {
+        type->level_names = uTypedCalloc(def->numLevels, Atom);
+
+        /* assert def->szNames<=def->numLevels */
+        for (i = 0; i < def->szNames; i++)
+        {
+            type->level_names[i] = (Atom) def->lvlNames[i];
+        }
+    }
+    else
+    {
+        type->level_names = NULL;
+    }
+
+    def->nEntries = def->szEntries = 0;
+    def->entries = NULL;
+    return XkbComputeEffectiveMap(xkb, type, NULL);
+}
+
+Bool
+CompileKeyTypes(XkbFile * file, XkbFileInfo * result, unsigned merge)
+{
+    KeyTypesInfo info;
+    XkbDescPtr xkb;
+
+    xkb = result->xkb;
+    InitKeyTypesInfo(&info, xkb, NULL);
+    info.fileID = file->id;
+    HandleKeyTypesFile(file, xkb, merge, &info);
+
+    if (info.errorCount == 0)
+    {
+        register int i;
+        register KeyTypeInfo *def;
+        register XkbKeyTypePtr type, next;
+
+        if (info.name != NULL)
+        {
+            if (XkbAllocNames(xkb, XkbTypesNameMask, 0, 0) == Success)
+                xkb->names->types = XkbInternAtom(xkb->dpy, info.name, False);
+            else
+            {
+                WSGO("Couldn't allocate space for types name\n");
+                ACTION2("Name \"%s\" (from %s) NOT assigned\n",
+                        scanFile, info.name);
+            }
+        }
+        i = info.nTypes;
+        if ((info.stdPresent & XkbOneLevelMask) == 0)
+            i++;
+        if ((info.stdPresent & XkbTwoLevelMask) == 0)
+            i++;
+        if ((info.stdPresent & XkbKeypadMask) == 0)
+            i++;
+        if ((info.stdPresent & XkbAlphabeticMask) == 0)
+            i++;
+        if (XkbAllocClientMap(xkb, XkbKeyTypesMask, i) != Success)
+        {
+            WSGO("Couldn't allocate client map\n");
+            ACTION("Exiting\n");
+            return False;
+        }
+        xkb->map->num_types = i;
+        if (XkbAllRequiredTypes & (~info.stdPresent))
+        {
+            unsigned missing, keypadVMod;
+
+            missing = XkbAllRequiredTypes & (~info.stdPresent);
+            keypadVMod = FindKeypadVMod(xkb);
+            if (XkbInitCanonicalKeyTypes(xkb, missing, keypadVMod) != Success)
+            {
+                WSGO("Couldn't initialize canonical key types\n");
+                ACTION("Exiting\n");
+                return False;
+            }
+            if (missing & XkbOneLevelMask)
+                xkb->map->types[XkbOneLevelIndex].name = tok_ONE_LEVEL;
+            if (missing & XkbTwoLevelMask)
+                xkb->map->types[XkbTwoLevelIndex].name = tok_TWO_LEVEL;
+            if (missing & XkbAlphabeticMask)
+                xkb->map->types[XkbAlphabeticIndex].name = tok_ALPHABETIC;
+            if (missing & XkbKeypadMask)
+                xkb->map->types[XkbKeypadIndex].name = tok_KEYPAD;
+        }
+        next = &xkb->map->types[XkbLastRequiredType + 1];
+        for (i = 0, def = info.types; i < info.nTypes; i++)
+        {
+            if (def->name == tok_ONE_LEVEL)
+                type = &xkb->map->types[XkbOneLevelIndex];
+            else if (def->name == tok_TWO_LEVEL)
+                type = &xkb->map->types[XkbTwoLevelIndex];
+            else if (def->name == tok_ALPHABETIC)
+                type = &xkb->map->types[XkbAlphabeticIndex];
+            else if (def->name == tok_KEYPAD)
+                type = &xkb->map->types[XkbKeypadIndex];
+            else
+                type = next++;
+            DeleteLevel1MapEntries(def);
+            if (!CopyDefToKeyType(xkb, type, def))
+                return False;
+            def = (KeyTypeInfo *) def->defs.next;
+        }
+        return True;
+    }
+    return False;
+}