dos -> unix

18 files changed, 9010 insertions, 9010 deletions

diff --git a/libX11/src/xkb/Makefile.am b/libX11/src/xkb/Makefile.am
index ba21bbc7b..cde2afbf9 100644
--- a/libX11/src/xkb/Makefile.am
+++ b/libX11/src/xkb/Makefile.am
@@ -1,52 +1,52 @@
-AM_CPPFLAGS= \

-	-I$(top_srcdir)/include \

-	-I$(top_srcdir)/include/X11 \

-	-I$(top_builddir)/include \

-	-I$(top_builddir)/include/X11 \

-	-I$(top_srcdir)/src/xcms \

-	-I$(top_srcdir)/src/xkb \

-	-I$(top_srcdir)/src/xlibi18n \

-	-D_BSD_SOURCE

-

-AM_CFLAGS= \

-	$(X11_CFLAGS) \

-	$(BIGFONT_CFLAGS) \

-	$(XMALLOC_ZERO_CFLAGS) \

-	$(CWARNFLAGS)

-

-noinst_LTLIBRARIES = libxkb.la

-

-libxkb_la_SOURCES = \

-	XKB.c \

-	XKBBind.c \

-	XKBCompat.c \

-	XKBCtrls.c \

-	XKBCvt.c \

-	XKBGetMap.c \

-	XKBGetByName.c \

-	XKBNames.c \

-	XKBRdBuf.c \

-	XKBSetMap.c \

-	XKBUse.c \

-	XKBleds.c \

-	XKBBell.c \

-	XKBGeom.c \

-	XKBSetGeom.c \

-	XKBExtDev.c \

-	XKBList.c \

-	XKBMisc.c \

-	XKBMAlloc.c \

-	XKBGAlloc.c \

-	XKBAlloc.c \

-	XKBlibint.h

-

-if LINT

-# Check source code with tools like lint & sparse

-

-ALL_LINT_FLAGS=$(LINT_FLAGS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \

-		$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS)

-

-lint:

-	$(LINT) $(ALL_LINT_FLAGS) $(libxkb_la_SOURCES) -lm

-

-endif LINT

+AM_CPPFLAGS= \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/include/X11 \
+	-I$(top_builddir)/include \
+	-I$(top_builddir)/include/X11 \
+	-I$(top_srcdir)/src/xcms \
+	-I$(top_srcdir)/src/xkb \
+	-I$(top_srcdir)/src/xlibi18n \
+	-D_BSD_SOURCE
+
+AM_CFLAGS= \
+	$(X11_CFLAGS) \
+	$(BIGFONT_CFLAGS) \
+	$(XMALLOC_ZERO_CFLAGS) \
+	$(CWARNFLAGS)
+
+noinst_LTLIBRARIES = libxkb.la
+
+libxkb_la_SOURCES = \
+	XKB.c \
+	XKBBind.c \
+	XKBCompat.c \
+	XKBCtrls.c \
+	XKBCvt.c \
+	XKBGetMap.c \
+	XKBGetByName.c \
+	XKBNames.c \
+	XKBRdBuf.c \
+	XKBSetMap.c \
+	XKBUse.c \
+	XKBleds.c \
+	XKBBell.c \
+	XKBGeom.c \
+	XKBSetGeom.c \
+	XKBExtDev.c \
+	XKBList.c \
+	XKBMisc.c \
+	XKBMAlloc.c \
+	XKBGAlloc.c \
+	XKBAlloc.c \
+	XKBlibint.h
+
+if LINT
+# Check source code with tools like lint & sparse
+
+ALL_LINT_FLAGS=$(LINT_FLAGS) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+		$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS)
+
+lint:
+	$(LINT) $(ALL_LINT_FLAGS) $(libxkb_la_SOURCES) -lm
+
+endif LINT
diff --git a/libX11/src/xkb/XKBAlloc.c b/libX11/src/xkb/XKBAlloc.c
index 7a46ef2b9..05e9f7315 100644
--- a/libX11/src/xkb/XKBAlloc.c
+++ b/libX11/src/xkb/XKBAlloc.c
@@ -1,498 +1,498 @@
-/************************************************************

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

-#include <dix-config.h>

-#elif defined(HAVE_CONFIG_H)

-#include <config.h>

-#endif

-

-#ifndef XKB_IN_SERVER

-

-#include <stdio.h>

-#include "Xlibint.h"

-#include "XKBlibint.h"

-#include <X11/extensions/XKBgeom.h>

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-#else

-

-#include <stdio.h>

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "inputstr.h"

-#include <X11/extensions/XKBsrv.h>

-#include <X11/extensions/XKBgeom.h>

-

-#endif /* XKB_IN_SERVER */

-

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

-

-/*ARGSUSED*/

-Status

-XkbAllocCompatMap(XkbDescPtr xkb,unsigned which,unsigned nSI)

-{

-XkbCompatMapPtr	compat;

-XkbSymInterpretRec *prev_interpret;

-

-    if (!xkb)

-	return BadMatch;

-    if (xkb->compat) {

-	if (xkb->compat->size_si>=nSI)

-	    return Success;

-	compat= xkb->compat;

-	compat->size_si= nSI;

-	if (compat->sym_interpret==NULL)

-	    compat->num_si= 0;

-	prev_interpret = compat->sym_interpret;

-	compat->sym_interpret= _XkbTypedRealloc(compat->sym_interpret,

-						     nSI,XkbSymInterpretRec);

-	if (compat->sym_interpret==NULL) {

-	    _XkbFree(prev_interpret);

-	    compat->size_si= compat->num_si= 0;

-	    return BadAlloc;

-	}

-	if (compat->num_si!=0) {

-	    _XkbClearElems(compat->sym_interpret,compat->num_si,

-					compat->size_si-1,XkbSymInterpretRec);

-	}

-	return Success;

-    }

-    compat= _XkbTypedCalloc(1,XkbCompatMapRec);

-    if (compat==NULL)

-	return BadAlloc;

-    if (nSI>0) {

-	compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec);

-	if (!compat->sym_interpret) {

-	    _XkbFree(compat);

-	    return BadAlloc;

-	}

-    }

-    compat->size_si= nSI;

-    compat->num_si= 0;

-    bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));

-    xkb->compat= compat;

-    return Success;

-}

-

-

-void

-XkbFreeCompatMap(XkbDescPtr xkb,unsigned which,Bool freeMap)

-{

-register XkbCompatMapPtr compat;

-

-    if ((xkb==NULL)||(xkb->compat==NULL))

-	return;

-    compat= xkb->compat;

-    if (freeMap)

-	which= XkbAllCompatMask;

-    if (which&XkbGroupCompatMask)

-	bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));

-    if (which&XkbSymInterpMask) {

-	if ((compat->sym_interpret)&&(compat->size_si>0))

-	    _XkbFree(compat->sym_interpret);

-	compat->size_si= compat->num_si= 0;

-	compat->sym_interpret= NULL;

-    }

-    if (freeMap) {

-	_XkbFree(compat);

-	xkb->compat= NULL;

-    }

-    return;

-}

-

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

-

-Status

-XkbAllocNames(XkbDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)

-{

-XkbNamesPtr	names;

-

-    if (xkb==NULL)

-	return BadMatch;

-    if (xkb->names==NULL) {

-	xkb->names = _XkbTypedCalloc(1,XkbNamesRec);

-	if (xkb->names==NULL)

-	    return BadAlloc;

-    }

-    names= xkb->names;

-    if ((which&XkbKTLevelNamesMask)&&(xkb->map!=NULL)&&(xkb->map->types!=NULL)){

-	register int	i;

-	XkbKeyTypePtr	type;

-

-	type= xkb->map->types;

-	for (i=0;i<xkb->map->num_types;i++,type++) {

-	    if (type->level_names==NULL) {

-		type->level_names= _XkbTypedCalloc(type->num_levels,Atom);

-		if (type->level_names==NULL)

-		    return BadAlloc;

-	    }

-	}

-    }

-    if ((which&XkbKeyNamesMask)&&(names->keys==NULL)) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadValue;

-	names->keys= _XkbTypedCalloc((xkb->max_key_code+1),XkbKeyNameRec);

-	if (names->keys==NULL)

-	    return BadAlloc;

-    }

-    if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {

-	if (names->key_aliases==NULL) {

-	    names->key_aliases= _XkbTypedCalloc(nTotalAliases,XkbKeyAliasRec);

-	}

-	else if (nTotalAliases>names->num_key_aliases) {

-	    XkbKeyAliasRec *prev_aliases = names->key_aliases;

-

-	    names->key_aliases= _XkbTypedRealloc(names->key_aliases,

-						nTotalAliases,XkbKeyAliasRec);

-	    if (names->key_aliases!=NULL) {

-		_XkbClearElems(names->key_aliases,names->num_key_aliases,

-						nTotalAliases-1,XkbKeyAliasRec);

-	    } else {

-		_XkbFree(prev_aliases);

-	    }

-	}

-	if (names->key_aliases==NULL) {

-	    names->num_key_aliases= 0;

-	    return BadAlloc;

-	}

-	names->num_key_aliases= nTotalAliases;

-    }

-    if ((which&XkbRGNamesMask)&&(nTotalRG>0)) {

-	if (names->radio_groups==NULL) {

-	    names->radio_groups= _XkbTypedCalloc(nTotalRG,Atom);

-	}

-	else if (nTotalRG>names->num_rg) {

-	    Atom *prev_radio_groups = names->radio_groups;

-

-	    names->radio_groups= _XkbTypedRealloc(names->radio_groups,nTotalRG,

-									Atom);

-	    if (names->radio_groups!=NULL) {

-		_XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1,

-									Atom);

-	    } else {

-		_XkbFree(prev_radio_groups);

-	    }

-	}

-	if (names->radio_groups==NULL)

-	    return BadAlloc;

-	names->num_rg= nTotalRG;

-    }

-    return Success;

-}

-

-void

-XkbFreeNames(XkbDescPtr xkb,unsigned which,Bool freeMap)

-{

-XkbNamesPtr	names;

-

-    if ((xkb==NULL)||(xkb->names==NULL))

-	return;

-    names= xkb->names;

-    if (freeMap)

-	which= XkbAllNamesMask;

-    if (which&XkbKTLevelNamesMask) {

-	XkbClientMapPtr	map= xkb->map;

-	if ((map!=NULL)&&(map->types!=NULL)) {

-	    register int 		i;

-	    register XkbKeyTypePtr	type;

-	    type= map->types;

-	    for (i=0;i<map->num_types;i++,type++) {

-		if (type->level_names!=NULL) {

-		    _XkbFree(type->level_names);

-		    type->level_names= NULL;

-		}

-	    }

-	}

-    }

-    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {

-	_XkbFree(names->keys);

-	names->keys= NULL;

-	names->num_keys= 0;

-    }

-    if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){

-	_XkbFree(names->key_aliases);

-	names->key_aliases=NULL;

-	names->num_key_aliases=0;

-    }

-    if ((which&XkbRGNamesMask)&&(names->radio_groups)) {

-	_XkbFree(names->radio_groups);

-	names->radio_groups= NULL;

-	names->num_rg= 0;

-    }

-    if (freeMap) {

-	_XkbFree(names);

-	xkb->names= NULL;

-    }

-    return;

-}

-

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

-

-/*ARGSUSED*/

-Status

-XkbAllocControls(XkbDescPtr xkb,unsigned which)

-{

-    if (xkb==NULL)

-	return BadMatch;

-

-    if (xkb->ctrls==NULL) {

-	xkb->ctrls= _XkbTypedCalloc(1,XkbControlsRec);

-	if (!xkb->ctrls)

-	    return BadAlloc;

-    }

-    return Success;

-}

-

-/*ARGSUSED*/

-void

-XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)

-{

-    if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {

-	_XkbFree(xkb->ctrls);

-	xkb->ctrls= NULL;

-    }

-    return;

-}

-

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

-

-Status

-XkbAllocIndicatorMaps(XkbDescPtr xkb)

-{

-    if (xkb==NULL)

-	return BadMatch;

-    if (xkb->indicators==NULL) {

-	xkb->indicators= _XkbTypedCalloc(1,XkbIndicatorRec);

-	if (!xkb->indicators)

-	    return BadAlloc;

-    }

-    return Success;

-}

-

-void

-XkbFreeIndicatorMaps(XkbDescPtr xkb)

-{

-    if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {

-	_XkbFree(xkb->indicators);

-	xkb->indicators= NULL;

-    }

-    return;

-}

-

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

-

-XkbDescRec	*

-XkbAllocKeyboard(void)

-{

-XkbDescRec *xkb;

-

-    xkb = _XkbTypedCalloc(1,XkbDescRec);

-    if (xkb)

-	xkb->device_spec= XkbUseCoreKbd;

-    return xkb;

-}

-

-void

-XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)

-{

-    if (xkb==NULL)

-	return;

-    if (freeAll)

-	which= XkbAllComponentsMask;

-    if (which&XkbClientMapMask)

-	XkbFreeClientMap(xkb,XkbAllClientInfoMask,True);

-    if (which&XkbServerMapMask)

-	XkbFreeServerMap(xkb,XkbAllServerInfoMask,True);

-    if (which&XkbCompatMapMask)

-	XkbFreeCompatMap(xkb,XkbAllCompatMask,True);

-    if (which&XkbIndicatorMapMask)

-	XkbFreeIndicatorMaps(xkb);

-    if (which&XkbNamesMask)

-	XkbFreeNames(xkb,XkbAllNamesMask,True);

-    if ((which&XkbGeometryMask) && (xkb->geom!=NULL))

-	XkbFreeGeometry(xkb->geom,XkbGeomAllMask,True);

-    if (which&XkbControlsMask)

-	XkbFreeControls(xkb,XkbAllControlsMask,True);

-    if (freeAll)

-	_XkbFree(xkb);

-    return;

-}

-

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

-

-XkbDeviceLedInfoPtr

-XkbAddDeviceLedInfo(XkbDeviceInfoPtr devi,unsigned ledClass,unsigned ledId)

-{

-XkbDeviceLedInfoPtr	devli;

-register int		i;

-

-    if ((!devi)||(!XkbSingleXIClass(ledClass))||(!XkbSingleXIId(ledId)))

-	return NULL;

-    for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {

-	if ((devli->led_class==ledClass)&&(devli->led_id==ledId))

-	    return devli;

-    }

-    if (devi->num_leds>=devi->sz_leds) {

-	XkbDeviceLedInfoRec *prev_leds = devi->leds;

-

-	if (devi->sz_leds>0)	devi->sz_leds*= 2;

-	else			devi->sz_leds= 1;

-	devi->leds= _XkbTypedRealloc(devi->leds,devi->sz_leds,

-							XkbDeviceLedInfoRec);

-	if (!devi->leds) {

-	    _XkbFree(prev_leds);

-	    devi->sz_leds= devi->num_leds= 0;

-	    return NULL;

-	}

-	i= devi->num_leds;

-	for (devli=&devi->leds[i];i<devi->sz_leds;i++,devli++) {

-	    bzero(devli,sizeof(XkbDeviceLedInfoRec));

-	    devli->led_class= XkbXINone;

-	    devli->led_id= XkbXINone;

-	}

-    }

-    devli= &devi->leds[devi->num_leds++];

-    bzero(devli,sizeof(XkbDeviceLedInfoRec));

-    devli->led_class= ledClass;

-    devli->led_id= ledId;

-    return devli;

-}

-

-Status

-XkbResizeDeviceButtonActions(XkbDeviceInfoPtr devi,unsigned newTotal)

-{

-    XkbAction *prev_btn_acts;

-

-    if ((!devi)||(newTotal>255))

-	return BadValue;

-    if ((devi->btn_acts!=NULL)&&(newTotal==devi->num_btns))

-	return Success;

-    if (newTotal==0) {

-	if (devi->btn_acts!=NULL) {

-	    _XkbFree(devi->btn_acts);

-	    devi->btn_acts= NULL;

-	}

-	devi->num_btns= 0;

-	return Success;

-    }

-    prev_btn_acts = devi->btn_acts;

-    devi->btn_acts= _XkbTypedRealloc(devi->btn_acts,newTotal,XkbAction);

-    if (devi->btn_acts==NULL) {

-	_XkbFree(prev_btn_acts);

-	devi->num_btns= 0;

-	return BadAlloc;

-    }

-    if (newTotal>devi->num_btns) {

-	XkbAction *act;

-	act= &devi->btn_acts[devi->num_btns];

-	bzero((char *)act,(newTotal-devi->num_btns)*sizeof(XkbAction));

-    }

-    devi->num_btns= newTotal;

-    return Success;

-}

-

-/*ARGSUSED*/

-XkbDeviceInfoPtr

-XkbAllocDeviceInfo(unsigned deviceSpec,unsigned nButtons,unsigned szLeds)

-{

-XkbDeviceInfoPtr	devi;

-

-    devi= _XkbTypedCalloc(1,XkbDeviceInfoRec);

-    if (devi!=NULL) {

-	devi->device_spec= deviceSpec;

-	devi->has_own_state= False;

-	devi->num_btns= 0;

-	devi->btn_acts= NULL;

-	if (nButtons>0) {

-	    devi->num_btns= nButtons;

-	    devi->btn_acts= _XkbTypedCalloc(nButtons,XkbAction);

-	    if (!devi->btn_acts) {

-		_XkbFree(devi);

-		return NULL;

-	    }

-	}

-	devi->dflt_kbd_fb= XkbXINone;

-	devi->dflt_led_fb= XkbXINone;

-	devi->num_leds= 0;

-	devi->sz_leds= 0;

-	devi->leds= NULL;

-	if (szLeds>0) {

-	    devi->sz_leds= szLeds;

-	    devi->leds= _XkbTypedCalloc(szLeds,XkbDeviceLedInfoRec);

-	    if (!devi->leds) {

-		if (devi->btn_acts)

-		    _XkbFree(devi->btn_acts);

-		_XkbFree(devi);

-		return NULL;

-	    }

-	}

-    }

-    return devi;

-}

-

-

-void

-XkbFreeDeviceInfo(XkbDeviceInfoPtr devi,unsigned which,Bool freeDevI)

-{

-    if (devi) {

-	if (freeDevI) {

-	    which= XkbXI_AllDeviceFeaturesMask;

-	    if (devi->name) {

-		_XkbFree(devi->name);

-		devi->name= NULL;

-	    }

-	}

-	if ((which&XkbXI_ButtonActionsMask)&&(devi->btn_acts)) {

-	    _XkbFree(devi->btn_acts);

-	    devi->num_btns= 0;

-	    devi->btn_acts= NULL;

-	}

-	if ((which&XkbXI_IndicatorsMask)&&(devi->leds)) {

-	    register int i;

-	    if ((which&XkbXI_IndicatorsMask)==XkbXI_IndicatorsMask) {

-		_XkbFree(devi->leds);

-		devi->sz_leds= devi->num_leds= 0;

-		devi->leds= NULL;

-	    }

-	    else {

-		XkbDeviceLedInfoPtr	devli;

-		for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {

-		    if (which&XkbXI_IndicatorMapsMask)

-			 bzero((char *)&devli->maps[0],sizeof(devli->maps));

-		    else bzero((char *)&devli->names[0],sizeof(devli->names));

-		}

-	    }

-	}

-	if (freeDevI)

-	    _XkbFree(devi);

-    }

-    return;

-}

+/************************************************************
+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_DIX_CONFIG_H
+#include <dix-config.h>
+#elif defined(HAVE_CONFIG_H)
+#include <config.h>
+#endif
+
+#ifndef XKB_IN_SERVER
+
+#include <stdio.h>
+#include "Xlibint.h"
+#include "XKBlibint.h"
+#include <X11/extensions/XKBgeom.h>
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+#else
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "inputstr.h"
+#include <X11/extensions/XKBsrv.h>
+#include <X11/extensions/XKBgeom.h>
+
+#endif /* XKB_IN_SERVER */
+
+/***===================================================================***/
+
+/*ARGSUSED*/
+Status
+XkbAllocCompatMap(XkbDescPtr xkb,unsigned which,unsigned nSI)
+{
+XkbCompatMapPtr	compat;
+XkbSymInterpretRec *prev_interpret;
+
+    if (!xkb)
+	return BadMatch;
+    if (xkb->compat) {
+	if (xkb->compat->size_si>=nSI)
+	    return Success;
+	compat= xkb->compat;
+	compat->size_si= nSI;
+	if (compat->sym_interpret==NULL)
+	    compat->num_si= 0;
+	prev_interpret = compat->sym_interpret;
+	compat->sym_interpret= _XkbTypedRealloc(compat->sym_interpret,
+						     nSI,XkbSymInterpretRec);
+	if (compat->sym_interpret==NULL) {
+	    _XkbFree(prev_interpret);
+	    compat->size_si= compat->num_si= 0;
+	    return BadAlloc;
+	}
+	if (compat->num_si!=0) {
+	    _XkbClearElems(compat->sym_interpret,compat->num_si,
+					compat->size_si-1,XkbSymInterpretRec);
+	}
+	return Success;
+    }
+    compat= _XkbTypedCalloc(1,XkbCompatMapRec);
+    if (compat==NULL)
+	return BadAlloc;
+    if (nSI>0) {
+	compat->sym_interpret= _XkbTypedCalloc(nSI,XkbSymInterpretRec);
+	if (!compat->sym_interpret) {
+	    _XkbFree(compat);
+	    return BadAlloc;
+	}
+    }
+    compat->size_si= nSI;
+    compat->num_si= 0;
+    bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
+    xkb->compat= compat;
+    return Success;
+}
+
+
+void
+XkbFreeCompatMap(XkbDescPtr xkb,unsigned which,Bool freeMap)
+{
+register XkbCompatMapPtr compat;
+
+    if ((xkb==NULL)||(xkb->compat==NULL))
+	return;
+    compat= xkb->compat;
+    if (freeMap)
+	which= XkbAllCompatMask;
+    if (which&XkbGroupCompatMask)
+	bzero((char *)&compat->groups[0],XkbNumKbdGroups*sizeof(XkbModsRec));
+    if (which&XkbSymInterpMask) {
+	if ((compat->sym_interpret)&&(compat->size_si>0))
+	    _XkbFree(compat->sym_interpret);
+	compat->size_si= compat->num_si= 0;
+	compat->sym_interpret= NULL;
+    }
+    if (freeMap) {
+	_XkbFree(compat);
+	xkb->compat= NULL;
+    }
+    return;
+}
+
+/***===================================================================***/
+
+Status
+XkbAllocNames(XkbDescPtr xkb,unsigned which,int nTotalRG,int nTotalAliases)
+{
+XkbNamesPtr	names;
+
+    if (xkb==NULL)
+	return BadMatch;
+    if (xkb->names==NULL) {
+	xkb->names = _XkbTypedCalloc(1,XkbNamesRec);
+	if (xkb->names==NULL)
+	    return BadAlloc;
+    }
+    names= xkb->names;
+    if ((which&XkbKTLevelNamesMask)&&(xkb->map!=NULL)&&(xkb->map->types!=NULL)){
+	register int	i;
+	XkbKeyTypePtr	type;
+
+	type= xkb->map->types;
+	for (i=0;i<xkb->map->num_types;i++,type++) {
+	    if (type->level_names==NULL) {
+		type->level_names= _XkbTypedCalloc(type->num_levels,Atom);
+		if (type->level_names==NULL)
+		    return BadAlloc;
+	    }
+	}
+    }
+    if ((which&XkbKeyNamesMask)&&(names->keys==NULL)) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadValue;
+	names->keys= _XkbTypedCalloc((xkb->max_key_code+1),XkbKeyNameRec);
+	if (names->keys==NULL)
+	    return BadAlloc;
+    }
+    if ((which&XkbKeyAliasesMask)&&(nTotalAliases>0)) {
+	if (names->key_aliases==NULL) {
+	    names->key_aliases= _XkbTypedCalloc(nTotalAliases,XkbKeyAliasRec);
+	}
+	else if (nTotalAliases>names->num_key_aliases) {
+	    XkbKeyAliasRec *prev_aliases = names->key_aliases;
+
+	    names->key_aliases= _XkbTypedRealloc(names->key_aliases,
+						nTotalAliases,XkbKeyAliasRec);
+	    if (names->key_aliases!=NULL) {
+		_XkbClearElems(names->key_aliases,names->num_key_aliases,
+						nTotalAliases-1,XkbKeyAliasRec);
+	    } else {
+		_XkbFree(prev_aliases);
+	    }
+	}
+	if (names->key_aliases==NULL) {
+	    names->num_key_aliases= 0;
+	    return BadAlloc;
+	}
+	names->num_key_aliases= nTotalAliases;
+    }
+    if ((which&XkbRGNamesMask)&&(nTotalRG>0)) {
+	if (names->radio_groups==NULL) {
+	    names->radio_groups= _XkbTypedCalloc(nTotalRG,Atom);
+	}
+	else if (nTotalRG>names->num_rg) {
+	    Atom *prev_radio_groups = names->radio_groups;
+
+	    names->radio_groups= _XkbTypedRealloc(names->radio_groups,nTotalRG,
+									Atom);
+	    if (names->radio_groups!=NULL) {
+		_XkbClearElems(names->radio_groups,names->num_rg,nTotalRG-1,
+									Atom);
+	    } else {
+		_XkbFree(prev_radio_groups);
+	    }
+	}
+	if (names->radio_groups==NULL)
+	    return BadAlloc;
+	names->num_rg= nTotalRG;
+    }
+    return Success;
+}
+
+void
+XkbFreeNames(XkbDescPtr xkb,unsigned which,Bool freeMap)
+{
+XkbNamesPtr	names;
+
+    if ((xkb==NULL)||(xkb->names==NULL))
+	return;
+    names= xkb->names;
+    if (freeMap)
+	which= XkbAllNamesMask;
+    if (which&XkbKTLevelNamesMask) {
+	XkbClientMapPtr	map= xkb->map;
+	if ((map!=NULL)&&(map->types!=NULL)) {
+	    register int 		i;
+	    register XkbKeyTypePtr	type;
+	    type= map->types;
+	    for (i=0;i<map->num_types;i++,type++) {
+		if (type->level_names!=NULL) {
+		    _XkbFree(type->level_names);
+		    type->level_names= NULL;
+		}
+	    }
+	}
+    }
+    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
+	_XkbFree(names->keys);
+	names->keys= NULL;
+	names->num_keys= 0;
+    }
+    if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
+	_XkbFree(names->key_aliases);
+	names->key_aliases=NULL;
+	names->num_key_aliases=0;
+    }
+    if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
+	_XkbFree(names->radio_groups);
+	names->radio_groups= NULL;
+	names->num_rg= 0;
+    }
+    if (freeMap) {
+	_XkbFree(names);
+	xkb->names= NULL;
+    }
+    return;
+}
+
+/***===================================================================***/
+
+/*ARGSUSED*/
+Status
+XkbAllocControls(XkbDescPtr xkb,unsigned which)
+{
+    if (xkb==NULL)
+	return BadMatch;
+
+    if (xkb->ctrls==NULL) {
+	xkb->ctrls= _XkbTypedCalloc(1,XkbControlsRec);
+	if (!xkb->ctrls)
+	    return BadAlloc;
+    }
+    return Success;
+}
+
+/*ARGSUSED*/
+void
+XkbFreeControls(XkbDescPtr xkb,unsigned which,Bool freeMap)
+{
+    if (freeMap && (xkb!=NULL) && (xkb->ctrls!=NULL)) {
+	_XkbFree(xkb->ctrls);
+	xkb->ctrls= NULL;
+    }
+    return;
+}
+
+/***===================================================================***/
+
+Status
+XkbAllocIndicatorMaps(XkbDescPtr xkb)
+{
+    if (xkb==NULL)
+	return BadMatch;
+    if (xkb->indicators==NULL) {
+	xkb->indicators= _XkbTypedCalloc(1,XkbIndicatorRec);
+	if (!xkb->indicators)
+	    return BadAlloc;
+    }
+    return Success;
+}
+
+void
+XkbFreeIndicatorMaps(XkbDescPtr xkb)
+{
+    if ((xkb!=NULL)&&(xkb->indicators!=NULL)) {
+	_XkbFree(xkb->indicators);
+	xkb->indicators= NULL;
+    }
+    return;
+}
+
+/***====================================================================***/
+
+XkbDescRec	*
+XkbAllocKeyboard(void)
+{
+XkbDescRec *xkb;
+
+    xkb = _XkbTypedCalloc(1,XkbDescRec);
+    if (xkb)
+	xkb->device_spec= XkbUseCoreKbd;
+    return xkb;
+}
+
+void
+XkbFreeKeyboard(XkbDescPtr xkb,unsigned which,Bool freeAll)
+{
+    if (xkb==NULL)
+	return;
+    if (freeAll)
+	which= XkbAllComponentsMask;
+    if (which&XkbClientMapMask)
+	XkbFreeClientMap(xkb,XkbAllClientInfoMask,True);
+    if (which&XkbServerMapMask)
+	XkbFreeServerMap(xkb,XkbAllServerInfoMask,True);
+    if (which&XkbCompatMapMask)
+	XkbFreeCompatMap(xkb,XkbAllCompatMask,True);
+    if (which&XkbIndicatorMapMask)
+	XkbFreeIndicatorMaps(xkb);
+    if (which&XkbNamesMask)
+	XkbFreeNames(xkb,XkbAllNamesMask,True);
+    if ((which&XkbGeometryMask) && (xkb->geom!=NULL))
+	XkbFreeGeometry(xkb->geom,XkbGeomAllMask,True);
+    if (which&XkbControlsMask)
+	XkbFreeControls(xkb,XkbAllControlsMask,True);
+    if (freeAll)
+	_XkbFree(xkb);
+    return;
+}
+
+/***====================================================================***/
+
+XkbDeviceLedInfoPtr
+XkbAddDeviceLedInfo(XkbDeviceInfoPtr devi,unsigned ledClass,unsigned ledId)
+{
+XkbDeviceLedInfoPtr	devli;
+register int		i;
+
+    if ((!devi)||(!XkbSingleXIClass(ledClass))||(!XkbSingleXIId(ledId)))
+	return NULL;
+    for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {
+	if ((devli->led_class==ledClass)&&(devli->led_id==ledId))
+	    return devli;
+    }
+    if (devi->num_leds>=devi->sz_leds) {
+	XkbDeviceLedInfoRec *prev_leds = devi->leds;
+
+	if (devi->sz_leds>0)	devi->sz_leds*= 2;
+	else			devi->sz_leds= 1;
+	devi->leds= _XkbTypedRealloc(devi->leds,devi->sz_leds,
+							XkbDeviceLedInfoRec);
+	if (!devi->leds) {
+	    _XkbFree(prev_leds);
+	    devi->sz_leds= devi->num_leds= 0;
+	    return NULL;
+	}
+	i= devi->num_leds;
+	for (devli=&devi->leds[i];i<devi->sz_leds;i++,devli++) {
+	    bzero(devli,sizeof(XkbDeviceLedInfoRec));
+	    devli->led_class= XkbXINone;
+	    devli->led_id= XkbXINone;
+	}
+    }
+    devli= &devi->leds[devi->num_leds++];
+    bzero(devli,sizeof(XkbDeviceLedInfoRec));
+    devli->led_class= ledClass;
+    devli->led_id= ledId;
+    return devli;
+}
+
+Status
+XkbResizeDeviceButtonActions(XkbDeviceInfoPtr devi,unsigned newTotal)
+{
+    XkbAction *prev_btn_acts;
+
+    if ((!devi)||(newTotal>255))
+	return BadValue;
+    if ((devi->btn_acts!=NULL)&&(newTotal==devi->num_btns))
+	return Success;
+    if (newTotal==0) {
+	if (devi->btn_acts!=NULL) {
+	    _XkbFree(devi->btn_acts);
+	    devi->btn_acts= NULL;
+	}
+	devi->num_btns= 0;
+	return Success;
+    }
+    prev_btn_acts = devi->btn_acts;
+    devi->btn_acts= _XkbTypedRealloc(devi->btn_acts,newTotal,XkbAction);
+    if (devi->btn_acts==NULL) {
+	_XkbFree(prev_btn_acts);
+	devi->num_btns= 0;
+	return BadAlloc;
+    }
+    if (newTotal>devi->num_btns) {
+	XkbAction *act;
+	act= &devi->btn_acts[devi->num_btns];
+	bzero((char *)act,(newTotal-devi->num_btns)*sizeof(XkbAction));
+    }
+    devi->num_btns= newTotal;
+    return Success;
+}
+
+/*ARGSUSED*/
+XkbDeviceInfoPtr
+XkbAllocDeviceInfo(unsigned deviceSpec,unsigned nButtons,unsigned szLeds)
+{
+XkbDeviceInfoPtr	devi;
+
+    devi= _XkbTypedCalloc(1,XkbDeviceInfoRec);
+    if (devi!=NULL) {
+	devi->device_spec= deviceSpec;
+	devi->has_own_state= False;
+	devi->num_btns= 0;
+	devi->btn_acts= NULL;
+	if (nButtons>0) {
+	    devi->num_btns= nButtons;
+	    devi->btn_acts= _XkbTypedCalloc(nButtons,XkbAction);
+	    if (!devi->btn_acts) {
+		_XkbFree(devi);
+		return NULL;
+	    }
+	}
+	devi->dflt_kbd_fb= XkbXINone;
+	devi->dflt_led_fb= XkbXINone;
+	devi->num_leds= 0;
+	devi->sz_leds= 0;
+	devi->leds= NULL;
+	if (szLeds>0) {
+	    devi->sz_leds= szLeds;
+	    devi->leds= _XkbTypedCalloc(szLeds,XkbDeviceLedInfoRec);
+	    if (!devi->leds) {
+		if (devi->btn_acts)
+		    _XkbFree(devi->btn_acts);
+		_XkbFree(devi);
+		return NULL;
+	    }
+	}
+    }
+    return devi;
+}
+
+
+void
+XkbFreeDeviceInfo(XkbDeviceInfoPtr devi,unsigned which,Bool freeDevI)
+{
+    if (devi) {
+	if (freeDevI) {
+	    which= XkbXI_AllDeviceFeaturesMask;
+	    if (devi->name) {
+		_XkbFree(devi->name);
+		devi->name= NULL;
+	    }
+	}
+	if ((which&XkbXI_ButtonActionsMask)&&(devi->btn_acts)) {
+	    _XkbFree(devi->btn_acts);
+	    devi->num_btns= 0;
+	    devi->btn_acts= NULL;
+	}
+	if ((which&XkbXI_IndicatorsMask)&&(devi->leds)) {
+	    register int i;
+	    if ((which&XkbXI_IndicatorsMask)==XkbXI_IndicatorsMask) {
+		_XkbFree(devi->leds);
+		devi->sz_leds= devi->num_leds= 0;
+		devi->leds= NULL;
+	    }
+	    else {
+		XkbDeviceLedInfoPtr	devli;
+		for (i=0,devli=devi->leds;i<devi->num_leds;i++,devli++) {
+		    if (which&XkbXI_IndicatorMapsMask)
+			 bzero((char *)&devli->maps[0],sizeof(devli->maps));
+		    else bzero((char *)&devli->names[0],sizeof(devli->names));
+		}
+	    }
+	}
+	if (freeDevI)
+	    _XkbFree(devi);
+    }
+    return;
+}
diff --git a/libX11/src/xkb/XKBBell.c b/libX11/src/xkb/XKBBell.c
index 13937c9cd..cf93ea79a 100644
--- a/libX11/src/xkb/XKBBell.c
+++ b/libX11/src/xkb/XKBBell.c
@@ -1,178 +1,178 @@
-/************************************************************

-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 <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-

-Bool

-XkbDeviceBell(	Display *	dpy,

-		Window 		window,

-		int 		deviceID,

-		int 		bellClass,

-		int 		bellID,

-		int 		percent,

-		Atom 		name)

-{

-    register xkbBellReq *req;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbBell,req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbBell;

-    req->deviceSpec = deviceID;

-    req->window = (CARD32)window;

-    req->bellClass = (CARD16)bellClass;

-    req->bellID = (CARD16)bellID;

-    req->percent = percent;

-    req->forceSound = False;

-    req->eventOnly = False;

-    req->pitch = 0;

-    req->duration = 0;

-    req->name = (CARD32)name;

-    req->pad1= 0; req->pad2= 0;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbForceDeviceBell(	Display *	dpy,

-			int 		deviceID,

-			int 		bellClass,

-			int 		bellID,

-			int 		percent)

-{

-    register xkbBellReq *req;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbBell,req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbBell;

-    req->deviceSpec = deviceID;

-    req->window = (CARD32)None;

-    req->bellClass = (CARD16)bellClass;

-    req->bellID = (CARD16)bellID;

-    req->percent = percent;

-    req->forceSound = True;

-    req->eventOnly = False;

-    req->pitch = 0;

-    req->duration = 0;

-    req->name = None;

-    req->pad1= 0; req->pad2= 0;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbDeviceBellEvent(	Display *	dpy,

-			Window 		window,

-			int		deviceID,

-			int		bellClass,

-			int		bellID,

-			int		percent,

-			Atom 		name)

-{

-    register xkbBellReq *req;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbBell,req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbBell;

-    req->deviceSpec = deviceID;

-    req->window = (CARD32)window;

-    req->bellClass = (CARD16)bellClass;

-    req->bellID = (CARD16)bellID;

-    req->percent = percent;

-    req->forceSound = False;

-    req->eventOnly = True;

-    req->pitch = 0;

-    req->duration = 0;

-    req->name = (CARD32)name;

-    req->pad1= 0; req->pad2= 0;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbBell(Display *dpy,Window window,int percent,Atom name)

-{

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {

-	XBell(dpy,percent);

-	return False;

-    }

-    return XkbDeviceBell(dpy,window,XkbUseCoreKbd,XkbDfltXIClass,XkbDfltXIId,

-								percent,name);

-}

-

-Bool

-XkbForceBell(Display *dpy,int percent)

-{

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {

-	XBell(dpy,percent);

-	return False;

-    }

-    return XkbForceDeviceBell(dpy,XkbUseCoreKbd,XkbDfltXIClass,XkbDfltXIId,

-								percent);

-}

-

-Bool

-XkbBellEvent(Display *dpy,Window window,int percent,Atom name)

-{

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {

-	return False;

-    }

-    /* class 0 = KbdFeedbackClass (X Input Extension) */

-    return XkbDeviceBellEvent(dpy,window,XkbUseCoreKbd,

-					XkbDfltXIClass,XkbDfltXIId,

-					percent,name);

-}

-

+/************************************************************
+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 <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+
+Bool
+XkbDeviceBell(	Display *	dpy,
+		Window 		window,
+		int 		deviceID,
+		int 		bellClass,
+		int 		bellID,
+		int 		percent,
+		Atom 		name)
+{
+    register xkbBellReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbBell,req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbBell;
+    req->deviceSpec = deviceID;
+    req->window = (CARD32)window;
+    req->bellClass = (CARD16)bellClass;
+    req->bellID = (CARD16)bellID;
+    req->percent = percent;
+    req->forceSound = False;
+    req->eventOnly = False;
+    req->pitch = 0;
+    req->duration = 0;
+    req->name = (CARD32)name;
+    req->pad1= 0; req->pad2= 0;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbForceDeviceBell(	Display *	dpy,
+			int 		deviceID,
+			int 		bellClass,
+			int 		bellID,
+			int 		percent)
+{
+    register xkbBellReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbBell,req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbBell;
+    req->deviceSpec = deviceID;
+    req->window = (CARD32)None;
+    req->bellClass = (CARD16)bellClass;
+    req->bellID = (CARD16)bellID;
+    req->percent = percent;
+    req->forceSound = True;
+    req->eventOnly = False;
+    req->pitch = 0;
+    req->duration = 0;
+    req->name = None;
+    req->pad1= 0; req->pad2= 0;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbDeviceBellEvent(	Display *	dpy,
+			Window 		window,
+			int		deviceID,
+			int		bellClass,
+			int		bellID,
+			int		percent,
+			Atom 		name)
+{
+    register xkbBellReq *req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbBell,req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbBell;
+    req->deviceSpec = deviceID;
+    req->window = (CARD32)window;
+    req->bellClass = (CARD16)bellClass;
+    req->bellID = (CARD16)bellID;
+    req->percent = percent;
+    req->forceSound = False;
+    req->eventOnly = True;
+    req->pitch = 0;
+    req->duration = 0;
+    req->name = (CARD32)name;
+    req->pad1= 0; req->pad2= 0;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbBell(Display *dpy,Window window,int percent,Atom name)
+{
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {
+	XBell(dpy,percent);
+	return False;
+    }
+    return XkbDeviceBell(dpy,window,XkbUseCoreKbd,XkbDfltXIClass,XkbDfltXIId,
+								percent,name);
+}
+
+Bool
+XkbForceBell(Display *dpy,int percent)
+{
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {
+	XBell(dpy,percent);
+	return False;
+    }
+    return XkbForceDeviceBell(dpy,XkbUseCoreKbd,XkbDfltXIClass,XkbDfltXIId,
+								percent);
+}
+
+Bool
+XkbBellEvent(Display *dpy,Window window,int percent,Atom name)
+{
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))) {
+	return False;
+    }
+    /* class 0 = KbdFeedbackClass (X Input Extension) */
+    return XkbDeviceBellEvent(dpy,window,XkbUseCoreKbd,
+					XkbDfltXIClass,XkbDfltXIId,
+					percent,name);
+}
+
diff --git a/libX11/src/xkb/XKBBind.c b/libX11/src/xkb/XKBBind.c
index 2e4b1fe68..1c16adce2 100644
--- a/libX11/src/xkb/XKBBind.c
+++ b/libX11/src/xkb/XKBBind.c
@@ -1,848 +1,848 @@
-/*

-

-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 last,first= changes.first_key_act;

-		    last= changes.first_key_act+changes.num_key_acts-1;

-		    fprintf(stderr,"     acts:  %d..%d\n",first,last);

-		}

-		if (changes.changed&XkbKeyBehaviorsMask) {

-		    int last,first= changes.first_key_behavior;

-		    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 last,first= changes.first_key_explicit;

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

-	char ch;

-	for (i=change=0;i<n;i++) {

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

-}

+/*
+
+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 last,first= changes.first_key_act;
+		    last= changes.first_key_act+changes.num_key_acts-1;
+		    fprintf(stderr,"     acts:  %d..%d\n",first,last);
+		}
+		if (changes.changed&XkbKeyBehaviorsMask) {
+		    int last,first= changes.first_key_behavior;
+		    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 last,first= changes.first_key_explicit;
+		    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;
+	char ch;
+	for (i=change=0;i<n;i++) {
+	    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;
+}
diff --git a/libX11/src/xkb/XKBCompat.c b/libX11/src/xkb/XKBCompat.c
index 6d110b167..206b0c90f 100644
--- a/libX11/src/xkb/XKBCompat.c
+++ b/libX11/src/xkb/XKBCompat.c
@@ -1,247 +1,247 @@
-/************************************************************

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

-#define	NEED_MAP_READERS

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-Status

-_XkbReadGetCompatMapReply(	Display *		dpy,

-				xkbGetCompatMapReply *	rep,

-				XkbDescPtr		xkb,

-				int	*		nread_rtrn)

-{

-register int 		i;

-XkbReadBufferRec	buf;

-

-    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))

-	return BadAlloc;

-

-    if (nread_rtrn)

-	*nread_rtrn= (int)rep->length*4;

-

-    i= rep->firstSI+rep->nSI;

-    if ((!xkb->compat)&&

-	(XkbAllocCompatMap(xkb,XkbAllCompatMask,i)!=Success))

-	return BadAlloc;

-

-    if (rep->nSI!=0) {

-	XkbSymInterpretRec *syms;

-	xkbSymInterpretWireDesc *wire;

-

-	wire= (xkbSymInterpretWireDesc *)_XkbGetReadBufferPtr(&buf,

-				   rep->nSI*SIZEOF(xkbSymInterpretWireDesc));

-	if (wire==NULL)

-	    goto BAILOUT;

-	syms= &xkb->compat->sym_interpret[rep->firstSI];

-

-	for (i=0;i<rep->nSI;i++,syms++,wire++) {

-	    syms->sym= wire->sym;

-	    syms->mods= wire->mods;

-	    syms->match= wire->match;

-	    syms->virtual_mod= wire->virtualMod;

-	    syms->flags= wire->flags;

-	    syms->act= *((XkbAnyAction *)&wire->act);

-	}

-	xkb->compat->num_si+= rep->nSI;

-    }

-

-    if (rep->groups&XkbAllGroupsMask) {

-	register unsigned	bit,nGroups;

-	xkbModsWireDesc * 	wire;

-	for (i=0,nGroups=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {

-	    if (rep->groups&bit)

-		nGroups++;

-	}

-	wire= (xkbModsWireDesc *)_XkbGetReadBufferPtr(&buf,

-				  nGroups*SIZEOF(xkbModsWireDesc));

-	if (wire==NULL)

-	    goto BAILOUT;

-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {

-	    if ((rep->groups&bit)==0)

-		continue;

-	    xkb->compat->groups[i].mask= wire->mask;

-	    xkb->compat->groups[i].real_mods= wire->realMods;

-	    xkb->compat->groups[i].vmods= wire->virtualMods;

-	    wire++;

-	}

-    }

-    i= _XkbFreeReadBuffer(&buf);

-    if (i)

-	fprintf(stderr,"CompatMapReply! Bad length (%d extra bytes)\n",i);

-    if (i || buf.error)

-	return BadLength;

-    return Success;

-BAILOUT:

-    _XkbFreeReadBuffer(&buf);

-    return BadLength;

-}

-

-Status

-XkbGetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-    register xkbGetCompatMapReq *req;

-    xkbGetCompatMapReply	 rep;

-    Status			status;

-    XkbInfoPtr xkbi;

-

-    if ( (!dpy) || (!xkb) || (dpy->flags & XlibDisplayNoXkb) ||

-	((xkb->dpy!=NULL)&&(xkb->dpy!=dpy)) ||

-	(!dpy->xkb_info && (!XkbUseExtension(dpy,NULL,NULL))))

-	return BadAccess;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetCompatMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetCompatMap;

-    req->deviceSpec = xkb->device_spec;

-    if (which&XkbSymInterpMask)

-	 req->getAllSI= True;

-    else req->getAllSI= False;

-    req->firstSI= req->nSI= 0;

-

-    if (which&XkbGroupCompatMask)

-	 req->groups= XkbAllGroupsMask;

-    else req->groups=  0;

-

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadLength;

-    }

-    if (xkb->dpy==NULL)

-	xkb->dpy= dpy;

-    if (xkb->device_spec==XkbUseCoreKbd)

-	xkb->device_spec= rep.deviceID;

-

-    status = _XkbReadGetCompatMapReply(dpy,&rep,xkb,NULL);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-static Bool

-_XkbWriteSetCompatMap(Display *dpy,xkbSetCompatMapReq *req,XkbDescPtr xkb)

-{

-CARD16			firstSI;

-CARD16			nSI;

-int			size;

-register int 		i,nGroups;

-register unsigned	bit;

-unsigned		groups;

-char *			buf;

-

-    firstSI = req->firstSI;

-    nSI = req->nSI;

-    size= nSI*SIZEOF(xkbSymInterpretWireDesc);

-    nGroups= 0;

-    groups= req->groups;

-    if (groups&XkbAllGroupsMask) {

-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {

-	    if (groups&bit)

-		nGroups++;

-	}

-	size+= SIZEOF(xkbModsWireDesc)*nGroups;

-    }

-    req->length+= size/4;

-    BufAlloc(char *,buf,size);

-    if (!buf)

-	return False;

-

-    if (nSI) {

-	XkbSymInterpretPtr sym= &xkb->compat->sym_interpret[firstSI];

-	xkbSymInterpretWireDesc *wire= (xkbSymInterpretWireDesc *)buf;

-	for (i=0;i<nSI;i++,wire++,sym++) {

-	    wire->sym= (CARD32)sym->sym;

-	    wire->mods= sym->mods;

-	    wire->match= sym->match;

-	    wire->flags= sym->flags;

-	    wire->virtualMod= sym->virtual_mod;

-	    memcpy(&wire->act,&sym->act,sz_xkbActionWireDesc);

-	}

-	buf+= nSI*SIZEOF(xkbSymInterpretWireDesc);

-    }

-    if (groups&XkbAllGroupsMask) {

-	xkbModsWireDesc *	out;

-

-	out= (xkbModsWireDesc *)buf;

-	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {

-	    if ((groups&bit)!=0) {

-		out->mask= xkb->compat->groups[i].mask;

-		out->realMods= xkb->compat->groups[i].real_mods;

-		out->virtualMods=  xkb->compat->groups[i].vmods;

-		out++;

-	    }

-	}

-	buf+= nGroups*SIZEOF(xkbModsWireDesc);

-    }

-    return True;

-}

-

-Bool

-XkbSetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb,Bool updateActions)

-{

-    register xkbSetCompatMapReq *req;

-    Status		     ok;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) || (dpy!=xkb->dpy) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!xkb->compat) ||

-	((which&XkbSymInterpMask)&&(!xkb->compat->sym_interpret)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetCompatMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetCompatMap;

-    req->deviceSpec = xkb->device_spec;

-    req->recomputeActions = updateActions;

-    if (which&XkbSymInterpMask) {

-	req->truncateSI = True;

-	req->firstSI= 0;

-	req->nSI= xkb->compat->num_si;

-    }

-    else {

-	req->truncateSI = False;

-	req->firstSI= 0;

-	req->nSI= 0;

-    }

-    if (which&XkbGroupCompatMask)

-	 req->groups= XkbAllGroupsMask;

-    else req->groups=  0;

-    ok= _XkbWriteSetCompatMap(dpy,req,xkb);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return ok;

-}

-

+/************************************************************
+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>
+#define	NEED_MAP_READERS
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+Status
+_XkbReadGetCompatMapReply(	Display *		dpy,
+				xkbGetCompatMapReply *	rep,
+				XkbDescPtr		xkb,
+				int	*		nread_rtrn)
+{
+register int 		i;
+XkbReadBufferRec	buf;
+
+    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))
+	return BadAlloc;
+
+    if (nread_rtrn)
+	*nread_rtrn= (int)rep->length*4;
+
+    i= rep->firstSI+rep->nSI;
+    if ((!xkb->compat)&&
+	(XkbAllocCompatMap(xkb,XkbAllCompatMask,i)!=Success))
+	return BadAlloc;
+
+    if (rep->nSI!=0) {
+	XkbSymInterpretRec *syms;
+	xkbSymInterpretWireDesc *wire;
+
+	wire= (xkbSymInterpretWireDesc *)_XkbGetReadBufferPtr(&buf,
+				   rep->nSI*SIZEOF(xkbSymInterpretWireDesc));
+	if (wire==NULL)
+	    goto BAILOUT;
+	syms= &xkb->compat->sym_interpret[rep->firstSI];
+
+	for (i=0;i<rep->nSI;i++,syms++,wire++) {
+	    syms->sym= wire->sym;
+	    syms->mods= wire->mods;
+	    syms->match= wire->match;
+	    syms->virtual_mod= wire->virtualMod;
+	    syms->flags= wire->flags;
+	    syms->act= *((XkbAnyAction *)&wire->act);
+	}
+	xkb->compat->num_si+= rep->nSI;
+    }
+
+    if (rep->groups&XkbAllGroupsMask) {
+	register unsigned	bit,nGroups;
+	xkbModsWireDesc * 	wire;
+	for (i=0,nGroups=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+	    if (rep->groups&bit)
+		nGroups++;
+	}
+	wire= (xkbModsWireDesc *)_XkbGetReadBufferPtr(&buf,
+				  nGroups*SIZEOF(xkbModsWireDesc));
+	if (wire==NULL)
+	    goto BAILOUT;
+	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+	    if ((rep->groups&bit)==0)
+		continue;
+	    xkb->compat->groups[i].mask= wire->mask;
+	    xkb->compat->groups[i].real_mods= wire->realMods;
+	    xkb->compat->groups[i].vmods= wire->virtualMods;
+	    wire++;
+	}
+    }
+    i= _XkbFreeReadBuffer(&buf);
+    if (i)
+	fprintf(stderr,"CompatMapReply! Bad length (%d extra bytes)\n",i);
+    if (i || buf.error)
+	return BadLength;
+    return Success;
+BAILOUT:
+    _XkbFreeReadBuffer(&buf);
+    return BadLength;
+}
+
+Status
+XkbGetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+    register xkbGetCompatMapReq *req;
+    xkbGetCompatMapReply	 rep;
+    Status			status;
+    XkbInfoPtr xkbi;
+
+    if ( (!dpy) || (!xkb) || (dpy->flags & XlibDisplayNoXkb) ||
+	((xkb->dpy!=NULL)&&(xkb->dpy!=dpy)) ||
+	(!dpy->xkb_info && (!XkbUseExtension(dpy,NULL,NULL))))
+	return BadAccess;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetCompatMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetCompatMap;
+    req->deviceSpec = xkb->device_spec;
+    if (which&XkbSymInterpMask)
+	 req->getAllSI= True;
+    else req->getAllSI= False;
+    req->firstSI= req->nSI= 0;
+
+    if (which&XkbGroupCompatMask)
+	 req->groups= XkbAllGroupsMask;
+    else req->groups=  0;
+
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadLength;
+    }
+    if (xkb->dpy==NULL)
+	xkb->dpy= dpy;
+    if (xkb->device_spec==XkbUseCoreKbd)
+	xkb->device_spec= rep.deviceID;
+
+    status = _XkbReadGetCompatMapReply(dpy,&rep,xkb,NULL);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+static Bool
+_XkbWriteSetCompatMap(Display *dpy,xkbSetCompatMapReq *req,XkbDescPtr xkb)
+{
+CARD16			firstSI;
+CARD16			nSI;
+int			size;
+register int 		i,nGroups;
+register unsigned	bit;
+unsigned		groups;
+char *			buf;
+
+    firstSI = req->firstSI;
+    nSI = req->nSI;
+    size= nSI*SIZEOF(xkbSymInterpretWireDesc);
+    nGroups= 0;
+    groups= req->groups;
+    if (groups&XkbAllGroupsMask) {
+	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+	    if (groups&bit)
+		nGroups++;
+	}
+	size+= SIZEOF(xkbModsWireDesc)*nGroups;
+    }
+    req->length+= size/4;
+    BufAlloc(char *,buf,size);
+    if (!buf)
+	return False;
+
+    if (nSI) {
+	XkbSymInterpretPtr sym= &xkb->compat->sym_interpret[firstSI];
+	xkbSymInterpretWireDesc *wire= (xkbSymInterpretWireDesc *)buf;
+	for (i=0;i<nSI;i++,wire++,sym++) {
+	    wire->sym= (CARD32)sym->sym;
+	    wire->mods= sym->mods;
+	    wire->match= sym->match;
+	    wire->flags= sym->flags;
+	    wire->virtualMod= sym->virtual_mod;
+	    memcpy(&wire->act,&sym->act,sz_xkbActionWireDesc);
+	}
+	buf+= nSI*SIZEOF(xkbSymInterpretWireDesc);
+    }
+    if (groups&XkbAllGroupsMask) {
+	xkbModsWireDesc *	out;
+
+	out= (xkbModsWireDesc *)buf;
+	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
+	    if ((groups&bit)!=0) {
+		out->mask= xkb->compat->groups[i].mask;
+		out->realMods= xkb->compat->groups[i].real_mods;
+		out->virtualMods=  xkb->compat->groups[i].vmods;
+		out++;
+	    }
+	}
+	buf+= nGroups*SIZEOF(xkbModsWireDesc);
+    }
+    return True;
+}
+
+Bool
+XkbSetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb,Bool updateActions)
+{
+    register xkbSetCompatMapReq *req;
+    Status		     ok;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) || (dpy!=xkb->dpy) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!xkb->compat) ||
+	((which&XkbSymInterpMask)&&(!xkb->compat->sym_interpret)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetCompatMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetCompatMap;
+    req->deviceSpec = xkb->device_spec;
+    req->recomputeActions = updateActions;
+    if (which&XkbSymInterpMask) {
+	req->truncateSI = True;
+	req->firstSI= 0;
+	req->nSI= xkb->compat->num_si;
+    }
+    else {
+	req->truncateSI = False;
+	req->firstSI= 0;
+	req->nSI= 0;
+    }
+    if (which&XkbGroupCompatMask)
+	 req->groups= XkbAllGroupsMask;
+    else req->groups=  0;
+    ok= _XkbWriteSetCompatMap(dpy,req,xkb);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return ok;
+}
+
diff --git a/libX11/src/xkb/XKBCtrls.c b/libX11/src/xkb/XKBCtrls.c
index abb470be9..2b33b3059 100644
--- a/libX11/src/xkb/XKBCtrls.c
+++ b/libX11/src/xkb/XKBCtrls.c
@@ -1,352 +1,352 @@
-/************************************************************

-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 <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-

-static xkbSetControlsReq *

-_XkbGetSetControlsReq(Display *dpy,XkbInfoPtr xkbi,unsigned int deviceSpec)

-{

-xkbSetControlsReq *req;

-

-    GetReq(kbSetControls,req);

-    bzero(req,SIZEOF(xkbSetControlsReq));

-    req->reqType = xkbi->codes->major_opcode;

-    req->length = (SIZEOF(xkbSetControlsReq)>>2);

-    req->xkbReqType = X_kbSetControls;

-    req->deviceSpec = deviceSpec;

-    return req;

-}

-

-Bool

-XkbSetAutoRepeatRate(	Display *dpy,

-			unsigned int deviceSpec,

-			unsigned int timeout,

-			unsigned int interval)

-{

-    register xkbSetControlsReq *req;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);

-    req->changeCtrls = XkbRepeatKeysMask;

-    req->repeatDelay = timeout;

-    req->repeatInterval = interval;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbGetAutoRepeatRate(	Display *	dpy,

-			unsigned int 	deviceSpec,

-			unsigned int *	timeoutp,

-			unsigned int *	intervalp)

-{

-    register xkbGetControlsReq *req;

-    xkbGetControlsReply rep;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetControls, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetControls;

-    req->deviceSpec = deviceSpec;

-    if (!_XReply(dpy, (xReply *)&rep,

-		(SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    *timeoutp = rep.repeatDelay;

-    *intervalp = rep.repeatInterval;

-    return True;

-}

-

-Bool

-XkbSetServerInternalMods(	Display *	dpy,

-				unsigned 	deviceSpec,

-				unsigned 	affectReal,

-				unsigned 	realValues,

-				unsigned 	affectVirtual,

-				unsigned 	virtualValues)

-{

-    register xkbSetControlsReq *req;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);

-    req->affectInternalMods = affectReal;

-    req->internalMods = realValues;

-    req->affectInternalVMods= affectVirtual;

-    req->internalVMods= virtualValues;

-    req->changeCtrls = XkbInternalModsMask;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbSetIgnoreLockMods(	Display *	dpy,

-			unsigned int 	deviceSpec,

-			unsigned 	affectReal,

-			unsigned 	realValues,

-			unsigned 	affectVirtual,

-			unsigned 	virtualValues)

-{

-    register xkbSetControlsReq *req;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);

-    req->affectIgnoreLockMods= affectReal;

-    req->ignoreLockMods = realValues;

-    req->affectIgnoreLockVMods= affectVirtual;

-    req->ignoreLockVMods= virtualValues;

-    req->changeCtrls = XkbIgnoreLockModsMask;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbChangeEnabledControls(	Display *	dpy,

-				unsigned	deviceSpec,

-				unsigned	affect,

-				unsigned	values)

-{

-    register xkbSetControlsReq *req;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);

-    req->affectEnabledCtrls= affect;

-    req->enabledCtrls= (affect&values);

-    req->changeCtrls = XkbControlsEnabledMask;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Status

-XkbGetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)

-{

-    register xkbGetControlsReq *req;

-    xkbGetControlsReply rep;

-    XkbControlsPtr	ctrls;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    if ((!xkb) || (!which))

-	return BadMatch;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetControls, req);

-    if (!xkb->ctrls)  {

-	xkb->ctrls = _XkbTypedCalloc(1,XkbControlsRec);

-	if (!xkb->ctrls) {

-	    UnlockDisplay(dpy);

-	    SyncHandle();

-	    return BadAlloc;

-	}

-    }

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetControls;

-    req->deviceSpec = xkb->device_spec;

-    if (!_XReply(dpy, (xReply *)&rep,

-		(SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadImplementation;

-    }

-    if (xkb->device_spec==XkbUseCoreKbd)

-	xkb->device_spec= rep.deviceID;

-    ctrls= xkb->ctrls;

-    if (which&XkbControlsEnabledMask)

-	ctrls->enabled_ctrls = rep.enabledCtrls;

-    ctrls->num_groups= rep.numGroups;

-    if (which&XkbGroupsWrapMask)

-	ctrls->groups_wrap= rep.groupsWrap;

-    if (which&XkbInternalModsMask) {

-	ctrls->internal.mask = rep.internalMods;

-	ctrls->internal.real_mods = rep.internalRealMods;

-	ctrls->internal.vmods = rep.internalVMods;

-    }

-    if (which&XkbIgnoreLockModsMask) {

-	ctrls->ignore_lock.mask = rep.ignoreLockMods;

-	ctrls->ignore_lock.real_mods = rep.ignoreLockRealMods;

-	ctrls->ignore_lock.vmods = rep.ignoreLockVMods;

-    }

-    if (which&XkbRepeatKeysMask) {

-	ctrls->repeat_delay = rep.repeatDelay;

-	ctrls->repeat_interval = rep.repeatInterval;

-    }

-    if (which&XkbSlowKeysMask)

-	ctrls->slow_keys_delay = rep.slowKeysDelay;

-    if (which&XkbBounceKeysMask)

-	ctrls->debounce_delay = rep.debounceDelay;

-    if (which&XkbMouseKeysMask) {

-	ctrls->mk_dflt_btn = rep.mkDfltBtn;

-    }

-    if (which&XkbMouseKeysAccelMask) {

-	ctrls->mk_delay = rep.mkDelay;

-	ctrls->mk_interval = rep.mkInterval;

-	ctrls->mk_time_to_max = rep.mkTimeToMax;

-	ctrls->mk_max_speed = rep.mkMaxSpeed;

-	ctrls->mk_curve = rep.mkCurve;

-    }

-    if (which&XkbAccessXKeysMask)

-	ctrls->ax_options= rep.axOptions;

-    if (which&XkbStickyKeysMask) {

-	ctrls->ax_options &= ~XkbAX_SKOptionsMask;

-	ctrls->ax_options |= rep.axOptions & XkbAX_SKOptionsMask;

-    }

-    if (which&XkbAccessXFeedbackMask) {

-	ctrls->ax_options &= ~XkbAX_FBOptionsMask;

-	ctrls->ax_options |= rep.axOptions & XkbAX_FBOptionsMask;

-    }

-    if (which&XkbAccessXTimeoutMask) {

-	ctrls->ax_timeout = rep.axTimeout;

-	ctrls->axt_ctrls_mask = rep.axtCtrlsMask;

-	ctrls->axt_ctrls_values = rep.axtCtrlsValues;

-	ctrls->axt_opts_mask = rep.axtOptsMask;

-	ctrls->axt_opts_values= rep.axtOptsValues;

-    }

-    if (which&XkbPerKeyRepeatMask) {

-   	memcpy(ctrls->per_key_repeat,rep.perKeyRepeat,

-					  XkbPerKeyBitArraySize);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return Success;

-}

-

-Bool

-XkbSetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)

-{

-    register xkbSetControlsReq *req;

-    XkbControlsPtr	ctrls;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!xkb)||(!xkb->ctrls))

-	return False;

-

-    ctrls= xkb->ctrls;

-    LockDisplay(dpy);

-    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,xkb->device_spec);

-    req->changeCtrls = (CARD32)which;

-    if (which&XkbInternalModsMask) {

-	req->affectInternalMods= ~0;

-	req->internalMods= ctrls->internal.real_mods;

-	req->affectInternalVMods = ~0;

-	req->internalVMods= ctrls->internal.vmods;

-    }

-    if (which&XkbIgnoreLockModsMask) {

-	req->affectIgnoreLockMods= ~0;

-	req->ignoreLockMods= ctrls->ignore_lock.real_mods;

-	req->affectIgnoreLockVMods= ~0;

-	req->ignoreLockVMods= ctrls->ignore_lock.vmods;

-    }

-    if (which&XkbControlsEnabledMask) {

-	req->affectEnabledCtrls= XkbAllBooleanCtrlsMask;

-	req->enabledCtrls= ctrls->enabled_ctrls;

-    }

-    if (which&XkbRepeatKeysMask) {

-	req->repeatDelay = ctrls->repeat_delay;

-	req->repeatInterval = ctrls->repeat_interval;

-    }

-    if (which&XkbSlowKeysMask)

-	 req->slowKeysDelay = ctrls->slow_keys_delay;

-    if (which&XkbBounceKeysMask)

-	 req->debounceDelay = ctrls->debounce_delay;

-    if (which&XkbMouseKeysMask) {

-	req->mkDfltBtn = ctrls->mk_dflt_btn;

-    }

-    if (which&XkbGroupsWrapMask)

-	req->groupsWrap= ctrls->groups_wrap;

-    if (which&(XkbAccessXKeysMask|XkbStickyKeysMask|XkbAccessXFeedbackMask))

-	req->axOptions= ctrls->ax_options;

-    if (which&XkbMouseKeysAccelMask) {

-	req->mkDelay = ctrls->mk_delay;

-	req->mkInterval = ctrls->mk_interval;

-	req->mkTimeToMax = ctrls->mk_time_to_max;

-	req->mkMaxSpeed = ctrls->mk_max_speed;

-	req->mkCurve = ctrls->mk_curve;

-    }

-    if (which&XkbAccessXTimeoutMask) {

-	 req->axTimeout = ctrls->ax_timeout;

-	 req->axtCtrlsMask = ctrls->axt_ctrls_mask;

-	 req->axtCtrlsValues = ctrls->axt_ctrls_values;

-	 req->axtOptsMask = ctrls->axt_opts_mask;

-	 req->axtOptsValues=ctrls->axt_opts_values;

-    }

-    if (which&XkbPerKeyRepeatMask) {

-	memcpy(req->perKeyRepeat,ctrls->per_key_repeat,

-					XkbPerKeyBitArraySize);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

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

-

-void

-XkbNoteControlsChanges(	XkbControlsChangesPtr		old,

-			XkbControlsNotifyEvent *	new,

-			unsigned int	 		wanted)

-{

-    old->changed_ctrls|= (new->changed_ctrls&wanted);

-    if (new->changed_ctrls&XkbControlsEnabledMask&wanted)

-	old->enabled_ctrls_changes^= new->enabled_ctrl_changes;

-    /* num_groups_changed?? */

-    return;

-}

+/************************************************************
+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 <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+
+static xkbSetControlsReq *
+_XkbGetSetControlsReq(Display *dpy,XkbInfoPtr xkbi,unsigned int deviceSpec)
+{
+xkbSetControlsReq *req;
+
+    GetReq(kbSetControls,req);
+    bzero(req,SIZEOF(xkbSetControlsReq));
+    req->reqType = xkbi->codes->major_opcode;
+    req->length = (SIZEOF(xkbSetControlsReq)>>2);
+    req->xkbReqType = X_kbSetControls;
+    req->deviceSpec = deviceSpec;
+    return req;
+}
+
+Bool
+XkbSetAutoRepeatRate(	Display *dpy,
+			unsigned int deviceSpec,
+			unsigned int timeout,
+			unsigned int interval)
+{
+    register xkbSetControlsReq *req;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
+    req->changeCtrls = XkbRepeatKeysMask;
+    req->repeatDelay = timeout;
+    req->repeatInterval = interval;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbGetAutoRepeatRate(	Display *	dpy,
+			unsigned int 	deviceSpec,
+			unsigned int *	timeoutp,
+			unsigned int *	intervalp)
+{
+    register xkbGetControlsReq *req;
+    xkbGetControlsReply rep;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetControls, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetControls;
+    req->deviceSpec = deviceSpec;
+    if (!_XReply(dpy, (xReply *)&rep,
+		(SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    *timeoutp = rep.repeatDelay;
+    *intervalp = rep.repeatInterval;
+    return True;
+}
+
+Bool
+XkbSetServerInternalMods(	Display *	dpy,
+				unsigned 	deviceSpec,
+				unsigned 	affectReal,
+				unsigned 	realValues,
+				unsigned 	affectVirtual,
+				unsigned 	virtualValues)
+{
+    register xkbSetControlsReq *req;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
+    req->affectInternalMods = affectReal;
+    req->internalMods = realValues;
+    req->affectInternalVMods= affectVirtual;
+    req->internalVMods= virtualValues;
+    req->changeCtrls = XkbInternalModsMask;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbSetIgnoreLockMods(	Display *	dpy,
+			unsigned int 	deviceSpec,
+			unsigned 	affectReal,
+			unsigned 	realValues,
+			unsigned 	affectVirtual,
+			unsigned 	virtualValues)
+{
+    register xkbSetControlsReq *req;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
+    req->affectIgnoreLockMods= affectReal;
+    req->ignoreLockMods = realValues;
+    req->affectIgnoreLockVMods= affectVirtual;
+    req->ignoreLockVMods= virtualValues;
+    req->changeCtrls = XkbIgnoreLockModsMask;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbChangeEnabledControls(	Display *	dpy,
+				unsigned	deviceSpec,
+				unsigned	affect,
+				unsigned	values)
+{
+    register xkbSetControlsReq *req;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,deviceSpec);
+    req->affectEnabledCtrls= affect;
+    req->enabledCtrls= (affect&values);
+    req->changeCtrls = XkbControlsEnabledMask;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Status
+XkbGetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)
+{
+    register xkbGetControlsReq *req;
+    xkbGetControlsReply rep;
+    XkbControlsPtr	ctrls;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    if ((!xkb) || (!which))
+	return BadMatch;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetControls, req);
+    if (!xkb->ctrls)  {
+	xkb->ctrls = _XkbTypedCalloc(1,XkbControlsRec);
+	if (!xkb->ctrls) {
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return BadAlloc;
+	}
+    }
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetControls;
+    req->deviceSpec = xkb->device_spec;
+    if (!_XReply(dpy, (xReply *)&rep,
+		(SIZEOF(xkbGetControlsReply)-SIZEOF(xReply))>>2, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadImplementation;
+    }
+    if (xkb->device_spec==XkbUseCoreKbd)
+	xkb->device_spec= rep.deviceID;
+    ctrls= xkb->ctrls;
+    if (which&XkbControlsEnabledMask)
+	ctrls->enabled_ctrls = rep.enabledCtrls;
+    ctrls->num_groups= rep.numGroups;
+    if (which&XkbGroupsWrapMask)
+	ctrls->groups_wrap= rep.groupsWrap;
+    if (which&XkbInternalModsMask) {
+	ctrls->internal.mask = rep.internalMods;
+	ctrls->internal.real_mods = rep.internalRealMods;
+	ctrls->internal.vmods = rep.internalVMods;
+    }
+    if (which&XkbIgnoreLockModsMask) {
+	ctrls->ignore_lock.mask = rep.ignoreLockMods;
+	ctrls->ignore_lock.real_mods = rep.ignoreLockRealMods;
+	ctrls->ignore_lock.vmods = rep.ignoreLockVMods;
+    }
+    if (which&XkbRepeatKeysMask) {
+	ctrls->repeat_delay = rep.repeatDelay;
+	ctrls->repeat_interval = rep.repeatInterval;
+    }
+    if (which&XkbSlowKeysMask)
+	ctrls->slow_keys_delay = rep.slowKeysDelay;
+    if (which&XkbBounceKeysMask)
+	ctrls->debounce_delay = rep.debounceDelay;
+    if (which&XkbMouseKeysMask) {
+	ctrls->mk_dflt_btn = rep.mkDfltBtn;
+    }
+    if (which&XkbMouseKeysAccelMask) {
+	ctrls->mk_delay = rep.mkDelay;
+	ctrls->mk_interval = rep.mkInterval;
+	ctrls->mk_time_to_max = rep.mkTimeToMax;
+	ctrls->mk_max_speed = rep.mkMaxSpeed;
+	ctrls->mk_curve = rep.mkCurve;
+    }
+    if (which&XkbAccessXKeysMask)
+	ctrls->ax_options= rep.axOptions;
+    if (which&XkbStickyKeysMask) {
+	ctrls->ax_options &= ~XkbAX_SKOptionsMask;
+	ctrls->ax_options |= rep.axOptions & XkbAX_SKOptionsMask;
+    }
+    if (which&XkbAccessXFeedbackMask) {
+	ctrls->ax_options &= ~XkbAX_FBOptionsMask;
+	ctrls->ax_options |= rep.axOptions & XkbAX_FBOptionsMask;
+    }
+    if (which&XkbAccessXTimeoutMask) {
+	ctrls->ax_timeout = rep.axTimeout;
+	ctrls->axt_ctrls_mask = rep.axtCtrlsMask;
+	ctrls->axt_ctrls_values = rep.axtCtrlsValues;
+	ctrls->axt_opts_mask = rep.axtOptsMask;
+	ctrls->axt_opts_values= rep.axtOptsValues;
+    }
+    if (which&XkbPerKeyRepeatMask) {
+   	memcpy(ctrls->per_key_repeat,rep.perKeyRepeat,
+					  XkbPerKeyBitArraySize);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return Success;
+}
+
+Bool
+XkbSetControls(Display *dpy, unsigned long which, XkbDescPtr xkb)
+{
+    register xkbSetControlsReq *req;
+    XkbControlsPtr	ctrls;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!xkb)||(!xkb->ctrls))
+	return False;
+
+    ctrls= xkb->ctrls;
+    LockDisplay(dpy);
+    req= _XkbGetSetControlsReq(dpy,dpy->xkb_info,xkb->device_spec);
+    req->changeCtrls = (CARD32)which;
+    if (which&XkbInternalModsMask) {
+	req->affectInternalMods= ~0;
+	req->internalMods= ctrls->internal.real_mods;
+	req->affectInternalVMods = ~0;
+	req->internalVMods= ctrls->internal.vmods;
+    }
+    if (which&XkbIgnoreLockModsMask) {
+	req->affectIgnoreLockMods= ~0;
+	req->ignoreLockMods= ctrls->ignore_lock.real_mods;
+	req->affectIgnoreLockVMods= ~0;
+	req->ignoreLockVMods= ctrls->ignore_lock.vmods;
+    }
+    if (which&XkbControlsEnabledMask) {
+	req->affectEnabledCtrls= XkbAllBooleanCtrlsMask;
+	req->enabledCtrls= ctrls->enabled_ctrls;
+    }
+    if (which&XkbRepeatKeysMask) {
+	req->repeatDelay = ctrls->repeat_delay;
+	req->repeatInterval = ctrls->repeat_interval;
+    }
+    if (which&XkbSlowKeysMask)
+	 req->slowKeysDelay = ctrls->slow_keys_delay;
+    if (which&XkbBounceKeysMask)
+	 req->debounceDelay = ctrls->debounce_delay;
+    if (which&XkbMouseKeysMask) {
+	req->mkDfltBtn = ctrls->mk_dflt_btn;
+    }
+    if (which&XkbGroupsWrapMask)
+	req->groupsWrap= ctrls->groups_wrap;
+    if (which&(XkbAccessXKeysMask|XkbStickyKeysMask|XkbAccessXFeedbackMask))
+	req->axOptions= ctrls->ax_options;
+    if (which&XkbMouseKeysAccelMask) {
+	req->mkDelay = ctrls->mk_delay;
+	req->mkInterval = ctrls->mk_interval;
+	req->mkTimeToMax = ctrls->mk_time_to_max;
+	req->mkMaxSpeed = ctrls->mk_max_speed;
+	req->mkCurve = ctrls->mk_curve;
+    }
+    if (which&XkbAccessXTimeoutMask) {
+	 req->axTimeout = ctrls->ax_timeout;
+	 req->axtCtrlsMask = ctrls->axt_ctrls_mask;
+	 req->axtCtrlsValues = ctrls->axt_ctrls_values;
+	 req->axtOptsMask = ctrls->axt_opts_mask;
+	 req->axtOptsValues=ctrls->axt_opts_values;
+    }
+    if (which&XkbPerKeyRepeatMask) {
+	memcpy(req->perKeyRepeat,ctrls->per_key_repeat,
+					XkbPerKeyBitArraySize);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+/***====================================================================***/
+
+void
+XkbNoteControlsChanges(	XkbControlsChangesPtr		old,
+			XkbControlsNotifyEvent *	new,
+			unsigned int	 		wanted)
+{
+    old->changed_ctrls|= (new->changed_ctrls&wanted);
+    if (new->changed_ctrls&XkbControlsEnabledMask&wanted)
+	old->enabled_ctrls_changes^= new->enabled_ctrl_changes;
+    /* num_groups_changed?? */
+    return;
+}
diff --git a/libX11/src/xkb/XKBCvt.c b/libX11/src/xkb/XKBCvt.c
index a68778223..da74fc047 100644
--- a/libX11/src/xkb/XKBCvt.c
+++ b/libX11/src/xkb/XKBCvt.c
@@ -1,337 +1,337 @@
-/*

-

-Copyright 1988, 1989, 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.

-

-*/

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <stdio.h>

-#include <sys/types.h>

-#include <sys/stat.h>

-

-#include <X11/X.h>

-#include <X11/Xlib.h>

-#include "Xlibint.h"

-#include "Xlcint.h"

-#include "XlcPubI.h"

-#include "Ximint.h"

-#include <X11/Xutil.h>

-#include <X11/Xmd.h>

-#define XK_LATIN1

-#define XK_PUBLISHING

-#include <X11/keysym.h>

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-#include <X11/Xlocale.h>

-#include <ctype.h>

-#include <X11/Xos.h>

-

-#ifdef __sgi_not_xconsortium

-#define	XKB_EXTEND_LOOKUP_STRING

-#endif

-

-static int

-_XkbHandleSpecialSym(KeySym keysym, char *buffer, int nbytes, int *extra_rtrn)

-{

-

-    /* try to convert to Latin-1, handling ctrl */

-    if (!(((keysym >= XK_BackSpace) && (keysym <= XK_Clear)) ||

-	   (keysym == XK_Return) || (keysym == XK_Escape) ||

-	   (keysym == XK_KP_Space) || (keysym == XK_KP_Tab) ||

-	   (keysym == XK_KP_Enter) ||

-	   ((keysym >= XK_KP_Multiply) && (keysym <= XK_KP_9)) ||

-	   (keysym == XK_KP_Equal) ||

-	   (keysym == XK_Delete)))

-	return 0;

-

-    if (nbytes<1) {

-	if (extra_rtrn)

-	    *extra_rtrn= 1;

-	return 0;

-    }

-    /* if X keysym, convert to ascii by grabbing low 7 bits */

-    if (keysym == XK_KP_Space)

-	 buffer[0] = XK_space & 0x7F; /* patch encoding botch */

-    else if (keysym == XK_hyphen)

-	 buffer[0] = (char)(XK_minus & 0xFF); /* map to equiv character */

-    else buffer[0] = (char)(keysym & 0x7F);

-    return 1;

-}

-

-/*ARGSUSED*/

-static int

-_XkbKSToKnownSet (	XPointer 	priv,

-			KeySym 		keysym,

-			char *		buffer,

-			int 		nbytes,

-			int *		extra_rtrn)

-{

-    char tbuf[8],*buf;

-

-    if (extra_rtrn)

-	*extra_rtrn= 0;

-

-    /* convert "dead" diacriticals for dumb applications */

-    if ( (keysym&0xffffff00)== 0xfe00 ) {

-	switch ( keysym ) {

-	    case XK_dead_grave:		keysym = XK_grave; break;

-	    case XK_dead_acute:		keysym = XK_acute; break;

-	    case XK_dead_circumflex:	keysym = XK_asciicircum; break;

-	    case XK_dead_tilde:		keysym = XK_asciitilde; break;

-	    case XK_dead_macron:	keysym = XK_macron; break;

-	    case XK_dead_breve:		keysym = XK_breve; break;

-	    case XK_dead_abovedot:	keysym = XK_abovedot; break;

-	    case XK_dead_diaeresis:	keysym = XK_diaeresis; break;

-	    case XK_dead_abovering:	keysym = XK_degree; break;

-	    case XK_dead_doubleacute:	keysym = XK_doubleacute; break;

-	    case XK_dead_caron:		keysym = XK_caron; break;

-	    case XK_dead_cedilla:	keysym = XK_cedilla; break;

-	    case XK_dead_ogonek	:	keysym = XK_ogonek; break;

-	    case XK_dead_iota:		keysym = XK_Greek_iota; break;

-#ifdef XK_KATAKANA

-	    case XK_dead_voiced_sound:	keysym = XK_voicedsound; break;

-	    case XK_dead_semivoiced_sound:keysym = XK_semivoicedsound; break;

-#endif

-	}

-    }

-

-    if (nbytes<1)	buf= tbuf;

-    else		buf= buffer;

-

-    if ((keysym&0xffffff00)==0xff00) {

-	return _XkbHandleSpecialSym(keysym, buf, nbytes, extra_rtrn);

-    }

-    return _XimGetCharCode (priv, keysym, (unsigned char *)buf, nbytes);

-}

-

-typedef struct _XkbToKS {

-	unsigned	 prefix;

-	char		*map;

-} XkbToKS;

-

-/*ARGSUSED*/

-static KeySym

-_XkbKnownSetToKS(XPointer priv,char *buffer,int nbytes,Status *status)

-{

-    if (nbytes!=1)

-	return NoSymbol;

-    if (((buffer[0]&0x80)==0)&&(buffer[0]>=32))

-	return buffer[0];

-    else if ((buffer[0]&0x7f)>=32) {

-	XkbToKS *map= (XkbToKS *)priv;

-	if ( map ) {

-	    if ( map->map )	return map->prefix|map->map[buffer[0]&0x7f];

-	    else		return map->prefix|buffer[0];

-	}

-	return buffer[0];

-    }

-    return NoSymbol;

-}

-

-static KeySym

-__XkbDefaultToUpper(KeySym sym)

-{

-    KeySym	lower,upper;

-

-    XConvertCase(sym, &lower, &upper);

-    return upper;

-}

-

-#ifdef XKB_EXTEND_LOOKUP_STRING

-static int

-Strcmp(char *str1, char *str2)

-{

-    char str[256];

-    char c, *s;

-

-    /*

-     * unchecked strings from the environment can end up here, so check

-     * the length before copying.

-     */

-    if (strlen(str1) >= sizeof(str)) /* almost certain it's a mismatch */

-	return 1;

-

-    for (s = str; (c = *str1++); ) {

-	if (isupper(c))

-	    c = tolower(c);

-	*s++ = c;

-    }

-    *s = '\0';

-    return (strcmp(str, str2));

-}

-#endif

-

-int

-_XkbGetConverters(const char *encoding_name, XkbConverters *cvt_rtrn)

-{

-    if ( !cvt_rtrn ) return 0;

-

-    cvt_rtrn->KSToMB = _XkbKSToKnownSet;

-    cvt_rtrn->KSToMBPriv = _XimGetLocaleCode(encoding_name);

-    cvt_rtrn->MBToKS = _XkbKnownSetToKS;

-    cvt_rtrn->MBToKSPriv = NULL;

-    cvt_rtrn->KSToUpper = __XkbDefaultToUpper;

-    return 1;

-}

-

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

-

-/*

- * The function _XkbGetCharset seems to be missnamed as what it seems to

- * be used for is to determine the encoding-name for the locale. ???

- */

-

-#ifdef XKB_EXTEND_LOOKUP_STRING

-

-/*

- * XKB_EXTEND_LOOKUP_STRING is not used by the SI. It is used by various

- * X Consortium/X Project Team members, so we leave it in the source as

- * an simplify integration by these companies.

- */

-

-#define	CHARSET_FILE	"/usr/lib/X11/input/charsets"

-static char *_XkbKnownLanguages = "c=ascii:da,de,en,es,fr,is,it,nl,no,pt,sv=iso8859-1:hu,pl,cs=iso8859-2:eo=iso8859-3:sp=iso8859-5:ar,ara=iso8859-6:el=iso8859-7:he=iso8859-8:tr=iso8859-9:lt,lv=iso8859-13:et,fi=iso8859-15:ru=koi8-r:uk=koi8-u:th,th_TH,th_TH.iso8859-11=iso8859-11:th_TH.TIS620=tis620:hy=armscii-8:vi=tcvn-5712:ka=georgian-academy:be,bg=microsoft-cp1251";

-

-char	*

-_XkbGetCharset(void)

-{

-    /*

-     * PAGE USAGE TUNING: explicitly initialize to move these to data

-     * instead of bss

-     */

-    static char buf[100] = { 0 };

-    char lang[256];

-    char *start,*tmp,*end,*next,*set;

-    char *country,*charset;

-    char *locale;

-

-    tmp = getenv( "_XKB_CHARSET" );

-    if ( tmp )

-	return tmp;

-    locale = setlocale(LC_CTYPE,NULL);

-

-    if ( locale == NULL )

-	return NULL;

-

-    if (strlen(locale) >= sizeof(lang))

-	return NULL;

-

-    for (tmp = lang; *tmp = *locale++; tmp++) {

-	if (isupper(*tmp))

-	    *tmp = tolower(*tmp);

-    }

-    country = strchr( lang, '_');

-    if ( country ) {

-	*country++ = '\0';

-	charset = strchr( country, '.' );

-	if ( charset )	*charset++ = '\0';

-	if ( charset ) {

-	    strncpy(buf,charset,99);

-	    buf[99] = '\0';

-	    return buf;

-	}

-    }

-    else {

-	charset = NULL;

-    }

-

-    if ((tmp = getenv("_XKB_LOCALE_CHARSETS"))!=NULL) {

-	start = _XkbAlloc(strlen(tmp) + 1);

-	strcpy(start, tmp);

-	tmp = start;

-    } else {

-	struct stat sbuf;

-	FILE *file;

-#ifndef __UNIXOS2__

-	char *cf = CHARSET_FILE;

-#else

-        char *cf = __XOS2RedirRoot(CHARSET_FILE);

-#endif

-

-#ifndef S_ISREG

-# define S_ISREG(mode)   (((mode) & S_IFMT) == S_IFREG)

-#endif

-

-	if ( (stat(cf,&sbuf)==0) && S_ISREG(sbuf.st_mode) &&

-	    (file = fopen(cf,"r")) ) {

-	    tmp = _XkbAlloc(sbuf.st_size+1);

-	    if (tmp!=NULL) {

-		sbuf.st_size = (long)fread(tmp,1,sbuf.st_size,file);

-		tmp[sbuf.st_size] = '\0';

-	    }

-	    fclose(file);

-	}

-    }

-

-    if ( tmp == NULL ) {

-	tmp = _XkbAlloc(strlen(_XkbKnownLanguages) + 1);

-	if (!tmp)

-	    return NULL;

-	strcpy(tmp, _XkbKnownLanguages);

-    }

-    start = tmp;

-    do {

-	if ( (set=strchr(tmp,'=')) == NULL )

-	    break;

-	*set++ = '\0';

-	if ( (next=strchr(set,':')) != NULL )

-	    *next++ = '\0';

-	while ( tmp && *tmp ) {

-	    if ( (end=strchr(tmp,',')) != NULL )

-		*end++ = '\0';

-	    if ( Strcmp( tmp, lang ) == 0 ) {

-		strncpy(buf,set,100);

-		buf[99] = '\0';

-		Xfree(start);

-		return buf;

-	    }

-	    tmp = end;

-	}

-	tmp = next;

-    } while ( tmp && *tmp );

-    Xfree(start);

-    return NULL;

-}

-#else

-char	*

-_XkbGetCharset(void)

-{

-    char *tmp;

-    XLCd lcd;

-

-    tmp = getenv( "_XKB_CHARSET" );

-    if ( tmp )

-	return tmp;

-

-    lcd = _XlcCurrentLC();

-    if ( lcd )

-	return XLC_PUBLIC(lcd,encoding_name);

-

-    return NULL;

-}

-#endif

-

+/*
+
+Copyright 1988, 1989, 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.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include "Xlibint.h"
+#include "Xlcint.h"
+#include "XlcPubI.h"
+#include "Ximint.h"
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+#define XK_LATIN1
+#define XK_PUBLISHING
+#include <X11/keysym.h>
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+#include <X11/Xlocale.h>
+#include <ctype.h>
+#include <X11/Xos.h>
+
+#ifdef __sgi_not_xconsortium
+#define	XKB_EXTEND_LOOKUP_STRING
+#endif
+
+static int
+_XkbHandleSpecialSym(KeySym keysym, char *buffer, int nbytes, int *extra_rtrn)
+{
+
+    /* try to convert to Latin-1, handling ctrl */
+    if (!(((keysym >= XK_BackSpace) && (keysym <= XK_Clear)) ||
+	   (keysym == XK_Return) || (keysym == XK_Escape) ||
+	   (keysym == XK_KP_Space) || (keysym == XK_KP_Tab) ||
+	   (keysym == XK_KP_Enter) ||
+	   ((keysym >= XK_KP_Multiply) && (keysym <= XK_KP_9)) ||
+	   (keysym == XK_KP_Equal) ||
+	   (keysym == XK_Delete)))
+	return 0;
+
+    if (nbytes<1) {
+	if (extra_rtrn)
+	    *extra_rtrn= 1;
+	return 0;
+    }
+    /* if X keysym, convert to ascii by grabbing low 7 bits */
+    if (keysym == XK_KP_Space)
+	 buffer[0] = XK_space & 0x7F; /* patch encoding botch */
+    else if (keysym == XK_hyphen)
+	 buffer[0] = (char)(XK_minus & 0xFF); /* map to equiv character */
+    else buffer[0] = (char)(keysym & 0x7F);
+    return 1;
+}
+
+/*ARGSUSED*/
+static int
+_XkbKSToKnownSet (	XPointer 	priv,
+			KeySym 		keysym,
+			char *		buffer,
+			int 		nbytes,
+			int *		extra_rtrn)
+{
+    char tbuf[8],*buf;
+
+    if (extra_rtrn)
+	*extra_rtrn= 0;
+
+    /* convert "dead" diacriticals for dumb applications */
+    if ( (keysym&0xffffff00)== 0xfe00 ) {
+	switch ( keysym ) {
+	    case XK_dead_grave:		keysym = XK_grave; break;
+	    case XK_dead_acute:		keysym = XK_acute; break;
+	    case XK_dead_circumflex:	keysym = XK_asciicircum; break;
+	    case XK_dead_tilde:		keysym = XK_asciitilde; break;
+	    case XK_dead_macron:	keysym = XK_macron; break;
+	    case XK_dead_breve:		keysym = XK_breve; break;
+	    case XK_dead_abovedot:	keysym = XK_abovedot; break;
+	    case XK_dead_diaeresis:	keysym = XK_diaeresis; break;
+	    case XK_dead_abovering:	keysym = XK_degree; break;
+	    case XK_dead_doubleacute:	keysym = XK_doubleacute; break;
+	    case XK_dead_caron:		keysym = XK_caron; break;
+	    case XK_dead_cedilla:	keysym = XK_cedilla; break;
+	    case XK_dead_ogonek	:	keysym = XK_ogonek; break;
+	    case XK_dead_iota:		keysym = XK_Greek_iota; break;
+#ifdef XK_KATAKANA
+	    case XK_dead_voiced_sound:	keysym = XK_voicedsound; break;
+	    case XK_dead_semivoiced_sound:keysym = XK_semivoicedsound; break;
+#endif
+	}
+    }
+
+    if (nbytes<1)	buf= tbuf;
+    else		buf= buffer;
+
+    if ((keysym&0xffffff00)==0xff00) {
+	return _XkbHandleSpecialSym(keysym, buf, nbytes, extra_rtrn);
+    }
+    return _XimGetCharCode (priv, keysym, (unsigned char *)buf, nbytes);
+}
+
+typedef struct _XkbToKS {
+	unsigned	 prefix;
+	char		*map;
+} XkbToKS;
+
+/*ARGSUSED*/
+static KeySym
+_XkbKnownSetToKS(XPointer priv,char *buffer,int nbytes,Status *status)
+{
+    if (nbytes!=1)
+	return NoSymbol;
+    if (((buffer[0]&0x80)==0)&&(buffer[0]>=32))
+	return buffer[0];
+    else if ((buffer[0]&0x7f)>=32) {
+	XkbToKS *map= (XkbToKS *)priv;
+	if ( map ) {
+	    if ( map->map )	return map->prefix|map->map[buffer[0]&0x7f];
+	    else		return map->prefix|buffer[0];
+	}
+	return buffer[0];
+    }
+    return NoSymbol;
+}
+
+static KeySym
+__XkbDefaultToUpper(KeySym sym)
+{
+    KeySym	lower,upper;
+
+    XConvertCase(sym, &lower, &upper);
+    return upper;
+}
+
+#ifdef XKB_EXTEND_LOOKUP_STRING
+static int
+Strcmp(char *str1, char *str2)
+{
+    char str[256];
+    char c, *s;
+
+    /*
+     * unchecked strings from the environment can end up here, so check
+     * the length before copying.
+     */
+    if (strlen(str1) >= sizeof(str)) /* almost certain it's a mismatch */
+	return 1;
+
+    for (s = str; (c = *str1++); ) {
+	if (isupper(c))
+	    c = tolower(c);
+	*s++ = c;
+    }
+    *s = '\0';
+    return (strcmp(str, str2));
+}
+#endif
+
+int
+_XkbGetConverters(const char *encoding_name, XkbConverters *cvt_rtrn)
+{
+    if ( !cvt_rtrn ) return 0;
+
+    cvt_rtrn->KSToMB = _XkbKSToKnownSet;
+    cvt_rtrn->KSToMBPriv = _XimGetLocaleCode(encoding_name);
+    cvt_rtrn->MBToKS = _XkbKnownSetToKS;
+    cvt_rtrn->MBToKSPriv = NULL;
+    cvt_rtrn->KSToUpper = __XkbDefaultToUpper;
+    return 1;
+}
+
+/***====================================================================***/
+
+/*
+ * The function _XkbGetCharset seems to be missnamed as what it seems to
+ * be used for is to determine the encoding-name for the locale. ???
+ */
+
+#ifdef XKB_EXTEND_LOOKUP_STRING
+
+/*
+ * XKB_EXTEND_LOOKUP_STRING is not used by the SI. It is used by various
+ * X Consortium/X Project Team members, so we leave it in the source as
+ * an simplify integration by these companies.
+ */
+
+#define	CHARSET_FILE	"/usr/lib/X11/input/charsets"
+static char *_XkbKnownLanguages = "c=ascii:da,de,en,es,fr,is,it,nl,no,pt,sv=iso8859-1:hu,pl,cs=iso8859-2:eo=iso8859-3:sp=iso8859-5:ar,ara=iso8859-6:el=iso8859-7:he=iso8859-8:tr=iso8859-9:lt,lv=iso8859-13:et,fi=iso8859-15:ru=koi8-r:uk=koi8-u:th,th_TH,th_TH.iso8859-11=iso8859-11:th_TH.TIS620=tis620:hy=armscii-8:vi=tcvn-5712:ka=georgian-academy:be,bg=microsoft-cp1251";
+
+char	*
+_XkbGetCharset(void)
+{
+    /*
+     * PAGE USAGE TUNING: explicitly initialize to move these to data
+     * instead of bss
+     */
+    static char buf[100] = { 0 };
+    char lang[256];
+    char *start,*tmp,*end,*next,*set;
+    char *country,*charset;
+    char *locale;
+
+    tmp = getenv( "_XKB_CHARSET" );
+    if ( tmp )
+	return tmp;
+    locale = setlocale(LC_CTYPE,NULL);
+
+    if ( locale == NULL )
+	return NULL;
+
+    if (strlen(locale) >= sizeof(lang))
+	return NULL;
+
+    for (tmp = lang; *tmp = *locale++; tmp++) {
+	if (isupper(*tmp))
+	    *tmp = tolower(*tmp);
+    }
+    country = strchr( lang, '_');
+    if ( country ) {
+	*country++ = '\0';
+	charset = strchr( country, '.' );
+	if ( charset )	*charset++ = '\0';
+	if ( charset ) {
+	    strncpy(buf,charset,99);
+	    buf[99] = '\0';
+	    return buf;
+	}
+    }
+    else {
+	charset = NULL;
+    }
+
+    if ((tmp = getenv("_XKB_LOCALE_CHARSETS"))!=NULL) {
+	start = _XkbAlloc(strlen(tmp) + 1);
+	strcpy(start, tmp);
+	tmp = start;
+    } else {
+	struct stat sbuf;
+	FILE *file;
+#ifndef __UNIXOS2__
+	char *cf = CHARSET_FILE;
+#else
+        char *cf = __XOS2RedirRoot(CHARSET_FILE);
+#endif
+
+#ifndef S_ISREG
+# define S_ISREG(mode)   (((mode) & S_IFMT) == S_IFREG)
+#endif
+
+	if ( (stat(cf,&sbuf)==0) && S_ISREG(sbuf.st_mode) &&
+	    (file = fopen(cf,"r")) ) {
+	    tmp = _XkbAlloc(sbuf.st_size+1);
+	    if (tmp!=NULL) {
+		sbuf.st_size = (long)fread(tmp,1,sbuf.st_size,file);
+		tmp[sbuf.st_size] = '\0';
+	    }
+	    fclose(file);
+	}
+    }
+
+    if ( tmp == NULL ) {
+	tmp = _XkbAlloc(strlen(_XkbKnownLanguages) + 1);
+	if (!tmp)
+	    return NULL;
+	strcpy(tmp, _XkbKnownLanguages);
+    }
+    start = tmp;
+    do {
+	if ( (set=strchr(tmp,'=')) == NULL )
+	    break;
+	*set++ = '\0';
+	if ( (next=strchr(set,':')) != NULL )
+	    *next++ = '\0';
+	while ( tmp && *tmp ) {
+	    if ( (end=strchr(tmp,',')) != NULL )
+		*end++ = '\0';
+	    if ( Strcmp( tmp, lang ) == 0 ) {
+		strncpy(buf,set,100);
+		buf[99] = '\0';
+		Xfree(start);
+		return buf;
+	    }
+	    tmp = end;
+	}
+	tmp = next;
+    } while ( tmp && *tmp );
+    Xfree(start);
+    return NULL;
+}
+#else
+char	*
+_XkbGetCharset(void)
+{
+    char *tmp;
+    XLCd lcd;
+
+    tmp = getenv( "_XKB_CHARSET" );
+    if ( tmp )
+	return tmp;
+
+    lcd = _XlcCurrentLC();
+    if ( lcd )
+	return XLC_PUBLIC(lcd,encoding_name);
+
+    return NULL;
+}
+#endif
+
diff --git a/libX11/src/xkb/XKBExtDev.c b/libX11/src/xkb/XKBExtDev.c
index b762747e6..353e769bf 100644
--- a/libX11/src/xkb/XKBExtDev.c
+++ b/libX11/src/xkb/XKBExtDev.c
@@ -1,819 +1,819 @@
-/************************************************************

-Copyright (c) 1995 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>

-#define	NEED_MAP_READERS

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-#include <X11/extensions/XI.h>

-

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

-

-extern void

-XkbNoteDeviceChanges(	XkbDeviceChangesPtr		old,

-			XkbExtensionDeviceNotifyEvent *	new,

-			unsigned int			wanted)

-{

-    if ((!old)||(!new)||(!wanted)||((new->reason&wanted)==0))

-	return;

-    if ((wanted&new->reason)&XkbXI_ButtonActionsMask) {

-	if (old->changed&XkbXI_ButtonActionsMask) {

-	    int first,last,newLast;

-	    if (new->first_btn<old->first_btn)

-		 first= new->first_btn;

-	    else first= old->first_btn;

-	    last= old->first_btn+old->num_btns-1;

-	    newLast= new->first_btn+new->num_btns-1;

-	    if (newLast>last)

-		last= newLast;

-	    old->first_btn= first;

-	    old->num_btns= (last-first)+1;

-	}

-	else {

-	    old->changed|= XkbXI_ButtonActionsMask;

-	    old->first_btn= new->first_btn;

-	    old->num_btns= new->num_btns;

-	}

-    }

-    if ((wanted&new->reason)&XkbXI_IndicatorsMask) {

-	XkbDeviceLedChangesPtr this;

-	if (old->changed&XkbXI_IndicatorsMask) {

-	    XkbDeviceLedChangesPtr found;

-	    found= NULL;

-	    for (this= &old->leds;this&&(!found);this=this->next) {

-		if ((this->led_class==new->led_class)&&

-						(this->led_id==new->led_id)) {

-		    found= this;

-		}

-	    }

-	    if (!found) {

-		found= _XkbTypedCalloc(1,XkbDeviceLedChangesRec);

-		if (!found)

-		    return;

-		found->next= old->leds.next;

-		found->led_class= new->led_class;

-		found->led_id= new->led_id;

-		old->leds.next= found;

-	    }

-	    if ((wanted&new->reason)&XkbXI_IndicatorNamesMask)

-		found->defined= new->leds_defined;

-	}

-	else {

-	    old->changed|= ((wanted&new->reason)&XkbXI_IndicatorsMask);

-	    old->leds.led_class= new->led_class;

-	    old->leds.led_id= new->led_id;

-	    old->leds.defined= new->leds_defined;

-	    if (old->leds.next) {

-		XkbDeviceLedChangesPtr next;

-		for (this=old->leds.next;this;this=next) {

-		    next= this->next;

-		    _XkbFree(this);

-		}

-		old->leds.next= NULL;

-	    }

-	}

-    }

-    return;

-}

-

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

-

-static Status

-_XkbReadDeviceLedInfo(	XkbReadBufferPtr	buf,

-			unsigned 		present,

-			XkbDeviceInfoPtr 	devi)

-{

-register unsigned	i,bit;

-XkbDeviceLedInfoPtr	devli;

-xkbDeviceLedsWireDesc *	wireli;

-

-    wireli= _XkbGetTypedRdBufPtr(buf,1,xkbDeviceLedsWireDesc);

-    if (!wireli)

-	return BadLength;

-    devli= XkbAddDeviceLedInfo(devi,wireli->ledClass,wireli->ledID);

-    if (!devli)

-	return BadAlloc;

-    devli->phys_indicators= 	wireli->physIndicators;

-

-    if (present&XkbXI_IndicatorStateMask)

-	devli->state= wireli->state;

-

-    if (present&XkbXI_IndicatorNamesMask) {

-	devli->names_present= 	wireli->namesPresent;

-	if (devli->names_present) {

-	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {

-		if (wireli->namesPresent&bit) {

-		    if (!_XkbCopyFromReadBuffer(buf,(char *)&devli->names[i],4))

-			return BadLength;

-		}

-	    }

-	}

-    }

-

-    if (present&XkbXI_IndicatorMapsMask) {

-	devli->maps_present= 	wireli->mapsPresent;

-	if (devli->maps_present) {

-	    XkbIndicatorMapPtr	 	im;

-	    xkbIndicatorMapWireDesc *	wireim;

-	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {

-		if (wireli->mapsPresent&bit) {

-		    wireim= _XkbGetTypedRdBufPtr(buf,1,xkbIndicatorMapWireDesc);

-		    if (!wireim)

-			return BadAlloc;

-		    im= &devli->maps[i];

-		    im->flags= 		wireim->flags;

-		    im->which_groups= 	wireim->whichGroups;

-		    im->groups= 	wireim->groups;

-		    im->which_mods= 	wireim->whichMods;

-		    im->mods.mask= 	wireim->mods;

-		    im->mods.real_mods= wireim->realMods;

-		    im->mods.vmods= 	wireim->virtualMods;

-		    im->ctrls= 		wireim->ctrls;

-		}

-	    }

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadGetDeviceInfoReply(	Display *		dpy,

-				xkbGetDeviceInfoReply *	rep,

-				XkbDeviceInfoPtr	devi)

-{

-XkbReadBufferRec	buf;

-XkbAction *		act;

-int			tmp;

-

-    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))

-	return BadAlloc;

-

-    if ((rep->totalBtns>0)&&(rep->totalBtns!=devi->num_btns)) {

-	tmp= XkbResizeDeviceButtonActions(devi,rep->totalBtns);

-	if (tmp!=Success)

-	    return tmp;

-    }

-    if (rep->nBtnsWanted>0) {

-	act= &devi->btn_acts[rep->firstBtnWanted];

-	bzero((char *)act,(rep->nBtnsWanted*sizeof(XkbAction)));

-    }

-    if (devi->name!=NULL)

-	_XkbFree(devi->name);

-    if (!_XkbGetReadBufferCountedString(&buf,&devi->name))

-	goto BAILOUT;

-    if (rep->nBtnsRtrn>0) {

-	int size;

-	act= &devi->btn_acts[rep->firstBtnRtrn];

-	size= rep->nBtnsRtrn*SIZEOF(xkbActionWireDesc);

-	if (!_XkbCopyFromReadBuffer(&buf,(char *)act,size))

-	    goto BAILOUT;

-    }

-    if (rep->nDeviceLedFBs>0) {

-	register int 		i;

-	for (i=0;i<rep->nDeviceLedFBs;i++) {

-	    if ((tmp= _XkbReadDeviceLedInfo(&buf,rep->present,devi))!=Success)

-		return tmp;

-	}

-    }

-    tmp= _XkbFreeReadBuffer(&buf);

-    if (tmp)

-	fprintf(stderr,"GetDeviceInfo! Bad length (%d extra bytes)\n",tmp);

-    if (tmp || buf.error)

-	return BadLength;

-    return Success;

-BAILOUT:

-    _XkbFreeReadBuffer(&buf);

-    return BadLength;

-}

-

-XkbDeviceInfoPtr

-XkbGetDeviceInfo(	Display *	dpy,

-			unsigned 	which,

-			unsigned 	deviceSpec,

-			unsigned 	class,

-			unsigned 	id)

-{

-    register xkbGetDeviceInfoReq *	req;

-    xkbGetDeviceInfoReply	 	rep;

-    Status				status;

-    XkbDeviceInfoPtr			devi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return NULL;

-    LockDisplay(dpy);

-    GetReq(kbGetDeviceInfo, req);

-    req->reqType = dpy->xkb_info->codes->major_opcode;

-    req->xkbReqType = X_kbGetDeviceInfo;

-    req->deviceSpec = deviceSpec;

-    req->wanted= which;

-    req->allBtns= ((which&XkbXI_ButtonActionsMask)!=0);

-    req->firstBtn= req->nBtns= 0;

-    req->ledClass= class;

-    req->ledID= id;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return NULL;

-    }

-    devi= XkbAllocDeviceInfo(rep.deviceID,rep.totalBtns,rep.nDeviceLedFBs);

-    if (devi) {

-	devi->supported= rep.supported;

-	devi->unsupported= rep.unsupported;

-	devi->type= rep.devType;

-	devi->has_own_state= rep.hasOwnState;

-	devi->dflt_kbd_fb = rep.dfltKbdFB;

-	devi->dflt_led_fb = rep.dfltLedFB;

-	status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);

-	if (status!=Success) {

-	    XkbFreeDeviceInfo(devi,XkbXI_AllDeviceFeaturesMask,True);

-	    devi= NULL;

-	}

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return devi;

-}

-

-Status

-XkbGetDeviceInfoChanges(	Display *		dpy,

-				XkbDeviceInfoPtr 	devi,

-				XkbDeviceChangesPtr	changes)

-{

-    register xkbGetDeviceInfoReq *	req;

-    xkbGetDeviceInfoReply	 	rep;

-    Status				status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadMatch;

-    if ((changes->changed&XkbXI_AllDeviceFeaturesMask)==0)

-	return Success;

-    changes->changed&= ~XkbXI_AllDeviceFeaturesMask;

-    status= Success;

-    LockDisplay(dpy);

-    while ((changes->changed)&&(status==Success)) {

-	GetReq(kbGetDeviceInfo, req);

-	req->reqType = dpy->xkb_info->codes->major_opcode;

-	req->xkbReqType = X_kbGetDeviceInfo;

-	req->deviceSpec = devi->device_spec;

-	req->wanted= changes->changed;

-	req->allBtns= False;

-	if (changes->changed&XkbXI_ButtonActionsMask) {

-	     req->firstBtn= changes->first_btn;

-	     req->nBtns= 	changes->num_btns;

-	     changes->changed&= ~XkbXI_ButtonActionsMask;

-	}

-	else req->firstBtn= req->nBtns= 0;

-	if (changes->changed&XkbXI_IndicatorsMask) {

-	    req->ledClass= changes->leds.led_class;

-	    req->ledID= changes->leds.led_id;

-	    if (changes->leds.next==NULL)

-		changes->changed&= ~XkbXI_IndicatorsMask;

-	    else {

-		XkbDeviceLedChangesPtr next;

-		next= changes->leds.next;

-		changes->leds= *next;

-		_XkbFree(next);

-	    }

-	}

-	else {

-	    req->ledClass= XkbDfltXIClass;

-	    req->ledID= XkbDfltXIId;

-	}

-	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	    status= BadLength;

-	    break;

-	}

-	devi->supported|= rep.supported;

-	devi->unsupported|= rep.unsupported;

-	devi->type= rep.devType;

-	status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetDeviceButtonActions(	Display *		dpy,

-				XkbDeviceInfoPtr	devi,

-				Bool			all,

-				unsigned int		first,

-				unsigned int		num)

-{

-    register xkbGetDeviceInfoReq *	req;

-    xkbGetDeviceInfoReply	 	rep;

-    Status				status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadMatch;

-    if (!devi)

-	return BadValue;

-    LockDisplay(dpy);

-    GetReq(kbGetDeviceInfo, req);

-    req->reqType = dpy->xkb_info->codes->major_opcode;

-    req->xkbReqType = X_kbGetDeviceInfo;

-    req->deviceSpec = devi->device_spec;

-    req->wanted= XkbXI_ButtonActionsMask;

-    req->allBtns= all;

-    req->firstBtn= first;

-    req->nBtns= num;

-    req->ledClass= XkbDfltXIClass;

-    req->ledID= XkbDfltXIId;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadLength;

-    }

-    devi->type= rep.devType;

-    devi->supported= rep.supported;

-    devi->unsupported= rep.unsupported;

-    status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetDeviceLedInfo(	Display *		dpy,

-			XkbDeviceInfoPtr	devi,

-			unsigned int		ledClass,

-			unsigned int		ledId,

-			unsigned int		which)

-{

-    register xkbGetDeviceInfoReq *	req;

-    xkbGetDeviceInfoReply	 	rep;

-    Status				status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadMatch;

-    if (((which&XkbXI_IndicatorsMask)==0)||(which&(~XkbXI_IndicatorsMask)))

-	return BadMatch;

-    if (!devi)

-	return BadValue;

-    LockDisplay(dpy);

-    GetReq(kbGetDeviceInfo, req);

-    req->reqType = dpy->xkb_info->codes->major_opcode;

-    req->xkbReqType = X_kbGetDeviceInfo;

-    req->deviceSpec = devi->device_spec;

-    req->wanted= which;

-    req->allBtns= False;

-    req->firstBtn= req->nBtns= 0;

-    req->ledClass= ledClass;

-    req->ledID= ledId;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadLength;

-    }

-    devi->type= rep.devType;

-    devi->supported= rep.supported;

-    devi->unsupported= rep.unsupported;

-    status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

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

-

-typedef struct _LedInfoStuff {

-	Bool			used;

-	XkbDeviceLedInfoPtr	devli;

-} LedInfoStuff;

-

-typedef struct _SetLedStuff {

-	unsigned		wanted;

-	int			num_info;

-	int			dflt_class;

-	LedInfoStuff *		dflt_kbd_fb;

-	LedInfoStuff *		dflt_led_fb;

-	LedInfoStuff *		info;

-} SetLedStuff;

-

-static void

-_InitLedStuff(SetLedStuff *stuff,unsigned wanted,XkbDeviceInfoPtr devi)

-{

-int				i;

-register XkbDeviceLedInfoPtr	devli;

-

-    bzero(stuff,sizeof(SetLedStuff));

-    stuff->wanted= wanted;

-    stuff->dflt_class=	XkbXINone;

-    if ((devi->num_leds<1)||((wanted&XkbXI_IndicatorsMask)==0))

-	return;

-    stuff->info= _XkbTypedCalloc(devi->num_leds,LedInfoStuff);

-    if (!stuff->info)

-	return;

-    stuff->num_info= devi->num_leds;

-    for (devli=&devi->leds[0],i=0;i<devi->num_leds;i++,devli++) {

-	stuff->info[i].devli= devli;

-	if (devli->led_class==KbdFeedbackClass) {

-	    stuff->dflt_class= KbdFeedbackClass;

-	    if (stuff->dflt_kbd_fb==NULL)

-		stuff->dflt_kbd_fb= &stuff->info[i];

-	}

-	else if (devli->led_class==LedFeedbackClass) {

-	    if (stuff->dflt_class==XkbXINone)

-		stuff->dflt_class= LedFeedbackClass;

-	    if (stuff->dflt_led_fb==NULL)

-		stuff->dflt_led_fb= &stuff->info[i];

-	}

-    }

-    return;

-}

-

-static void

-_FreeLedStuff(SetLedStuff *stuff)

-{

-    if ((stuff->num_info>0)&&(stuff->info!=NULL))

-	_XkbFree(stuff->info);

-    bzero(stuff,sizeof(SetLedStuff));

-    return;

-}

-

-static int

-_XkbSizeLedInfo(unsigned changed,XkbDeviceLedInfoPtr devli)

-{

-register int i,size;

-register unsigned bit,namesNeeded,mapsNeeded;

-

-    size= SIZEOF(xkbDeviceLedsWireDesc);

-    namesNeeded= mapsNeeded= 0;

-    if (changed&XkbXI_IndicatorNamesMask)

-	namesNeeded= devli->names_present;

-    if (changed&XkbXI_IndicatorMapsMask)

-	mapsNeeded= devli->maps_present;

-    if ((namesNeeded)||(mapsNeeded)) {

-	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {

-	    if (namesNeeded&bit)

-		size+= 4; /* atoms are 4 bytes on the wire */

-	    if (mapsNeeded&bit)

-		size+= SIZEOF(xkbIndicatorMapWireDesc);

-	}

-    }

-    return size;

-}

-

-static Bool

-_SizeMatches(	SetLedStuff *		stuff,

-		XkbDeviceLedChangesPtr 	changes,

-		int *			sz_rtrn,

-		int *			nleds_rtrn)

-{

-int		i,nMatch,class,id;

-LedInfoStuff *	linfo;

-Bool		match;

-

-    nMatch= 0;

-    class= changes->led_class;

-    id= changes->led_id;

-    if (class==XkbDfltXIClass)

-	class= stuff->dflt_class;

-    for (i=0,linfo=&stuff->info[0];i<stuff->num_info;i++,linfo++) {

-	XkbDeviceLedInfoPtr	devli;

-	LedInfoStuff *		dflt;

-

-	devli= linfo->devli;

-	match= ((class==devli->led_class)||(class==XkbAllXIClasses));

-	if (devli->led_class==KbdFeedbackClass)	dflt= stuff->dflt_kbd_fb;

-	else					dflt= stuff->dflt_led_fb;

-	match = (match && (id == devli->led_id)) ||

-	  (id == XkbAllXIIds) ||

-	  ((id == XkbDfltXIId) &&

-	   (linfo == dflt));

-	if (match) {

-	    if (!linfo->used) {

-		*sz_rtrn+= _XkbSizeLedInfo(stuff->wanted,devli);

-		*nleds_rtrn+= 1;

-		linfo->used= True;

-		if ((class!=XkbAllXIClasses)&&(id!=XkbAllXIIds))

-		    return True;

-	    }

-	    nMatch++;

-	    linfo->used= True;

-	}

-    }

-    return (nMatch>0);

-}

-

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

-

-

-static Status

-_XkbSetDeviceInfoSize(	XkbDeviceInfoPtr	devi,

-			XkbDeviceChangesPtr	changes,

-			SetLedStuff *		stuff,

-			int *			sz_rtrn,

-			int *			num_leds_rtrn)

-{

-    *sz_rtrn= 0;

-    if ((changes->changed&XkbXI_ButtonActionsMask)&&(changes->num_btns>0)) {

-	if (!XkbXI_LegalDevBtn(devi,(changes->first_btn+changes->num_btns-1)))

-	    return BadMatch;

-	*sz_rtrn+= changes->num_btns*SIZEOF(xkbActionWireDesc);

-    }

-    else {

-	changes->changed&= ~XkbXI_ButtonActionsMask;

-	changes->first_btn= changes->num_btns= 0;

-    }

-    if ((changes->changed&XkbXI_IndicatorsMask)&&

-				XkbLegalXILedClass(changes->leds.led_class)) {

-	XkbDeviceLedChangesPtr	leds;

-

-	for (leds=&changes->leds;leds!=NULL;leds= leds->next) {

-	    if (!_SizeMatches(stuff,leds,sz_rtrn,num_leds_rtrn))

-		return BadMatch;

-	}

-    }

-    else {

-	changes->changed&= ~XkbXI_IndicatorsMask;

-	*num_leds_rtrn= 0;

-    }

-    return Success;

-}

-

-static char *

-_XkbWriteLedInfo(char *wire,unsigned changed,XkbDeviceLedInfoPtr devli)

-{

-register int 		i;

-register unsigned 	bit,namesNeeded,mapsNeeded;

-xkbDeviceLedsWireDesc *	lwire;

-

-    namesNeeded= mapsNeeded= 0;

-    if (changed&XkbXI_IndicatorNamesMask)

-	namesNeeded= devli->names_present;

-    if (changed&XkbXI_IndicatorMapsMask)

-	mapsNeeded= devli->maps_present;

-

-    lwire= (xkbDeviceLedsWireDesc *)wire;

-    lwire->ledClass= devli->led_class;

-    lwire->ledID= devli->led_id;

-    lwire->namesPresent= namesNeeded;

-    lwire->mapsPresent=  mapsNeeded;

-    lwire->physIndicators= devli->phys_indicators;

-    lwire->state= devli->state;

-    wire= (char *)&lwire[1];

-    if (namesNeeded) {

-	CARD32 *awire;

-	awire= (CARD32 *)wire;

-	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {

-	    if (namesNeeded&bit) {

-		*awire= (CARD32)devli->names[i];

-		awire++;

-	    }

-	}

-	wire= (char *)awire;

-    }

-    if (mapsNeeded) {

-	xkbIndicatorMapWireDesc *mwire;

-

-	mwire= (xkbIndicatorMapWireDesc *)wire;

-	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {

-	    if (mapsNeeded&bit) {

-		XkbIndicatorMapPtr	map;

-		map= 			&devli->maps[i];

-		mwire->flags= 		map->flags;

-		mwire->whichGroups=	map->which_groups;

-		mwire->groups=		map->groups;

-		mwire->whichMods=	map->which_mods;

-		mwire->mods=		map->mods.mask;

-		mwire->realMods=	map->mods.real_mods;

-		mwire->virtualMods=	map->mods.vmods;

-		mwire->ctrls=		map->ctrls;

-		mwire++;

-	    }

-	}

-	wire= (char *)mwire;

-    }

-    return wire;

-}

-

-

-static int

-_XkbWriteSetDeviceInfo(	char *			wire,

-			XkbDeviceChangesPtr	changes,

-			SetLedStuff *		stuff,

-			XkbDeviceInfoPtr	devi)

-{

-char *start;

-

-    start= wire;

-    if (changes->changed&XkbXI_ButtonActionsMask) {

-	int			size;

-	size= changes->num_btns*SIZEOF(xkbActionWireDesc);

-	memcpy(wire,(char *)&devi->btn_acts[changes->first_btn],size);

-	wire+= size;

-    }

-    if (changes->changed&XkbXI_IndicatorsMask) {

-	register int i;

-	register LedInfoStuff *linfo;

-

-	for (i=0,linfo=&stuff->info[0];i<stuff->num_info;i++,linfo++) {

-	    if (linfo->used) {

-		register char *new_wire;

-		new_wire= _XkbWriteLedInfo(wire,stuff->wanted,linfo->devli);

-		if (!new_wire)

-		    return wire-start;

-		wire= new_wire;

-	    }

-	}

-    }

-    return wire-start;

-}

-

-Bool

-XkbSetDeviceInfo(	Display *		dpy,

-			unsigned 		which,

-			XkbDeviceInfoPtr	devi)

-{

-    register xkbSetDeviceInfoReq *req;

-    Status		     	ok = 0;

-    int				size,nLeds;

-    XkbInfoPtr 			xkbi;

-    XkbDeviceChangesRec		changes;

-    SetLedStuff			lstuff;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!devi) || (which&(~XkbXI_AllDeviceFeaturesMask)) ||

-	((which&XkbXI_ButtonActionsMask)&&(!XkbXI_DevHasBtnActs(devi)))||

-	((which&XkbXI_IndicatorsMask)&&(!XkbXI_DevHasLeds(devi))))

-	return False;

-

-    bzero((char *)&changes,sizeof(XkbDeviceChangesRec));

-    changes.changed= which;

-    changes.first_btn=		0;

-    changes.num_btns=		devi->num_btns;

-    changes.leds.led_class=	XkbAllXIClasses;

-    changes.leds.led_id=	XkbAllXIIds;

-    changes.leds.defined=	0;

-    size= nLeds= 		0;

-    _InitLedStuff(&lstuff,changes.changed,devi);

-    if (_XkbSetDeviceInfoSize(devi,&changes,&lstuff,&size,&nLeds)!=Success)

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetDeviceInfo, req);

-    req->length+=	size/4;

-    req->reqType= 	xkbi->codes->major_opcode;

-    req->xkbReqType= 	X_kbSetDeviceInfo;

-    req->deviceSpec= 	devi->device_spec;

-    req->firstBtn=	changes.first_btn;

-    req->nBtns=		changes.num_btns;

-    req->change=	changes.changed;

-    req->nDeviceLedFBs=	nLeds;

-    if (size>0) {

-	char * 	wire;

-	BufAlloc(char *,wire,size);

-	ok= (wire!=NULL)&&

-		(_XkbWriteSetDeviceInfo(wire,&changes,&lstuff,devi)==size);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    _FreeLedStuff(&lstuff);

-    /* 12/11/95 (ef) -- XXX!! should clear changes here */

-    return ok;

-}

-

-Bool

-XkbChangeDeviceInfo(	Display *		dpy,

-			XkbDeviceInfoPtr	devi,

-			XkbDeviceChangesPtr	changes)

-{

-    register xkbSetDeviceInfoReq *req;

-    Status		     	ok = 0;

-    int				size,nLeds;

-    XkbInfoPtr 			xkbi;

-    SetLedStuff			lstuff;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!devi) || (changes->changed&(~XkbXI_AllDeviceFeaturesMask)) ||

-	((changes->changed&XkbXI_ButtonActionsMask)&&

-					(!XkbXI_DevHasBtnActs(devi)))||

-	((changes->changed&XkbXI_IndicatorsMask)&&(!XkbXI_DevHasLeds(devi))))

-	return False;

-

-    size= nLeds= 0;

-    _InitLedStuff(&lstuff,changes->changed,devi);

-    if (_XkbSetDeviceInfoSize(devi,changes,&lstuff,&size,&nLeds)!=Success)

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetDeviceInfo, req);

-    req->length+=	size/4;

-    req->reqType= 	xkbi->codes->major_opcode;

-    req->xkbReqType= 	X_kbSetDeviceInfo;

-    req->deviceSpec= 	devi->device_spec;

-    req->firstBtn=	changes->first_btn;

-    req->nBtns=		changes->num_btns;

-    req->change=	changes->changed;

-    req->nDeviceLedFBs=	nLeds;

-    if (size>0) {

-	char * 	wire;

-	BufAlloc(char *,wire,size);

-	ok= (wire!=NULL)&&

-		(_XkbWriteSetDeviceInfo(wire,changes,&lstuff,devi)==size);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    _FreeLedStuff(&lstuff);

-    /* 12/11/95 (ef) -- XXX!! should clear changes here */

-    return ok;

-}

-

-Bool

-XkbSetDeviceLedInfo(	Display *		dpy,

-			XkbDeviceInfoPtr	devi,

-			unsigned 		ledClass,

-			unsigned		ledID,

-			unsigned		which)

-{

-    return False;

-}

-

-Bool

-XkbSetDeviceButtonActions(	Display *		dpy,

-				XkbDeviceInfoPtr 	devi,

-				unsigned int		first,

-				unsigned int		nBtns)

-{

-    register xkbSetDeviceInfoReq *req;

-    Status		     	ok = 0;

-    int				size,nLeds;

-    XkbInfoPtr 			xkbi;

-    XkbDeviceChangesRec		changes;

-    SetLedStuff			lstuff;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!devi)||(!XkbXI_DevHasBtnActs(devi))||(first+nBtns>devi->num_btns))

-	return False;

-    if (nBtns==0)

-	return True;

-

-    bzero((char *)&changes,sizeof(XkbDeviceChangesRec));

-    changes.changed= 		XkbXI_ButtonActionsMask;

-    changes.first_btn=		first;

-    changes.num_btns=		nBtns;

-    changes.leds.led_class=	XkbXINone;

-    changes.leds.led_id=	XkbXINone;

-    changes.leds.defined=	0;

-    size= nLeds= 		0;

-    if (_XkbSetDeviceInfoSize(devi,&changes,NULL,&size,&nLeds)!=Success)

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetDeviceInfo, req);

-    req->length+=	size/4;

-    req->reqType= 	xkbi->codes->major_opcode;

-    req->xkbReqType= 	X_kbSetDeviceInfo;

-    req->deviceSpec= 	devi->device_spec;

-    req->firstBtn=	changes.first_btn;

-    req->nBtns=		changes.num_btns;

-    req->change=	changes.changed;

-    req->nDeviceLedFBs=	nLeds;

-    if (size>0) {

-	char * 	wire;

-	BufAlloc(char *,wire,size);

-	ok= (wire!=NULL)&&

-		(_XkbWriteSetDeviceInfo(wire,&changes,&lstuff,devi)==size);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return ok;

-}

+/************************************************************
+Copyright (c) 1995 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>
+#define	NEED_MAP_READERS
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+#include <X11/extensions/XI.h>
+
+/***====================================================================***/
+
+extern void
+XkbNoteDeviceChanges(	XkbDeviceChangesPtr		old,
+			XkbExtensionDeviceNotifyEvent *	new,
+			unsigned int			wanted)
+{
+    if ((!old)||(!new)||(!wanted)||((new->reason&wanted)==0))
+	return;
+    if ((wanted&new->reason)&XkbXI_ButtonActionsMask) {
+	if (old->changed&XkbXI_ButtonActionsMask) {
+	    int first,last,newLast;
+	    if (new->first_btn<old->first_btn)
+		 first= new->first_btn;
+	    else first= old->first_btn;
+	    last= old->first_btn+old->num_btns-1;
+	    newLast= new->first_btn+new->num_btns-1;
+	    if (newLast>last)
+		last= newLast;
+	    old->first_btn= first;
+	    old->num_btns= (last-first)+1;
+	}
+	else {
+	    old->changed|= XkbXI_ButtonActionsMask;
+	    old->first_btn= new->first_btn;
+	    old->num_btns= new->num_btns;
+	}
+    }
+    if ((wanted&new->reason)&XkbXI_IndicatorsMask) {
+	XkbDeviceLedChangesPtr this;
+	if (old->changed&XkbXI_IndicatorsMask) {
+	    XkbDeviceLedChangesPtr found;
+	    found= NULL;
+	    for (this= &old->leds;this&&(!found);this=this->next) {
+		if ((this->led_class==new->led_class)&&
+						(this->led_id==new->led_id)) {
+		    found= this;
+		}
+	    }
+	    if (!found) {
+		found= _XkbTypedCalloc(1,XkbDeviceLedChangesRec);
+		if (!found)
+		    return;
+		found->next= old->leds.next;
+		found->led_class= new->led_class;
+		found->led_id= new->led_id;
+		old->leds.next= found;
+	    }
+	    if ((wanted&new->reason)&XkbXI_IndicatorNamesMask)
+		found->defined= new->leds_defined;
+	}
+	else {
+	    old->changed|= ((wanted&new->reason)&XkbXI_IndicatorsMask);
+	    old->leds.led_class= new->led_class;
+	    old->leds.led_id= new->led_id;
+	    old->leds.defined= new->leds_defined;
+	    if (old->leds.next) {
+		XkbDeviceLedChangesPtr next;
+		for (this=old->leds.next;this;this=next) {
+		    next= this->next;
+		    _XkbFree(this);
+		}
+		old->leds.next= NULL;
+	    }
+	}
+    }
+    return;
+}
+
+/***====================================================================***/
+
+static Status
+_XkbReadDeviceLedInfo(	XkbReadBufferPtr	buf,
+			unsigned 		present,
+			XkbDeviceInfoPtr 	devi)
+{
+register unsigned	i,bit;
+XkbDeviceLedInfoPtr	devli;
+xkbDeviceLedsWireDesc *	wireli;
+
+    wireli= _XkbGetTypedRdBufPtr(buf,1,xkbDeviceLedsWireDesc);
+    if (!wireli)
+	return BadLength;
+    devli= XkbAddDeviceLedInfo(devi,wireli->ledClass,wireli->ledID);
+    if (!devli)
+	return BadAlloc;
+    devli->phys_indicators= 	wireli->physIndicators;
+
+    if (present&XkbXI_IndicatorStateMask)
+	devli->state= wireli->state;
+
+    if (present&XkbXI_IndicatorNamesMask) {
+	devli->names_present= 	wireli->namesPresent;
+	if (devli->names_present) {
+	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
+		if (wireli->namesPresent&bit) {
+		    if (!_XkbCopyFromReadBuffer(buf,(char *)&devli->names[i],4))
+			return BadLength;
+		}
+	    }
+	}
+    }
+
+    if (present&XkbXI_IndicatorMapsMask) {
+	devli->maps_present= 	wireli->mapsPresent;
+	if (devli->maps_present) {
+	    XkbIndicatorMapPtr	 	im;
+	    xkbIndicatorMapWireDesc *	wireim;
+	    for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
+		if (wireli->mapsPresent&bit) {
+		    wireim= _XkbGetTypedRdBufPtr(buf,1,xkbIndicatorMapWireDesc);
+		    if (!wireim)
+			return BadAlloc;
+		    im= &devli->maps[i];
+		    im->flags= 		wireim->flags;
+		    im->which_groups= 	wireim->whichGroups;
+		    im->groups= 	wireim->groups;
+		    im->which_mods= 	wireim->whichMods;
+		    im->mods.mask= 	wireim->mods;
+		    im->mods.real_mods= wireim->realMods;
+		    im->mods.vmods= 	wireim->virtualMods;
+		    im->ctrls= 		wireim->ctrls;
+		}
+	    }
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadGetDeviceInfoReply(	Display *		dpy,
+				xkbGetDeviceInfoReply *	rep,
+				XkbDeviceInfoPtr	devi)
+{
+XkbReadBufferRec	buf;
+XkbAction *		act;
+int			tmp;
+
+    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))
+	return BadAlloc;
+
+    if ((rep->totalBtns>0)&&(rep->totalBtns!=devi->num_btns)) {
+	tmp= XkbResizeDeviceButtonActions(devi,rep->totalBtns);
+	if (tmp!=Success)
+	    return tmp;
+    }
+    if (rep->nBtnsWanted>0) {
+	act= &devi->btn_acts[rep->firstBtnWanted];
+	bzero((char *)act,(rep->nBtnsWanted*sizeof(XkbAction)));
+    }
+    if (devi->name!=NULL)
+	_XkbFree(devi->name);
+    if (!_XkbGetReadBufferCountedString(&buf,&devi->name))
+	goto BAILOUT;
+    if (rep->nBtnsRtrn>0) {
+	int size;
+	act= &devi->btn_acts[rep->firstBtnRtrn];
+	size= rep->nBtnsRtrn*SIZEOF(xkbActionWireDesc);
+	if (!_XkbCopyFromReadBuffer(&buf,(char *)act,size))
+	    goto BAILOUT;
+    }
+    if (rep->nDeviceLedFBs>0) {
+	register int 		i;
+	for (i=0;i<rep->nDeviceLedFBs;i++) {
+	    if ((tmp= _XkbReadDeviceLedInfo(&buf,rep->present,devi))!=Success)
+		return tmp;
+	}
+    }
+    tmp= _XkbFreeReadBuffer(&buf);
+    if (tmp)
+	fprintf(stderr,"GetDeviceInfo! Bad length (%d extra bytes)\n",tmp);
+    if (tmp || buf.error)
+	return BadLength;
+    return Success;
+BAILOUT:
+    _XkbFreeReadBuffer(&buf);
+    return BadLength;
+}
+
+XkbDeviceInfoPtr
+XkbGetDeviceInfo(	Display *	dpy,
+			unsigned 	which,
+			unsigned 	deviceSpec,
+			unsigned 	class,
+			unsigned 	id)
+{
+    register xkbGetDeviceInfoReq *	req;
+    xkbGetDeviceInfoReply	 	rep;
+    Status				status;
+    XkbDeviceInfoPtr			devi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return NULL;
+    LockDisplay(dpy);
+    GetReq(kbGetDeviceInfo, req);
+    req->reqType = dpy->xkb_info->codes->major_opcode;
+    req->xkbReqType = X_kbGetDeviceInfo;
+    req->deviceSpec = deviceSpec;
+    req->wanted= which;
+    req->allBtns= ((which&XkbXI_ButtonActionsMask)!=0);
+    req->firstBtn= req->nBtns= 0;
+    req->ledClass= class;
+    req->ledID= id;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return NULL;
+    }
+    devi= XkbAllocDeviceInfo(rep.deviceID,rep.totalBtns,rep.nDeviceLedFBs);
+    if (devi) {
+	devi->supported= rep.supported;
+	devi->unsupported= rep.unsupported;
+	devi->type= rep.devType;
+	devi->has_own_state= rep.hasOwnState;
+	devi->dflt_kbd_fb = rep.dfltKbdFB;
+	devi->dflt_led_fb = rep.dfltLedFB;
+	status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);
+	if (status!=Success) {
+	    XkbFreeDeviceInfo(devi,XkbXI_AllDeviceFeaturesMask,True);
+	    devi= NULL;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return devi;
+}
+
+Status
+XkbGetDeviceInfoChanges(	Display *		dpy,
+				XkbDeviceInfoPtr 	devi,
+				XkbDeviceChangesPtr	changes)
+{
+    register xkbGetDeviceInfoReq *	req;
+    xkbGetDeviceInfoReply	 	rep;
+    Status				status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadMatch;
+    if ((changes->changed&XkbXI_AllDeviceFeaturesMask)==0)
+	return Success;
+    changes->changed&= ~XkbXI_AllDeviceFeaturesMask;
+    status= Success;
+    LockDisplay(dpy);
+    while ((changes->changed)&&(status==Success)) {
+	GetReq(kbGetDeviceInfo, req);
+	req->reqType = dpy->xkb_info->codes->major_opcode;
+	req->xkbReqType = X_kbGetDeviceInfo;
+	req->deviceSpec = devi->device_spec;
+	req->wanted= changes->changed;
+	req->allBtns= False;
+	if (changes->changed&XkbXI_ButtonActionsMask) {
+	     req->firstBtn= changes->first_btn;
+	     req->nBtns= 	changes->num_btns;
+	     changes->changed&= ~XkbXI_ButtonActionsMask;
+	}
+	else req->firstBtn= req->nBtns= 0;
+	if (changes->changed&XkbXI_IndicatorsMask) {
+	    req->ledClass= changes->leds.led_class;
+	    req->ledID= changes->leds.led_id;
+	    if (changes->leds.next==NULL)
+		changes->changed&= ~XkbXI_IndicatorsMask;
+	    else {
+		XkbDeviceLedChangesPtr next;
+		next= changes->leds.next;
+		changes->leds= *next;
+		_XkbFree(next);
+	    }
+	}
+	else {
+	    req->ledClass= XkbDfltXIClass;
+	    req->ledID= XkbDfltXIId;
+	}
+	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	    status= BadLength;
+	    break;
+	}
+	devi->supported|= rep.supported;
+	devi->unsupported|= rep.unsupported;
+	devi->type= rep.devType;
+	status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetDeviceButtonActions(	Display *		dpy,
+				XkbDeviceInfoPtr	devi,
+				Bool			all,
+				unsigned int		first,
+				unsigned int		num)
+{
+    register xkbGetDeviceInfoReq *	req;
+    xkbGetDeviceInfoReply	 	rep;
+    Status				status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadMatch;
+    if (!devi)
+	return BadValue;
+    LockDisplay(dpy);
+    GetReq(kbGetDeviceInfo, req);
+    req->reqType = dpy->xkb_info->codes->major_opcode;
+    req->xkbReqType = X_kbGetDeviceInfo;
+    req->deviceSpec = devi->device_spec;
+    req->wanted= XkbXI_ButtonActionsMask;
+    req->allBtns= all;
+    req->firstBtn= first;
+    req->nBtns= num;
+    req->ledClass= XkbDfltXIClass;
+    req->ledID= XkbDfltXIId;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadLength;
+    }
+    devi->type= rep.devType;
+    devi->supported= rep.supported;
+    devi->unsupported= rep.unsupported;
+    status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetDeviceLedInfo(	Display *		dpy,
+			XkbDeviceInfoPtr	devi,
+			unsigned int		ledClass,
+			unsigned int		ledId,
+			unsigned int		which)
+{
+    register xkbGetDeviceInfoReq *	req;
+    xkbGetDeviceInfoReply	 	rep;
+    Status				status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadMatch;
+    if (((which&XkbXI_IndicatorsMask)==0)||(which&(~XkbXI_IndicatorsMask)))
+	return BadMatch;
+    if (!devi)
+	return BadValue;
+    LockDisplay(dpy);
+    GetReq(kbGetDeviceInfo, req);
+    req->reqType = dpy->xkb_info->codes->major_opcode;
+    req->xkbReqType = X_kbGetDeviceInfo;
+    req->deviceSpec = devi->device_spec;
+    req->wanted= which;
+    req->allBtns= False;
+    req->firstBtn= req->nBtns= 0;
+    req->ledClass= ledClass;
+    req->ledID= ledId;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadLength;
+    }
+    devi->type= rep.devType;
+    devi->supported= rep.supported;
+    devi->unsupported= rep.unsupported;
+    status= _XkbReadGetDeviceInfoReply(dpy,&rep,devi);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+/***====================================================================***/
+
+typedef struct _LedInfoStuff {
+	Bool			used;
+	XkbDeviceLedInfoPtr	devli;
+} LedInfoStuff;
+
+typedef struct _SetLedStuff {
+	unsigned		wanted;
+	int			num_info;
+	int			dflt_class;
+	LedInfoStuff *		dflt_kbd_fb;
+	LedInfoStuff *		dflt_led_fb;
+	LedInfoStuff *		info;
+} SetLedStuff;
+
+static void
+_InitLedStuff(SetLedStuff *stuff,unsigned wanted,XkbDeviceInfoPtr devi)
+{
+int				i;
+register XkbDeviceLedInfoPtr	devli;
+
+    bzero(stuff,sizeof(SetLedStuff));
+    stuff->wanted= wanted;
+    stuff->dflt_class=	XkbXINone;
+    if ((devi->num_leds<1)||((wanted&XkbXI_IndicatorsMask)==0))
+	return;
+    stuff->info= _XkbTypedCalloc(devi->num_leds,LedInfoStuff);
+    if (!stuff->info)
+	return;
+    stuff->num_info= devi->num_leds;
+    for (devli=&devi->leds[0],i=0;i<devi->num_leds;i++,devli++) {
+	stuff->info[i].devli= devli;
+	if (devli->led_class==KbdFeedbackClass) {
+	    stuff->dflt_class= KbdFeedbackClass;
+	    if (stuff->dflt_kbd_fb==NULL)
+		stuff->dflt_kbd_fb= &stuff->info[i];
+	}
+	else if (devli->led_class==LedFeedbackClass) {
+	    if (stuff->dflt_class==XkbXINone)
+		stuff->dflt_class= LedFeedbackClass;
+	    if (stuff->dflt_led_fb==NULL)
+		stuff->dflt_led_fb= &stuff->info[i];
+	}
+    }
+    return;
+}
+
+static void
+_FreeLedStuff(SetLedStuff *stuff)
+{
+    if ((stuff->num_info>0)&&(stuff->info!=NULL))
+	_XkbFree(stuff->info);
+    bzero(stuff,sizeof(SetLedStuff));
+    return;
+}
+
+static int
+_XkbSizeLedInfo(unsigned changed,XkbDeviceLedInfoPtr devli)
+{
+register int i,size;
+register unsigned bit,namesNeeded,mapsNeeded;
+
+    size= SIZEOF(xkbDeviceLedsWireDesc);
+    namesNeeded= mapsNeeded= 0;
+    if (changed&XkbXI_IndicatorNamesMask)
+	namesNeeded= devli->names_present;
+    if (changed&XkbXI_IndicatorMapsMask)
+	mapsNeeded= devli->maps_present;
+    if ((namesNeeded)||(mapsNeeded)) {
+	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
+	    if (namesNeeded&bit)
+		size+= 4; /* atoms are 4 bytes on the wire */
+	    if (mapsNeeded&bit)
+		size+= SIZEOF(xkbIndicatorMapWireDesc);
+	}
+    }
+    return size;
+}
+
+static Bool
+_SizeMatches(	SetLedStuff *		stuff,
+		XkbDeviceLedChangesPtr 	changes,
+		int *			sz_rtrn,
+		int *			nleds_rtrn)
+{
+int		i,nMatch,class,id;
+LedInfoStuff *	linfo;
+Bool		match;
+
+    nMatch= 0;
+    class= changes->led_class;
+    id= changes->led_id;
+    if (class==XkbDfltXIClass)
+	class= stuff->dflt_class;
+    for (i=0,linfo=&stuff->info[0];i<stuff->num_info;i++,linfo++) {
+	XkbDeviceLedInfoPtr	devli;
+	LedInfoStuff *		dflt;
+
+	devli= linfo->devli;
+	match= ((class==devli->led_class)||(class==XkbAllXIClasses));
+	if (devli->led_class==KbdFeedbackClass)	dflt= stuff->dflt_kbd_fb;
+	else					dflt= stuff->dflt_led_fb;
+	match = (match && (id == devli->led_id)) ||
+	  (id == XkbAllXIIds) ||
+	  ((id == XkbDfltXIId) &&
+	   (linfo == dflt));
+	if (match) {
+	    if (!linfo->used) {
+		*sz_rtrn+= _XkbSizeLedInfo(stuff->wanted,devli);
+		*nleds_rtrn+= 1;
+		linfo->used= True;
+		if ((class!=XkbAllXIClasses)&&(id!=XkbAllXIIds))
+		    return True;
+	    }
+	    nMatch++;
+	    linfo->used= True;
+	}
+    }
+    return (nMatch>0);
+}
+
+/***====================================================================***/
+
+
+static Status
+_XkbSetDeviceInfoSize(	XkbDeviceInfoPtr	devi,
+			XkbDeviceChangesPtr	changes,
+			SetLedStuff *		stuff,
+			int *			sz_rtrn,
+			int *			num_leds_rtrn)
+{
+    *sz_rtrn= 0;
+    if ((changes->changed&XkbXI_ButtonActionsMask)&&(changes->num_btns>0)) {
+	if (!XkbXI_LegalDevBtn(devi,(changes->first_btn+changes->num_btns-1)))
+	    return BadMatch;
+	*sz_rtrn+= changes->num_btns*SIZEOF(xkbActionWireDesc);
+    }
+    else {
+	changes->changed&= ~XkbXI_ButtonActionsMask;
+	changes->first_btn= changes->num_btns= 0;
+    }
+    if ((changes->changed&XkbXI_IndicatorsMask)&&
+				XkbLegalXILedClass(changes->leds.led_class)) {
+	XkbDeviceLedChangesPtr	leds;
+
+	for (leds=&changes->leds;leds!=NULL;leds= leds->next) {
+	    if (!_SizeMatches(stuff,leds,sz_rtrn,num_leds_rtrn))
+		return BadMatch;
+	}
+    }
+    else {
+	changes->changed&= ~XkbXI_IndicatorsMask;
+	*num_leds_rtrn= 0;
+    }
+    return Success;
+}
+
+static char *
+_XkbWriteLedInfo(char *wire,unsigned changed,XkbDeviceLedInfoPtr devli)
+{
+register int 		i;
+register unsigned 	bit,namesNeeded,mapsNeeded;
+xkbDeviceLedsWireDesc *	lwire;
+
+    namesNeeded= mapsNeeded= 0;
+    if (changed&XkbXI_IndicatorNamesMask)
+	namesNeeded= devli->names_present;
+    if (changed&XkbXI_IndicatorMapsMask)
+	mapsNeeded= devli->maps_present;
+
+    lwire= (xkbDeviceLedsWireDesc *)wire;
+    lwire->ledClass= devli->led_class;
+    lwire->ledID= devli->led_id;
+    lwire->namesPresent= namesNeeded;
+    lwire->mapsPresent=  mapsNeeded;
+    lwire->physIndicators= devli->phys_indicators;
+    lwire->state= devli->state;
+    wire= (char *)&lwire[1];
+    if (namesNeeded) {
+	CARD32 *awire;
+	awire= (CARD32 *)wire;
+	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
+	    if (namesNeeded&bit) {
+		*awire= (CARD32)devli->names[i];
+		awire++;
+	    }
+	}
+	wire= (char *)awire;
+    }
+    if (mapsNeeded) {
+	xkbIndicatorMapWireDesc *mwire;
+
+	mwire= (xkbIndicatorMapWireDesc *)wire;
+	for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
+	    if (mapsNeeded&bit) {
+		XkbIndicatorMapPtr	map;
+		map= 			&devli->maps[i];
+		mwire->flags= 		map->flags;
+		mwire->whichGroups=	map->which_groups;
+		mwire->groups=		map->groups;
+		mwire->whichMods=	map->which_mods;
+		mwire->mods=		map->mods.mask;
+		mwire->realMods=	map->mods.real_mods;
+		mwire->virtualMods=	map->mods.vmods;
+		mwire->ctrls=		map->ctrls;
+		mwire++;
+	    }
+	}
+	wire= (char *)mwire;
+    }
+    return wire;
+}
+
+
+static int
+_XkbWriteSetDeviceInfo(	char *			wire,
+			XkbDeviceChangesPtr	changes,
+			SetLedStuff *		stuff,
+			XkbDeviceInfoPtr	devi)
+{
+char *start;
+
+    start= wire;
+    if (changes->changed&XkbXI_ButtonActionsMask) {
+	int			size;
+	size= changes->num_btns*SIZEOF(xkbActionWireDesc);
+	memcpy(wire,(char *)&devi->btn_acts[changes->first_btn],size);
+	wire+= size;
+    }
+    if (changes->changed&XkbXI_IndicatorsMask) {
+	register int i;
+	register LedInfoStuff *linfo;
+
+	for (i=0,linfo=&stuff->info[0];i<stuff->num_info;i++,linfo++) {
+	    if (linfo->used) {
+		register char *new_wire;
+		new_wire= _XkbWriteLedInfo(wire,stuff->wanted,linfo->devli);
+		if (!new_wire)
+		    return wire-start;
+		wire= new_wire;
+	    }
+	}
+    }
+    return wire-start;
+}
+
+Bool
+XkbSetDeviceInfo(	Display *		dpy,
+			unsigned 		which,
+			XkbDeviceInfoPtr	devi)
+{
+    register xkbSetDeviceInfoReq *req;
+    Status		     	ok = 0;
+    int				size,nLeds;
+    XkbInfoPtr 			xkbi;
+    XkbDeviceChangesRec		changes;
+    SetLedStuff			lstuff;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!devi) || (which&(~XkbXI_AllDeviceFeaturesMask)) ||
+	((which&XkbXI_ButtonActionsMask)&&(!XkbXI_DevHasBtnActs(devi)))||
+	((which&XkbXI_IndicatorsMask)&&(!XkbXI_DevHasLeds(devi))))
+	return False;
+
+    bzero((char *)&changes,sizeof(XkbDeviceChangesRec));
+    changes.changed= which;
+    changes.first_btn=		0;
+    changes.num_btns=		devi->num_btns;
+    changes.leds.led_class=	XkbAllXIClasses;
+    changes.leds.led_id=	XkbAllXIIds;
+    changes.leds.defined=	0;
+    size= nLeds= 		0;
+    _InitLedStuff(&lstuff,changes.changed,devi);
+    if (_XkbSetDeviceInfoSize(devi,&changes,&lstuff,&size,&nLeds)!=Success)
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetDeviceInfo, req);
+    req->length+=	size/4;
+    req->reqType= 	xkbi->codes->major_opcode;
+    req->xkbReqType= 	X_kbSetDeviceInfo;
+    req->deviceSpec= 	devi->device_spec;
+    req->firstBtn=	changes.first_btn;
+    req->nBtns=		changes.num_btns;
+    req->change=	changes.changed;
+    req->nDeviceLedFBs=	nLeds;
+    if (size>0) {
+	char * 	wire;
+	BufAlloc(char *,wire,size);
+	ok= (wire!=NULL)&&
+		(_XkbWriteSetDeviceInfo(wire,&changes,&lstuff,devi)==size);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    _FreeLedStuff(&lstuff);
+    /* 12/11/95 (ef) -- XXX!! should clear changes here */
+    return ok;
+}
+
+Bool
+XkbChangeDeviceInfo(	Display *		dpy,
+			XkbDeviceInfoPtr	devi,
+			XkbDeviceChangesPtr	changes)
+{
+    register xkbSetDeviceInfoReq *req;
+    Status		     	ok = 0;
+    int				size,nLeds;
+    XkbInfoPtr 			xkbi;
+    SetLedStuff			lstuff;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!devi) || (changes->changed&(~XkbXI_AllDeviceFeaturesMask)) ||
+	((changes->changed&XkbXI_ButtonActionsMask)&&
+					(!XkbXI_DevHasBtnActs(devi)))||
+	((changes->changed&XkbXI_IndicatorsMask)&&(!XkbXI_DevHasLeds(devi))))
+	return False;
+
+    size= nLeds= 0;
+    _InitLedStuff(&lstuff,changes->changed,devi);
+    if (_XkbSetDeviceInfoSize(devi,changes,&lstuff,&size,&nLeds)!=Success)
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetDeviceInfo, req);
+    req->length+=	size/4;
+    req->reqType= 	xkbi->codes->major_opcode;
+    req->xkbReqType= 	X_kbSetDeviceInfo;
+    req->deviceSpec= 	devi->device_spec;
+    req->firstBtn=	changes->first_btn;
+    req->nBtns=		changes->num_btns;
+    req->change=	changes->changed;
+    req->nDeviceLedFBs=	nLeds;
+    if (size>0) {
+	char * 	wire;
+	BufAlloc(char *,wire,size);
+	ok= (wire!=NULL)&&
+		(_XkbWriteSetDeviceInfo(wire,changes,&lstuff,devi)==size);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    _FreeLedStuff(&lstuff);
+    /* 12/11/95 (ef) -- XXX!! should clear changes here */
+    return ok;
+}
+
+Bool
+XkbSetDeviceLedInfo(	Display *		dpy,
+			XkbDeviceInfoPtr	devi,
+			unsigned 		ledClass,
+			unsigned		ledID,
+			unsigned		which)
+{
+    return False;
+}
+
+Bool
+XkbSetDeviceButtonActions(	Display *		dpy,
+				XkbDeviceInfoPtr 	devi,
+				unsigned int		first,
+				unsigned int		nBtns)
+{
+    register xkbSetDeviceInfoReq *req;
+    Status		     	ok = 0;
+    int				size,nLeds;
+    XkbInfoPtr 			xkbi;
+    XkbDeviceChangesRec		changes;
+    SetLedStuff			lstuff;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!devi)||(!XkbXI_DevHasBtnActs(devi))||(first+nBtns>devi->num_btns))
+	return False;
+    if (nBtns==0)
+	return True;
+
+    bzero((char *)&changes,sizeof(XkbDeviceChangesRec));
+    changes.changed= 		XkbXI_ButtonActionsMask;
+    changes.first_btn=		first;
+    changes.num_btns=		nBtns;
+    changes.leds.led_class=	XkbXINone;
+    changes.leds.led_id=	XkbXINone;
+    changes.leds.defined=	0;
+    size= nLeds= 		0;
+    if (_XkbSetDeviceInfoSize(devi,&changes,NULL,&size,&nLeds)!=Success)
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetDeviceInfo, req);
+    req->length+=	size/4;
+    req->reqType= 	xkbi->codes->major_opcode;
+    req->xkbReqType= 	X_kbSetDeviceInfo;
+    req->deviceSpec= 	devi->device_spec;
+    req->firstBtn=	changes.first_btn;
+    req->nBtns=		changes.num_btns;
+    req->change=	changes.changed;
+    req->nDeviceLedFBs=	nLeds;
+    if (size>0) {
+	char * 	wire;
+	BufAlloc(char *,wire,size);
+	ok= (wire!=NULL)&&
+		(_XkbWriteSetDeviceInfo(wire,&changes,&lstuff,devi)==size);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return ok;
+}
diff --git a/libX11/src/xkb/XKBGetByName.c b/libX11/src/xkb/XKBGetByName.c
index 9417238ce..8e4f55458 100644
--- a/libX11/src/xkb/XKBGetByName.c
+++ b/libX11/src/xkb/XKBGetByName.c
@@ -1,214 +1,214 @@
-/************************************************************

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

-

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

-

-#define	NEED_MAP_READERS

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

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

-

-XkbDescPtr

-XkbGetKeyboardByName(	Display *		dpy,

-			unsigned		deviceSpec,

-			XkbComponentNamesPtr	names,

-			unsigned		want,

-			unsigned		need,

-			Bool			load)

-{

-    register xkbGetKbdByNameReq	*	req;

-    xkbGetKbdByNameReply 		rep;

-    int					len,extraLen;

-    char *				str;

-    XkbDescPtr				xkb;

-    int					mapLen,codesLen,typesLen,compatLen;

-    int					symsLen,geomLen;

-    XkbInfoPtr 				xkbi;

-

-    if ( (dpy==NULL) || (dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)) )

-	return NULL;

-

-    xkbi= dpy->xkb_info;

-    xkb = (XkbDescRec *)_XkbCalloc(1,sizeof(XkbDescRec));

-    if (!xkb)

-	return NULL;

-    xkb->device_spec = deviceSpec;

-    xkb->map = (XkbClientMapRec *)_XkbCalloc(1,sizeof(XkbClientMapRec));

-    xkb->dpy = dpy;

-

-    LockDisplay(dpy);

-    GetReq(kbGetKbdByName, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetKbdByName;

-    req->deviceSpec = xkb->device_spec;

-    req->want= want;

-    req->need= need;

-    req->load= load;

-

-    mapLen= codesLen= typesLen= compatLen= symsLen= geomLen= 0;

-    if (names) {

-	if (names->keymap)

-	    mapLen= (int)strlen(names->keymap);

-	if (names->keycodes)

-	    codesLen= (int)strlen(names->keycodes);

-	if (names->types)

-	    typesLen= (int)strlen(names->types);

-	if (names->compat)

-	    compatLen= (int)strlen(names->compat);

-	if (names->symbols)

-	    symsLen= (int)strlen(names->symbols);

-	if (names->geometry)

-	    geomLen= (int)strlen(names->geometry);

-	if (mapLen>255)		mapLen= 255;

-	if (codesLen>255)	codesLen= 255;

-	if (typesLen>255)	typesLen= 255;

-	if (compatLen>255)	compatLen= 255;

-	if (symsLen>255)	symsLen= 255;

-	if (geomLen>255)	geomLen= 255;

-    }

-    else mapLen= codesLen= typesLen= compatLen= symsLen= geomLen= 0;

-

-    len= mapLen+codesLen+typesLen+compatLen+symsLen+geomLen+6;

-    len= XkbPaddedSize(len);

-    req->length+= len/4;

-    BufAlloc(char *,str,len);

-    *str++= mapLen;

-    if (mapLen>0) {

-	 memcpy(str,names->keymap,mapLen);

-	 str+= mapLen;

-    }

-    *str++= codesLen;

-    if (codesLen>0) {

-	 memcpy(str,names->keycodes,codesLen);

-	 str+= codesLen;

-    }

-    *str++= typesLen;

-    if (typesLen>0) {

-	 memcpy(str,names->types,typesLen);

-	 str+= typesLen;

-    }

-    *str++= compatLen;

-    if (compatLen>0) {

-	 memcpy(str,names->compat,compatLen);

-	 str+= compatLen;

-    }

-    *str++= symsLen;

-    if (symsLen>0) {

-	 memcpy(str,names->symbols,symsLen);

-	 str+= symsLen;

-    }

-    *str++= geomLen;

-    if (geomLen>0) {

-	 memcpy(str,names->geometry,geomLen);

-	 str+= geomLen;

-    }

-    if ((!_XReply(dpy, (xReply *)&rep, 0, xFalse))||(!rep.reported))

-	goto BAILOUT;

-    extraLen= (int)rep.length*4;

-

-    xkb->device_spec= rep.deviceID;

-    xkb->min_key_code = rep.minKeyCode;

-    xkb->max_key_code = rep.maxKeyCode;

-    if (rep.reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask)) {

-	xkbGetMapReply 	mrep;

-	Status		status;

-	int		nread= 0;

-

-	_XRead(dpy, (char *)&mrep, SIZEOF(xkbGetMapReply));

-	extraLen-= SIZEOF(xkbGetMapReply);

-	status= _XkbReadGetMapReply(dpy,&mrep,xkb,&nread);

-	extraLen-= nread;

-	if (status!=Success)

-	    goto BAILOUT;

-    }

-    if (rep.reported&XkbGBN_CompatMapMask) {

-	xkbGetCompatMapReply 	crep;

-	Status			status;

-	int			nread= 0;

-

-	_XRead(dpy, (char *)&crep, SIZEOF(xkbGetCompatMapReply));

-	extraLen-= SIZEOF(xkbGetCompatMapReply);

-	status= _XkbReadGetCompatMapReply(dpy,&crep,xkb,&nread);

-	extraLen-= nread;

-	if (status!=Success)

-	    goto BAILOUT;

-    }

-    if (rep.reported&XkbGBN_IndicatorMapMask) {

-	xkbGetIndicatorMapReply irep;

-	Status			status;

-	int			nread= 0;

-

-	_XRead(dpy, (char *)&irep, SIZEOF(xkbGetIndicatorMapReply));

-	extraLen-= SIZEOF(xkbGetIndicatorMapReply);

-	status= _XkbReadGetIndicatorMapReply(dpy,&irep,xkb,&nread);

-	extraLen-= nread;

-	if (status!=Success)

-	    goto BAILOUT;

-    }

-    if (rep.reported&(XkbGBN_KeyNamesMask|XkbGBN_OtherNamesMask)) {

-	xkbGetNamesReply	nrep;

-	Status			status;

-	int			nread= 0;

-

-	_XRead(dpy, (char *)&nrep, SIZEOF(xkbGetNamesReply));

-	extraLen-= SIZEOF(xkbGetNamesReply);

-	status= _XkbReadGetNamesReply(dpy,&nrep,xkb,&nread);

-	extraLen-= nread;

-	if (status!=Success)

-	    goto BAILOUT;

-    }

-    if (rep.reported&XkbGBN_GeometryMask) {

-	xkbGetGeometryReply	grep;

-	Status			status;

-	int			nread= 0;

-

-	_XRead(dpy, (char *)&grep, SIZEOF(xkbGetGeometryReply));

-	extraLen-= SIZEOF(xkbGetGeometryReply);

-	status= _XkbReadGetGeometryReply(dpy,&grep,xkb,&nread);

-	extraLen-= nread;

-	if (status!=Success)

-	    goto BAILOUT;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return xkb;

-BAILOUT:

-    if (xkb!=NULL)

-	XkbFreeKeyboard(xkb,XkbAllComponentsMask,xTrue);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return NULL;

-}

-

-XkbDescPtr

-XkbGetKeyboard(Display *dpy,unsigned which,unsigned deviceSpec)

-{

-    return XkbGetKeyboardByName(dpy,deviceSpec,NULL,which,which,False);

-}

+/************************************************************
+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.
+
+********************************************************/
+
+#define	NEED_MAP_READERS
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+/***====================================================================***/
+
+XkbDescPtr
+XkbGetKeyboardByName(	Display *		dpy,
+			unsigned		deviceSpec,
+			XkbComponentNamesPtr	names,
+			unsigned		want,
+			unsigned		need,
+			Bool			load)
+{
+    register xkbGetKbdByNameReq	*	req;
+    xkbGetKbdByNameReply 		rep;
+    int					len,extraLen;
+    char *				str;
+    XkbDescPtr				xkb;
+    int					mapLen,codesLen,typesLen,compatLen;
+    int					symsLen,geomLen;
+    XkbInfoPtr 				xkbi;
+
+    if ( (dpy==NULL) || (dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)) )
+	return NULL;
+
+    xkbi= dpy->xkb_info;
+    xkb = (XkbDescRec *)_XkbCalloc(1,sizeof(XkbDescRec));
+    if (!xkb)
+	return NULL;
+    xkb->device_spec = deviceSpec;
+    xkb->map = (XkbClientMapRec *)_XkbCalloc(1,sizeof(XkbClientMapRec));
+    xkb->dpy = dpy;
+
+    LockDisplay(dpy);
+    GetReq(kbGetKbdByName, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetKbdByName;
+    req->deviceSpec = xkb->device_spec;
+    req->want= want;
+    req->need= need;
+    req->load= load;
+
+    mapLen= codesLen= typesLen= compatLen= symsLen= geomLen= 0;
+    if (names) {
+	if (names->keymap)
+	    mapLen= (int)strlen(names->keymap);
+	if (names->keycodes)
+	    codesLen= (int)strlen(names->keycodes);
+	if (names->types)
+	    typesLen= (int)strlen(names->types);
+	if (names->compat)
+	    compatLen= (int)strlen(names->compat);
+	if (names->symbols)
+	    symsLen= (int)strlen(names->symbols);
+	if (names->geometry)
+	    geomLen= (int)strlen(names->geometry);
+	if (mapLen>255)		mapLen= 255;
+	if (codesLen>255)	codesLen= 255;
+	if (typesLen>255)	typesLen= 255;
+	if (compatLen>255)	compatLen= 255;
+	if (symsLen>255)	symsLen= 255;
+	if (geomLen>255)	geomLen= 255;
+    }
+    else mapLen= codesLen= typesLen= compatLen= symsLen= geomLen= 0;
+
+    len= mapLen+codesLen+typesLen+compatLen+symsLen+geomLen+6;
+    len= XkbPaddedSize(len);
+    req->length+= len/4;
+    BufAlloc(char *,str,len);
+    *str++= mapLen;
+    if (mapLen>0) {
+	 memcpy(str,names->keymap,mapLen);
+	 str+= mapLen;
+    }
+    *str++= codesLen;
+    if (codesLen>0) {
+	 memcpy(str,names->keycodes,codesLen);
+	 str+= codesLen;
+    }
+    *str++= typesLen;
+    if (typesLen>0) {
+	 memcpy(str,names->types,typesLen);
+	 str+= typesLen;
+    }
+    *str++= compatLen;
+    if (compatLen>0) {
+	 memcpy(str,names->compat,compatLen);
+	 str+= compatLen;
+    }
+    *str++= symsLen;
+    if (symsLen>0) {
+	 memcpy(str,names->symbols,symsLen);
+	 str+= symsLen;
+    }
+    *str++= geomLen;
+    if (geomLen>0) {
+	 memcpy(str,names->geometry,geomLen);
+	 str+= geomLen;
+    }
+    if ((!_XReply(dpy, (xReply *)&rep, 0, xFalse))||(!rep.reported))
+	goto BAILOUT;
+    extraLen= (int)rep.length*4;
+
+    xkb->device_spec= rep.deviceID;
+    xkb->min_key_code = rep.minKeyCode;
+    xkb->max_key_code = rep.maxKeyCode;
+    if (rep.reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask)) {
+	xkbGetMapReply 	mrep;
+	Status		status;
+	int		nread= 0;
+
+	_XRead(dpy, (char *)&mrep, SIZEOF(xkbGetMapReply));
+	extraLen-= SIZEOF(xkbGetMapReply);
+	status= _XkbReadGetMapReply(dpy,&mrep,xkb,&nread);
+	extraLen-= nread;
+	if (status!=Success)
+	    goto BAILOUT;
+    }
+    if (rep.reported&XkbGBN_CompatMapMask) {
+	xkbGetCompatMapReply 	crep;
+	Status			status;
+	int			nread= 0;
+
+	_XRead(dpy, (char *)&crep, SIZEOF(xkbGetCompatMapReply));
+	extraLen-= SIZEOF(xkbGetCompatMapReply);
+	status= _XkbReadGetCompatMapReply(dpy,&crep,xkb,&nread);
+	extraLen-= nread;
+	if (status!=Success)
+	    goto BAILOUT;
+    }
+    if (rep.reported&XkbGBN_IndicatorMapMask) {
+	xkbGetIndicatorMapReply irep;
+	Status			status;
+	int			nread= 0;
+
+	_XRead(dpy, (char *)&irep, SIZEOF(xkbGetIndicatorMapReply));
+	extraLen-= SIZEOF(xkbGetIndicatorMapReply);
+	status= _XkbReadGetIndicatorMapReply(dpy,&irep,xkb,&nread);
+	extraLen-= nread;
+	if (status!=Success)
+	    goto BAILOUT;
+    }
+    if (rep.reported&(XkbGBN_KeyNamesMask|XkbGBN_OtherNamesMask)) {
+	xkbGetNamesReply	nrep;
+	Status			status;
+	int			nread= 0;
+
+	_XRead(dpy, (char *)&nrep, SIZEOF(xkbGetNamesReply));
+	extraLen-= SIZEOF(xkbGetNamesReply);
+	status= _XkbReadGetNamesReply(dpy,&nrep,xkb,&nread);
+	extraLen-= nread;
+	if (status!=Success)
+	    goto BAILOUT;
+    }
+    if (rep.reported&XkbGBN_GeometryMask) {
+	xkbGetGeometryReply	grep;
+	Status			status;
+	int			nread= 0;
+
+	_XRead(dpy, (char *)&grep, SIZEOF(xkbGetGeometryReply));
+	extraLen-= SIZEOF(xkbGetGeometryReply);
+	status= _XkbReadGetGeometryReply(dpy,&grep,xkb,&nread);
+	extraLen-= nread;
+	if (status!=Success)
+	    goto BAILOUT;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return xkb;
+BAILOUT:
+    if (xkb!=NULL)
+	XkbFreeKeyboard(xkb,XkbAllComponentsMask,xTrue);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return NULL;
+}
+
+XkbDescPtr
+XkbGetKeyboard(Display *dpy,unsigned which,unsigned deviceSpec)
+{
+    return XkbGetKeyboardByName(dpy,deviceSpec,NULL,which,which,False);
+}
diff --git a/libX11/src/xkb/XKBGetMap.c b/libX11/src/xkb/XKBGetMap.c
index eff088341..30fb62971 100644
--- a/libX11/src/xkb/XKBGetMap.c
+++ b/libX11/src/xkb/XKBGetMap.c
@@ -1,828 +1,828 @@
-/************************************************************

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

-

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

-

-#define	NEED_MAP_READERS

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-static Status

-_XkbReadKeyTypes(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-int		 i,n,lastMapCount;

-XkbKeyTypePtr	type;

-

-    if ( rep->nTypes>0 ) {

-	n = rep->firstType+rep->nTypes;

-	if (xkb->map->num_types>=n)

-	    n= xkb->map->num_types;

-	else if (XkbAllocClientMap(xkb,XkbKeyTypesMask,n)!=Success)

-	    return BadAlloc;

-

-	type = &xkb->map->types[rep->firstType];

-	for (i=0;i<(int)rep->nTypes;i++,type++) {

-	    xkbKeyTypeWireDesc	*desc;

-	    register int ndx;

-

-	    ndx= i+rep->firstType;

-	    if (ndx>=xkb->map->num_types)

-		xkb->map->num_types= ndx+1;

-

-	    desc= (xkbKeyTypeWireDesc *)_XkbGetReadBufferPtr(buf,

-						SIZEOF(xkbKeyTypeWireDesc));

-	    if (desc==NULL)

-		return BadLength;

-

-	    lastMapCount= type->map_count;

-	    if ( desc->nMapEntries>0 ) {

-		if ((type->map==NULL)||(desc->nMapEntries>type->map_count)) {

-		    XkbKTMapEntryRec *prev_map = type->map;

-

-		    type->map= _XkbTypedRealloc(type->map,desc->nMapEntries,

-							      XkbKTMapEntryRec);

-		    if (type->map==NULL) {

-			_XkbFree(prev_map);

-			return BadAlloc;

-		    }

-		}

-	    }

-	    else if (type->map!=NULL) {

-		Xfree(type->map);

-		type->map_count= 0;

-		type->map= NULL;

-	    }

-

-	    if ( desc->preserve && (desc->nMapEntries>0) ) {

-		if ((!type->preserve)||

-		    (desc->nMapEntries>lastMapCount)) {

-		    XkbModsRec *prev_preserve = type->preserve;

-

-		    type->preserve= _XkbTypedRealloc(type->preserve,

-							desc->nMapEntries,

-							XkbModsRec);

-		    if (type->preserve==NULL) {

-			_XkbFree(prev_preserve);

-			return BadAlloc;

-		    }

-		}

-	    }

-	    else if (type->preserve!=NULL) {

-		Xfree(type->preserve);

-		type->preserve= NULL;

-	    }

-

-	    type->mods.mask = desc->mask;

-	    type->mods.real_mods = desc->realMods;

-	    type->mods.vmods = desc->virtualMods;

-	    type->num_levels = desc->numLevels;

-	    type->map_count = desc->nMapEntries;

-	    if (desc->nMapEntries>0) {

-		register xkbKTMapEntryWireDesc *wire;

-		register XkbKTMapEntryPtr	entry;

-		register int size;

-

-		size= type->map_count*SIZEOF(xkbKTMapEntryWireDesc);

-		wire= (xkbKTMapEntryWireDesc *)_XkbGetReadBufferPtr(buf,size);

-		if (wire==NULL)

-		    return BadLength;

-		entry= type->map;

-		for (n=0;n<type->map_count;n++,wire++,entry++) {

-		    entry->active= wire->active;

-		    entry->level= wire->level;

-		    entry->mods.mask= wire->mask;

-		    entry->mods.real_mods= wire->realMods;

-		    entry->mods.vmods= wire->virtualMods;

-		}

-

-	 	if (desc->preserve) {

-		    register xkbModsWireDesc *	pwire;

-		    register XkbModsPtr		preserve;

-		    register int sz;

-

-		    sz= desc->nMapEntries*SIZEOF(xkbModsWireDesc);

-		    pwire=(xkbModsWireDesc *)_XkbGetReadBufferPtr(buf,sz);

-		    if (pwire==NULL)

-			return BadLength;

-		    preserve= type->preserve;

-		    for (n=0;n<desc->nMapEntries;n++,pwire++,preserve++) {

-			preserve->mask=  pwire->mask;

-			preserve->vmods=  pwire->virtualMods;

-			preserve->real_mods= pwire->realMods;

-		    }

-		}

-	    }

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadKeySyms(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-register int i;

-XkbClientMapPtr	map;

-

-    map= xkb->map;

-    if (map->key_sym_map==NULL) {

-	register int offset;

-	XkbSymMapPtr	oldMap;

-	xkbSymMapWireDesc *newMap;

-	map->key_sym_map= _XkbTypedCalloc((xkb->max_key_code+1),XkbSymMapRec);

-	if (map->key_sym_map==NULL)

-	    return BadAlloc;

-	if (map->syms==NULL) {

-	    int sz;

-	    sz= (rep->totalSyms*12)/10;

-	    sz= ((sz+(unsigned)128)/128)*128;

-	    map->syms = _XkbTypedCalloc(sz,KeySym);

-	    if (map->syms==NULL)

-		return BadAlloc;

-	    map->size_syms = sz;

-	}

-	offset = 1;

-	oldMap = &map->key_sym_map[rep->firstKeySym];

-	for (i=0;i<(int)rep->nKeySyms;i++,oldMap++) {

-	    newMap= (xkbSymMapWireDesc *)

-			_XkbGetReadBufferPtr(buf,SIZEOF(xkbSymMapWireDesc));

-	    if (newMap==NULL)

-		return BadLength;

-	    oldMap->kt_index[0]= newMap->ktIndex[0];

-	    oldMap->kt_index[1]= newMap->ktIndex[1];

-	    oldMap->kt_index[2]= newMap->ktIndex[2];

-	    oldMap->kt_index[3]= newMap->ktIndex[3];

-	    oldMap->group_info= newMap->groupInfo;

-	    oldMap->width= newMap->width;

-	    oldMap->offset= offset;

-	    if (offset+newMap->nSyms>=map->size_syms) {

-		register int sz;

-		KeySym *prev_syms = map->syms;

-

-		sz= map->size_syms+128;

-		map->syms= _XkbTypedRealloc(map->syms,sz,KeySym);

-		if (map->syms==NULL) {

-		    _XkbFree(prev_syms);

-		    map->size_syms= 0;

-		    return BadAlloc;

-		}

-		map->size_syms= sz;

-	    }

-	    if (newMap->nSyms>0) {

-		_XkbReadBufferCopyKeySyms(buf,(KeySym *)&map->syms[offset],

-							newMap->nSyms);

-		offset+= newMap->nSyms;

-	    }

-	    else {

-		map->syms[offset]= 0;

-	    }

-	}

-	map->num_syms= offset;

-    }

-    else {

-	xkbSymMapWireDesc *	newMap;

-	XkbSymMapPtr		oldMap;

-	KeySym *		newSyms;

-	int			tmp;

-

-	oldMap = &map->key_sym_map[rep->firstKeySym];

-	for (i=0;i<(int)rep->nKeySyms;i++,oldMap++) {

-	    newMap= (xkbSymMapWireDesc *)

-			_XkbGetReadBufferPtr(buf,SIZEOF(xkbSymMapWireDesc));

-	    if (newMap==NULL)

-		return BadLength;

-

-	    if (newMap->nSyms>0)

-		 tmp= newMap->nSyms;

-	    else tmp= 0;

-

-	    newSyms = XkbResizeKeySyms(xkb,i+rep->firstKeySym,tmp);

-	    if (newSyms==NULL)

-		return BadAlloc;

-	    if (newMap->nSyms>0)

-		_XkbReadBufferCopyKeySyms(buf,newSyms,newMap->nSyms);

-	    else newSyms[0]= NoSymbol;

-	    oldMap->kt_index[0] = newMap->ktIndex[0];

-	    oldMap->kt_index[1] = newMap->ktIndex[1];

-	    oldMap->kt_index[2] = newMap->ktIndex[2];

-	    oldMap->kt_index[3] = newMap->ktIndex[3];

-	    oldMap->group_info = newMap->groupInfo;

-	    oldMap->width = newMap->width;

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadKeyActions(XkbReadBufferPtr buf,XkbDescPtr info,xkbGetMapReply *rep)

-{

-int		i;

-CARD8		numDescBuf[248];

-CARD8*		numDesc = NULL;

-register int	nKeyActs;

-Status		ret = Success;

-

-    if ( (nKeyActs=rep->nKeyActs)>0 ) {

-	XkbSymMapPtr	symMap;

-

-	if (nKeyActs < sizeof numDescBuf) numDesc = numDescBuf;

-	else numDesc = Xmalloc (nKeyActs * sizeof(CARD8));

-

-	if (!_XkbCopyFromReadBuffer(buf, (char *)numDesc, nKeyActs)) {

-	    ret = BadLength;

-	    goto done;

-	}

-	i= XkbPaddedSize(nKeyActs)-nKeyActs;

-	if ((i>0)&&(!_XkbSkipReadBufferData(buf,i))) {

-	    ret = BadLength;

-	    goto done;

-	}

-	symMap = &info->map->key_sym_map[rep->firstKeyAct];

-	for (i=0;i<(int)rep->nKeyActs;i++,symMap++) {

-	    if (numDesc[i]==0) {

-		info->server->key_acts[i+rep->firstKeyAct]= 0;

-	    }

-	    else {

-		XkbAction *newActs;

-		/* 8/16/93 (ef) -- XXX! Verify size here (numdesc must be */

-		/*                 either zero or XkbKeyNumSyms(info,key) */

-		newActs=XkbResizeKeyActions(info,i+rep->firstKeyAct,

-								numDesc[i]);

-		if (newActs==NULL) {

-		    ret = BadAlloc;

-		    goto done;

-		}

-		if (!_XkbCopyFromReadBuffer(buf,(char *)newActs,

-					(int)(numDesc[i]*sizeof(XkbAction)))) {

-		    ret = BadLength;

-		    goto done;

-		}

-	    }

-	}

-    }

-done:

-    if (numDesc != NULL && numDesc != numDescBuf) Xfree (numDesc);

-    return ret;

-}

-

-static Status

-_XkbReadKeyBehaviors(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-register int i;

-xkbBehaviorWireDesc	*wire;

-

-    if ( rep->totalKeyBehaviors>0 ) {

-	if ( xkb->server->behaviors == NULL ) {

-	    int size = xkb->max_key_code+1;

-	    xkb->server->behaviors = _XkbTypedCalloc(size,XkbBehavior);

-	    if (xkb->server->behaviors==NULL)

-		return BadAlloc;

-	}

-	else {

-	    bzero(&xkb->server->behaviors[rep->firstKeyBehavior],

-	    		(rep->nKeyBehaviors*sizeof(XkbBehavior)));

-	}

-	for (i=0;i<rep->totalKeyBehaviors;i++) {

-	    wire= (xkbBehaviorWireDesc *)_XkbGetReadBufferPtr(buf,

-						SIZEOF(xkbBehaviorWireDesc));

-	    if (wire==NULL)

-		return BadLength;

-	    xkb->server->behaviors[wire->key].type= wire->type;

-	    xkb->server->behaviors[wire->key].data= wire->data;

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadVirtualMods(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-    if ( rep->virtualMods ) {

-	register int i,bit,nVMods;

-	register char *data;

-

-	for (i=nVMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {

-	    if (rep->virtualMods&bit)

-		nVMods++;

-	}

-	data= _XkbGetReadBufferPtr(buf,XkbPaddedSize(nVMods));

-	if (data==NULL)

-	    return BadLength;

-	for (i=0,bit=1;(i<XkbNumVirtualMods)&&(nVMods>0);i++,bit<<=1) {

-	    if (rep->virtualMods&bit) {

-		xkb->server->vmods[i]= *data++;

-		nVMods--;

-	    }

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadExplicitComponents(	XkbReadBufferPtr	buf,

-				XkbDescPtr 		xkb,

-				xkbGetMapReply *	rep)

-{

-register int i;

-unsigned char *wire;

-

-    if ( rep->totalKeyExplicit>0 ) {

-	if ( xkb->server->explicit == NULL ) {

-	    int size = xkb->max_key_code+1;

-	    xkb->server->explicit = _XkbTypedCalloc(size,unsigned char);

-	    if (xkb->server->explicit==NULL)

-		return BadAlloc;

-	}

-	else {

-	    bzero(&xkb->server->explicit[rep->firstKeyExplicit],

-	    						rep->nKeyExplicit);

-	}

-	i= XkbPaddedSize(2*rep->totalKeyExplicit);

-	wire=(unsigned char *)_XkbGetReadBufferPtr(buf,i);

-	if (!wire)

-	    return BadLength;

-	for (i=0;i<rep->totalKeyExplicit;i++,wire+=2) {

-	    xkb->server->explicit[wire[0]]= wire[1];

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadModifierMap(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-register int i;

-unsigned char *wire;

-

-    if ( rep->totalModMapKeys>0 ) {

-	if ((xkb->map->modmap==NULL)&&

-	    (XkbAllocClientMap(xkb,XkbModifierMapMask,0)!=Success)) {

-	    return BadAlloc;

-	}

-	else {

-	    bzero(&xkb->map->modmap[rep->firstModMapKey],rep->nModMapKeys);

-	}

-	i= XkbPaddedSize(2*rep->totalModMapKeys);

-	wire=(unsigned char *)_XkbGetReadBufferPtr(buf,i);

-	if (!wire)

-	    return BadLength;

-	for (i=0;i<rep->totalModMapKeys;i++,wire+=2) {

-	    xkb->map->modmap[wire[0]]= wire[1];

-	}

-    }

-    return Success;

-}

-

-static Status

-_XkbReadVirtualModMap(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)

-{

-register int 		i;

-xkbVModMapWireDesc *	wire;

-XkbServerMapPtr		srv;

-

-    if ( rep->totalVModMapKeys>0 ) {

-	if (((xkb->server==NULL)||(xkb->server->vmodmap==NULL))&&

-	    (XkbAllocServerMap(xkb,XkbVirtualModMapMask,0)!=Success)) {

-	    return BadAlloc;

-	}

-	else {

-	    srv= xkb->server;

-	    if (rep->nVModMapKeys > rep->firstVModMapKey)

-		bzero((char *)&srv->vmodmap[rep->firstVModMapKey],

-		      (rep->nVModMapKeys - rep->firstVModMapKey) *

-		      sizeof(unsigned short));

-	}

-	srv= xkb->server;

-	i= rep->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);

-	wire=(xkbVModMapWireDesc *)_XkbGetReadBufferPtr(buf,i);

-	if (!wire)

-	    return BadLength;

-	for (i=0;i<rep->totalVModMapKeys;i++,wire++) {

-	    if ((wire->key>=xkb->min_key_code)&&(wire->key<=xkb->max_key_code))

-		srv->vmodmap[wire->key]= wire->vmods;

-	}

-    }

-    return Success;

-}

-

-static xkbGetMapReq *

-_XkbGetGetMapReq(Display *dpy,XkbDescPtr xkb)

-{

-xkbGetMapReq *req;

-

-    GetReq(kbGetMap, req);

-    req->reqType = dpy->xkb_info->codes->major_opcode;

-    req->xkbReqType = X_kbGetMap;

-    req->deviceSpec = xkb->device_spec;

-    req->full = req->partial = 0;

-    req->firstType = req->nTypes = 0;

-    req->firstKeySym = req->nKeySyms = 0;

-    req->firstKeyAct = req->nKeyActs = 0;

-    req->firstKeyBehavior = req->nKeyBehaviors = 0;

-    req->virtualMods = 0;

-    req->firstKeyExplicit = req->nKeyExplicit = 0;

-    req->firstModMapKey = req->nModMapKeys = 0;

-    req->firstVModMapKey = req->nVModMapKeys = 0;

-    return req;

-}

-

-Status

-_XkbReadGetMapReply(	Display *	dpy,

-			xkbGetMapReply *rep,

-			XkbDescPtr	xkb,

-			int *		nread_rtrn)

-{

-int		extraData;

-unsigned	mask;

-

-    if ( xkb->device_spec == XkbUseCoreKbd )

-	xkb->device_spec= rep->deviceID;

-    xkb->min_key_code = rep->minKeyCode;

-    xkb->max_key_code = rep->maxKeyCode;

-

-    if (!xkb->map) {

-	mask= rep->present&XkbAllClientInfoMask;

-	if (mask&&(XkbAllocClientMap(xkb,mask,rep->nTypes)!=Success))

-	    return BadAlloc;

-    }

-    if (!xkb->server) {

-	mask= rep->present&XkbAllServerInfoMask;

-	if (mask&&(XkbAllocServerMap(xkb,mask,rep->totalActs)!=Success))

-	    return BadAlloc;

-    }

-    extraData= (int)(rep->length*4);

-    extraData-= (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply));

-    if (rep->length) {

-	XkbReadBufferRec	buf;

-	int			left;

-	if (_XkbInitReadBuffer(dpy,&buf,extraData)) {

-	    Status status= Success;

-	    if (nread_rtrn!=NULL)

-		*nread_rtrn= extraData;

-	    if (status==Success)

-		status= _XkbReadKeyTypes(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadKeySyms(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadKeyActions(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadKeyBehaviors(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadVirtualMods(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadExplicitComponents(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadModifierMap(&buf,xkb,rep);

-	    if (status==Success)

-		status= _XkbReadVirtualModMap(&buf,xkb,rep);

-	    left= _XkbFreeReadBuffer(&buf);

-	    if (status!=Success)		return status;

-	    else if ( left || buf.error )	return BadLength;

-	}

-	else return BadAlloc;

-    }

-    return Success;

-}

-

-static Status

-_XkbHandleGetMapReply(Display *dpy,XkbDescPtr xkb)

-{

-xkbGetMapReply	rep;

-

-    if (!_XReply(dpy, (xReply *)&rep,

-    		 ( (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply)) >> 2 ),

-		 xFalse)) {

-	return BadImplementation;

-    }

-    return _XkbReadGetMapReply(dpy,&rep,xkb,NULL);

-}

-

-Status

-XkbGetUpdatedMap(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    if (which) {

-	register xkbGetMapReq *req;

-	Status status;

-

-	LockDisplay(dpy);

-

-	req = _XkbGetGetMapReq(dpy, xkb);

-	req->full = which;

-	status= _XkbHandleGetMapReply(dpy, xkb);

-

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return status;

-    }

-    return Success;

-}

-

-XkbDescPtr

-XkbGetMap(Display *dpy,unsigned which,unsigned deviceSpec)

-{

-XkbDescPtr xkb;

-

-    xkb = _XkbTypedCalloc(1,XkbDescRec);

-    if (xkb) {

-	xkb->device_spec = deviceSpec;

-	xkb->map = _XkbTypedCalloc(1,XkbClientMapRec);

-	if ((xkb->map==NULL)||

-	    ((which)&&(XkbGetUpdatedMap(dpy,which,xkb)!=Success))) {

-	    if (xkb->map) {

-		Xfree(xkb->map);

-		xkb->map= NULL;

-	    }

-	    Xfree(xkb);

-	    return NULL;

-	}

-	xkb->dpy= dpy;

-    }

-    return xkb;

-}

-

-Status

-XkbGetKeyTypes(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    if ((num<1)||(num>XkbMaxKeyTypes))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstType = first;

-    req->nTypes = num;

-    status= _XkbHandleGetMapReply(dpy, xkb);

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetKeyActions(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstKeyAct = first;

-    req->nKeyActs = num;

-    status= _XkbHandleGetMapReply(dpy, xkb);

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetKeySyms(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstKeySym = first;

-    req->nKeySyms = num;

-    status= _XkbHandleGetMapReply(dpy, xkb);

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-

-    return status;

-}

-

-Status

-XkbGetKeyBehaviors(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstKeyBehavior = first;

-    req->nKeyBehaviors = num;

-    status= _XkbHandleGetMapReply(dpy, xkb);

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetVirtualMods(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->virtualMods = which;

-    status= _XkbHandleGetMapReply(dpy, xkb);

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetKeyExplicitComponents(	Display *	dpy,

-				unsigned	first,

-				unsigned 	num,

-				XkbDescPtr	xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstKeyExplicit = first;

-    req->nKeyExplicit = num;

-    if ((xkb!=NULL) && (xkb->server!=NULL) && (xkb->server->explicit!=NULL)) {

-	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))

-	    bzero(&xkb->server->explicit[first],num);

-    }

-    if (xkb)

-        status= _XkbHandleGetMapReply(dpy, xkb);

-    else

-        status = BadMatch;

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetKeyModifierMap(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstModMapKey = first;

-    req->nModMapKeys = num;

-    if ((xkb!=NULL) && (xkb->map!=NULL) && (xkb->map->modmap!=NULL)) {

-	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))

-	    bzero(&xkb->map->modmap[first],num);

-    }

-    if (xkb)

-        status= _XkbHandleGetMapReply(dpy, xkb);

-    else

-        status = BadMatch;

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetKeyVirtualModMap(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)

-{

-    register xkbGetMapReq *req;

-    Status status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    if ((num<1)||(num>XkbMaxKeyCount))

-	return BadValue;

-

-    LockDisplay(dpy);

-

-    req = _XkbGetGetMapReq(dpy, xkb);

-    req->firstVModMapKey = first;

-    req->nVModMapKeys = num;

-    if ((xkb!=NULL) && (xkb->map!=NULL) && (xkb->map->modmap!=NULL)) {

-	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))

-	    bzero(&xkb->server->vmodmap[first],num*sizeof(unsigned short));

-    }

-

-    if (xkb)

-        status= _XkbHandleGetMapReply(dpy, xkb);

-    else

-        status = BadMatch;

-

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Status

-XkbGetMapChanges(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)

-{

-    xkbGetMapReq *req;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    LockDisplay(dpy);

-    if (changes->changed) {

-	Status status= Success;

-	req = _XkbGetGetMapReq(dpy, xkb);

-	req->full = 0;

-	req->partial = changes->changed;

-	req->firstType = changes->first_type;

-	req->nTypes = changes->num_types;

-	req->firstKeySym = changes->first_key_sym;

-	req->nKeySyms = changes->num_key_syms;

-	req->firstKeyAct = changes->first_key_act;

-	req->nKeyActs = changes->num_key_acts;

-	req->firstKeyBehavior = changes->first_key_behavior;

-	req->nKeyBehaviors = changes->num_key_behaviors;

-	req->virtualMods = changes->vmods;

-	req->firstKeyExplicit = changes->first_key_explicit;

-	req->nKeyExplicit = changes->num_key_explicit;

-	req->firstModMapKey = changes->first_modmap_key;

-	req->nModMapKeys = changes->num_modmap_keys;

-	req->firstVModMapKey = changes->first_vmodmap_key;

-	req->nVModMapKeys = changes->num_vmodmap_keys;

-	status= _XkbHandleGetMapReply(dpy, xkb);

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return status;

-    }

-    UnlockDisplay(dpy);

-    return Success;

-}

-

+/************************************************************
+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.
+
+********************************************************/
+
+#define	NEED_MAP_READERS
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+static Status
+_XkbReadKeyTypes(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+int		 i,n,lastMapCount;
+XkbKeyTypePtr	type;
+
+    if ( rep->nTypes>0 ) {
+	n = rep->firstType+rep->nTypes;
+	if (xkb->map->num_types>=n)
+	    n= xkb->map->num_types;
+	else if (XkbAllocClientMap(xkb,XkbKeyTypesMask,n)!=Success)
+	    return BadAlloc;
+
+	type = &xkb->map->types[rep->firstType];
+	for (i=0;i<(int)rep->nTypes;i++,type++) {
+	    xkbKeyTypeWireDesc	*desc;
+	    register int ndx;
+
+	    ndx= i+rep->firstType;
+	    if (ndx>=xkb->map->num_types)
+		xkb->map->num_types= ndx+1;
+
+	    desc= (xkbKeyTypeWireDesc *)_XkbGetReadBufferPtr(buf,
+						SIZEOF(xkbKeyTypeWireDesc));
+	    if (desc==NULL)
+		return BadLength;
+
+	    lastMapCount= type->map_count;
+	    if ( desc->nMapEntries>0 ) {
+		if ((type->map==NULL)||(desc->nMapEntries>type->map_count)) {
+		    XkbKTMapEntryRec *prev_map = type->map;
+
+		    type->map= _XkbTypedRealloc(type->map,desc->nMapEntries,
+							      XkbKTMapEntryRec);
+		    if (type->map==NULL) {
+			_XkbFree(prev_map);
+			return BadAlloc;
+		    }
+		}
+	    }
+	    else if (type->map!=NULL) {
+		Xfree(type->map);
+		type->map_count= 0;
+		type->map= NULL;
+	    }
+
+	    if ( desc->preserve && (desc->nMapEntries>0) ) {
+		if ((!type->preserve)||
+		    (desc->nMapEntries>lastMapCount)) {
+		    XkbModsRec *prev_preserve = type->preserve;
+
+		    type->preserve= _XkbTypedRealloc(type->preserve,
+							desc->nMapEntries,
+							XkbModsRec);
+		    if (type->preserve==NULL) {
+			_XkbFree(prev_preserve);
+			return BadAlloc;
+		    }
+		}
+	    }
+	    else if (type->preserve!=NULL) {
+		Xfree(type->preserve);
+		type->preserve= NULL;
+	    }
+
+	    type->mods.mask = desc->mask;
+	    type->mods.real_mods = desc->realMods;
+	    type->mods.vmods = desc->virtualMods;
+	    type->num_levels = desc->numLevels;
+	    type->map_count = desc->nMapEntries;
+	    if (desc->nMapEntries>0) {
+		register xkbKTMapEntryWireDesc *wire;
+		register XkbKTMapEntryPtr	entry;
+		register int size;
+
+		size= type->map_count*SIZEOF(xkbKTMapEntryWireDesc);
+		wire= (xkbKTMapEntryWireDesc *)_XkbGetReadBufferPtr(buf,size);
+		if (wire==NULL)
+		    return BadLength;
+		entry= type->map;
+		for (n=0;n<type->map_count;n++,wire++,entry++) {
+		    entry->active= wire->active;
+		    entry->level= wire->level;
+		    entry->mods.mask= wire->mask;
+		    entry->mods.real_mods= wire->realMods;
+		    entry->mods.vmods= wire->virtualMods;
+		}
+
+	 	if (desc->preserve) {
+		    register xkbModsWireDesc *	pwire;
+		    register XkbModsPtr		preserve;
+		    register int sz;
+
+		    sz= desc->nMapEntries*SIZEOF(xkbModsWireDesc);
+		    pwire=(xkbModsWireDesc *)_XkbGetReadBufferPtr(buf,sz);
+		    if (pwire==NULL)
+			return BadLength;
+		    preserve= type->preserve;
+		    for (n=0;n<desc->nMapEntries;n++,pwire++,preserve++) {
+			preserve->mask=  pwire->mask;
+			preserve->vmods=  pwire->virtualMods;
+			preserve->real_mods= pwire->realMods;
+		    }
+		}
+	    }
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadKeySyms(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+register int i;
+XkbClientMapPtr	map;
+
+    map= xkb->map;
+    if (map->key_sym_map==NULL) {
+	register int offset;
+	XkbSymMapPtr	oldMap;
+	xkbSymMapWireDesc *newMap;
+	map->key_sym_map= _XkbTypedCalloc((xkb->max_key_code+1),XkbSymMapRec);
+	if (map->key_sym_map==NULL)
+	    return BadAlloc;
+	if (map->syms==NULL) {
+	    int sz;
+	    sz= (rep->totalSyms*12)/10;
+	    sz= ((sz+(unsigned)128)/128)*128;
+	    map->syms = _XkbTypedCalloc(sz,KeySym);
+	    if (map->syms==NULL)
+		return BadAlloc;
+	    map->size_syms = sz;
+	}
+	offset = 1;
+	oldMap = &map->key_sym_map[rep->firstKeySym];
+	for (i=0;i<(int)rep->nKeySyms;i++,oldMap++) {
+	    newMap= (xkbSymMapWireDesc *)
+			_XkbGetReadBufferPtr(buf,SIZEOF(xkbSymMapWireDesc));
+	    if (newMap==NULL)
+		return BadLength;
+	    oldMap->kt_index[0]= newMap->ktIndex[0];
+	    oldMap->kt_index[1]= newMap->ktIndex[1];
+	    oldMap->kt_index[2]= newMap->ktIndex[2];
+	    oldMap->kt_index[3]= newMap->ktIndex[3];
+	    oldMap->group_info= newMap->groupInfo;
+	    oldMap->width= newMap->width;
+	    oldMap->offset= offset;
+	    if (offset+newMap->nSyms>=map->size_syms) {
+		register int sz;
+		KeySym *prev_syms = map->syms;
+
+		sz= map->size_syms+128;
+		map->syms= _XkbTypedRealloc(map->syms,sz,KeySym);
+		if (map->syms==NULL) {
+		    _XkbFree(prev_syms);
+		    map->size_syms= 0;
+		    return BadAlloc;
+		}
+		map->size_syms= sz;
+	    }
+	    if (newMap->nSyms>0) {
+		_XkbReadBufferCopyKeySyms(buf,(KeySym *)&map->syms[offset],
+							newMap->nSyms);
+		offset+= newMap->nSyms;
+	    }
+	    else {
+		map->syms[offset]= 0;
+	    }
+	}
+	map->num_syms= offset;
+    }
+    else {
+	xkbSymMapWireDesc *	newMap;
+	XkbSymMapPtr		oldMap;
+	KeySym *		newSyms;
+	int			tmp;
+
+	oldMap = &map->key_sym_map[rep->firstKeySym];
+	for (i=0;i<(int)rep->nKeySyms;i++,oldMap++) {
+	    newMap= (xkbSymMapWireDesc *)
+			_XkbGetReadBufferPtr(buf,SIZEOF(xkbSymMapWireDesc));
+	    if (newMap==NULL)
+		return BadLength;
+
+	    if (newMap->nSyms>0)
+		 tmp= newMap->nSyms;
+	    else tmp= 0;
+
+	    newSyms = XkbResizeKeySyms(xkb,i+rep->firstKeySym,tmp);
+	    if (newSyms==NULL)
+		return BadAlloc;
+	    if (newMap->nSyms>0)
+		_XkbReadBufferCopyKeySyms(buf,newSyms,newMap->nSyms);
+	    else newSyms[0]= NoSymbol;
+	    oldMap->kt_index[0] = newMap->ktIndex[0];
+	    oldMap->kt_index[1] = newMap->ktIndex[1];
+	    oldMap->kt_index[2] = newMap->ktIndex[2];
+	    oldMap->kt_index[3] = newMap->ktIndex[3];
+	    oldMap->group_info = newMap->groupInfo;
+	    oldMap->width = newMap->width;
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadKeyActions(XkbReadBufferPtr buf,XkbDescPtr info,xkbGetMapReply *rep)
+{
+int		i;
+CARD8		numDescBuf[248];
+CARD8*		numDesc = NULL;
+register int	nKeyActs;
+Status		ret = Success;
+
+    if ( (nKeyActs=rep->nKeyActs)>0 ) {
+	XkbSymMapPtr	symMap;
+
+	if (nKeyActs < sizeof numDescBuf) numDesc = numDescBuf;
+	else numDesc = Xmalloc (nKeyActs * sizeof(CARD8));
+
+	if (!_XkbCopyFromReadBuffer(buf, (char *)numDesc, nKeyActs)) {
+	    ret = BadLength;
+	    goto done;
+	}
+	i= XkbPaddedSize(nKeyActs)-nKeyActs;
+	if ((i>0)&&(!_XkbSkipReadBufferData(buf,i))) {
+	    ret = BadLength;
+	    goto done;
+	}
+	symMap = &info->map->key_sym_map[rep->firstKeyAct];
+	for (i=0;i<(int)rep->nKeyActs;i++,symMap++) {
+	    if (numDesc[i]==0) {
+		info->server->key_acts[i+rep->firstKeyAct]= 0;
+	    }
+	    else {
+		XkbAction *newActs;
+		/* 8/16/93 (ef) -- XXX! Verify size here (numdesc must be */
+		/*                 either zero or XkbKeyNumSyms(info,key) */
+		newActs=XkbResizeKeyActions(info,i+rep->firstKeyAct,
+								numDesc[i]);
+		if (newActs==NULL) {
+		    ret = BadAlloc;
+		    goto done;
+		}
+		if (!_XkbCopyFromReadBuffer(buf,(char *)newActs,
+					(int)(numDesc[i]*sizeof(XkbAction)))) {
+		    ret = BadLength;
+		    goto done;
+		}
+	    }
+	}
+    }
+done:
+    if (numDesc != NULL && numDesc != numDescBuf) Xfree (numDesc);
+    return ret;
+}
+
+static Status
+_XkbReadKeyBehaviors(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+register int i;
+xkbBehaviorWireDesc	*wire;
+
+    if ( rep->totalKeyBehaviors>0 ) {
+	if ( xkb->server->behaviors == NULL ) {
+	    int size = xkb->max_key_code+1;
+	    xkb->server->behaviors = _XkbTypedCalloc(size,XkbBehavior);
+	    if (xkb->server->behaviors==NULL)
+		return BadAlloc;
+	}
+	else {
+	    bzero(&xkb->server->behaviors[rep->firstKeyBehavior],
+	    		(rep->nKeyBehaviors*sizeof(XkbBehavior)));
+	}
+	for (i=0;i<rep->totalKeyBehaviors;i++) {
+	    wire= (xkbBehaviorWireDesc *)_XkbGetReadBufferPtr(buf,
+						SIZEOF(xkbBehaviorWireDesc));
+	    if (wire==NULL)
+		return BadLength;
+	    xkb->server->behaviors[wire->key].type= wire->type;
+	    xkb->server->behaviors[wire->key].data= wire->data;
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadVirtualMods(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+    if ( rep->virtualMods ) {
+	register int i,bit,nVMods;
+	register char *data;
+
+	for (i=nVMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	    if (rep->virtualMods&bit)
+		nVMods++;
+	}
+	data= _XkbGetReadBufferPtr(buf,XkbPaddedSize(nVMods));
+	if (data==NULL)
+	    return BadLength;
+	for (i=0,bit=1;(i<XkbNumVirtualMods)&&(nVMods>0);i++,bit<<=1) {
+	    if (rep->virtualMods&bit) {
+		xkb->server->vmods[i]= *data++;
+		nVMods--;
+	    }
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadExplicitComponents(	XkbReadBufferPtr	buf,
+				XkbDescPtr 		xkb,
+				xkbGetMapReply *	rep)
+{
+register int i;
+unsigned char *wire;
+
+    if ( rep->totalKeyExplicit>0 ) {
+	if ( xkb->server->explicit == NULL ) {
+	    int size = xkb->max_key_code+1;
+	    xkb->server->explicit = _XkbTypedCalloc(size,unsigned char);
+	    if (xkb->server->explicit==NULL)
+		return BadAlloc;
+	}
+	else {
+	    bzero(&xkb->server->explicit[rep->firstKeyExplicit],
+	    						rep->nKeyExplicit);
+	}
+	i= XkbPaddedSize(2*rep->totalKeyExplicit);
+	wire=(unsigned char *)_XkbGetReadBufferPtr(buf,i);
+	if (!wire)
+	    return BadLength;
+	for (i=0;i<rep->totalKeyExplicit;i++,wire+=2) {
+	    xkb->server->explicit[wire[0]]= wire[1];
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadModifierMap(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+register int i;
+unsigned char *wire;
+
+    if ( rep->totalModMapKeys>0 ) {
+	if ((xkb->map->modmap==NULL)&&
+	    (XkbAllocClientMap(xkb,XkbModifierMapMask,0)!=Success)) {
+	    return BadAlloc;
+	}
+	else {
+	    bzero(&xkb->map->modmap[rep->firstModMapKey],rep->nModMapKeys);
+	}
+	i= XkbPaddedSize(2*rep->totalModMapKeys);
+	wire=(unsigned char *)_XkbGetReadBufferPtr(buf,i);
+	if (!wire)
+	    return BadLength;
+	for (i=0;i<rep->totalModMapKeys;i++,wire+=2) {
+	    xkb->map->modmap[wire[0]]= wire[1];
+	}
+    }
+    return Success;
+}
+
+static Status
+_XkbReadVirtualModMap(XkbReadBufferPtr buf,XkbDescPtr xkb,xkbGetMapReply *rep)
+{
+register int 		i;
+xkbVModMapWireDesc *	wire;
+XkbServerMapPtr		srv;
+
+    if ( rep->totalVModMapKeys>0 ) {
+	if (((xkb->server==NULL)||(xkb->server->vmodmap==NULL))&&
+	    (XkbAllocServerMap(xkb,XkbVirtualModMapMask,0)!=Success)) {
+	    return BadAlloc;
+	}
+	else {
+	    srv= xkb->server;
+	    if (rep->nVModMapKeys > rep->firstVModMapKey)
+		bzero((char *)&srv->vmodmap[rep->firstVModMapKey],
+		      (rep->nVModMapKeys - rep->firstVModMapKey) *
+		      sizeof(unsigned short));
+	}
+	srv= xkb->server;
+	i= rep->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);
+	wire=(xkbVModMapWireDesc *)_XkbGetReadBufferPtr(buf,i);
+	if (!wire)
+	    return BadLength;
+	for (i=0;i<rep->totalVModMapKeys;i++,wire++) {
+	    if ((wire->key>=xkb->min_key_code)&&(wire->key<=xkb->max_key_code))
+		srv->vmodmap[wire->key]= wire->vmods;
+	}
+    }
+    return Success;
+}
+
+static xkbGetMapReq *
+_XkbGetGetMapReq(Display *dpy,XkbDescPtr xkb)
+{
+xkbGetMapReq *req;
+
+    GetReq(kbGetMap, req);
+    req->reqType = dpy->xkb_info->codes->major_opcode;
+    req->xkbReqType = X_kbGetMap;
+    req->deviceSpec = xkb->device_spec;
+    req->full = req->partial = 0;
+    req->firstType = req->nTypes = 0;
+    req->firstKeySym = req->nKeySyms = 0;
+    req->firstKeyAct = req->nKeyActs = 0;
+    req->firstKeyBehavior = req->nKeyBehaviors = 0;
+    req->virtualMods = 0;
+    req->firstKeyExplicit = req->nKeyExplicit = 0;
+    req->firstModMapKey = req->nModMapKeys = 0;
+    req->firstVModMapKey = req->nVModMapKeys = 0;
+    return req;
+}
+
+Status
+_XkbReadGetMapReply(	Display *	dpy,
+			xkbGetMapReply *rep,
+			XkbDescPtr	xkb,
+			int *		nread_rtrn)
+{
+int		extraData;
+unsigned	mask;
+
+    if ( xkb->device_spec == XkbUseCoreKbd )
+	xkb->device_spec= rep->deviceID;
+    xkb->min_key_code = rep->minKeyCode;
+    xkb->max_key_code = rep->maxKeyCode;
+
+    if (!xkb->map) {
+	mask= rep->present&XkbAllClientInfoMask;
+	if (mask&&(XkbAllocClientMap(xkb,mask,rep->nTypes)!=Success))
+	    return BadAlloc;
+    }
+    if (!xkb->server) {
+	mask= rep->present&XkbAllServerInfoMask;
+	if (mask&&(XkbAllocServerMap(xkb,mask,rep->totalActs)!=Success))
+	    return BadAlloc;
+    }
+    extraData= (int)(rep->length*4);
+    extraData-= (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply));
+    if (rep->length) {
+	XkbReadBufferRec	buf;
+	int			left;
+	if (_XkbInitReadBuffer(dpy,&buf,extraData)) {
+	    Status status= Success;
+	    if (nread_rtrn!=NULL)
+		*nread_rtrn= extraData;
+	    if (status==Success)
+		status= _XkbReadKeyTypes(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadKeySyms(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadKeyActions(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadKeyBehaviors(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadVirtualMods(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadExplicitComponents(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadModifierMap(&buf,xkb,rep);
+	    if (status==Success)
+		status= _XkbReadVirtualModMap(&buf,xkb,rep);
+	    left= _XkbFreeReadBuffer(&buf);
+	    if (status!=Success)		return status;
+	    else if ( left || buf.error )	return BadLength;
+	}
+	else return BadAlloc;
+    }
+    return Success;
+}
+
+static Status
+_XkbHandleGetMapReply(Display *dpy,XkbDescPtr xkb)
+{
+xkbGetMapReply	rep;
+
+    if (!_XReply(dpy, (xReply *)&rep,
+    		 ( (SIZEOF(xkbGetMapReply)-SIZEOF(xGenericReply)) >> 2 ),
+		 xFalse)) {
+	return BadImplementation;
+    }
+    return _XkbReadGetMapReply(dpy,&rep,xkb,NULL);
+}
+
+Status
+XkbGetUpdatedMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    if (which) {
+	register xkbGetMapReq *req;
+	Status status;
+
+	LockDisplay(dpy);
+
+	req = _XkbGetGetMapReq(dpy, xkb);
+	req->full = which;
+	status= _XkbHandleGetMapReply(dpy, xkb);
+
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return status;
+    }
+    return Success;
+}
+
+XkbDescPtr
+XkbGetMap(Display *dpy,unsigned which,unsigned deviceSpec)
+{
+XkbDescPtr xkb;
+
+    xkb = _XkbTypedCalloc(1,XkbDescRec);
+    if (xkb) {
+	xkb->device_spec = deviceSpec;
+	xkb->map = _XkbTypedCalloc(1,XkbClientMapRec);
+	if ((xkb->map==NULL)||
+	    ((which)&&(XkbGetUpdatedMap(dpy,which,xkb)!=Success))) {
+	    if (xkb->map) {
+		Xfree(xkb->map);
+		xkb->map= NULL;
+	    }
+	    Xfree(xkb);
+	    return NULL;
+	}
+	xkb->dpy= dpy;
+    }
+    return xkb;
+}
+
+Status
+XkbGetKeyTypes(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    if ((num<1)||(num>XkbMaxKeyTypes))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstType = first;
+    req->nTypes = num;
+    status= _XkbHandleGetMapReply(dpy, xkb);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetKeyActions(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstKeyAct = first;
+    req->nKeyActs = num;
+    status= _XkbHandleGetMapReply(dpy, xkb);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetKeySyms(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstKeySym = first;
+    req->nKeySyms = num;
+    status= _XkbHandleGetMapReply(dpy, xkb);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return status;
+}
+
+Status
+XkbGetKeyBehaviors(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstKeyBehavior = first;
+    req->nKeyBehaviors = num;
+    status= _XkbHandleGetMapReply(dpy, xkb);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetVirtualMods(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->virtualMods = which;
+    status= _XkbHandleGetMapReply(dpy, xkb);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetKeyExplicitComponents(	Display *	dpy,
+				unsigned	first,
+				unsigned 	num,
+				XkbDescPtr	xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstKeyExplicit = first;
+    req->nKeyExplicit = num;
+    if ((xkb!=NULL) && (xkb->server!=NULL) && (xkb->server->explicit!=NULL)) {
+	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))
+	    bzero(&xkb->server->explicit[first],num);
+    }
+    if (xkb)
+        status= _XkbHandleGetMapReply(dpy, xkb);
+    else
+        status = BadMatch;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetKeyModifierMap(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstModMapKey = first;
+    req->nModMapKeys = num;
+    if ((xkb!=NULL) && (xkb->map!=NULL) && (xkb->map->modmap!=NULL)) {
+	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))
+	    bzero(&xkb->map->modmap[first],num);
+    }
+    if (xkb)
+        status= _XkbHandleGetMapReply(dpy, xkb);
+    else
+        status = BadMatch;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetKeyVirtualModMap(Display *dpy,unsigned first,unsigned num,XkbDescPtr xkb)
+{
+    register xkbGetMapReq *req;
+    Status status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    if ((num<1)||(num>XkbMaxKeyCount))
+	return BadValue;
+
+    LockDisplay(dpy);
+
+    req = _XkbGetGetMapReq(dpy, xkb);
+    req->firstVModMapKey = first;
+    req->nVModMapKeys = num;
+    if ((xkb!=NULL) && (xkb->map!=NULL) && (xkb->map->modmap!=NULL)) {
+	if ((num>0)&&(first>=xkb->min_key_code)&&(first+num<=xkb->max_key_code))
+	    bzero(&xkb->server->vmodmap[first],num*sizeof(unsigned short));
+    }
+
+    if (xkb)
+        status= _XkbHandleGetMapReply(dpy, xkb);
+    else
+        status = BadMatch;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Status
+XkbGetMapChanges(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
+{
+    xkbGetMapReq *req;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    LockDisplay(dpy);
+    if (changes->changed) {
+	Status status= Success;
+	req = _XkbGetGetMapReq(dpy, xkb);
+	req->full = 0;
+	req->partial = changes->changed;
+	req->firstType = changes->first_type;
+	req->nTypes = changes->num_types;
+	req->firstKeySym = changes->first_key_sym;
+	req->nKeySyms = changes->num_key_syms;
+	req->firstKeyAct = changes->first_key_act;
+	req->nKeyActs = changes->num_key_acts;
+	req->firstKeyBehavior = changes->first_key_behavior;
+	req->nKeyBehaviors = changes->num_key_behaviors;
+	req->virtualMods = changes->vmods;
+	req->firstKeyExplicit = changes->first_key_explicit;
+	req->nKeyExplicit = changes->num_key_explicit;
+	req->firstModMapKey = changes->first_modmap_key;
+	req->nModMapKeys = changes->num_modmap_keys;
+	req->firstVModMapKey = changes->first_vmodmap_key;
+	req->nVModMapKeys = changes->num_vmodmap_keys;
+	status= _XkbHandleGetMapReply(dpy, xkb);
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return status;
+    }
+    UnlockDisplay(dpy);
+    return Success;
+}
+
diff --git a/libX11/src/xkb/XKBMAlloc.c b/libX11/src/xkb/XKBMAlloc.c
index f65e4e914..a6b392168 100644
--- a/libX11/src/xkb/XKBMAlloc.c
+++ b/libX11/src/xkb/XKBMAlloc.c
@@ -1,990 +1,990 @@
-/************************************************************

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

-#include <dix-config.h>

-#elif defined(HAVE_CONFIG_H)

-#include <config.h>

-#endif

-

-#ifndef XKB_IN_SERVER

-

-#include <stdio.h>

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include <X11/keysym.h>

-#include "XKBlibint.h"

-

-#else

-

-#include <stdio.h>

-#include <X11/X.h>

-#include <X11/Xproto.h>

-#include "misc.h"

-#include "inputstr.h"

-#include <X11/keysym.h>

-#define	XKBSRV_NEED_FILE_FUNCS

-#include <X11/extensions/XKBsrv.h>

-

-#endif /* XKB_IN_SERVER */

-

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

-

-Status

-XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)

-{

-register int	i;

-XkbClientMapPtr map;

-

-    if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))

-	return BadValue;

-    if ((which&XkbKeySymsMask)&&

-	((!XkbIsLegalKeycode(xkb->min_key_code))||

-	 (!XkbIsLegalKeycode(xkb->max_key_code))||

-	 (xkb->max_key_code<xkb->min_key_code))) {

-#ifdef DEBUG

-fprintf(stderr,"bad keycode (%d,%d) in XkbAllocClientMap\n",

-				xkb->min_key_code,xkb->max_key_code);

-#endif

-	return BadValue;

-    }

-

-    if (xkb->map==NULL) {

-	map= _XkbTypedCalloc(1,XkbClientMapRec);

-	if (map==NULL)

-	    return BadAlloc;

-	xkb->map= map;

-    }

-    else map= xkb->map;

-

-    if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {

-	if (map->types==NULL) {

-	    map->types= _XkbTypedCalloc(nTotalTypes,XkbKeyTypeRec);

-	    if (map->types==NULL)

-		return BadAlloc;

-	    map->num_types= 0;

-	    map->size_types= nTotalTypes;

-	}

-	else if (map->size_types<nTotalTypes) {

-	    XkbKeyTypeRec *prev_types = map->types;

-

-	    map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);

-	    if (map->types==NULL) {

-		_XkbFree(prev_types);

-		map->num_types= map->size_types= 0;

-		return BadAlloc;

-	    }

-	    map->size_types= nTotalTypes;

-	    bzero(&map->types[map->num_types],

-		  ((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));

-	}

-    }

-    if (which&XkbKeySymsMask) {

-	int nKeys= XkbNumKeys(xkb);

-	if (map->syms==NULL) {

-	    map->size_syms= (nKeys*15)/10;

-	    map->syms= _XkbTypedCalloc(map->size_syms,KeySym);

-	    if (!map->syms) {

-		map->size_syms= 0;

-		return BadAlloc;

-	    }

-	    map->num_syms= 1;

-	    map->syms[0]= NoSymbol;

-	}

-	if (map->key_sym_map==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->key_sym_map= _XkbTypedCalloc(i,XkbSymMapRec);

-	    if (map->key_sym_map==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbModifierMapMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->modmap==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->modmap= _XkbTypedCalloc(i,unsigned char);

-	    if (map->modmap==NULL)

-		return BadAlloc;

-	}

-    }

-    return Success;

-}

-

-Status

-XkbAllocServerMap(XkbDescPtr xkb,unsigned which,unsigned nNewActions)

-{

-register int	i;

-XkbServerMapPtr map;

-

-    if (xkb==NULL)

-	return BadMatch;

-    if (xkb->server==NULL) {

-	map= _XkbTypedCalloc(1,XkbServerMapRec);

-	if (map==NULL)

-	    return BadAlloc;

-	for (i=0;i<XkbNumVirtualMods;i++) {

-	    map->vmods[i]= XkbNoModifierMask;

-	}

-	xkb->server= map;

-    }

-    else map= xkb->server;

-    if (which&XkbExplicitComponentsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->explicit==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->explicit= _XkbTypedCalloc(i,unsigned char);

-	    if (map->explicit==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbKeyActionsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-        if (nNewActions<1)

-	    nNewActions= 1;

-	if (map->acts==NULL) {

-	    map->acts= _XkbTypedCalloc((nNewActions+1),XkbAction);

-	    if (map->acts==NULL)

-		return BadAlloc;

-	    map->num_acts= 1;

-	    map->size_acts= nNewActions+1;

-	}

-	else if ((map->size_acts-map->num_acts)<nNewActions) {

-	    unsigned need;

-	    XkbAction *prev_acts = map->acts;

-	    need= map->num_acts+nNewActions;

-	    map->acts= _XkbTypedRealloc(map->acts,need,XkbAction);

-	    if (map->acts==NULL) {

-		_XkbFree(prev_acts);

-	        map->num_acts= map->size_acts= 0;

-	        return BadAlloc;

-	    }

-	    map->size_acts= need;

-	    bzero(&map->acts[map->num_acts],

-		    ((map->size_acts-map->num_acts)*sizeof(XkbAction)));

-	}

-	if (map->key_acts==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->key_acts= _XkbTypedCalloc(i,unsigned short);

-	    if (map->key_acts==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbKeyBehaviorsMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->behaviors==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->behaviors= _XkbTypedCalloc(i,XkbBehavior);

-	    if (map->behaviors==NULL)

-		return BadAlloc;

-	}

-    }

-    if (which&XkbVirtualModMapMask) {

-	if ((!XkbIsLegalKeycode(xkb->min_key_code))||

-	    (!XkbIsLegalKeycode(xkb->max_key_code))||

-	    (xkb->max_key_code<xkb->min_key_code))

-	    return BadMatch;

-	if (map->vmodmap==NULL) {

-	    i= xkb->max_key_code+1;

-	    map->vmodmap= _XkbTypedCalloc(i,unsigned short);

-	    if (map->vmodmap==NULL)

-		return BadAlloc;

-	}

-    }

-    return Success;

-}

-

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

-

-Status

-XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)

-{

-    if ((!from)||(!into))

-	return BadMatch;

-    if (into->map) {

-	_XkbFree(into->map);

-	into->map= NULL;

-    }

-    if (into->preserve) {

-	_XkbFree(into->preserve);

-	into->preserve= NULL;

-    }

-    if (into->level_names) {

-	_XkbFree(into->level_names);

-	into->level_names= NULL;

-    }

-    *into= *from;

-    if ((from->map)&&(into->map_count>0)) {

-	into->map= _XkbTypedCalloc(into->map_count,XkbKTMapEntryRec);

-	if (!into->map)

-	    return BadAlloc;

-	memcpy(into->map,from->map,into->map_count*sizeof(XkbKTMapEntryRec));

-    }

-    if ((from->preserve)&&(into->map_count>0)) {

-	into->preserve= _XkbTypedCalloc(into->map_count,XkbModsRec);

-	if (!into->preserve)

-	    return BadAlloc;

-	memcpy(into->preserve,from->preserve,

-				into->map_count*sizeof(XkbModsRec));

-    }

-    if ((from->level_names)&&(into->num_levels>0)) {

-	into->level_names= _XkbTypedCalloc(into->num_levels,Atom);

-	if (!into->level_names)

-	    return BadAlloc;

-	memcpy(into->level_names,from->level_names,

-				 into->num_levels*sizeof(Atom));

-    }

-    return Success;

-}

-

-Status

-XkbCopyKeyTypes(XkbKeyTypePtr from,XkbKeyTypePtr into,int num_types)

-{

-register int i,rtrn;

-

-    if ((!from)||(!into)||(num_types<0))

-	return BadMatch;

-    for (i=0;i<num_types;i++) {

-	if ((rtrn= XkbCopyKeyType(from++,into++))!=Success)

-	    return rtrn;

-    }

-    return Success;

-}

-

-XkbKeyTypePtr

-XkbAddKeyType(	XkbDescPtr	xkb,

-		Atom 		name,

-		int 		map_count,

-		Bool 		want_preserve,

-		int		num_lvls)

-{

-register int 	i;

-unsigned	tmp;

-XkbKeyTypePtr	type;

-XkbClientMapPtr	map;

-

-    if ((!xkb)||(num_lvls<1))

-	return NULL;

-    map= xkb->map;

-    if ((map)&&(map->types)) {

-	for (i=0;i<map->num_types;i++) {

-	    if (map->types[i].name==name) {

-		Status status;

-		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);

-		return (status==Success?&map->types[i]:NULL);

-	    }

-	}

-    }

-    if ((!map)||(!map->types)||(!map->num_types<XkbNumRequiredTypes)) {

-	tmp= XkbNumRequiredTypes+1;

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

-	    return NULL;

-        if (!map)

-            map = xkb->map;

-	tmp= 0;

-	if (map->num_types<=XkbKeypadIndex)

-	    tmp|= XkbKeypadMask;

-	if (map->num_types<=XkbAlphabeticIndex)

-	    tmp|= XkbAlphabeticMask;

-	if (map->num_types<=XkbTwoLevelIndex)

-	    tmp|= XkbTwoLevelMask;

-	if (map->num_types<=XkbOneLevelIndex)

-	    tmp|= XkbOneLevelMask;

-	if (XkbInitCanonicalKeyTypes(xkb,tmp,XkbNoModifier)==Success) {

-	    for (i=0;i<map->num_types;i++) {

-		Status status;

-		if (map->types[i].name!=name)

-		    continue;

-		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);

-		return (status==Success?&map->types[i]:NULL);

-	    }

-	}

-    }

-    if ((map->num_types<=map->size_types)&&

-	(XkbAllocClientMap(xkb,XkbKeyTypesMask,map->num_types+1)!=Success)) {

-	return NULL;

-    }

-    type= &map->types[map->num_types];

-    map->num_types++;

-    bzero((char *)type,sizeof(XkbKeyTypeRec));

-    type->num_levels=	num_lvls;

-    type->map_count=	map_count;

-    type->name=		name;

-    if (map_count>0) {

-	type->map=	_XkbTypedCalloc(map_count,XkbKTMapEntryRec);

-	if (!type->map) {

-	    map->num_types--;

-	    return NULL;

-	}

-	if (want_preserve) {

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

-	    if (!type->preserve) {

-		_XkbFree(type->map);

-		map->num_types--;

-		return NULL;

-	    }

-	}

-    }

-    return type;

-}

-

-Status

-XkbResizeKeyType(	XkbDescPtr	xkb,

-			int		type_ndx,

-			int		map_count,

-			Bool		want_preserve,

-			int		new_num_lvls)

-{

-XkbKeyTypePtr	type;

-KeyCode		matchingKeys[XkbMaxKeyCount],nMatchingKeys;

-

-    if ((type_ndx<0)||(type_ndx>=xkb->map->num_types)||(map_count<0)||

-    							(new_num_lvls<1))

-	return BadValue;

-    switch (type_ndx) {

-	case XkbOneLevelIndex:

-	    if (new_num_lvls!=1)

-		return BadMatch;

-	    break;

-	case XkbTwoLevelIndex:

-	case XkbAlphabeticIndex:

-	case XkbKeypadIndex:

-	    if (new_num_lvls!=2)

-		return BadMatch;

-	    break;

-    }

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

-    if (map_count==0) {

-	if (type->map!=NULL)

-	    _XkbFree(type->map);

-	type->map= NULL;

-	if (type->preserve!=NULL)

-	    _XkbFree(type->preserve);

-	type->preserve= NULL;

-	type->map_count= 0;

-    }

-    else {

-	XkbKTMapEntryRec *prev_map = type->map;

-

-	if ((map_count>type->map_count)||(type->map==NULL))

-	    type->map=_XkbTypedRealloc(type->map,map_count,XkbKTMapEntryRec);

-	if (!type->map) {

-	    if (prev_map)

-		_XkbFree(prev_map);

-	    return BadAlloc;

-	}

-	if (want_preserve) {

-	    XkbModsRec *prev_preserve = type->preserve;

-

-	    if ((map_count>type->map_count)||(type->preserve==NULL)) {

-		type->preserve= _XkbTypedRealloc(type->preserve,map_count,

-	     						    XkbModsRec);

-	    }

-	    if (!type->preserve) {

-		if (prev_preserve)

-		    _XkbFree(prev_preserve);

-		return BadAlloc;

-	    }

-	}

-	else if (type->preserve!=NULL) {

-	    _XkbFree(type->preserve);

-	    type->preserve= NULL;

-	}

-	type->map_count= map_count;

-    }

-

-    if ((new_num_lvls>type->num_levels)||(type->level_names==NULL)) {

-	Atom * prev_level_names = type->level_names;

-

-	type->level_names=_XkbTypedRealloc(type->level_names,new_num_lvls,Atom);

-	if (!type->level_names) {

-	    if (prev_level_names)

-		_XkbFree(prev_level_names);

-	    return BadAlloc;

-	}

-    }

-    /*

-     * Here's the theory:

-     *    If the width of the type changed, we might have to resize the symbol

-     * maps for any keys that use the type for one or more groups.  This is

-     * expensive, so we'll try to cull out any keys that are obviously okay:

-     * In any case:

-     *    - keys that have a group width <= the old width are okay (because

-     *      they could not possibly have been associated with the old type)

-     * If the key type increased in size:

-     *    - keys that already have a group width >= to the new width are okay

-     *    + keys that have a group width >= the old width but < the new width

-     *      might have to be enlarged.

-     * If the key type decreased in size:

-     *    - keys that have a group width > the old width don't have to be

-     *      resized (because they must have some other wider type associated

-     *      with some group).

-     *    + keys that have a group width == the old width might have to be

-     *      shrunk.

-     * The possibilities marked with '+' require us to examine the key types

-     * associated with each group for the key.

-     */

-    bzero(matchingKeys,XkbMaxKeyCount*sizeof(KeyCode));

-    nMatchingKeys= 0;

-    if (new_num_lvls>type->num_levels) {

-	int	 		nTotal;

-	KeySym	*		newSyms;

-	int			width,match,nResize;

-	register int		i,g,nSyms;

-

-	nResize= 0;

-	for (nTotal=1,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-	    width= XkbKeyGroupsWidth(xkb,i);

-	    if (width<type->num_levels)

-		continue;

-	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {

-		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {

-		    matchingKeys[nMatchingKeys++]= i;

-		    match= 1;

-		}

-	    }

-	    if ((!match)||(width>=new_num_lvls))

-		nTotal+= XkbKeyNumSyms(xkb,i);

-	    else {

-		nTotal+= XkbKeyNumGroups(xkb,i)*new_num_lvls;

-		nResize++;

-	    }

-	}

-	if (nResize>0) {

-	    int nextMatch;

-	    xkb->map->size_syms= (nTotal*12)/10;

-	    newSyms = _XkbTypedCalloc(xkb->map->size_syms,KeySym);

-	    if (newSyms==NULL)

-		return BadAlloc;

-	    nextMatch= 0;

-	    nSyms= 1;

-	    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-		if (matchingKeys[nextMatch]==i) {

-		    KeySym *pOld;

-		    nextMatch++;

-		    width= XkbKeyGroupsWidth(xkb,i);

-		    pOld= XkbKeySymsPtr(xkb,i);

-		    for (g=XkbKeyNumGroups(xkb,i)-1;g>=0;g--) {

-			memcpy(&newSyms[nSyms+(new_num_lvls*g)],&pOld[width*g],

-							width*sizeof(KeySym));

-		    }

-		    xkb->map->key_sym_map[i].offset= nSyms;

-		    nSyms+= XkbKeyNumGroups(xkb,i)*new_num_lvls;

-		}

-		else {

-		    memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),

-					XkbKeyNumSyms(xkb,i)*sizeof(KeySym));

-		    xkb->map->key_sym_map[i].offset= nSyms;

-		    nSyms+= XkbKeyNumSyms(xkb,i);

-		}

-	    }

-	    type->num_levels= new_num_lvls;

-	    _XkbFree(xkb->map->syms);

-	    xkb->map->syms= newSyms;

-	    xkb->map->num_syms= nSyms;

-	    return Success;

-	}

-    }

-    else if (new_num_lvls<type->num_levels) {

-	int 		width,match;

-	register int	g,i;

-	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {

-	    width= XkbKeyGroupsWidth(xkb,i);

-	    if (width<type->num_levels)

-		continue;

-	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {

-		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {

-		    matchingKeys[nMatchingKeys++]= i;

-		    match= 1;

-		}

-	    }

-	}

-    }

-    if (nMatchingKeys>0) {

-	int 		key,firstClear;

-	register int	i,g;

-	if (new_num_lvls>type->num_levels)

-	     firstClear= type->num_levels;

-	else firstClear= new_num_lvls;

-	for (i=0;i<nMatchingKeys;i++) {

-	    KeySym *	pSyms;

-	    int		width,nClear;

-

-	    key= matchingKeys[i];

-	    width= XkbKeyGroupsWidth(xkb,key);

-	    nClear= width-firstClear;

-	    pSyms= XkbKeySymsPtr(xkb,key);

-	    for (g=XkbKeyNumGroups(xkb,key)-1;g>=0;g--) {

-		if (XkbKeyKeyTypeIndex(xkb,key,g)==type_ndx) {

-		    if (nClear>0)

-			bzero(&pSyms[g*width+firstClear],nClear*sizeof(KeySym));

-		}

-	    }

-	}

-    }

-    type->num_levels= new_num_lvls;

-    return Success;

-}

-

-KeySym *

-XkbResizeKeySyms(XkbDescPtr xkb,int key,int needed)

-{

-register int i,nSyms,nKeySyms;

-unsigned nOldSyms;

-KeySym	*newSyms;

-

-    if (needed==0) {

-	xkb->map->key_sym_map[key].offset= 0;

-	return xkb->map->syms;

-    }

-    nOldSyms= XkbKeyNumSyms(xkb,key);

-    if (nOldSyms>=(unsigned)needed) {

-	return XkbKeySymsPtr(xkb,key);

-    }

-    if (xkb->map->size_syms-xkb->map->num_syms>=(unsigned)needed) {

-	if (nOldSyms>0) {

-	    memcpy(&xkb->map->syms[xkb->map->num_syms],XkbKeySymsPtr(xkb,key),

-						nOldSyms*sizeof(KeySym));

-	}

-	if ((needed-nOldSyms)>0) {

-	    bzero(&xkb->map->syms[xkb->map->num_syms+XkbKeyNumSyms(xkb,key)],

-					(needed-nOldSyms)*sizeof(KeySym));

-	}

-	xkb->map->key_sym_map[key].offset = xkb->map->num_syms;

-	xkb->map->num_syms+= needed;

-	return &xkb->map->syms[xkb->map->key_sym_map[key].offset];

-    }

-    xkb->map->size_syms+= (needed>32?needed:32);

-    newSyms = _XkbTypedCalloc(xkb->map->size_syms,KeySym);

-    if (newSyms==NULL)

-	return NULL;

-    newSyms[0]= NoSymbol;

-    nSyms = 1;

-    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {

-	int nCopy;

-

-	nCopy= nKeySyms= XkbKeyNumSyms(xkb,i);

-	if ((nKeySyms==0)&&(i!=key))

-	    continue;

-	if (i==key)

-	    nKeySyms= needed;

-	if (nCopy!=0)

-	   memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),nCopy*sizeof(KeySym));

-	if (nKeySyms>nCopy)

-	    bzero(&newSyms[nSyms+nCopy],(nKeySyms-nCopy)*sizeof(KeySym));

-	xkb->map->key_sym_map[i].offset = nSyms;

-	nSyms+= nKeySyms;

-    }

-    _XkbFree(xkb->map->syms);

-    xkb->map->syms = newSyms;

-    xkb->map->num_syms = nSyms;

-    return &xkb->map->syms[xkb->map->key_sym_map[key].offset];

-}

-

-static unsigned

-_ExtendRange(	unsigned int 	old_flags,

-		unsigned int	flag,

-		KeyCode		newKC,

-		KeyCode *	old_min,

-		unsigned char *	old_num)

-{

-    if ((old_flags&flag)==0) {

-	old_flags|= flag;

-	*old_min= newKC;

-	*old_num= 1;

-    }

-    else {

-	int	last= (*old_min)+(*old_num)-1;

-	if (newKC<*old_min) {

-	    *old_min= newKC;

-	    *old_num= (last-newKC)+1;

-	}

-	else if (newKC>last) {

-	    *old_num= (newKC-(*old_min))+1;

-	}

-    }

-    return old_flags;

-}

-

-Status

-XkbChangeKeycodeRange(	XkbDescPtr	xkb,

-			int 		minKC,

-			int 		maxKC,

-			XkbChangesPtr	changes)

-{

-int	tmp;

-

-    if ((!xkb)||(minKC<XkbMinLegalKeyCode)||(maxKC>XkbMaxLegalKeyCode))

-	return BadValue;

-    if (minKC>maxKC)

-	return BadMatch;

-    if (minKC<xkb->min_key_code) {

-	if (changes)

-	    changes->map.min_key_code= minKC;

-	tmp= xkb->min_key_code-minKC;

-	if (xkb->map)  {

-	    if (xkb->map->key_sym_map) {

-		bzero((char *)&xkb->map->key_sym_map[minKC],

-					tmp*sizeof(XkbSymMapRec));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbKeySymsMask,minKC,

-	    					&changes->map.first_key_sym,

-	    					&changes->map.num_key_syms);

-		}

-	    }

-	    if (xkb->map->modmap) {

-		bzero((char *)&xkb->map->modmap[minKC],tmp);

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbModifierMapMask,minKC,

-	    					&changes->map.first_modmap_key,

-	    					&changes->map.num_modmap_keys);

-		}

-	    }

-	}

-	if (xkb->server) {

-	    if (xkb->server->behaviors) {

-		bzero((char *)&xkb->server->behaviors[minKC],

-						tmp*sizeof(XkbBehavior));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyBehaviorsMask,minKC,

-    					&changes->map.first_key_behavior,

-    					&changes->map.num_key_behaviors);

-		}

-	    }

-	    if (xkb->server->key_acts) {

-		bzero((char *)&xkb->server->key_acts[minKC],

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyActionsMask,minKC,

-    					&changes->map.first_key_act,

-    					&changes->map.num_key_acts);

-		}

-	    }

-	    if (xkb->server->vmodmap) {

-		bzero((char *)&xkb->server->vmodmap[minKC],

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbVirtualModMapMask,minKC,

-		    			&changes->map.first_modmap_key,

-    					&changes->map.num_vmodmap_keys);

-		}

-	    }

-	}

-	if ((xkb->names)&&(xkb->names->keys)) {

-	    bzero((char *)&xkb->names->keys[minKC],tmp*sizeof(XkbKeyNameRec));

-	    if (changes) {

-		changes->names.changed= _ExtendRange(changes->names.changed,

-					XkbKeyNamesMask,minKC,

-					&changes->names.first_key,

-    					&changes->names.num_keys);

-	    }

-	}

-	xkb->min_key_code= minKC;

-    }

-    if (maxKC>xkb->max_key_code) {

-	if (changes)

-	    changes->map.max_key_code= maxKC;

-	tmp= maxKC-xkb->max_key_code;

-	if (xkb->map)  {

-	    if (xkb->map->key_sym_map) {

-		XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;

-

-		xkb->map->key_sym_map= _XkbTypedRealloc(xkb->map->key_sym_map,

-						(maxKC+1),XkbSymMapRec);

-		if (!xkb->map->key_sym_map) {

-		    _XkbFree(prev_key_sym_map);

-		    return BadAlloc;

-		}

-		bzero((char *)&xkb->map->key_sym_map[xkb->max_key_code],

-					tmp*sizeof(XkbSymMapRec));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbKeySymsMask,maxKC,

-	    					&changes->map.first_key_sym,

-	    					&changes->map.num_key_syms);

-		}

-	    }

-	    if (xkb->map->modmap) {

-		unsigned char *prev_modmap = xkb->map->modmap;

-

-		xkb->map->modmap= _XkbTypedRealloc(xkb->map->modmap,

-						(maxKC+1),unsigned char);

-		if (!xkb->map->modmap) {

-		    _XkbFree(prev_modmap);

-		    return BadAlloc;

-		}

-		bzero((char *)&xkb->map->modmap[xkb->max_key_code],tmp);

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    				XkbModifierMapMask,maxKC,

-	    					&changes->map.first_modmap_key,

-	    					&changes->map.num_modmap_keys);

-		}

-	    }

-	}

-	if (xkb->server) {

-	    if (xkb->server->behaviors) {

-		XkbBehavior *prev_behaviors = xkb->server->behaviors;

-

-		xkb->server->behaviors=_XkbTypedRealloc(xkb->server->behaviors,

-						(maxKC+1),XkbBehavior);

-		if (!xkb->server->behaviors) {

-		    _XkbFree(prev_behaviors);

-		    return BadAlloc;

-		}

-		bzero((char *)&xkb->server->behaviors[xkb->max_key_code],

-						tmp*sizeof(XkbBehavior));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyBehaviorsMask,maxKC,

-    					&changes->map.first_key_behavior,

-    					&changes->map.num_key_behaviors);

-		}

-	    }

-	    if (xkb->server->key_acts) {

-		unsigned short *prev_key_acts = xkb->server->key_acts;

-

-		xkb->server->key_acts= _XkbTypedRealloc(xkb->server->key_acts,

-						(maxKC+1),unsigned short);

-		if (!xkb->server->key_acts) {

-		    _XkbFree(prev_key_acts);

-		    return BadAlloc;

-		}

-		bzero((char *)&xkb->server->key_acts[xkb->max_key_code],

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbKeyActionsMask,maxKC,

-    					&changes->map.first_key_act,

-    					&changes->map.num_key_acts);

-		}

-	    }

-	    if (xkb->server->vmodmap) {

-		unsigned short *prev_vmodmap = xkb->server->vmodmap;

-

-		xkb->server->vmodmap= _XkbTypedRealloc(xkb->server->vmodmap,

-						(maxKC+1),unsigned short);

-		if (!xkb->server->vmodmap) {

-		    _XkbFree(prev_vmodmap);

-		    return BadAlloc;

-		}

-		bzero((char *)&xkb->server->vmodmap[xkb->max_key_code],

-						tmp*sizeof(unsigned short));

-		if (changes) {

-		    changes->map.changed= _ExtendRange(changes->map.changed,

-		    			XkbVirtualModMapMask,maxKC,

-		    			&changes->map.first_modmap_key,

-    					&changes->map.num_vmodmap_keys);

-		}

-	    }

-	}

-	if ((xkb->names)&&(xkb->names->keys)) {

-	    XkbKeyNameRec *prev_keys = xkb->names->keys;

-

-	    xkb->names->keys= _XkbTypedRealloc(xkb->names->keys,

-	    					(maxKC+1),XkbKeyNameRec);

-	    if (!xkb->names->keys) {

-		_XkbFree(prev_keys);

-		return BadAlloc;

-	    }

-	    bzero((char *)&xkb->names->keys[xkb->max_key_code],

-	    					tmp*sizeof(XkbKeyNameRec));

-	    if (changes) {

-		changes->names.changed= _ExtendRange(changes->names.changed,

-					XkbKeyNamesMask,maxKC,

-					&changes->names.first_key,

-    					&changes->names.num_keys);

-	    }

-	}

-	xkb->max_key_code= maxKC;

-    }

-    return Success;

-}

-

-XkbAction *

-XkbResizeKeyActions(XkbDescPtr xkb,int key,int needed)

-{

-register int i,nActs;

-XkbAction *newActs;

-

-    if (needed==0) {

-	xkb->server->key_acts[key]= 0;

-	return NULL;

-    }

-    if (XkbKeyHasActions(xkb,key)&&(XkbKeyNumSyms(xkb,key)>=(unsigned)needed))

-	return XkbKeyActionsPtr(xkb,key);

-    if (xkb->server->size_acts-xkb->server->num_acts>=(unsigned)needed) {

-	xkb->server->key_acts[key]= xkb->server->num_acts;

-	xkb->server->num_acts+= needed;

-	return &xkb->server->acts[xkb->server->key_acts[key]];

-    }

-    xkb->server->size_acts= xkb->server->num_acts+needed+8;

-    newActs = _XkbTypedCalloc(xkb->server->size_acts,XkbAction);

-    if (newActs==NULL)

-	return NULL;

-    newActs[0].type = XkbSA_NoAction;

-    nActs = 1;

-    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {

-	int nKeyActs,nCopy;

-

-	if ((xkb->server->key_acts[i]==0)&&(i!=key))

-	    continue;

-

-	nCopy= nKeyActs= XkbKeyNumActions(xkb,i);

-	if (i==key) {

-	    nKeyActs= needed;

-	    if (needed<nCopy)

-		nCopy= needed;

-	}

-

-	if (nCopy>0)

-	    memcpy(&newActs[nActs],XkbKeyActionsPtr(xkb,i),

-						nCopy*sizeof(XkbAction));

-	if (nCopy<nKeyActs)

-	    bzero(&newActs[nActs+nCopy],(nKeyActs-nCopy)*sizeof(XkbAction));

-	xkb->server->key_acts[i]= nActs;

-	nActs+= nKeyActs;

-    }

-    _XkbFree(xkb->server->acts);

-    xkb->server->acts = newActs;

-    xkb->server->num_acts= nActs;

-    return &xkb->server->acts[xkb->server->key_acts[key]];

-}

-

-void

-XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)

-{

-XkbClientMapPtr	map;

-

-    if ((xkb==NULL)||(xkb->map==NULL))

-	return;

-    if (freeMap)

-	what= XkbAllClientInfoMask;

-    map= xkb->map;

-    if (what&XkbKeyTypesMask) {

-	if (map->types!=NULL) {

-	    if (map->num_types>0) {

-		register int 	i;

-		XkbKeyTypePtr	type;

-		for (i=0,type=map->types;i<map->num_types;i++,type++) {

-		    if (type->map!=NULL) {

-			_XkbFree(type->map);

-			type->map= NULL;

-		    }

-		    if (type->preserve!=NULL) {

-			_XkbFree(type->preserve);

-			type->preserve= NULL;

-		    }

-		    type->map_count= 0;

-		    if (type->level_names!=NULL) {

-			_XkbFree(type->level_names);

-			type->level_names= NULL;

-		    }

-		}

-	    }

-	    _XkbFree(map->types);

-	    map->num_types= map->size_types= 0;

-	    map->types= NULL;

-	}

-    }

-    if (what&XkbKeySymsMask) {

-	if (map->key_sym_map!=NULL) {

-	    _XkbFree(map->key_sym_map);

-	    map->key_sym_map= NULL;

-	}

-	if (map->syms!=NULL) {

-	    _XkbFree(map->syms);

-	    map->size_syms= map->num_syms= 0;

-	    map->syms= NULL;

-	}

-    }

-    if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {

-	_XkbFree(map->modmap);

-	map->modmap= NULL;

-    }

-    if (freeMap) {

-	_XkbFree(xkb->map);

-	xkb->map= NULL;

-    }

-    return;

-}

-

-void

-XkbFreeServerMap(XkbDescPtr xkb,unsigned what,Bool freeMap)

-{

-XkbServerMapPtr	map;

-

-    if ((xkb==NULL)||(xkb->server==NULL))

-	return;

-    if (freeMap)

-	what= XkbAllServerInfoMask;

-    map= xkb->server;

-    if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {

-	_XkbFree(map->explicit);

-	map->explicit= NULL;

-    }

-    if (what&XkbKeyActionsMask) {

-	if (map->key_acts!=NULL) {

-	    _XkbFree(map->key_acts);

-	    map->key_acts= NULL;

-	}

-	if (map->acts!=NULL) {

-	    _XkbFree(map->acts);

-	    map->num_acts= map->size_acts= 0;

-	    map->acts= NULL;

-	}

-    }

-    if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {

-	_XkbFree(map->behaviors);

-	map->behaviors= NULL;

-    }

-    if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {

-	_XkbFree(map->vmodmap);

-	map->vmodmap= NULL;

-    }

-

-    if (freeMap) {

-	_XkbFree(xkb->server);

-	xkb->server= NULL;

-    }

-    return;

-}

+/************************************************************
+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_DIX_CONFIG_H
+#include <dix-config.h>
+#elif defined(HAVE_CONFIG_H)
+#include <config.h>
+#endif
+
+#ifndef XKB_IN_SERVER
+
+#include <stdio.h>
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include <X11/keysym.h>
+#include "XKBlibint.h"
+
+#else
+
+#include <stdio.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "misc.h"
+#include "inputstr.h"
+#include <X11/keysym.h>
+#define	XKBSRV_NEED_FILE_FUNCS
+#include <X11/extensions/XKBsrv.h>
+
+#endif /* XKB_IN_SERVER */
+
+/***====================================================================***/
+
+Status
+XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
+{
+register int	i;
+XkbClientMapPtr map;
+
+    if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))
+	return BadValue;
+    if ((which&XkbKeySymsMask)&&
+	((!XkbIsLegalKeycode(xkb->min_key_code))||
+	 (!XkbIsLegalKeycode(xkb->max_key_code))||
+	 (xkb->max_key_code<xkb->min_key_code))) {
+#ifdef DEBUG
+fprintf(stderr,"bad keycode (%d,%d) in XkbAllocClientMap\n",
+				xkb->min_key_code,xkb->max_key_code);
+#endif
+	return BadValue;
+    }
+
+    if (xkb->map==NULL) {
+	map= _XkbTypedCalloc(1,XkbClientMapRec);
+	if (map==NULL)
+	    return BadAlloc;
+	xkb->map= map;
+    }
+    else map= xkb->map;
+
+    if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {
+	if (map->types==NULL) {
+	    map->types= _XkbTypedCalloc(nTotalTypes,XkbKeyTypeRec);
+	    if (map->types==NULL)
+		return BadAlloc;
+	    map->num_types= 0;
+	    map->size_types= nTotalTypes;
+	}
+	else if (map->size_types<nTotalTypes) {
+	    XkbKeyTypeRec *prev_types = map->types;
+
+	    map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);
+	    if (map->types==NULL) {
+		_XkbFree(prev_types);
+		map->num_types= map->size_types= 0;
+		return BadAlloc;
+	    }
+	    map->size_types= nTotalTypes;
+	    bzero(&map->types[map->num_types],
+		  ((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));
+	}
+    }
+    if (which&XkbKeySymsMask) {
+	int nKeys= XkbNumKeys(xkb);
+	if (map->syms==NULL) {
+	    map->size_syms= (nKeys*15)/10;
+	    map->syms= _XkbTypedCalloc(map->size_syms,KeySym);
+	    if (!map->syms) {
+		map->size_syms= 0;
+		return BadAlloc;
+	    }
+	    map->num_syms= 1;
+	    map->syms[0]= NoSymbol;
+	}
+	if (map->key_sym_map==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->key_sym_map= _XkbTypedCalloc(i,XkbSymMapRec);
+	    if (map->key_sym_map==NULL)
+		return BadAlloc;
+	}
+    }
+    if (which&XkbModifierMapMask) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadMatch;
+	if (map->modmap==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->modmap= _XkbTypedCalloc(i,unsigned char);
+	    if (map->modmap==NULL)
+		return BadAlloc;
+	}
+    }
+    return Success;
+}
+
+Status
+XkbAllocServerMap(XkbDescPtr xkb,unsigned which,unsigned nNewActions)
+{
+register int	i;
+XkbServerMapPtr map;
+
+    if (xkb==NULL)
+	return BadMatch;
+    if (xkb->server==NULL) {
+	map= _XkbTypedCalloc(1,XkbServerMapRec);
+	if (map==NULL)
+	    return BadAlloc;
+	for (i=0;i<XkbNumVirtualMods;i++) {
+	    map->vmods[i]= XkbNoModifierMask;
+	}
+	xkb->server= map;
+    }
+    else map= xkb->server;
+    if (which&XkbExplicitComponentsMask) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadMatch;
+	if (map->explicit==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->explicit= _XkbTypedCalloc(i,unsigned char);
+	    if (map->explicit==NULL)
+		return BadAlloc;
+	}
+    }
+    if (which&XkbKeyActionsMask) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadMatch;
+        if (nNewActions<1)
+	    nNewActions= 1;
+	if (map->acts==NULL) {
+	    map->acts= _XkbTypedCalloc((nNewActions+1),XkbAction);
+	    if (map->acts==NULL)
+		return BadAlloc;
+	    map->num_acts= 1;
+	    map->size_acts= nNewActions+1;
+	}
+	else if ((map->size_acts-map->num_acts)<nNewActions) {
+	    unsigned need;
+	    XkbAction *prev_acts = map->acts;
+	    need= map->num_acts+nNewActions;
+	    map->acts= _XkbTypedRealloc(map->acts,need,XkbAction);
+	    if (map->acts==NULL) {
+		_XkbFree(prev_acts);
+	        map->num_acts= map->size_acts= 0;
+	        return BadAlloc;
+	    }
+	    map->size_acts= need;
+	    bzero(&map->acts[map->num_acts],
+		    ((map->size_acts-map->num_acts)*sizeof(XkbAction)));
+	}
+	if (map->key_acts==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->key_acts= _XkbTypedCalloc(i,unsigned short);
+	    if (map->key_acts==NULL)
+		return BadAlloc;
+	}
+    }
+    if (which&XkbKeyBehaviorsMask) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadMatch;
+	if (map->behaviors==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->behaviors= _XkbTypedCalloc(i,XkbBehavior);
+	    if (map->behaviors==NULL)
+		return BadAlloc;
+	}
+    }
+    if (which&XkbVirtualModMapMask) {
+	if ((!XkbIsLegalKeycode(xkb->min_key_code))||
+	    (!XkbIsLegalKeycode(xkb->max_key_code))||
+	    (xkb->max_key_code<xkb->min_key_code))
+	    return BadMatch;
+	if (map->vmodmap==NULL) {
+	    i= xkb->max_key_code+1;
+	    map->vmodmap= _XkbTypedCalloc(i,unsigned short);
+	    if (map->vmodmap==NULL)
+		return BadAlloc;
+	}
+    }
+    return Success;
+}
+
+/***====================================================================***/
+
+Status
+XkbCopyKeyType(XkbKeyTypePtr from,XkbKeyTypePtr into)
+{
+    if ((!from)||(!into))
+	return BadMatch;
+    if (into->map) {
+	_XkbFree(into->map);
+	into->map= NULL;
+    }
+    if (into->preserve) {
+	_XkbFree(into->preserve);
+	into->preserve= NULL;
+    }
+    if (into->level_names) {
+	_XkbFree(into->level_names);
+	into->level_names= NULL;
+    }
+    *into= *from;
+    if ((from->map)&&(into->map_count>0)) {
+	into->map= _XkbTypedCalloc(into->map_count,XkbKTMapEntryRec);
+	if (!into->map)
+	    return BadAlloc;
+	memcpy(into->map,from->map,into->map_count*sizeof(XkbKTMapEntryRec));
+    }
+    if ((from->preserve)&&(into->map_count>0)) {
+	into->preserve= _XkbTypedCalloc(into->map_count,XkbModsRec);
+	if (!into->preserve)
+	    return BadAlloc;
+	memcpy(into->preserve,from->preserve,
+				into->map_count*sizeof(XkbModsRec));
+    }
+    if ((from->level_names)&&(into->num_levels>0)) {
+	into->level_names= _XkbTypedCalloc(into->num_levels,Atom);
+	if (!into->level_names)
+	    return BadAlloc;
+	memcpy(into->level_names,from->level_names,
+				 into->num_levels*sizeof(Atom));
+    }
+    return Success;
+}
+
+Status
+XkbCopyKeyTypes(XkbKeyTypePtr from,XkbKeyTypePtr into,int num_types)
+{
+register int i,rtrn;
+
+    if ((!from)||(!into)||(num_types<0))
+	return BadMatch;
+    for (i=0;i<num_types;i++) {
+	if ((rtrn= XkbCopyKeyType(from++,into++))!=Success)
+	    return rtrn;
+    }
+    return Success;
+}
+
+XkbKeyTypePtr
+XkbAddKeyType(	XkbDescPtr	xkb,
+		Atom 		name,
+		int 		map_count,
+		Bool 		want_preserve,
+		int		num_lvls)
+{
+register int 	i;
+unsigned	tmp;
+XkbKeyTypePtr	type;
+XkbClientMapPtr	map;
+
+    if ((!xkb)||(num_lvls<1))
+	return NULL;
+    map= xkb->map;
+    if ((map)&&(map->types)) {
+	for (i=0;i<map->num_types;i++) {
+	    if (map->types[i].name==name) {
+		Status status;
+		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);
+		return (status==Success?&map->types[i]:NULL);
+	    }
+	}
+    }
+    if ((!map)||(!map->types)||(!map->num_types<XkbNumRequiredTypes)) {
+	tmp= XkbNumRequiredTypes+1;
+	if (XkbAllocClientMap(xkb,XkbKeyTypesMask,tmp)!=Success)
+	    return NULL;
+        if (!map)
+            map = xkb->map;
+	tmp= 0;
+	if (map->num_types<=XkbKeypadIndex)
+	    tmp|= XkbKeypadMask;
+	if (map->num_types<=XkbAlphabeticIndex)
+	    tmp|= XkbAlphabeticMask;
+	if (map->num_types<=XkbTwoLevelIndex)
+	    tmp|= XkbTwoLevelMask;
+	if (map->num_types<=XkbOneLevelIndex)
+	    tmp|= XkbOneLevelMask;
+	if (XkbInitCanonicalKeyTypes(xkb,tmp,XkbNoModifier)==Success) {
+	    for (i=0;i<map->num_types;i++) {
+		Status status;
+		if (map->types[i].name!=name)
+		    continue;
+		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);
+		return (status==Success?&map->types[i]:NULL);
+	    }
+	}
+    }
+    if ((map->num_types<=map->size_types)&&
+	(XkbAllocClientMap(xkb,XkbKeyTypesMask,map->num_types+1)!=Success)) {
+	return NULL;
+    }
+    type= &map->types[map->num_types];
+    map->num_types++;
+    bzero((char *)type,sizeof(XkbKeyTypeRec));
+    type->num_levels=	num_lvls;
+    type->map_count=	map_count;
+    type->name=		name;
+    if (map_count>0) {
+	type->map=	_XkbTypedCalloc(map_count,XkbKTMapEntryRec);
+	if (!type->map) {
+	    map->num_types--;
+	    return NULL;
+	}
+	if (want_preserve) {
+	    type->preserve=	_XkbTypedCalloc(map_count,XkbModsRec);
+	    if (!type->preserve) {
+		_XkbFree(type->map);
+		map->num_types--;
+		return NULL;
+	    }
+	}
+    }
+    return type;
+}
+
+Status
+XkbResizeKeyType(	XkbDescPtr	xkb,
+			int		type_ndx,
+			int		map_count,
+			Bool		want_preserve,
+			int		new_num_lvls)
+{
+XkbKeyTypePtr	type;
+KeyCode		matchingKeys[XkbMaxKeyCount],nMatchingKeys;
+
+    if ((type_ndx<0)||(type_ndx>=xkb->map->num_types)||(map_count<0)||
+    							(new_num_lvls<1))
+	return BadValue;
+    switch (type_ndx) {
+	case XkbOneLevelIndex:
+	    if (new_num_lvls!=1)
+		return BadMatch;
+	    break;
+	case XkbTwoLevelIndex:
+	case XkbAlphabeticIndex:
+	case XkbKeypadIndex:
+	    if (new_num_lvls!=2)
+		return BadMatch;
+	    break;
+    }
+    type= &xkb->map->types[type_ndx];
+    if (map_count==0) {
+	if (type->map!=NULL)
+	    _XkbFree(type->map);
+	type->map= NULL;
+	if (type->preserve!=NULL)
+	    _XkbFree(type->preserve);
+	type->preserve= NULL;
+	type->map_count= 0;
+    }
+    else {
+	XkbKTMapEntryRec *prev_map = type->map;
+
+	if ((map_count>type->map_count)||(type->map==NULL))
+	    type->map=_XkbTypedRealloc(type->map,map_count,XkbKTMapEntryRec);
+	if (!type->map) {
+	    if (prev_map)
+		_XkbFree(prev_map);
+	    return BadAlloc;
+	}
+	if (want_preserve) {
+	    XkbModsRec *prev_preserve = type->preserve;
+
+	    if ((map_count>type->map_count)||(type->preserve==NULL)) {
+		type->preserve= _XkbTypedRealloc(type->preserve,map_count,
+	     						    XkbModsRec);
+	    }
+	    if (!type->preserve) {
+		if (prev_preserve)
+		    _XkbFree(prev_preserve);
+		return BadAlloc;
+	    }
+	}
+	else if (type->preserve!=NULL) {
+	    _XkbFree(type->preserve);
+	    type->preserve= NULL;
+	}
+	type->map_count= map_count;
+    }
+
+    if ((new_num_lvls>type->num_levels)||(type->level_names==NULL)) {
+	Atom * prev_level_names = type->level_names;
+
+	type->level_names=_XkbTypedRealloc(type->level_names,new_num_lvls,Atom);
+	if (!type->level_names) {
+	    if (prev_level_names)
+		_XkbFree(prev_level_names);
+	    return BadAlloc;
+	}
+    }
+    /*
+     * Here's the theory:
+     *    If the width of the type changed, we might have to resize the symbol
+     * maps for any keys that use the type for one or more groups.  This is
+     * expensive, so we'll try to cull out any keys that are obviously okay:
+     * In any case:
+     *    - keys that have a group width <= the old width are okay (because
+     *      they could not possibly have been associated with the old type)
+     * If the key type increased in size:
+     *    - keys that already have a group width >= to the new width are okay
+     *    + keys that have a group width >= the old width but < the new width
+     *      might have to be enlarged.
+     * If the key type decreased in size:
+     *    - keys that have a group width > the old width don't have to be
+     *      resized (because they must have some other wider type associated
+     *      with some group).
+     *    + keys that have a group width == the old width might have to be
+     *      shrunk.
+     * The possibilities marked with '+' require us to examine the key types
+     * associated with each group for the key.
+     */
+    bzero(matchingKeys,XkbMaxKeyCount*sizeof(KeyCode));
+    nMatchingKeys= 0;
+    if (new_num_lvls>type->num_levels) {
+	int	 		nTotal;
+	KeySym	*		newSyms;
+	int			width,match,nResize;
+	register int		i,g,nSyms;
+
+	nResize= 0;
+	for (nTotal=1,i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+	    width= XkbKeyGroupsWidth(xkb,i);
+	    if (width<type->num_levels)
+		continue;
+	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {
+		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {
+		    matchingKeys[nMatchingKeys++]= i;
+		    match= 1;
+		}
+	    }
+	    if ((!match)||(width>=new_num_lvls))
+		nTotal+= XkbKeyNumSyms(xkb,i);
+	    else {
+		nTotal+= XkbKeyNumGroups(xkb,i)*new_num_lvls;
+		nResize++;
+	    }
+	}
+	if (nResize>0) {
+	    int nextMatch;
+	    xkb->map->size_syms= (nTotal*12)/10;
+	    newSyms = _XkbTypedCalloc(xkb->map->size_syms,KeySym);
+	    if (newSyms==NULL)
+		return BadAlloc;
+	    nextMatch= 0;
+	    nSyms= 1;
+	    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+		if (matchingKeys[nextMatch]==i) {
+		    KeySym *pOld;
+		    nextMatch++;
+		    width= XkbKeyGroupsWidth(xkb,i);
+		    pOld= XkbKeySymsPtr(xkb,i);
+		    for (g=XkbKeyNumGroups(xkb,i)-1;g>=0;g--) {
+			memcpy(&newSyms[nSyms+(new_num_lvls*g)],&pOld[width*g],
+							width*sizeof(KeySym));
+		    }
+		    xkb->map->key_sym_map[i].offset= nSyms;
+		    nSyms+= XkbKeyNumGroups(xkb,i)*new_num_lvls;
+		}
+		else {
+		    memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),
+					XkbKeyNumSyms(xkb,i)*sizeof(KeySym));
+		    xkb->map->key_sym_map[i].offset= nSyms;
+		    nSyms+= XkbKeyNumSyms(xkb,i);
+		}
+	    }
+	    type->num_levels= new_num_lvls;
+	    _XkbFree(xkb->map->syms);
+	    xkb->map->syms= newSyms;
+	    xkb->map->num_syms= nSyms;
+	    return Success;
+	}
+    }
+    else if (new_num_lvls<type->num_levels) {
+	int 		width,match;
+	register int	g,i;
+	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+	    width= XkbKeyGroupsWidth(xkb,i);
+	    if (width<type->num_levels)
+		continue;
+	    for (match=0,g=XkbKeyNumGroups(xkb,i)-1;(g>=0)&&(!match);g--) {
+		if (XkbKeyKeyTypeIndex(xkb,i,g)==type_ndx) {
+		    matchingKeys[nMatchingKeys++]= i;
+		    match= 1;
+		}
+	    }
+	}
+    }
+    if (nMatchingKeys>0) {
+	int 		key,firstClear;
+	register int	i,g;
+	if (new_num_lvls>type->num_levels)
+	     firstClear= type->num_levels;
+	else firstClear= new_num_lvls;
+	for (i=0;i<nMatchingKeys;i++) {
+	    KeySym *	pSyms;
+	    int		width,nClear;
+
+	    key= matchingKeys[i];
+	    width= XkbKeyGroupsWidth(xkb,key);
+	    nClear= width-firstClear;
+	    pSyms= XkbKeySymsPtr(xkb,key);
+	    for (g=XkbKeyNumGroups(xkb,key)-1;g>=0;g--) {
+		if (XkbKeyKeyTypeIndex(xkb,key,g)==type_ndx) {
+		    if (nClear>0)
+			bzero(&pSyms[g*width+firstClear],nClear*sizeof(KeySym));
+		}
+	    }
+	}
+    }
+    type->num_levels= new_num_lvls;
+    return Success;
+}
+
+KeySym *
+XkbResizeKeySyms(XkbDescPtr xkb,int key,int needed)
+{
+register int i,nSyms,nKeySyms;
+unsigned nOldSyms;
+KeySym	*newSyms;
+
+    if (needed==0) {
+	xkb->map->key_sym_map[key].offset= 0;
+	return xkb->map->syms;
+    }
+    nOldSyms= XkbKeyNumSyms(xkb,key);
+    if (nOldSyms>=(unsigned)needed) {
+	return XkbKeySymsPtr(xkb,key);
+    }
+    if (xkb->map->size_syms-xkb->map->num_syms>=(unsigned)needed) {
+	if (nOldSyms>0) {
+	    memcpy(&xkb->map->syms[xkb->map->num_syms],XkbKeySymsPtr(xkb,key),
+						nOldSyms*sizeof(KeySym));
+	}
+	if ((needed-nOldSyms)>0) {
+	    bzero(&xkb->map->syms[xkb->map->num_syms+XkbKeyNumSyms(xkb,key)],
+					(needed-nOldSyms)*sizeof(KeySym));
+	}
+	xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
+	xkb->map->num_syms+= needed;
+	return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
+    }
+    xkb->map->size_syms+= (needed>32?needed:32);
+    newSyms = _XkbTypedCalloc(xkb->map->size_syms,KeySym);
+    if (newSyms==NULL)
+	return NULL;
+    newSyms[0]= NoSymbol;
+    nSyms = 1;
+    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {
+	int nCopy;
+
+	nCopy= nKeySyms= XkbKeyNumSyms(xkb,i);
+	if ((nKeySyms==0)&&(i!=key))
+	    continue;
+	if (i==key)
+	    nKeySyms= needed;
+	if (nCopy!=0)
+	   memcpy(&newSyms[nSyms],XkbKeySymsPtr(xkb,i),nCopy*sizeof(KeySym));
+	if (nKeySyms>nCopy)
+	    bzero(&newSyms[nSyms+nCopy],(nKeySyms-nCopy)*sizeof(KeySym));
+	xkb->map->key_sym_map[i].offset = nSyms;
+	nSyms+= nKeySyms;
+    }
+    _XkbFree(xkb->map->syms);
+    xkb->map->syms = newSyms;
+    xkb->map->num_syms = nSyms;
+    return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
+}
+
+static unsigned
+_ExtendRange(	unsigned int 	old_flags,
+		unsigned int	flag,
+		KeyCode		newKC,
+		KeyCode *	old_min,
+		unsigned char *	old_num)
+{
+    if ((old_flags&flag)==0) {
+	old_flags|= flag;
+	*old_min= newKC;
+	*old_num= 1;
+    }
+    else {
+	int	last= (*old_min)+(*old_num)-1;
+	if (newKC<*old_min) {
+	    *old_min= newKC;
+	    *old_num= (last-newKC)+1;
+	}
+	else if (newKC>last) {
+	    *old_num= (newKC-(*old_min))+1;
+	}
+    }
+    return old_flags;
+}
+
+Status
+XkbChangeKeycodeRange(	XkbDescPtr	xkb,
+			int 		minKC,
+			int 		maxKC,
+			XkbChangesPtr	changes)
+{
+int	tmp;
+
+    if ((!xkb)||(minKC<XkbMinLegalKeyCode)||(maxKC>XkbMaxLegalKeyCode))
+	return BadValue;
+    if (minKC>maxKC)
+	return BadMatch;
+    if (minKC<xkb->min_key_code) {
+	if (changes)
+	    changes->map.min_key_code= minKC;
+	tmp= xkb->min_key_code-minKC;
+	if (xkb->map)  {
+	    if (xkb->map->key_sym_map) {
+		bzero((char *)&xkb->map->key_sym_map[minKC],
+					tmp*sizeof(XkbSymMapRec));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    				XkbKeySymsMask,minKC,
+	    					&changes->map.first_key_sym,
+	    					&changes->map.num_key_syms);
+		}
+	    }
+	    if (xkb->map->modmap) {
+		bzero((char *)&xkb->map->modmap[minKC],tmp);
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    				XkbModifierMapMask,minKC,
+	    					&changes->map.first_modmap_key,
+	    					&changes->map.num_modmap_keys);
+		}
+	    }
+	}
+	if (xkb->server) {
+	    if (xkb->server->behaviors) {
+		bzero((char *)&xkb->server->behaviors[minKC],
+						tmp*sizeof(XkbBehavior));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbKeyBehaviorsMask,minKC,
+    					&changes->map.first_key_behavior,
+    					&changes->map.num_key_behaviors);
+		}
+	    }
+	    if (xkb->server->key_acts) {
+		bzero((char *)&xkb->server->key_acts[minKC],
+						tmp*sizeof(unsigned short));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbKeyActionsMask,minKC,
+    					&changes->map.first_key_act,
+    					&changes->map.num_key_acts);
+		}
+	    }
+	    if (xkb->server->vmodmap) {
+		bzero((char *)&xkb->server->vmodmap[minKC],
+						tmp*sizeof(unsigned short));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbVirtualModMapMask,minKC,
+		    			&changes->map.first_modmap_key,
+    					&changes->map.num_vmodmap_keys);
+		}
+	    }
+	}
+	if ((xkb->names)&&(xkb->names->keys)) {
+	    bzero((char *)&xkb->names->keys[minKC],tmp*sizeof(XkbKeyNameRec));
+	    if (changes) {
+		changes->names.changed= _ExtendRange(changes->names.changed,
+					XkbKeyNamesMask,minKC,
+					&changes->names.first_key,
+    					&changes->names.num_keys);
+	    }
+	}
+	xkb->min_key_code= minKC;
+    }
+    if (maxKC>xkb->max_key_code) {
+	if (changes)
+	    changes->map.max_key_code= maxKC;
+	tmp= maxKC-xkb->max_key_code;
+	if (xkb->map)  {
+	    if (xkb->map->key_sym_map) {
+		XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;
+
+		xkb->map->key_sym_map= _XkbTypedRealloc(xkb->map->key_sym_map,
+						(maxKC+1),XkbSymMapRec);
+		if (!xkb->map->key_sym_map) {
+		    _XkbFree(prev_key_sym_map);
+		    return BadAlloc;
+		}
+		bzero((char *)&xkb->map->key_sym_map[xkb->max_key_code],
+					tmp*sizeof(XkbSymMapRec));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    				XkbKeySymsMask,maxKC,
+	    					&changes->map.first_key_sym,
+	    					&changes->map.num_key_syms);
+		}
+	    }
+	    if (xkb->map->modmap) {
+		unsigned char *prev_modmap = xkb->map->modmap;
+
+		xkb->map->modmap= _XkbTypedRealloc(xkb->map->modmap,
+						(maxKC+1),unsigned char);
+		if (!xkb->map->modmap) {
+		    _XkbFree(prev_modmap);
+		    return BadAlloc;
+		}
+		bzero((char *)&xkb->map->modmap[xkb->max_key_code],tmp);
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    				XkbModifierMapMask,maxKC,
+	    					&changes->map.first_modmap_key,
+	    					&changes->map.num_modmap_keys);
+		}
+	    }
+	}
+	if (xkb->server) {
+	    if (xkb->server->behaviors) {
+		XkbBehavior *prev_behaviors = xkb->server->behaviors;
+
+		xkb->server->behaviors=_XkbTypedRealloc(xkb->server->behaviors,
+						(maxKC+1),XkbBehavior);
+		if (!xkb->server->behaviors) {
+		    _XkbFree(prev_behaviors);
+		    return BadAlloc;
+		}
+		bzero((char *)&xkb->server->behaviors[xkb->max_key_code],
+						tmp*sizeof(XkbBehavior));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbKeyBehaviorsMask,maxKC,
+    					&changes->map.first_key_behavior,
+    					&changes->map.num_key_behaviors);
+		}
+	    }
+	    if (xkb->server->key_acts) {
+		unsigned short *prev_key_acts = xkb->server->key_acts;
+
+		xkb->server->key_acts= _XkbTypedRealloc(xkb->server->key_acts,
+						(maxKC+1),unsigned short);
+		if (!xkb->server->key_acts) {
+		    _XkbFree(prev_key_acts);
+		    return BadAlloc;
+		}
+		bzero((char *)&xkb->server->key_acts[xkb->max_key_code],
+						tmp*sizeof(unsigned short));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbKeyActionsMask,maxKC,
+    					&changes->map.first_key_act,
+    					&changes->map.num_key_acts);
+		}
+	    }
+	    if (xkb->server->vmodmap) {
+		unsigned short *prev_vmodmap = xkb->server->vmodmap;
+
+		xkb->server->vmodmap= _XkbTypedRealloc(xkb->server->vmodmap,
+						(maxKC+1),unsigned short);
+		if (!xkb->server->vmodmap) {
+		    _XkbFree(prev_vmodmap);
+		    return BadAlloc;
+		}
+		bzero((char *)&xkb->server->vmodmap[xkb->max_key_code],
+						tmp*sizeof(unsigned short));
+		if (changes) {
+		    changes->map.changed= _ExtendRange(changes->map.changed,
+		    			XkbVirtualModMapMask,maxKC,
+		    			&changes->map.first_modmap_key,
+    					&changes->map.num_vmodmap_keys);
+		}
+	    }
+	}
+	if ((xkb->names)&&(xkb->names->keys)) {
+	    XkbKeyNameRec *prev_keys = xkb->names->keys;
+
+	    xkb->names->keys= _XkbTypedRealloc(xkb->names->keys,
+	    					(maxKC+1),XkbKeyNameRec);
+	    if (!xkb->names->keys) {
+		_XkbFree(prev_keys);
+		return BadAlloc;
+	    }
+	    bzero((char *)&xkb->names->keys[xkb->max_key_code],
+	    					tmp*sizeof(XkbKeyNameRec));
+	    if (changes) {
+		changes->names.changed= _ExtendRange(changes->names.changed,
+					XkbKeyNamesMask,maxKC,
+					&changes->names.first_key,
+    					&changes->names.num_keys);
+	    }
+	}
+	xkb->max_key_code= maxKC;
+    }
+    return Success;
+}
+
+XkbAction *
+XkbResizeKeyActions(XkbDescPtr xkb,int key,int needed)
+{
+register int i,nActs;
+XkbAction *newActs;
+
+    if (needed==0) {
+	xkb->server->key_acts[key]= 0;
+	return NULL;
+    }
+    if (XkbKeyHasActions(xkb,key)&&(XkbKeyNumSyms(xkb,key)>=(unsigned)needed))
+	return XkbKeyActionsPtr(xkb,key);
+    if (xkb->server->size_acts-xkb->server->num_acts>=(unsigned)needed) {
+	xkb->server->key_acts[key]= xkb->server->num_acts;
+	xkb->server->num_acts+= needed;
+	return &xkb->server->acts[xkb->server->key_acts[key]];
+    }
+    xkb->server->size_acts= xkb->server->num_acts+needed+8;
+    newActs = _XkbTypedCalloc(xkb->server->size_acts,XkbAction);
+    if (newActs==NULL)
+	return NULL;
+    newActs[0].type = XkbSA_NoAction;
+    nActs = 1;
+    for (i=xkb->min_key_code;i<=(int)xkb->max_key_code;i++) {
+	int nKeyActs,nCopy;
+
+	if ((xkb->server->key_acts[i]==0)&&(i!=key))
+	    continue;
+
+	nCopy= nKeyActs= XkbKeyNumActions(xkb,i);
+	if (i==key) {
+	    nKeyActs= needed;
+	    if (needed<nCopy)
+		nCopy= needed;
+	}
+
+	if (nCopy>0)
+	    memcpy(&newActs[nActs],XkbKeyActionsPtr(xkb,i),
+						nCopy*sizeof(XkbAction));
+	if (nCopy<nKeyActs)
+	    bzero(&newActs[nActs+nCopy],(nKeyActs-nCopy)*sizeof(XkbAction));
+	xkb->server->key_acts[i]= nActs;
+	nActs+= nKeyActs;
+    }
+    _XkbFree(xkb->server->acts);
+    xkb->server->acts = newActs;
+    xkb->server->num_acts= nActs;
+    return &xkb->server->acts[xkb->server->key_acts[key]];
+}
+
+void
+XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+{
+XkbClientMapPtr	map;
+
+    if ((xkb==NULL)||(xkb->map==NULL))
+	return;
+    if (freeMap)
+	what= XkbAllClientInfoMask;
+    map= xkb->map;
+    if (what&XkbKeyTypesMask) {
+	if (map->types!=NULL) {
+	    if (map->num_types>0) {
+		register int 	i;
+		XkbKeyTypePtr	type;
+		for (i=0,type=map->types;i<map->num_types;i++,type++) {
+		    if (type->map!=NULL) {
+			_XkbFree(type->map);
+			type->map= NULL;
+		    }
+		    if (type->preserve!=NULL) {
+			_XkbFree(type->preserve);
+			type->preserve= NULL;
+		    }
+		    type->map_count= 0;
+		    if (type->level_names!=NULL) {
+			_XkbFree(type->level_names);
+			type->level_names= NULL;
+		    }
+		}
+	    }
+	    _XkbFree(map->types);
+	    map->num_types= map->size_types= 0;
+	    map->types= NULL;
+	}
+    }
+    if (what&XkbKeySymsMask) {
+	if (map->key_sym_map!=NULL) {
+	    _XkbFree(map->key_sym_map);
+	    map->key_sym_map= NULL;
+	}
+	if (map->syms!=NULL) {
+	    _XkbFree(map->syms);
+	    map->size_syms= map->num_syms= 0;
+	    map->syms= NULL;
+	}
+    }
+    if ((what&XkbModifierMapMask)&&(map->modmap!=NULL)) {
+	_XkbFree(map->modmap);
+	map->modmap= NULL;
+    }
+    if (freeMap) {
+	_XkbFree(xkb->map);
+	xkb->map= NULL;
+    }
+    return;
+}
+
+void
+XkbFreeServerMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
+{
+XkbServerMapPtr	map;
+
+    if ((xkb==NULL)||(xkb->server==NULL))
+	return;
+    if (freeMap)
+	what= XkbAllServerInfoMask;
+    map= xkb->server;
+    if ((what&XkbExplicitComponentsMask)&&(map->explicit!=NULL)) {
+	_XkbFree(map->explicit);
+	map->explicit= NULL;
+    }
+    if (what&XkbKeyActionsMask) {
+	if (map->key_acts!=NULL) {
+	    _XkbFree(map->key_acts);
+	    map->key_acts= NULL;
+	}
+	if (map->acts!=NULL) {
+	    _XkbFree(map->acts);
+	    map->num_acts= map->size_acts= 0;
+	    map->acts= NULL;
+	}
+    }
+    if ((what&XkbKeyBehaviorsMask)&&(map->behaviors!=NULL)) {
+	_XkbFree(map->behaviors);
+	map->behaviors= NULL;
+    }
+    if ((what&XkbVirtualModMapMask)&&(map->vmodmap!=NULL)) {
+	_XkbFree(map->vmodmap);
+	map->vmodmap= NULL;
+    }
+
+    if (freeMap) {
+	_XkbFree(xkb->server);
+	xkb->server= NULL;
+    }
+    return;
+}
diff --git a/libX11/src/xkb/XKBNames.c b/libX11/src/xkb/XKBNames.c
index 3cc1f60ed..cf2382cca 100644
--- a/libX11/src/xkb/XKBNames.c
+++ b/libX11/src/xkb/XKBNames.c
@@ -1,887 +1,887 @@
-/************************************************************

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

-

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

-

-#define NEED_MAP_READERS

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-

-static Status

-_XkbReadAtoms(	XkbReadBufferPtr	buf,

-		Atom *			atoms,

-		int			maxAtoms,

-		CARD32		 	present)

-{

-register int i,bit;

-

-    for (i=0,bit=1;(i<maxAtoms)&&(present);i++,bit<<=1) {

-	if (present&bit) {

-	    if (!_XkbReadBufferCopy32(buf,(long *)&atoms[i],1))

-		return BadLength;

-	    present&= ~bit;

-	}

-    }

-    return Success;

-}

-

-Status

-_XkbReadGetNamesReply(	Display *		dpy,

-			xkbGetNamesReply *	rep,

-			XkbDescPtr 		xkb,

-			int *			nread_rtrn)

-{

-    int				 i,len;

-    XkbReadBufferRec		 buf;

-    register XkbNamesPtr	 names;

-

-    if ( xkb->device_spec == XkbUseCoreKbd )

-	xkb->device_spec = rep->deviceID;

-

-    if ((xkb->names==NULL)&&

-	(XkbAllocNames(xkb,rep->which,

-				rep->nRadioGroups,rep->nKeyAliases)!=Success)) {

-	return BadAlloc;

-    }

-    names= xkb->names;

-    if (rep->length==0)

-	return Success;

-

-    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))

-	return BadAlloc;

-    if (nread_rtrn)

-	*nread_rtrn= (int)rep->length*4;

-

-    if ((rep->which&XkbKeycodesNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->keycodes,1)))

-	    goto BAILOUT;

-    if ((rep->which&XkbGeometryNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->geometry,1)))

-	    goto BAILOUT;

-    if ((rep->which&XkbSymbolsNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->symbols,1)))

-	    goto BAILOUT;

-    if ((rep->which&XkbPhysSymbolsNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->phys_symbols,1)))

-	    goto BAILOUT;

-    if ((rep->which&XkbTypesNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->types,1)))

-	    goto BAILOUT;

-    if ((rep->which&XkbCompatNameMask)&&

-	(!_XkbReadBufferCopy32(&buf,(long *)&names->compat,1)))

-	    goto BAILOUT;

-

-    if ( rep->which & XkbKeyTypeNamesMask ) {

-	XkbClientMapPtr	map= xkb->map;

-	XkbKeyTypePtr	type;

-

-	len= rep->nTypes*4;

-	if (map!=NULL) {

-	    type= map->types;

-	    for (i=0;(i<map->num_types)&&(i<rep->nTypes);i++,type++) {

-		if (!_XkbReadBufferCopy32(&buf,(long *)&type->name,1))

-		    goto BAILOUT;

-		len-= 4;

-	    }

-	}

-	if ((len>0)&&(!_XkbSkipReadBufferData(&buf,len)))

-	    goto BAILOUT;

-    }

-    if ( rep->which&XkbKTLevelNamesMask ) {

-	CARD8 *nLevels;

-	XkbClientMapPtr	map= xkb->map;

-	XkbKeyTypePtr	type;

-

-	nLevels=(CARD8*)_XkbGetReadBufferPtr(&buf,XkbPaddedSize(rep->nTypes));

-	if (nLevels==NULL)

-	    goto BAILOUT;

-	if (map!=NULL) {

-	    type= map->types;

-	    for (i=0;i<(int)rep->nTypes;i++,type++) {

-		if (i>=map->num_types) {

-		    if (!_XkbSkipReadBufferData(&buf,nLevels[i]*4))

-			goto BAILOUT;

-		    continue;

-		}

-		if ((nLevels[i]>0)&&(nLevels[i]!=type->num_levels)) {

-		    goto BAILOUT;

-		}

-		if (type->level_names!=NULL)

-		    Xfree(type->level_names);

-		if (nLevels[i]==0) {

-		    type->level_names= NULL;

-		    continue;

-		}

-		type->level_names= _XkbTypedCalloc(nLevels[i],Atom);

-		if (type->level_names!=NULL) {

-		    if (!_XkbReadBufferCopy32(&buf,(long *)type->level_names,

-								nLevels[i]))

-			goto BAILOUT;

-		}

-		else {

-		    _XkbSkipReadBufferData(&buf,nLevels[i]*4);

-		}

-	    }

-	}

-	else {

-	    for (i=0;i<(int)rep->nTypes;i++) {

-		_XkbSkipReadBufferData(&buf,nLevels[i]*4);

-	    }

-	}

-    }

-    if (rep->which & XkbIndicatorNamesMask) {

-	if (_XkbReadAtoms(&buf,names->indicators,XkbNumIndicators,

-						rep->indicators)!=Success)

-	    goto BAILOUT;

-    }

-    if ( rep->which&XkbVirtualModNamesMask ) {

-	if (_XkbReadAtoms(&buf,names->vmods,XkbNumVirtualMods,

-					(CARD32)rep->virtualMods)!=Success)

-	    goto BAILOUT;

-    }

-    if ( rep->which&XkbGroupNamesMask ) {

-	if (_XkbReadAtoms(&buf,names->groups,XkbNumKbdGroups,

-					(CARD32)rep->groupNames)!=Success)

-	    goto BAILOUT;

-    }

-    if ( rep->which&XkbKeyNamesMask ) {

-	if (names->keys==NULL) {

-	    int nKeys;

-	    if (xkb->max_key_code==0) {

-		xkb->min_key_code= rep->minKeyCode;

-		xkb->max_key_code= rep->maxKeyCode;

-	    }

-	    nKeys= xkb->max_key_code+1;

-	    names->keys= _XkbTypedCalloc(nKeys,XkbKeyNameRec);

-	}

-	if (names->keys!=NULL) {

-	    if (!_XkbCopyFromReadBuffer(&buf,

-					(char *)&names->keys[rep->firstKey],

-					rep->nKeys*XkbKeyNameLength))

-		goto BAILOUT;

-	}

-	else _XkbSkipReadBufferData(&buf,rep->nKeys*XkbKeyNameLength);

-    }

-    if ( rep->which&XkbKeyAliasesMask && (rep->nKeyAliases>0) ) {

-	if (XkbAllocNames(xkb,XkbKeyAliasesMask,0,rep->nKeyAliases)!=Success)

-	    goto BAILOUT;

-	if (!_XkbCopyFromReadBuffer(&buf,(char *)names->key_aliases,

-				rep->nKeyAliases*XkbKeyNameLength*2))

-	    goto BAILOUT;

-    }

-    if ( rep->which&XkbRGNamesMask ) {

-	if (rep->nRadioGroups>0) {

-	    Atom *rgNames;

-

-	    if (names->radio_groups==NULL)

-		names->radio_groups = _XkbTypedCalloc(rep->nRadioGroups,Atom);

-	    else if (names->num_rg<rep->nRadioGroups) {

-		names->radio_groups = _XkbTypedRealloc(names->radio_groups,

-							rep->nRadioGroups,

-							Atom);

-	    }

-	    rgNames= names->radio_groups;

-	    if (!rgNames) {

-		goto BAILOUT;

-	    }

-	    if (!_XkbReadBufferCopy32(&buf,(long *)rgNames,rep->nRadioGroups))

-		goto BAILOUT;

-	    names->num_rg= rep->nRadioGroups;

-	}

-	else if (names->num_rg>0) {

-	    names->num_rg= 0;

-	    Xfree(names->radio_groups);

-	}

-    }

-    len= _XkbFreeReadBuffer(&buf);

-    if (len!=0) 	return BadLength;

-    else		return Success;

-BAILOUT:

-    _XkbFreeReadBuffer(&buf);

-    return BadLength;

-}

-

-Status

-XkbGetNames(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-    register xkbGetNamesReq *req;

-    xkbGetNamesReply	     rep;

-    Status		     status;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    if (!xkb->names) {

-	xkb->names = _XkbTypedCalloc(1,XkbNamesRec);

-	if (!xkb->names) {

-	    UnlockDisplay(dpy);

-	    SyncHandle();

-	    return BadAlloc;

-	}

-    }

-    GetReq(kbGetNames, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetNames;

-    req->deviceSpec = xkb->device_spec;

-    req->which = which;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadImplementation;

-    }

-

-    status = _XkbReadGetNamesReply(dpy,&rep,xkb,NULL);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

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

-

-static int

-_XkbCountBits(int nBitsMax,unsigned long mask)

-{

-register unsigned long y, nBits;

-

-    y = (mask >> 1) &033333333333;

-    y = mask - y - ((y >>1) & 033333333333);

-    nBits = ((unsigned int) (((y + (y >> 3)) & 030707070707) % 077));

-

-    /* nBitsMax really means max+1 */

-    return (nBits < nBitsMax) ? nBits : (nBitsMax - 1);

-}

-

-static CARD32

-_XkbCountAtoms(Atom *atoms,int maxAtoms,int *count)

-{

-register unsigned int i,bit,nAtoms;

-register CARD32 atomsPresent;

-

-    for (i=nAtoms=atomsPresent=0,bit=1;i<maxAtoms;i++,bit<<=1) {

-        if (atoms[i]!=None) {

-            atomsPresent|= bit;

-            nAtoms++;

-        }

-    }

-    if (count)

-        *count= nAtoms;

-    return atomsPresent;

-}

-

-static void

-_XkbCopyAtoms(Display *dpy,Atom *atoms,CARD32 mask,int maxAtoms)

-{

-register unsigned int i,bit;

-

-    for (i=0,bit=1;i<maxAtoms;i++,bit<<=1) {

-        if (mask&bit)

-	    Data32(dpy,&atoms[i],4);

-    }

-    return;

-}

-

-Bool

-XkbSetNames(	Display *	dpy,

-		unsigned int 	which,

-		unsigned int 	firstType,

-		unsigned int 	nTypes,

-		XkbDescPtr 	xkb)

-{

-    register xkbSetNamesReq *req;

-    int  nLvlNames = 0;

-    XkbInfoPtr xkbi;

-    XkbNamesPtr names;

-    unsigned firstLvlType,nLvlTypes;

-    int	nVMods,nLEDs,nRG,nKA,nGroups;

-    int nKeys=0,firstKey=0,nAtoms;

-    CARD32 leds,vmods,groups;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!xkb)||(!xkb->names))

-	return False;

-    firstLvlType= firstType;

-    nLvlTypes= nTypes;

-    if (nTypes<1)

-	which&= ~(XkbKTLevelNamesMask|XkbKeyTypeNamesMask);

-    else if (firstType<=XkbLastRequiredType) {

-	int	adjust;

-	adjust= XkbLastRequiredType-firstType+1;

-	firstType+= adjust;

-	nTypes-= adjust;

-	if (nTypes<1)

-	    which&= ~XkbKeyTypeNamesMask;

-    }

-    names= xkb->names;

-    if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) {

-	register int	i;

-	XkbKeyTypePtr	type;

-	if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)||

-				(firstType+nTypes>xkb->map->num_types)||

-				(firstLvlType+nLvlTypes>xkb->map->num_types))

-	    return False;

-	if (which&XkbKTLevelNamesMask) {

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

-	    for (i=nLvlNames=0;i<nLvlTypes;i++,type++) {

-		if (type->level_names!=NULL)

-		    nLvlNames+= type->num_levels;

-	    }

-	}

-    }

-

-    nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetNames, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetNames;

-    req->deviceSpec = xkb->device_spec;

-    req->firstType = firstType;

-    req->nTypes = nTypes;

-    req->firstKey = xkb->min_key_code;

-    req->nKeys = xkb->max_key_code-xkb->min_key_code+1;

-

-    if (which&XkbKeycodesNameMask)

-	nAtoms++;

-    if (which&XkbGeometryNameMask)

-	nAtoms++;

-    if (which&XkbSymbolsNameMask)

-	nAtoms++;

-    if (which&XkbPhysSymbolsNameMask)

-	nAtoms++;

-    if (which&XkbTypesNameMask)

-	nAtoms++;

-    if (which&XkbCompatNameMask)

-	nAtoms++;

-    if (which&XkbKeyTypeNamesMask)

-	nAtoms+= nTypes;

-    if (which&XkbKTLevelNamesMask) {

-	req->firstKTLevel= firstLvlType;

-	req->nKTLevels= nLvlTypes;

-	req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */

-	nAtoms+= nLvlNames;

-    }

-    else req->firstKTLevel= req->nKTLevels= 0;

-

-    if (which&XkbIndicatorNamesMask) {

-	req->indicators= leds=

-		_XkbCountAtoms(names->indicators,XkbNumIndicators,&nLEDs);

-	if (nLEDs>0)

-	     nAtoms+= nLEDs;

-	else which&= ~XkbIndicatorNamesMask;

-    }

-    else req->indicators= leds= 0;

-

-    if (which&XkbVirtualModNamesMask) {

-	vmods= req->virtualMods= (CARD16)

-		_XkbCountAtoms(names->vmods,XkbNumVirtualMods,&nVMods);

-	if (nVMods>0)

-	     nAtoms+= nVMods;

-	else which&= ~XkbVirtualModNamesMask;

-    }

-    else vmods= req->virtualMods= 0;

-

-    if (which&XkbGroupNamesMask) {

-	groups= req->groupNames= (CARD8)

-		_XkbCountAtoms(names->groups,XkbNumKbdGroups,&nGroups);

-	if (nGroups>0)

-	     nAtoms+= nGroups;

-	else which&= ~XkbGroupNamesMask;

-    }

-    else groups= req->groupNames= 0;

-

-    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {

-	firstKey= req->firstKey;

-	nKeys= req->nKeys;

-	nAtoms+= nKeys;	/* technically not atoms, but 4 bytes wide */

-    }

-    else which&= ~XkbKeyNamesMask;

-

-    if (which&XkbKeyAliasesMask) {

-	nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0);

-	if (nKA>0) {

-	    req->nKeyAliases= nKA;

-	    nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */

-	}

-	else {

-	    which&= ~XkbKeyAliasesMask;

-	    req->nKeyAliases = 0;

-	}

-    }

-    else req->nKeyAliases= 0;

-

-    if (which&XkbRGNamesMask) {

-	nRG= names->num_rg;

-	if (nRG>0)

-	     nAtoms+= nRG;

-	else which&= ~XkbRGNamesMask;

-    }

-

-    req->which= which;

-    req->nRadioGroups= nRG;

-    req->length+= (nAtoms*4)/4;

-

-    if (which&XkbKeycodesNameMask)

-	Data32(dpy,(long *)&names->keycodes,4);

-    if (which&XkbGeometryNameMask)

-	Data32(dpy,(long *)&names->geometry,4);

-    if (which&XkbSymbolsNameMask)

-	Data32(dpy,(long *)&names->symbols,4);

-    if (which&XkbPhysSymbolsNameMask)

-	Data32(dpy,(long *)&names->phys_symbols,4);

-    if (which&XkbTypesNameMask)

-	Data32(dpy,(long *)&names->types,4);

-    if (which&XkbCompatNameMask)

-	Data32(dpy,(long *)&names->compat,4);

-    if (which&XkbKeyTypeNamesMask) {

-	register int 		i;

-	register XkbKeyTypePtr	type;

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

-	for (i=0;i<nTypes;i++,type++) {

-	    Data32(dpy,(long *)&type->name,4);

-	}

-    }

-    if (which&XkbKTLevelNamesMask) {

-	XkbKeyTypePtr type;

-	int i;

-	char *tmp;

-

-	BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes));

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

-	for (i=0;i<nLvlTypes;i++,type++) {

-	    *tmp++ = type->num_levels;

-	}

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

-	for (i=0;i<nLvlTypes;i++,type++) {

-	    if (type->level_names!=NULL)

-		Data32(dpy,(long *)type->level_names,type->num_levels*4);

-	}

-    }

-    if (which&XkbIndicatorNamesMask)

-	_XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators);

-    if (which&XkbVirtualModNamesMask)

-	_XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods);

-    if (which&XkbGroupNamesMask)

-	_XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups);

-    if (which&XkbKeyNamesMask) {

-#ifdef WORD64

-	char *tmp;

-	register int i;

-	BufAlloc(char *,tmp,nKeys*XkbKeyNameLength);

-	for (i=0;i<nKeys;i++,tmp+= XkbKeyNameLength) {

-	    tmp[0]= names->keys[firstKey+i].name[0];

-	    tmp[1]= names->keys[firstKey+i].name[1];

-	    tmp[2]= names->keys[firstKey+i].name[2];

-	    tmp[3]= names->keys[firstKey+i].name[3];

-	}

-#else

-	Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength);

-#endif

-    }

-    if (which&XkbKeyAliasesMask) {

-#ifdef WORD64

-	char *tmp;

-	register int i;

-	BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2);

-	for (i=0;i<nKeys;i++,tmp+= 2*XkbKeyNameLength) {

-	    tmp[0]= names->key_aliases[i].real[0];

-	    tmp[1]= names->key_aliases[i].real[1];

-	    tmp[2]= names->key_aliases[i].real[2];

-	    tmp[3]= names->key_aliases[i].real[3];

-	    tmp[4]= names->key_aliases[i].alias[0];

-	    tmp[5]= names->key_aliases[i].alias[1];

-	    tmp[6]= names->key_aliases[i].alias[2];

-	    tmp[7]= names->key_aliases[i].alias[3];

-	}

-#else

-	Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2);

-#endif

-    }

-    if (which&XkbRGNamesMask) {

-	Data32(dpy,(long *)names->radio_groups,nRG*4);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbChangeNames(Display *dpy,XkbDescPtr xkb,XkbNameChangesPtr changes)

-{

-    register xkbSetNamesReq *req;

-    int  nLvlNames = 0;

-    XkbInfoPtr xkbi;

-    XkbNamesPtr names;

-    unsigned which,firstType,nTypes;

-    unsigned firstLvlType,nLvlTypes;

-    int	nVMods,nLEDs,nRG,nKA,nGroups;

-    int nKeys=0,firstKey=0,nAtoms;

-    CARD32 leds=0,vmods=0,groups=0;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!xkb)||(!xkb->names)||(!changes))

-	return False;

-    which= changes->changed;

-    firstType= changes->first_type;

-    nTypes= changes->num_types;

-    firstLvlType= changes->first_lvl;;

-    nLvlTypes= changes->num_lvls;

-    if (which&XkbKeyTypeNamesMask) {

-	if (nTypes<1)

-	    which&= ~XkbKeyTypeNamesMask;

-	else if (firstType<=XkbLastRequiredType) {

-	    int	adjust;

-	    adjust= XkbLastRequiredType-firstType+1;

-	    firstType+= adjust;

-	    nTypes-= adjust;

-	    if (nTypes<1)

-		which&= ~XkbKeyTypeNamesMask;

-	}

-    }

-    else firstType= nTypes= 0;

-

-    if (which&XkbKTLevelNamesMask) {

-	if (nLvlTypes<1)

-	    which&= ~XkbKTLevelNamesMask;

-    }

-    else firstLvlType= nLvlTypes= 0;

-

-    names= xkb->names;

-    if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) {

-	register int	i;

-	XkbKeyTypePtr	type;

-	if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)||

-				(firstType+nTypes>xkb->map->num_types)||

-				(firstLvlType+nLvlTypes>xkb->map->num_types))

-	    return False;

-	if (which&XkbKTLevelNamesMask) {

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

-	    for (i=nLvlNames=0;i<nLvlTypes;i++,type++) {

-		if (type->level_names!=NULL)

-		    nLvlNames+= type->num_levels;

-	    }

-	}

-    }

-

-    if (changes->num_keys<1)

-	which&= ~XkbKeyNamesMask;

-    if ((which&XkbKeyNamesMask)==0)

-	changes->first_key= changes->num_keys= 0;

-    else if ((changes->first_key<xkb->min_key_code)||

-	     (changes->first_key+changes->num_keys>xkb->max_key_code)) {

-	return False;

-    }

-

-    if ((which&XkbVirtualModNamesMask)==0)

-	changes->changed_vmods= 0;

-    else if (changes->changed_vmods==0)

-	which&= ~XkbVirtualModNamesMask;

-

-    if ((which&XkbIndicatorNamesMask)==0)

-	changes->changed_indicators= 0;

-    else if (changes->changed_indicators==0)

-	which&= ~XkbIndicatorNamesMask;

-

-    if ((which&XkbGroupNamesMask)==0)

-	changes->changed_groups= 0;

-    else if (changes->changed_groups==0)

-	which&= ~XkbGroupNamesMask;

-

-    nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetNames, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetNames;

-    req->deviceSpec = xkb->device_spec;

-    req->firstType = firstType;

-    req->nTypes = nTypes;

-    req->firstKey = changes->first_key;

-    req->nKeys = changes->num_keys;

-

-    if (which&XkbKeycodesNameMask)

-	nAtoms++;

-    if (which&XkbGeometryNameMask)

-	nAtoms++;

-    if (which&XkbSymbolsNameMask)

-	nAtoms++;

-    if (which&XkbPhysSymbolsNameMask)

-	nAtoms++;

-    if (which&XkbTypesNameMask)

-	nAtoms++;

-    if (which&XkbCompatNameMask)

-	nAtoms++;

-    if (which&XkbKeyTypeNamesMask)

-	nAtoms+= nTypes;

-    if (which&XkbKTLevelNamesMask) {

-	req->firstKTLevel= firstLvlType;

-	req->nKTLevels= nLvlTypes;

-	req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */

-	nAtoms+= nLvlNames;

-    }

-    else req->firstKTLevel= req->nKTLevels= 0;

-

-    if (which&XkbIndicatorNamesMask) {

-	leds= req->indicators= (CARD32)changes->changed_indicators;

-	nLEDs= _XkbCountBits(XkbNumIndicators,changes->changed_indicators);

-	if (nLEDs>0)

-	     nAtoms+= nLEDs;

-	else which&= ~XkbIndicatorNamesMask;

-    }

-    else req->indicators= 0;

-

-    if (which&XkbVirtualModNamesMask) {

-	vmods= req->virtualMods= changes->changed_vmods;

-	nVMods= _XkbCountBits(XkbNumVirtualMods,

-					(unsigned long)changes->changed_vmods);

-	if (nVMods>0)

-	     nAtoms+= nVMods;

-	else which&= ~XkbVirtualModNamesMask;

-    }

-    else req->virtualMods= 0;

-

-    if (which&XkbGroupNamesMask) {

-	groups= req->groupNames= changes->changed_groups;

-	nGroups= _XkbCountBits(XkbNumKbdGroups,

-					(unsigned long)changes->changed_groups);

-	if (nGroups>0)

-	     nAtoms+= nGroups;

-	else which&= ~XkbGroupNamesMask;

-    }

-    else req->groupNames= 0;

-

-    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {

-	firstKey= req->firstKey;

-	nKeys= req->nKeys;

-	nAtoms+= nKeys;	/* technically not atoms, but 4 bytes wide */

-    }

-    else which&= ~XkbKeyNamesMask;

-

-    if (which&XkbKeyAliasesMask) {

-	nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0);

-	if (nKA>0)

-	    nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */

-	else which&= ~XkbKeyAliasesMask;

-    }

-

-    if (which&XkbRGNamesMask) {

-	nRG= names->num_rg;

-	if (nRG>0)

-	     nAtoms+= nRG;

-	else which&= ~XkbRGNamesMask;

-    }

-

-    req->which= which;

-    req->nRadioGroups= nRG;

-    req->length+= (nAtoms*4)/4;

-

-    if (which&XkbKeycodesNameMask)

-	Data32(dpy,(long *)&names->keycodes,4);

-    if (which&XkbGeometryNameMask)

-	Data32(dpy,(long *)&names->geometry,4);

-    if (which&XkbSymbolsNameMask)

-	Data32(dpy,(long *)&names->symbols,4);

-    if (which&XkbPhysSymbolsNameMask)

-	Data32(dpy,(long *)&names->phys_symbols,4);

-    if (which&XkbTypesNameMask)

-	Data32(dpy,(long *)&names->types,4);

-    if (which&XkbCompatNameMask)

-	Data32(dpy,(long *)&names->compat,4);

-    if (which&XkbKeyTypeNamesMask) {

-	register int 		i;

-	register XkbKeyTypePtr	type;

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

-	for (i=0;i<nTypes;i++,type++) {

-	    Data32(dpy,(long *)&type->name,4);

-	}

-    }

-    if (which&XkbKTLevelNamesMask) {

-	XkbKeyTypePtr type;

-	int i;

-	char *tmp;

-

-	BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes));

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

-	for (i=0;i<nLvlTypes;i++,type++) {

-	    *tmp++ = type->num_levels;

-	}

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

-	for (i=0;i<nLvlTypes;i++,type++) {

-	    if (type->level_names!=NULL)

-		Data32(dpy,(long *)type->level_names,type->num_levels*4);

-	}

-    }

-    if (which&XkbIndicatorNamesMask)

-	_XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators);

-    if (which&XkbVirtualModNamesMask)

-	_XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods);

-    if (which&XkbGroupNamesMask)

-	_XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups);

-    if (which&XkbKeyNamesMask) {

-#ifdef WORD64

-	char *tmp;

-	register int i;

-	BufAlloc(char *,tmp,nKeys*4);

-	for (i=0;i<nKeys;i++,tmp+= 4) {

-	    tmp[0]= names->keys[firstKey+i].name[0];

-	    tmp[1]= names->keys[firstKey+i].name[1];

-	    tmp[2]= names->keys[firstKey+i].name[2];

-	    tmp[3]= names->keys[firstKey+i].name[3];

-	}

-#else

-	Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength);

-#endif

-    }

-    if (which&XkbKeyAliasesMask) {

-#ifdef WORD64

-	char *tmp;

-	register int i;

-	BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2);

-	for (i=0;i<nKeys;i++,tmp+= 2*XkbKeyNameLength) {

-	    tmp[0]= names->key_aliases[i].real[0];

-	    tmp[1]= names->key_aliases[i].real[1];

-	    tmp[2]= names->key_aliases[i].real[2];

-	    tmp[3]= names->key_aliases[i].real[3];

-	    tmp[4]= names->key_aliases[i].alias[0];

-	    tmp[5]= names->key_aliases[i].alias[1];

-	    tmp[6]= names->key_aliases[i].alias[2];

-	    tmp[7]= names->key_aliases[i].alias[3];

-	}

-#else

-	Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2);

-#endif

-    }

-    if (which&XkbRGNamesMask) {

-	Data32(dpy,(long *)names->radio_groups,nRG*4);

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-void

-XkbNoteNameChanges(	XkbNameChangesPtr	old,

-			XkbNamesNotifyEvent *	new,

-			unsigned int	 	wanted)

-{

-int	first,last,old_last,new_last;

-

-    wanted&= new->changed;

-    if ((old==NULL)||(new==NULL)||(wanted==0))

-	return;

-    if (wanted&XkbKeyTypeNamesMask) {

-	if (old->changed&XkbKeyTypeNamesMask) {

-	    new_last= (new->first_type+new->num_types-1);

-	    old_last= (old->first_type+old->num_types-1);

-

-	    if (new->first_type<old->first_type)

-		 first= new->first_type;

-	    else first= old->first_type;

-

-	    if (old_last>new_last)

-		 last= old_last;

-	    else last= new_last;

-

-	    old->first_type= first;

-	    old->num_types= (last-first)+1;

-	}

-	else {

-	    old->first_type= new->first_type;

-	    old->num_types= new->num_types;

-	}

-    }

-    if (wanted&XkbKTLevelNamesMask) {

-	if (old->changed&XkbKTLevelNamesMask) {

-	    new_last= (new->first_lvl+new->num_lvls-1);

-	    old_last= (old->first_lvl+old->num_lvls-1);

-

-	    if (new->first_lvl<old->first_lvl)

-		 first= new->first_lvl;

-	    else first= old->first_lvl;

-

-	    if (old_last>new_last)

-		 last= old_last;

-	    else last= new_last;

-

-	    old->first_lvl= first;

-	    old->num_lvls= (last-first)+1;

-	}

-	else {

-	    old->first_lvl= new->first_lvl;

-	    old->num_lvls= new->num_lvls;

-	}

-    }

-    if (wanted&XkbIndicatorNamesMask) {

-	if (old->changed&XkbIndicatorNamesMask)

-	     old->changed_indicators|= new->changed_indicators;

-	else old->changed_indicators=  new->changed_indicators;

-    }

-    if (wanted&XkbKeyNamesMask) {

-	if (old->changed&XkbKeyNamesMask) {

-	    new_last= (new->first_key+new->num_keys-1);

-	    old_last= (old->first_key+old->num_keys-1);

-

-	    first= old->first_key;

-

-	    if (new->first_key<old->first_key)

-		first= new->first_key;

-	    if (old_last>new_last)

-		new_last= old_last;

-

-	    old->first_key= first;

-	    old->num_keys= (new_last-first)+1;

-	}

-	else {

-	    old->first_key= new->first_key;

-	    old->num_keys= new->num_keys;

-	}

-    }

-    if (wanted&XkbVirtualModNamesMask) {

-	if (old->changed&XkbVirtualModNamesMask)

-	     old->changed_vmods|= new->changed_vmods;

-	else old->changed_vmods=  new->changed_vmods;

-    }

-    if (wanted&XkbGroupNamesMask) {

-	if (old->changed&XkbGroupNamesMask)

-	     old->changed_groups|= new->changed_groups;

-	else old->changed_groups=  new->changed_groups;

-    }

-    if (wanted&XkbRGNamesMask)

-	old->num_rg= new->num_radio_groups;

-    if (wanted&XkbKeyAliasesMask)

-	old->num_aliases= new->num_aliases;

-    old->changed|= wanted;

-    return;

-}

+/************************************************************
+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.
+
+********************************************************/
+
+#define NEED_MAP_READERS
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+
+static Status
+_XkbReadAtoms(	XkbReadBufferPtr	buf,
+		Atom *			atoms,
+		int			maxAtoms,
+		CARD32		 	present)
+{
+register int i,bit;
+
+    for (i=0,bit=1;(i<maxAtoms)&&(present);i++,bit<<=1) {
+	if (present&bit) {
+	    if (!_XkbReadBufferCopy32(buf,(long *)&atoms[i],1))
+		return BadLength;
+	    present&= ~bit;
+	}
+    }
+    return Success;
+}
+
+Status
+_XkbReadGetNamesReply(	Display *		dpy,
+			xkbGetNamesReply *	rep,
+			XkbDescPtr 		xkb,
+			int *			nread_rtrn)
+{
+    int				 i,len;
+    XkbReadBufferRec		 buf;
+    register XkbNamesPtr	 names;
+
+    if ( xkb->device_spec == XkbUseCoreKbd )
+	xkb->device_spec = rep->deviceID;
+
+    if ((xkb->names==NULL)&&
+	(XkbAllocNames(xkb,rep->which,
+				rep->nRadioGroups,rep->nKeyAliases)!=Success)) {
+	return BadAlloc;
+    }
+    names= xkb->names;
+    if (rep->length==0)
+	return Success;
+
+    if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))
+	return BadAlloc;
+    if (nread_rtrn)
+	*nread_rtrn= (int)rep->length*4;
+
+    if ((rep->which&XkbKeycodesNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->keycodes,1)))
+	    goto BAILOUT;
+    if ((rep->which&XkbGeometryNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->geometry,1)))
+	    goto BAILOUT;
+    if ((rep->which&XkbSymbolsNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->symbols,1)))
+	    goto BAILOUT;
+    if ((rep->which&XkbPhysSymbolsNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->phys_symbols,1)))
+	    goto BAILOUT;
+    if ((rep->which&XkbTypesNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->types,1)))
+	    goto BAILOUT;
+    if ((rep->which&XkbCompatNameMask)&&
+	(!_XkbReadBufferCopy32(&buf,(long *)&names->compat,1)))
+	    goto BAILOUT;
+
+    if ( rep->which & XkbKeyTypeNamesMask ) {
+	XkbClientMapPtr	map= xkb->map;
+	XkbKeyTypePtr	type;
+
+	len= rep->nTypes*4;
+	if (map!=NULL) {
+	    type= map->types;
+	    for (i=0;(i<map->num_types)&&(i<rep->nTypes);i++,type++) {
+		if (!_XkbReadBufferCopy32(&buf,(long *)&type->name,1))
+		    goto BAILOUT;
+		len-= 4;
+	    }
+	}
+	if ((len>0)&&(!_XkbSkipReadBufferData(&buf,len)))
+	    goto BAILOUT;
+    }
+    if ( rep->which&XkbKTLevelNamesMask ) {
+	CARD8 *nLevels;
+	XkbClientMapPtr	map= xkb->map;
+	XkbKeyTypePtr	type;
+
+	nLevels=(CARD8*)_XkbGetReadBufferPtr(&buf,XkbPaddedSize(rep->nTypes));
+	if (nLevels==NULL)
+	    goto BAILOUT;
+	if (map!=NULL) {
+	    type= map->types;
+	    for (i=0;i<(int)rep->nTypes;i++,type++) {
+		if (i>=map->num_types) {
+		    if (!_XkbSkipReadBufferData(&buf,nLevels[i]*4))
+			goto BAILOUT;
+		    continue;
+		}
+		if ((nLevels[i]>0)&&(nLevels[i]!=type->num_levels)) {
+		    goto BAILOUT;
+		}
+		if (type->level_names!=NULL)
+		    Xfree(type->level_names);
+		if (nLevels[i]==0) {
+		    type->level_names= NULL;
+		    continue;
+		}
+		type->level_names= _XkbTypedCalloc(nLevels[i],Atom);
+		if (type->level_names!=NULL) {
+		    if (!_XkbReadBufferCopy32(&buf,(long *)type->level_names,
+								nLevels[i]))
+			goto BAILOUT;
+		}
+		else {
+		    _XkbSkipReadBufferData(&buf,nLevels[i]*4);
+		}
+	    }
+	}
+	else {
+	    for (i=0;i<(int)rep->nTypes;i++) {
+		_XkbSkipReadBufferData(&buf,nLevels[i]*4);
+	    }
+	}
+    }
+    if (rep->which & XkbIndicatorNamesMask) {
+	if (_XkbReadAtoms(&buf,names->indicators,XkbNumIndicators,
+						rep->indicators)!=Success)
+	    goto BAILOUT;
+    }
+    if ( rep->which&XkbVirtualModNamesMask ) {
+	if (_XkbReadAtoms(&buf,names->vmods,XkbNumVirtualMods,
+					(CARD32)rep->virtualMods)!=Success)
+	    goto BAILOUT;
+    }
+    if ( rep->which&XkbGroupNamesMask ) {
+	if (_XkbReadAtoms(&buf,names->groups,XkbNumKbdGroups,
+					(CARD32)rep->groupNames)!=Success)
+	    goto BAILOUT;
+    }
+    if ( rep->which&XkbKeyNamesMask ) {
+	if (names->keys==NULL) {
+	    int nKeys;
+	    if (xkb->max_key_code==0) {
+		xkb->min_key_code= rep->minKeyCode;
+		xkb->max_key_code= rep->maxKeyCode;
+	    }
+	    nKeys= xkb->max_key_code+1;
+	    names->keys= _XkbTypedCalloc(nKeys,XkbKeyNameRec);
+	}
+	if (names->keys!=NULL) {
+	    if (!_XkbCopyFromReadBuffer(&buf,
+					(char *)&names->keys[rep->firstKey],
+					rep->nKeys*XkbKeyNameLength))
+		goto BAILOUT;
+	}
+	else _XkbSkipReadBufferData(&buf,rep->nKeys*XkbKeyNameLength);
+    }
+    if ( rep->which&XkbKeyAliasesMask && (rep->nKeyAliases>0) ) {
+	if (XkbAllocNames(xkb,XkbKeyAliasesMask,0,rep->nKeyAliases)!=Success)
+	    goto BAILOUT;
+	if (!_XkbCopyFromReadBuffer(&buf,(char *)names->key_aliases,
+				rep->nKeyAliases*XkbKeyNameLength*2))
+	    goto BAILOUT;
+    }
+    if ( rep->which&XkbRGNamesMask ) {
+	if (rep->nRadioGroups>0) {
+	    Atom *rgNames;
+
+	    if (names->radio_groups==NULL)
+		names->radio_groups = _XkbTypedCalloc(rep->nRadioGroups,Atom);
+	    else if (names->num_rg<rep->nRadioGroups) {
+		names->radio_groups = _XkbTypedRealloc(names->radio_groups,
+							rep->nRadioGroups,
+							Atom);
+	    }
+	    rgNames= names->radio_groups;
+	    if (!rgNames) {
+		goto BAILOUT;
+	    }
+	    if (!_XkbReadBufferCopy32(&buf,(long *)rgNames,rep->nRadioGroups))
+		goto BAILOUT;
+	    names->num_rg= rep->nRadioGroups;
+	}
+	else if (names->num_rg>0) {
+	    names->num_rg= 0;
+	    Xfree(names->radio_groups);
+	}
+    }
+    len= _XkbFreeReadBuffer(&buf);
+    if (len!=0) 	return BadLength;
+    else		return Success;
+BAILOUT:
+    _XkbFreeReadBuffer(&buf);
+    return BadLength;
+}
+
+Status
+XkbGetNames(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+    register xkbGetNamesReq *req;
+    xkbGetNamesReply	     rep;
+    Status		     status;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    if (!xkb->names) {
+	xkb->names = _XkbTypedCalloc(1,XkbNamesRec);
+	if (!xkb->names) {
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return BadAlloc;
+	}
+    }
+    GetReq(kbGetNames, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetNames;
+    req->deviceSpec = xkb->device_spec;
+    req->which = which;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadImplementation;
+    }
+
+    status = _XkbReadGetNamesReply(dpy,&rep,xkb,NULL);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+/***====================================================================***/
+
+static int
+_XkbCountBits(int nBitsMax,unsigned long mask)
+{
+register unsigned long y, nBits;
+
+    y = (mask >> 1) &033333333333;
+    y = mask - y - ((y >>1) & 033333333333);
+    nBits = ((unsigned int) (((y + (y >> 3)) & 030707070707) % 077));
+
+    /* nBitsMax really means max+1 */
+    return (nBits < nBitsMax) ? nBits : (nBitsMax - 1);
+}
+
+static CARD32
+_XkbCountAtoms(Atom *atoms,int maxAtoms,int *count)
+{
+register unsigned int i,bit,nAtoms;
+register CARD32 atomsPresent;
+
+    for (i=nAtoms=atomsPresent=0,bit=1;i<maxAtoms;i++,bit<<=1) {
+        if (atoms[i]!=None) {
+            atomsPresent|= bit;
+            nAtoms++;
+        }
+    }
+    if (count)
+        *count= nAtoms;
+    return atomsPresent;
+}
+
+static void
+_XkbCopyAtoms(Display *dpy,Atom *atoms,CARD32 mask,int maxAtoms)
+{
+register unsigned int i,bit;
+
+    for (i=0,bit=1;i<maxAtoms;i++,bit<<=1) {
+        if (mask&bit)
+	    Data32(dpy,&atoms[i],4);
+    }
+    return;
+}
+
+Bool
+XkbSetNames(	Display *	dpy,
+		unsigned int 	which,
+		unsigned int 	firstType,
+		unsigned int 	nTypes,
+		XkbDescPtr 	xkb)
+{
+    register xkbSetNamesReq *req;
+    int  nLvlNames = 0;
+    XkbInfoPtr xkbi;
+    XkbNamesPtr names;
+    unsigned firstLvlType,nLvlTypes;
+    int	nVMods,nLEDs,nRG,nKA,nGroups;
+    int nKeys=0,firstKey=0,nAtoms;
+    CARD32 leds,vmods,groups;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!xkb)||(!xkb->names))
+	return False;
+    firstLvlType= firstType;
+    nLvlTypes= nTypes;
+    if (nTypes<1)
+	which&= ~(XkbKTLevelNamesMask|XkbKeyTypeNamesMask);
+    else if (firstType<=XkbLastRequiredType) {
+	int	adjust;
+	adjust= XkbLastRequiredType-firstType+1;
+	firstType+= adjust;
+	nTypes-= adjust;
+	if (nTypes<1)
+	    which&= ~XkbKeyTypeNamesMask;
+    }
+    names= xkb->names;
+    if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) {
+	register int	i;
+	XkbKeyTypePtr	type;
+	if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)||
+				(firstType+nTypes>xkb->map->num_types)||
+				(firstLvlType+nLvlTypes>xkb->map->num_types))
+	    return False;
+	if (which&XkbKTLevelNamesMask) {
+	    type= &xkb->map->types[firstLvlType];
+	    for (i=nLvlNames=0;i<nLvlTypes;i++,type++) {
+		if (type->level_names!=NULL)
+		    nLvlNames+= type->num_levels;
+	    }
+	}
+    }
+
+    nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetNames, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetNames;
+    req->deviceSpec = xkb->device_spec;
+    req->firstType = firstType;
+    req->nTypes = nTypes;
+    req->firstKey = xkb->min_key_code;
+    req->nKeys = xkb->max_key_code-xkb->min_key_code+1;
+
+    if (which&XkbKeycodesNameMask)
+	nAtoms++;
+    if (which&XkbGeometryNameMask)
+	nAtoms++;
+    if (which&XkbSymbolsNameMask)
+	nAtoms++;
+    if (which&XkbPhysSymbolsNameMask)
+	nAtoms++;
+    if (which&XkbTypesNameMask)
+	nAtoms++;
+    if (which&XkbCompatNameMask)
+	nAtoms++;
+    if (which&XkbKeyTypeNamesMask)
+	nAtoms+= nTypes;
+    if (which&XkbKTLevelNamesMask) {
+	req->firstKTLevel= firstLvlType;
+	req->nKTLevels= nLvlTypes;
+	req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */
+	nAtoms+= nLvlNames;
+    }
+    else req->firstKTLevel= req->nKTLevels= 0;
+
+    if (which&XkbIndicatorNamesMask) {
+	req->indicators= leds=
+		_XkbCountAtoms(names->indicators,XkbNumIndicators,&nLEDs);
+	if (nLEDs>0)
+	     nAtoms+= nLEDs;
+	else which&= ~XkbIndicatorNamesMask;
+    }
+    else req->indicators= leds= 0;
+
+    if (which&XkbVirtualModNamesMask) {
+	vmods= req->virtualMods= (CARD16)
+		_XkbCountAtoms(names->vmods,XkbNumVirtualMods,&nVMods);
+	if (nVMods>0)
+	     nAtoms+= nVMods;
+	else which&= ~XkbVirtualModNamesMask;
+    }
+    else vmods= req->virtualMods= 0;
+
+    if (which&XkbGroupNamesMask) {
+	groups= req->groupNames= (CARD8)
+		_XkbCountAtoms(names->groups,XkbNumKbdGroups,&nGroups);
+	if (nGroups>0)
+	     nAtoms+= nGroups;
+	else which&= ~XkbGroupNamesMask;
+    }
+    else groups= req->groupNames= 0;
+
+    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
+	firstKey= req->firstKey;
+	nKeys= req->nKeys;
+	nAtoms+= nKeys;	/* technically not atoms, but 4 bytes wide */
+    }
+    else which&= ~XkbKeyNamesMask;
+
+    if (which&XkbKeyAliasesMask) {
+	nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0);
+	if (nKA>0) {
+	    req->nKeyAliases= nKA;
+	    nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */
+	}
+	else {
+	    which&= ~XkbKeyAliasesMask;
+	    req->nKeyAliases = 0;
+	}
+    }
+    else req->nKeyAliases= 0;
+
+    if (which&XkbRGNamesMask) {
+	nRG= names->num_rg;
+	if (nRG>0)
+	     nAtoms+= nRG;
+	else which&= ~XkbRGNamesMask;
+    }
+
+    req->which= which;
+    req->nRadioGroups= nRG;
+    req->length+= (nAtoms*4)/4;
+
+    if (which&XkbKeycodesNameMask)
+	Data32(dpy,(long *)&names->keycodes,4);
+    if (which&XkbGeometryNameMask)
+	Data32(dpy,(long *)&names->geometry,4);
+    if (which&XkbSymbolsNameMask)
+	Data32(dpy,(long *)&names->symbols,4);
+    if (which&XkbPhysSymbolsNameMask)
+	Data32(dpy,(long *)&names->phys_symbols,4);
+    if (which&XkbTypesNameMask)
+	Data32(dpy,(long *)&names->types,4);
+    if (which&XkbCompatNameMask)
+	Data32(dpy,(long *)&names->compat,4);
+    if (which&XkbKeyTypeNamesMask) {
+	register int 		i;
+	register XkbKeyTypePtr	type;
+	type= &xkb->map->types[firstType];
+	for (i=0;i<nTypes;i++,type++) {
+	    Data32(dpy,(long *)&type->name,4);
+	}
+    }
+    if (which&XkbKTLevelNamesMask) {
+	XkbKeyTypePtr type;
+	int i;
+	char *tmp;
+
+	BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes));
+	type = &xkb->map->types[firstLvlType];
+	for (i=0;i<nLvlTypes;i++,type++) {
+	    *tmp++ = type->num_levels;
+	}
+	type = &xkb->map->types[firstLvlType];
+	for (i=0;i<nLvlTypes;i++,type++) {
+	    if (type->level_names!=NULL)
+		Data32(dpy,(long *)type->level_names,type->num_levels*4);
+	}
+    }
+    if (which&XkbIndicatorNamesMask)
+	_XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators);
+    if (which&XkbVirtualModNamesMask)
+	_XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods);
+    if (which&XkbGroupNamesMask)
+	_XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups);
+    if (which&XkbKeyNamesMask) {
+#ifdef WORD64
+	char *tmp;
+	register int i;
+	BufAlloc(char *,tmp,nKeys*XkbKeyNameLength);
+	for (i=0;i<nKeys;i++,tmp+= XkbKeyNameLength) {
+	    tmp[0]= names->keys[firstKey+i].name[0];
+	    tmp[1]= names->keys[firstKey+i].name[1];
+	    tmp[2]= names->keys[firstKey+i].name[2];
+	    tmp[3]= names->keys[firstKey+i].name[3];
+	}
+#else
+	Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength);
+#endif
+    }
+    if (which&XkbKeyAliasesMask) {
+#ifdef WORD64
+	char *tmp;
+	register int i;
+	BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2);
+	for (i=0;i<nKeys;i++,tmp+= 2*XkbKeyNameLength) {
+	    tmp[0]= names->key_aliases[i].real[0];
+	    tmp[1]= names->key_aliases[i].real[1];
+	    tmp[2]= names->key_aliases[i].real[2];
+	    tmp[3]= names->key_aliases[i].real[3];
+	    tmp[4]= names->key_aliases[i].alias[0];
+	    tmp[5]= names->key_aliases[i].alias[1];
+	    tmp[6]= names->key_aliases[i].alias[2];
+	    tmp[7]= names->key_aliases[i].alias[3];
+	}
+#else
+	Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2);
+#endif
+    }
+    if (which&XkbRGNamesMask) {
+	Data32(dpy,(long *)names->radio_groups,nRG*4);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbChangeNames(Display *dpy,XkbDescPtr xkb,XkbNameChangesPtr changes)
+{
+    register xkbSetNamesReq *req;
+    int  nLvlNames = 0;
+    XkbInfoPtr xkbi;
+    XkbNamesPtr names;
+    unsigned which,firstType,nTypes;
+    unsigned firstLvlType,nLvlTypes;
+    int	nVMods,nLEDs,nRG,nKA,nGroups;
+    int nKeys=0,firstKey=0,nAtoms;
+    CARD32 leds=0,vmods=0,groups=0;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!xkb)||(!xkb->names)||(!changes))
+	return False;
+    which= changes->changed;
+    firstType= changes->first_type;
+    nTypes= changes->num_types;
+    firstLvlType= changes->first_lvl;;
+    nLvlTypes= changes->num_lvls;
+    if (which&XkbKeyTypeNamesMask) {
+	if (nTypes<1)
+	    which&= ~XkbKeyTypeNamesMask;
+	else if (firstType<=XkbLastRequiredType) {
+	    int	adjust;
+	    adjust= XkbLastRequiredType-firstType+1;
+	    firstType+= adjust;
+	    nTypes-= adjust;
+	    if (nTypes<1)
+		which&= ~XkbKeyTypeNamesMask;
+	}
+    }
+    else firstType= nTypes= 0;
+
+    if (which&XkbKTLevelNamesMask) {
+	if (nLvlTypes<1)
+	    which&= ~XkbKTLevelNamesMask;
+    }
+    else firstLvlType= nLvlTypes= 0;
+
+    names= xkb->names;
+    if (which&(XkbKTLevelNamesMask|XkbKeyTypeNamesMask)) {
+	register int	i;
+	XkbKeyTypePtr	type;
+	if((xkb->map==NULL)||(xkb->map->types==NULL)||(nTypes==0)||
+				(firstType+nTypes>xkb->map->num_types)||
+				(firstLvlType+nLvlTypes>xkb->map->num_types))
+	    return False;
+	if (which&XkbKTLevelNamesMask) {
+	    type= &xkb->map->types[firstLvlType];
+	    for (i=nLvlNames=0;i<nLvlTypes;i++,type++) {
+		if (type->level_names!=NULL)
+		    nLvlNames+= type->num_levels;
+	    }
+	}
+    }
+
+    if (changes->num_keys<1)
+	which&= ~XkbKeyNamesMask;
+    if ((which&XkbKeyNamesMask)==0)
+	changes->first_key= changes->num_keys= 0;
+    else if ((changes->first_key<xkb->min_key_code)||
+	     (changes->first_key+changes->num_keys>xkb->max_key_code)) {
+	return False;
+    }
+
+    if ((which&XkbVirtualModNamesMask)==0)
+	changes->changed_vmods= 0;
+    else if (changes->changed_vmods==0)
+	which&= ~XkbVirtualModNamesMask;
+
+    if ((which&XkbIndicatorNamesMask)==0)
+	changes->changed_indicators= 0;
+    else if (changes->changed_indicators==0)
+	which&= ~XkbIndicatorNamesMask;
+
+    if ((which&XkbGroupNamesMask)==0)
+	changes->changed_groups= 0;
+    else if (changes->changed_groups==0)
+	which&= ~XkbGroupNamesMask;
+
+    nVMods= nLEDs= nRG= nKA= nAtoms= nGroups= 0;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetNames, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetNames;
+    req->deviceSpec = xkb->device_spec;
+    req->firstType = firstType;
+    req->nTypes = nTypes;
+    req->firstKey = changes->first_key;
+    req->nKeys = changes->num_keys;
+
+    if (which&XkbKeycodesNameMask)
+	nAtoms++;
+    if (which&XkbGeometryNameMask)
+	nAtoms++;
+    if (which&XkbSymbolsNameMask)
+	nAtoms++;
+    if (which&XkbPhysSymbolsNameMask)
+	nAtoms++;
+    if (which&XkbTypesNameMask)
+	nAtoms++;
+    if (which&XkbCompatNameMask)
+	nAtoms++;
+    if (which&XkbKeyTypeNamesMask)
+	nAtoms+= nTypes;
+    if (which&XkbKTLevelNamesMask) {
+	req->firstKTLevel= firstLvlType;
+	req->nKTLevels= nLvlTypes;
+	req->length+= XkbPaddedSize(nLvlTypes)/4; /* room for group widths */
+	nAtoms+= nLvlNames;
+    }
+    else req->firstKTLevel= req->nKTLevels= 0;
+
+    if (which&XkbIndicatorNamesMask) {
+	leds= req->indicators= (CARD32)changes->changed_indicators;
+	nLEDs= _XkbCountBits(XkbNumIndicators,changes->changed_indicators);
+	if (nLEDs>0)
+	     nAtoms+= nLEDs;
+	else which&= ~XkbIndicatorNamesMask;
+    }
+    else req->indicators= 0;
+
+    if (which&XkbVirtualModNamesMask) {
+	vmods= req->virtualMods= changes->changed_vmods;
+	nVMods= _XkbCountBits(XkbNumVirtualMods,
+					(unsigned long)changes->changed_vmods);
+	if (nVMods>0)
+	     nAtoms+= nVMods;
+	else which&= ~XkbVirtualModNamesMask;
+    }
+    else req->virtualMods= 0;
+
+    if (which&XkbGroupNamesMask) {
+	groups= req->groupNames= changes->changed_groups;
+	nGroups= _XkbCountBits(XkbNumKbdGroups,
+					(unsigned long)changes->changed_groups);
+	if (nGroups>0)
+	     nAtoms+= nGroups;
+	else which&= ~XkbGroupNamesMask;
+    }
+    else req->groupNames= 0;
+
+    if ((which&XkbKeyNamesMask)&&(names->keys!=NULL)) {
+	firstKey= req->firstKey;
+	nKeys= req->nKeys;
+	nAtoms+= nKeys;	/* technically not atoms, but 4 bytes wide */
+    }
+    else which&= ~XkbKeyNamesMask;
+
+    if (which&XkbKeyAliasesMask) {
+	nKA= ((names->key_aliases!=NULL)?names->num_key_aliases:0);
+	if (nKA>0)
+	    nAtoms+= nKA*2; /* not atoms, but 8 bytes on the wire */
+	else which&= ~XkbKeyAliasesMask;
+    }
+
+    if (which&XkbRGNamesMask) {
+	nRG= names->num_rg;
+	if (nRG>0)
+	     nAtoms+= nRG;
+	else which&= ~XkbRGNamesMask;
+    }
+
+    req->which= which;
+    req->nRadioGroups= nRG;
+    req->length+= (nAtoms*4)/4;
+
+    if (which&XkbKeycodesNameMask)
+	Data32(dpy,(long *)&names->keycodes,4);
+    if (which&XkbGeometryNameMask)
+	Data32(dpy,(long *)&names->geometry,4);
+    if (which&XkbSymbolsNameMask)
+	Data32(dpy,(long *)&names->symbols,4);
+    if (which&XkbPhysSymbolsNameMask)
+	Data32(dpy,(long *)&names->phys_symbols,4);
+    if (which&XkbTypesNameMask)
+	Data32(dpy,(long *)&names->types,4);
+    if (which&XkbCompatNameMask)
+	Data32(dpy,(long *)&names->compat,4);
+    if (which&XkbKeyTypeNamesMask) {
+	register int 		i;
+	register XkbKeyTypePtr	type;
+	type= &xkb->map->types[firstType];
+	for (i=0;i<nTypes;i++,type++) {
+	    Data32(dpy,(long *)&type->name,4);
+	}
+    }
+    if (which&XkbKTLevelNamesMask) {
+	XkbKeyTypePtr type;
+	int i;
+	char *tmp;
+
+	BufAlloc(char *,tmp,XkbPaddedSize(nLvlTypes));
+	type = &xkb->map->types[firstLvlType];
+	for (i=0;i<nLvlTypes;i++,type++) {
+	    *tmp++ = type->num_levels;
+	}
+	type = &xkb->map->types[firstLvlType];
+	for (i=0;i<nLvlTypes;i++,type++) {
+	    if (type->level_names!=NULL)
+		Data32(dpy,(long *)type->level_names,type->num_levels*4);
+	}
+    }
+    if (which&XkbIndicatorNamesMask)
+	_XkbCopyAtoms(dpy,names->indicators,leds,XkbNumIndicators);
+    if (which&XkbVirtualModNamesMask)
+	_XkbCopyAtoms(dpy,names->vmods,vmods,XkbNumVirtualMods);
+    if (which&XkbGroupNamesMask)
+	_XkbCopyAtoms(dpy,names->groups,groups,XkbNumKbdGroups);
+    if (which&XkbKeyNamesMask) {
+#ifdef WORD64
+	char *tmp;
+	register int i;
+	BufAlloc(char *,tmp,nKeys*4);
+	for (i=0;i<nKeys;i++,tmp+= 4) {
+	    tmp[0]= names->keys[firstKey+i].name[0];
+	    tmp[1]= names->keys[firstKey+i].name[1];
+	    tmp[2]= names->keys[firstKey+i].name[2];
+	    tmp[3]= names->keys[firstKey+i].name[3];
+	}
+#else
+	Data(dpy,(char *)&names->keys[firstKey],nKeys*XkbKeyNameLength);
+#endif
+    }
+    if (which&XkbKeyAliasesMask) {
+#ifdef WORD64
+	char *tmp;
+	register int i;
+	BufAlloc(char *,tmp,nKA*XkbKeyNameLength*2);
+	for (i=0;i<nKeys;i++,tmp+= 2*XkbKeyNameLength) {
+	    tmp[0]= names->key_aliases[i].real[0];
+	    tmp[1]= names->key_aliases[i].real[1];
+	    tmp[2]= names->key_aliases[i].real[2];
+	    tmp[3]= names->key_aliases[i].real[3];
+	    tmp[4]= names->key_aliases[i].alias[0];
+	    tmp[5]= names->key_aliases[i].alias[1];
+	    tmp[6]= names->key_aliases[i].alias[2];
+	    tmp[7]= names->key_aliases[i].alias[3];
+	}
+#else
+	Data(dpy,(char *)names->key_aliases,nKA*XkbKeyNameLength*2);
+#endif
+    }
+    if (which&XkbRGNamesMask) {
+	Data32(dpy,(long *)names->radio_groups,nRG*4);
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+void
+XkbNoteNameChanges(	XkbNameChangesPtr	old,
+			XkbNamesNotifyEvent *	new,
+			unsigned int	 	wanted)
+{
+int	first,last,old_last,new_last;
+
+    wanted&= new->changed;
+    if ((old==NULL)||(new==NULL)||(wanted==0))
+	return;
+    if (wanted&XkbKeyTypeNamesMask) {
+	if (old->changed&XkbKeyTypeNamesMask) {
+	    new_last= (new->first_type+new->num_types-1);
+	    old_last= (old->first_type+old->num_types-1);
+
+	    if (new->first_type<old->first_type)
+		 first= new->first_type;
+	    else first= old->first_type;
+
+	    if (old_last>new_last)
+		 last= old_last;
+	    else last= new_last;
+
+	    old->first_type= first;
+	    old->num_types= (last-first)+1;
+	}
+	else {
+	    old->first_type= new->first_type;
+	    old->num_types= new->num_types;
+	}
+    }
+    if (wanted&XkbKTLevelNamesMask) {
+	if (old->changed&XkbKTLevelNamesMask) {
+	    new_last= (new->first_lvl+new->num_lvls-1);
+	    old_last= (old->first_lvl+old->num_lvls-1);
+
+	    if (new->first_lvl<old->first_lvl)
+		 first= new->first_lvl;
+	    else first= old->first_lvl;
+
+	    if (old_last>new_last)
+		 last= old_last;
+	    else last= new_last;
+
+	    old->first_lvl= first;
+	    old->num_lvls= (last-first)+1;
+	}
+	else {
+	    old->first_lvl= new->first_lvl;
+	    old->num_lvls= new->num_lvls;
+	}
+    }
+    if (wanted&XkbIndicatorNamesMask) {
+	if (old->changed&XkbIndicatorNamesMask)
+	     old->changed_indicators|= new->changed_indicators;
+	else old->changed_indicators=  new->changed_indicators;
+    }
+    if (wanted&XkbKeyNamesMask) {
+	if (old->changed&XkbKeyNamesMask) {
+	    new_last= (new->first_key+new->num_keys-1);
+	    old_last= (old->first_key+old->num_keys-1);
+
+	    first= old->first_key;
+
+	    if (new->first_key<old->first_key)
+		first= new->first_key;
+	    if (old_last>new_last)
+		new_last= old_last;
+
+	    old->first_key= first;
+	    old->num_keys= (new_last-first)+1;
+	}
+	else {
+	    old->first_key= new->first_key;
+	    old->num_keys= new->num_keys;
+	}
+    }
+    if (wanted&XkbVirtualModNamesMask) {
+	if (old->changed&XkbVirtualModNamesMask)
+	     old->changed_vmods|= new->changed_vmods;
+	else old->changed_vmods=  new->changed_vmods;
+    }
+    if (wanted&XkbGroupNamesMask) {
+	if (old->changed&XkbGroupNamesMask)
+	     old->changed_groups|= new->changed_groups;
+	else old->changed_groups=  new->changed_groups;
+    }
+    if (wanted&XkbRGNamesMask)
+	old->num_rg= new->num_radio_groups;
+    if (wanted&XkbKeyAliasesMask)
+	old->num_aliases= new->num_aliases;
+    old->changed|= wanted;
+    return;
+}
diff --git a/libX11/src/xkb/XKBRdBuf.c b/libX11/src/xkb/XKBRdBuf.c
index fa7fa3af8..3023a32ed 100644
--- a/libX11/src/xkb/XKBRdBuf.c
+++ b/libX11/src/xkb/XKBRdBuf.c
@@ -1,230 +1,230 @@
-/************************************************************

-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 "XKBlibint.h"

-#include <X11/extensions/XKBproto.h>

-

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

-

-int

-_XkbInitReadBuffer(Display *dpy,XkbReadBufferPtr buf,int size)

-{

-    if ((dpy!=NULL) && (buf!=NULL) && (size>0)) {

-	buf->error=  0;

-	buf->size=   size;

-	buf->start= buf->data= _XkbAlloc(size);

-	if (buf->start) {

-	    _XRead(dpy, buf->start, size);

-	    return 1;

-	}

-    }

-    return 0;

-}

-

-#define	_XkbReadBufferDataLeft(b)	(((b)->size)-((b)->data-(b)->start))

-

-int

-_XkbSkipReadBufferData(XkbReadBufferPtr	from,int size)

-{

-    if (size==0)

-	return 1;

-    if ((from==NULL)||(from->error)||(size<1)||

-					(_XkbReadBufferDataLeft(from)<size))

-	return 0;

-    from->data+= size;

-    return 1;

-}

-

-int

-_XkbCopyFromReadBuffer(XkbReadBufferPtr	from,char *to,int size)

-{

-    if (size==0)

-	return 1;

-    if ((from==NULL)||(from->error)||(to==NULL)||(size<1)||

-					(_XkbReadBufferDataLeft(from)<size))

-	return 0;

-    memcpy(to,from->data,size);

-    from->data+= size;

-    return 1;

-}

-

-#ifdef XKB_FORCE_INT_KEYSYM

-int

-_XkbReadCopyKeySyms(int *wire,KeySym *to,int num_words)

-{

-    while (num_words-->0) {

-	*to++= *wire++;

-    }

-    return 1;

-}

-

-int

-_XkbReadBufferCopyKeySyms(XkbReadBufferPtr from,KeySym *to,int num_words)

-{

-    if ((unsigned)(num_words*4)>_XkbReadBufferDataLeft(from))

-        return 0;

-    _XkbReadCopyKeySyms((int *)from->data,to,num_words);

-    from->data+= (4*num_words);

-    return True;

-}

-

-int

-_XkbWriteCopyKeySyms (register KeySym *from,CARD32 *to,int len)

-{

-

-    while (len-->0) {

-        *to++= (CARD32)*from++;

-    }

-    return True;

-}

-#endif

-

-#ifdef LONG64

-int

-_XkbReadCopyData32(int *wire,long *to,int num_words)

-{

-    while (num_words-->0) {

-	*to++= *wire++;

-    }

-    return 1;

-}

-#endif

-#ifdef WORD64

-int

-_XkbReadCopyData32(int *from,long *lp,int num_words)

-{

-long *lpack;

-long mask32 = 0x00000000ffffffff;

-long maskw, i, bits;

-

-    lpack = (long *)from;

-    bits = 32;

-

-    for (i=0;i<num_words;i++) {

-	maskw = mask32 << bits;

-	*lp++ = (*lpack & maskw) >> bits;

-	bits = bits ^ 32;

-	if (bits)

-	    lpack++;

-    }

-    return 1;

-}

-#endif

-

-#if defined(LONG64) || defined(WORD64)

-int

-_XkbReadBufferCopy32(XkbReadBufferPtr from,long *to,int num_words)

-{

-    if ((unsigned)(num_words*4)>_XkbReadBufferDataLeft(from))

-	return 0;

-    _XkbReadCopyData32((int *)from->data,to,num_words);

-    from->data+= (4*num_words);

-    return True;

-}

-#endif

-

-#ifdef LONG64

-int

-_XkbWriteCopyData32 (register unsigned long *from,CARD32 *to,int len)

-{

-

-    while (len-->0) {

-	*to++= (CARD32)*from++;

-    }

-    return True;

-}

-#endif /* LONG64 */

-

-#ifdef WORD64

-_XkbWriteCopyData32 Not Implemented Yet for sizeof(int)==8

-#endif

-

-char *

-_XkbPeekAtReadBuffer(XkbReadBufferPtr from,int size)

-{

-    if ((from==NULL)||(from->error)||(size<1)||

-					(_XkbReadBufferDataLeft(from)<size))

-	return NULL;

-    return from->data;

-}

-

-char *

-_XkbGetReadBufferPtr(XkbReadBufferPtr from,int size)

-{

-char	*ptr;

-    if ((from==NULL)||(from->error)||(size<1)||

-					(_XkbReadBufferDataLeft(from)<size))

-	return NULL;

-    ptr= from->data;

-    from->data+= size;

-    return ptr;

-}

-

-

-int

-_XkbFreeReadBuffer(XkbReadBufferPtr buf)

-{

-    if ((buf!=NULL) && (buf->start!=NULL)) {

-	int left;

-	left= (int)_XkbReadBufferDataLeft(buf);

-	if (buf->start!=NULL)

-	    Xfree(buf->start);

-	buf->size= 0;

-	buf->start= buf->data= NULL;

-	return left;

-    }

-    return 0;

-}

-

-Bool

-_XkbGetReadBufferCountedString(XkbReadBufferPtr buf,char **rtrn)

-{

-CARD16	len,*pLen;

-int	left;

-char *	str = NULL;

-

-    if ((buf==NULL)||(buf->error)||((left=(int)_XkbReadBufferDataLeft(buf))<4))

-	return False;

-    pLen= (CARD16 *)buf->data;

-    len= *pLen;

-    if (len>0) {

-	if (XkbPaddedSize(len+2)>left)

-	    return False;

-	str= _XkbAlloc(len+1);

-	if (str) {

-	    memcpy(str,&buf->data[2],len);

-	    str[len]= '\0';

-	}

-    }

-    buf->data+= XkbPaddedSize(len+2);

-    *rtrn= str;

-    return True;

-}

+/************************************************************
+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 "XKBlibint.h"
+#include <X11/extensions/XKBproto.h>
+
+/***====================================================================***/
+
+int
+_XkbInitReadBuffer(Display *dpy,XkbReadBufferPtr buf,int size)
+{
+    if ((dpy!=NULL) && (buf!=NULL) && (size>0)) {
+	buf->error=  0;
+	buf->size=   size;
+	buf->start= buf->data= _XkbAlloc(size);
+	if (buf->start) {
+	    _XRead(dpy, buf->start, size);
+	    return 1;
+	}
+    }
+    return 0;
+}
+
+#define	_XkbReadBufferDataLeft(b)	(((b)->size)-((b)->data-(b)->start))
+
+int
+_XkbSkipReadBufferData(XkbReadBufferPtr	from,int size)
+{
+    if (size==0)
+	return 1;
+    if ((from==NULL)||(from->error)||(size<1)||
+					(_XkbReadBufferDataLeft(from)<size))
+	return 0;
+    from->data+= size;
+    return 1;
+}
+
+int
+_XkbCopyFromReadBuffer(XkbReadBufferPtr	from,char *to,int size)
+{
+    if (size==0)
+	return 1;
+    if ((from==NULL)||(from->error)||(to==NULL)||(size<1)||
+					(_XkbReadBufferDataLeft(from)<size))
+	return 0;
+    memcpy(to,from->data,size);
+    from->data+= size;
+    return 1;
+}
+
+#ifdef XKB_FORCE_INT_KEYSYM
+int
+_XkbReadCopyKeySyms(int *wire,KeySym *to,int num_words)
+{
+    while (num_words-->0) {
+	*to++= *wire++;
+    }
+    return 1;
+}
+
+int
+_XkbReadBufferCopyKeySyms(XkbReadBufferPtr from,KeySym *to,int num_words)
+{
+    if ((unsigned)(num_words*4)>_XkbReadBufferDataLeft(from))
+        return 0;
+    _XkbReadCopyKeySyms((int *)from->data,to,num_words);
+    from->data+= (4*num_words);
+    return True;
+}
+
+int
+_XkbWriteCopyKeySyms (register KeySym *from,CARD32 *to,int len)
+{
+
+    while (len-->0) {
+        *to++= (CARD32)*from++;
+    }
+    return True;
+}
+#endif
+
+#ifdef LONG64
+int
+_XkbReadCopyData32(int *wire,long *to,int num_words)
+{
+    while (num_words-->0) {
+	*to++= *wire++;
+    }
+    return 1;
+}
+#endif
+#ifdef WORD64
+int
+_XkbReadCopyData32(int *from,long *lp,int num_words)
+{
+long *lpack;
+long mask32 = 0x00000000ffffffff;
+long maskw, i, bits;
+
+    lpack = (long *)from;
+    bits = 32;
+
+    for (i=0;i<num_words;i++) {
+	maskw = mask32 << bits;
+	*lp++ = (*lpack & maskw) >> bits;
+	bits = bits ^ 32;
+	if (bits)
+	    lpack++;
+    }
+    return 1;
+}
+#endif
+
+#if defined(LONG64) || defined(WORD64)
+int
+_XkbReadBufferCopy32(XkbReadBufferPtr from,long *to,int num_words)
+{
+    if ((unsigned)(num_words*4)>_XkbReadBufferDataLeft(from))
+	return 0;
+    _XkbReadCopyData32((int *)from->data,to,num_words);
+    from->data+= (4*num_words);
+    return True;
+}
+#endif
+
+#ifdef LONG64
+int
+_XkbWriteCopyData32 (register unsigned long *from,CARD32 *to,int len)
+{
+
+    while (len-->0) {
+	*to++= (CARD32)*from++;
+    }
+    return True;
+}
+#endif /* LONG64 */
+
+#ifdef WORD64
+_XkbWriteCopyData32 Not Implemented Yet for sizeof(int)==8
+#endif
+
+char *
+_XkbPeekAtReadBuffer(XkbReadBufferPtr from,int size)
+{
+    if ((from==NULL)||(from->error)||(size<1)||
+					(_XkbReadBufferDataLeft(from)<size))
+	return NULL;
+    return from->data;
+}
+
+char *
+_XkbGetReadBufferPtr(XkbReadBufferPtr from,int size)
+{
+char	*ptr;
+    if ((from==NULL)||(from->error)||(size<1)||
+					(_XkbReadBufferDataLeft(from)<size))
+	return NULL;
+    ptr= from->data;
+    from->data+= size;
+    return ptr;
+}
+
+
+int
+_XkbFreeReadBuffer(XkbReadBufferPtr buf)
+{
+    if ((buf!=NULL) && (buf->start!=NULL)) {
+	int left;
+	left= (int)_XkbReadBufferDataLeft(buf);
+	if (buf->start!=NULL)
+	    Xfree(buf->start);
+	buf->size= 0;
+	buf->start= buf->data= NULL;
+	return left;
+    }
+    return 0;
+}
+
+Bool
+_XkbGetReadBufferCountedString(XkbReadBufferPtr buf,char **rtrn)
+{
+CARD16	len,*pLen;
+int	left;
+char *	str = NULL;
+
+    if ((buf==NULL)||(buf->error)||((left=(int)_XkbReadBufferDataLeft(buf))<4))
+	return False;
+    pLen= (CARD16 *)buf->data;
+    len= *pLen;
+    if (len>0) {
+	if (XkbPaddedSize(len+2)>left)
+	    return False;
+	str= _XkbAlloc(len+1);
+	if (str) {
+	    memcpy(str,&buf->data[2],len);
+	    str[len]= '\0';
+	}
+    }
+    buf->data+= XkbPaddedSize(len+2);
+    *rtrn= str;
+    return True;
+}
diff --git a/libX11/src/xkb/XKBSetGeom.c b/libX11/src/xkb/XKBSetGeom.c
index 439b75e01..ab76a2063 100644
--- a/libX11/src/xkb/XKBSetGeom.c
+++ b/libX11/src/xkb/XKBSetGeom.c
@@ -1,466 +1,466 @@
-/************************************************************

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

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include <stdio.h>

-#endif

-

-#include "Xlibint.h"

-#include "XKBlibint.h"

-#include <X11/extensions/XKBgeom.h>

-#include <X11/extensions/XKBproto.h>

-

-#ifndef MINSHORT

-#define	MINSHORT	-32768

-#endif

-#ifndef MAXSHORT

-#define	MAXSHORT	32767

-#endif

-

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

-

-#define	_SizeCountedString(s)  ((s)?XkbPaddedSize(2+strlen(s)):4)

-

-static char *

-_WriteCountedString(char *wire,char *str)

-{

-CARD16	len,*pLen;

-

-    len= (str?strlen(str):0);

-    pLen= (CARD16 *)wire;

-    *pLen= len;

-    if (len && str)

-	memcpy(&wire[2],str,len);

-    wire+= XkbPaddedSize(len+2);

-    return wire;

-}

-

-static int

-_SizeGeomProperties(XkbGeometryPtr geom)

-{

-register int 	i,size;

-XkbPropertyPtr	prop;

-

-    for (size=i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {

-	size+= _SizeCountedString(prop->name);

-	size+= _SizeCountedString(prop->value);

-    }

-    return size;

-}

-

-static int

-_SizeGeomColors(XkbGeometryPtr geom)

-{

-register int 		i,size;

-register XkbColorPtr	color;

-

-    for (i=size=0,color=geom->colors;i<geom->num_colors;i++,color++) {

-	size+= _SizeCountedString(color->spec);

-    }

-    return size;

-}

-

-static int

-_SizeGeomShapes(XkbGeometryPtr geom)

-{

-register int		i,size;

-register XkbShapePtr	shape;

-

-    for (i=size=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {

-	register int		n;

-	register XkbOutlinePtr	ol;

-	size+= SIZEOF(xkbShapeWireDesc);

-	for (n=0,ol=shape->outlines;n<shape->num_outlines;n++,ol++) {

-	    size+= SIZEOF(xkbOutlineWireDesc);

-	    size+= ol->num_points*SIZEOF(xkbPointWireDesc);

-	}

-    }

-    return size;

-}

-

-static int

-_SizeGeomDoodads(int num_doodads,XkbDoodadPtr doodad)

-{

-register int	i,size;

-

-    for (i=size=0;i<num_doodads;i++,doodad++) {

-	size+= SIZEOF(xkbAnyDoodadWireDesc);

-	if (doodad->any.type==XkbTextDoodad) {

-	    size+= _SizeCountedString(doodad->text.text);

-	    size+= _SizeCountedString(doodad->text.font);

-	}

-	else if (doodad->any.type==XkbLogoDoodad) {

-	    size+= _SizeCountedString(doodad->logo.logo_name);

-	}

-    }

-    return size;

-}

-

-static int

-_SizeGeomSections(XkbGeometryPtr geom)

-{

-register int 	i,size;

-XkbSectionPtr	section;

-

-    for (i=size=0,section=geom->sections;i<geom->num_sections;i++,section++) {

-	size+= SIZEOF(xkbSectionWireDesc);

-	if (section->rows) {

-	    int		r;

-	    XkbRowPtr	row;

-	    for (r=0,row=section->rows;r<section->num_rows;row++,r++) {

-		size+= SIZEOF(xkbRowWireDesc);

-		size+= row->num_keys*SIZEOF(xkbKeyWireDesc);

-	    }

-	}

-	if (section->doodads)

-	    size+= _SizeGeomDoodads(section->num_doodads,section->doodads);

-	if (section->overlays) {

-	    int			o;

-	    XkbOverlayPtr	ol;

-	    for (o=0,ol=section->overlays;o<section->num_overlays;o++,ol++) {

-		int			r;

-		XkbOverlayRowPtr	row;

-		size+= SIZEOF(xkbOverlayWireDesc);

-		for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {

-		   size+= SIZEOF(xkbOverlayRowWireDesc);

-		   size+= row->num_keys*SIZEOF(xkbOverlayKeyWireDesc);

-		}

-	    }

-	}

-    }

-    return size;

-}

-

-static int

-_SizeGeomKeyAliases(XkbGeometryPtr geom)

-{

-    return geom->num_key_aliases*(2*XkbKeyNameLength);

-}

-

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

-

-static char *

-_WriteGeomProperties(char *wire,XkbGeometryPtr geom)

-{

-register int 	i;

-register XkbPropertyPtr	prop;

-

-    for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {

-	wire= _WriteCountedString(wire,prop->name);

-	wire= _WriteCountedString(wire,prop->value);

-    }

-    return wire;

-}

-

-static char *

-_WriteGeomColors(char *wire,XkbGeometryPtr geom)

-{

-register int		i;

-register XkbColorPtr	color;

-

-    for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {

-	wire= _WriteCountedString(wire,color->spec);

-    }

-    return wire;

-}

-

-static char *

-_WriteGeomShapes(char *wire,XkbGeometryPtr geom)

-{

-int			i;

-XkbShapePtr		shape;

-xkbShapeWireDesc *	shapeWire;

-

-    for (i=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {

-	register int 		o;

-	XkbOutlinePtr		ol;

-	xkbOutlineWireDesc *	olWire;

-	shapeWire= (xkbShapeWireDesc *)wire;

-	shapeWire->name= shape->name;

-	shapeWire->nOutlines= shape->num_outlines;

-	if (shape->primary!=NULL)

-	     shapeWire->primaryNdx= XkbOutlineIndex(shape,shape->primary);

-	else shapeWire->primaryNdx= XkbNoShape;

-	if (shape->approx!=NULL)

-	     shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);

-	else shapeWire->approxNdx= XkbNoShape;

-	wire= (char *)&shapeWire[1];

-	for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {

-	    register int	p;

-	    XkbPointPtr		pt;

-	    xkbPointWireDesc *	ptWire;

-	    olWire= (xkbOutlineWireDesc *)wire;

-	    olWire->nPoints= ol->num_points;

-	    olWire->cornerRadius= ol->corner_radius;

-	    wire= (char *)&olWire[1];

-	    ptWire= (xkbPointWireDesc *)wire;

-	    for (p=0,pt=ol->points;p<ol->num_points;p++,pt++) {

-		ptWire[p].x= pt->x;

-		ptWire[p].y= pt->y;

-	    }

-	    wire= (char *)&ptWire[ol->num_points];

-	}

-    }

-    return wire;

-}

-

-static char *

-_WriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad)

-{

-register int		i;

-xkbDoodadWireDesc *	doodadWire;

-

-    for (i=0;i<num_doodads;i++,doodad++) {

-	doodadWire= (xkbDoodadWireDesc *)wire;

-	wire= (char *)&doodadWire[1];

-	bzero(doodadWire,SIZEOF(xkbDoodadWireDesc));

-	doodadWire->any.name= doodad->any.name;

-	doodadWire->any.type= doodad->any.type;

-	doodadWire->any.priority= doodad->any.priority;

-	doodadWire->any.top= doodad->any.top;

-	doodadWire->any.left= doodad->any.left;

-	doodadWire->any.angle= doodad->any.angle;

-	switch (doodad->any.type) {

-	    case XkbOutlineDoodad:

-	    case XkbSolidDoodad:

-		doodadWire->shape.colorNdx= doodad->shape.color_ndx;

-		doodadWire->shape.shapeNdx= doodad->shape.shape_ndx;

-		break;

-	    case XkbTextDoodad:

-		doodadWire->text.width= doodad->text.width;

-		doodadWire->text.height= doodad->text.height;

-		doodadWire->text.colorNdx= doodad->text.color_ndx;

-		wire= _WriteCountedString(wire,doodad->text.text);

-		wire= _WriteCountedString(wire,doodad->text.font);

-		break;

-	    case XkbIndicatorDoodad:

-		doodadWire->indicator.shapeNdx= doodad->indicator.shape_ndx;

-		doodadWire->indicator.onColorNdx=doodad->indicator.on_color_ndx;

-		doodadWire->indicator.offColorNdx=

-						doodad->indicator.off_color_ndx;

-		break;

-	    case XkbLogoDoodad:

-		doodadWire->logo.colorNdx= doodad->logo.color_ndx;

-		doodadWire->logo.shapeNdx= doodad->logo.shape_ndx;

-		wire= _WriteCountedString(wire,doodad->logo.logo_name);

-		break;

-	    default:

-		break;

-	}

-    }

-    return wire;

-}

-

-static char *

-_WriteGeomOverlay(char *wire,XkbOverlayPtr ol)

-{

-register int		r;

-XkbOverlayRowPtr	row;

-xkbOverlayWireDesc *	olWire;

-

-   olWire= (xkbOverlayWireDesc *)wire;

-   olWire->name= ol->name;

-   olWire->nRows= ol->num_rows;

-   wire= (char *)&olWire[1];

-   for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {

-   	unsigned int		k;

-	XkbOverlayKeyPtr	key;

-	xkbOverlayRowWireDesc *	rowWire;

-	rowWire= (xkbOverlayRowWireDesc *)wire;

-	rowWire->rowUnder= row->row_under;

-	rowWire->nKeys= row->num_keys;

-	wire= (char *)&rowWire[1];

-	for (k=0,key=row->keys;k<row->num_keys;k++,key++) {

-	    xkbOverlayKeyWireDesc *	keyWire;

-	    keyWire= (xkbOverlayKeyWireDesc *)wire;

-	    memcpy(keyWire->over,key->over.name,XkbKeyNameLength);

-	    memcpy(keyWire->under,key->under.name,XkbKeyNameLength);

-	    wire= (char *)&keyWire[1];

-	}

-   }

-   return wire;

-}

-

-static char *

-_WriteGeomSections(char *wire,XkbGeometryPtr geom)

-{

-register int		i;

-XkbSectionPtr		section;

-xkbSectionWireDesc *	sectionWire;

-

-    for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {

-	sectionWire= (xkbSectionWireDesc *)wire;

-	sectionWire->name= section->name;

-	sectionWire->top= section->top;

-	sectionWire->left= section->left;

-	sectionWire->width= section->width;

-	sectionWire->height= section->height;

-	sectionWire->angle= section->angle;

-	sectionWire->priority= section->priority;

-	sectionWire->nRows= section->num_rows;

-	sectionWire->nDoodads= section->num_doodads;

-	sectionWire->nOverlays= section->num_overlays;

-	sectionWire->pad= 0;

-	wire= (char *)&sectionWire[1];

-	if (section->rows) {

-	    int			r;

-	    XkbRowPtr		row;

-	    xkbRowWireDesc *	rowWire;

-	    for (r=0,row=section->rows;r<section->num_rows;r++,row++) {

-		rowWire= (xkbRowWireDesc *)wire;

-		rowWire->top= row->top;

-		rowWire->left= row->left;

-		rowWire->nKeys= row->num_keys;

-		rowWire->vertical= row->vertical;

-		rowWire->pad= 0;

-		wire= (char *)&rowWire[1];

-		if (row->keys) {

-		    int			k;

-		    XkbKeyPtr		key;

-		    xkbKeyWireDesc *	keyWire;

-		    keyWire= (xkbKeyWireDesc *)wire;

-		    for (k=0,key=row->keys;k<row->num_keys;k++,key++) {

-			memcpy(keyWire[k].name,key->name.name,XkbKeyNameLength);

-			keyWire[k].gap= key->gap;

-			keyWire[k].shapeNdx= key->shape_ndx;

-			keyWire[k].colorNdx= key->color_ndx;

-		    }

-		    wire= (char *)&keyWire[row->num_keys];

-		}

-	    }

-	}

-	if (section->doodads) {

-	    wire= _WriteGeomDoodads(wire,

-	    			      section->num_doodads,section->doodads);

-	}

-	if (section->overlays) {

-	    register int o;

-	    for (o=0;o<section->num_overlays;o++) {

-		wire= _WriteGeomOverlay(wire,&section->overlays[o]);

-	    }

-	}

-    }

-    return wire;

-}

-

-static char *

-_WriteGeomKeyAliases(char *wire,XkbGeometryPtr geom)

-{

-register int sz;

-

-    sz= geom->num_key_aliases*(XkbKeyNameLength*2);

-    if (sz>0) {

-	memcpy(wire,(char *)geom->key_aliases,sz);

-	wire+= sz;

-    }

-    return wire;

-}

-

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

-

-static Status

-_SendSetGeometry(Display *dpy,XkbGeometryPtr geom,xkbSetGeometryReq *req)

-{

-int			sz;

-char *			wire,*tbuf;

-

-    sz= 0;

-    sz+= _SizeCountedString(geom->label_font);

-    sz+= _SizeGeomProperties(geom);

-    sz+= _SizeGeomColors(geom);

-    sz+= _SizeGeomShapes(geom);

-    sz+= _SizeGeomSections(geom);

-    sz+= _SizeGeomDoodads(geom->num_doodads,geom->doodads);

-    sz+= _SizeGeomKeyAliases(geom);

-    req->length+= (sz/4);

-    if (sz < (dpy->bufmax - dpy->buffer)) {

-	BufAlloc(char *,wire,sz);

-	tbuf= NULL;

-    }

-    else {

-	tbuf= _XAllocTemp(dpy,sz);

-	if (!tbuf)

-	    return BadAlloc;

-	wire= tbuf;

-    }

-    wire= _WriteCountedString(wire,geom->label_font);

-    if (geom->num_properties>0)

-	wire= _WriteGeomProperties(wire,geom);

-    if (geom->num_colors>0)

-	wire= _WriteGeomColors(wire,geom);

-    if (geom->num_shapes>0)

-	wire= _WriteGeomShapes(wire,geom);

-    if (geom->num_sections>0)

-	wire= _WriteGeomSections(wire,geom);

-    if (geom->num_doodads>0)

-	wire= _WriteGeomDoodads(wire,geom->num_doodads,geom->doodads);

-    if (geom->num_key_aliases>0)

-	wire= _WriteGeomKeyAliases(wire,geom);

-    if (tbuf!=NULL) {

-	Data(dpy,tbuf,sz);

-	_XFreeTemp(dpy,tbuf,sz);

-    }

-    return Success;

-}

-

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

-

-Status

-XkbSetGeometry(Display *dpy,unsigned deviceSpec,XkbGeometryPtr geom)

-{

-xkbSetGeometryReq	*req;

-Status ret;

-

-    if ( (!geom) || (dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-

-    LockDisplay(dpy);

-    GetReq(kbSetGeometry, req);

-    req->reqType = dpy->xkb_info->codes->major_opcode;

-    req->xkbReqType = X_kbSetGeometry;

-    req->deviceSpec = deviceSpec;

-    req->nShapes= geom->num_shapes;

-    req->nSections= geom->num_sections;

-    req->name= geom->name;

-    req->widthMM= geom->width_mm;

-    req->heightMM= geom->height_mm;

-    req->nProperties= geom->num_properties;

-    req->nColors= geom->num_colors;

-    req->nDoodads= geom->num_doodads;

-    req->nKeyAliases= geom->num_key_aliases;

-    req->baseColorNdx= (geom->base_color-geom->colors);

-    req->labelColorNdx= (geom->label_color-geom->colors);

-

-    ret = _SendSetGeometry(dpy,geom,req);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return ret;

-}

-

+/************************************************************
+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 DEBUG
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#endif
+
+#include "Xlibint.h"
+#include "XKBlibint.h"
+#include <X11/extensions/XKBgeom.h>
+#include <X11/extensions/XKBproto.h>
+
+#ifndef MINSHORT
+#define	MINSHORT	-32768
+#endif
+#ifndef MAXSHORT
+#define	MAXSHORT	32767
+#endif
+
+/***====================================================================***/
+
+#define	_SizeCountedString(s)  ((s)?XkbPaddedSize(2+strlen(s)):4)
+
+static char *
+_WriteCountedString(char *wire,char *str)
+{
+CARD16	len,*pLen;
+
+    len= (str?strlen(str):0);
+    pLen= (CARD16 *)wire;
+    *pLen= len;
+    if (len && str)
+	memcpy(&wire[2],str,len);
+    wire+= XkbPaddedSize(len+2);
+    return wire;
+}
+
+static int
+_SizeGeomProperties(XkbGeometryPtr geom)
+{
+register int 	i,size;
+XkbPropertyPtr	prop;
+
+    for (size=i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
+	size+= _SizeCountedString(prop->name);
+	size+= _SizeCountedString(prop->value);
+    }
+    return size;
+}
+
+static int
+_SizeGeomColors(XkbGeometryPtr geom)
+{
+register int 		i,size;
+register XkbColorPtr	color;
+
+    for (i=size=0,color=geom->colors;i<geom->num_colors;i++,color++) {
+	size+= _SizeCountedString(color->spec);
+    }
+    return size;
+}
+
+static int
+_SizeGeomShapes(XkbGeometryPtr geom)
+{
+register int		i,size;
+register XkbShapePtr	shape;
+
+    for (i=size=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
+	register int		n;
+	register XkbOutlinePtr	ol;
+	size+= SIZEOF(xkbShapeWireDesc);
+	for (n=0,ol=shape->outlines;n<shape->num_outlines;n++,ol++) {
+	    size+= SIZEOF(xkbOutlineWireDesc);
+	    size+= ol->num_points*SIZEOF(xkbPointWireDesc);
+	}
+    }
+    return size;
+}
+
+static int
+_SizeGeomDoodads(int num_doodads,XkbDoodadPtr doodad)
+{
+register int	i,size;
+
+    for (i=size=0;i<num_doodads;i++,doodad++) {
+	size+= SIZEOF(xkbAnyDoodadWireDesc);
+	if (doodad->any.type==XkbTextDoodad) {
+	    size+= _SizeCountedString(doodad->text.text);
+	    size+= _SizeCountedString(doodad->text.font);
+	}
+	else if (doodad->any.type==XkbLogoDoodad) {
+	    size+= _SizeCountedString(doodad->logo.logo_name);
+	}
+    }
+    return size;
+}
+
+static int
+_SizeGeomSections(XkbGeometryPtr geom)
+{
+register int 	i,size;
+XkbSectionPtr	section;
+
+    for (i=size=0,section=geom->sections;i<geom->num_sections;i++,section++) {
+	size+= SIZEOF(xkbSectionWireDesc);
+	if (section->rows) {
+	    int		r;
+	    XkbRowPtr	row;
+	    for (r=0,row=section->rows;r<section->num_rows;row++,r++) {
+		size+= SIZEOF(xkbRowWireDesc);
+		size+= row->num_keys*SIZEOF(xkbKeyWireDesc);
+	    }
+	}
+	if (section->doodads)
+	    size+= _SizeGeomDoodads(section->num_doodads,section->doodads);
+	if (section->overlays) {
+	    int			o;
+	    XkbOverlayPtr	ol;
+	    for (o=0,ol=section->overlays;o<section->num_overlays;o++,ol++) {
+		int			r;
+		XkbOverlayRowPtr	row;
+		size+= SIZEOF(xkbOverlayWireDesc);
+		for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
+		   size+= SIZEOF(xkbOverlayRowWireDesc);
+		   size+= row->num_keys*SIZEOF(xkbOverlayKeyWireDesc);
+		}
+	    }
+	}
+    }
+    return size;
+}
+
+static int
+_SizeGeomKeyAliases(XkbGeometryPtr geom)
+{
+    return geom->num_key_aliases*(2*XkbKeyNameLength);
+}
+
+/***====================================================================***/
+
+static char *
+_WriteGeomProperties(char *wire,XkbGeometryPtr geom)
+{
+register int 	i;
+register XkbPropertyPtr	prop;
+
+    for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
+	wire= _WriteCountedString(wire,prop->name);
+	wire= _WriteCountedString(wire,prop->value);
+    }
+    return wire;
+}
+
+static char *
+_WriteGeomColors(char *wire,XkbGeometryPtr geom)
+{
+register int		i;
+register XkbColorPtr	color;
+
+    for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
+	wire= _WriteCountedString(wire,color->spec);
+    }
+    return wire;
+}
+
+static char *
+_WriteGeomShapes(char *wire,XkbGeometryPtr geom)
+{
+int			i;
+XkbShapePtr		shape;
+xkbShapeWireDesc *	shapeWire;
+
+    for (i=0,shape=geom->shapes;i<geom->num_shapes;i++,shape++) {
+	register int 		o;
+	XkbOutlinePtr		ol;
+	xkbOutlineWireDesc *	olWire;
+	shapeWire= (xkbShapeWireDesc *)wire;
+	shapeWire->name= shape->name;
+	shapeWire->nOutlines= shape->num_outlines;
+	if (shape->primary!=NULL)
+	     shapeWire->primaryNdx= XkbOutlineIndex(shape,shape->primary);
+	else shapeWire->primaryNdx= XkbNoShape;
+	if (shape->approx!=NULL)
+	     shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);
+	else shapeWire->approxNdx= XkbNoShape;
+	wire= (char *)&shapeWire[1];
+	for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
+	    register int	p;
+	    XkbPointPtr		pt;
+	    xkbPointWireDesc *	ptWire;
+	    olWire= (xkbOutlineWireDesc *)wire;
+	    olWire->nPoints= ol->num_points;
+	    olWire->cornerRadius= ol->corner_radius;
+	    wire= (char *)&olWire[1];
+	    ptWire= (xkbPointWireDesc *)wire;
+	    for (p=0,pt=ol->points;p<ol->num_points;p++,pt++) {
+		ptWire[p].x= pt->x;
+		ptWire[p].y= pt->y;
+	    }
+	    wire= (char *)&ptWire[ol->num_points];
+	}
+    }
+    return wire;
+}
+
+static char *
+_WriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad)
+{
+register int		i;
+xkbDoodadWireDesc *	doodadWire;
+
+    for (i=0;i<num_doodads;i++,doodad++) {
+	doodadWire= (xkbDoodadWireDesc *)wire;
+	wire= (char *)&doodadWire[1];
+	bzero(doodadWire,SIZEOF(xkbDoodadWireDesc));
+	doodadWire->any.name= doodad->any.name;
+	doodadWire->any.type= doodad->any.type;
+	doodadWire->any.priority= doodad->any.priority;
+	doodadWire->any.top= doodad->any.top;
+	doodadWire->any.left= doodad->any.left;
+	doodadWire->any.angle= doodad->any.angle;
+	switch (doodad->any.type) {
+	    case XkbOutlineDoodad:
+	    case XkbSolidDoodad:
+		doodadWire->shape.colorNdx= doodad->shape.color_ndx;
+		doodadWire->shape.shapeNdx= doodad->shape.shape_ndx;
+		break;
+	    case XkbTextDoodad:
+		doodadWire->text.width= doodad->text.width;
+		doodadWire->text.height= doodad->text.height;
+		doodadWire->text.colorNdx= doodad->text.color_ndx;
+		wire= _WriteCountedString(wire,doodad->text.text);
+		wire= _WriteCountedString(wire,doodad->text.font);
+		break;
+	    case XkbIndicatorDoodad:
+		doodadWire->indicator.shapeNdx= doodad->indicator.shape_ndx;
+		doodadWire->indicator.onColorNdx=doodad->indicator.on_color_ndx;
+		doodadWire->indicator.offColorNdx=
+						doodad->indicator.off_color_ndx;
+		break;
+	    case XkbLogoDoodad:
+		doodadWire->logo.colorNdx= doodad->logo.color_ndx;
+		doodadWire->logo.shapeNdx= doodad->logo.shape_ndx;
+		wire= _WriteCountedString(wire,doodad->logo.logo_name);
+		break;
+	    default:
+		break;
+	}
+    }
+    return wire;
+}
+
+static char *
+_WriteGeomOverlay(char *wire,XkbOverlayPtr ol)
+{
+register int		r;
+XkbOverlayRowPtr	row;
+xkbOverlayWireDesc *	olWire;
+
+   olWire= (xkbOverlayWireDesc *)wire;
+   olWire->name= ol->name;
+   olWire->nRows= ol->num_rows;
+   wire= (char *)&olWire[1];
+   for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
+   	unsigned int		k;
+	XkbOverlayKeyPtr	key;
+	xkbOverlayRowWireDesc *	rowWire;
+	rowWire= (xkbOverlayRowWireDesc *)wire;
+	rowWire->rowUnder= row->row_under;
+	rowWire->nKeys= row->num_keys;
+	wire= (char *)&rowWire[1];
+	for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
+	    xkbOverlayKeyWireDesc *	keyWire;
+	    keyWire= (xkbOverlayKeyWireDesc *)wire;
+	    memcpy(keyWire->over,key->over.name,XkbKeyNameLength);
+	    memcpy(keyWire->under,key->under.name,XkbKeyNameLength);
+	    wire= (char *)&keyWire[1];
+	}
+   }
+   return wire;
+}
+
+static char *
+_WriteGeomSections(char *wire,XkbGeometryPtr geom)
+{
+register int		i;
+XkbSectionPtr		section;
+xkbSectionWireDesc *	sectionWire;
+
+    for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
+	sectionWire= (xkbSectionWireDesc *)wire;
+	sectionWire->name= section->name;
+	sectionWire->top= section->top;
+	sectionWire->left= section->left;
+	sectionWire->width= section->width;
+	sectionWire->height= section->height;
+	sectionWire->angle= section->angle;
+	sectionWire->priority= section->priority;
+	sectionWire->nRows= section->num_rows;
+	sectionWire->nDoodads= section->num_doodads;
+	sectionWire->nOverlays= section->num_overlays;
+	sectionWire->pad= 0;
+	wire= (char *)&sectionWire[1];
+	if (section->rows) {
+	    int			r;
+	    XkbRowPtr		row;
+	    xkbRowWireDesc *	rowWire;
+	    for (r=0,row=section->rows;r<section->num_rows;r++,row++) {
+		rowWire= (xkbRowWireDesc *)wire;
+		rowWire->top= row->top;
+		rowWire->left= row->left;
+		rowWire->nKeys= row->num_keys;
+		rowWire->vertical= row->vertical;
+		rowWire->pad= 0;
+		wire= (char *)&rowWire[1];
+		if (row->keys) {
+		    int			k;
+		    XkbKeyPtr		key;
+		    xkbKeyWireDesc *	keyWire;
+		    keyWire= (xkbKeyWireDesc *)wire;
+		    for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
+			memcpy(keyWire[k].name,key->name.name,XkbKeyNameLength);
+			keyWire[k].gap= key->gap;
+			keyWire[k].shapeNdx= key->shape_ndx;
+			keyWire[k].colorNdx= key->color_ndx;
+		    }
+		    wire= (char *)&keyWire[row->num_keys];
+		}
+	    }
+	}
+	if (section->doodads) {
+	    wire= _WriteGeomDoodads(wire,
+	    			      section->num_doodads,section->doodads);
+	}
+	if (section->overlays) {
+	    register int o;
+	    for (o=0;o<section->num_overlays;o++) {
+		wire= _WriteGeomOverlay(wire,&section->overlays[o]);
+	    }
+	}
+    }
+    return wire;
+}
+
+static char *
+_WriteGeomKeyAliases(char *wire,XkbGeometryPtr geom)
+{
+register int sz;
+
+    sz= geom->num_key_aliases*(XkbKeyNameLength*2);
+    if (sz>0) {
+	memcpy(wire,(char *)geom->key_aliases,sz);
+	wire+= sz;
+    }
+    return wire;
+}
+
+/***====================================================================***/
+
+static Status
+_SendSetGeometry(Display *dpy,XkbGeometryPtr geom,xkbSetGeometryReq *req)
+{
+int			sz;
+char *			wire,*tbuf;
+
+    sz= 0;
+    sz+= _SizeCountedString(geom->label_font);
+    sz+= _SizeGeomProperties(geom);
+    sz+= _SizeGeomColors(geom);
+    sz+= _SizeGeomShapes(geom);
+    sz+= _SizeGeomSections(geom);
+    sz+= _SizeGeomDoodads(geom->num_doodads,geom->doodads);
+    sz+= _SizeGeomKeyAliases(geom);
+    req->length+= (sz/4);
+    if (sz < (dpy->bufmax - dpy->buffer)) {
+	BufAlloc(char *,wire,sz);
+	tbuf= NULL;
+    }
+    else {
+	tbuf= _XAllocTemp(dpy,sz);
+	if (!tbuf)
+	    return BadAlloc;
+	wire= tbuf;
+    }
+    wire= _WriteCountedString(wire,geom->label_font);
+    if (geom->num_properties>0)
+	wire= _WriteGeomProperties(wire,geom);
+    if (geom->num_colors>0)
+	wire= _WriteGeomColors(wire,geom);
+    if (geom->num_shapes>0)
+	wire= _WriteGeomShapes(wire,geom);
+    if (geom->num_sections>0)
+	wire= _WriteGeomSections(wire,geom);
+    if (geom->num_doodads>0)
+	wire= _WriteGeomDoodads(wire,geom->num_doodads,geom->doodads);
+    if (geom->num_key_aliases>0)
+	wire= _WriteGeomKeyAliases(wire,geom);
+    if (tbuf!=NULL) {
+	Data(dpy,tbuf,sz);
+	_XFreeTemp(dpy,tbuf,sz);
+    }
+    return Success;
+}
+
+/***====================================================================***/
+
+Status
+XkbSetGeometry(Display *dpy,unsigned deviceSpec,XkbGeometryPtr geom)
+{
+xkbSetGeometryReq	*req;
+Status ret;
+
+    if ( (!geom) || (dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+
+    LockDisplay(dpy);
+    GetReq(kbSetGeometry, req);
+    req->reqType = dpy->xkb_info->codes->major_opcode;
+    req->xkbReqType = X_kbSetGeometry;
+    req->deviceSpec = deviceSpec;
+    req->nShapes= geom->num_shapes;
+    req->nSections= geom->num_sections;
+    req->name= geom->name;
+    req->widthMM= geom->width_mm;
+    req->heightMM= geom->height_mm;
+    req->nProperties= geom->num_properties;
+    req->nColors= geom->num_colors;
+    req->nDoodads= geom->num_doodads;
+    req->nKeyAliases= geom->num_key_aliases;
+    req->baseColorNdx= (geom->base_color-geom->colors);
+    req->labelColorNdx= (geom->label_color-geom->colors);
+
+    ret = _SendSetGeometry(dpy,geom,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return ret;
+}
+
diff --git a/libX11/src/xkb/XKBSetMap.c b/libX11/src/xkb/XKBSetMap.c
index 8adfe5446..cad9364b7 100644
--- a/libX11/src/xkb/XKBSetMap.c
+++ b/libX11/src/xkb/XKBSetMap.c
@@ -1,591 +1,591 @@
-/************************************************************

-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 <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-static int

-_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    XkbKeyTypePtr	map;

-    int			i,len;

-

-    if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {

-	req->present&= ~XkbKeyTypesMask;

-	req->firstType= req->nTypes= 0;

-	return 0;

-    }

-    len= 0;

-    map= &xkb->map->types[req->firstType];

-    for (i=0;i<req->nTypes;i++,map++){

-	len+= SIZEOF(xkbKeyTypeWireDesc);

-	len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);

-	if (map->preserve)

-	    len+= map->map_count*SIZEOF(xkbModsWireDesc);

-    }

-    return len;

-}

-

-static void

-_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    char *		buf;

-    XkbKeyTypePtr 	type;

-    int			i,n,sz;

-    xkbKeyTypeWireDesc *desc;

-

-    if ((req->present&XkbKeyTypesMask)==0)

-	return;

-    type= &xkb->map->types[req->firstType];

-    for (i=0;i<req->nTypes;i++,type++) {

-	sz= SIZEOF(xkbKeyTypeWireDesc);

-	sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);

-	if (type->preserve)

-	    sz+= type->map_count*SIZEOF(xkbModsWireDesc);

-	BufAlloc(xkbKeyTypeWireDesc *,desc,sz);

-	desc->mask = type->mods.mask;

-	desc->realMods = type->mods.real_mods;

-	desc->virtualMods = type->mods.vmods;

-	desc->numLevels = type->num_levels;

-	desc->nMapEntries = type->map_count;

-	desc->preserve = (type->preserve!=NULL);

-	buf= (char *)&desc[1];

-	if (desc->nMapEntries>0) {

-	    xkbKTSetMapEntryWireDesc *wire;

-	    wire= (xkbKTSetMapEntryWireDesc *)buf;

-	    for (n=0;n<type->map_count;n++,wire++) {

-		wire->level= type->map[n].level;

-		wire->realMods= type->map[n].mods.real_mods;

-		wire->virtualMods= type->map[n].mods.vmods;

-	    }

-	    buf= (char *)wire;

-	    if (type->preserve) {

-		xkbModsWireDesc *pwire;

-		pwire= (xkbModsWireDesc *)buf;

-		for (n=0;n<type->map_count;n++,pwire++) {

-		    pwire->realMods= type->preserve[n].real_mods;

-		    pwire->virtualMods= type->preserve[n].vmods;

-		}

-	    }

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    int			i,len;

-    unsigned		nSyms;

-

-    if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {

-	req->present&= ~XkbKeySymsMask;

-	req->firstKeySym= req->nKeySyms= 0;

-	req->totalSyms= 0;

-	return 0;

-    }

-    len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));

-    for (i=nSyms=0;i<req->nKeySyms;i++) {

-	nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);

-    }

-    len+= nSyms*sizeof(CARD32);

-    req->totalSyms= nSyms;

-    return len;

-}

-

-static void

-_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register KeySym *	pSym;

-CARD32 *		outSym;

-XkbSymMapPtr		symMap;

-xkbSymMapWireDesc *desc;

-register int	i;

-

-    if ((req->present&XkbKeySymsMask)==0)

-	return;

-    symMap = &xkb->map->key_sym_map[req->firstKeySym];

-    for (i=0;i<req->nKeySyms;i++,symMap++) {

-	BufAlloc(xkbSymMapWireDesc *,desc,

-		 SIZEOF(xkbSymMapWireDesc)+

-		 (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));

-	desc->ktIndex[0] = symMap->kt_index[0];

-	desc->ktIndex[1] = symMap->kt_index[1];

-	desc->ktIndex[2] = symMap->kt_index[2];

-	desc->ktIndex[3] = symMap->kt_index[3];

-	desc->groupInfo = symMap->group_info;

-	desc->width = symMap->width;

-	desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);

-	outSym = (CARD32 *)&desc[1];

-	if (desc->nSyms>0) {

-	     pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);

-	    _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    int			i,len,nActs;

-

-    if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {

-	req->present&= ~XkbKeyActionsMask;

-	req->firstKeyAct= req->nKeyActs= 0;

-	req->totalActs= 0;

-	return 0;

-    }

-    for (nActs=i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]!=0)

-	    nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);

-    }

-    len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));

-    req->totalActs= nActs;

-    return len;

-}

-

-static void

-_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-    register int	 i;

-    int	 		 n;

-    CARD8		*numDesc;

-    XkbAction		*actDesc;

-

-    if ((req->present&XkbKeyActionsMask)==0)

-	return;

-    n = XkbPaddedSize(req->nKeyActs);

-    n+= (req->totalActs*SIZEOF(xkbActionWireDesc));

-

-    BufAlloc(CARD8 *,numDesc,n);

-    for (i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]==0)

-	     numDesc[i] = 0;

-	else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));

-    }

-    actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];

-    for (i=0;i<req->nKeyActs;i++) {

-	if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {

-	    n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));

-	    memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),

-                                                   n*SIZEOF(xkbActionWireDesc));

-	    actDesc+= n;

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyBehaviors(XkbDescPtr	xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {

-	req->present&= ~XkbKeyBehaviorsMask;

-	req->firstKeyBehavior= req->nKeyBehaviors= 0;

-	req->totalKeyBehaviors= 0;

-	return 0;

-    }

-    first= req->firstKeyBehavior;

-    last= first+req->nKeyBehaviors-1;

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->behaviors[i].type!=XkbKB_Default)

-	    nFound++;

-    }

-    req->totalKeyBehaviors= nFound;

-    return (nFound*SIZEOF(xkbBehaviorWireDesc));

-}

-

-static void

-_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int 		i,first,last;

-xkbBehaviorWireDesc *	wire;

-char *			buf;

-

-    if ((req->present&XkbKeyBehaviorsMask)==0)

-	return;

-    first= req->firstKeyBehavior;

-    last= first+req->nKeyBehaviors-1;

-

-    i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);

-    BufAlloc(char *,buf,i);

-    wire= (xkbBehaviorWireDesc *)buf;

-    for (i=first;i<=last;i++) {

-	if (xkb->server->behaviors[i].type!=XkbKB_Default) {

-	    wire->key= i;

-	    wire->type= xkb->server->behaviors[i].type;

-	    wire->data= xkb->server->behaviors[i].data;

-	    buf+= SIZEOF(xkbBehaviorWireDesc);

-	    wire= (xkbBehaviorWireDesc *)buf;

-	}

-    }

-    return;

-}

-

-static unsigned

-_XkbSizeVirtualMods(xkbSetMapReq *req)

-{

-register int i,bit,nMods;

-

-   if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {

-	req->present&= ~XkbVirtualModsMask;

-	req->virtualMods= 0;

-	return 0;

-   }

-   for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {

-	if (req->virtualMods&bit)

-	    nMods++;

-   }

-   return XkbPaddedSize(nMods);

-}

-

-static void

-_XkbWriteVirtualMods(	Display *	dpy,

-			XkbDescPtr 	xkb,

-			xkbSetMapReq *	req,

-			unsigned 	size)

-{

-    register int	 i,bit;

-    CARD8		*vmods;

-

-    /* This was req->present&XkbVirtualModsMask==0, and '==' beats '&' */

-    if (((req->present & XkbVirtualModsMask) == 0) || (size < 1))

-	return;

-    BufAlloc(CARD8 *,vmods,size);

-    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {

-	if (req->virtualMods&bit)

-	    *vmods++= xkb->server->vmods[i];

-    }

-    return;

-}

-

-static int

-_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {

-	req->present&= ~XkbExplicitComponentsMask;

-	req->firstKeyExplicit= req->nKeyExplicit= 0;

-	req->totalKeyExplicit= 0;

-	return 0;

-    }

-    first= req->firstKeyExplicit;

-    last= first+req->nKeyExplicit-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->explicit[i]!=0)

-	    nFound++;

-    }

-    req->totalKeyExplicit= nFound;

-    return XkbPaddedSize((nFound*2));

-}

-

-static void

-_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int	i,first,last;

-CARD8 *		wire;

-

-    if ((req->present&XkbExplicitComponentsMask)==0)

-	return;

-    first= req->firstKeyExplicit;

-    last= first+req->nKeyExplicit - 1;

-    i= XkbPaddedSize((req->totalKeyExplicit*2));

-    BufAlloc(CARD8 *,wire,i);

-    for (i=first;i<=last;i++) {

-	if (xkb->server->explicit[i]!=0) {

-	    wire[0]= i;

-	    wire[1]= xkb->server->explicit[i];

-	    wire+= 2;

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {

-	req->present&= ~XkbModifierMapMask;

-	req->firstModMapKey= req->nModMapKeys= 0;

-	req->totalModMapKeys= 0;

-	return 0;

-    }

-    first= req->firstModMapKey;

-    last= first+req->nModMapKeys-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->map->modmap[i]!=0)

-	    nFound++;

-    }

-    req->totalModMapKeys= nFound;

-    return XkbPaddedSize((nFound*2));

-}

-

-static void

-_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int	i,first,last;

-CARD8 *		wire;

-

-    if ((req->present&XkbModifierMapMask)==0)

-	return;

-    first= req->firstModMapKey;

-    last= first+req->nModMapKeys-1;

-    if (req->totalModMapKeys>0) {

-	i= XkbPaddedSize((req->totalModMapKeys*2));

-	BufAlloc(CARD8 *,wire,i);

-	for (i=first;i<=last;i++) {

-	    if (xkb->map->modmap[i]!=0) {

-		wire[0]= i;

-		wire[1]= xkb->map->modmap[i];

-		wire+= 2;

-	    }

-	}

-    }

-    return;

-}

-

-static int

-_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int i,first,last,nFound;

-

-    if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {

-	req->present&= ~XkbVirtualModMapMask;

-	req->firstVModMapKey= req->nVModMapKeys= 0;

-	req->totalVModMapKeys= 0;

-	return 0;

-    }

-    first= req->firstVModMapKey;

-    last= first+req->nVModMapKeys-1;

-

-    for (i=first,nFound=0;i<=last;i++) {

-	if (xkb->server->vmodmap[i]!=0)

-	    nFound++;

-    }

-    req->totalVModMapKeys= nFound;

-    return nFound*SIZEOF(xkbVModMapWireDesc);

-}

-

-static void

-_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-register int		i,first,last;

-xkbVModMapWireDesc *	wire;

-

-    if ((req->present&XkbVirtualModMapMask)==0)

-	return;

-    first= req->firstVModMapKey;

-    last= first+req->nVModMapKeys-1;

-    if (req->totalVModMapKeys>0) {

-	i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);

-	BufAlloc(xkbVModMapWireDesc *,wire,i);

-	for (i=first;i<=last;i++) {

-	    if (xkb->server->vmodmap[i]!=0) {

-		wire->key= i;

-		wire->vmods= xkb->server->vmodmap[i];

-		wire++;

-	    }

-	}

-    }

-    return;

-}

-

-static void

-SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)

-{

-xkbSetMapReq tmp;

-unsigned szMods;

-

-    req->length+= _XkbSizeKeyTypes(xkb,req)/4;

-    req->length+= _XkbSizeKeySyms(xkb,req)/4;

-    req->length+= _XkbSizeKeyActions(xkb,req)/4;

-    req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;

-    szMods= _XkbSizeVirtualMods(req);

-    req->length+= szMods/4;

-    req->length+= _XkbSizeKeyExplicit(xkb,req)/4;

-    req->length+= _XkbSizeModifierMap(xkb,req)/4;

-    req->length+= _XkbSizeVirtualModMap(xkb,req)/4;

-

-    tmp= *req;

-    if ( tmp.nTypes>0 )

-	_XkbWriteKeyTypes(dpy,xkb,&tmp);

-    if ( tmp.nKeySyms>0 )

-	_XkbWriteKeySyms(dpy,xkb,&tmp);

-    if ( tmp.nKeyActs )

-	_XkbWriteKeyActions(dpy,xkb,&tmp);

-    if ( tmp.totalKeyBehaviors>0 )

-	_XkbWriteKeyBehaviors(dpy,xkb,&tmp);

-    if ( tmp.virtualMods )

-	_XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);

-    if ( tmp.totalKeyExplicit>0)

-	_XkbWriteKeyExplicit(dpy,xkb,&tmp);

-    if ( tmp.totalModMapKeys>0)

-	_XkbWriteModifierMap(dpy,xkb,&tmp);

-    if ( tmp.totalVModMapKeys>0)

-	_XkbWriteVirtualModMap(dpy,xkb,&tmp);

-    return;

-}

-

-Bool

-XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)

-{

-register xkbSetMapReq *	req;

-XkbInfoPtr 		xkbi;

-XkbServerMapPtr		srv;

-XkbClientMapPtr		map;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||

-	(!xkb))

-	return False;

-    map= xkb->map;

-    srv= xkb->server;

-

-    if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||

-	((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||

-	((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||

-	((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||

-	((which&XkbVirtualModsMask)&&(!srv))||

-	((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||

-	((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||

-	((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))

-	return False;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetMap;

-    req->deviceSpec = xkb->device_spec;

-    req->present = which;

-    req->flags = XkbSetMapAllFlags;

-    req->minKeyCode= xkb->min_key_code;

-    req->maxKeyCode= xkb->max_key_code;

-    req->firstType = 0;

-    if (which&XkbKeyTypesMask)	req->nTypes = map->num_types;

-    else			req->nTypes = 0;

-    if (which&XkbKeySymsMask) {

-	req->firstKeySym = xkb->min_key_code;

-	req->nKeySyms = XkbNumKeys(xkb);

-    }

-    if (which&XkbKeyActionsMask) {

-	req->firstKeyAct = xkb->min_key_code;

-	req->nKeyActs = XkbNumKeys(xkb);

-    }

-    if (which&XkbKeyBehaviorsMask) {

-	req->firstKeyBehavior = xkb->min_key_code;

-	req->nKeyBehaviors = XkbNumKeys(xkb);

-    }

-    if (which&XkbVirtualModsMask)

-	req->virtualMods= ~0;

-    if (which&XkbExplicitComponentsMask) {

-	req->firstKeyExplicit= xkb->min_key_code;

-	req->nKeyExplicit = XkbNumKeys(xkb);

-    }

-    if (which&XkbModifierMapMask) {

-	req->firstModMapKey= xkb->min_key_code;

-	req->nModMapKeys = XkbNumKeys(xkb);

-    }

-    if (which&XkbVirtualModMapMask) {

-	req->firstVModMapKey= xkb->min_key_code;

-	req->nVModMapKeys = XkbNumKeys(xkb);

-    }

-    SendSetMap(dpy,xkb,req);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)

-{

-register xkbSetMapReq *	req;

-XkbInfoPtr 		xkbi;

-XkbServerMapPtr		srv;

-XkbClientMapPtr		map;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||

-	(!xkb)||(!changes))

-	return False;

-    srv= xkb->server;

-    map= xkb->map;

-

-    if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||

-	((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||

-				(!map->key_sym_map)))||

-	((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||

-	((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||

-	((changes->changed&XkbVirtualModsMask)&&(!srv))||

-	((changes->changed&XkbExplicitComponentsMask)&&

-				((!srv)||(!srv->explicit)))||

-	((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||

-	((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))

-	return False;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetMap;

-    req->deviceSpec = xkb->device_spec;

-    req->present = changes->changed;

-    req->flags = XkbSetMapRecomputeActions;

-    req->minKeyCode= xkb->min_key_code;

-    req->maxKeyCode= xkb->max_key_code;

-    req->firstType = changes->first_type;

-    req->nTypes = changes->num_types;

-    req->firstKeySym = changes->first_key_sym;

-    req->nKeySyms = changes->num_key_syms;

-    req->firstKeyAct = changes->first_key_act;

-    req->nKeyActs = changes->num_key_acts;

-    req->firstKeyBehavior = changes->first_key_behavior;

-    req->nKeyBehaviors = changes->num_key_behaviors;

-    req->virtualMods = changes->vmods;

-    req->firstKeyExplicit = changes->first_key_explicit;

-    req->nKeyExplicit = changes->num_key_explicit;

-    req->firstModMapKey = changes->first_modmap_key;

-    req->nModMapKeys = changes->num_modmap_keys;

-    req->firstVModMapKey = changes->first_vmodmap_key;

-    req->nVModMapKeys = changes->num_vmodmap_keys;

-    SendSetMap(dpy,xkb,req);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

+/************************************************************
+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 <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+static int
+_XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    XkbKeyTypePtr	map;
+    int			i,len;
+
+    if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {
+	req->present&= ~XkbKeyTypesMask;
+	req->firstType= req->nTypes= 0;
+	return 0;
+    }
+    len= 0;
+    map= &xkb->map->types[req->firstType];
+    for (i=0;i<req->nTypes;i++,map++){
+	len+= SIZEOF(xkbKeyTypeWireDesc);
+	len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
+	if (map->preserve)
+	    len+= map->map_count*SIZEOF(xkbModsWireDesc);
+    }
+    return len;
+}
+
+static void
+_XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    char *		buf;
+    XkbKeyTypePtr 	type;
+    int			i,n,sz;
+    xkbKeyTypeWireDesc *desc;
+
+    if ((req->present&XkbKeyTypesMask)==0)
+	return;
+    type= &xkb->map->types[req->firstType];
+    for (i=0;i<req->nTypes;i++,type++) {
+	sz= SIZEOF(xkbKeyTypeWireDesc);
+	sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
+	if (type->preserve)
+	    sz+= type->map_count*SIZEOF(xkbModsWireDesc);
+	BufAlloc(xkbKeyTypeWireDesc *,desc,sz);
+	desc->mask = type->mods.mask;
+	desc->realMods = type->mods.real_mods;
+	desc->virtualMods = type->mods.vmods;
+	desc->numLevels = type->num_levels;
+	desc->nMapEntries = type->map_count;
+	desc->preserve = (type->preserve!=NULL);
+	buf= (char *)&desc[1];
+	if (desc->nMapEntries>0) {
+	    xkbKTSetMapEntryWireDesc *wire;
+	    wire= (xkbKTSetMapEntryWireDesc *)buf;
+	    for (n=0;n<type->map_count;n++,wire++) {
+		wire->level= type->map[n].level;
+		wire->realMods= type->map[n].mods.real_mods;
+		wire->virtualMods= type->map[n].mods.vmods;
+	    }
+	    buf= (char *)wire;
+	    if (type->preserve) {
+		xkbModsWireDesc *pwire;
+		pwire= (xkbModsWireDesc *)buf;
+		for (n=0;n<type->map_count;n++,pwire++) {
+		    pwire->realMods= type->preserve[n].real_mods;
+		    pwire->virtualMods= type->preserve[n].vmods;
+		}
+	    }
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    int			i,len;
+    unsigned		nSyms;
+
+    if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
+	req->present&= ~XkbKeySymsMask;
+	req->firstKeySym= req->nKeySyms= 0;
+	req->totalSyms= 0;
+	return 0;
+    }
+    len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));
+    for (i=nSyms=0;i<req->nKeySyms;i++) {
+	nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);
+    }
+    len+= nSyms*sizeof(CARD32);
+    req->totalSyms= nSyms;
+    return len;
+}
+
+static void
+_XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register KeySym *	pSym;
+CARD32 *		outSym;
+XkbSymMapPtr		symMap;
+xkbSymMapWireDesc *desc;
+register int	i;
+
+    if ((req->present&XkbKeySymsMask)==0)
+	return;
+    symMap = &xkb->map->key_sym_map[req->firstKeySym];
+    for (i=0;i<req->nKeySyms;i++,symMap++) {
+	BufAlloc(xkbSymMapWireDesc *,desc,
+		 SIZEOF(xkbSymMapWireDesc)+
+		 (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));
+	desc->ktIndex[0] = symMap->kt_index[0];
+	desc->ktIndex[1] = symMap->kt_index[1];
+	desc->ktIndex[2] = symMap->kt_index[2];
+	desc->ktIndex[3] = symMap->kt_index[3];
+	desc->groupInfo = symMap->group_info;
+	desc->width = symMap->width;
+	desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);
+	outSym = (CARD32 *)&desc[1];
+	if (desc->nSyms>0) {
+	     pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);
+	    _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    int			i,len,nActs;
+
+    if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
+	req->present&= ~XkbKeyActionsMask;
+	req->firstKeyAct= req->nKeyActs= 0;
+	req->totalActs= 0;
+	return 0;
+    }
+    for (nActs=i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]!=0)
+	    nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);
+    }
+    len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
+    req->totalActs= nActs;
+    return len;
+}
+
+static void
+_XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+    register int	 i;
+    int	 		 n;
+    CARD8		*numDesc;
+    XkbAction		*actDesc;
+
+    if ((req->present&XkbKeyActionsMask)==0)
+	return;
+    n = XkbPaddedSize(req->nKeyActs);
+    n+= (req->totalActs*SIZEOF(xkbActionWireDesc));
+
+    BufAlloc(CARD8 *,numDesc,n);
+    for (i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]==0)
+	     numDesc[i] = 0;
+	else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
+    }
+    actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];
+    for (i=0;i<req->nKeyActs;i++) {
+	if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {
+	    n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
+	    memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),
+                                                   n*SIZEOF(xkbActionWireDesc));
+	    actDesc+= n;
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyBehaviors(XkbDescPtr	xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
+	req->present&= ~XkbKeyBehaviorsMask;
+	req->firstKeyBehavior= req->nKeyBehaviors= 0;
+	req->totalKeyBehaviors= 0;
+	return 0;
+    }
+    first= req->firstKeyBehavior;
+    last= first+req->nKeyBehaviors-1;
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->behaviors[i].type!=XkbKB_Default)
+	    nFound++;
+    }
+    req->totalKeyBehaviors= nFound;
+    return (nFound*SIZEOF(xkbBehaviorWireDesc));
+}
+
+static void
+_XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int 		i,first,last;
+xkbBehaviorWireDesc *	wire;
+char *			buf;
+
+    if ((req->present&XkbKeyBehaviorsMask)==0)
+	return;
+    first= req->firstKeyBehavior;
+    last= first+req->nKeyBehaviors-1;
+
+    i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);
+    BufAlloc(char *,buf,i);
+    wire= (xkbBehaviorWireDesc *)buf;
+    for (i=first;i<=last;i++) {
+	if (xkb->server->behaviors[i].type!=XkbKB_Default) {
+	    wire->key= i;
+	    wire->type= xkb->server->behaviors[i].type;
+	    wire->data= xkb->server->behaviors[i].data;
+	    buf+= SIZEOF(xkbBehaviorWireDesc);
+	    wire= (xkbBehaviorWireDesc *)buf;
+	}
+    }
+    return;
+}
+
+static unsigned
+_XkbSizeVirtualMods(xkbSetMapReq *req)
+{
+register int i,bit,nMods;
+
+   if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {
+	req->present&= ~XkbVirtualModsMask;
+	req->virtualMods= 0;
+	return 0;
+   }
+   for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (req->virtualMods&bit)
+	    nMods++;
+   }
+   return XkbPaddedSize(nMods);
+}
+
+static void
+_XkbWriteVirtualMods(	Display *	dpy,
+			XkbDescPtr 	xkb,
+			xkbSetMapReq *	req,
+			unsigned 	size)
+{
+    register int	 i,bit;
+    CARD8		*vmods;
+
+    /* This was req->present&XkbVirtualModsMask==0, and '==' beats '&' */
+    if (((req->present & XkbVirtualModsMask) == 0) || (size < 1))
+	return;
+    BufAlloc(CARD8 *,vmods,size);
+    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (req->virtualMods&bit)
+	    *vmods++= xkb->server->vmods[i];
+    }
+    return;
+}
+
+static int
+_XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
+	req->present&= ~XkbExplicitComponentsMask;
+	req->firstKeyExplicit= req->nKeyExplicit= 0;
+	req->totalKeyExplicit= 0;
+	return 0;
+    }
+    first= req->firstKeyExplicit;
+    last= first+req->nKeyExplicit-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->explicit[i]!=0)
+	    nFound++;
+    }
+    req->totalKeyExplicit= nFound;
+    return XkbPaddedSize((nFound*2));
+}
+
+static void
+_XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int	i,first,last;
+CARD8 *		wire;
+
+    if ((req->present&XkbExplicitComponentsMask)==0)
+	return;
+    first= req->firstKeyExplicit;
+    last= first+req->nKeyExplicit - 1;
+    i= XkbPaddedSize((req->totalKeyExplicit*2));
+    BufAlloc(CARD8 *,wire,i);
+    for (i=first;i<=last;i++) {
+	if (xkb->server->explicit[i]!=0) {
+	    wire[0]= i;
+	    wire[1]= xkb->server->explicit[i];
+	    wire+= 2;
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {
+	req->present&= ~XkbModifierMapMask;
+	req->firstModMapKey= req->nModMapKeys= 0;
+	req->totalModMapKeys= 0;
+	return 0;
+    }
+    first= req->firstModMapKey;
+    last= first+req->nModMapKeys-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->map->modmap[i]!=0)
+	    nFound++;
+    }
+    req->totalModMapKeys= nFound;
+    return XkbPaddedSize((nFound*2));
+}
+
+static void
+_XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int	i,first,last;
+CARD8 *		wire;
+
+    if ((req->present&XkbModifierMapMask)==0)
+	return;
+    first= req->firstModMapKey;
+    last= first+req->nModMapKeys-1;
+    if (req->totalModMapKeys>0) {
+	i= XkbPaddedSize((req->totalModMapKeys*2));
+	BufAlloc(CARD8 *,wire,i);
+	for (i=first;i<=last;i++) {
+	    if (xkb->map->modmap[i]!=0) {
+		wire[0]= i;
+		wire[1]= xkb->map->modmap[i];
+		wire+= 2;
+	    }
+	}
+    }
+    return;
+}
+
+static int
+_XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int i,first,last,nFound;
+
+    if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {
+	req->present&= ~XkbVirtualModMapMask;
+	req->firstVModMapKey= req->nVModMapKeys= 0;
+	req->totalVModMapKeys= 0;
+	return 0;
+    }
+    first= req->firstVModMapKey;
+    last= first+req->nVModMapKeys-1;
+
+    for (i=first,nFound=0;i<=last;i++) {
+	if (xkb->server->vmodmap[i]!=0)
+	    nFound++;
+    }
+    req->totalVModMapKeys= nFound;
+    return nFound*SIZEOF(xkbVModMapWireDesc);
+}
+
+static void
+_XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+register int		i,first,last;
+xkbVModMapWireDesc *	wire;
+
+    if ((req->present&XkbVirtualModMapMask)==0)
+	return;
+    first= req->firstVModMapKey;
+    last= first+req->nVModMapKeys-1;
+    if (req->totalVModMapKeys>0) {
+	i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);
+	BufAlloc(xkbVModMapWireDesc *,wire,i);
+	for (i=first;i<=last;i++) {
+	    if (xkb->server->vmodmap[i]!=0) {
+		wire->key= i;
+		wire->vmods= xkb->server->vmodmap[i];
+		wire++;
+	    }
+	}
+    }
+    return;
+}
+
+static void
+SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
+{
+xkbSetMapReq tmp;
+unsigned szMods;
+
+    req->length+= _XkbSizeKeyTypes(xkb,req)/4;
+    req->length+= _XkbSizeKeySyms(xkb,req)/4;
+    req->length+= _XkbSizeKeyActions(xkb,req)/4;
+    req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;
+    szMods= _XkbSizeVirtualMods(req);
+    req->length+= szMods/4;
+    req->length+= _XkbSizeKeyExplicit(xkb,req)/4;
+    req->length+= _XkbSizeModifierMap(xkb,req)/4;
+    req->length+= _XkbSizeVirtualModMap(xkb,req)/4;
+
+    tmp= *req;
+    if ( tmp.nTypes>0 )
+	_XkbWriteKeyTypes(dpy,xkb,&tmp);
+    if ( tmp.nKeySyms>0 )
+	_XkbWriteKeySyms(dpy,xkb,&tmp);
+    if ( tmp.nKeyActs )
+	_XkbWriteKeyActions(dpy,xkb,&tmp);
+    if ( tmp.totalKeyBehaviors>0 )
+	_XkbWriteKeyBehaviors(dpy,xkb,&tmp);
+    if ( tmp.virtualMods )
+	_XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);
+    if ( tmp.totalKeyExplicit>0)
+	_XkbWriteKeyExplicit(dpy,xkb,&tmp);
+    if ( tmp.totalModMapKeys>0)
+	_XkbWriteModifierMap(dpy,xkb,&tmp);
+    if ( tmp.totalVModMapKeys>0)
+	_XkbWriteVirtualModMap(dpy,xkb,&tmp);
+    return;
+}
+
+Bool
+XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
+{
+register xkbSetMapReq *	req;
+XkbInfoPtr 		xkbi;
+XkbServerMapPtr		srv;
+XkbClientMapPtr		map;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+	(!xkb))
+	return False;
+    map= xkb->map;
+    srv= xkb->server;
+
+    if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+	((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||
+	((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+	((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+	((which&XkbVirtualModsMask)&&(!srv))||
+	((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||
+	((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+	((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
+	return False;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetMap;
+    req->deviceSpec = xkb->device_spec;
+    req->present = which;
+    req->flags = XkbSetMapAllFlags;
+    req->minKeyCode= xkb->min_key_code;
+    req->maxKeyCode= xkb->max_key_code;
+    req->firstType = 0;
+    if (which&XkbKeyTypesMask)	req->nTypes = map->num_types;
+    else			req->nTypes = 0;
+    if (which&XkbKeySymsMask) {
+	req->firstKeySym = xkb->min_key_code;
+	req->nKeySyms = XkbNumKeys(xkb);
+    }
+    if (which&XkbKeyActionsMask) {
+	req->firstKeyAct = xkb->min_key_code;
+	req->nKeyActs = XkbNumKeys(xkb);
+    }
+    if (which&XkbKeyBehaviorsMask) {
+	req->firstKeyBehavior = xkb->min_key_code;
+	req->nKeyBehaviors = XkbNumKeys(xkb);
+    }
+    if (which&XkbVirtualModsMask)
+	req->virtualMods= ~0;
+    if (which&XkbExplicitComponentsMask) {
+	req->firstKeyExplicit= xkb->min_key_code;
+	req->nKeyExplicit = XkbNumKeys(xkb);
+    }
+    if (which&XkbModifierMapMask) {
+	req->firstModMapKey= xkb->min_key_code;
+	req->nModMapKeys = XkbNumKeys(xkb);
+    }
+    if (which&XkbVirtualModMapMask) {
+	req->firstVModMapKey= xkb->min_key_code;
+	req->nVModMapKeys = XkbNumKeys(xkb);
+    }
+    SendSetMap(dpy,xkb,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
+{
+register xkbSetMapReq *	req;
+XkbInfoPtr 		xkbi;
+XkbServerMapPtr		srv;
+XkbClientMapPtr		map;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
+	(!xkb)||(!changes))
+	return False;
+    srv= xkb->server;
+    map= xkb->map;
+
+    if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||
+	((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||
+				(!map->key_sym_map)))||
+	((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
+	((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
+	((changes->changed&XkbVirtualModsMask)&&(!srv))||
+	((changes->changed&XkbExplicitComponentsMask)&&
+				((!srv)||(!srv->explicit)))||
+	((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
+	((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
+	return False;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetMap;
+    req->deviceSpec = xkb->device_spec;
+    req->present = changes->changed;
+    req->flags = XkbSetMapRecomputeActions;
+    req->minKeyCode= xkb->min_key_code;
+    req->maxKeyCode= xkb->max_key_code;
+    req->firstType = changes->first_type;
+    req->nTypes = changes->num_types;
+    req->firstKeySym = changes->first_key_sym;
+    req->nKeySyms = changes->num_key_syms;
+    req->firstKeyAct = changes->first_key_act;
+    req->nKeyActs = changes->num_key_acts;
+    req->firstKeyBehavior = changes->first_key_behavior;
+    req->nKeyBehaviors = changes->num_key_behaviors;
+    req->virtualMods = changes->vmods;
+    req->firstKeyExplicit = changes->first_key_explicit;
+    req->nKeyExplicit = changes->num_key_explicit;
+    req->firstModMapKey = changes->first_modmap_key;
+    req->nModMapKeys = changes->num_modmap_keys;
+    req->firstVModMapKey = changes->first_vmodmap_key;
+    req->nVModMapKeys = changes->num_vmodmap_keys;
+    SendSetMap(dpy,xkb,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
diff --git a/libX11/src/xkb/XKBUse.c b/libX11/src/xkb/XKBUse.c
index efca018f6..05dcfc182 100644
--- a/libX11/src/xkb/XKBUse.c
+++ b/libX11/src/xkb/XKBUse.c
@@ -1,797 +1,797 @@
-/************************************************************

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

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-static Bool	_XkbIgnoreExtension = False;

-

-void

-XkbNoteMapChanges(XkbMapChangesPtr old,XkbMapNotifyEvent *new,unsigned wanted)

-{

-    int first,oldLast,newLast;

-    wanted&= new->changed;

-

-    if (wanted&XkbKeyTypesMask) {

-	if (old->changed&XkbKeyTypesMask) {

-	    first = old->first_type;

-	    oldLast = old->first_type+old->num_types-1;

-	    newLast = new->first_type+new->num_types-1;

-

-	    if (new->first_type<first)

-		first = new->first_type;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_type = first;

-	    old->num_types = newLast-first+1;

-	}

-	else {

-	    old->first_type= new->first_type;

-	    old->num_types = new->num_types;

-	}

-    }

-    if (wanted&XkbKeySymsMask) {

-	if (old->changed&XkbKeySymsMask) {

-	    first = old->first_key_sym;

-	    oldLast = old->first_key_sym+old->num_key_syms-1;

-	    newLast = new->first_key_sym+new->num_key_syms-1;

-

-	    if (new->first_key_sym<first)

-		first = new->first_key_sym;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_key_sym = first;

-	    old->num_key_syms = newLast-first+1;

-	}

-	else {

-	    old->first_key_sym = new->first_key_sym;

-	    old->num_key_syms = new->num_key_syms;

-	}

-    }

-    if (wanted&XkbKeyActionsMask) {

-	if (old->changed&XkbKeyActionsMask) {

-	    first = old->first_key_act;

-	    oldLast = old->first_key_act+old->num_key_acts-1;

-	    newLast = new->first_key_act+new->num_key_acts-1;

-

-	    if (new->first_key_act<first)

-		first = new->first_key_act;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_key_act = first;

-	    old->num_key_acts = newLast-first+1;

-	}

-	else {

-	    old->first_key_act = new->first_key_act;

-	    old->num_key_acts = new->num_key_acts;

-	}

-    }

-    if (wanted&XkbKeyBehaviorsMask) {

-	if (old->changed&XkbKeyBehaviorsMask) {

-	    first = old->first_key_behavior;

-	    oldLast = old->first_key_behavior+old->num_key_behaviors-1;

-	    newLast = new->first_key_behavior+new->num_key_behaviors-1;

-

-	    if (new->first_key_behavior<first)

-		first = new->first_key_behavior;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_key_behavior = first;

-	    old->num_key_behaviors = newLast-first+1;

-	}

-	else {

-	    old->first_key_behavior = new->first_key_behavior;

-	    old->num_key_behaviors = new->num_key_behaviors;

-	}

-    }

-    if (wanted&XkbVirtualModsMask) {

-	old->vmods|= new->vmods;

-    }

-    if (wanted&XkbExplicitComponentsMask) {

-	if (old->changed&XkbExplicitComponentsMask) {

-	    first = old->first_key_explicit;

-	    oldLast = old->first_key_explicit+old->num_key_explicit-1;

-	    newLast = new->first_key_explicit+new->num_key_explicit-1;

-

-	    if (new->first_key_explicit<first)

-		first = new->first_key_explicit;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_key_explicit = first;

-	    old->num_key_explicit = newLast-first+1;

-	}

-	else {

-	    old->first_key_explicit = new->first_key_explicit;

-	    old->num_key_explicit = new->num_key_explicit;

-	}

-    }

-    if (wanted&XkbModifierMapMask) {

-	if (old->changed&XkbModifierMapMask) {

-	    first = old->first_modmap_key;

-	    oldLast = old->first_modmap_key+old->num_modmap_keys-1;

-	    newLast = new->first_modmap_key+new->num_modmap_keys-1;

-

-	    if (new->first_modmap_key<first)

-		first = new->first_modmap_key;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_modmap_key = first;

-	    old->num_modmap_keys = newLast-first+1;

-	}

-	else {

-	    old->first_modmap_key = new->first_modmap_key;

-	    old->num_modmap_keys = new->num_modmap_keys;

-	}

-    }

-    if (wanted&XkbVirtualModMapMask) {

-	if (old->changed&XkbVirtualModMapMask) {

-	    first = old->first_vmodmap_key;

-	    oldLast = old->first_vmodmap_key+old->num_vmodmap_keys-1;

-	    newLast = new->first_vmodmap_key+new->num_vmodmap_keys-1;

-

-	    if (new->first_vmodmap_key<first)

-		first = new->first_vmodmap_key;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_vmodmap_key = first;

-	    old->num_vmodmap_keys = newLast-first+1;

-	}

-	else {

-	    old->first_vmodmap_key = new->first_vmodmap_key;

-	    old->num_vmodmap_keys = new->num_vmodmap_keys;

-	}

-    }

-    old->changed|= wanted;

-    return;

-}

-

-void

-_XkbNoteCoreMapChanges(	XkbMapChangesPtr	 old,

-			XMappingEvent * 	new,

-			unsigned int 		wanted)

-{

-    int first,oldLast,newLast;

-

-    if ((new->request==MappingKeyboard)&&(wanted&XkbKeySymsMask)) {

-	if (old->changed&XkbKeySymsMask) {

-	    first = old->first_key_sym;

-	    oldLast = old->first_key_sym+old->num_key_syms-1;

-	    newLast = new->first_keycode+new->count-1;

-

-	    if (new->first_keycode<first)

-		first = new->first_keycode;

-	    if (oldLast>newLast)

-		newLast= oldLast;

-	    old->first_key_sym = first;

-	    old->num_key_syms = newLast-first+1;

-	}

-	else {

-	    old->changed|= XkbKeySymsMask;

-	    old->first_key_sym = new->first_keycode;

-	    old->num_key_syms = new->count;

-	}

-    }

-    return;

-}

-

-static Bool

-wire_to_event(Display *dpy,XEvent *re,xEvent *event)

-{

-    xkbEvent *xkbevent= (xkbEvent *)event;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    xkbi = dpy->xkb_info;

-    if (((event->u.u.type&0x7f)-xkbi->codes->first_event)!=XkbEventCode)

-	return False;

-

-    switch (xkbevent->u.any.xkbType) {

-	case XkbStateNotify:

-	    {

-		xkbStateNotify *sn = (xkbStateNotify *)event;

-		if ( xkbi->selected_events&XkbStateNotifyMask ) {

-		    XkbStateNotifyEvent *sev=(XkbStateNotifyEvent *)re;

-		    sev->type = XkbEventCode+xkbi->codes->first_event;

-		    sev->xkb_type = XkbStateNotify;

-		    sev->serial = _XSetLastRequestRead(dpy,

-					(xGenericReply *)event);

-		    sev->send_event = ((event->u.u.type & 0x80) != 0);

-		    sev->display = dpy;

-		    sev->time = sn->time;

-		    sev->device = sn->deviceID;

-		    sev->keycode = sn->keycode;

-		    sev->event_type = sn->eventType;

-		    sev->req_major = sn->requestMajor;

-		    sev->req_minor = sn->requestMinor;

-		    sev->changed = sn->changed;

-		    sev->group = sn->group;

-		    sev->base_group = sn->baseGroup;

-		    sev->latched_group = sn->latchedGroup;

-		    sev->locked_group = sn->lockedGroup;

-		    sev->mods = sn->mods;

-		    sev->base_mods = sn->baseMods;

-		    sev->latched_mods = sn->latchedMods;

-		    sev->locked_mods = sn->lockedMods;

-		    sev->compat_state = sn->compatState;

-		    sev->grab_mods = sn->grabMods;

-		    sev->compat_grab_mods = sn->compatGrabMods;

-		    sev->lookup_mods = sn->lookupMods;

-		    sev->compat_lookup_mods = sn->compatLookupMods;

-		    sev->ptr_buttons = sn->ptrBtnState;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbMapNotify:

-	    {

-		xkbMapNotify *mn = (xkbMapNotify *)event;

-		if ((xkbi->selected_events&XkbMapNotifyMask)&&

-				(xkbi->selected_map_details&mn->changed)) {

-		    XkbMapNotifyEvent *mev;

-		    mev =(XkbMapNotifyEvent *)re;

-		    mev->type = XkbEventCode+xkbi->codes->first_event;

-		    mev->xkb_type = XkbMapNotify;

-		    mev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    mev->send_event = ((event->u.u.type&0x80)!=0);

-		    mev->display = dpy;

-		    mev->time = mn->time;

-		    mev->device = mn->deviceID;

-		    mev->changed =  mn->changed;

-		    mev->min_key_code = mn->minKeyCode;

-		    mev->max_key_code = mn->maxKeyCode;

-		    mev->first_type = mn->firstType;

-		    mev->num_types = mn->nTypes;

-		    mev->first_key_sym = mn->firstKeySym;

-		    mev->num_key_syms = mn->nKeySyms;

-		    mev->first_key_act = mn->firstKeyAct;

-		    mev->num_key_acts = mn->nKeyActs;

-		    mev->first_key_behavior = mn->firstKeyBehavior;

-		    mev->num_key_behaviors = mn->nKeyBehaviors;

-		    mev->vmods = mn->virtualMods;

-		    mev->first_key_explicit = mn->firstKeyExplicit;

-		    mev->num_key_explicit = mn->nKeyExplicit;

-		    mev->first_modmap_key = mn->firstModMapKey;

-		    mev->num_modmap_keys = mn->nModMapKeys;

-		    mev->first_vmodmap_key = mn->firstVModMapKey;

-		    mev->num_vmodmap_keys = mn->nVModMapKeys;

-		    XkbNoteMapChanges(&xkbi->changes,mev,XKB_XLIB_MAP_MASK);

-		    if (xkbi->changes.changed)

-			xkbi->flags|= XkbMapPending;

-		    return True;

-		}

-		else if (mn->nKeySyms>0) {

-		    register XMappingEvent *ev = (XMappingEvent *)re;

-		    ev->type = MappingNotify;

-		    ev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    ev->send_event = ((event->u.u.type&0x80)!=0);

-		    ev->display = dpy;

-		    ev->window = 0;

-		    ev->first_keycode = mn->firstKeySym;

-		    ev->request = MappingKeyboard;

-		    ev->count = mn->nKeySyms;

-		    _XkbNoteCoreMapChanges(&xkbi->changes,ev,XKB_XLIB_MAP_MASK);

-		    if (xkbi->changes.changed)

-			xkbi->flags|= XkbMapPending;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbControlsNotify:

-	    {

-		if (xkbi->selected_events&XkbControlsNotifyMask) {

-		    xkbControlsNotify *cn =(xkbControlsNotify *)event;

-		    XkbControlsNotifyEvent *cev;

-		    cev =(XkbControlsNotifyEvent *)re;

-		    cev->type = XkbEventCode+xkbi->codes->first_event;

-		    cev->xkb_type = XkbControlsNotify;

-		    cev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    cev->send_event = ((event->u.u.type&0x80)!=0);

-		    cev->display = dpy;

-		    cev->time = cn->time;

-		    cev->device = cn->deviceID;

-		    cev->changed_ctrls =  cn->changedControls;

-		    cev->enabled_ctrls =  cn->enabledControls;

-		    cev->enabled_ctrl_changes = cn->enabledControlChanges;

-		    cev->keycode = cn->keycode;

-		    cev->num_groups = cn->numGroups;

-		    cev->event_type = cn->eventType;

-		    cev->req_major = cn->requestMajor;

-		    cev->req_minor = cn->requestMinor;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbIndicatorMapNotify:

-	    {

-		if (xkbi->selected_events&XkbIndicatorMapNotifyMask) {

-		    xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;

-		    XkbIndicatorNotifyEvent *iev;

-		    iev =(XkbIndicatorNotifyEvent *)re;

-		    iev->type = XkbEventCode+xkbi->codes->first_event;

-		    iev->xkb_type = XkbIndicatorMapNotify;

-		    iev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    iev->send_event = ((event->u.u.type&0x80)!=0);

-		    iev->display = dpy;

-		    iev->time = in->time;

-		    iev->device = in->deviceID;

-		    iev->changed =  in->changed;

-		    iev->state=  in->state;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbIndicatorStateNotify:

-	    {

-		if (xkbi->selected_events&XkbIndicatorStateNotifyMask) {

-		    xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;

-		    XkbIndicatorNotifyEvent *iev;

-		    iev =(XkbIndicatorNotifyEvent *)re;

-		    iev->type = XkbEventCode+xkbi->codes->first_event;

-		    iev->xkb_type = XkbIndicatorStateNotify;

-		    iev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    iev->send_event = ((event->u.u.type&0x80)!=0);

-		    iev->display = dpy;

-		    iev->time = in->time;

-		    iev->device = in->deviceID;

-		    iev->changed =  in->changed;

-		    iev->state=  in->state;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbBellNotify:

-	    {

-		if (xkbi->selected_events&XkbBellNotifyMask) {

-		    xkbBellNotify *bn =(xkbBellNotify *)event;

-		    XkbBellNotifyEvent *bev;

-		    bev =(XkbBellNotifyEvent *)re;

-		    bev->type = XkbEventCode+xkbi->codes->first_event;

-		    bev->xkb_type = XkbBellNotify;

-		    bev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    bev->send_event = ((event->u.u.type&0x80)!=0);

-		    bev->display = dpy;

-		    bev->time = bn->time;

-		    bev->device = bn->deviceID;

-		    bev->percent = bn->percent;

-		    bev->pitch = bn->pitch;

-		    bev->duration = bn->duration;

-		    bev->bell_class = bn->bellClass;

-		    bev->bell_id = bn->bellID;

-		    bev->name = bn->name;

-		    bev->window = bn->window;

-		    bev->event_only = bn->eventOnly;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbAccessXNotify:

-	    {

-		if (xkbi->selected_events&XkbAccessXNotifyMask) {

-		    xkbAccessXNotify *axn =(xkbAccessXNotify *)event;

-		    XkbAccessXNotifyEvent *axev;

-		    axev =(XkbAccessXNotifyEvent *)re;

-		    axev->type = XkbEventCode+xkbi->codes->first_event;

-		    axev->xkb_type = XkbAccessXNotify;

-		    axev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    axev->send_event = ((event->u.u.type&0x80)!=0);

-		    axev->display = dpy;

-		    axev->time = axn->time;

-		    axev->device = axn->deviceID;

-		    axev->detail = axn->detail;

-		    axev->keycode = axn->keycode;

-		    axev->sk_delay = axn->slowKeysDelay;

-		    axev->debounce_delay = axn->debounceDelay;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbNamesNotify:

-	    {

-		if (xkbi->selected_events&XkbNamesNotifyMask) {

-		    xkbNamesNotify *nn =(xkbNamesNotify *)event;

-		    XkbNamesNotifyEvent *nev;

-		    nev =(XkbNamesNotifyEvent *)re;

-		    nev->type = XkbEventCode+xkbi->codes->first_event;

-		    nev->xkb_type = XkbNamesNotify;

-		    nev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    nev->send_event = ((event->u.u.type&0x80)!=0);

-		    nev->display = dpy;

-		    nev->time = nn->time;

-		    nev->device = nn->deviceID;

-		    nev->changed = nn->changed;

-		    nev->first_type = nn->firstType;

-		    nev->num_types = nn->nTypes;

-		    nev->first_lvl = nn->firstLevelName;

-		    nev->num_lvls = nn->nLevelNames;

-		    nev->num_aliases = nn->nAliases;

-		    nev->num_radio_groups = nn->nRadioGroups;

-		    nev->changed_vmods = nn->changedVirtualMods;

-		    nev->changed_groups = nn->changedGroupNames;

-		    nev->changed_indicators = nn->changedIndicators;

-		    nev->first_key = nn->firstKey;

-		    nev->num_keys = nn->nKeys;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbCompatMapNotify:

-	    {

-		if (xkbi->selected_events&XkbCompatMapNotifyMask) {

-		    xkbCompatMapNotify *cmn =(xkbCompatMapNotify *)event;

-		    XkbCompatMapNotifyEvent *cmev;

-		    cmev =(XkbCompatMapNotifyEvent *)re;

-		    cmev->type = XkbEventCode+xkbi->codes->first_event;

-		    cmev->xkb_type = XkbCompatMapNotify;

-		    cmev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    cmev->send_event = ((event->u.u.type&0x80)!=0);

-		    cmev->display = dpy;

-		    cmev->time = cmn->time;

-		    cmev->device = cmn->deviceID;

-		    cmev->changed_groups = cmn->changedGroups;

-		    cmev->first_si = cmn->firstSI;

-		    cmev->num_si = cmn->nSI;

-		    cmev->num_total_si = cmn->nTotalSI;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbActionMessage:

-	    {

-		if (xkbi->selected_events&XkbActionMessageMask) {

-		    xkbActionMessage *am= (xkbActionMessage *)event;

-		    XkbActionMessageEvent *amev;

-		    amev= (XkbActionMessageEvent *)re;

-		    amev->type = XkbEventCode+xkbi->codes->first_event;

-		    amev->xkb_type = XkbActionMessage;

-		    amev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    amev->send_event = ((event->u.u.type&0x80)!=0);

-		    amev->display = dpy;

-		    amev->time = am->time;

-		    amev->device = am->deviceID;

-		    amev->keycode = am->keycode;

-		    amev->press = am->press;

-		    amev->key_event_follows = am->keyEventFollows;

-		    amev->group = am->group;

-		    amev->mods = am->mods;

-		    memcpy(amev->message,am->message,XkbActionMessageLength);

-		    amev->message[XkbActionMessageLength]= '\0';

-		    return True;

-		}

-	    }

-	    break;

-	case XkbExtensionDeviceNotify:

-	    {

-		if (xkbi->selected_events&XkbExtensionDeviceNotifyMask) {

-		    xkbExtensionDeviceNotify *ed=

-					(xkbExtensionDeviceNotify *)event;

-		    XkbExtensionDeviceNotifyEvent *edev;

-		    edev= (XkbExtensionDeviceNotifyEvent *)re;

-		    edev->type= XkbEventCode+xkbi->codes->first_event;

-		    edev->xkb_type= XkbExtensionDeviceNotify;

-		    edev->serial= _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    edev->send_event= ((event->u.u.type&0x80)!=0);

-		    edev->display= dpy;

-		    edev->time= ed->time;

-		    edev->device= ed->deviceID;

-		    edev->led_class= ed->ledClass;

-		    edev->led_id= ed->ledID;

-		    edev->reason= ed->reason;

-		    edev->supported= ed->supported;

-		    edev->leds_defined= ed->ledsDefined;

-		    edev->led_state= ed->ledState;

-		    edev->first_btn= ed->firstBtn;

-		    edev->num_btns= ed->nBtns;

-		    edev->unsupported= ed->unsupported;

-		    return True;

-		}

-	    }

-	    break;

-	case XkbNewKeyboardNotify:

-	    {

-		xkbNewKeyboardNotify *nkn = (xkbNewKeyboardNotify *)event;

-		if ((xkbi->selected_events&XkbNewKeyboardNotifyMask)&&

-				    (xkbi->selected_nkn_details&nkn->changed)) {

-		    XkbNewKeyboardNotifyEvent *nkev;

-		    nkev =(XkbNewKeyboardNotifyEvent *)re;

-		    nkev->type = XkbEventCode+xkbi->codes->first_event;

-		    nkev->xkb_type = XkbNewKeyboardNotify;

-		    nkev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    nkev->send_event = ((event->u.u.type&0x80)!=0);

-		    nkev->display = dpy;

-		    nkev->time = nkn->time;

-		    nkev->device = nkn->deviceID;

-		    nkev->old_device = nkn->oldDeviceID;

-		    nkev->min_key_code = nkn->minKeyCode;

-		    nkev->max_key_code = nkn->maxKeyCode;

-		    nkev->old_min_key_code = nkn->oldMinKeyCode;

-		    nkev->old_max_key_code = nkn->oldMaxKeyCode;

-		    nkev->req_major = nkn->requestMajor;

-		    nkev->req_minor = nkn->requestMinor;

-		    nkev->changed = nkn->changed;

-		    if ((xkbi->desc)&&(nkev->send_event==0)&&

-			((xkbi->desc->device_spec==nkev->old_device)||

-			 (nkev->device!=nkev->old_device))) {

-			xkbi->flags= XkbMapPending|XkbXlibNewKeyboard;

-		    }

-		    return True;

-		}

-		else if(nkn->changed&(XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask)){

-		    register XMappingEvent *ev = (XMappingEvent *)re;

-		    ev->type = MappingNotify;

-		    ev->serial = _XSetLastRequestRead(dpy,

-						(xGenericReply *)event);

-		    ev->send_event = ((event->u.u.type&0x80)!=0);

-		    ev->display = dpy;

-		    ev->window = 0;

-		    ev->first_keycode = dpy->min_keycode;

-		    ev->request = MappingKeyboard;

-		    ev->count = (dpy->max_keycode-dpy->min_keycode)+1;

-		    if ((xkbi->desc)&&(ev->send_event==0)&&

-			((xkbi->desc->device_spec==nkn->oldDeviceID)||

-			 (nkn->deviceID!=nkn->oldDeviceID))) {

-			xkbi->flags|= XkbMapPending|XkbXlibNewKeyboard;

-		    }

-		    return True;

-		}

-	    }

-	    break;

-	default:

-#ifdef DEBUG

-	    fprintf(stderr,"Got unknown XKEYBOARD event (%d, base=%d)\n",

-						re->type,

-						xkbi->codes->first_event);

-#endif

-	    break;

-    }

-    return False;

-}

-

-Bool

-XkbIgnoreExtension(Bool ignore)

-{

-    if (getenv("XKB_FORCE")!=NULL) {

-#ifdef DEBUG

-	fprintf(stderr,"Forcing use of XKEYBOARD (overriding an IgnoreExtensions)\n");

-#endif

-	return False;

-    }

-#ifdef DEBUG

-    else if (getenv("XKB_DEBUG")!=NULL) {

-	fprintf(stderr,"Explicitly %signoring XKEYBOARD\n",ignore?"":"not ");

-    }

-#endif

-    _XkbIgnoreExtension = ignore;

-    return True;

-}

-

-static void

-_XkbFreeInfo(Display *dpy)

-{

-    XkbInfoPtr xkbi = dpy->xkb_info;

-    if (xkbi) {

-	if (xkbi->desc)

-	    XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);

-	Xfree(xkbi);

-      }

-}

-

-Bool

-XkbUseExtension(Display *dpy,int *major_rtrn,int *minor_rtrn)

-{

-    xkbUseExtensionReply rep;

-    register xkbUseExtensionReq *req;

-    XExtCodes		*codes;

-    int	ev_base,forceIgnore;

-    XkbInfoPtr xkbi;

-    char *	str;

-    static int debugMsg;

-    static int been_here= 0;

-

-    if ( dpy->xkb_info && !(dpy->flags & XlibDisplayNoXkb)) {

-	if (major_rtrn)	*major_rtrn= dpy->xkb_info->srv_major;

-	if (minor_rtrn)	*minor_rtrn= dpy->xkb_info->srv_minor;

-	return True;

-    }

-    if (!been_here) {

-	debugMsg= (getenv("XKB_DEBUG")!=NULL);

-	been_here= 1;

-    }

-

-    if (major_rtrn)	*major_rtrn= 0;

-    if (minor_rtrn)	*minor_rtrn= 0;

-

-    if (!dpy->xkb_info) {

-        xkbi = _XkbTypedCalloc(1, XkbInfoRec);

-        if ( !xkbi )

-	    return False;

-        dpy->xkb_info = xkbi;

-        dpy->free_funcs->xkb = _XkbFreeInfo;

-

-        xkbi->xlib_ctrls|= (XkbLC_ControlFallback|XkbLC_ConsumeLookupMods);

-        if ((str=getenv("_XKB_OPTIONS_ENABLE"))!=NULL) {

-	    if ((str=getenv("_XKB_LATIN1_LOOKUP"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_ForceLatin1Lookup;

-	        else xkbi->xlib_ctrls|= XkbLC_ForceLatin1Lookup;

-	    }

-	    if ((str=getenv("_XKB_CONSUME_LOOKUP_MODS"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_ConsumeLookupMods;

-	        else xkbi->xlib_ctrls|= XkbLC_ConsumeLookupMods;

-	    }

-	    if ((str=getenv("_XKB_CONSUME_SHIFT_AND_LOCK"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_AlwaysConsumeShiftAndLock;

-	        else xkbi->xlib_ctrls|= XkbLC_AlwaysConsumeShiftAndLock;

-	    }

-	    if ((str=getenv("_XKB_IGNORE_NEW_KEYBOARDS"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_IgnoreNewKeyboards;

-	        else xkbi->xlib_ctrls|= XkbLC_IgnoreNewKeyboards;

-	    }

-	    if ((str=getenv("_XKB_CONTROL_FALLBACK"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_ControlFallback;

-	        else xkbi->xlib_ctrls|= XkbLC_ControlFallback;

-	    }

-	    if ((str=getenv("_XKB_COMP_LED"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		    xkbi->xlib_ctrls&= ~XkbLC_ComposeLED;

-	        else {

-		    xkbi->xlib_ctrls|= XkbLC_ComposeLED;

-		    if (strlen(str)>0)

-		        xkbi->composeLED= XInternAtom(dpy,str,False);

-	        }

-	    }

-	    if ((str=getenv("_XKB_COMP_FAIL_BEEP"))!=NULL) {

-	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))

-		     xkbi->xlib_ctrls&= ~XkbLC_BeepOnComposeFail;

-	        else xkbi->xlib_ctrls|= XkbLC_BeepOnComposeFail;

-	    }

-        }

-        if ((xkbi->composeLED==None)&&((xkbi->xlib_ctrls&XkbLC_ComposeLED)!=0))

-	    xkbi->composeLED= XInternAtom(dpy,"Compose",False);

-#ifdef DEBUG

-        if (debugMsg) {

-	    register unsigned c= xkbi->xlib_ctrls;

-	    fprintf(stderr,"XKEYBOARD compose: beep on failure is %s, LED is %s\n",

-		((c&XkbLC_BeepOnComposeFail)?"on":"off"),

-		((c&XkbLC_ComposeLED)?"on":"off"));

-	    fprintf(stderr,"XKEYBOARD XLookupString: %slatin-1, %s lookup modifiers\n",

-		((c&XkbLC_ForceLatin1Lookup)?"allow non-":"force "),

-		((c&XkbLC_ConsumeLookupMods)?"consume":"re-use"));

-	    fprintf(stderr,

-	        "XKEYBOARD XLookupString: %sconsume shift and lock, %scontrol fallback\n",

-	        ((c&XkbLC_AlwaysConsumeShiftAndLock)?"always ":"don't "),

-	        ((c&XkbLC_ControlFallback)?"":"no "));

-

-        }

-#endif

-    } else

-        xkbi = dpy->xkb_info;

-

-    forceIgnore= (dpy->flags&XlibDisplayNoXkb)||dpy->keysyms;

-    forceIgnore= forceIgnore&&(major_rtrn==NULL)&&(minor_rtrn==NULL);

-    if ( forceIgnore || _XkbIgnoreExtension || getenv("XKB_DISABLE")) {

-	LockDisplay(dpy);

-	dpy->flags |= XlibDisplayNoXkb;

-	UnlockDisplay(dpy);

-	if (debugMsg)

-	    fprintf(stderr,"XKEYBOARD extension disabled or missing\n");

-	return False;

-    }

-

-    if ( (codes=XInitExtension(dpy,XkbName))==NULL ) {

-	LockDisplay(dpy);

-	dpy->flags |= XlibDisplayNoXkb;

-	UnlockDisplay(dpy);

-	if (debugMsg)

-	    fprintf(stderr,"XKEYBOARD extension not present\n");

-	return False;

-    }

-    xkbi->codes = codes;

-    LockDisplay(dpy);

-

-    GetReq(kbUseExtension, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbUseExtension;

-    req->wantedMajor = XkbMajorVersion;

-    req->wantedMinor = XkbMinorVersion;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.supported ) {

-	Bool	fail;

-	fail= True;

-	if (debugMsg)

-	    fprintf(stderr,

-		"XKEYBOARD version mismatch (want %d.%02d, got %d.%02d)\n",

-		XkbMajorVersion,XkbMinorVersion,

-		rep.serverMajor, rep.serverMinor);

-

-	/* pre-release 0.65 is very close to 1.00 */

-	if ((rep.serverMajor==0)&&(rep.serverMinor==65)) {

-	    if (debugMsg)

-		fprintf(stderr,"Trying to fall back to version 0.65...");

-	    GetReq(kbUseExtension, req);

-	    req->reqType = xkbi->codes->major_opcode;

-	    req->xkbReqType = X_kbUseExtension;

-	    req->wantedMajor = 0;

-	    req->wantedMinor = 65;

-	    if ( _XReply(dpy, (xReply *)&rep, 0, xFalse) && rep.supported ) {

-		if (debugMsg)

-		    fprintf(stderr,"succeeded\n");

-		fail= False;

-	    }

-	    else if (debugMsg) fprintf(stderr,"failed\n");

-	}

-	if (fail) {

-	    dpy->flags |= XlibDisplayNoXkb;

-	    UnlockDisplay(dpy);

-	    SyncHandle();

-	    if (major_rtrn) *major_rtrn= rep.serverMajor;

-	    if (minor_rtrn) *minor_rtrn= rep.serverMinor;

-	    return False;

-	}

-    }

-#ifdef DEBUG

-    else if ( forceIgnore ) {

-	fprintf(stderr,"Internal Error!  XkbUseExtension succeeded with forceIgnore set\n");

-    }

-#endif

-    UnlockDisplay(dpy);

-    xkbi->srv_major= rep.serverMajor;

-    xkbi->srv_minor= rep.serverMinor;

-    if (major_rtrn)	*major_rtrn= rep.serverMajor;

-    if (minor_rtrn)	*minor_rtrn= rep.serverMinor;

-    if (debugMsg)

-	fprintf(stderr,"XKEYBOARD (version %d.%02d/%d.%02d) OK!\n",

-				XkbMajorVersion,XkbMinorVersion,

-				rep.serverMajor,rep.serverMinor);

-

-    ev_base = codes->first_event;

-    XESetWireToEvent(dpy,ev_base+XkbEventCode,wire_to_event);

-    SyncHandle();

-    return True;

-}

-

+/************************************************************
+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 <ctype.h>
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+static Bool	_XkbIgnoreExtension = False;
+
+void
+XkbNoteMapChanges(XkbMapChangesPtr old,XkbMapNotifyEvent *new,unsigned wanted)
+{
+    int first,oldLast,newLast;
+    wanted&= new->changed;
+
+    if (wanted&XkbKeyTypesMask) {
+	if (old->changed&XkbKeyTypesMask) {
+	    first = old->first_type;
+	    oldLast = old->first_type+old->num_types-1;
+	    newLast = new->first_type+new->num_types-1;
+
+	    if (new->first_type<first)
+		first = new->first_type;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_type = first;
+	    old->num_types = newLast-first+1;
+	}
+	else {
+	    old->first_type= new->first_type;
+	    old->num_types = new->num_types;
+	}
+    }
+    if (wanted&XkbKeySymsMask) {
+	if (old->changed&XkbKeySymsMask) {
+	    first = old->first_key_sym;
+	    oldLast = old->first_key_sym+old->num_key_syms-1;
+	    newLast = new->first_key_sym+new->num_key_syms-1;
+
+	    if (new->first_key_sym<first)
+		first = new->first_key_sym;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_key_sym = first;
+	    old->num_key_syms = newLast-first+1;
+	}
+	else {
+	    old->first_key_sym = new->first_key_sym;
+	    old->num_key_syms = new->num_key_syms;
+	}
+    }
+    if (wanted&XkbKeyActionsMask) {
+	if (old->changed&XkbKeyActionsMask) {
+	    first = old->first_key_act;
+	    oldLast = old->first_key_act+old->num_key_acts-1;
+	    newLast = new->first_key_act+new->num_key_acts-1;
+
+	    if (new->first_key_act<first)
+		first = new->first_key_act;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_key_act = first;
+	    old->num_key_acts = newLast-first+1;
+	}
+	else {
+	    old->first_key_act = new->first_key_act;
+	    old->num_key_acts = new->num_key_acts;
+	}
+    }
+    if (wanted&XkbKeyBehaviorsMask) {
+	if (old->changed&XkbKeyBehaviorsMask) {
+	    first = old->first_key_behavior;
+	    oldLast = old->first_key_behavior+old->num_key_behaviors-1;
+	    newLast = new->first_key_behavior+new->num_key_behaviors-1;
+
+	    if (new->first_key_behavior<first)
+		first = new->first_key_behavior;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_key_behavior = first;
+	    old->num_key_behaviors = newLast-first+1;
+	}
+	else {
+	    old->first_key_behavior = new->first_key_behavior;
+	    old->num_key_behaviors = new->num_key_behaviors;
+	}
+    }
+    if (wanted&XkbVirtualModsMask) {
+	old->vmods|= new->vmods;
+    }
+    if (wanted&XkbExplicitComponentsMask) {
+	if (old->changed&XkbExplicitComponentsMask) {
+	    first = old->first_key_explicit;
+	    oldLast = old->first_key_explicit+old->num_key_explicit-1;
+	    newLast = new->first_key_explicit+new->num_key_explicit-1;
+
+	    if (new->first_key_explicit<first)
+		first = new->first_key_explicit;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_key_explicit = first;
+	    old->num_key_explicit = newLast-first+1;
+	}
+	else {
+	    old->first_key_explicit = new->first_key_explicit;
+	    old->num_key_explicit = new->num_key_explicit;
+	}
+    }
+    if (wanted&XkbModifierMapMask) {
+	if (old->changed&XkbModifierMapMask) {
+	    first = old->first_modmap_key;
+	    oldLast = old->first_modmap_key+old->num_modmap_keys-1;
+	    newLast = new->first_modmap_key+new->num_modmap_keys-1;
+
+	    if (new->first_modmap_key<first)
+		first = new->first_modmap_key;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_modmap_key = first;
+	    old->num_modmap_keys = newLast-first+1;
+	}
+	else {
+	    old->first_modmap_key = new->first_modmap_key;
+	    old->num_modmap_keys = new->num_modmap_keys;
+	}
+    }
+    if (wanted&XkbVirtualModMapMask) {
+	if (old->changed&XkbVirtualModMapMask) {
+	    first = old->first_vmodmap_key;
+	    oldLast = old->first_vmodmap_key+old->num_vmodmap_keys-1;
+	    newLast = new->first_vmodmap_key+new->num_vmodmap_keys-1;
+
+	    if (new->first_vmodmap_key<first)
+		first = new->first_vmodmap_key;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_vmodmap_key = first;
+	    old->num_vmodmap_keys = newLast-first+1;
+	}
+	else {
+	    old->first_vmodmap_key = new->first_vmodmap_key;
+	    old->num_vmodmap_keys = new->num_vmodmap_keys;
+	}
+    }
+    old->changed|= wanted;
+    return;
+}
+
+void
+_XkbNoteCoreMapChanges(	XkbMapChangesPtr	 old,
+			XMappingEvent * 	new,
+			unsigned int 		wanted)
+{
+    int first,oldLast,newLast;
+
+    if ((new->request==MappingKeyboard)&&(wanted&XkbKeySymsMask)) {
+	if (old->changed&XkbKeySymsMask) {
+	    first = old->first_key_sym;
+	    oldLast = old->first_key_sym+old->num_key_syms-1;
+	    newLast = new->first_keycode+new->count-1;
+
+	    if (new->first_keycode<first)
+		first = new->first_keycode;
+	    if (oldLast>newLast)
+		newLast= oldLast;
+	    old->first_key_sym = first;
+	    old->num_key_syms = newLast-first+1;
+	}
+	else {
+	    old->changed|= XkbKeySymsMask;
+	    old->first_key_sym = new->first_keycode;
+	    old->num_key_syms = new->count;
+	}
+    }
+    return;
+}
+
+static Bool
+wire_to_event(Display *dpy,XEvent *re,xEvent *event)
+{
+    xkbEvent *xkbevent= (xkbEvent *)event;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    xkbi = dpy->xkb_info;
+    if (((event->u.u.type&0x7f)-xkbi->codes->first_event)!=XkbEventCode)
+	return False;
+
+    switch (xkbevent->u.any.xkbType) {
+	case XkbStateNotify:
+	    {
+		xkbStateNotify *sn = (xkbStateNotify *)event;
+		if ( xkbi->selected_events&XkbStateNotifyMask ) {
+		    XkbStateNotifyEvent *sev=(XkbStateNotifyEvent *)re;
+		    sev->type = XkbEventCode+xkbi->codes->first_event;
+		    sev->xkb_type = XkbStateNotify;
+		    sev->serial = _XSetLastRequestRead(dpy,
+					(xGenericReply *)event);
+		    sev->send_event = ((event->u.u.type & 0x80) != 0);
+		    sev->display = dpy;
+		    sev->time = sn->time;
+		    sev->device = sn->deviceID;
+		    sev->keycode = sn->keycode;
+		    sev->event_type = sn->eventType;
+		    sev->req_major = sn->requestMajor;
+		    sev->req_minor = sn->requestMinor;
+		    sev->changed = sn->changed;
+		    sev->group = sn->group;
+		    sev->base_group = sn->baseGroup;
+		    sev->latched_group = sn->latchedGroup;
+		    sev->locked_group = sn->lockedGroup;
+		    sev->mods = sn->mods;
+		    sev->base_mods = sn->baseMods;
+		    sev->latched_mods = sn->latchedMods;
+		    sev->locked_mods = sn->lockedMods;
+		    sev->compat_state = sn->compatState;
+		    sev->grab_mods = sn->grabMods;
+		    sev->compat_grab_mods = sn->compatGrabMods;
+		    sev->lookup_mods = sn->lookupMods;
+		    sev->compat_lookup_mods = sn->compatLookupMods;
+		    sev->ptr_buttons = sn->ptrBtnState;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbMapNotify:
+	    {
+		xkbMapNotify *mn = (xkbMapNotify *)event;
+		if ((xkbi->selected_events&XkbMapNotifyMask)&&
+				(xkbi->selected_map_details&mn->changed)) {
+		    XkbMapNotifyEvent *mev;
+		    mev =(XkbMapNotifyEvent *)re;
+		    mev->type = XkbEventCode+xkbi->codes->first_event;
+		    mev->xkb_type = XkbMapNotify;
+		    mev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    mev->send_event = ((event->u.u.type&0x80)!=0);
+		    mev->display = dpy;
+		    mev->time = mn->time;
+		    mev->device = mn->deviceID;
+		    mev->changed =  mn->changed;
+		    mev->min_key_code = mn->minKeyCode;
+		    mev->max_key_code = mn->maxKeyCode;
+		    mev->first_type = mn->firstType;
+		    mev->num_types = mn->nTypes;
+		    mev->first_key_sym = mn->firstKeySym;
+		    mev->num_key_syms = mn->nKeySyms;
+		    mev->first_key_act = mn->firstKeyAct;
+		    mev->num_key_acts = mn->nKeyActs;
+		    mev->first_key_behavior = mn->firstKeyBehavior;
+		    mev->num_key_behaviors = mn->nKeyBehaviors;
+		    mev->vmods = mn->virtualMods;
+		    mev->first_key_explicit = mn->firstKeyExplicit;
+		    mev->num_key_explicit = mn->nKeyExplicit;
+		    mev->first_modmap_key = mn->firstModMapKey;
+		    mev->num_modmap_keys = mn->nModMapKeys;
+		    mev->first_vmodmap_key = mn->firstVModMapKey;
+		    mev->num_vmodmap_keys = mn->nVModMapKeys;
+		    XkbNoteMapChanges(&xkbi->changes,mev,XKB_XLIB_MAP_MASK);
+		    if (xkbi->changes.changed)
+			xkbi->flags|= XkbMapPending;
+		    return True;
+		}
+		else if (mn->nKeySyms>0) {
+		    register XMappingEvent *ev = (XMappingEvent *)re;
+		    ev->type = MappingNotify;
+		    ev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    ev->send_event = ((event->u.u.type&0x80)!=0);
+		    ev->display = dpy;
+		    ev->window = 0;
+		    ev->first_keycode = mn->firstKeySym;
+		    ev->request = MappingKeyboard;
+		    ev->count = mn->nKeySyms;
+		    _XkbNoteCoreMapChanges(&xkbi->changes,ev,XKB_XLIB_MAP_MASK);
+		    if (xkbi->changes.changed)
+			xkbi->flags|= XkbMapPending;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbControlsNotify:
+	    {
+		if (xkbi->selected_events&XkbControlsNotifyMask) {
+		    xkbControlsNotify *cn =(xkbControlsNotify *)event;
+		    XkbControlsNotifyEvent *cev;
+		    cev =(XkbControlsNotifyEvent *)re;
+		    cev->type = XkbEventCode+xkbi->codes->first_event;
+		    cev->xkb_type = XkbControlsNotify;
+		    cev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    cev->send_event = ((event->u.u.type&0x80)!=0);
+		    cev->display = dpy;
+		    cev->time = cn->time;
+		    cev->device = cn->deviceID;
+		    cev->changed_ctrls =  cn->changedControls;
+		    cev->enabled_ctrls =  cn->enabledControls;
+		    cev->enabled_ctrl_changes = cn->enabledControlChanges;
+		    cev->keycode = cn->keycode;
+		    cev->num_groups = cn->numGroups;
+		    cev->event_type = cn->eventType;
+		    cev->req_major = cn->requestMajor;
+		    cev->req_minor = cn->requestMinor;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbIndicatorMapNotify:
+	    {
+		if (xkbi->selected_events&XkbIndicatorMapNotifyMask) {
+		    xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;
+		    XkbIndicatorNotifyEvent *iev;
+		    iev =(XkbIndicatorNotifyEvent *)re;
+		    iev->type = XkbEventCode+xkbi->codes->first_event;
+		    iev->xkb_type = XkbIndicatorMapNotify;
+		    iev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    iev->send_event = ((event->u.u.type&0x80)!=0);
+		    iev->display = dpy;
+		    iev->time = in->time;
+		    iev->device = in->deviceID;
+		    iev->changed =  in->changed;
+		    iev->state=  in->state;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbIndicatorStateNotify:
+	    {
+		if (xkbi->selected_events&XkbIndicatorStateNotifyMask) {
+		    xkbIndicatorNotify *in =(xkbIndicatorNotify *)event;
+		    XkbIndicatorNotifyEvent *iev;
+		    iev =(XkbIndicatorNotifyEvent *)re;
+		    iev->type = XkbEventCode+xkbi->codes->first_event;
+		    iev->xkb_type = XkbIndicatorStateNotify;
+		    iev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    iev->send_event = ((event->u.u.type&0x80)!=0);
+		    iev->display = dpy;
+		    iev->time = in->time;
+		    iev->device = in->deviceID;
+		    iev->changed =  in->changed;
+		    iev->state=  in->state;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbBellNotify:
+	    {
+		if (xkbi->selected_events&XkbBellNotifyMask) {
+		    xkbBellNotify *bn =(xkbBellNotify *)event;
+		    XkbBellNotifyEvent *bev;
+		    bev =(XkbBellNotifyEvent *)re;
+		    bev->type = XkbEventCode+xkbi->codes->first_event;
+		    bev->xkb_type = XkbBellNotify;
+		    bev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    bev->send_event = ((event->u.u.type&0x80)!=0);
+		    bev->display = dpy;
+		    bev->time = bn->time;
+		    bev->device = bn->deviceID;
+		    bev->percent = bn->percent;
+		    bev->pitch = bn->pitch;
+		    bev->duration = bn->duration;
+		    bev->bell_class = bn->bellClass;
+		    bev->bell_id = bn->bellID;
+		    bev->name = bn->name;
+		    bev->window = bn->window;
+		    bev->event_only = bn->eventOnly;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbAccessXNotify:
+	    {
+		if (xkbi->selected_events&XkbAccessXNotifyMask) {
+		    xkbAccessXNotify *axn =(xkbAccessXNotify *)event;
+		    XkbAccessXNotifyEvent *axev;
+		    axev =(XkbAccessXNotifyEvent *)re;
+		    axev->type = XkbEventCode+xkbi->codes->first_event;
+		    axev->xkb_type = XkbAccessXNotify;
+		    axev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    axev->send_event = ((event->u.u.type&0x80)!=0);
+		    axev->display = dpy;
+		    axev->time = axn->time;
+		    axev->device = axn->deviceID;
+		    axev->detail = axn->detail;
+		    axev->keycode = axn->keycode;
+		    axev->sk_delay = axn->slowKeysDelay;
+		    axev->debounce_delay = axn->debounceDelay;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbNamesNotify:
+	    {
+		if (xkbi->selected_events&XkbNamesNotifyMask) {
+		    xkbNamesNotify *nn =(xkbNamesNotify *)event;
+		    XkbNamesNotifyEvent *nev;
+		    nev =(XkbNamesNotifyEvent *)re;
+		    nev->type = XkbEventCode+xkbi->codes->first_event;
+		    nev->xkb_type = XkbNamesNotify;
+		    nev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    nev->send_event = ((event->u.u.type&0x80)!=0);
+		    nev->display = dpy;
+		    nev->time = nn->time;
+		    nev->device = nn->deviceID;
+		    nev->changed = nn->changed;
+		    nev->first_type = nn->firstType;
+		    nev->num_types = nn->nTypes;
+		    nev->first_lvl = nn->firstLevelName;
+		    nev->num_lvls = nn->nLevelNames;
+		    nev->num_aliases = nn->nAliases;
+		    nev->num_radio_groups = nn->nRadioGroups;
+		    nev->changed_vmods = nn->changedVirtualMods;
+		    nev->changed_groups = nn->changedGroupNames;
+		    nev->changed_indicators = nn->changedIndicators;
+		    nev->first_key = nn->firstKey;
+		    nev->num_keys = nn->nKeys;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbCompatMapNotify:
+	    {
+		if (xkbi->selected_events&XkbCompatMapNotifyMask) {
+		    xkbCompatMapNotify *cmn =(xkbCompatMapNotify *)event;
+		    XkbCompatMapNotifyEvent *cmev;
+		    cmev =(XkbCompatMapNotifyEvent *)re;
+		    cmev->type = XkbEventCode+xkbi->codes->first_event;
+		    cmev->xkb_type = XkbCompatMapNotify;
+		    cmev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    cmev->send_event = ((event->u.u.type&0x80)!=0);
+		    cmev->display = dpy;
+		    cmev->time = cmn->time;
+		    cmev->device = cmn->deviceID;
+		    cmev->changed_groups = cmn->changedGroups;
+		    cmev->first_si = cmn->firstSI;
+		    cmev->num_si = cmn->nSI;
+		    cmev->num_total_si = cmn->nTotalSI;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbActionMessage:
+	    {
+		if (xkbi->selected_events&XkbActionMessageMask) {
+		    xkbActionMessage *am= (xkbActionMessage *)event;
+		    XkbActionMessageEvent *amev;
+		    amev= (XkbActionMessageEvent *)re;
+		    amev->type = XkbEventCode+xkbi->codes->first_event;
+		    amev->xkb_type = XkbActionMessage;
+		    amev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    amev->send_event = ((event->u.u.type&0x80)!=0);
+		    amev->display = dpy;
+		    amev->time = am->time;
+		    amev->device = am->deviceID;
+		    amev->keycode = am->keycode;
+		    amev->press = am->press;
+		    amev->key_event_follows = am->keyEventFollows;
+		    amev->group = am->group;
+		    amev->mods = am->mods;
+		    memcpy(amev->message,am->message,XkbActionMessageLength);
+		    amev->message[XkbActionMessageLength]= '\0';
+		    return True;
+		}
+	    }
+	    break;
+	case XkbExtensionDeviceNotify:
+	    {
+		if (xkbi->selected_events&XkbExtensionDeviceNotifyMask) {
+		    xkbExtensionDeviceNotify *ed=
+					(xkbExtensionDeviceNotify *)event;
+		    XkbExtensionDeviceNotifyEvent *edev;
+		    edev= (XkbExtensionDeviceNotifyEvent *)re;
+		    edev->type= XkbEventCode+xkbi->codes->first_event;
+		    edev->xkb_type= XkbExtensionDeviceNotify;
+		    edev->serial= _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    edev->send_event= ((event->u.u.type&0x80)!=0);
+		    edev->display= dpy;
+		    edev->time= ed->time;
+		    edev->device= ed->deviceID;
+		    edev->led_class= ed->ledClass;
+		    edev->led_id= ed->ledID;
+		    edev->reason= ed->reason;
+		    edev->supported= ed->supported;
+		    edev->leds_defined= ed->ledsDefined;
+		    edev->led_state= ed->ledState;
+		    edev->first_btn= ed->firstBtn;
+		    edev->num_btns= ed->nBtns;
+		    edev->unsupported= ed->unsupported;
+		    return True;
+		}
+	    }
+	    break;
+	case XkbNewKeyboardNotify:
+	    {
+		xkbNewKeyboardNotify *nkn = (xkbNewKeyboardNotify *)event;
+		if ((xkbi->selected_events&XkbNewKeyboardNotifyMask)&&
+				    (xkbi->selected_nkn_details&nkn->changed)) {
+		    XkbNewKeyboardNotifyEvent *nkev;
+		    nkev =(XkbNewKeyboardNotifyEvent *)re;
+		    nkev->type = XkbEventCode+xkbi->codes->first_event;
+		    nkev->xkb_type = XkbNewKeyboardNotify;
+		    nkev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    nkev->send_event = ((event->u.u.type&0x80)!=0);
+		    nkev->display = dpy;
+		    nkev->time = nkn->time;
+		    nkev->device = nkn->deviceID;
+		    nkev->old_device = nkn->oldDeviceID;
+		    nkev->min_key_code = nkn->minKeyCode;
+		    nkev->max_key_code = nkn->maxKeyCode;
+		    nkev->old_min_key_code = nkn->oldMinKeyCode;
+		    nkev->old_max_key_code = nkn->oldMaxKeyCode;
+		    nkev->req_major = nkn->requestMajor;
+		    nkev->req_minor = nkn->requestMinor;
+		    nkev->changed = nkn->changed;
+		    if ((xkbi->desc)&&(nkev->send_event==0)&&
+			((xkbi->desc->device_spec==nkev->old_device)||
+			 (nkev->device!=nkev->old_device))) {
+			xkbi->flags= XkbMapPending|XkbXlibNewKeyboard;
+		    }
+		    return True;
+		}
+		else if(nkn->changed&(XkbNKN_KeycodesMask|XkbNKN_DeviceIDMask)){
+		    register XMappingEvent *ev = (XMappingEvent *)re;
+		    ev->type = MappingNotify;
+		    ev->serial = _XSetLastRequestRead(dpy,
+						(xGenericReply *)event);
+		    ev->send_event = ((event->u.u.type&0x80)!=0);
+		    ev->display = dpy;
+		    ev->window = 0;
+		    ev->first_keycode = dpy->min_keycode;
+		    ev->request = MappingKeyboard;
+		    ev->count = (dpy->max_keycode-dpy->min_keycode)+1;
+		    if ((xkbi->desc)&&(ev->send_event==0)&&
+			((xkbi->desc->device_spec==nkn->oldDeviceID)||
+			 (nkn->deviceID!=nkn->oldDeviceID))) {
+			xkbi->flags|= XkbMapPending|XkbXlibNewKeyboard;
+		    }
+		    return True;
+		}
+	    }
+	    break;
+	default:
+#ifdef DEBUG
+	    fprintf(stderr,"Got unknown XKEYBOARD event (%d, base=%d)\n",
+						re->type,
+						xkbi->codes->first_event);
+#endif
+	    break;
+    }
+    return False;
+}
+
+Bool
+XkbIgnoreExtension(Bool ignore)
+{
+    if (getenv("XKB_FORCE")!=NULL) {
+#ifdef DEBUG
+	fprintf(stderr,"Forcing use of XKEYBOARD (overriding an IgnoreExtensions)\n");
+#endif
+	return False;
+    }
+#ifdef DEBUG
+    else if (getenv("XKB_DEBUG")!=NULL) {
+	fprintf(stderr,"Explicitly %signoring XKEYBOARD\n",ignore?"":"not ");
+    }
+#endif
+    _XkbIgnoreExtension = ignore;
+    return True;
+}
+
+static void
+_XkbFreeInfo(Display *dpy)
+{
+    XkbInfoPtr xkbi = dpy->xkb_info;
+    if (xkbi) {
+	if (xkbi->desc)
+	    XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
+	Xfree(xkbi);
+      }
+}
+
+Bool
+XkbUseExtension(Display *dpy,int *major_rtrn,int *minor_rtrn)
+{
+    xkbUseExtensionReply rep;
+    register xkbUseExtensionReq *req;
+    XExtCodes		*codes;
+    int	ev_base,forceIgnore;
+    XkbInfoPtr xkbi;
+    char *	str;
+    static int debugMsg;
+    static int been_here= 0;
+
+    if ( dpy->xkb_info && !(dpy->flags & XlibDisplayNoXkb)) {
+	if (major_rtrn)	*major_rtrn= dpy->xkb_info->srv_major;
+	if (minor_rtrn)	*minor_rtrn= dpy->xkb_info->srv_minor;
+	return True;
+    }
+    if (!been_here) {
+	debugMsg= (getenv("XKB_DEBUG")!=NULL);
+	been_here= 1;
+    }
+
+    if (major_rtrn)	*major_rtrn= 0;
+    if (minor_rtrn)	*minor_rtrn= 0;
+
+    if (!dpy->xkb_info) {
+        xkbi = _XkbTypedCalloc(1, XkbInfoRec);
+        if ( !xkbi )
+	    return False;
+        dpy->xkb_info = xkbi;
+        dpy->free_funcs->xkb = _XkbFreeInfo;
+
+        xkbi->xlib_ctrls|= (XkbLC_ControlFallback|XkbLC_ConsumeLookupMods);
+        if ((str=getenv("_XKB_OPTIONS_ENABLE"))!=NULL) {
+	    if ((str=getenv("_XKB_LATIN1_LOOKUP"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_ForceLatin1Lookup;
+	        else xkbi->xlib_ctrls|= XkbLC_ForceLatin1Lookup;
+	    }
+	    if ((str=getenv("_XKB_CONSUME_LOOKUP_MODS"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_ConsumeLookupMods;
+	        else xkbi->xlib_ctrls|= XkbLC_ConsumeLookupMods;
+	    }
+	    if ((str=getenv("_XKB_CONSUME_SHIFT_AND_LOCK"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_AlwaysConsumeShiftAndLock;
+	        else xkbi->xlib_ctrls|= XkbLC_AlwaysConsumeShiftAndLock;
+	    }
+	    if ((str=getenv("_XKB_IGNORE_NEW_KEYBOARDS"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_IgnoreNewKeyboards;
+	        else xkbi->xlib_ctrls|= XkbLC_IgnoreNewKeyboards;
+	    }
+	    if ((str=getenv("_XKB_CONTROL_FALLBACK"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_ControlFallback;
+	        else xkbi->xlib_ctrls|= XkbLC_ControlFallback;
+	    }
+	    if ((str=getenv("_XKB_COMP_LED"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		    xkbi->xlib_ctrls&= ~XkbLC_ComposeLED;
+	        else {
+		    xkbi->xlib_ctrls|= XkbLC_ComposeLED;
+		    if (strlen(str)>0)
+		        xkbi->composeLED= XInternAtom(dpy,str,False);
+	        }
+	    }
+	    if ((str=getenv("_XKB_COMP_FAIL_BEEP"))!=NULL) {
+	        if ((strcmp(str,"off")==0)||(strcmp(str,"0")==0))
+		     xkbi->xlib_ctrls&= ~XkbLC_BeepOnComposeFail;
+	        else xkbi->xlib_ctrls|= XkbLC_BeepOnComposeFail;
+	    }
+        }
+        if ((xkbi->composeLED==None)&&((xkbi->xlib_ctrls&XkbLC_ComposeLED)!=0))
+	    xkbi->composeLED= XInternAtom(dpy,"Compose",False);
+#ifdef DEBUG
+        if (debugMsg) {
+	    register unsigned c= xkbi->xlib_ctrls;
+	    fprintf(stderr,"XKEYBOARD compose: beep on failure is %s, LED is %s\n",
+		((c&XkbLC_BeepOnComposeFail)?"on":"off"),
+		((c&XkbLC_ComposeLED)?"on":"off"));
+	    fprintf(stderr,"XKEYBOARD XLookupString: %slatin-1, %s lookup modifiers\n",
+		((c&XkbLC_ForceLatin1Lookup)?"allow non-":"force "),
+		((c&XkbLC_ConsumeLookupMods)?"consume":"re-use"));
+	    fprintf(stderr,
+	        "XKEYBOARD XLookupString: %sconsume shift and lock, %scontrol fallback\n",
+	        ((c&XkbLC_AlwaysConsumeShiftAndLock)?"always ":"don't "),
+	        ((c&XkbLC_ControlFallback)?"":"no "));
+
+        }
+#endif
+    } else
+        xkbi = dpy->xkb_info;
+
+    forceIgnore= (dpy->flags&XlibDisplayNoXkb)||dpy->keysyms;
+    forceIgnore= forceIgnore&&(major_rtrn==NULL)&&(minor_rtrn==NULL);
+    if ( forceIgnore || _XkbIgnoreExtension || getenv("XKB_DISABLE")) {
+	LockDisplay(dpy);
+	dpy->flags |= XlibDisplayNoXkb;
+	UnlockDisplay(dpy);
+	if (debugMsg)
+	    fprintf(stderr,"XKEYBOARD extension disabled or missing\n");
+	return False;
+    }
+
+    if ( (codes=XInitExtension(dpy,XkbName))==NULL ) {
+	LockDisplay(dpy);
+	dpy->flags |= XlibDisplayNoXkb;
+	UnlockDisplay(dpy);
+	if (debugMsg)
+	    fprintf(stderr,"XKEYBOARD extension not present\n");
+	return False;
+    }
+    xkbi->codes = codes;
+    LockDisplay(dpy);
+
+    GetReq(kbUseExtension, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbUseExtension;
+    req->wantedMajor = XkbMajorVersion;
+    req->wantedMinor = XkbMinorVersion;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.supported ) {
+	Bool	fail;
+	fail= True;
+	if (debugMsg)
+	    fprintf(stderr,
+		"XKEYBOARD version mismatch (want %d.%02d, got %d.%02d)\n",
+		XkbMajorVersion,XkbMinorVersion,
+		rep.serverMajor, rep.serverMinor);
+
+	/* pre-release 0.65 is very close to 1.00 */
+	if ((rep.serverMajor==0)&&(rep.serverMinor==65)) {
+	    if (debugMsg)
+		fprintf(stderr,"Trying to fall back to version 0.65...");
+	    GetReq(kbUseExtension, req);
+	    req->reqType = xkbi->codes->major_opcode;
+	    req->xkbReqType = X_kbUseExtension;
+	    req->wantedMajor = 0;
+	    req->wantedMinor = 65;
+	    if ( _XReply(dpy, (xReply *)&rep, 0, xFalse) && rep.supported ) {
+		if (debugMsg)
+		    fprintf(stderr,"succeeded\n");
+		fail= False;
+	    }
+	    else if (debugMsg) fprintf(stderr,"failed\n");
+	}
+	if (fail) {
+	    dpy->flags |= XlibDisplayNoXkb;
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    if (major_rtrn) *major_rtrn= rep.serverMajor;
+	    if (minor_rtrn) *minor_rtrn= rep.serverMinor;
+	    return False;
+	}
+    }
+#ifdef DEBUG
+    else if ( forceIgnore ) {
+	fprintf(stderr,"Internal Error!  XkbUseExtension succeeded with forceIgnore set\n");
+    }
+#endif
+    UnlockDisplay(dpy);
+    xkbi->srv_major= rep.serverMajor;
+    xkbi->srv_minor= rep.serverMinor;
+    if (major_rtrn)	*major_rtrn= rep.serverMajor;
+    if (minor_rtrn)	*minor_rtrn= rep.serverMinor;
+    if (debugMsg)
+	fprintf(stderr,"XKEYBOARD (version %d.%02d/%d.%02d) OK!\n",
+				XkbMajorVersion,XkbMinorVersion,
+				rep.serverMajor,rep.serverMinor);
+
+    ev_base = codes->first_event;
+    XESetWireToEvent(dpy,ev_base+XkbEventCode,wire_to_event);
+    SyncHandle();
+    return True;
+}
+
diff --git a/libX11/src/xkb/XKBleds.c b/libX11/src/xkb/XKBleds.c
index 47811a5c7..d9b743c6f 100644
--- a/libX11/src/xkb/XKBleds.c
+++ b/libX11/src/xkb/XKBleds.c
@@ -1,333 +1,333 @@
-/************************************************************

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

-

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

-

-#define NEED_MAP_READERS

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include "Xlibint.h"

-#include <X11/extensions/XKBproto.h>

-#include "XKBlibint.h"

-

-Status

-XkbGetIndicatorState(Display *dpy,unsigned deviceSpec,unsigned *pStateRtrn)

-{

-    register xkbGetIndicatorStateReq *req;

-    xkbGetIndicatorStateReply	rep;

-    XkbInfoPtr xkbi;

-    Bool ok;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetIndicatorState, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetIndicatorState;

-    req->deviceSpec = deviceSpec;

-    ok=_XReply(dpy, (xReply *)&rep, 0, xFalse);

-    if (ok && (pStateRtrn!=NULL))

-	*pStateRtrn= rep.state;

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return (ok?Success:BadImplementation);

-}

-

-Status

-_XkbReadGetIndicatorMapReply(	Display *			dpy,

-				xkbGetIndicatorMapReply *	rep,

-				XkbDescPtr			xkb,

-				int	*			nread_rtrn)

-{

-XkbIndicatorPtr		leds;

-XkbReadBufferRec	buf;

-

-    if ((!xkb->indicators)&&(XkbAllocIndicatorMaps(xkb)!=Success))

-	return BadAlloc;

-    leds= xkb->indicators;

-

-    leds->phys_indicators = rep->realIndicators;

-    if (rep->length>0) {

-	register int left;

-	if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))

-	    return BadAlloc;

-	if (nread_rtrn)

-	    *nread_rtrn= (int)rep->length*4;

-	if (rep->which) {

-	    register int i,bit;

-	    left= (int)rep->which;

-	    for (i=0,bit=1;(i<XkbNumIndicators)&&(left);i++,bit<<=1) {

-		if (left&bit) {

-		    xkbIndicatorMapWireDesc *wire;

-		    wire= (xkbIndicatorMapWireDesc *)

-			  _XkbGetReadBufferPtr(&buf,

-					SIZEOF(xkbIndicatorMapWireDesc));

-		    if (wire==NULL) {

-			_XkbFreeReadBuffer(&buf);

-			return BadAlloc;

-		    }

-		    leds->maps[i].flags= wire->flags;

-		    leds->maps[i].which_groups= wire->whichGroups;

-		    leds->maps[i].groups= wire->groups;

-		    leds->maps[i].which_mods= wire->whichMods;

-		    leds->maps[i].mods.mask= wire->mods;

-		    leds->maps[i].mods.real_mods= wire->realMods;

-		    leds->maps[i].mods.vmods= wire->virtualMods;

-		    leds->maps[i].ctrls= wire->ctrls;

-		    left&= ~bit;

-		}

-	    }

-	}

-	left= _XkbFreeReadBuffer(&buf);

-    }

-    return Success;

-}

-

-Bool

-XkbGetIndicatorMap(Display *dpy,unsigned long which,XkbDescPtr xkb)

-{

-    register xkbGetIndicatorMapReq *	req;

-    xkbGetIndicatorMapReply 		rep;

-    XkbInfoPtr 				xkbi;

-    Status				status;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return BadAccess;

-    if ((!which)||(!xkb))

-	return BadValue;

-

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    if (!xkb->indicators) {

-	xkb->indicators = _XkbTypedCalloc(1,XkbIndicatorRec);

-	if (!xkb->indicators) {

-	    UnlockDisplay(dpy);

-	    SyncHandle();

-	    return BadAlloc;

-	}

-    }

-    GetReq(kbGetIndicatorMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetIndicatorMap;

-    req->deviceSpec = xkb->device_spec;

-    req->which = (CARD32)which;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return BadValue;

-    }

-    status= _XkbReadGetIndicatorMapReply(dpy,&rep,xkb,NULL);

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return status;

-}

-

-Bool

-XkbSetIndicatorMap(Display *dpy,unsigned long which,XkbDescPtr xkb)

-{

-    register xkbSetIndicatorMapReq	*req;

-    register int i,bit;

-    int nMaps;

-    xkbIndicatorMapWireDesc *wire;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    if ((!xkb)||(!which)||(!xkb->indicators))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetIndicatorMap, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetIndicatorMap;

-    req->deviceSpec = xkb->device_spec;

-    req->which = (CARD32)which;

-    for (i=nMaps=0,bit=1;i<32;i++,bit<<=1) {

-	if (which&bit)

-	    nMaps++;

-    }

-    req->length+= (nMaps*sizeof(XkbIndicatorMapRec))/4;

-    BufAlloc(xkbIndicatorMapWireDesc *,wire,

-				       (nMaps*SIZEOF(xkbIndicatorMapWireDesc)));

-    for (i=0,bit=1;i<32;i++,bit<<=1) {

-	if (which&bit) {

-	    wire->flags= xkb->indicators->maps[i].flags;

-	    wire->whichGroups= xkb->indicators->maps[i].which_groups;

-	    wire->groups= xkb->indicators->maps[i].groups;

-	    wire->whichMods= xkb->indicators->maps[i].which_mods;

-	    wire->mods= xkb->indicators->maps[i].mods.real_mods;

-	    wire->virtualMods= xkb->indicators->maps[i].mods.vmods;

-	    wire->ctrls= xkb->indicators->maps[i].ctrls;

-	    wire++;

-	}

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbGetNamedDeviceIndicator(	Display *		dpy,

-				unsigned		device,

-				unsigned		class,

-				unsigned		id,

-				Atom			name,

-				int	*		pNdxRtrn,

-    				Bool *			pStateRtrn,

-				XkbIndicatorMapPtr	pMapRtrn,

-				Bool *			pRealRtrn)

-{

-    register xkbGetNamedIndicatorReq *req;

-    xkbGetNamedIndicatorReply	rep;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) || (name==None) ||

-	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbGetNamedIndicator, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbGetNamedIndicator;

-    req->deviceSpec = device;

-    req->ledClass = class;

-    req->ledID = id;

-    req->indicator = (CARD32)name;

-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

-	UnlockDisplay(dpy);

-	SyncHandle();

-	return False;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    if ((!rep.found)||(!rep.supported))

-	return False;

-    if (pNdxRtrn!=NULL)

-	*pNdxRtrn= rep.ndx;

-    if (pStateRtrn!=NULL)

-	*pStateRtrn= rep.on;

-    if (pMapRtrn!=NULL) {

-	pMapRtrn->flags= rep.flags;

-	pMapRtrn->which_groups= rep.whichGroups;

-	pMapRtrn->groups= rep.groups;

-	pMapRtrn->which_mods= rep.whichMods;

-	pMapRtrn->mods.mask= rep.mods;

-	pMapRtrn->mods.real_mods= rep.realMods;

-	pMapRtrn->mods.vmods= rep.virtualMods;

-	pMapRtrn->ctrls= rep.ctrls;

-    }

-    if (pRealRtrn!=NULL)

-	*pRealRtrn= rep.realIndicator;

-    return True;

-}

-

-Bool

-XkbGetNamedIndicator(	Display *		dpy,

-			Atom			name,

-			int	*		pNdxRtrn,

-    			Bool *			pStateRtrn,

-			XkbIndicatorMapPtr	pMapRtrn,

-			Bool *			pRealRtrn)

-{

-    return XkbGetNamedDeviceIndicator(dpy,XkbUseCoreKbd,

-					  XkbDfltXIClass,XkbDfltXIId,

-					  name,pNdxRtrn,pStateRtrn,

-					  pMapRtrn,pRealRtrn);

-}

-

-Bool

-XkbSetNamedDeviceIndicator(	Display *		dpy,

-				unsigned		device,

-				unsigned		class,

-				unsigned		id,

-				Atom			name,

-				Bool			changeState,

-				Bool			state,

-				Bool			createNewMap,

-				XkbIndicatorMapPtr	pMap)

-{

-    register xkbSetNamedIndicatorReq	*req;

-    XkbInfoPtr xkbi;

-

-    if ((dpy->flags & XlibDisplayNoXkb) || (name==None) ||

- 	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))

-	return False;

-    LockDisplay(dpy);

-    xkbi = dpy->xkb_info;

-    GetReq(kbSetNamedIndicator, req);

-    req->reqType = xkbi->codes->major_opcode;

-    req->xkbReqType = X_kbSetNamedIndicator;

-    req->deviceSpec = device;

-    req->ledClass = class;

-    req->ledID = id;

-    req->indicator= (CARD32)name;

-    req->setState= changeState;

-    if (req->setState)

-	 req->on= state;

-    else req->on= False;

-    if (pMap!=NULL) {

-	req->setMap= True;

-	req->createMap= createNewMap;

-	req->flags= pMap->flags;

-	req->whichGroups= pMap->which_groups;

-	req->groups= pMap->groups;

-	req->whichMods= pMap->which_mods;

-	req->realMods= pMap->mods.real_mods;

-	req->virtualMods= pMap->mods.vmods;

-	req->ctrls= pMap->ctrls;

-    }

-    else {

-	req->setMap= 		False;

-	req->createMap= 	False;

-	req->flags= 		0;

-	req->whichGroups= 	0;

-	req->groups= 		0;

-	req->whichMods= 	0;

-	req->realMods= 		0;

-	req->virtualMods= 	0;

-	req->ctrls=		0;

-    }

-    UnlockDisplay(dpy);

-    SyncHandle();

-    return True;

-}

-

-Bool

-XkbSetNamedIndicator(	Display *		dpy,

-			Atom			name,

-			Bool			changeState,

-			Bool			state,

-			Bool			createNewMap,

-			XkbIndicatorMapPtr	pMap)

-{

-    return XkbSetNamedDeviceIndicator(dpy,XkbUseCoreKbd,

-					  XkbDfltXIClass,XkbDfltXIId,

-					  name,changeState,state,

-					  createNewMap,pMap);

-}

+/************************************************************
+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.
+
+********************************************************/
+
+#define NEED_MAP_READERS
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include "XKBlibint.h"
+
+Status
+XkbGetIndicatorState(Display *dpy,unsigned deviceSpec,unsigned *pStateRtrn)
+{
+    register xkbGetIndicatorStateReq *req;
+    xkbGetIndicatorStateReply	rep;
+    XkbInfoPtr xkbi;
+    Bool ok;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetIndicatorState, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetIndicatorState;
+    req->deviceSpec = deviceSpec;
+    ok=_XReply(dpy, (xReply *)&rep, 0, xFalse);
+    if (ok && (pStateRtrn!=NULL))
+	*pStateRtrn= rep.state;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return (ok?Success:BadImplementation);
+}
+
+Status
+_XkbReadGetIndicatorMapReply(	Display *			dpy,
+				xkbGetIndicatorMapReply *	rep,
+				XkbDescPtr			xkb,
+				int	*			nread_rtrn)
+{
+XkbIndicatorPtr		leds;
+XkbReadBufferRec	buf;
+
+    if ((!xkb->indicators)&&(XkbAllocIndicatorMaps(xkb)!=Success))
+	return BadAlloc;
+    leds= xkb->indicators;
+
+    leds->phys_indicators = rep->realIndicators;
+    if (rep->length>0) {
+	register int left;
+	if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4))
+	    return BadAlloc;
+	if (nread_rtrn)
+	    *nread_rtrn= (int)rep->length*4;
+	if (rep->which) {
+	    register int i,bit;
+	    left= (int)rep->which;
+	    for (i=0,bit=1;(i<XkbNumIndicators)&&(left);i++,bit<<=1) {
+		if (left&bit) {
+		    xkbIndicatorMapWireDesc *wire;
+		    wire= (xkbIndicatorMapWireDesc *)
+			  _XkbGetReadBufferPtr(&buf,
+					SIZEOF(xkbIndicatorMapWireDesc));
+		    if (wire==NULL) {
+			_XkbFreeReadBuffer(&buf);
+			return BadAlloc;
+		    }
+		    leds->maps[i].flags= wire->flags;
+		    leds->maps[i].which_groups= wire->whichGroups;
+		    leds->maps[i].groups= wire->groups;
+		    leds->maps[i].which_mods= wire->whichMods;
+		    leds->maps[i].mods.mask= wire->mods;
+		    leds->maps[i].mods.real_mods= wire->realMods;
+		    leds->maps[i].mods.vmods= wire->virtualMods;
+		    leds->maps[i].ctrls= wire->ctrls;
+		    left&= ~bit;
+		}
+	    }
+	}
+	left= _XkbFreeReadBuffer(&buf);
+    }
+    return Success;
+}
+
+Bool
+XkbGetIndicatorMap(Display *dpy,unsigned long which,XkbDescPtr xkb)
+{
+    register xkbGetIndicatorMapReq *	req;
+    xkbGetIndicatorMapReply 		rep;
+    XkbInfoPtr 				xkbi;
+    Status				status;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    if ((!which)||(!xkb))
+	return BadValue;
+
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    if (!xkb->indicators) {
+	xkb->indicators = _XkbTypedCalloc(1,XkbIndicatorRec);
+	if (!xkb->indicators) {
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return BadAlloc;
+	}
+    }
+    GetReq(kbGetIndicatorMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetIndicatorMap;
+    req->deviceSpec = xkb->device_spec;
+    req->which = (CARD32)which;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return BadValue;
+    }
+    status= _XkbReadGetIndicatorMapReply(dpy,&rep,xkb,NULL);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return status;
+}
+
+Bool
+XkbSetIndicatorMap(Display *dpy,unsigned long which,XkbDescPtr xkb)
+{
+    register xkbSetIndicatorMapReq	*req;
+    register int i,bit;
+    int nMaps;
+    xkbIndicatorMapWireDesc *wire;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    if ((!xkb)||(!which)||(!xkb->indicators))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetIndicatorMap, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetIndicatorMap;
+    req->deviceSpec = xkb->device_spec;
+    req->which = (CARD32)which;
+    for (i=nMaps=0,bit=1;i<32;i++,bit<<=1) {
+	if (which&bit)
+	    nMaps++;
+    }
+    req->length+= (nMaps*sizeof(XkbIndicatorMapRec))/4;
+    BufAlloc(xkbIndicatorMapWireDesc *,wire,
+				       (nMaps*SIZEOF(xkbIndicatorMapWireDesc)));
+    for (i=0,bit=1;i<32;i++,bit<<=1) {
+	if (which&bit) {
+	    wire->flags= xkb->indicators->maps[i].flags;
+	    wire->whichGroups= xkb->indicators->maps[i].which_groups;
+	    wire->groups= xkb->indicators->maps[i].groups;
+	    wire->whichMods= xkb->indicators->maps[i].which_mods;
+	    wire->mods= xkb->indicators->maps[i].mods.real_mods;
+	    wire->virtualMods= xkb->indicators->maps[i].mods.vmods;
+	    wire->ctrls= xkb->indicators->maps[i].ctrls;
+	    wire++;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbGetNamedDeviceIndicator(	Display *		dpy,
+				unsigned		device,
+				unsigned		class,
+				unsigned		id,
+				Atom			name,
+				int	*		pNdxRtrn,
+    				Bool *			pStateRtrn,
+				XkbIndicatorMapPtr	pMapRtrn,
+				Bool *			pRealRtrn)
+{
+    register xkbGetNamedIndicatorReq *req;
+    xkbGetNamedIndicatorReply	rep;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) || (name==None) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbGetNamedIndicator, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbGetNamedIndicator;
+    req->deviceSpec = device;
+    req->ledClass = class;
+    req->ledID = id;
+    req->indicator = (CARD32)name;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if ((!rep.found)||(!rep.supported))
+	return False;
+    if (pNdxRtrn!=NULL)
+	*pNdxRtrn= rep.ndx;
+    if (pStateRtrn!=NULL)
+	*pStateRtrn= rep.on;
+    if (pMapRtrn!=NULL) {
+	pMapRtrn->flags= rep.flags;
+	pMapRtrn->which_groups= rep.whichGroups;
+	pMapRtrn->groups= rep.groups;
+	pMapRtrn->which_mods= rep.whichMods;
+	pMapRtrn->mods.mask= rep.mods;
+	pMapRtrn->mods.real_mods= rep.realMods;
+	pMapRtrn->mods.vmods= rep.virtualMods;
+	pMapRtrn->ctrls= rep.ctrls;
+    }
+    if (pRealRtrn!=NULL)
+	*pRealRtrn= rep.realIndicator;
+    return True;
+}
+
+Bool
+XkbGetNamedIndicator(	Display *		dpy,
+			Atom			name,
+			int	*		pNdxRtrn,
+    			Bool *			pStateRtrn,
+			XkbIndicatorMapPtr	pMapRtrn,
+			Bool *			pRealRtrn)
+{
+    return XkbGetNamedDeviceIndicator(dpy,XkbUseCoreKbd,
+					  XkbDfltXIClass,XkbDfltXIId,
+					  name,pNdxRtrn,pStateRtrn,
+					  pMapRtrn,pRealRtrn);
+}
+
+Bool
+XkbSetNamedDeviceIndicator(	Display *		dpy,
+				unsigned		device,
+				unsigned		class,
+				unsigned		id,
+				Atom			name,
+				Bool			changeState,
+				Bool			state,
+				Bool			createNewMap,
+				XkbIndicatorMapPtr	pMap)
+{
+    register xkbSetNamedIndicatorReq	*req;
+    XkbInfoPtr xkbi;
+
+    if ((dpy->flags & XlibDisplayNoXkb) || (name==None) ||
+ 	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return False;
+    LockDisplay(dpy);
+    xkbi = dpy->xkb_info;
+    GetReq(kbSetNamedIndicator, req);
+    req->reqType = xkbi->codes->major_opcode;
+    req->xkbReqType = X_kbSetNamedIndicator;
+    req->deviceSpec = device;
+    req->ledClass = class;
+    req->ledID = id;
+    req->indicator= (CARD32)name;
+    req->setState= changeState;
+    if (req->setState)
+	 req->on= state;
+    else req->on= False;
+    if (pMap!=NULL) {
+	req->setMap= True;
+	req->createMap= createNewMap;
+	req->flags= pMap->flags;
+	req->whichGroups= pMap->which_groups;
+	req->groups= pMap->groups;
+	req->whichMods= pMap->which_mods;
+	req->realMods= pMap->mods.real_mods;
+	req->virtualMods= pMap->mods.vmods;
+	req->ctrls= pMap->ctrls;
+    }
+    else {
+	req->setMap= 		False;
+	req->createMap= 	False;
+	req->flags= 		0;
+	req->whichGroups= 	0;
+	req->groups= 		0;
+	req->whichMods= 	0;
+	req->realMods= 		0;
+	req->virtualMods= 	0;
+	req->ctrls=		0;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return True;
+}
+
+Bool
+XkbSetNamedIndicator(	Display *		dpy,
+			Atom			name,
+			Bool			changeState,
+			Bool			state,
+			Bool			createNewMap,
+			XkbIndicatorMapPtr	pMap)
+{
+    return XkbSetNamedDeviceIndicator(dpy,XkbUseCoreKbd,
+					  XkbDfltXIClass,XkbDfltXIId,
+					  name,changeState,state,
+					  createNewMap,pMap);
+}
diff --git a/libX11/src/xkb/XKBlibint.h b/libX11/src/xkb/XKBlibint.h
index bb39f7a22..ce145276c 100644
--- a/libX11/src/xkb/XKBlibint.h
+++ b/libX11/src/xkb/XKBlibint.h
@@ -1,343 +1,343 @@
-/************************************************************

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

-

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

-

-#ifndef _XKBLIBINT_H_

-#define	_XKBLIBINT_H_

-

-#include <X11/Xutil.h>

-#include <X11/XKBlib.h>

-

-#define	XkbMapPending		(1<<0)

-#define	XkbXlibNewKeyboard	(1<<1)

-

-typedef int	(*XkbKSToMBFunc)(

-	XPointer	/* priv */,

-	KeySym		/* sym */,

-	char *		/* buf */,

-	int		/* len */,

-	int *		/* extra_rtrn */

-);

-

-typedef KeySym	(*XkbMBToKSFunc)(

-	XPointer	/* priv */,

-	char *		/* buf */,

-	int		/* len */,

-	Status *	/* status */

-);

-

-typedef KeySym	(*XkbToUpperFunc)(

-	KeySym		/* sym */

-);

-

-typedef struct _XkbConverters {

-	XkbKSToMBFunc	 KSToMB;

-	XPointer	 KSToMBPriv;

-	XkbMBToKSFunc	 MBToKS;

-	XPointer	 MBToKSPriv;

-	XkbToUpperFunc	 KSToUpper;

-} XkbConverters;

-

-extern	XkbInternAtomFunc	_XkbInternAtomFunc;

-extern	XkbGetAtomNameFunc	_XkbGetAtomNameFunc;

-

-typedef struct _XkbInfoRec {

-	unsigned	 flags;

-	unsigned	 xlib_ctrls;

-	XExtCodes	 *codes;

-	int		 srv_major;

-	int		 srv_minor;

-	unsigned	 selected_events;

-	unsigned short	 selected_nkn_details;

-	unsigned short	 selected_map_details;

-	XkbDescRec	*desc;

-	XkbMapChangesRec changes;

-	Atom		 composeLED;

-	XkbConverters	 cvt;

-	XkbConverters	 latin1cvt;

-} XkbInfoRec, *XkbInfoPtr;

-

-

-#define	_XkbUnavailable(d) \

-	(((d)->flags&XlibDisplayNoXkb) ||\

-	 ((!(d)->xkb_info || (!(d)->xkb_info->desc)) && !_XkbLoadDpy(d)))

-

-#define	_XkbCheckPendingRefresh(d,xi) {\

-    if ((xi)->flags&XkbXlibNewKeyboard)\

-	_XkbReloadDpy((d));\

-    else if ((xi)->flags&XkbMapPending) {\

-	if (XkbGetMapChanges((d),(xi)->desc, &(xi)->changes)==Success) {\

-	    LockDisplay((d));\

-	    (xi)->changes.changed= 0;\

-	    UnlockDisplay((d));\

-	}\

-    }\

-}

-

-#define	_XkbNeedModmap(i)    ((!(i)->desc->map)||(!(i)->desc->map->modmap))

-

-	/*

-	 * mask of the events that the "invisible" XKB support in Xlib needs

-	 */

-#define XKB_XLIB_MAP_MASK (XkbAllClientInfoMask)

-

-	/*

-	 * Handy helper macros

-	 */

-#define	XKB_INSURE_SIZE(f,t,nNum,oNum)	{\

-	if ((f)==NULL)	\

-	     (f)=(t *)Xmalloc(sizeof(t)*(nNum));\

-	else if ((nNum)<(oNum))\

-	     (f)=(t *)Xrealloc((f),sizeof(t)*(nNum));\

-	}

-

-typedef struct _XkbReadBuffer {

-	int	 error;

-	int	 size;

-	char	*start;

-	char	*data;

-} XkbReadBufferRec,*XkbReadBufferPtr;

-

-#define	_XkbAlloc(s)		Xmalloc((s))

-#define	_XkbCalloc(n,s)		Xcalloc((n),(s))

-#define	_XkbRealloc(o,s)	Xrealloc((o),(s))

-#define	_XkbTypedAlloc(t)	((t *)Xmalloc(sizeof(t)))

-#define	_XkbTypedCalloc(n,t)	((t *)Xcalloc((n),sizeof(t)))

-#define	_XkbTypedRealloc(o,n,t) \

-	((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t))

-#define	_XkbClearElems(a,f,l,t)	bzero(&(a)[f],((l)-(f)+1)*sizeof(t))

-#define	_XkbFree(p)		Xfree(p)

-

-_XFUNCPROTOBEGIN

-

-extern	void _XkbReloadDpy(

-    Display *		/* dpy */

-);

-

-extern KeySym _XKeycodeToKeysym(

-    Display*		/* display */,

-#if NeedWidePrototypes

-    unsigned int	/* keycode */,

-#else

-    KeyCode		/* keycode */,

-#endif

-    int			/* index */

-);

-

-extern KeyCode _XKeysymToKeycode(

-    Display*		/* display */,

-    KeySym		/* keysym */

-);

-

-extern KeySym _XLookupKeysym(

-    XKeyEvent*		/* key_event */,

-    int			/* index */

-);

-

-extern int _XRefreshKeyboardMapping(

-    XMappingEvent*	/* event_map */

-);

-

-extern unsigned	_XKeysymToModifiers(

-    Display *		/* dpy */,

-    KeySym 		/* ks */

-);

-

-extern int _XTranslateKey(

-    register Display *	/* dpy */,

-    KeyCode 		/* keycode */,

-    register unsigned int /* modifiers */,

-    unsigned int *	/* modifiers_return */,

-    KeySym *		/* keysym_return */

-);

-

-extern int	_XTranslateKeySym(

-    Display *		/* dpy */,

-    register KeySym 	/* symbol */,

-    unsigned int 	/* modifiers */,

-    char *		/* buffer */,

-    int 		/* nbytes */

-);

-

-extern	int _XLookupString(

-    register XKeyEvent *	/* event */,

-    char *			/* buffer */,

-    int 			/* nbytes */,

-    KeySym *			/* keysym */,

-    XComposeStatus *		/* status */

-);

-

-extern void _XkbNoteCoreMapChanges(

-    XkbMapChangesRec * 		/* old */,

-    XMappingEvent * 		/* new */,

-    unsigned int 		/* wanted */

-);

-

-extern	int _XkbInitReadBuffer(

-    Display *		/* dpy */,

-    XkbReadBufferPtr	/* buf */,

-    int			/* size */

-);

-

-extern int _XkbSkipReadBufferData(

-    XkbReadBufferPtr	/* from */,

-    int			/* size */

-);

-

-extern int _XkbCopyFromReadBuffer(

-    XkbReadBufferPtr	/* from */,

-    char *		/* to */,

-    int			/* size */

-);

-

-

-#if defined(WORD64) || defined(LONG64)

-extern	int _XkbReadCopyData32(

-    int *		/* from */,

-    long *		/* to */,

-    int			/* num_words */

-);

-

-extern	int _XkbWriteCopyData32(

-    unsigned long *	/* from */,

-    CARD32 *		/* to */,

-    int			/* num_words */

-);

-

-extern int _XkbReadBufferCopy32(

-    XkbReadBufferPtr	/* from */,

-    long *		/* to */,

-    int			/* size */

-);

-#else

-#define	_XkbReadCopyData32(f,t,s)    memcpy((char *)(t),(char *)(f),(s)*4)

-#define	_XkbWriteCopyData32(f,t,s)   memcpy((char *)(t),(char *)(f),(s)*4)

-#define	_XkbReadBufferCopy32(f,t,s) _XkbCopyFromReadBuffer(f,(char *)t,(s)*4)

-#endif

-

-#ifndef NO_DEC_BINARY_COMPATIBILITY

-#define XKB_FORCE_INT_KEYSYM 1

-#endif

-

-#ifdef XKB_FORCE_INT_KEYSYM

-extern int _XkbReadCopyKeySyms(

-    int *		/* from */,

-    KeySym *		/* to */,

-    int			/* num_words */

-);

-

-extern	int _XkbWriteCopyKeySyms(

-    KeySym *		/* from */,

-    CARD32 *		/* to */,

-    int			/* num_words */

-);

-

-extern int _XkbReadBufferCopyKeySyms(

-    XkbReadBufferPtr	/* from */,

-#ifndef NO_DEC_BUG_FIX

-    KeySym *		/* to */,

-#else

-    long *		/* to */,

-#endif

-    int			/* size */

-);

-#else

-#define	_XkbReadCopyKeySyms(f,t,n)		_XkbReadCopyData32(f,t,n)

-#define	_XkbWriteCopyKeySyms(f,t,n)		_XkbWriteCopyData32(f,t,n)

-#define	_XkbReadBufferCopyKeySyms(f,t,s)	_XkbReadBufferCopy32(f,t,s)

-#endif

-

-extern char *_XkbPeekAtReadBuffer(

-    XkbReadBufferPtr	/* from */,

-    int			/*  size */

-);

-

-extern char *_XkbGetReadBufferPtr(

-    XkbReadBufferPtr	/* from */,

-    int			/* size */

-);

-#define	_XkbGetTypedRdBufPtr(b,n,t) ((t *)_XkbGetReadBufferPtr(b,(n)*SIZEOF(t)))

-

-extern int _XkbFreeReadBuffer(

-    XkbReadBufferPtr	/* buf */

-);

-

-extern Bool

-_XkbGetReadBufferCountedString(

-    XkbReadBufferPtr	/* buf */,

-    char **		/* rtrn */

-);

-

-extern char	*_XkbGetCharset(

-    void

-);

-

-extern int	 _XkbGetConverters(

-    const char *       /* encoding_name */,

-    XkbConverters *    /* cvt_rtrn */

-);

-

-#ifdef	NEED_MAP_READERS

-

-extern	Status	_XkbReadGetMapReply(

-    Display *		/* dpy */,

-    xkbGetMapReply * 	/* rep */,

-    XkbDescRec *	/* xkb */,

-    int *		/* nread_rtrn */

-);

-

-extern	Status	_XkbReadGetCompatMapReply(

-    Display *			/* dpy */,

-    xkbGetCompatMapReply *	/* rep */,

-    XkbDescPtr			/* xkb */,

-    int	*			/* nread_rtrn */

-);

-

-extern	Status	_XkbReadGetIndicatorMapReply(

-    Display *			/* dpy */,

-    xkbGetIndicatorMapReply *	/* rep */,

-    XkbDescPtr			/* xkb */,

-    int	*			/* nread_rtrn */

-);

-

-extern	Status	_XkbReadGetNamesReply(

-    Display *			/* dpy */,

-    xkbGetNamesReply *		/* rep */,

-    XkbDescPtr 			/* xkb */,

-    int *			/* nread_rtrn */

-);

-

-extern	Status	_XkbReadGetGeometryReply(

-    Display *			/* dpy */,

-    xkbGetGeometryReply *	/* rep */,

-    XkbDescPtr 			/* xkb */,

-    int *			/* nread_rtrn */

-);

-

-#endif

-

-_XFUNCPROTOEND

-

-#endif /* _XKBLIBINT_H_ */

+/************************************************************
+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.
+
+********************************************************/
+
+#ifndef _XKBLIBINT_H_
+#define	_XKBLIBINT_H_
+
+#include <X11/Xutil.h>
+#include <X11/XKBlib.h>
+
+#define	XkbMapPending		(1<<0)
+#define	XkbXlibNewKeyboard	(1<<1)
+
+typedef int	(*XkbKSToMBFunc)(
+	XPointer	/* priv */,
+	KeySym		/* sym */,
+	char *		/* buf */,
+	int		/* len */,
+	int *		/* extra_rtrn */
+);
+
+typedef KeySym	(*XkbMBToKSFunc)(
+	XPointer	/* priv */,
+	char *		/* buf */,
+	int		/* len */,
+	Status *	/* status */
+);
+
+typedef KeySym	(*XkbToUpperFunc)(
+	KeySym		/* sym */
+);
+
+typedef struct _XkbConverters {
+	XkbKSToMBFunc	 KSToMB;
+	XPointer	 KSToMBPriv;
+	XkbMBToKSFunc	 MBToKS;
+	XPointer	 MBToKSPriv;
+	XkbToUpperFunc	 KSToUpper;
+} XkbConverters;
+
+extern	XkbInternAtomFunc	_XkbInternAtomFunc;
+extern	XkbGetAtomNameFunc	_XkbGetAtomNameFunc;
+
+typedef struct _XkbInfoRec {
+	unsigned	 flags;
+	unsigned	 xlib_ctrls;
+	XExtCodes	 *codes;
+	int		 srv_major;
+	int		 srv_minor;
+	unsigned	 selected_events;
+	unsigned short	 selected_nkn_details;
+	unsigned short	 selected_map_details;
+	XkbDescRec	*desc;
+	XkbMapChangesRec changes;
+	Atom		 composeLED;
+	XkbConverters	 cvt;
+	XkbConverters	 latin1cvt;
+} XkbInfoRec, *XkbInfoPtr;
+
+
+#define	_XkbUnavailable(d) \
+	(((d)->flags&XlibDisplayNoXkb) ||\
+	 ((!(d)->xkb_info || (!(d)->xkb_info->desc)) && !_XkbLoadDpy(d)))
+
+#define	_XkbCheckPendingRefresh(d,xi) {\
+    if ((xi)->flags&XkbXlibNewKeyboard)\
+	_XkbReloadDpy((d));\
+    else if ((xi)->flags&XkbMapPending) {\
+	if (XkbGetMapChanges((d),(xi)->desc, &(xi)->changes)==Success) {\
+	    LockDisplay((d));\
+	    (xi)->changes.changed= 0;\
+	    UnlockDisplay((d));\
+	}\
+    }\
+}
+
+#define	_XkbNeedModmap(i)    ((!(i)->desc->map)||(!(i)->desc->map->modmap))
+
+	/*
+	 * mask of the events that the "invisible" XKB support in Xlib needs
+	 */
+#define XKB_XLIB_MAP_MASK (XkbAllClientInfoMask)
+
+	/*
+	 * Handy helper macros
+	 */
+#define	XKB_INSURE_SIZE(f,t,nNum,oNum)	{\
+	if ((f)==NULL)	\
+	     (f)=(t *)Xmalloc(sizeof(t)*(nNum));\
+	else if ((nNum)<(oNum))\
+	     (f)=(t *)Xrealloc((f),sizeof(t)*(nNum));\
+	}
+
+typedef struct _XkbReadBuffer {
+	int	 error;
+	int	 size;
+	char	*start;
+	char	*data;
+} XkbReadBufferRec,*XkbReadBufferPtr;
+
+#define	_XkbAlloc(s)		Xmalloc((s))
+#define	_XkbCalloc(n,s)		Xcalloc((n),(s))
+#define	_XkbRealloc(o,s)	Xrealloc((o),(s))
+#define	_XkbTypedAlloc(t)	((t *)Xmalloc(sizeof(t)))
+#define	_XkbTypedCalloc(n,t)	((t *)Xcalloc((n),sizeof(t)))
+#define	_XkbTypedRealloc(o,n,t) \
+	((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t))
+#define	_XkbClearElems(a,f,l,t)	bzero(&(a)[f],((l)-(f)+1)*sizeof(t))
+#define	_XkbFree(p)		Xfree(p)
+
+_XFUNCPROTOBEGIN
+
+extern	void _XkbReloadDpy(
+    Display *		/* dpy */
+);
+
+extern KeySym _XKeycodeToKeysym(
+    Display*		/* display */,
+#if NeedWidePrototypes
+    unsigned int	/* keycode */,
+#else
+    KeyCode		/* keycode */,
+#endif
+    int			/* index */
+);
+
+extern KeyCode _XKeysymToKeycode(
+    Display*		/* display */,
+    KeySym		/* keysym */
+);
+
+extern KeySym _XLookupKeysym(
+    XKeyEvent*		/* key_event */,
+    int			/* index */
+);
+
+extern int _XRefreshKeyboardMapping(
+    XMappingEvent*	/* event_map */
+);
+
+extern unsigned	_XKeysymToModifiers(
+    Display *		/* dpy */,
+    KeySym 		/* ks */
+);
+
+extern int _XTranslateKey(
+    register Display *	/* dpy */,
+    KeyCode 		/* keycode */,
+    register unsigned int /* modifiers */,
+    unsigned int *	/* modifiers_return */,
+    KeySym *		/* keysym_return */
+);
+
+extern int	_XTranslateKeySym(
+    Display *		/* dpy */,
+    register KeySym 	/* symbol */,
+    unsigned int 	/* modifiers */,
+    char *		/* buffer */,
+    int 		/* nbytes */
+);
+
+extern	int _XLookupString(
+    register XKeyEvent *	/* event */,
+    char *			/* buffer */,
+    int 			/* nbytes */,
+    KeySym *			/* keysym */,
+    XComposeStatus *		/* status */
+);
+
+extern void _XkbNoteCoreMapChanges(
+    XkbMapChangesRec * 		/* old */,
+    XMappingEvent * 		/* new */,
+    unsigned int 		/* wanted */
+);
+
+extern	int _XkbInitReadBuffer(
+    Display *		/* dpy */,
+    XkbReadBufferPtr	/* buf */,
+    int			/* size */
+);
+
+extern int _XkbSkipReadBufferData(
+    XkbReadBufferPtr	/* from */,
+    int			/* size */
+);
+
+extern int _XkbCopyFromReadBuffer(
+    XkbReadBufferPtr	/* from */,
+    char *		/* to */,
+    int			/* size */
+);
+
+
+#if defined(WORD64) || defined(LONG64)
+extern	int _XkbReadCopyData32(
+    int *		/* from */,
+    long *		/* to */,
+    int			/* num_words */
+);
+
+extern	int _XkbWriteCopyData32(
+    unsigned long *	/* from */,
+    CARD32 *		/* to */,
+    int			/* num_words */
+);
+
+extern int _XkbReadBufferCopy32(
+    XkbReadBufferPtr	/* from */,
+    long *		/* to */,
+    int			/* size */
+);
+#else
+#define	_XkbReadCopyData32(f,t,s)    memcpy((char *)(t),(char *)(f),(s)*4)
+#define	_XkbWriteCopyData32(f,t,s)   memcpy((char *)(t),(char *)(f),(s)*4)
+#define	_XkbReadBufferCopy32(f,t,s) _XkbCopyFromReadBuffer(f,(char *)t,(s)*4)
+#endif
+
+#ifndef NO_DEC_BINARY_COMPATIBILITY
+#define XKB_FORCE_INT_KEYSYM 1
+#endif
+
+#ifdef XKB_FORCE_INT_KEYSYM
+extern int _XkbReadCopyKeySyms(
+    int *		/* from */,
+    KeySym *		/* to */,
+    int			/* num_words */
+);
+
+extern	int _XkbWriteCopyKeySyms(
+    KeySym *		/* from */,
+    CARD32 *		/* to */,
+    int			/* num_words */
+);
+
+extern int _XkbReadBufferCopyKeySyms(
+    XkbReadBufferPtr	/* from */,
+#ifndef NO_DEC_BUG_FIX
+    KeySym *		/* to */,
+#else
+    long *		/* to */,
+#endif
+    int			/* size */
+);
+#else
+#define	_XkbReadCopyKeySyms(f,t,n)		_XkbReadCopyData32(f,t,n)
+#define	_XkbWriteCopyKeySyms(f,t,n)		_XkbWriteCopyData32(f,t,n)
+#define	_XkbReadBufferCopyKeySyms(f,t,s)	_XkbReadBufferCopy32(f,t,s)
+#endif
+
+extern char *_XkbPeekAtReadBuffer(
+    XkbReadBufferPtr	/* from */,
+    int			/*  size */
+);
+
+extern char *_XkbGetReadBufferPtr(
+    XkbReadBufferPtr	/* from */,
+    int			/* size */
+);
+#define	_XkbGetTypedRdBufPtr(b,n,t) ((t *)_XkbGetReadBufferPtr(b,(n)*SIZEOF(t)))
+
+extern int _XkbFreeReadBuffer(
+    XkbReadBufferPtr	/* buf */
+);
+
+extern Bool
+_XkbGetReadBufferCountedString(
+    XkbReadBufferPtr	/* buf */,
+    char **		/* rtrn */
+);
+
+extern char	*_XkbGetCharset(
+    void
+);
+
+extern int	 _XkbGetConverters(
+    const char *       /* encoding_name */,
+    XkbConverters *    /* cvt_rtrn */
+);
+
+#ifdef	NEED_MAP_READERS
+
+extern	Status	_XkbReadGetMapReply(
+    Display *		/* dpy */,
+    xkbGetMapReply * 	/* rep */,
+    XkbDescRec *	/* xkb */,
+    int *		/* nread_rtrn */
+);
+
+extern	Status	_XkbReadGetCompatMapReply(
+    Display *			/* dpy */,
+    xkbGetCompatMapReply *	/* rep */,
+    XkbDescPtr			/* xkb */,
+    int	*			/* nread_rtrn */
+);
+
+extern	Status	_XkbReadGetIndicatorMapReply(
+    Display *			/* dpy */,
+    xkbGetIndicatorMapReply *	/* rep */,
+    XkbDescPtr			/* xkb */,
+    int	*			/* nread_rtrn */
+);
+
+extern	Status	_XkbReadGetNamesReply(
+    Display *			/* dpy */,
+    xkbGetNamesReply *		/* rep */,
+    XkbDescPtr 			/* xkb */,
+    int *			/* nread_rtrn */
+);
+
+extern	Status	_XkbReadGetGeometryReply(
+    Display *			/* dpy */,
+    xkbGetGeometryReply *	/* rep */,
+    XkbDescPtr 			/* xkb */,
+    int *			/* nread_rtrn */
+);
+
+#endif
+
+_XFUNCPROTOEND
+
+#endif /* _XKBLIBINT_H_ */