Convert nx-X11/lib/ build flow from imake to autotools.

1 files changed, 0 insertions, 1021 deletions

diff --git a/nx-X11/lib/X11/XKBMisc.c b/nx-X11/lib/X11/XKBMisc.c
deleted file mode 100644
index ab48b6124..000000000
--- a/nx-X11/lib/X11/XKBMisc.c
+++ /dev/null
@@ -1,1021 +0,0 @@
-/************************************************************
-Copyright (c) 1993 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.
-
-********************************************************/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-
-#include <stdio.h>
-#include "Xlibint.h"
-#include <nx-X11/extensions/XKBproto.h>
-#include <nx-X11/keysym.h>
-#include "XKBlibint.h"
-
-
-/***====================================================================***/
-
-#define	mapSize(m)	(sizeof(m)/sizeof(XkbKTMapEntryRec))
-static XkbKTMapEntryRec map2Level[] = {
-    { True, ShiftMask, {1, ShiftMask, 0} }
-};
-
-static XkbKTMapEntryRec mapAlpha[] = {
-    { True, ShiftMask, {1, ShiftMask, 0} },
-    { True, LockMask, {0, LockMask, 0} }
-};
-
-static XkbModsRec preAlpha[] = {
-    {        0,        0, 0 },
-    { LockMask, LockMask, 0 }
-};
-
-#define	NL_VMOD_MASK	0
-static XkbKTMapEntryRec mapKeypad[] = {
-    { True, ShiftMask, { 1, ShiftMask,            0 } },
-    { False,        0, { 1,         0, NL_VMOD_MASK } }
-};
-
-static XkbKeyTypeRec canonicalTypes[XkbNumRequiredTypes] = {
-    { { 0, 0, 0 },
-      1,                             /* num_levels */
-      0,                             /* map_count */
-      NULL,         NULL,
-      None,         NULL
-    },
-    { { ShiftMask, ShiftMask, 0 },
-      2,                             /* num_levels */
-      mapSize(map2Level),            /* map_count */
-      map2Level,    NULL,
-      None,         NULL
-    },
-    { { ShiftMask|LockMask, ShiftMask|LockMask, 0 },
-      2,                            /* num_levels */
-      mapSize(mapAlpha),            /* map_count */
-      mapAlpha,     preAlpha,
-      None,         NULL
-    },
-    { { ShiftMask, ShiftMask, NL_VMOD_MASK },
-      2,                            /* num_levels */
-      mapSize(mapKeypad),           /* map_count */
-      mapKeypad,    NULL,
-      None,         NULL
-    }
-};
-
-Status
-XkbInitCanonicalKeyTypes(XkbDescPtr xkb, unsigned which, int keypadVMod)
-{
-    XkbClientMapPtr map;
-    XkbKeyTypePtr from, to;
-    Status rtrn;
-
-    if (!xkb)
-        return BadMatch;
-    rtrn = XkbAllocClientMap(xkb, XkbKeyTypesMask, XkbNumRequiredTypes);
-    if (rtrn != Success)
-        return rtrn;
-    map = xkb->map;
-    if ((which & XkbAllRequiredTypes) == 0)
-        return Success;
-    rtrn = Success;
-    from = canonicalTypes;
-    to = map->types;
-    if (which & XkbOneLevelMask)
-        rtrn = XkbCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
-    if ((which & XkbTwoLevelMask) && (rtrn == Success))
-        rtrn = XkbCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
-    if ((which & XkbAlphabeticMask) && (rtrn == Success))
-        rtrn =
-            XkbCopyKeyType(&from[XkbAlphabeticIndex], &to[XkbAlphabeticIndex]);
-    if ((which & XkbKeypadMask) && (rtrn == Success)) {
-        XkbKeyTypePtr type;
-
-        rtrn = XkbCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
-        type = &to[XkbKeypadIndex];
-        if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
-            (rtrn == Success)) {
-            type->mods.vmods = (1 << keypadVMod);
-            type->map[0].active = True;
-            type->map[0].mods.mask = ShiftMask;
-            type->map[0].mods.real_mods = ShiftMask;
-            type->map[0].mods.vmods = 0;
-            type->map[0].level = 1;
-            type->map[1].active = False;
-            type->map[1].mods.mask = 0;
-            type->map[1].mods.real_mods = 0;
-            type->map[1].mods.vmods = (1 << keypadVMod);
-            type->map[1].level = 1;
-        }
-    }
-    return Success;
-}
-
-/***====================================================================***/
-
-#define	CORE_SYM(i)	(i<map_width?core_syms[i]:NoSymbol)
-#define	XKB_OFFSET(g,l)	(((g)*groupsWidth)+(l))
-
-int
-XkbKeyTypesForCoreSymbols(XkbDescPtr xkb,
-                          int map_width,
-                          KeySym *core_syms,
-                          unsigned int protected,
-                          int *types_inout,
-                          KeySym *xkb_syms_rtrn)
-{
-    register int i;
-    unsigned int empty;
-    int nSyms[XkbNumKbdGroups];
-    int nGroups, tmp, groupsWidth;
-
-    /* Section 12.2 of the protocol describes this process in more detail */
-    /* Step 1:  find the # of symbols in the core mapping per group */
-    groupsWidth = 2;
-    for (i = 0; i < XkbNumKbdGroups; i++) {
-        if ((protected & (1 << i)) && (types_inout[i] < xkb->map->num_types)) {
-            nSyms[i] = xkb->map->types[types_inout[i]].num_levels;
-            if (nSyms[i] > groupsWidth)
-                groupsWidth = nSyms[i];
-        }
-        else {
-            types_inout[i] = XkbTwoLevelIndex;  /* don't really know, yet */
-            nSyms[i] = 2;
-        }
-    }
-    if (nSyms[XkbGroup1Index] < 2)
-        nSyms[XkbGroup1Index] = 2;
-    if (nSyms[XkbGroup2Index] < 2)
-        nSyms[XkbGroup2Index] = 2;
-    /* Step 2:  Copy the symbols from the core ordering to XKB ordering */
-    /*          symbols in the core are in the order:                   */
-    /*          G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*] */
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 0)] = CORE_SYM(0);
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, 1)] = CORE_SYM(1);
-    for (i = 2; i < nSyms[XkbGroup1Index]; i++) {
-        xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index, i)] = CORE_SYM(2 + i);
-    }
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 0)] = CORE_SYM(2);
-    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, 1)] = CORE_SYM(3);
-    tmp = 2 + (nSyms[XkbGroup1Index] - 2);      /* offset to extra group2 syms */
-    for (i = 2; i < nSyms[XkbGroup2Index]; i++) {
-        xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index, i)] = CORE_SYM(tmp + i);
-    }
-    tmp = nSyms[XkbGroup1Index] + nSyms[XkbGroup2Index];
-    if ((tmp >= map_width) &&
-        ((protected & (XkbExplicitKeyType3Mask | XkbExplicitKeyType4Mask)) ==
-         0)) {
-        nSyms[XkbGroup3Index] = 0;
-        nSyms[XkbGroup4Index] = 0;
-        nGroups = 2;
-    }
-    else {
-        nGroups = 3;
-        for (i = 0; i < nSyms[XkbGroup3Index]; i++, tmp++) {
-            xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index, i)] = CORE_SYM(tmp);
-        }
-        if ((tmp < map_width) || (protected & XkbExplicitKeyType4Mask)) {
-            nGroups = 4;
-            for (i = 0; i < nSyms[XkbGroup4Index]; i++, tmp++) {
-                xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index, i)] = CORE_SYM(tmp);
-            }
-        }
-        else {
-            nSyms[XkbGroup4Index] = 0;
-        }
-    }
-    /* steps 3&4: alphanumeric expansion,  assign canonical types */
-    empty = 0;
-    for (i = 0; i < nGroups; i++) {
-        KeySym *syms;
-
-        syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
-        if ((nSyms[i] > 1) && (syms[1] == NoSymbol) && (syms[0] != NoSymbol)) {
-            KeySym upper, lower;
-
-            XConvertCase(syms[0], &lower, &upper);
-            if (upper != lower) {
-                xkb_syms_rtrn[XKB_OFFSET(i, 0)] = lower;
-                xkb_syms_rtrn[XKB_OFFSET(i, 1)] = upper;
-                if ((protected & (1 << i)) == 0)
-                    types_inout[i] = XkbAlphabeticIndex;
-            }
-            else if ((protected & (1 << i)) == 0) {
-                types_inout[i] = XkbOneLevelIndex;
-                /*      nSyms[i]=       1; */
-            }
-        }
-        if (((protected & (1 << i)) == 0) &&
-            (types_inout[i] == XkbTwoLevelIndex)) {
-            if (IsKeypadKey(syms[0]) || IsKeypadKey(syms[1]))
-                types_inout[i] = XkbKeypadIndex;
-            else {
-                KeySym upper, lower;
-
-                XConvertCase(syms[0], &lower, &upper);
-                if ((syms[0] == lower) && (syms[1] == upper))
-                    types_inout[i] = XkbAlphabeticIndex;
-            }
-        }
-        if (syms[0] == NoSymbol) {
-            register int n;
-            Bool found;
-
-            for (n = 1, found = False; (!found) && (n < nSyms[i]); n++) {
-                found = (syms[n] != NoSymbol);
-            }
-            if (!found)
-                empty |= (1 << i);
-        }
-    }
-    /* step 5: squoosh out empty groups */
-    if (empty) {
-        for (i = nGroups - 1; i >= 0; i--) {
-            if (((empty & (1 << i)) == 0) || (protected & (1 << i)))
-                break;
-            nGroups--;
-        }
-    }
-    if (nGroups < 1)
-        return 0;
-
-    /* step 6: replicate group 1 into group two, if necessary */
-    if ((nGroups > 1) &&
-        ((empty & (XkbGroup1Mask | XkbGroup2Mask)) == XkbGroup2Mask)) {
-        if ((protected & (XkbExplicitKeyType1Mask | XkbExplicitKeyType2Mask)) ==
-            0) {
-            nSyms[XkbGroup2Index] = nSyms[XkbGroup1Index];
-            types_inout[XkbGroup2Index] = types_inout[XkbGroup1Index];
-            memcpy((char *) &xkb_syms_rtrn[2], (char *) xkb_syms_rtrn,
-                   2 * sizeof(KeySym));
-        }
-        else if (types_inout[XkbGroup1Index] == types_inout[XkbGroup2Index]) {
-            memcpy((char *) &xkb_syms_rtrn[nSyms[XkbGroup1Index]],
-                   (char *) xkb_syms_rtrn,
-                   nSyms[XkbGroup1Index] * sizeof(KeySym));
-        }
-    }
-
-    /* step 7: check for all groups identical or all width 1 */
-    if (nGroups > 1) {
-        Bool sameType, allOneLevel;
-
-        allOneLevel = (xkb->map->types[types_inout[0]].num_levels == 1);
-        for (i = 1, sameType = True; (allOneLevel || sameType) && (i < nGroups);
-             i++) {
-            sameType = (sameType &&
-                        (types_inout[i] == types_inout[XkbGroup1Index]));
-            if (allOneLevel)
-                allOneLevel = (xkb->map->types[types_inout[i]].num_levels == 1);
-        }
-        if ((sameType) &&
-            (!(protected &
-               (XkbExplicitKeyTypesMask & ~XkbExplicitKeyType1Mask)))) {
-            register int s;
-            Bool identical;
-
-            for (i = 1, identical = True; identical && (i < nGroups); i++) {
-                KeySym *syms;
-
-                syms = &xkb_syms_rtrn[XKB_OFFSET(i, 0)];
-                for (s = 0; identical && (s < nSyms[i]); s++) {
-                    if (syms[s] != xkb_syms_rtrn[s])
-                        identical = False;
-                }
-            }
-            if (identical)
-                nGroups = 1;
-        }
-        if (allOneLevel && (nGroups > 1)) {
-            KeySym *syms;
-
-            syms = &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
-            nSyms[XkbGroup1Index] = 1;
-            for (i = 1; i < nGroups; i++) {
-                xkb_syms_rtrn[i] = syms[0];
-                syms += nSyms[i];
-                nSyms[i] = 1;
-            }
-        }
-    }
-    return nGroups;
-}
-
-static XkbSymInterpretPtr
-_XkbFindMatchingInterp(XkbDescPtr xkb,
-                       KeySym sym,
-                       unsigned int real_mods,
-                       unsigned int level)
-{
-    register unsigned i;
-    XkbSymInterpretPtr interp, rtrn;
-    CARD8 mods;
-
-    rtrn = NULL;
-    interp = xkb->compat->sym_interpret;
-    for (i = 0; i < xkb->compat->num_si; i++, interp++) {
-        if ((interp->sym == NoSymbol) || (sym == interp->sym)) {
-            int match;
-
-            if ((level == 0) || ((interp->match & XkbSI_LevelOneOnly) == 0))
-                mods = real_mods;
-            else
-                mods = 0;
-            switch (interp->match & XkbSI_OpMask) {
-            case XkbSI_NoneOf:
-                match = ((interp->mods & mods) == 0);
-                break;
-            case XkbSI_AnyOfOrNone:
-                match = ((mods == 0) || ((interp->mods & mods) != 0));
-                break;
-            case XkbSI_AnyOf:
-                match = ((interp->mods & mods) != 0);
-                break;
-            case XkbSI_AllOf:
-                match = ((interp->mods & mods) == interp->mods);
-                break;
-            case XkbSI_Exactly:
-                match = (interp->mods == mods);
-                break;
-            default:
-                match = 0;
-                break;
-            }
-            if (match) {
-                if (interp->sym != NoSymbol) {
-                    return interp;
-                }
-                else if (rtrn == NULL) {
-                    rtrn = interp;
-                }
-            }
-        }
-    }
-    return rtrn;
-}
-
-static void
-_XkbAddKeyChange(KeyCode *pFirst, unsigned char *pNum, KeyCode newKey)
-{
-    KeyCode last;
-
-    last = (*pFirst) + (*pNum);
-    if (newKey < *pFirst) {
-        *pFirst = newKey;
-        *pNum = (last - newKey) + 1;
-    }
-    else if (newKey > last) {
-        *pNum = (last - *pFirst) + 1;
-    }
-    return;
-}
-
-static void
-_XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods)
-{
-    unsigned tmp;
-
-    switch (act->type) {
-    case XkbSA_SetMods:
-    case XkbSA_LatchMods:
-    case XkbSA_LockMods:
-        if (act->mods.flags & XkbSA_UseModMapMods)
-            act->mods.real_mods = act->mods.mask = mods;
-        if ((tmp = XkbModActionVMods(&act->mods)) != 0) {
-            XkbVirtualModsToReal(xkb, tmp, &tmp);
-            act->mods.mask |= tmp;
-        }
-        break;
-    case XkbSA_ISOLock:
-        if (act->iso.flags & XkbSA_UseModMapMods)
-            act->iso.real_mods = act->iso.mask = mods;
-        if ((tmp = XkbModActionVMods(&act->iso)) != 0) {
-            XkbVirtualModsToReal(xkb, tmp, &tmp);
-            act->iso.mask |= tmp;
-        }
-        break;
-    }
-    return;
-}
-
-#define	IBUF_SIZE	8
-
-Bool
-XkbApplyCompatMapToKey(XkbDescPtr xkb, KeyCode key, XkbChangesPtr changes)
-{
-    KeySym *syms;
-    unsigned char explicit, mods;
-    XkbSymInterpretPtr *interps, ibuf[IBUF_SIZE];
-    int n, nSyms, found;
-    unsigned changed, tmp;
-
-    if ((!xkb) || (!xkb->map) || (!xkb->map->key_sym_map) ||
-        (!xkb->compat) || (!xkb->compat->sym_interpret) ||
-        (key < xkb->min_key_code) || (key > xkb->max_key_code)) {
-        return False;
-    }
-    if (((!xkb->server) || (!xkb->server->key_acts)) &&
-        (XkbAllocServerMap(xkb, XkbAllServerInfoMask, 0) != Success)) {
-        return False;
-    }
-    changed = 0;                /* keeps track of what has changed in _this_ call */
-    explicit = xkb->server->explicit[key];
-    if (explicit & XkbExplicitInterpretMask)    /* nothing to do */
-        return True;
-    mods = (xkb->map->modmap ? xkb->map->modmap[key] : 0);
-    nSyms = XkbKeyNumSyms(xkb, key);
-    syms = XkbKeySymsPtr(xkb, key);
-    if (nSyms > IBUF_SIZE) {
-        interps = _XkbTypedCalloc(nSyms, XkbSymInterpretPtr);
-        if (interps == NULL) {
-            interps = ibuf;
-            nSyms = IBUF_SIZE;
-        }
-    }
-    else {
-        interps = ibuf;
-    }
-    found = 0;
-    for (n = 0; n < nSyms; n++) {
-        unsigned level = (n % XkbKeyGroupsWidth(xkb, key));
-
-        interps[n] = NULL;
-        if (syms[n] != NoSymbol) {
-            interps[n] = _XkbFindMatchingInterp(xkb, syms[n], mods, level);
-            if (interps[n] && interps[n]->act.type != XkbSA_NoAction)
-                found++;
-            else
-                interps[n] = NULL;
-        }
-    }
-    /* 1/28/96 (ef) -- XXX! WORKING HERE */
-    if (!found) {
-        if (xkb->server->key_acts[key] != 0) {
-            xkb->server->key_acts[key] = 0;
-            changed |= XkbKeyActionsMask;
-        }
-    }
-    else {
-        XkbAction *pActs;
-        unsigned int new_vmodmask;
-
-        changed |= XkbKeyActionsMask;
-        pActs = XkbResizeKeyActions(xkb, key, nSyms);
-        if (!pActs) {
-            if (nSyms > IBUF_SIZE)
-                Xfree(interps);
-            return False;
-        }
-        new_vmodmask = 0;
-        for (n = 0; n < nSyms; n++) {
-            if (interps[n]) {
-                unsigned effMods;
-
-                pActs[n] = *((XkbAction *) &interps[n]->act);
-                if ((n == 0) || ((interps[n]->match & XkbSI_LevelOneOnly) == 0)) {
-                    effMods = mods;
-                    if (interps[n]->virtual_mod != XkbNoModifier)
-                        new_vmodmask |= (1 << interps[n]->virtual_mod);
-                }
-                else
-                    effMods = 0;
-                _XkbSetActionKeyMods(xkb, &pActs[n], effMods);
-            }
-            else
-                pActs[n].type = XkbSA_NoAction;
-        }
-        if (((explicit & XkbExplicitVModMapMask) == 0) &&
-            (xkb->server->vmodmap[key] != new_vmodmask)) {
-            changed |= XkbVirtualModMapMask;
-            xkb->server->vmodmap[key] = new_vmodmask;
-        }
-        if (interps[0]) {
-            if ((interps[0]->flags & XkbSI_LockingKey) &&
-                ((explicit & XkbExplicitBehaviorMask) == 0)) {
-                xkb->server->behaviors[key].type = XkbKB_Lock;
-                changed |= XkbKeyBehaviorsMask;
-            }
-            if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
-                CARD8 old;
-
-                old = xkb->ctrls->per_key_repeat[key / 8];
-                if (interps[0]->flags & XkbSI_AutoRepeat)
-                    xkb->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8));
-                else
-                    xkb->ctrls->per_key_repeat[key / 8] &= ~(1 << (key % 8));
-                if (changes && (old != xkb->ctrls->per_key_repeat[key / 8]))
-                    changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
-            }
-        }
-    }
-    if ((!found) || (interps[0] == NULL)) {
-        if (((explicit & XkbExplicitAutoRepeatMask) == 0) && (xkb->ctrls)) {
-            CARD8 old;
-
-            old = xkb->ctrls->per_key_repeat[key / 8];
-#ifdef RETURN_SHOULD_REPEAT
-            if (*XkbKeySymsPtr(xkb, key) != XK_Return)
-#endif
-                xkb->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8));
-            if (changes && (old != xkb->ctrls->per_key_repeat[key / 8]))
-                changes->ctrls.changed_ctrls |= XkbPerKeyRepeatMask;
-        }
-        if (((explicit & XkbExplicitBehaviorMask) == 0) &&
-            (xkb->server->behaviors[key].type == XkbKB_Lock)) {
-            xkb->server->behaviors[key].type = XkbKB_Default;
-            changed |= XkbKeyBehaviorsMask;
-        }
-    }
-    if (changes) {
-        XkbMapChangesPtr mc;
-
-        mc = &changes->map;
-        tmp = (changed & mc->changed);
-        if (tmp & XkbKeyActionsMask)
-            _XkbAddKeyChange(&mc->first_key_act, &mc->num_key_acts, key);
-        else if (changed & XkbKeyActionsMask) {
-            mc->changed |= XkbKeyActionsMask;
-            mc->first_key_act = key;
-            mc->num_key_acts = 1;
-        }
-        if (tmp & XkbKeyBehaviorsMask) {
-            _XkbAddKeyChange(&mc->first_key_behavior, &mc->num_key_behaviors,
-                             key);
-        }
-        else if (changed & XkbKeyBehaviorsMask) {
-            mc->changed |= XkbKeyBehaviorsMask;
-            mc->first_key_behavior = key;
-            mc->num_key_behaviors = 1;
-        }
-        if (tmp & XkbVirtualModMapMask)
-            _XkbAddKeyChange(&mc->first_vmodmap_key, &mc->num_vmodmap_keys,
-                             key);
-        else if (changed & XkbVirtualModMapMask) {
-            mc->changed |= XkbVirtualModMapMask;
-            mc->first_vmodmap_key = key;
-            mc->num_vmodmap_keys = 1;
-        }
-        mc->changed |= changed;
-    }
-    if (interps != ibuf)
-        _XkbFree(interps);
-    return True;
-}
-
-Bool
-XkbUpdateMapFromCore(XkbDescPtr xkb,
-                     KeyCode first_key,
-                     int num_keys,
-                     int map_width,
-                     KeySym *core_keysyms,
-                     XkbChangesPtr changes)
-{
-    register int key, last_key;
-    KeySym *syms;
-
-    syms = &core_keysyms[(first_key - xkb->min_key_code) * map_width];
-    if (changes) {
-        if (changes->map.changed & XkbKeySymsMask) {
-            _XkbAddKeyChange(&changes->map.first_key_sym,
-                             &changes->map.num_key_syms, first_key);
-            if (num_keys > 1) {
-                _XkbAddKeyChange(&changes->map.first_key_sym,
-                                 &changes->map.num_key_syms,
-                                 first_key + num_keys - 1);
-            }
-        }
-        else {
-            changes->map.changed |= XkbKeySymsMask;
-            changes->map.first_key_sym = first_key;
-            changes->map.num_key_syms = num_keys;
-        }
-    }
-    last_key = first_key + num_keys - 1;
-    for (key = first_key; key <= last_key; key++, syms += map_width) {
-        XkbMapChangesPtr mc;
-        unsigned explicit;
-        KeySym tsyms[XkbMaxSymsPerKey];
-        int types[XkbNumKbdGroups];
-        int nG;
-
-        explicit = xkb->server->explicit[key] & XkbExplicitKeyTypesMask;
-        types[XkbGroup1Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
-        types[XkbGroup2Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup2Index);
-        types[XkbGroup3Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup3Index);
-        types[XkbGroup4Index] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup4Index);
-        nG = XkbKeyTypesForCoreSymbols(xkb, map_width, syms, explicit, types,
-                                       tsyms);
-        if (changes)
-            mc = &changes->map;
-        else
-            mc = NULL;
-        XkbChangeTypesOfKey(xkb, key, nG, XkbAllGroupsMask, types, mc);
-        memcpy((char *) XkbKeySymsPtr(xkb, key), (char *) tsyms,
-               XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
-        XkbApplyCompatMapToKey(xkb, key, changes);
-    }
-
-    if ((xkb->map->modmap != NULL) && (changes) &&
-        (changes->map.changed & (XkbVirtualModMapMask | XkbModifierMapMask))) {
-        unsigned char newVMods[XkbNumVirtualMods];
-        register unsigned bit, i;
-        unsigned present;
-
-        bzero(newVMods, XkbNumVirtualMods);
-        present = 0;
-        for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
-            if (xkb->server->vmodmap[key] == 0)
-                continue;
-            for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
-                if (bit & xkb->server->vmodmap[key]) {
-                    present |= bit;
-                    newVMods[i] |= xkb->map->modmap[key];
-                }
-            }
-        }
-        for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
-            if ((bit & present) && (newVMods[i] != xkb->server->vmods[i])) {
-                changes->map.changed |= XkbVirtualModsMask;
-                changes->map.vmods |= bit;
-                xkb->server->vmods[i] = newVMods[i];
-            }
-        }
-    }
-    if (changes && (changes->map.changed & XkbVirtualModsMask))
-        XkbApplyVirtualModChanges(xkb, changes->map.vmods, changes);
-    return True;
-}
-
-Status
-XkbChangeTypesOfKey(XkbDescPtr xkb,
-                    int key,
-                    int nGroups,
-                    unsigned groups,
-                    int *newTypesIn,
-                    XkbMapChangesPtr changes)
-{
-    XkbKeyTypePtr pOldType, pNewType;
-    register int i;
-    int width, nOldGroups, oldWidth, newTypes[XkbNumKbdGroups];
-
-    if ((!xkb) || (!XkbKeycodeInRange(xkb, key)) || (!xkb->map) ||
-        (!xkb->map->types) || ((groups & XkbAllGroupsMask) == 0) ||
-        (nGroups > XkbNumKbdGroups)) {
-        return BadMatch;
-    }
-    if (nGroups == 0) {
-        for (i = 0; i < XkbNumKbdGroups; i++) {
-            xkb->map->key_sym_map[key].kt_index[i] = XkbOneLevelIndex;
-        }
-        i = xkb->map->key_sym_map[key].group_info;
-        i = XkbSetNumGroups(i, 0);
-        xkb->map->key_sym_map[key].group_info = i;
-        XkbResizeKeySyms(xkb, key, 0);
-        return Success;
-    }
-
-    nOldGroups = XkbKeyNumGroups(xkb, key);
-    oldWidth = XkbKeyGroupsWidth(xkb, key);
-    for (width = i = 0; i < nGroups; i++) {
-        if (groups & (1 << i))
-            newTypes[i] = newTypesIn[i];
-        else if (i < nOldGroups)
-            newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, i);
-        else if (nOldGroups > 0)
-            newTypes[i] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index);
-        else
-            newTypes[i] = XkbTwoLevelIndex;
-        if (newTypes[i] > xkb->map->num_types)
-            return BadMatch;
-        pNewType = &xkb->map->types[newTypes[i]];
-        if (pNewType->num_levels > width)
-            width = pNewType->num_levels;
-    }
-    if ((xkb->ctrls) && (nGroups > xkb->ctrls->num_groups))
-        xkb->ctrls->num_groups = nGroups;
-    if ((width != oldWidth) || (nGroups != nOldGroups)) {
-        KeySym oldSyms[XkbMaxSymsPerKey], *pSyms;
-        int nCopy;
-
-        if (nOldGroups == 0) {
-            pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
-            if (pSyms != NULL) {
-                i = xkb->map->key_sym_map[key].group_info;
-                i = XkbSetNumGroups(i, nGroups);
-                xkb->map->key_sym_map[key].group_info = i;
-                xkb->map->key_sym_map[key].width = width;
-                for (i = 0; i < nGroups; i++) {
-                    xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
-                }
-                return Success;
-            }
-            return BadAlloc;
-        }
-        pSyms = XkbKeySymsPtr(xkb, key);
-        memcpy(oldSyms, pSyms, XkbKeyNumSyms(xkb, key) * sizeof(KeySym));
-        pSyms = XkbResizeKeySyms(xkb, key, width * nGroups);
-        if (pSyms == NULL)
-            return BadAlloc;
-        bzero(pSyms, width * nGroups * sizeof(KeySym));
-        for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
-            pOldType = XkbKeyKeyType(xkb, key, i);
-            pNewType = &xkb->map->types[newTypes[i]];
-            if (pNewType->num_levels > pOldType->num_levels)
-                nCopy = pOldType->num_levels;
-            else
-                nCopy = pNewType->num_levels;
-            memcpy(&pSyms[i * width], &oldSyms[i * oldWidth],
-                   nCopy * sizeof(KeySym));
-        }
-        if (XkbKeyHasActions(xkb, key)) {
-            XkbAction oldActs[XkbMaxSymsPerKey], *pActs;
-
-            pActs = XkbKeyActionsPtr(xkb, key);
-            memcpy(oldActs, pActs, XkbKeyNumSyms(xkb, key) * sizeof(XkbAction));
-            pActs = XkbResizeKeyActions(xkb, key, width * nGroups);
-            if (pActs == NULL)
-                return BadAlloc;
-            bzero(pActs, width * nGroups * sizeof(XkbAction));
-            for (i = 0; (i < nGroups) && (i < nOldGroups); i++) {
-                pOldType = XkbKeyKeyType(xkb, key, i);
-                pNewType = &xkb->map->types[newTypes[i]];
-                if (pNewType->num_levels > pOldType->num_levels)
-                    nCopy = pOldType->num_levels;
-                else
-                    nCopy = pNewType->num_levels;
-                memcpy(&pActs[i * width], &oldActs[i * oldWidth],
-                       nCopy * sizeof(XkbAction));
-            }
-        }
-        i = xkb->map->key_sym_map[key].group_info;
-        i = XkbSetNumGroups(i, nGroups);
-        xkb->map->key_sym_map[key].group_info = i;
-        xkb->map->key_sym_map[key].width = width;
-    }
-    width = 0;
-    for (i = 0; i < nGroups; i++) {
-        xkb->map->key_sym_map[key].kt_index[i] = newTypes[i];
-        if (xkb->map->types[newTypes[i]].num_levels > width)
-            width = xkb->map->types[newTypes[i]].num_levels;
-    }
-    xkb->map->key_sym_map[key].width = width;
-    if (changes != NULL) {
-        if (changes->changed & XkbKeySymsMask) {
-            _XkbAddKeyChange(&changes->first_key_sym, &changes->num_key_syms,
-                             key);
-        }
-        else {
-            changes->changed |= XkbKeySymsMask;
-            changes->first_key_sym = key;
-            changes->num_key_syms = 1;
-        }
-    }
-    return Success;
-}
-
-/***====================================================================***/
-
-Bool
-XkbVirtualModsToReal(XkbDescPtr xkb, unsigned virtual_mask, unsigned *mask_rtrn)
-{
-    register int i, bit;
-    register unsigned mask;
-
-    if (xkb == NULL)
-        return False;
-    if (virtual_mask == 0) {
-        *mask_rtrn = 0;
-        return True;
-    }
-    if (xkb->server == NULL)
-        return False;
-    for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
-        if (virtual_mask & bit)
-            mask |= xkb->server->vmods[i];
-    }
-    *mask_rtrn = mask;
-    return True;
-}
-
-/***====================================================================***/
-
-Bool
-XkbUpdateActionVirtualMods(XkbDescPtr xkb, XkbAction *act, unsigned changed)
-{
-    unsigned int tmp;
-
-    switch (act->type) {
-    case XkbSA_SetMods:
-    case XkbSA_LatchMods:
-    case XkbSA_LockMods:
-        if (((tmp = XkbModActionVMods(&act->mods)) & changed) != 0) {
-            XkbVirtualModsToReal(xkb, tmp, &tmp);
-            act->mods.mask = act->mods.real_mods;
-            act->mods.mask |= tmp;
-            return True;
-        }
-        break;
-    case XkbSA_ISOLock:
-        if ((((tmp = XkbModActionVMods(&act->iso)) != 0) & changed) != 0) {
-            XkbVirtualModsToReal(xkb, tmp, &tmp);
-            act->iso.mask = act->iso.real_mods;
-            act->iso.mask |= tmp;
-            return True;
-        }
-        break;
-    }
-    return False;
-}
-
-void
-XkbUpdateKeyTypeVirtualMods(XkbDescPtr xkb,
-                            XkbKeyTypePtr type,
-                            unsigned int changed,
-                            XkbChangesPtr changes)
-{
-    register unsigned int i;
-    unsigned int mask = 0;
-
-    XkbVirtualModsToReal(xkb, type->mods.vmods, &mask);
-    type->mods.mask = type->mods.real_mods | mask;
-    if ((type->map_count > 0) && (type->mods.vmods != 0)) {
-        XkbKTMapEntryPtr entry;
-
-        for (i = 0, entry = type->map; i < type->map_count; i++, entry++) {
-            if (entry->mods.vmods != 0) {
-                XkbVirtualModsToReal(xkb, entry->mods.vmods, &mask);
-                entry->mods.mask = entry->mods.real_mods | mask;
-                /* entry is active if vmods are bound */
-                entry->active = (mask != 0);
-            }
-            else
-                entry->active = 1;
-        }
-    }
-    if (changes) {
-        int type_ndx;
-
-        type_ndx = type - xkb->map->types;
-        if ((type_ndx < 0) || (type_ndx > xkb->map->num_types))
-            return;
-        if (changes->map.changed & XkbKeyTypesMask) {
-            int last;
-
-            last = changes->map.first_type + changes->map.num_types - 1;
-            if (type_ndx < changes->map.first_type) {
-                changes->map.first_type = type_ndx;
-                changes->map.num_types = (last - type_ndx) + 1;
-            }
-            else if (type_ndx > last) {
-                changes->map.num_types =
-                    (type_ndx - changes->map.first_type) + 1;
-            }
-        }
-        else {
-            changes->map.changed |= XkbKeyTypesMask;
-            changes->map.first_type = type_ndx;
-            changes->map.num_types = 1;
-        }
-    }
-    return;
-}
-
-Bool
-XkbApplyVirtualModChanges(XkbDescPtr xkb,
-                          unsigned changed,
-                          XkbChangesPtr changes)
-{
-    register int i;
-    unsigned int checkState = 0;
-
-    if ((!xkb) || (!xkb->map) || (changed == 0))
-        return False;
-    for (i = 0; i < xkb->map->num_types; i++) {
-        if (xkb->map->types[i].mods.vmods & changed)
-            XkbUpdateKeyTypeVirtualMods(xkb, &xkb->map->types[i], changed,
-                                        changes);
-    }
-    if (changed & xkb->ctrls->internal.vmods) {
-        unsigned int newMask = 0;
-
-        XkbVirtualModsToReal(xkb, xkb->ctrls->internal.vmods, &newMask);
-        newMask |= xkb->ctrls->internal.real_mods;
-        if (xkb->ctrls->internal.mask != newMask) {
-            xkb->ctrls->internal.mask = newMask;
-            if (changes) {
-                changes->ctrls.changed_ctrls |= XkbInternalModsMask;
-                checkState = True;
-            }
-        }
-    }
-    if (changed & xkb->ctrls->ignore_lock.vmods) {
-        unsigned int newMask = 0;
-
-        XkbVirtualModsToReal(xkb, xkb->ctrls->ignore_lock.vmods, &newMask);
-        newMask |= xkb->ctrls->ignore_lock.real_mods;
-        if (xkb->ctrls->ignore_lock.mask != newMask) {
-            xkb->ctrls->ignore_lock.mask = newMask;
-            if (changes) {
-                changes->ctrls.changed_ctrls |= XkbIgnoreLockModsMask;
-                checkState = True;
-            }
-        }
-    }
-    if (xkb->indicators != NULL) {
-        XkbIndicatorMapPtr map;
-
-        map = &xkb->indicators->maps[0];
-        for (i = 0; i < XkbNumIndicators; i++, map++) {
-            if (map->mods.vmods & changed) {
-                unsigned int newMask = 0;
-
-                XkbVirtualModsToReal(xkb, map->mods.vmods, &newMask);
-                newMask |= map->mods.real_mods;
-                if (newMask != map->mods.mask) {
-                    map->mods.mask = newMask;
-                    if (changes) {
-                        changes->indicators.map_changes |= (1 << i);
-                        checkState = True;
-                    }
-                }
-            }
-        }
-    }
-    if (xkb->compat != NULL) {
-        XkbCompatMapPtr compat;
-
-        compat = xkb->compat;
-        for (i = 0; i < XkbNumKbdGroups; i++) {
-            unsigned int newMask = 0;
-
-            XkbVirtualModsToReal(xkb, compat->groups[i].vmods, &newMask);
-            newMask |= compat->groups[i].real_mods;
-            if (compat->groups[i].mask != newMask) {
-                compat->groups[i].mask = newMask;
-                if (changes) {
-                    changes->compat.changed_groups |= (1 << i);
-                    checkState = True;
-                }
-            }
-        }
-    }
-    if (xkb->map && xkb->server) {
-        int highChange = 0, lowChange = -1;
-
-        for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
-            if (XkbKeyHasActions(xkb, i)) {
-                register XkbAction *pAct;
-                register int n;
-
-                pAct = XkbKeyActionsPtr(xkb, i);
-                for (n = XkbKeyNumActions(xkb, i); n > 0; n--, pAct++) {
-                    if ((pAct->type != XkbSA_NoAction) &&
-                        XkbUpdateActionVirtualMods(xkb, pAct, changed)) {
-                        if (lowChange < 0)
-                            lowChange = i;
-                        highChange = i;
-                    }
-                }
-            }
-        }
-        if (changes && (lowChange > 0)) {       /* something changed */
-            if (changes->map.changed & XkbKeyActionsMask) {
-                int last;
-
-                if (changes->map.first_key_act < lowChange)
-                    lowChange = changes->map.first_key_act;
-                last =
-                    changes->map.first_key_act + changes->map.num_key_acts - 1;
-                if (last > highChange)
-                    highChange = last;
-            }
-            changes->map.changed |= XkbKeyActionsMask;
-            changes->map.first_key_act = lowChange;
-            changes->map.num_key_acts = (highChange - lowChange) + 1;
-        }
-    }
-    return checkState;
-}