xref: /xsrc/external/mit/libX11/dist/src/xkb/XKBBind.c

/*

Copyright 1985, 1987, 1994, 1998  The Open Group

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization
from The Open Group.

*/

        /* the new monsters ate the old ones */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "XKBlib.h"
#include <X11/Xlibint.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <stdio.h>
#include <ctype.h>

#include <X11/extensions/XKBproto.h>
#include "XKBlibint.h"

#ifdef USE_OWN_COMPOSE
#define COMPOSE_NO_CONST_MEMBERS
#include "imComp.h"
#endif

#define AllMods (ShiftMask|LockMask|ControlMask| \
                 Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)

static int _XkbLoadDpy(Display *dpy);

struct _XKeytrans {
    struct _XKeytrans *next;    /* next on list */
    char *string;               /* string to return when the time comes */
    int len;                    /* length of string (since NULL is legit) */
    KeySym key;                 /* keysym rebound */
    unsigned int state;         /* modifier state */
    KeySym *modifiers;          /* modifier keysyms you want */
    int mlen;                   /* length of modifier list */
};

KeySym
XkbKeycodeToKeysym(Display *dpy,
#if NeedWidePrototypes
                   unsigned int kc,
#else
                   KeyCode kc,
#endif
                   int group,
                   int level)
{
    XkbDescRec *xkb;

    if (_XkbUnavailable(dpy))
        return NoSymbol;

    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);

    xkb = dpy->xkb_info->desc;
    if ((kc < xkb->min_key_code) || (kc > xkb->max_key_code))
        return NoSymbol;

    if ((group < 0) || (level < 0) || (group >= XkbKeyNumGroups(xkb, kc)))
        return NoSymbol;
    if (level >= XkbKeyGroupWidth(xkb, kc, group)) {
        /* for compatibility with the core protocol, _always_ allow  */
        /* two symbols in the first two groups.   If either of the   */
        /* two is of type ONE_LEVEL, just replicate the first symbol */
        if ((group > XkbGroup2Index) || (XkbKeyGroupWidth(xkb, kc, group) != 1)
            || (level != 1)) {
            return NoSymbol;
        }
        level = 0;
    }
    return XkbKeySymEntry(xkb, kc, level, group);
}

KeySym
XKeycodeToKeysym(Display *dpy,
#if NeedWidePrototypes
                 unsigned int kc,
#else
                 KeyCode kc,
#endif
                 int col)
{
    XkbDescRec *xkb;

    if (_XkbUnavailable(dpy))
        return _XKeycodeToKeysym(dpy, kc, col);

    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);

    xkb = dpy->xkb_info->desc;
    if ((kc < xkb->min_key_code) || (kc > xkb->max_key_code))
        return NoSymbol;

    if (col > 3) {
        int lastSym, tmp, nGrp;

        lastSym = 3;
        nGrp = XkbKeyNumGroups(xkb, kc);
        if ((nGrp > 0) &&
            ((tmp = XkbKeyGroupWidth(xkb, kc, XkbGroup1Index)) > 2)) {
            if (col <= (lastSym + tmp - 2))
                return XkbKeycodeToKeysym(dpy, kc, XkbGroup1Index,
                                          col - lastSym + 2);
            lastSym += tmp - 2;
        }
        if ((nGrp > 1) &&
            ((tmp = XkbKeyGroupWidth(xkb, kc, XkbGroup2Index)) > 2)) {
            if (col <= (lastSym + tmp - 2))
                return XkbKeycodeToKeysym(dpy, kc, XkbGroup2Index,
                                          col - lastSym + 2);
            lastSym += tmp - 2;
        }
        if (nGrp > 2) {
            tmp = XkbKeyGroupWidth(xkb, kc, XkbGroup3Index);
            if (col <= lastSym + tmp)
                return XkbKeycodeToKeysym(dpy, kc, XkbGroup3Index,
                                          col - lastSym);
            lastSym += tmp;
        }
        if (nGrp > 3) {
            tmp = XkbKeyGroupWidth(xkb, kc, XkbGroup4Index);
            if (col <= lastSym + tmp)
                return XkbKeycodeToKeysym(dpy, kc, XkbGroup4Index,
                                          col - lastSym);
        }
        return NoSymbol;
    }
    return XkbKeycodeToKeysym(dpy, kc, (col >> 1), (col & 1));
}

KeyCode
XKeysymToKeycode(Display *dpy, KeySym ks)
{
    register int i, j, gotOne;

    if (_XkbUnavailable(dpy))
        return _XKeysymToKeycode(dpy, ks);
    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);

    j = 0;
    do {
        register XkbDescRec *xkb = dpy->xkb_info->desc;
        gotOne = 0;
        for (i = dpy->min_keycode; i <= dpy->max_keycode; i++) {
            if (j < (int) XkbKeyNumSyms(xkb, i)) {
                gotOne = 1;
                if ((XkbKeySym(xkb, i, j) == ks))
                    return i;
            }
        }
        j++;
    } while (gotOne);
    return 0;
}

static int
_XkbComputeModmap(Display *dpy)
{
    register XkbDescPtr xkb;

    xkb = dpy->xkb_info->desc;
    if (XkbGetUpdatedMap(dpy, XkbModifierMapMask, xkb) == Success)
        return 1;
    return 0;
}

unsigned
XkbKeysymToModifiers(Display *dpy, KeySym ks)
{
    XkbDescRec *xkb;
    register int i, j;
    register KeySym *pSyms;
    CARD8 mods;

    if (_XkbUnavailable(dpy))
        return _XKeysymToModifiers(dpy, ks);
    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);

    if (_XkbNeedModmap(dpy->xkb_info) && (!_XkbComputeModmap(dpy)))
        return _XKeysymToModifiers(dpy, ks);

    xkb = dpy->xkb_info->desc;
    mods = 0;
    for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) {
        pSyms = XkbKeySymsPtr(xkb, i);
        for (j = XkbKeyNumSyms(xkb, i) - 1; j >= 0; j--) {
            if (pSyms[j] == ks) {
                mods |= xkb->map->modmap[i];
                break;
            }
        }
    }
    return mods;
}

KeySym
XLookupKeysym(register XKeyEvent * event, int col)
{
    Display *dpy = event->display;

    if (_XkbUnavailable(dpy))
        return _XLookupKeysym(event, col);
    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);
    return XKeycodeToKeysym(dpy, event->keycode, col);
}

   /*
    * Not a public entry point -- XkbTranslateKey is an obsolete name
    * that is preserved here so that functions linked against the old
    * version will continue to work in a shared library environment.
    */
int
XkbTranslateKey(register Display *dpy,
                KeyCode key,
                register unsigned int mods,
                unsigned int *mods_rtrn,
                KeySym *keysym_rtrn);

int
XkbTranslateKey(register Display *dpy,
                KeyCode key,
                register unsigned int mods,
                unsigned int *mods_rtrn,
                KeySym *keysym_rtrn)
{
    return XkbLookupKeySym(dpy, key, mods, mods_rtrn, keysym_rtrn);
}

Bool
XkbLookupKeySym(register Display *dpy,
                KeyCode key,
                register unsigned int mods,
                unsigned int *mods_rtrn,
                KeySym *keysym_rtrn)
{
    if (_XkbUnavailable(dpy))
        return _XTranslateKey(dpy, key, mods, mods_rtrn, keysym_rtrn);
    _XkbCheckPendingRefresh(dpy, dpy->xkb_info);
    return XkbTranslateKeyCode(dpy->xkb_info->desc, key, mods, mods_rtrn,
                               keysym_rtrn);
}

Bool
XkbTranslateKeyCode(register XkbDescPtr xkb,
                    KeyCode key,
                    register unsigned int mods,
                    unsigned int *mods_rtrn,
                    KeySym *keysym_rtrn)
{
    XkbKeyTypeRec *type;
    int col, nKeyGroups;
    unsigned preserve, effectiveGroup;
    KeySym *syms;

    if (mods_rtrn != NULL)
        *mods_rtrn = 0;

    nKeyGroups = XkbKeyNumGroups(xkb, key);
    if ((!XkbKeycodeInRange(xkb, key)) || (nKeyGroups == 0)) {
        if (keysym_rtrn != NULL)
            *keysym_rtrn = NoSymbol;
        return False;
    }

    syms = XkbKeySymsPtr(xkb, key);

    /* find the offset of the effective group */
    col = 0;
    effectiveGroup = XkbGroupForCoreState(mods);
    if (effectiveGroup >= nKeyGroups) {
        unsigned groupInfo = XkbKeyGroupInfo(xkb, key);

        switch (XkbOutOfRangeGroupAction(groupInfo)) {
        default:
            effectiveGroup %= nKeyGroups;
            break;
        case XkbClampIntoRange:
            effectiveGroup = nKeyGroups - 1;
            break;
        case XkbRedirectIntoRange:
            effectiveGroup = XkbOutOfRangeGroupNumber(groupInfo);
            if (effectiveGroup >= nKeyGroups)
                effectiveGroup = 0;
            break;
        }
    }
    col = effectiveGroup * XkbKeyGroupsWidth(xkb, key);
    type = XkbKeyKeyType(xkb, key, effectiveGroup);

    preserve = 0;
    if (type->map) {  /* find the column (shift level) within the group */
        register int i;
        register XkbKTMapEntryPtr entry;

        for (i = 0, entry = type->map; i < type->map_count; i++, entry++) {
            if ((entry->active) &&
                ((mods & type->mods.mask) == entry->mods.mask)) {
                col += entry->level;
                if (type->preserve)
                    preserve = type->preserve[i].mask;
                break;
            }
        }
    }

    if (keysym_rtrn != NULL)
        *keysym_rtrn = syms[col];
    if (mods_rtrn) {
        *mods_rtrn = type->mods.mask & (~preserve);
        /* The Motif VTS doesn't get the help callback called if help
         * is bound to Shift+<whatever>, and it appears as though it
         * is XkbTranslateKeyCode that is causing the problem.  The
         * core X version of XTranslateKey always OR's in ShiftMask
         * and LockMask for mods_rtrn, so this "fix" keeps this behavior
         * and solves the VTS problem.
         */
        if ((xkb->dpy) && (xkb->dpy->xkb_info) &&
            (xkb->dpy->xkb_info->
             xlib_ctrls & XkbLC_AlwaysConsumeShiftAndLock)) {
            *mods_rtrn |= (ShiftMask | LockMask);
        }
    }
    return (syms[col] != NoSymbol);
}

Status
XkbRefreshKeyboardMapping(register XkbMapNotifyEvent * event)
{
    Display *dpy = event->display;
    XkbInfoPtr xkbi;

    if (_XkbUnavailable(dpy)) {
        _XRefreshKeyboardMapping((XMappingEvent *) event);
        return Success;
    }
    xkbi = dpy->xkb_info;

    if (((event->type & 0x7f) - xkbi->codes->first_event) != XkbEventCode)
        return BadMatch;
    if (event->xkb_type == XkbNewKeyboardNotify) {
        _XkbReloadDpy(dpy);
        return Success;
    }
    if (event->xkb_type == XkbMapNotify) {
        XkbMapChangesRec changes;
        Status rtrn;

        if (xkbi->flags & XkbMapPending)
            changes = xkbi->changes;
        else
            bzero(&changes, sizeof(changes));
        XkbNoteMapChanges(&changes, event, XKB_XLIB_MAP_MASK);
        if ((rtrn = XkbGetMapChanges(dpy, xkbi->desc, &changes)) != Success) {
#ifdef DEBUG
            fprintf(stderr, "Internal Error! XkbGetMapChanges failed:\n");
#endif
            xkbi->changes = changes;
        }
        else if (xkbi->flags & XkbMapPending) {
            xkbi->flags &= ~XkbMapPending;
            bzero(&xkbi->changes, sizeof(XkbMapChangesRec));
        }
        return rtrn;
    }
    return BadMatch;
}

int
XRefreshKeyboardMapping(register XMappingEvent * event)
{
    XkbEvent *xkbevent = (XkbEvent *) event;
    Display *dpy = event->display;
    XkbMapChangesRec changes;
    XkbInfoPtr xkbi;

    /* always do this for input methods, which still use the old keymap */
    (void) _XRefreshKeyboardMapping(event);

    if (_XkbUnavailable(dpy))
        return 1;

    xkbi = dpy->xkb_info;

    if (((event->type & 0x7f) - xkbi->codes->first_event) == XkbEventCode)
        return XkbRefreshKeyboardMapping(&xkbevent->map);

    if (xkbi->flags & XkbXlibNewKeyboard) {
        _XkbReloadDpy(dpy);
        return 1;
    }

    if ((xkbi->flags & XkbMapPending) || (event->request == MappingKeyboard)) {
        if (xkbi->flags & XkbMapPending) {
            changes = xkbi->changes;
            _XkbNoteCoreMapChanges(&changes, event, XKB_XLIB_MAP_MASK);
        }
        else {
            bzero(&changes, sizeof(changes));
            changes.changed = XkbKeySymsMask;
            if (xkbi->desc->min_key_code < xkbi->desc->max_key_code) {
                changes.first_key_sym = xkbi->desc->min_key_code;
                changes.num_key_syms = xkbi->desc->max_key_code -
                    xkbi->desc->min_key_code + 1;
            }
            else {
                changes.first_key_sym = event->first_keycode;
                changes.num_key_syms = event->count;
            }
        }

        if (XkbGetMapChanges(dpy, xkbi->desc, &changes) != Success) {
#ifdef DEBUG
            fprintf(stderr, "Internal Error! XkbGetMapChanges failed:\n");
            if (changes.changed & XkbKeyTypesMask) {
                int first = changes.first_type;
                int last = changes.first_type + changes.num_types - 1;

                fprintf(stderr, "       types:  %d..%d\n", first, last);
            }
            if (changes.changed & XkbKeySymsMask) {
                int first = changes.first_key_sym;
                int last = changes.first_key_sym + changes.num_key_syms - 1;

                fprintf(stderr, "     symbols:  %d..%d\n", first, last);
            }
            if (changes.changed & XkbKeyActionsMask) {
                int first = changes.first_key_act;
                int last = changes.first_key_act + changes.num_key_acts - 1;

                fprintf(stderr, "     acts:  %d..%d\n", first, last);
            }
            if (changes.changed & XkbKeyBehaviorsMask) {
                int first = changes.first_key_behavior;
                int last = first + changes.num_key_behaviors - 1;

                fprintf(stderr, "   behaviors:  %d..%d\n", first, last);
            }
            if (changes.changed & XkbVirtualModsMask) {
                fprintf(stderr, "virtual mods: 0x%04x\n", changes.vmods);
            }
            if (changes.changed & XkbExplicitComponentsMask) {
                int first = changes.first_key_explicit;
                int last = first + changes.num_key_explicit - 1;

                fprintf(stderr, "    explicit:  %d..%d\n", first, last);
            }
#endif
        }
        LockDisplay(dpy);
        if (xkbi->flags & XkbMapPending) {
            xkbi->flags &= ~XkbMapPending;
            bzero(&xkbi->changes, sizeof(XkbMapChangesRec));
        }
        UnlockDisplay(dpy);
    }
    if (event->request == MappingModifier) {
        LockDisplay(dpy);
        if (xkbi->desc->map->modmap) {
            _XkbFree(xkbi->desc->map->modmap);
            xkbi->desc->map->modmap = NULL;
        }
        if (dpy->key_bindings) {
            register struct _XKeytrans *p;

            for (p = dpy->key_bindings; p; p = p->next) {
                register int i;

                p->state = 0;
                if (p->mlen > 0) {
                    for (i = 0; i < p->mlen; i++) {
                        p->state |= XkbKeysymToModifiers(dpy, p->modifiers[i]);
                    }
                    if (p->state)
                        p->state &= AllMods;
                    else
                        p->state = AnyModifier;
                }
            }
        }
        UnlockDisplay(dpy);
    }
    return 1;
}

static int
_XkbLoadDpy(Display *dpy)
{
    XkbInfoPtr xkbi;
    unsigned query, oldEvents;
    XkbDescRec *desc;

    if (!XkbUseExtension(dpy, NULL, NULL))
        return 0;

    xkbi = dpy->xkb_info;
    query = XkbAllClientInfoMask;
    desc = XkbGetMap(dpy, query, XkbUseCoreKbd);
    if (!desc) {
#ifdef DEBUG
        fprintf(stderr, "Warning! XkbGetMap failed!\n");
#endif
        return 0;
    }
    LockDisplay(dpy);
    xkbi->desc = desc;

    UnlockDisplay(dpy);
    oldEvents = xkbi->selected_events;
    if (!(xkbi->xlib_ctrls & XkbLC_IgnoreNewKeyboards)) {
        XkbSelectEventDetails(dpy, xkbi->desc->device_spec,
                              XkbNewKeyboardNotify,
                              XkbNKN_KeycodesMask | XkbNKN_DeviceIDMask,
                              XkbNKN_KeycodesMask | XkbNKN_DeviceIDMask);
    }
    XkbSelectEventDetails(dpy, xkbi->desc->device_spec, XkbMapNotify,
                          XkbAllClientInfoMask, XkbAllClientInfoMask);
    LockDisplay(dpy);
    xkbi->selected_events = oldEvents;
    UnlockDisplay(dpy);
    return 1;
}

void
_XkbReloadDpy(Display *dpy)
{
    XkbInfoPtr xkbi;
    XkbDescRec *desc;
    unsigned oldDeviceID;

    if (_XkbUnavailable(dpy))
        return;

    xkbi = dpy->xkb_info;
    LockDisplay(dpy);
    if (xkbi->desc) {
        oldDeviceID = xkbi->desc->device_spec;
        XkbFreeKeyboard(xkbi->desc, XkbAllComponentsMask, True);
        xkbi->desc = NULL;
        xkbi->flags &= ~(XkbMapPending | XkbXlibNewKeyboard);
        xkbi->changes.changed = 0;
    }
    else
        oldDeviceID = XkbUseCoreKbd;
    UnlockDisplay(dpy);
    desc = XkbGetMap(dpy, XkbAllClientInfoMask, XkbUseCoreKbd);
    if (!desc)
        return;
    LockDisplay(dpy);
    xkbi->desc = desc;
    UnlockDisplay(dpy);

    if (desc->device_spec != oldDeviceID) {
        /* transfer(?) event masks here */
#ifdef NOTYET
        unsigned oldEvents;

        oldEvents = xkbi->selected_events;
        XkbSelectEventDetails(dpy, xkbi->desc->device_spec, XkbMapNotify,
                              XkbAllMapComponentsMask, XkbAllClientInfoMask);
        LockDisplay(dpy);
        xkbi->selected_events = oldEvents;
        UnlockDisplay(dpy);
#endif
    }
    return;
}

int
XkbTranslateKeySym(register Display *dpy,
                   register KeySym *sym_rtrn,
                   unsigned int mods,
                   char *buffer,
                   int nbytes,
                   int *extra_rtrn)
{
    register XkbInfoPtr xkb;
    XkbKSToMBFunc cvtr;
    XPointer priv;
    char tmp[4];
    int n;

    xkb = dpy->xkb_info;
    if (!xkb->cvt.KSToMB) {
        _XkbGetConverters(_XkbGetCharset(), &xkb->cvt);
        _XkbGetConverters("ISO8859-1", &xkb->latin1cvt);
    }

    if (extra_rtrn)
        *extra_rtrn = 0;

    if ((buffer == NULL) || (nbytes == 0)) {
        buffer = tmp;
        nbytes = 4;
    }

    /* see if symbol rebound, if so, return that string. */
    n = XkbLookupKeyBinding(dpy, *sym_rtrn, mods, buffer, nbytes, extra_rtrn);
    if (n)
        return n;

    if (nbytes > 0)
        buffer[0] = '\0';

    if (xkb->cvt.KSToUpper && (mods & LockMask)) {
        *sym_rtrn = (*xkb->cvt.KSToUpper) (*sym_rtrn);
    }
    if (xkb->xlib_ctrls & XkbLC_ForceLatin1Lookup) {
        cvtr = xkb->latin1cvt.KSToMB;
        priv = xkb->latin1cvt.KSToMBPriv;
    }
    else {
        cvtr = xkb->cvt.KSToMB;
        priv = xkb->cvt.KSToMBPriv;
    }

    n = (*cvtr) (priv, *sym_rtrn, buffer, nbytes, extra_rtrn);

    if ((!xkb->cvt.KSToUpper) && (mods & LockMask)) {
        register int i;
        int change;

        for (i = change = 0; i < n; i++) {
            char ch = toupper(buffer[i]);
            change = (change || (buffer[i] != ch));
            buffer[i] = ch;
        }
        if (change) {
            if (n == 1)
                *sym_rtrn =
                    (*xkb->cvt.MBToKS) (xkb->cvt.MBToKSPriv, buffer, n, NULL);
            else
                *sym_rtrn = NoSymbol;
        }
    }

    if (mods & ControlMask) {
        if (n == 1) {
            buffer[0] = XkbToControl(buffer[0]);
            if (nbytes > 1)
                buffer[1] = '\0';
            return 1;
        }
        if (nbytes > 0)
            buffer[0] = '\0';
        return 0;
    }
    return n;
}

int
XLookupString(register XKeyEvent *event,
              char *buffer,
              int nbytes,
              KeySym *keysym,
              XComposeStatus *status)
{
    KeySym dummy;
    int rtrnLen;
    unsigned int new_mods;
    Display *dpy = event->display;

    if (keysym == NULL)
        keysym = &dummy;
    if (!XkbLookupKeySym(dpy, event->keycode, event->state, &new_mods, keysym))
        return 0;
    new_mods = (event->state & (~new_mods));

    /* find the group where a symbol can be converted to control one */
    if (new_mods & ControlMask && *keysym > 0x7F &&
        (dpy->xkb_info->xlib_ctrls & XkbLC_ControlFallback)) {
        XKeyEvent tmp_ev = *event;
        KeySym tmp_keysym;
        unsigned int tmp_new_mods;

        if (_XkbUnavailable(dpy)) {
            tmp_ev.state = event->state ^ dpy->mode_switch;
            if (XkbLookupKeySym(dpy, tmp_ev.keycode, tmp_ev.state,
                                &tmp_new_mods, &tmp_keysym) &&
                tmp_keysym != NoSymbol && tmp_keysym < 0x80) {
                *keysym = tmp_keysym;
            }
        }
        else {
            int n = XkbKeyNumGroups(dpy->xkb_info->desc, tmp_ev.keycode);
            int i;

            for (i = 0; i < n; i++) {
                if (XkbGroupForCoreState(event->state) == i)
                    continue;
                tmp_ev.state = XkbBuildCoreState(tmp_ev.state, i);
                if (XkbLookupKeySym(dpy, tmp_ev.keycode, tmp_ev.state,
                                    &tmp_new_mods, &tmp_keysym) &&
                    tmp_keysym != NoSymbol && tmp_keysym < 0x80) {
                    *keysym = tmp_keysym;
                    new_mods = (event->state & (~tmp_new_mods));
                    break;
                }
            }
        }
    }

#ifdef USE_OWN_COMPOSE
    if (status) {
        static int been_here = 0;

        if (!been_here) {
            XimCompInitTables();
            been_here = 1;
        }
        if (!XimCompLegalStatus(status)) {
            status->compose_ptr = NULL;
            status->chars_matched = 0;
        }
        if (((status->chars_matched > 0) && (status->compose_ptr != NULL)) ||
            XimCompIsComposeKey(*keysym, event->keycode, status)) {
            XimCompRtrn rtrn;

            switch (XimCompProcessSym(status, *keysym, &rtrn)) {
            case XIM_COMP_IGNORE:
                break;
            case XIM_COMP_IN_PROGRESS:
                if (keysym != NULL)
                    *keysym = NoSymbol;
#ifndef NO_COMPOSE_LED
                if (dpy->xkb_info->xlib_ctrls & XkbLC_ComposeLED) {
                    XkbSetNamedIndicator(dpy, dpy->xkb_info->composeLED,
                                         True, True, False, NULL);
                }
#endif
                return 0;
            case XIM_COMP_FAIL:
            {
                static Atom _ComposeFail = None;
                int n = 0, len = 0;

#ifndef NO_COMPOSE_LED
                if (dpy->xkb_info->xlib_ctrls & XkbLC_ComposeLED) {
                    XkbSetNamedIndicator(dpy, dpy->xkb_info->composeLED,
                                         True, False, False, NULL);
                }
#endif
#ifndef NO_BELL_ON_COMPOSE_FAIL
                if (dpy->xkb_info->xlib_ctrls & XkbLC_BeepOnComposeFail) {
                    if (_ComposeFail == None)
                        _ComposeFail = XInternAtom(dpy, "ComposeFail", 0);
                    XkbBell(dpy, event->window, 0, _ComposeFail);
                }
#endif
                for (n = len = 0; rtrn.sym[n] != XK_VoidSymbol; n++) {
                    if (nbytes - len > 0) {
                        len += XkbTranslateKeySym(dpy, &rtrn.sym[n], new_mods,
                                                  buffer + len, nbytes - len,
                                                  NULL);
                    }
                }
                if (keysym != NULL) {
                    if (n == 1)
                        *keysym = rtrn.sym[0];
                    else
                        *keysym = NoSymbol;
                }
                return len;
            }
            case XIM_COMP_SUCCEED:
            {
                int len, n = 0;

#ifndef NO_COMPOSE_LED
                if (dpy->xkb_info->xlib_ctrls & XkbLC_ComposeLED) {
                    XkbSetNamedIndicator(dpy, dpy->xkb_info->composeLED,
                                         True, False, False, NULL);
                }
#endif
                *keysym = rtrn.matchSym;
                if (rtrn.str[0] != '\0') {
                    strncpy(buffer, rtrn.str, nbytes - 1);
                    buffer[nbytes - 1] = '\0';
                    len = (int) strlen(buffer);
                }
                else {
                    len = XkbTranslateKeySym(dpy, keysym, new_mods,
                                             buffer, nbytes, NULL);
                }
                for (n = 0; rtrn.sym[n] != XK_VoidSymbol; n++) {
                    if (nbytes - len > 0) {
                        len += XkbTranslateKeySym(dpy, &rtrn.sym[n],
                                                  event->state,
                                                  buffer + len, nbytes - len,
                                                  NULL);
                    }
                }
                return len;
            }
            }
        }
    }
#endif

    /* We *should* use the new_mods (which does not contain any modifiers */
    /* that were used to compute the symbol here, but pre-XKB XLookupString */
    /* did not and we have to remain compatible.  Sigh. */
    if (_XkbUnavailable(dpy) ||
        (dpy->xkb_info->xlib_ctrls & XkbLC_ConsumeLookupMods) == 0)
        new_mods = event->state;

    rtrnLen = XkbLookupKeyBinding(dpy, *keysym, new_mods, buffer, nbytes, NULL);
    if (rtrnLen > 0)
        return rtrnLen;

    return XkbTranslateKeySym(dpy, keysym, new_mods, buffer, nbytes, NULL);
}


int
XkbLookupKeyBinding(Display *dpy,
                    register KeySym sym,
                    unsigned int mods,
                    char *buffer,
                    int nbytes,
                    int *extra_rtrn)
{
    register struct _XKeytrans *p;

    if (extra_rtrn)
        *extra_rtrn = 0;
    for (p = dpy->key_bindings; p; p = p->next) {
        if (((mods & AllMods) == p->state) && (sym == p->key)) {
            int tmp = p->len;

            if (tmp > nbytes) {
                if (extra_rtrn)
                    *extra_rtrn = (tmp - nbytes);
                tmp = nbytes;
            }
            memcpy(buffer, p->string, tmp);
            if (tmp < nbytes)
                buffer[tmp] = '\0';
            return tmp;
        }
    }
    return 0;
}

char
XkbToControl(char ch)
{
    register char c = ch;

    if ((c >= '@' && c < '\177') || c == ' ')
        c &= 0x1F;
    else if (c == '2')
        c = '\000';
    else if (c >= '3' && c <= '7')
        c -= ('3' - '\033');
    else if (c == '8')
        c = '\177';
    else if (c == '/')
        c = '_' & 0x1F;
    return c;
}