X11R6.1 beta (seq-4104)

author: dawes <dawes> 1996-02-04 07:32:31 +0000
committer: dawes <dawes> 1996-02-04 07:32:31 +0000
commit: f672e940f91aaaea21feb4395fcb4f7bd701a9a9 (patch)
tree: 70ceaf230f7f0818e408cea639fa90eb0d045333
parent: 40f7145e28a483bcd00a9680c5d9d6385d98fcf4 (diff)
20 files changed, 2400 insertions, 567 deletions
diff --git a/config/cf/NetBSD.cf b/config/cf/NetBSD.cf
index 6ebe54903..ef9ccc173 100644
--- a/config/cf/NetBSD.cf
+++ b/config/cf/NetBSD.cf
@@ -1,5 +1,10 @@
-XCOMM platform:  $XConsortium: NetBSD.cf /main/13 1996/01/22 17:35:44 gildea $
-XCOMM platform:  $XFree86: xc/config/cf/NetBSD.cf,v 3.24 1995/12/07 07:14:23 dawes Exp $
+XCOMM platform:  $XConsortium: NetBSD.cf /main/14 1996/01/28 07:42:14 kaleb $
+
+
+
+
+
+XCOMM platform:  $XFree86: xc/config/cf/NetBSD.cf,v 3.30 1996/01/28 07:27:35 dawes Exp $
 
 #ifndef OSName
 #define OSName		NetBSD 1.1
@@ -96,6 +101,9 @@ XCOMM operating system:  OSName
 # else
 #  define ServerOSDefines 	/**/
 # endif
+# ifndef XFree86ConsoleDefines
+#  define XFree86ConsoleDefines -DPCCONS_SUPPORT -DPCVT_SUPPORT
+# endif
 #endif
 #ifdef i386Architecture
 #define ServerExtraDefines GccGasOption XFree86ServerDefines
diff --git a/config/cf/bsdLib.rules b/config/cf/bsdLib.rules
index e6c6c01b1..4c8ee831e 100644
--- a/config/cf/bsdLib.rules
+++ b/config/cf/bsdLib.rules
@@ -1,4 +1,4 @@
-XCOMM $XConsortium: bsdLib.rules,v 1.1 94/03/29 15:34:45 gildea Exp $
+XCOMM $XConsortium: bsdLib.rules /main/2 1996/01/24 06:38:15 kaleb $
 
 /*
  * NetBSD/FreeBSD shared library rules
@@ -7,9 +7,6 @@ XCOMM $XConsortium: bsdLib.rules,v 1.1 94/03/29 15:34:45 gildea Exp $
 #ifndef HasSharedLibraries
 #define HasSharedLibraries YES
 #endif
-#ifndef ForceNormalLib
-#define ForceNormalLib YES
-#endif
 #ifndef SharedDataSeparation
 #define SharedDataSeparation NO
 #endif
diff --git a/lib/X11/Imakefile b/lib/X11/Imakefile
index 4d6fbc1aa..849736684 100644
--- a/lib/X11/Imakefile
+++ b/lib/X11/Imakefile
@@ -1,4 +1,4 @@
-XCOMM $XConsortium: Imakefile /main/190 1996/01/16 19:51:54 kaleb $
+XCOMM $XConsortium: Imakefile /main/192 1996/02/02 16:15:49 kaleb $
 #define DoNormalLib NormalLibX11
 #define DoSharedLib SharedLibX11
 #define DoDebugLib DebugLibX11
@@ -31,14 +31,16 @@ EXTRA_LIBRARIES = /**/
         XDMAUTHSRCS = Wrap.c Wraphelp.c
 #endif
 #if BuildXKBlib
-    XKB_DEFINES = -DXKB
+    XKB_DEFINES = -DXKB 
         XKBSRCS = 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 XKBExtDev.c XKBList.c \
+		  XKBleds.c XKBBell.c XKBGeom.c XKBSetGeom.c XKBExtDev.c \
+		  XKBList.c XKBMisc.c \
 		  XKBMAlloc.c XKBGAlloc.c XKBAlloc.c
         XKBOBJS = XKB.o XKBBind.o XKBCompat.o XKBCtrls.o XKBCvt.o XKBGetMap.o \
 		  XKBGetByName.o XKBNames.o XKBRdBuf.o XKBSetMap.o XKBUse.o \
-		  XKBleds.o XKBBell.o XKBGeom.o XKBExtDev.o XKBList.o \
+		  XKBleds.o XKBBell.o XKBGeom.o XKBSetGeom.o XKBExtDev.o \
+		  XKBList.o XKBMisc.o \
 		  XKBMAlloc.o XKBGAlloc.o XKBAlloc.o
 #endif
 #if HasSecureRPC
@@ -812,7 +814,7 @@ LCSRCS = \
 	omTextEsc.c \
 	omTextExt.c \
 	omTextPer.c \
-	omXChar.c 
+	omXChar.c
 
 /*
 #if defined(SunArchitecture) && defined(HasSharedLibraries)
diff --git a/lib/X11/KeyBind.c b/lib/X11/KeyBind.c
index 4b1a6ffdf..7ab599421 100644
--- a/lib/X11/KeyBind.c
+++ b/lib/X11/KeyBind.c
@@ -1,4 +1,4 @@
-/* $XConsortium: KeyBind.c /main/54 1995/12/07 21:12:52 kaleb $ */
+/* $XConsortium: KeyBind.c /main/55 1996/02/02 14:08:55 kaleb $ */
 /* 
 
 Copyright (c) 1985, 1987,  X Consortium
@@ -42,6 +42,10 @@ in this Software without prior written authorization from the X Consortium.
 #include <X11/keysymdef.h>
 #include <stdio.h>
 
+#ifdef USE_OWN_COMPOSE
+#include "imComp.h"
+#endif
+
 #ifdef XKB
 #define	XKeycodeToKeysym	_XKeycodeToKeysym
 #define	XKeysymToKeycode	_XKeysymToKeycode
@@ -55,7 +59,7 @@ in this Software without prior written authorization from the X Consortium.
 #define AllMods (ShiftMask|LockMask|ControlMask| \
 		 Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
 
-static ComputeMaskFromKeytrans();
+static void ComputeMaskFromKeytrans();
 
 struct _XKeytrans {
 	struct _XKeytrans *next;/* next on list */
@@ -532,6 +536,73 @@ XLookupString (event, buffer, nbytes, keysym, status)
 		  &modifiers, &symbol))
 	return 0;
 
+#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(symbol,event->keycode,status) ) {
+	    XimCompRtrn rtrn;
+	    switch (XimCompProcessSym(status,symbol,&rtrn)) {
+		case XIM_COMP_IGNORE:
+		    break;
+		case XIM_COMP_IN_PROGRESS:
+		    if ( keysym!=NULL )
+			*keysym = NoSymbol;
+		    return 0;
+		case XIM_COMP_FAIL:
+		{
+		    int n = 0, len= 0;
+		    for (n=len=0;rtrn.sym[n]!=XK_VoidSymbol;n++) {
+			if ( nbytes-len > 0 ) {
+			    len+= _XTranslateKeySym(event->display,rtrn.sym[n],
+							event->state,
+							buffer+len,nbytes-len);
+			}
+		    }
+		    if ( keysym!=NULL ) {
+			if ( n==1 )	*keysym = rtrn.sym[0];
+			else		*keysym = NoSymbol;
+		    }
+		    return len;
+		}
+		case XIM_COMP_SUCCEED:
+		{
+		    int len,n = 0;
+
+		    symbol = rtrn.matchSym;
+		    if ( keysym!=NULL )	*keysym = symbol;
+		    if ( rtrn.str[0]!='\0' ) {
+			strncpy(buffer,rtrn.str,nbytes-1);
+			buffer[nbytes-1]= '\0';
+			len = strlen(buffer);
+		    }
+		    else {
+			len = _XTranslateKeySym(event->display,symbol,
+							event->state,
+							buffer,nbytes);
+		    }
+		    for (n=0;rtrn.sym[n]!=XK_VoidSymbol;n++) {
+			if ( nbytes-len > 0 ) {
+			    len+= _XTranslateKeySym(event->display,rtrn.sym[n],
+							event->state,
+							buffer+len,nbytes-len);
+			}
+		    }
+		    return len;
+		}
+	    }
+	}
+    }
+#endif
+
     if (keysym)
 	*keysym = symbol;
     /* arguable whether to use (event->state & ~modifiers) here */
@@ -646,7 +717,7 @@ _XKeysymToModifiers(dpy,ks)
  * what modifier it is bound to, if any.  Sets the AnyModifier bit if it
  * can't map some keysym to a modifier.
  */
-static
+static void
 ComputeMaskFromKeytrans(dpy, p)
     Display *dpy;
     register struct _XKeytrans *p;
diff --git a/lib/X11/OpenDis.c b/lib/X11/OpenDis.c
index a5c492ea6..1af8160b1 100644
--- a/lib/X11/OpenDis.c
+++ b/lib/X11/OpenDis.c
@@ -1,4 +1,4 @@
-/* $XConsortium: OpenDis.c /main/109 1995/11/30 19:02:39 kaleb $ */
+/* $XConsortium: OpenDis.c /main/110 1996/02/02 14:09:01 kaleb $ */
 /*
 
 Copyright (c) 1985, 1986  X Consortium
@@ -589,7 +589,7 @@ Display *XOpenDisplay (display)
 	}
 #endif
 #ifdef XKB
-	XkbUseExtension(dpy,NULL, NULL);
+	XkbUseExtension(dpy,NULL,NULL);
 #endif
 /*
  * and return successfully
diff --git a/lib/X11/XErrorDB b/lib/X11/XErrorDB
index d932d8a2f..67603bdaa 100644
--- a/lib/X11/XErrorDB
+++ b/lib/X11/XErrorDB
@@ -1,4 +1,4 @@
-! $XConsortium: XErrorDB /main/33 1995/12/09 15:44:40 kaleb $
+! $XConsortium: XErrorDB /main/37 1996/02/02 16:08:31 kaleb $
 ! Copyright (c) 1993, 1995  X Consortium
 ! 
 ! Permission is hereby granted, free of charge, to any person obtaining
@@ -502,7 +502,7 @@ XRequest.GLX.102: X_GLXEndList
 XRequest.GLX.105: X_GLXFeedbackBuffer
 XRequest.GLX.108: X_GLXFinish
 XRequest.GLX.142: X_GLXFlush
-XRequest.GLX.104: X_GLXGenList
+XRequest.GLX.104: X_GLXGenLists
 XRequest.GLX.112: X_GLXGetBooleanv
 XRequest.GLX.113: X_GLXGetClipPlane
 XRequest.GLX.114: X_GLXGetDoublev
@@ -574,20 +574,26 @@ XRequest.XFree86-VidModeExtension.2: XF86VidModeModModeLine
 XRequest.XFree86-VidModeExtension.3: XF86VidModeSwitchMode
 XRequest.XFree86-VidModeExtension.4: XF86VidModeGetMonitor
 XRequest.XFree86-VidModeExtension.5: XF86VidModeLockModeSwitch
-XRequest.XFree86-VidModeExtension.6: XF86VidModeGetSaver
-XRequest.XFree86-VidModeExtension.7: XF86VidModeSetSaver
-XRequest.XFree86-VidModeExtension.8: XF86VidModeGetServerName
+XRequest.XFree86-VidModeExtension.6: XF86VidModeGetAllModeLines
 XProtoError.XFree86-VidModeExtension.0: XF86VidModeBadClock
 XProtoError.XFree86-VidModeExtension.1: XF86VidModeBadHTimings
 XProtoError.XFree86-VidModeExtension.2: XF86VidModeBadVTimings
 XProtoError.XFree86-VidModeExtension.3: XF86VidModeModeUnsuitable
+XProtoError.XFree86-VidModeExtension.4: XF86VidModeExtensionDisabled
+XProtoError.XFree86-VidModeExtension.5: XF86VidModeClientNotLocal
+XProtoError.XFree86-VidModeExtension.6: XF86VidModeZoomLocked
 ! XFree86-DGA  -- not an X Consortium standard
-XRequest.XFree86-DGA.0: XF86DGAGetVideoLL
-XRequest.XFree86-DGA.1: XF86DGADirectVideo
-XRequest.XFree86-DGA.2: XF86DGAGetViewPort
-XRequest.XFree86-DGA.3: XF86DGASetViewPort
-XRequest.XFree86-DGA.4: XF86DGAGetVidPage
-XRequest.XFree86-DGA.5: XF86DGASetVidPage
+XRequest.XFree86-DGA.0: XF86DGAQueryVersion
+XRequest.XFree86-DGA.1: XF86DGAGetVideoLL
+XRequest.XFree86-DGA.2: XF86DGADirectVideo
+XRequest.XFree86-DGA.3: XF86DGAGetViewPort
+XRequest.XFree86-DGA.4: XF86DGASetViewPort
+XRequest.XFree86-DGA.5: XF86DGAGetVidPage
+XRequest.XFree86-DGA.6: XF86DGASetVidPage
+XProtoError.XFree86-DGA.0: XF86DGAClientNotLocal
+XProtoError.XFree86-DGA.1: XF86DGANoDirectVideoMode
+XProtoError.XFree86-DGA.2: XF86DGAScreenNotActive
+XProtoError.XFree86-DGA.3: XF86DGADirectNotActivated
 ! DOUBLE-BUFFER (DBE), an X Consortium standard
 XRequest.DOUBLE-BUFFER.0: DBEGetVersion
 XRequest.DOUBLE-BUFFER.1: DBEAllocateBackBufferName
diff --git a/lib/X11/XKB.c b/lib/X11/XKB.c
index 2b3766f78..3d3c21d7b 100644
--- a/lib/X11/XKB.c
+++ b/lib/X11/XKB.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKB.c /main/18 1996/01/14 16:42:40 kaleb $ */
+/* $XConsortium: XKB.c /main/22 1996/02/02 16:43:37 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -80,13 +80,15 @@ XkbLibraryVersion(libMajorRtrn,libMinorRtrn)
 {
 int supported;
 
-    if (*libMajorRtrn != XkbMajorVersion)
-	supported = False;
-#if XkbMajorVersion==0
-    else if (*libMinorRtrn != XkbMinorVersion)
-	supported = False;
-#endif
-    else supported = True;
+    if (*libMajorRtrn != XkbMajorVersion) {
+	/* version 0.65 is (almost) compatible with 1.00 */
+	if ((XkbMajorVersion==1)&&(((*libMajorRtrn)==0)&&((*libMinorRtrn)==65)))
+	     supported= True;
+	else supported= False;
+    }
+    else { 
+	supported = True;
+    }
 
     *libMajorRtrn = XkbMajorVersion;
     *libMinorRtrn = XkbMinorVersion;
@@ -404,36 +406,6 @@ XkbLatchGroup(dpy,deviceSpec,group)
     return True;
 }
 
-
-Bool
-#if NeedFunctionPrototypes
-XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn)
-#else
-XkbVirtualModsToReal(xkb,virtual_mask,mask_rtrn)
-    XkbDescPtr	xkb;
-    unsigned	virtual_mask;
-    unsigned *	mask_rtrn;
-#endif
-{
-register int i,bit;
-register unsigned mask;
-
-    if (xkb==NULL)
-	return False;
-    if (virtual_mask==0) {
-	*mask_rtrn= 0;
-	return True;
-    }
-    if (xkb->server==NULL)
-	return False;
-    for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
-	if (virtual_mask&bit)
-	    mask|= xkb->server->vmods[i];
-    }
-    *mask_rtrn= mask;
-    return True;
-}
-
 unsigned
 #if NeedFunctionPrototypes
 XkbSetXlibControls(Display *dpy,unsigned affect,unsigned values)
@@ -467,22 +439,40 @@ XkbGetXlibControls(dpy)
     return dpy->xkb_info->xlib_ctrls;
 }
 
+unsigned int
+#if NeedFunctionPrototypes
+XkbXlibControlsImplemented(void)
+#else
+XkbXlibControlsImplemented()
+#endif
+{
+#ifdef __sgi
+    return XkbLC_AllControls;
+#else
+    return XkbLC_AllControls&~XkbLC_AllComposeControls;
+#endif
+}
+
 Bool
 #if NeedFunctionPrototypes
 XkbSetDebuggingFlags(	Display *	dpy,
 			unsigned int 	mask,
 			unsigned int 	flags,
 			char *		msg,
-			unsigned int *	rtrnFlags,
-			Bool *		disableLocks)
+			unsigned int	ctrls_mask,
+			unsigned int	ctrls,
+			unsigned int *	rtrn_flags,
+			unsigned int *	rtrn_ctrls)
 #else
-XkbSetDebuggingFlags(dpy,mask,flags,msg,rtrnFlags,disableLocks)
-    Display *dpy;
-    unsigned int mask;
-    unsigned int flags;
-    char *msg;
-    unsigned int *rtrnFlags;
-    Bool *disableLocks;
+XkbSetDebuggingFlags(dpy,mask,flags,msg,ctrls_mask,ctrls,rtrn_flags,rtrn_ctrls)
+    Display *		dpy;
+    unsigned int 	mask;
+    unsigned int 	flags;
+    char *		msg;
+    unsigned int 	ctrls_mask;
+    unsigned int 	ctrls;
+    unsigned int *	rtrn_flags;
+    unsigned int *	rtrn_ctrls;
 #endif
 {
     register xkbSetDebuggingFlagsReq *req;
@@ -495,12 +485,12 @@ XkbSetDebuggingFlags(dpy,mask,flags,msg,rtrnFlags,disableLocks)
     LockDisplay(dpy);
     xkbi = dpy->xkb_info;
     GetReq(kbSetDebuggingFlags, req);
-    req->reqType = xkbi->codes->major_opcode;
-    req->xkbReqType = X_kbSetDebuggingFlags;
-    req->flags = flags;
-    req->mask = mask;
-    if (disableLocks)	req->disableLocks = *disableLocks;
-    else 		req->disableLocks = XkbLeaveLocks;
+    req->reqType= 	xkbi->codes->major_opcode;
+    req->xkbReqType=	X_kbSetDebuggingFlags;
+    req->affectFlags=	mask;
+    req->flags= 	flags;
+    req->affectCtrls=	ctrls_mask;
+    req->ctrls= 	ctrls;
 
     if (msg) {
 	char *out;
@@ -515,10 +505,10 @@ XkbSetDebuggingFlags(dpy,mask,flags,msg,rtrnFlags,disableLocks)
 	SyncHandle();
 	return False;
     }
-    if (rtrnFlags)
-	*rtrnFlags= rep.currentFlags;
-    if (disableLocks)
-	*disableLocks= rep.disableLocks;
+    if (rtrn_flags)
+	*rtrn_flags= rep.currentFlags;
+    if (rtrn_ctrls)
+	*rtrn_ctrls= rep.currentCtrls;
     UnlockDisplay(dpy);
     SyncHandle();
     return True;
diff --git a/lib/X11/XKBAlloc.c b/lib/X11/XKBAlloc.c
index c8fcbbb86..31df5a5d8 100644
--- a/lib/X11/XKBAlloc.c
+++ b/lib/X11/XKBAlloc.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBAlloc.c /main/5 1996/01/14 16:42:46 kaleb $ */
+/* $XConsortium: XKBAlloc.c /main/6 1996/02/02 14:09:14 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -254,13 +254,11 @@ XkbNamesPtr	names;
 	names->keys= NULL;
 	names->num_keys= 0;
     }
-#ifndef NO_DEC_BUG_FIX
     if ((which&XkbKeyAliasesMask)&&(names->key_aliases)){
 	_XkbFree(names->key_aliases);
 	names->key_aliases=NULL;
 	names->num_key_aliases=0;
     }
-#endif
     if ((which&XkbRGNamesMask)&&(names->radio_groups)) {
 	_XkbFree(names->radio_groups);
 	names->radio_groups= NULL;
diff --git a/lib/X11/XKBBind.c b/lib/X11/XKBBind.c
index 583deb77e..cf98a5cb4 100644
--- a/lib/X11/XKBBind.c
+++ b/lib/X11/XKBBind.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBBind.c /main/16 1996/01/23 10:05:09 kaleb $ */
+/* $XConsortium: XKBBind.c /main/18 1996/02/02 15:57:47 kaleb $ */
 /*
 
 Copyright (c) 1985, 1987, 1994  X Consortium
@@ -61,7 +61,6 @@ from the X Consortium.
 #define XIM_COMP_SUCCEED	COMPOSE_SUCCEED
 #endif
 
-
 #define AllMods (ShiftMask|LockMask|ControlMask| \
 		 Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
 
@@ -144,7 +143,7 @@ XKeycodeToKeysym(dpy, kc, col)
     XkbDescRec	*xkb;
     
     if (_XkbUnavailable(dpy))
-	return NoSymbol;
+	return _XKeycodeToKeysym(dpy, kc, col);
 
     _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
 
@@ -153,12 +152,9 @@ XKeycodeToKeysym(dpy, kc, col)
 	return NoSymbol;
     
     if (col>3) {
-	int lastSym;
-	int group,level,tmp;
-	int nGrp;
+	int lastSym,tmp,nGrp;
 
 	lastSym= 3;
-	group= level= -1;
 	nGrp= XkbKeyNumGroups(xkb,kc);
 	if ((nGrp>0)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup1Index))>2)) {
 	    if (col<=(lastSym+tmp-2))
@@ -308,15 +304,14 @@ XkbTranslateKey(dpy, key, mods, mods_rtrn, keysym_rtrn)
     return XkbLookupKeySym(dpy,key,mods,mods_rtrn,keysym_rtrn);
 }
 
+Bool
 #if NeedFunctionPrototypes
-int
 XkbLookupKeySym(	register Display *	dpy,
 			KeyCode 		key,
 			register unsigned int 	mods,
 			unsigned int *		mods_rtrn,
 			KeySym *		keysym_rtrn)
 #else
-int
 XkbLookupKeySym(dpy, key, mods, mods_rtrn, keysym_rtrn)
     register Display *dpy;
     KeyCode key;
@@ -332,15 +327,14 @@ XkbLookupKeySym(dpy, key, mods, mods_rtrn, keysym_rtrn)
 								keysym_rtrn);
 }
 
+Bool
 #if NeedFunctionPrototypes
-int
 XkbTranslateKeyCode(	register XkbDescPtr	xkb,
 			KeyCode 		key,
 			register unsigned int 	mods,
 			unsigned int *		mods_rtrn,
 			KeySym *		keysym_rtrn)
 #else
-int
 XkbTranslateKeyCode(xkb, key, mods, mods_rtrn, keysym_rtrn)
     register XkbDescPtr xkb;
     KeyCode key;
@@ -361,7 +355,7 @@ XkbTranslateKeyCode(xkb, key, mods, mods_rtrn, keysym_rtrn)
     if ((!XkbKeycodeInRange(xkb,key))||(nKeyGroups==0)) {
 	if (keysym_rtrn!=NULL)
 	    *keysym_rtrn = NoSymbol;
-	return 0;
+	return False;
     }
 
     syms = XkbKeySymsPtr(xkb,key);
@@ -674,14 +668,16 @@ XkbTranslateKeySym(	register Display *	dpy,
 			register KeySym *	sym_rtrn,
 			unsigned int 		mods,
 			char *			buffer,
-			int 			nbytes)
+			int 			nbytes,
+			int *			extra_rtrn)
 #else
-XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes)
+XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes, extra_rtrn)
     register Display *dpy;
     register KeySym *sym_rtrn;
     unsigned int mods;
     char *buffer;
     int nbytes;
+    int *extra_rtrn;
 #endif
 {
     register XkbInfoPtr	xkb;
@@ -689,6 +685,9 @@ XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes)
     register struct _XKeytrans *p; 
     int n;
 
+    if (extra_rtrn)
+	*extra_rtrn= 0;
+
     if (_XkbUnavailable(dpy))
         return _XTranslateKeySym(dpy, *sym_rtrn, mods, buffer, nbytes);
     _XkbCheckPendingRefresh(dpy,dpy->xkb_info);
@@ -703,7 +702,11 @@ XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes)
     for (p = dpy->key_bindings; p; p = p->next) {
 	if (((mods & AllMods) == p->state) && (*sym_rtrn == p->key)) {
 	    int tmp = p->len;
-	    if (tmp > nbytes) tmp = nbytes;
+	    if (tmp > nbytes) {
+		if (extra_rtrn)
+		    *extra_rtrn= tmp-nbytes;
+		tmp = nbytes;
+	    }
 	    memcpy (buffer, p->string, tmp);
 	    return tmp;
 	}
@@ -715,7 +718,8 @@ XkbTranslateKeySym(dpy, sym_rtrn, mods, buffer, nbytes)
     if ( xkb->cvt.KSToUpper && (mods&LockMask) ) {
 	*sym_rtrn = (*xkb->cvt.KSToUpper)(*sym_rtrn);
     }
-    n = (*xkb->cvt.KSToMB)(xkb->cvt.KSToMBPriv,*sym_rtrn,buffer,nbytes,NULL);
+    n = (*xkb->cvt.KSToMB)(xkb->cvt.KSToMBPriv,*sym_rtrn,buffer,nbytes,
+								extra_rtrn);
 
     if ((!xkb->cvt.KSToUpper)&&( mods&LockMask )) {
 	register int i;
@@ -840,7 +844,8 @@ XLookupString (event, buffer, nbytes, keysym, status)
 		    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);
+							buffer+len,nbytes-len,
+							NULL);
 			}
 		    }
 		    if ( keysym!=NULL ) {
@@ -867,13 +872,15 @@ XLookupString (event, buffer, nbytes, keysym, status)
 		    }
 		    else {
 			len = XkbTranslateKeySym(dpy,keysym,new_mods,
-							buffer,nbytes);
+							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);
+							buffer+len,nbytes-len,
+							NULL);
 			}
 		    }
 		    return len;
@@ -887,8 +894,9 @@ XLookupString (event, buffer, nbytes, keysym, status)
     /* that were used to compute the symbol here, but pre-XKB XLookupString */
     /* did not and we have to remain compatible.  Sigh. */
     if (dpy->xkb_info->flags&XkbLC_ConsumeLookupMods)
-	 rtrnLen = XkbTranslateKeySym(dpy,keysym,new_mods,buffer,nbytes);
-    else rtrnLen = XkbTranslateKeySym(dpy,keysym,event->state,buffer,nbytes);
+	 rtrnLen = XkbTranslateKeySym(dpy,keysym,new_mods,buffer,nbytes,NULL);
+    else rtrnLen = XkbTranslateKeySym(dpy,keysym,event->state,buffer,nbytes,
+									NULL);
     return rtrnLen;
 }
 
@@ -896,15 +904,15 @@ XLookupString (event, buffer, nbytes, keysym, status)
 int
 #if NeedFunctionPrototypes
 XkbLookupKeyBinding(	Display *		dpy,
-			register KeySym *	sym_rtrn,
+			register KeySym 	sym,
 			unsigned int 		mods,
 			char *			buffer,
 			int 			nbytes,
 			int * 			extra_rtrn)
 #else
-XkbLookupKeyBinding(dpy, sym_rtrn, mods, buffer, nbytes, extra_rtrn)
+XkbLookupKeyBinding(dpy, sym, mods, buffer, nbytes, extra_rtrn)
     Display *dpy;
-    register KeySym *sym_rtrn;
+    register KeySym sym;
     unsigned int mods;
     char *buffer;
     int nbytes;
@@ -916,7 +924,7 @@ XkbLookupKeyBinding(dpy, sym_rtrn, mods, buffer, nbytes, extra_rtrn)
     if (extra_rtrn)
 	*extra_rtrn= 0;
     for (p = dpy->key_bindings; p; p = p->next) {
-	if (((mods & AllMods) == p->state) && (*sym_rtrn == p->key)) {
+	if (((mods & AllMods) == p->state) && (sym == p->key)) {
 	    int tmp = p->len;
 	    if (tmp > nbytes) {
 		if (extra_rtrn)
diff --git a/lib/X11/XKBCtrls.c b/lib/X11/XKBCtrls.c
index b7f3d4b1d..e7f2c901d 100644
--- a/lib/X11/XKBCtrls.c
+++ b/lib/X11/XKBCtrls.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBCtrls.c /main/6 1996/01/14 16:43:01 kaleb $ */
+/* $XConsortium: XKBCtrls.c /main/7 1996/02/02 14:09:20 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -396,3 +396,23 @@ XkbSetControls(dpy, which, xkb)
     return False;
 }
 
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+XkbNoteControlsChanges(	XkbControlsChangesPtr		old,
+			XkbControlsNotifyEvent *	new,
+			unsigned int	 		wanted)
+#else
+XkbNoteControlsChanges(old,new,wanted)
+    XkbControlsChangesPtr	old;
+    XkbControlsNotifyEvent *	new;
+    unsigned int	 	wanted;
+#endif
+{
+    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/lib/X11/XKBCvt.c b/lib/X11/XKBCvt.c
index ddceacffb..35dfa3fa6 100644
--- a/lib/X11/XKBCvt.c
+++ b/lib/X11/XKBCvt.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBCvt.c /main/20 1996/01/14 16:43:06 kaleb $ */
+/* $XConsortium: XKBCvt.c /main/21 1996/02/02 14:09:26 kaleb $ */
 /*
 
 Copyright (c) 1988, 1989  X Consortium
@@ -169,11 +169,13 @@ static unsigned long	WantHebrew = sHebrew;
 
 static int 
 #if NeedFunctionPrototypes
-_XkbHandleSpecialSym(KeySym keysym, char *buffer)
+_XkbHandleSpecialSym(KeySym keysym, char *buffer, int nbytes, int *extra_rtrn)
 #else
-_XkbHandleSpecialSym(keysym, buffer)
+_XkbHandleSpecialSym(keysym, buffer, nbytes, extra_rtrn)
     KeySym	 keysym;
     char	*buffer;
+    int		 nbytes;
+    int *	 extra_rtrn;
 #endif
 {
 
@@ -187,6 +189,11 @@ _XkbHandleSpecialSym(keysym, buffer)
 	   (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 */
@@ -203,18 +210,22 @@ _XkbKSToKnownSet (	XPointer 	priv,
 			KeySym 		keysym,
 			char *		buffer,
 			int 		nbytes,
-			Status *	status)
+			int *		extra_rtrn)
 #else
-_XkbKSToKnownSet (priv, keysym, buffer, nbytes, status)
+_XkbKSToKnownSet (priv, keysym, buffer, nbytes, extra_rtrn)
     XPointer priv;
     KeySym keysym;
     char *buffer;
     int nbytes;
-    Status *status;
+    int *extra_rtrn;
 #endif
 {
     unsigned long kset,keysymSet;
     int	count,isLatin1;
+    char tbuf[8],*buf;
+
+    if (extra_rtrn)
+	*extra_rtrn= 0;
 
     keysymSet = *((unsigned long *)priv);
     kset = keysymSet&0xffffff;
@@ -246,8 +257,11 @@ _XkbKSToKnownSet (priv, keysym, buffer, nbytes, status)
     isLatin1 = ((keysym&0xffffff00)==0);
     count = 0;
 
+    if (nbytes<1)	buf= tbuf;
+    else		buf= buffer;
+
     if ((keysym&0xffffff00)==0xff00) {
-	return _XkbHandleSpecialSym(keysym, buffer);
+	return _XkbHandleSpecialSym(keysym, buf, nbytes, extra_rtrn);
     }
     else if ( keysym == NoSymbol )
 	return 0;
@@ -255,20 +269,20 @@ _XkbKSToKnownSet (priv, keysym, buffer, nbytes, status)
         count = 1;
         switch (keysymSet) {
         case sKana:
-            buffer[0] = (char)(keysym & 0xff);
-            if (buffer[0] == 0x7e)
+            buf[0] = (char)(keysym & 0xff);
+            if (buf[0] == 0x7e)
                 count = 0;
             break;
         case sCyrillic:
-            buffer[0] = cyrillic[keysym & 0x7f];
+            buf[0] = cyrillic[keysym & 0x7f];
             break;
         case sGreek:
-            buffer[0] = greek[keysym & 0x7f];
-            if (!buffer[0])
+            buf[0] = greek[keysym & 0x7f];
+            if (!buf[0])
                 count = 0;
             break;
         default:
-            buffer[0] = (char)(keysym & 0xff);
+            buf[0] = (char)(keysym & 0xff);
             break;
         }
     } else if ((keysymSet != 0) && (isLatin1) && (keysym & 0x80)) {
@@ -276,18 +290,18 @@ _XkbKSToKnownSet (priv, keysym, buffer, nbytes, status)
             /* Most non-latin1 locales use some latin-1 upper half
                keysyms as defined by bitpatterns in array latin1.
                Enforce it. */
-            buffer[0] = (char)(keysym & 0xff);
+            buf[0] = (char)(keysym & 0xff);
             count = 1;
         } else {
 	    count= 1;
 	    if ((keysymSet == sHebrew) && (keysym == XK_multiply))
-		 buffer[0] = (char)0xaa;
+		 buf[0] = (char)0xaa;
             else if ((keysymSet == sHebrew) && (keysym == XK_division))
-		 buffer[0] = (char)0xba;
+		 buf[0] = (char)0xba;
             else if ((keysymSet == sCyrillic) && (keysym == XK_section))
-		 buffer[0] = (char)0xfd;
+		 buf[0] = (char)0xfd;
             else if ((keysymSet == sX0201) && (keysym == XK_yen))
-		 buffer[0] = (char)0x5c;
+		 buf[0] = (char)0x5c;
             else count = 0;
 	}
     } else if (isLatin1) {
@@ -295,21 +309,26 @@ _XkbKSToKnownSet (priv, keysym, buffer, nbytes, status)
             ((keysym == XK_backslash) || (keysym == XK_asciitilde)))
             count = 0;
 	if ( (keysym&0x80)==0 ) {
-	    buffer[0] = (char)(keysym&0x7f);
+	    buf[0] = (char)(keysym&0x7f);
 	    count = 1;
 	}
     } else if (((keysym >> 8) == sLatin2) &&
                (keysym & 0x80) && (latin2[keysym & 0x7f] & (1 << kset))) {
-        buffer[0] = (char)(keysym & 0xff);
+        buf[0] = (char)(keysym & 0xff);
         count = 1;
     } else if ((keysymSet == sGreek) &&
                ((keysym == XK_leftsinglequotemark) ||
                 (keysym == XK_rightsinglequotemark))) {
-        buffer[0] = (char)(keysym - (XK_leftsinglequotemark - 0xa1));
+        buf[0] = (char)(keysym - (XK_leftsinglequotemark - 0xa1));
         count = 1;
     }
+    if (count>nbytes) {
+	if (*extra_rtrn)
+	    *extra_rtrn= count-nbytes;
+	return nbytes;
+    }
     if (count<nbytes)
-	buffer[count]= '\0';
+	buf[count]= '\0';
     return count;
 }
 
@@ -352,19 +371,19 @@ _XkbKSToThai (	XPointer 	priv,
 		KeySym 		keysym,
 		char *		buffer,
 		int 		nbytes,
-		Status *	status)
+		int *		extra_rtrn)
 #else
-_XkbKSToThai (priv, keysym, buffer, nbytes, status)
+_XkbKSToThai (priv, keysym, buffer, nbytes, extra_rtrn)
     XPointer priv;
     KeySym keysym;
     char *buffer;
     int nbytes;
-    Status *status;
+    int *extra_rtrn;
 #endif
 {
 
     if ((keysym&0xffffff00)==0xff00) {
-        return _XkbHandleSpecialSym(keysym, buffer);
+        return _XkbHandleSpecialSym(keysym, buffer, nbytes, extra_rtrn);
     }
     else if (((keysym&0xffffff80)==0xd80)||((keysym&0xffffff80)==0)) {
         if (nbytes>0) {
@@ -373,6 +392,8 @@ _XkbKSToThai (priv, keysym, buffer, nbytes, status)
                 buffer[1]= '\0';
             return 1;
         }
+	if (extra_rtrn)
+	    *extra_rtrn= 1;
     }
     return 0;
 }
diff --git a/lib/X11/XKBGAlloc.c b/lib/X11/XKBGAlloc.c
index 18d2e483b..edeb04be1 100644
--- a/lib/X11/XKBGAlloc.c
+++ b/lib/X11/XKBGAlloc.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBGAlloc.c /main/5 1996/01/14 16:43:16 kaleb $ */
+/* $XConsortium: XKBGAlloc.c /main/7 1996/02/02 14:38:24 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -56,69 +56,169 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 /***====================================================================***/
 
-void
+static void 
 #if NeedFunctionPrototypes
-XkbFreeGeomProperties(	XkbGeometryPtr	geom,
-			int		first,
-			int		count,
-			Bool		freeAll)
+_XkbFreeGeomLeafElems(	Bool			freeAll,
+			int			first,
+			int 			count,
+			unsigned short *	num_inout,
+			unsigned short *	sz_inout,
+			char **			elems,
+			unsigned int		elem_sz)
 #else
-XkbFreeGeomProperties(geom,first,count,freeAll)
-    XkbGeometryPtr	geom;
+_XkbFreeGeomLeafElems(freeAll,first,count,num_inout,sz_inout,elems,elem_sz)
+    Bool		freeAll;
     int			first;
     int			count;
+    unsigned short *	num_inout;
+    unsigned short *	sz_inout;
+    char **		elems;
+    unsigned int	elem_sz;
+#endif
+{
+    if ((freeAll)||(*elems==NULL)) {
+	*num_inout= *sz_inout= 0;
+	if (*elems!=NULL) {
+	    _XkbFree(*elems);
+	    *elems= NULL;
+	}	
+	return;
+    }
+
+    if ((first>=(*num_inout))||(first<0)||(count<1))
+	return;
+
+    if (first+count>=(*num_inout)) { 
+	/* truncating the array is easy */
+	(*num_inout)= first;
+    }
+    else {
+	char *	ptr;
+	int 	extra;
+	ptr= *elems;
+	extra= ((*num_inout)-(first+count))*elem_sz;
+	if (extra>0)
+	    memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],extra);
+	(*num_inout)-= count;
+    }
+    return;
+}
+
+typedef void (*ContentsClearFunc)(
+#if NeedFunctionPrototypes
+		char *		/* priv */
+#endif
+);
+
+static void 
+#if NeedFunctionPrototypes
+_XkbFreeGeomNonLeafElems(	Bool			freeAll,
+				int			first,
+				int 			count,
+				unsigned short *	num_inout,
+				unsigned short *	sz_inout,
+				char **			elems,
+				unsigned int		elem_sz,
+				ContentsClearFunc	freeFunc)
+#else
+_XkbFreeGeomNonLeafElems(freeAll,first,count,num_inout,sz_inout,elems,elem_sz,
+								 freeFunc)
     Bool		freeAll;
+    int			first;
+    int			count;
+    unsigned short *	num_inout;
+    unsigned short *	sz_inout;
+    char **		elems;
+    unsigned int	elem_sz;
+    ContentsClearFunc	freeFunc;
 #endif
 {
-XkbPropertyPtr	prop;
-register int	i;
+register int i;
+register char *ptr;
 
     if (freeAll) {
 	first= 0;
-	count= geom->num_properties;
+	count= (*num_inout);
     }
-    else if ((first>=geom->num_properties)||(first<0)||(count<1))
+    else if ((first>=(*num_inout))||(first<0)||(count<1))
+	return;
+    else if (first+count>(*num_inout))
+	count= (*num_inout)-first;
+    if (*elems==NULL)
 	return;
-    else if (first+count>geom->num_properties)
-	count= geom->num_properties-first;
 
-    for (i=0,prop=&geom->properties[first];i<count;i++,prop++) {
-	if (prop->name) {
-	    _XkbFree(prop->name);
-	    prop->name= NULL;
-	}
-	if (prop->value) {
-	    _XkbFree(prop->value);
-	    prop->value= NULL;
+    if (freeFunc) {
+	ptr= *elems;
+	ptr+= first*elem_sz;
+	for (i=0;i<count;i++) {
+	    (*freeFunc)(ptr);
+	    ptr+= elem_sz;
 	}
     }
     if (freeAll) {
-	_XkbFree(geom->properties);
-	geom->properties= NULL;
-	geom->sz_properties= geom->num_properties= 0;
+	(*num_inout)= (*sz_inout)= 0;
+	if (*elems) {
+	    _XkbFree(*elems);
+	    *elems= NULL;
+	}
     }
+    else if (first+count>=(*num_inout))
+	*num_inout= first;
     else {
-	for (i=0,prop=geom->properties;i<geom->num_properties;i++) {
-	    register int n;
-	    if (prop->name==NULL) {
-		Bool match= False;
-		for (n=i+1;(n<geom->num_properties)&&(!match);n++) {
-		    if (geom->properties[n].name!=NULL) {
-			prop->name= geom->properties[n].name;
-			prop->value= geom->properties[n].value;
-			geom->properties[n].name= NULL;
-			geom->properties[n].value= NULL;
-			match= True;
-		    }
-		}
-		if (!match)
-		    geom->num_properties= i+1;
-	    }
-	}
+	i= ((*num_inout)-(first+count))*elem_sz;
+	ptr= *elems;
+	memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],i);
+	(*num_inout)-= count;
     }
     return;
 }
 
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearProperty(char *prop_in)
+#else
+_XkbClearProperty(prop_in)
+    char *	prop_in;
+#endif
+{
+XkbPropertyPtr	prop= (XkbPropertyPtr)prop_in;
+
+    if (prop->name) {
+	_XkbFree(prop->name);
+	prop->name= NULL;
+    }
+    if (prop->value) {
+	_XkbFree(prop->value);
+	prop->value= NULL;
+    }
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomProperties(	XkbGeometryPtr	geom,
+			int		first,
+			int		count,
+			Bool		freeAll)
+#else
+XkbFreeGeomProperties(geom,first,count,freeAll)
+    XkbGeometryPtr	geom;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&geom->num_properties,&geom->sz_properties,
+				(char **)&geom->properties,
+				sizeof(XkbPropertyRec),_XkbClearProperty);
+    return;
+}
+
+/***====================================================================***/
+
 void
 #if NeedFunctionPrototypes
 XkbFreeGeomKeyAliases(	XkbGeometryPtr	geom,
@@ -132,28 +232,28 @@ XkbFreeGeomKeyAliases(geom,first,count,freeAll)
     int			count;
     Bool		freeAll;
 #endif
+{	
+    _XkbFreeGeomLeafElems(freeAll,first,count,
+				&geom->num_key_aliases,&geom->sz_key_aliases,
+				(char **)&geom->key_aliases,
+				sizeof(XkbKeyAliasRec));
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearColor(char *color_in)
+#else
+_XkbClearColor(color_in)
+    char *	color_in;
+#endif
 {
-    if (freeAll) {
-	if (geom->key_aliases)
-	    _XkbFree(geom->key_aliases);
-	geom->key_aliases= NULL;
-	geom->num_key_aliases= geom->sz_key_aliases= 0;
-	return;
-    }
-    if ((first<0)||(first>=geom->num_key_aliases)||(geom->key_aliases==NULL))
-	return;
-    else if (first+count>geom->num_key_aliases)
-	count= geom->num_colors-first;
-    if (count<1)
-	return;
+XkbColorPtr	color= (XkbColorPtr)color_in;
 
-    if (first+count<geom->num_key_aliases) {
-	int extra;
-	extra= geom->num_key_aliases-(first+count);
-	memmove(&geom->key_aliases[first],&geom->key_aliases[first+count],
-						extra*sizeof(XkbKeyAliasRec));
-    }
-    geom->num_key_aliases-= count;
+    if (color->spec)
+	_XkbFree(color->spec);
     return;
 }
 
@@ -168,48 +268,83 @@ XkbFreeGeomColors(geom,first,count,freeAll)
     Bool		freeAll;
 #endif
 {
-XkbColorPtr	color;
-register int	i;
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&geom->num_colors,&geom->sz_colors,
+				(char **)&geom->colors,
+				sizeof(XkbColorRec),_XkbClearColor);
+    return;
+}
 
-    if (freeAll) {
-	first= 0;
-	count= geom->num_colors;
-    }
-    else if ((first>=geom->num_colors)||(first<0)||(count<1))
-	return;
-    else if (first+count>geom->num_colors)
-	count= geom->num_colors-first;
+/***====================================================================***/
 
-    if (geom->colors==NULL)
-	return;
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomPoints(outline,first,count,freeAll)
+    XkbOutlinePtr	outline;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomLeafElems(freeAll,first,count,
+				&outline->num_points,&outline->sz_points,
+				(char **)&outline->points,
+				sizeof(XkbPointRec));
+    return;
+}
 
-    for (i=0,color=&geom->colors[first];i<count;i++,color++) {
-	if (color->spec)
-	    _XkbFree(color->spec);
-	color->spec= NULL;
-    }
-    if (freeAll) {
-	_XkbFree(geom->colors);
-	geom->colors= NULL;
-	geom->sz_colors= geom->num_colors= 0;
-    }
-    else {
-	for (i=0,color=geom->colors;i<geom->num_colors;i++) {
-	    register int n;
-	    if (color->spec==NULL) {
-		Bool match= False;
-		for (n=i+1;(n<geom->num_colors)&&(!match);n++) {
-		    if (geom->colors[n].spec!=NULL) {
-			color->spec= geom->colors[n].spec;
-			geom->colors[n].spec= NULL;
-			match= True;
-		    }
-		}
-		if (!match)
-		    geom->num_colors= i+1;
-	    }
-	}
-    }
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearOutline(char *outline_in)
+#else
+_XkbClearOutline(outline_in)
+    char *	outline_in;
+#endif
+{
+XkbOutlinePtr	outline= (XkbOutlinePtr)outline_in;
+
+    if (outline->points!=NULL)
+	XkbFreeGeomPoints(outline,0,outline->num_points,True);
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomOutlines(XkbShapePtr	shape,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomOutlines(shape,first,count,freeAll)
+    XkbShapePtr		shape;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&shape->num_outlines,&shape->sz_outlines,
+				(char **)&shape->outlines,
+				sizeof(XkbOutlineRec),_XkbClearOutline);
+	
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearShape(char *shape_in)
+#else
+_XkbClearShape(shape_in)
+    char *	shape_in;
+#endif
+{
+XkbShapePtr	shape= (XkbShapePtr)shape_in;
+
+    if (shape->outlines)
+	XkbFreeGeomOutlines(shape,0,shape->num_outlines,True);
     return;
 }
 
@@ -224,39 +359,174 @@ XkbFreeGeomShapes(geom,first,count,freeAll)
     Bool		freeAll;
 #endif
 {
-XkbShapePtr	shape;
-register int	i;
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&geom->num_shapes,&geom->sz_shapes,
+				(char **)&geom->shapes,
+				sizeof(XkbShapeRec),_XkbClearShape);
+    return;
+}
 
-    if (freeAll) {
-	first= 0;
-	count= geom->num_shapes;
-    }
-    else if ((first>=geom->num_shapes)||(first<0)||(count<1))
-	return;
-    else if (first+count>geom->num_shapes)
-	count= geom->num_shapes-first;
+/***====================================================================***/
 
-    if (geom->shapes==NULL)
-	return;
+void 
+#if NeedFunctionPrototypes
+XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomOverlayKeys(row,first,count,freeAll)
+    XkbOverlayRowPtr	row;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomLeafElems(freeAll,first,count,
+				&row->num_keys,&row->sz_keys,
+				(char **)&row->keys,
+				sizeof(XkbOverlayKeyRec));
+    return;
+}
 
-    for (i=0,shape=&geom->shapes[first];i<count;i++,shape++) {
-	if (shape->outlines) {
-	    register int 	o;
-	    XkbOutlinePtr	ol;
-	    for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
-		if (ol->points)
-		    _XkbFree(ol->points);
-		ol->points= NULL;
-		ol->num_points= ol->sz_points= 0;
-	    }
-	    _XkbFree(shape->outlines);
-	}
-	bzero(shape,sizeof(XkbShapeRec));
-    }
-    if (freeAll) {
-	_XkbFree(geom->shapes);
-	geom->shapes= NULL;
-	geom->num_shapes= geom->sz_shapes= 0;
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearOverlayRow(char *row_in)
+#else
+_XkbClearOverlayRow(row_in)
+    char *	row_in;
+#endif
+{
+XkbOverlayRowPtr	row= (XkbOverlayRowPtr)row_in;
+
+    if (row->keys!=NULL)
+	XkbFreeGeomOverlayKeys(row,0,row->num_keys,True);
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomOverlayRows(overlay,first,count,freeAll)
+    XkbOverlayPtr	overlay;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&overlay->num_rows,&overlay->sz_rows,
+				(char **)&overlay->rows,
+				sizeof(XkbOverlayRowRec),_XkbClearOverlayRow);
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearOverlay(char *overlay_in)
+#else
+_XkbClearOverlay(overlay_in)
+    char *	overlay_in;
+#endif
+{
+XkbOverlayPtr	overlay= (XkbOverlayPtr)overlay_in;
+
+    if (overlay->rows!=NULL)
+	XkbFreeGeomOverlayRows(overlay,0,overlay->num_rows,True);
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomOverlays(XkbSectionPtr section,int first,int	count,Bool freeAll)
+#else
+XkbFreeGeomOverlays(section,first,count,freeAll)
+    XkbSectionPtr	section;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&section->num_overlays,&section->sz_overlays,
+				(char **)&section->overlays,
+				sizeof(XkbOverlayRec),_XkbClearOverlay);
+    return;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomKeys(row,first,count,freeAll)
+    XkbRowPtr		row;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomLeafElems(freeAll,first,count,
+				&row->num_keys,&row->sz_keys,
+				(char **)&row->keys,
+				sizeof(XkbKeyRec));
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearRow(char *row_in)
+#else
+_XkbClearRow(row_in)
+    char *	row_in;
+#endif
+{
+XkbRowPtr	row= (XkbRowPtr)row_in;
+
+    if (row->keys!=NULL)
+	XkbFreeGeomKeys(row,0,row->num_keys,True);
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
+#else
+XkbFreeGeomRows(section,first,count,freeAll)
+    XkbSectionPtr	section;
+    int			first;
+    int			count;
+    Bool		freeAll;
+#endif
+{
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&section->num_rows,&section->sz_rows,
+				(char **)&section->rows,
+				sizeof(XkbRowRec),_XkbClearRow);
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_XkbClearSection(char *section_in)
+#else
+_XkbClearSection(section_in)
+    char *	section_in;
+#endif
+{
+XkbSectionPtr	section= (XkbSectionPtr)section_in;
+
+    if (section->rows!=NULL)
+	XkbFreeGeomRows(section,0,section->num_rows,True);
+    if (section->doodads!=NULL) {
+	XkbFreeGeomDoodads(section->doodads,section->num_doodads,True);
+	section->doodads= NULL;
     }
     return;
 }
@@ -272,45 +542,46 @@ XkbFreeGeomSections(geom,first,count,freeAll)
     Bool		freeAll;
 #endif
 {
-XkbSectionPtr	section;
-register int	i;
+    _XkbFreeGeomNonLeafElems(freeAll,first,count,
+				&geom->num_sections,&geom->sz_sections,
+				(char **)&geom->sections,
+				sizeof(XkbSectionRec),_XkbClearSection);
+    return;
+}
 
-    if (freeAll) {
-	first= 0;
-	count= geom->num_sections;
-    }
-    else if ((first>=geom->num_sections)||(first<0)||(count<1))
-	return;
-    else if (first+count>geom->num_sections)
-	count= geom->num_sections-first;
+/***====================================================================***/
 
-    if (geom->sections==NULL)
-	return;
+static void
+#if NeedFunctionPrototypes
+_XkbClearDoodad(char *doodad_in)
+#else
+_XkbClearDoodad(doodad_in)
+    char *	doodad_in;
+#endif
+{
+XkbDoodadPtr	doodad= (XkbDoodadPtr)doodad_in;
 
-    for (i=0,section=&geom->sections[first];i<count;i++,section++) {
-	if (section->rows) {
-	    register int	r;
-	    XkbRowPtr	row;
-	    for (r=0,row=section->rows;r<section->num_rows;r++,row++) {
-		if (row->keys)
-		    _XkbFree(row->keys);
-		row->keys= NULL;
-		row->num_keys= row->sz_keys= 0;
+    switch (doodad->any.type) {
+   	case XkbTextDoodad: 
+	    {
+		if (doodad->text.text!=NULL) {
+		    _XkbFree(doodad->text.text);
+		    doodad->text.text= NULL;
+		}
+		if (doodad->text.font!=NULL) {
+		    _XkbFree(doodad->text.font);
+		    doodad->text.font= NULL;
+		}
 	    }
-	    _XkbFree(section->rows);
-	}
-	section->rows= NULL;
-	section->num_rows= section->sz_rows= 0;
-	if (section->doodads) {
-	    XkbFreeGeomDoodads(section->doodads,section->num_doodads,True);
-	}
-	section->doodads= NULL;
-	section->num_doodads= section->sz_doodads= 0;
-    }
-    if (freeAll) {
-	_XkbFree(geom->sections);
-	geom->sections= NULL;
-	geom->num_sections= geom->sz_sections= 0;
+	    break;
+   	case XkbLogoDoodad: 
+	    {
+		if (doodad->logo.logo_name!=NULL) {
+		    _XkbFree(doodad->logo.logo_name);
+		    doodad->logo.logo_name= NULL;
+		}
+	    }
+	    break;
     }
     return;
 }
@@ -330,16 +601,7 @@ register XkbDoodadPtr	doodad;
 
     if (doodads) {
 	for (i=0,doodad= doodads;i<nDoodads;i++,doodad++) {
-	    if (doodad->any.type==XkbTextDoodad) {
-		if (doodad->text.text!=NULL) {
-		    _XkbFree(doodad->text.text);
-		    doodad->text.text= NULL;
-		}
-		if (doodad->text.font!=NULL) {
-		    _XkbFree(doodad->text.font);
-		    doodad->text.font= NULL;
-		}
-	    }
+	    _XkbClearDoodad((char *)doodad);
 	}
 	if (freeAll)
 	    _XkbFree(doodads);
@@ -377,8 +639,10 @@ XkbFreeGeometry(geom,which,freeMap)
     if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL))
 	XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,True);
     if (freeMap) {
-	if (geom->label_font!=NULL)
+	if (geom->label_font!=NULL) {
 	    _XkbFree(geom->label_font);
+	    geom->label_font= NULL;
+	}
 	_XkbFree(geom);
     }
     return;
@@ -1034,6 +1298,7 @@ Bool		found;
     key= &row->keys[row->num_keys];
     strncpy(key->under.name,under,XkbKeyNameLength);
     strncpy(key->over.name,over,XkbKeyNameLength);
+    row->num_keys++;
     return key;
 }
 
diff --git a/lib/X11/XKBGeom.c b/lib/X11/XKBGeom.c
index ff23eda7a..dae8b9f0e 100644
--- a/lib/X11/XKBGeom.c
+++ b/lib/X11/XKBGeom.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBGeom.c /main/5 1996/01/14 16:43:22 kaleb $ */
+/* $XConsortium: XKBGeom.c /main/7 1996/02/02 14:38:29 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -319,12 +319,10 @@ Status	rtrn;
 	return Success;
     if ((rtrn=XkbAllocGeomKeyAliases(geom,rep->nKeyAliases))==Success) {
 	register int i;
-	for (i=0;i<rep->nKeyAliases;i++) {
-	    if (!_XkbCopyFromReadBuffer(buf,(char *)geom->key_aliases,
+	if (!_XkbCopyFromReadBuffer(buf,(char *)geom->key_aliases,
 					(rep->nKeyAliases*XkbKeyNameLength*2)))
-		return BadLength;
-	    geom->num_key_aliases= rep->nKeyAliases;
-	}
+	    return BadLength;
+	geom->num_key_aliases= rep->nKeyAliases;
 	return Success;
     }
     else { /* alloc failed, just skip the aliases */
@@ -454,15 +452,14 @@ xkbDoodadWireDesc *	doodadWire;
     doodad->any.priority= doodadWire->any.priority;
     doodad->any.top= doodadWire->any.top;
     doodad->any.left= doodadWire->any.left;
+    doodad->any.angle= doodadWire->any.angle;
     switch (doodad->any.type) {
 	case XkbOutlineDoodad:
 	case XkbSolidDoodad:
-	    doodad->shape.angle= doodadWire->shape.angle;
 	    doodad->shape.color_ndx= doodadWire->shape.colorNdx;
 	    doodad->shape.shape_ndx= doodadWire->shape.shapeNdx;
 	    break;
 	case XkbTextDoodad:
-	    doodad->text.angle= doodadWire->text.angle;
 	    doodad->text.width= doodadWire->text.width;
 	    doodad->text.height= doodadWire->text.height;
 	    doodad->text.color_ndx= doodadWire->text.colorNdx;
@@ -477,7 +474,6 @@ xkbDoodadWireDesc *	doodadWire;
 	    doodad->indicator.off_color_ndx= doodadWire->indicator.offColorNdx;
 	    break;
 	case XkbLogoDoodad:
-	    doodad->logo.angle= doodadWire->logo.angle;
 	    doodad->logo.color_ndx= doodadWire->logo.colorNdx;
 	    doodad->logo.shape_ndx= doodadWire->logo.shapeNdx;
 	    if (!_XkbGetReadBufferCountedString(buf,&doodad->logo.logo_name))
diff --git a/lib/X11/XKBMAlloc.c b/lib/X11/XKBMAlloc.c
index 01387e4e1..31d2b786f 100644
--- a/lib/X11/XKBMAlloc.c
+++ b/lib/X11/XKBMAlloc.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBMAlloc.c /main/5 1996/01/14 16:43:37 kaleb $ */
+/* $XConsortium: XKBMAlloc.c /main/6 1996/02/02 14:09:43 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -32,6 +32,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #define NEED_EVENTS
 #include "Xlibint.h"
 #include <X11/extensions/XKBproto.h>
+#include <X11/keysym.h>
 #include "XKBlibint.h"
 
 #else 
@@ -43,114 +44,14 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "Xproto.h"
 #include "misc.h"
 #include "inputstr.h"
+#include <X11/keysym.h>
+#define	XKBSRV_NEED_FILE_FUNCS
 #include "XKBsrv.h"
 
 #endif /* XKB_IN_SERVER */
 
 /***====================================================================***/
 
-#define	mapSize(m)	(sizeof(m)/sizeof(XkbKTMapEntryRec))
-static  XkbKTMapEntryRec map2Level[]= { 
-	{ True, ShiftMask, 1, ShiftMask, 0 }
-};
-
-static  XkbKTMapEntryRec mapAlpha[]= { 
-	{ True, ShiftMask, 1, ShiftMask, 0 },
-	{ True,	LockMask,  0,  LockMask, 0 }
-};
-
-static	XkbModsRec preAlpha[]= {
-	{        0,        0, 0 },
-	{ LockMask, LockMask, 0 }
-};
-
-#define	NL_VMOD_MASK	0
-static  XkbKTMapEntryRec mapKeypad[]= { 
-	{ True,	ShiftMask, 1, ShiftMask,            0 },
-	{ False,        0, 1,         0, NL_VMOD_MASK }
-};
-
-static	XkbKeyTypeRec	canonicalTypes[XkbNumRequiredTypes] = {
-	{ { 0, 0, 0 }, 
-	  1,	/* num_levels */
-	  0,	/* map_count */
-	  NULL,		NULL,
-	  None,		NULL
-	},
-	{ { ShiftMask, ShiftMask, 0 }, 
-	  2,	/* num_levels */
-	  mapSize(map2Level),	/* map_count */
-	  map2Level,	NULL,
-	  None,		NULL
-	},
-	{ { ShiftMask|LockMask, ShiftMask|LockMask, 0 }, 
-	  2,				/* num_levels */
-	  mapSize(mapAlpha),		/* map_count */
-	  mapAlpha,	preAlpha,
-	  None,		NULL
-	},
-	{ { ShiftMask, ShiftMask, NL_VMOD_MASK },
-	  2,				/* num_levels */
-	  mapSize(mapKeypad),		/* map_count */
-	  mapKeypad,	NULL,
-	  None,		NULL
-	}
-};
-
-Status
-#if NeedFunctionPrototypes
-XkbInitCanonicalKeyTypes(XkbDescPtr xkb,unsigned which,int keypadVMod)
-#else
-XkbInitCanonicalKeyTypes(xkb,which,keypadVMod)
-    XkbDescPtr		xkb;
-    unsigned		which;
-    int			keypadVMod;
-#endif
-{
-XkbClientMapPtr	map;
-XkbKeyTypePtr	from,to;
-Status		rtrn;
-
-    if (!xkb)
-	return BadMatch;
-    rtrn= XkbAllocClientMap(xkb,XkbKeyTypesMask,XkbNumRequiredTypes);
-    if (rtrn!=Success)
-	return rtrn;
-    map= xkb->map;
-    if ((which&XkbAllRequiredTypes)==0)
-	return Success;
-    rtrn= Success;
-    from= canonicalTypes;
-    to= map->types;
-    if (which&XkbOneLevelMask)
-	rtrn= XkbCopyKeyType(&from[XkbOneLevelIndex],&to[XkbOneLevelIndex]);
-    if ((which&XkbTwoLevelMask)&&(rtrn==Success))
-	rtrn= XkbCopyKeyType(&from[XkbTwoLevelIndex],&to[XkbTwoLevelIndex]);
-    if ((which&XkbAlphabeticMask)&&(rtrn==Success))
-	rtrn= XkbCopyKeyType(&from[XkbAlphabeticIndex],&to[XkbAlphabeticIndex]);
-    if ((which&XkbKeypadMask)&&(rtrn==Success)) {
-	XkbKeyTypePtr type;
-	rtrn= XkbCopyKeyType(&from[XkbKeypadIndex],&to[XkbKeypadIndex]);
-	type= &to[XkbKeypadIndex];
-	if ((keypadVMod>=0)&&(keypadVMod<XkbNumVirtualMods)&&(rtrn==Success)) {
-	    type->mods.vmods= (1<<keypadVMod);
-	    type->map[0].active= True;
-	    type->map[0].mods.mask= ShiftMask;
-	    type->map[0].mods.real_mods= ShiftMask;
-	    type->map[0].mods.vmods= 0;
-	    type->map[0].level= 1;
-	    type->map[1].active= False;
-	    type->map[1].mods.mask= 0;
-	    type->map[1].mods.real_mods= 0;
-	    type->map[1].mods.vmods= (1<<keypadVMod);
-	    type->map[1].level= 1;
-	}
-    }
-    return Success;
-}
-
-/***====================================================================***/
-
 Status
 #if NeedFunctionPrototypes
 XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
@@ -434,7 +335,7 @@ XkbClientMapPtr	map;
 	    if (map->types[i].name==name) {
 		Status status;
 		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);
-		return (status==Success?type:NULL);
+		return (status==Success?&map->types[i]:NULL);
 	    }
 	}
     }
@@ -457,7 +358,7 @@ XkbClientMapPtr	map;
 		if (map->types[i].name!=name)
 		    continue;
 		status=XkbResizeKeyType(xkb,i,map_count,want_preserve,num_lvls);
-		return (status==Success?type:NULL);
+		return (status==Success?&map->types[i]:NULL);
 	    }
 	}
     }
@@ -800,123 +701,6 @@ XkbAction *newActs;
     return &xkb->server->acts[xkb->server->key_acts[key]];
 }
 
-Status
-#if NeedFunctionPrototypes
-XkbChangeTypesOfKey(	XkbDescPtr		 xkb,
-			int		 	 key,
-			int			 nGroups,
-			unsigned	 	 groups,
-			int	* 	 	 newTypesIn,
-			XkbMapChangesPtr	 pChanges)
-#else
-XkbChangeTypesOfKey(xkb,key,nGroups,groups,newTypesIn,pChanges)
-    XkbDescPtr		 xkb;
-    int		 	 key;
-    int			 nGroups;
-    unsigned	 	 groups;
-    int	* 	 	 newTypesIn;
-    XkbMapChangesPtr	 pChanges;
-#endif
-{
-XkbKeyTypePtr	pOldType,pNewType;
-register int	i;
-int		width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
-
-    if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) ||
-	(!xkb->map->types)||(!newTypes)||
-	(nGroups>XkbNumKbdGroups)||((groups&XkbAllGroupsMask)==0)) {
-	return BadMatch;
-    }
-    if (nGroups==0) {
-	for (i=0;i<XkbNumKbdGroups;i++) {
-	    xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex;
-	}
-	i= xkb->map->key_sym_map[key].group_info;
-	i= XkbSetNumGroups(i,0);
-	xkb->map->key_sym_map[key].group_info= i;
-	XkbResizeKeySyms(xkb,key,0);
-	return Success;
-    }
-
-    nOldGroups= XkbKeyNumGroups(xkb,key);
-    oldWidth= XkbKeyGroupsWidth(xkb,key);
-    for (width=i=0;i<nGroups;i++) {
-	if (groups&(1<<i))
-	     newTypes[i]=  newTypesIn[i];
-	else if (i<nOldGroups)
-	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i);
-	else if (nOldGroups>0)
-	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
-	else newTypes[i]= XkbTwoLevelIndex;
-	if (newTypes[i]>xkb->map->num_types)
-	    return BadMatch;
-	pNewType= &xkb->map->types[newTypes[i]];
-	if (pNewType->num_levels>width)
-	    width= pNewType->num_levels;
-    }
-    if ((width!=oldWidth)||(nGroups!=nOldGroups)) {
-	KeySym		oldSyms[XkbMaxSymsPerKey],*pSyms;
-	int		nCopy;
-
-	if (nOldGroups==0) {
-	    pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
-	    return ((pSyms!=NULL)?Success:BadAlloc);
-	}
-	pSyms= XkbKeySymsPtr(xkb,key);
-	memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
-	pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
-	if (pSyms==NULL)
-	    return BadAlloc;
-	bzero(pSyms,width*nGroups*sizeof(KeySym));
-	for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
-	    pOldType= XkbKeyKeyType(xkb,key,i);
-	    pNewType= &xkb->map->types[newTypes[i]];
-	    if (pNewType->num_levels>pOldType->num_levels)
-		 nCopy= pOldType->num_levels;
-	    else nCopy= pNewType->num_levels;
-	    memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym));
-	}
-	if (XkbKeyHasActions(xkb,key)) {
-	    XkbAction	oldActs[XkbMaxSymsPerKey],*pActs;
-	    pActs= XkbKeyActionsPtr(xkb,key);
-	    memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction));
-	    pActs= XkbResizeKeyActions(xkb,key,width*nGroups);
-	    if (pActs==NULL)
-		return BadAlloc;
-	    bzero(pActs,width*nGroups*sizeof(XkbAction));
-	    for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
-		pOldType= XkbKeyKeyType(xkb,key,i);
-		pNewType= &xkb->map->types[newTypes[i]];
-		if (pNewType->num_levels>pOldType->num_levels)
-		     nCopy= pOldType->num_levels;
-		else nCopy= pNewType->num_levels;
-		memcpy(&pActs[i*width],&oldActs[i*oldWidth],
-						nCopy*sizeof(XkbAction));
-	    }
-	}
-    }
-    for (i=0;i<nGroups;i++) {
-	xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
-    }
-    if (pChanges!=NULL) {
-	if (pChanges->changed&XkbKeySymsMask) {
-	    int first,last;
-	    first= pChanges->first_key_sym;
-	    last= pChanges->first_key_sym+pChanges->num_key_syms-1;
-	    if (key<first)	first= key;
-	    if (key>last)	last= key;
-	    pChanges->first_key_sym = first;
-	    pChanges->num_key_syms = (last-first)+1;
-	}
-	else {
-	    pChanges->changed|= XkbKeySymsMask;
-	    pChanges->first_key_sym= key;
-	    pChanges->num_key_syms= 1;
-	}
-    }
-    return Success;
-}
-
 void
 #if NeedFunctionPrototypes
 XkbFreeClientMap(XkbDescPtr xkb,unsigned what,Bool freeMap)
diff --git a/lib/X11/XKBMisc.c b/lib/X11/XKBMisc.c
new file mode 100644
index 000000000..da384f5f7
--- /dev/null
+++ b/lib/X11/XKBMisc.c
@@ -0,0 +1,1071 @@
+/* $XConsortium: XKBMisc.c /main/2 1996/02/03 06:04:25 kaleb $ */
+/************************************************************
+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 XKB_IN_SERVER
+
+#include <stdio.h>
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include "Xlibint.h"
+#include <X11/extensions/XKBproto.h>
+#include <X11/keysym.h>
+#include "XKBlibint.h"
+
+#else 
+
+#include <stdio.h>
+#include "X.h"
+#define	NEED_EVENTS
+#define	NEED_REPLIES
+#include "Xproto.h"
+#include "misc.h"
+#include "inputstr.h"
+#include <X11/keysym.h>
+#define	XKBSRV_NEED_FILE_FUNCS
+#include "XKBsrv.h"
+
+#endif /* XKB_IN_SERVER */
+
+/***====================================================================***/
+
+#define	mapSize(m)	(sizeof(m)/sizeof(XkbKTMapEntryRec))
+static  XkbKTMapEntryRec map2Level[]= { 
+	{ True, ShiftMask, 1, ShiftMask, 0 }
+};
+
+static  XkbKTMapEntryRec mapAlpha[]= { 
+	{ True, ShiftMask, 1, ShiftMask, 0 },
+	{ True,	LockMask,  0,  LockMask, 0 }
+};
+
+static	XkbModsRec preAlpha[]= {
+	{        0,        0, 0 },
+	{ LockMask, LockMask, 0 }
+};
+
+#define	NL_VMOD_MASK	0
+static  XkbKTMapEntryRec mapKeypad[]= { 
+	{ True,	ShiftMask, 1, ShiftMask,            0 },
+	{ False,        0, 1,         0, NL_VMOD_MASK }
+};
+
+static	XkbKeyTypeRec	canonicalTypes[XkbNumRequiredTypes] = {
+	{ { 0, 0, 0 }, 
+	  1,	/* num_levels */
+	  0,	/* map_count */
+	  NULL,		NULL,
+	  None,		NULL
+	},
+	{ { ShiftMask, ShiftMask, 0 }, 
+	  2,	/* num_levels */
+	  mapSize(map2Level),	/* map_count */
+	  map2Level,	NULL,
+	  None,		NULL
+	},
+	{ { ShiftMask|LockMask, ShiftMask|LockMask, 0 }, 
+	  2,				/* num_levels */
+	  mapSize(mapAlpha),		/* map_count */
+	  mapAlpha,	preAlpha,
+	  None,		NULL
+	},
+	{ { ShiftMask, ShiftMask, NL_VMOD_MASK },
+	  2,				/* num_levels */
+	  mapSize(mapKeypad),		/* map_count */
+	  mapKeypad,	NULL,
+	  None,		NULL
+	}
+};
+
+Status
+#if NeedFunctionPrototypes
+XkbInitCanonicalKeyTypes(XkbDescPtr xkb,unsigned which,int keypadVMod)
+#else
+XkbInitCanonicalKeyTypes(xkb,which,keypadVMod)
+    XkbDescPtr		xkb;
+    unsigned		which;
+    int			keypadVMod;
+#endif
+{
+XkbClientMapPtr	map;
+XkbKeyTypePtr	from,to;
+Status		rtrn;
+
+    if (!xkb)
+	return BadMatch;
+    rtrn= XkbAllocClientMap(xkb,XkbKeyTypesMask,XkbNumRequiredTypes);
+    if (rtrn!=Success)
+	return rtrn;
+    map= xkb->map;
+    if ((which&XkbAllRequiredTypes)==0)
+	return Success;
+    rtrn= Success;
+    from= canonicalTypes;
+    to= map->types;
+    if (which&XkbOneLevelMask)
+	rtrn= XkbCopyKeyType(&from[XkbOneLevelIndex],&to[XkbOneLevelIndex]);
+    if ((which&XkbTwoLevelMask)&&(rtrn==Success))
+	rtrn= XkbCopyKeyType(&from[XkbTwoLevelIndex],&to[XkbTwoLevelIndex]);
+    if ((which&XkbAlphabeticMask)&&(rtrn==Success))
+	rtrn= XkbCopyKeyType(&from[XkbAlphabeticIndex],&to[XkbAlphabeticIndex]);
+    if ((which&XkbKeypadMask)&&(rtrn==Success)) {
+	XkbKeyTypePtr type;
+	rtrn= XkbCopyKeyType(&from[XkbKeypadIndex],&to[XkbKeypadIndex]);
+	type= &to[XkbKeypadIndex];
+	if ((keypadVMod>=0)&&(keypadVMod<XkbNumVirtualMods)&&(rtrn==Success)) {
+	    type->mods.vmods= (1<<keypadVMod);
+	    type->map[0].active= True;
+	    type->map[0].mods.mask= ShiftMask;
+	    type->map[0].mods.real_mods= ShiftMask;
+	    type->map[0].mods.vmods= 0;
+	    type->map[0].level= 1;
+	    type->map[1].active= False;
+	    type->map[1].mods.mask= 0;
+	    type->map[1].mods.real_mods= 0;
+	    type->map[1].mods.vmods= (1<<keypadVMod);
+	    type->map[1].level= 1;
+	}
+    }
+    return Success;
+}
+
+/***====================================================================***/
+
+#define	CORE_SYM(i)	(i<map_width?core_syms[i]:NoSymbol)
+#define	XKB_OFFSET(g,l)	(((g)*groupsWidth)+(l))
+
+int
+#if NeedFunctionPrototypes
+XkbKeyTypesForCoreSymbols(	XkbDescPtr	xkb,
+				int		map_width,
+				KeySym *	core_syms,
+				unsigned int 	protected,
+    				int *		types_inout,
+				KeySym *	xkb_syms_rtrn)
+#else
+XkbKeyTypesForCoreSymbols(xkb,map_width,core_syms,protected,types_inout,
+								xkb_syms_rtrn)
+    XkbDescPtr		xkb;
+    int			map_width;
+    KeySym *		core_syms;
+    unsigned int 	protected;
+    int *		types_inout;
+    KeySym * 		xkb_syms_rtrn;
+#endif
+{
+register int	i;
+unsigned int	empty;
+int		nSyms[XkbNumKbdGroups];
+int		nGroups,tmp,groupsWidth;
+
+    /* Section 12.2 of the protocol describes this process in more detail */
+    /* Step 1:  find the # of symbols in the core mapping per group */
+    groupsWidth= 2;
+    for (i=0;i<XkbNumKbdGroups;i++) {
+	if ((protected&(1<<i))&&(types_inout[i]<xkb->map->num_types)) {
+	    nSyms[i]= xkb->map->types[types_inout[i]].num_levels;
+	    if (nSyms[i]>groupsWidth)
+		groupsWidth= nSyms[i];
+	}
+	else {
+	    types_inout[i]= XkbTwoLevelIndex;	/* don't really know, yet */
+	    nSyms[i]= 2;
+	}
+    }
+    if (nSyms[XkbGroup1Index]<2)
+	nSyms[XkbGroup1Index]= 2;
+    if (nSyms[XkbGroup2Index]<2)
+	nSyms[XkbGroup2Index]= 2;
+    /* Step 2:	Copy the symbols from the core ordering to XKB ordering	*/
+    /*		symbols in the core are in the order:			*/
+    /*		G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*]	*/
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,0)]= CORE_SYM(0);
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,1)]= CORE_SYM(1);
+    for (i=2;i<nSyms[XkbGroup1Index];i++) {
+	xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,i)]= CORE_SYM(2+i);
+    }
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,0)]= CORE_SYM(2);
+    xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,1)]= CORE_SYM(3);
+    tmp= 2+(nSyms[XkbGroup1Index]-2); /* offset to extra group2 syms */
+    for (i=2;i<nSyms[XkbGroup2Index];i++) {
+	xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,i)]= CORE_SYM(tmp+i);
+    }
+    tmp= nSyms[XkbGroup1Index]+nSyms[XkbGroup2Index];
+    if ((tmp>=map_width)&&
+	 ((protected&(XkbExplicitKeyType3Mask|XkbExplicitKeyType4Mask))==0)) {
+	nSyms[XkbGroup3Index]= 0;
+	nSyms[XkbGroup4Index]= 0;
+	nGroups= 2;
+    }
+    else {
+    	nGroups= 3;
+	for (i=0;i<nSyms[XkbGroup3Index];i++,tmp++) {
+	    xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index,i)]= CORE_SYM(tmp);
+	}
+	if ((tmp<map_width)||(protected&XkbExplicitKeyType4Mask)) {
+	    nGroups= 4;
+	    for (i=0;i<nSyms[XkbGroup4Index];i++,tmp++) {
+		xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index,i)]= CORE_SYM(tmp);
+	    }
+	}
+	else {
+	    nSyms[XkbGroup4Index]= 0;
+	}
+    }
+    /* steps 3&4: alphanumeric expansion,  assign canonical types */
+    empty= 0;
+    for (i=0;i<nGroups;i++) {
+	KeySym *syms;
+	syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
+	if ((nSyms[i]>1)&&(syms[1]==NoSymbol)&&(syms[0]!=NoSymbol)) {
+	    KeySym upper,lower;
+	    XConvertCase(syms[0],&lower,&upper);
+	    if (upper!=lower) {
+		xkb_syms_rtrn[XKB_OFFSET(i,0)]= lower;
+		xkb_syms_rtrn[XKB_OFFSET(i,1)]= upper;
+		if ((protected&(1<<i))==0)
+		    types_inout[i]= XkbAlphabeticIndex;
+	    }
+	    else if ((protected&(1<<i))==0) {
+		types_inout[i]= XkbOneLevelIndex;
+	/*	nSyms[i]=	1;*/
+	    }
+	}
+	if (((protected&(1<<i))==0)&&(types_inout[i]==XkbTwoLevelIndex)) {
+	    if (IsKeypadKey(syms[0])||IsKeypadKey(syms[1]))
+		types_inout[i]= XkbKeypadIndex;
+	    else {
+		KeySym upper,lower;
+		XConvertCase(syms[0],&lower,&upper);
+		if ((syms[0]==lower)&&(syms[1]==upper))
+		    types_inout[i]= XkbAlphabeticIndex;
+	    }
+	}
+	if (syms[0]==NoSymbol) {
+	    register int n;
+	    Bool	found;
+	    for (n=1,found=False;(!found)&&(n<nSyms[i]);n++) {
+		found= (syms[n]!=NoSymbol);
+	    }
+	    if (!found)
+		empty|= (1<<i);
+	}
+    }
+    /* step 5: squoosh out empty groups */
+    if (empty) {
+	for (i=nGroups-1;i>=0;i--) {
+	    if (((empty&(1<<i))==0)||(protected&(1<<i)))
+		break;
+	    nGroups--;
+	}
+    }
+    if (nGroups<1)
+	return 0;
+
+    /* step 6: replicate group 1 into group two, if necessary */
+    if ((nGroups>1)&&((empty&(XkbGroup1Mask|XkbGroup2Mask))==XkbGroup2Mask)) {
+	if ((protected&(XkbExplicitKeyType1Mask|XkbExplicitKeyType2Mask))==0) {
+	    nSyms[XkbGroup2Index]= nSyms[XkbGroup1Index];
+	    types_inout[XkbGroup2Index]= types_inout[XkbGroup1Index];
+	    memcpy((char *)&xkb_syms_rtrn[2],(char *)xkb_syms_rtrn,
+							2*sizeof(KeySym));
+	}
+	else if (types_inout[XkbGroup1Index]==types_inout[XkbGroup2Index]) {
+	    memcpy((char *)&xkb_syms_rtrn[nSyms[XkbGroup1Index]],
+	    				(char *)xkb_syms_rtrn,
+					nSyms[XkbGroup1Index]*sizeof(KeySym));
+	}
+    }
+
+    /* step 7: check for all groups identical or all width 1 */
+    if (nGroups>1) {
+	Bool sameType,allOneLevel;
+	allOneLevel= (xkb->map->types[types_inout[0]].num_levels==1);
+	for (i=1,sameType=True;(allOneLevel||sameType)&&(i<nGroups);i++) {
+	    sameType=(sameType&&(types_inout[i]==types_inout[XkbGroup1Index]));
+	    if (allOneLevel)
+		allOneLevel= (xkb->map->types[types_inout[i]].num_levels==1);
+	}
+	if ((sameType)&&
+	    (!(protected&(XkbExplicitKeyTypesMask&~XkbExplicitKeyType1Mask)))){
+	    register int s;
+	    Bool	identical;
+	    for (i=1,identical=True;identical&&(i<nGroups);i++) {
+		KeySym *syms;
+		syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
+		for (s=0;identical&&(s<nSyms[i]);s++) {
+		    if (syms[s]!=xkb_syms_rtrn[s])
+			identical= False;
+		}
+	    }
+	    if (identical)
+		nGroups= 1;
+	}
+	if (allOneLevel && (nGroups>1)) {
+	    KeySym *syms;
+	    syms= &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
+	    nSyms[XkbGroup1Index]= 1;
+	    for (i=1;i<nGroups;i++) {
+		xkb_syms_rtrn[i]= syms[0];
+		syms+= nSyms[i];
+		nSyms[i]= 1;
+	    }
+	}
+    }
+    return nGroups;
+}
+
+static XkbSymInterpretPtr
+#if NeedFunctionPrototypes
+_XkbFindMatchingInterp(	XkbDescPtr	xkb,
+			KeySym 		sym,
+			unsigned int	real_mods,
+			unsigned int	level)
+#else
+_XkbFindMatchingInterp(xkb,sym,real_mods,level)
+    XkbDescPtr		xkb;
+    KeySym		sym;
+    unsigned int	real_mods;
+    unsigned int	level;
+#endif
+{
+register unsigned	 i;
+XkbSymInterpretPtr	 interp,rtrn;
+CARD8			 mods;
+
+    rtrn= NULL;
+    interp= xkb->compat->sym_interpret;
+    for (i=0;i<xkb->compat->num_si;i++,interp++) {
+	if ((interp->sym==NoSymbol)||(sym==interp->sym)) {
+	    int match;
+	    if ((level==0)||((interp->match&XkbSI_LevelOneOnly)==0))
+		 mods= real_mods;
+	    else mods= 0;
+	    switch (interp->match&XkbSI_OpMask) {
+		case XkbSI_NoneOf:
+		    match= ((interp->mods&mods)==0);
+		    break;
+		case XkbSI_AnyOfOrNone:
+		    match= ((mods==0)||((interp->mods&mods)!=0));
+		    break;
+		case XkbSI_AnyOf:
+		    match= ((interp->mods&mods)!=0);
+		    break;
+		case XkbSI_AllOf:
+		    match= ((interp->mods&mods)==interp->mods);
+		    break;
+		case XkbSI_Exactly:
+		    match= (interp->mods==mods);
+		    break;
+		default:
+		    match= 0;
+		    break;
+	    }
+	    if (match) {
+		if (interp->sym!=NoSymbol) {
+		    return interp;
+		}
+		else if (rtrn==NULL) {
+		    rtrn= interp;
+		}
+	    }
+	}
+    }
+    return rtrn;
+}
+
+static void
+#if NeedFunctionPrototypes
+_XkbAddKeyChange(KeyCode *pFirst,unsigned char *pNum,KeyCode newKey)
+#else
+_XkbAddKeyChange(pFirst,pNum,newKey)
+    KeyCode *		pFirst;
+    unsigned char *	pNum;
+    KeyCode		newKey;
+#endif
+{
+KeyCode	last;
+
+    last= (*pFirst)+(*pNum);
+    if (newKey<*pFirst) {
+	*pFirst= newKey;
+	*pNum= (last-newKey)+1;
+    }
+    else if (newKey>last) {
+	*pNum= (last-*pFirst)+1;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
+#else
+_XkbSetActionKeyMods(xkb,act,mods)
+    XkbDescPtr	xkb;
+    XkbAction *	act;
+    unsigned	mods;
+#endif
+{
+unsigned	tmp;
+
+    switch (act->type) {
+	case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
+	    if (act->mods.flags&XkbSA_UseModMapMods)
+		act->mods.real_mods= act->mods.mask= mods;
+	    if ((tmp= XkbModActionVMods(&act->mods))!=0) {
+		XkbVirtualModsToReal(xkb,tmp,&tmp);
+		act->mods.mask|= tmp;
+	    }
+	    break;
+	case XkbSA_ISOLock:
+	    if (act->iso.flags&XkbSA_UseModMapMods)
+		act->iso.real_mods= act->iso.mask= mods;
+	    if ((tmp= XkbModActionVMods(&act->iso))!=0) {
+		XkbVirtualModsToReal(xkb,tmp,&tmp);
+		act->iso.mask|= tmp;
+	    }
+	    break;
+    }
+    return;
+}
+
+#define	IBUF_SIZE	8
+
+Bool
+#if NeedFunctionPrototypes
+XkbApplyCompatMapToKey(XkbDescPtr xkb,KeyCode key,XkbChangesPtr changes)
+#else
+XkbApplyCompatMapToKey(xkb,key,changes)
+    XkbDescPtr		xkb;
+    KeyCode		key;
+    XkbChangesPtr	changes;
+#endif
+{
+KeySym *		syms;
+unsigned char 		explicit,mods;
+XkbSymInterpretPtr	*interps,ibuf[IBUF_SIZE]; 
+int			n,nSyms,found;
+unsigned		changed,changedVMods,tmp;
+
+    if ((!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)||
+    			(!xkb->compat)||(!xkb->compat->sym_interpret)||
+			(key<xkb->min_key_code)||(key>xkb->max_key_code)) {
+	return False;
+    }
+    if (((!xkb->server)||(!xkb->server->key_acts))&&
+		(XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success)) {
+	return False;
+    }
+    changed= 0;	/* keeps track of what has changed in _this_ call */
+    explicit= xkb->server->explicit[key];
+    if (explicit&XkbExplicitInterpretMask) /* nothing to do */
+	return True;
+    mods= (xkb->map->modmap?xkb->map->modmap[key]:0);
+    nSyms= XkbKeyNumSyms(xkb,key);
+    syms= XkbKeySymsPtr(xkb,key);
+    if (nSyms>IBUF_SIZE) {
+	interps= _XkbTypedCalloc(nSyms,XkbSymInterpretPtr);
+	if (interps==NULL) {
+	    interps= ibuf;
+	    nSyms= IBUF_SIZE;
+	}
+    }
+    else {
+	interps= ibuf;
+    }
+    found= 0;
+    for (n=0;n<nSyms;n++) {
+	unsigned level= (n%XkbKeyGroupsWidth(xkb,key));
+	interps[n]= NULL;
+	if (syms[n]!=NoSymbol) {
+	    interps[n]= _XkbFindMatchingInterp(xkb,syms[n],mods,level);
+	    if (interps[n]&&interps[n]->act.type!=XkbSA_NoAction)
+		found++;
+	    else interps[n]= NULL;
+	}
+    }
+    /* 1/28/96 (ef) -- XXX! WORKING HERE */
+    if (!found) {
+	if (xkb->server->key_acts[key]!=0) {
+	    xkb->server->key_acts[key]= 0;
+	    changed|= XkbKeyActionsMask;
+	}
+    }
+    else {
+	XkbAction *pActs;
+	changed|= XkbKeyActionsMask;
+	pActs= XkbResizeKeyActions(xkb,key,nSyms);
+	if (!pActs)
+	    return False;
+	for (n=0;n<nSyms;n++) {
+	    if (interps[n]) {
+		unsigned effMods;
+
+		pActs[n]= *((XkbAction *)&interps[n]->act);
+		if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0))
+		     effMods= mods;
+		else effMods= 0;
+		_XkbSetActionKeyMods(xkb,&pActs[n],effMods);
+	    }
+	    else pActs[n].type= XkbSA_NoAction;
+	}
+	if ((explicit&XkbExplicitVModMapMask)==0) {
+	    unsigned new_vmodmask;
+	    if (interps[0]&&(interps[0]->virtual_mod!=XkbNoModifier))
+		 new_vmodmask= (1<<interps[0]->virtual_mod);
+	    else new_vmodmask= 0;
+	    if (xkb->server->vmodmap[key]!=new_vmodmask) {
+		changed|= XkbVirtualModMapMask;
+		xkb->server->vmodmap[key]= new_vmodmask;
+	    }
+	}
+	if (interps[0]) {
+	    if ((interps[0]->flags&XkbSI_LockingKey)&&
+				((explicit&XkbExplicitBehaviorMask)==0)) {
+		xkb->server->behaviors[key].type= XkbKB_Lock;
+		changed|= XkbKeyBehaviorsMask;
+	    }
+	    if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
+		CARD8 old;
+		old= xkb->ctrls->per_key_repeat[key/8];
+		if (interps[0]->flags&XkbSI_AutoRepeat)
+		     xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8));
+		else xkb->ctrls->per_key_repeat[key/8]&= ~(1<<(key%8));
+		if (changes && (old!=xkb->ctrls->per_key_repeat[key/8]))
+		    changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
+	    }
+	}
+    }
+    if ((!found)||(interps[0]==NULL)) {
+	if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
+	    CARD8 old;
+	    old= xkb->ctrls->per_key_repeat[key/8];
+#if RETURN_SHOULD_REPEAT
+	    if (*XkbKeySymsPtr(xkb,key) != XK_Return)
+#endif
+		xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8));
+	    if (changes && (old!=xkb->ctrls->per_key_repeat[key/8]))
+		changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
+	}
+	if (((explicit&XkbExplicitBehaviorMask)==0)&&
+		(xkb->server->behaviors[key].type==XkbKB_Lock)) {
+		xkb->server->behaviors[key].type= XkbKB_Default;
+		changed|= XkbKeyBehaviorsMask;
+	}
+    }
+    if (changes) {
+	XkbMapChangesPtr	mc;
+	mc= &changes->map;
+	tmp= (changed&mc->changed);
+	if (tmp&XkbKeyActionsMask)
+	    _XkbAddKeyChange(&mc->first_key_act,&mc->num_key_acts,key);
+	else if (changed&XkbKeyActionsMask) {
+	    mc->changed|= XkbKeyActionsMask;
+	    mc->first_key_act= key;
+	    mc->num_key_acts= 1;
+	}
+	if (tmp&XkbKeyBehaviorsMask) {
+	    _XkbAddKeyChange(&mc->first_key_behavior,&mc->num_key_behaviors,
+	    								key);
+	}
+	else if (changed&XkbKeyBehaviorsMask) {
+	    mc->changed|= XkbKeyBehaviorsMask;
+	    mc->first_key_behavior= key;
+	    mc->num_key_behaviors= 1;
+	}
+	if (tmp&XkbVirtualModMapMask)
+	    _XkbAddKeyChange(&mc->first_vmodmap_key,&mc->num_vmodmap_keys,key);
+	else if (changed&XkbVirtualModMapMask) {
+	    mc->changed|= XkbVirtualModMapMask;
+	    mc->first_vmodmap_key= key;
+	    mc->num_vmodmap_keys= 1;
+	}
+	mc->changed|= changed;
+    }
+    if (interps!=ibuf)
+	_XkbFree(interps);
+    return True;
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbUpdateMapFromCore(	XkbDescPtr	xkb,
+			KeyCode		first_key,
+			int		num_keys,
+			int		map_width,
+			KeySym *	core_keysyms,
+			XkbChangesPtr	changes)
+#else
+XkbUpdateMapFromCore(xkb,first_key,num_keys,map_width,core_keysyms,changes)
+    XkbDescPtr		xkb;
+    KeyCode		first_key;
+    int			num_keys;
+    int			map_width;
+    KeySym *		core_keysyms;
+    XkbChangesPtr	changes;
+#endif
+{
+register int	key,last_key;
+KeySym *	syms;
+
+    syms= &core_keysyms[(first_key-xkb->min_key_code)*map_width];
+    if (changes) {
+	if (changes->map.changed&XkbKeySymsMask) {
+	    _XkbAddKeyChange(&changes->map.first_key_sym,
+	    			&changes->map.num_key_syms,first_key);
+	    if (num_keys>1) {
+		_XkbAddKeyChange(&changes->map.first_key_sym,
+						&changes->map.num_key_syms,
+						first_key+num_keys-1);
+	    }
+	}
+	else {
+	    changes->map.changed|= XkbKeySymsMask;
+	    changes->map.first_key_sym= first_key;
+	    changes->map.num_key_syms= num_keys;
+	}
+    }
+    last_key= first_key+num_keys-1;
+    for (key=first_key;key<=last_key;key++,syms+= map_width) {
+	XkbMapChangesPtr	mc;
+	unsigned		explicit;
+	KeySym			tsyms[XkbMaxSymsPerKey];
+	int	 		types[XkbNumKbdGroups];
+	int			nG;
+
+	explicit= xkb->server->explicit[key]&XkbExplicitKeyTypesMask;
+	types[XkbGroup1Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
+	types[XkbGroup2Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup2Index);
+	types[XkbGroup3Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup3Index);
+	types[XkbGroup4Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup4Index);
+	nG= XkbKeyTypesForCoreSymbols(xkb,map_width,syms,explicit,types,tsyms);
+	if (changes)
+	     mc= &changes->map;
+	else mc= NULL;
+	XkbChangeTypesOfKey(xkb,key,nG,XkbAllGroupsMask,types,mc);
+	memcpy((char *)XkbKeySymsPtr(xkb,key),(char *)tsyms,
+					XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
+	XkbApplyCompatMapToKey(xkb,key,changes);
+    }
+
+    if ((xkb->server->vmods!=NULL)&&(xkb->map->modmap!=NULL)&&(changes)&&
+	(changes->map.changed&(XkbVirtualModMapMask|XkbModifierMapMask))) {
+	unsigned char		newVMods[XkbNumVirtualMods];
+	register  unsigned 	bit,i;
+	unsigned		present;
+
+	bzero(newVMods,XkbNumVirtualMods);
+	present= 0;
+	for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
+	    if (xkb->server->vmodmap[key]==0)
+		continue;
+	    for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+		if (bit&xkb->server->vmodmap[key]) {
+		    present|= bit;
+		    newVMods[i]|= xkb->map->modmap[key];
+		}
+	    }
+	}
+	for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	    if ((bit&present)&&(newVMods[i]!=xkb->server->vmods[i])) {
+		changes->map.changed|= XkbVirtualModsMask;
+		changes->map.vmods|= bit;
+		xkb->server->vmods[i]= newVMods[i];
+	    }
+	}
+    }
+    if (changes && (changes->map.changed&XkbVirtualModsMask))
+	XkbApplyVirtualModChanges(xkb,changes->map.vmods,changes);
+    return True;
+}
+
+Status
+#if NeedFunctionPrototypes
+XkbChangeTypesOfKey(	XkbDescPtr		 xkb,
+			int		 	 key,
+			int			 nGroups,
+			unsigned	 	 groups,
+			int	* 	 	 newTypesIn,
+			XkbMapChangesPtr	 changes)
+#else
+XkbChangeTypesOfKey(xkb,key,nGroups,groups,newTypesIn,changes)
+    XkbDescPtr		 xkb;
+    int		 	 key;
+    int			 nGroups;
+    unsigned	 	 groups;
+    int	* 	 	 newTypesIn;
+    XkbMapChangesPtr	 changes;
+#endif
+{
+XkbKeyTypePtr	pOldType,pNewType;
+register int	i;
+int		width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
+
+    if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) ||
+	(!xkb->map->types)||(!newTypes)||((groups&XkbAllGroupsMask)==0)||
+	(nGroups>XkbNumKbdGroups)) {
+	return BadMatch;
+    }
+    if (nGroups==0) {
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex;
+	}
+	i= xkb->map->key_sym_map[key].group_info;
+	i= XkbSetNumGroups(i,0);
+	xkb->map->key_sym_map[key].group_info= i;
+	XkbResizeKeySyms(xkb,key,0);
+	return Success;
+    }
+
+    nOldGroups= XkbKeyNumGroups(xkb,key);
+    oldWidth= XkbKeyGroupsWidth(xkb,key);
+    for (width=i=0;i<nGroups;i++) {
+	if (groups&(1<<i))
+	     newTypes[i]=  newTypesIn[i];
+	else if (i<nOldGroups)
+	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i);
+	else if (nOldGroups>0)
+	     newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
+	else newTypes[i]= XkbTwoLevelIndex;
+	if (newTypes[i]>xkb->map->num_types)
+	    return BadMatch;
+	pNewType= &xkb->map->types[newTypes[i]];
+	if (pNewType->num_levels>width)
+	    width= pNewType->num_levels;
+    }
+    if ((xkb->ctrls)&&(nGroups>xkb->ctrls->num_groups))
+	xkb->ctrls->num_groups= nGroups;
+    if ((width!=oldWidth)||(nGroups!=nOldGroups)) {
+	KeySym		oldSyms[XkbMaxSymsPerKey],*pSyms;
+	int		nCopy;
+
+	if (nOldGroups==0) {
+	    pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
+	    if (pSyms!=NULL) {
+		i= xkb->map->key_sym_map[key].group_info;
+		i= XkbSetNumGroups(i,nGroups);
+		xkb->map->key_sym_map[key].group_info= i;
+		xkb->map->key_sym_map[key].width= width;
+		for (i=0;i<nGroups;i++) {
+		    xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
+		}
+		return Success;
+	    }
+	    return BadAlloc;
+	}
+	pSyms= XkbKeySymsPtr(xkb,key);
+	memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
+	pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
+	if (pSyms==NULL)
+	    return BadAlloc;
+	bzero(pSyms,width*nGroups*sizeof(KeySym));
+	for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
+	    pOldType= XkbKeyKeyType(xkb,key,i);
+	    pNewType= &xkb->map->types[newTypes[i]];
+	    if (pNewType->num_levels>pOldType->num_levels)
+		 nCopy= pOldType->num_levels;
+	    else nCopy= pNewType->num_levels;
+	    memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym));
+	}
+	if (XkbKeyHasActions(xkb,key)) {
+	    XkbAction	oldActs[XkbMaxSymsPerKey],*pActs;
+	    pActs= XkbKeyActionsPtr(xkb,key);
+	    memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction));
+	    pActs= XkbResizeKeyActions(xkb,key,width*nGroups);
+	    if (pActs==NULL)
+		return BadAlloc;
+	    bzero(pActs,width*nGroups*sizeof(XkbAction));
+	    for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
+		pOldType= XkbKeyKeyType(xkb,key,i);
+		pNewType= &xkb->map->types[newTypes[i]];
+		if (pNewType->num_levels>pOldType->num_levels)
+		     nCopy= pOldType->num_levels;
+		else nCopy= pNewType->num_levels;
+		memcpy(&pActs[i*width],&oldActs[i*oldWidth],
+						nCopy*sizeof(XkbAction));
+	    }
+	}
+	i= xkb->map->key_sym_map[key].group_info;
+	i= XkbSetNumGroups(i,nGroups);
+	xkb->map->key_sym_map[key].group_info= i;
+	xkb->map->key_sym_map[key].width= width;
+    }
+    width= 0;
+    for (i=0;i<nGroups;i++) {
+	xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
+	if (xkb->map->types[newTypes[i]].num_levels>width)
+	    width= xkb->map->types[newTypes[i]].num_levels;
+    }
+    xkb->map->key_sym_map[key].width= width;
+    if (changes!=NULL) {
+	if (changes->changed&XkbKeySymsMask) {
+	    _XkbAddKeyChange(&changes->first_key_sym,&changes->num_key_syms,
+	    								key);
+	}
+	else {
+	    changes->changed|= XkbKeySymsMask;
+	    changes->first_key_sym= key;
+	    changes->num_key_syms= 1;
+	}
+    }
+    return Success;
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn)
+#else
+XkbVirtualModsToReal(xkb,virtual_mask,mask_rtrn)
+    XkbDescPtr	xkb;
+    unsigned	virtual_mask;
+    unsigned *	mask_rtrn;
+#endif
+{
+register int i,bit;
+register unsigned mask;
+
+    if (xkb==NULL)
+	return False;
+    if (virtual_mask==0) {
+	*mask_rtrn= 0;
+	return True;
+    }
+    if (xkb->server==NULL)
+	return False;
+    for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (virtual_mask&bit)
+	    mask|= xkb->server->vmods[i];
+    }
+    *mask_rtrn= mask;
+    return True;
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+XkbUpdateActionVirtualMods(XkbDescPtr xkb,XkbAction *act,unsigned changed)
+#else
+XkbUpdateActionVirtualMods(xkb,act,changed)
+    XkbDescPtr	xkb;
+    XkbAction *	act;
+    unsigned	changed;
+#endif
+{
+unsigned int	tmp;
+
+    switch (act->type) {
+	case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
+	    if (((tmp= XkbModActionVMods(&act->mods))&changed)!=0) {
+		XkbVirtualModsToReal(xkb,tmp,&tmp);
+		act->mods.mask= act->mods.real_mods;
+		act->mods.mask|= tmp;
+		return True;
+	    }
+	    break;
+	case XkbSA_ISOLock:
+	    if ((((tmp= XkbModActionVMods(&act->iso))!=0)&changed)!=0) {
+		XkbVirtualModsToReal(xkb,tmp,&tmp);
+		act->iso.mask= act->iso.real_mods;
+		act->iso.mask|= tmp;
+		return True;
+	    }
+	    break;
+    }
+    return False;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbUpdateKeyTypeVirtualMods(	XkbDescPtr	xkb,
+				XkbKeyTypePtr	type,
+				unsigned int	changed,
+				XkbChangesPtr 	changes)
+#else
+XkbUpdateKeyTypeVirtualMods(xkb,type,changed,changes)
+    XkbDescPtr		xkb;
+    XkbKeyTypePtr	type;
+    unsigned int	changed;
+    XkbChangesPtr	changes;
+#endif
+{
+register unsigned int	i;
+unsigned int		mask;
+
+    XkbVirtualModsToReal(xkb,type->mods.vmods,&mask);
+    type->mods.mask= type->mods.real_mods|mask;
+    if ((type->map_count>0)&&(type->mods.vmods!=0)) {
+	XkbKTMapEntryPtr entry;
+	for (i=0,entry=type->map;i<type->map_count;i++,entry++) {
+	    if (entry->mods.vmods!=0) {
+		XkbVirtualModsToReal(xkb,entry->mods.vmods,&mask);
+		entry->mods.mask=entry->mods.real_mods|mask;
+		/* entry is active if vmods are bound*/
+	    	entry->active= (mask!=0);
+	    }
+	    else entry->active= 1;
+	}
+    }
+    if (changes) {
+	int	type_ndx;
+	type_ndx= type-xkb->map->types;
+	if ((type_ndx<0)||(type_ndx>xkb->map->num_types))
+	    return;
+	if (changes->map.changed&XkbKeyTypesMask) {
+	    int last;
+	    last= changes->map.first_type+changes->map.num_types-1;
+	    if (type_ndx<changes->map.first_type) {
+		changes->map.first_type= type_ndx;
+		changes->map.num_types= (last-type_ndx)+1;
+	    }
+	    else if (type_ndx>last) {
+		changes->map.num_types= (type_ndx-changes->map.first_type)+1;
+	    }
+	}
+	else {
+	    changes->map.changed|= XkbKeyTypesMask;
+	    changes->map.first_type= type_ndx;
+	    changes->map.num_types= 1;
+	}
+    }
+    return;
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbApplyVirtualModChanges(XkbDescPtr xkb,unsigned changed,XkbChangesPtr changes)
+#else
+XkbApplyVirtualModChanges(xkb,changed,changes)
+    XkbDescPtr		xkb;
+    unsigned		changed;
+    XkbChangesPtr	changes;
+#endif
+{
+register int	i;
+unsigned	checkState;
+
+    if ((!xkb) || (!xkb->map) || (changed==0))
+	return False;
+    for (i=0;i<xkb->map->num_types;i++) {
+	if (xkb->map->types[i].mods.vmods & changed)
+	XkbUpdateKeyTypeVirtualMods(xkb,&xkb->map->types[i],changed,changes);
+    }
+    if (changed&xkb->ctrls->internal.vmods) {
+	unsigned int	newMask;
+	XkbVirtualModsToReal(xkb,xkb->ctrls->internal.vmods,&newMask);
+	newMask|= xkb->ctrls->internal.real_mods;
+	if (xkb->ctrls->internal.mask!=newMask) {
+	    xkb->ctrls->internal.mask= newMask;
+	    if (changes) {
+		changes->ctrls.changed_ctrls|= XkbInternalModsMask;
+		checkState= True;
+	    }
+	}
+    }
+    if (changed&xkb->ctrls->ignore_lock.vmods) {
+	unsigned int	newMask;
+	XkbVirtualModsToReal(xkb,xkb->ctrls->ignore_lock.vmods,&newMask);
+	newMask|= xkb->ctrls->ignore_lock.real_mods;
+	if (xkb->ctrls->ignore_lock.mask!=newMask) {
+	    xkb->ctrls->ignore_lock.mask= newMask;
+	    if (changes) {
+		changes->ctrls.changed_ctrls|= XkbIgnoreLockModsMask;
+		checkState= True;
+	    }
+	}
+    }
+    if (xkb->indicators!=NULL) {
+	XkbIndicatorMapPtr map;
+	map= &xkb->indicators->maps[0];
+	for (i=0;i<XkbNumIndicators;i++,map++) {
+	    if (map->mods.vmods&changed) {
+		unsigned int newMask;
+		XkbVirtualModsToReal(xkb,map->mods.vmods,&newMask);
+		newMask|= map->mods.real_mods;
+		if (newMask!=map->mods.mask) {
+		    map->mods.mask= newMask;
+		    if (changes) {
+			changes->indicators.map_changes|= (1<<i);
+			checkState= True;
+		    }
+		}
+	    }
+	}
+    }
+    if (xkb->compat!=NULL) {
+	XkbCompatMapPtr	compat;
+	compat= xkb->compat;
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    unsigned int newMask;
+	    XkbVirtualModsToReal(xkb,compat->groups[i].vmods,&newMask);
+	    newMask|= compat->groups[i].real_mods;
+	    if (compat->groups[i].mask!=newMask) {
+		compat->groups[i].mask= newMask;
+		if (changes) {
+		    changes->compat.changed_groups|= (1<<i);
+		    checkState= True;
+		}
+	    }
+	}
+    }
+    if (xkb->map && xkb->server) {
+	int	highChange,lowChange;
+	lowChange= -1;
+	for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+	    if (XkbKeyHasActions(xkb,i)) {
+		register XkbAction *pAct;
+		register int n;
+
+		pAct= XkbKeyActionsPtr(xkb,i);
+		for (n=XkbKeyNumActions(xkb,i);n>0;n--,pAct++) {
+		    if ((pAct->type!=XkbSA_NoAction)&&
+			XkbUpdateActionVirtualMods(xkb,pAct,changed)) {
+			if (lowChange<0)
+			    lowChange= i;
+			highChange= i;
+		    }
+		}
+	    }
+	}
+	if (changes && (lowChange>0)) { /* something changed */
+	    if (changes->map.changed&XkbKeyActionsMask) {
+		int last;
+		if (changes->map.first_key_act<lowChange)
+		    lowChange= changes->map.first_key_act;
+		last= changes->map.first_key_act+changes->map.num_key_acts-1;
+		if (last>highChange)
+		    highChange= last;
+	    }
+	    changes->map.changed|= 	XkbKeyActionsMask;
+	    changes->map.first_key_act=	lowChange;
+	    changes->map.num_key_acts=	(highChange-lowChange)+1;
+	}
+    }
+    return checkState;
+}
diff --git a/lib/X11/XKBSetGeom.c b/lib/X11/XKBSetGeom.c
new file mode 100644
index 000000000..0327536f1
--- /dev/null
+++ b/lib/X11/XKBSetGeom.c
@@ -0,0 +1,559 @@
+/* $XConsortium: XKBSetGeom.c /main/2 1996/02/02 14:38:34 kaleb $ */
+/************************************************************
+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
+#include <stdio.h>
+#endif
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#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 *
+#if NeedFunctionPrototypes
+_WriteCountedString(char *wire,char *str)
+#else
+_WriteCountedString(wire,str)
+    char *	wire;
+    char *	str;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomProperties(XkbGeometryPtr geom)
+#else
+_SizeGeomProperties(geom)
+    XkbGeometryPtr	geom;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomColors(XkbGeometryPtr geom)
+#else
+_SizeGeomColors(geom)
+    XkbGeometryPtr	geom;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomShapes(XkbGeometryPtr geom)
+#else
+_SizeGeomShapes(geom)
+    XkbGeometryPtr	geom;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomDoodads(int num_doodads,XkbDoodadPtr doodad)
+#else
+_SizeGeomDoodads(num_doodads,doodad)
+    int			num_doodads;
+    XkbDoodadPtr	doodad;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomSections(XkbGeometryPtr geom)
+#else
+_SizeGeomSections(geom)
+    XkbGeometryPtr	geom;
+#endif
+{
+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
+#if NeedFunctionPrototypes
+_SizeGeomKeyAliases(XkbGeometryPtr geom)
+#else
+_SizeGeomKeyAliases(geom)
+    XkbGeometryPtr	geom;
+#endif
+{
+    return geom->num_key_aliases*(2*XkbKeyNameLength);
+}
+
+/***====================================================================***/
+
+static char *
+#if NeedFunctionPrototypes
+_WriteGeomProperties(char *wire,XkbGeometryPtr geom)
+#else
+_WriteGeomProperties(wire,geom)
+    char *		wire;
+    XkbGeometryPtr 	geom;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomColors(char *wire,XkbGeometryPtr geom)
+#else
+_WriteGeomColors(wire,geom)
+    char *		wire;
+    XkbGeometryPtr 	geom;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomShapes(char *wire,XkbGeometryPtr geom)
+#else
+_WriteGeomShapes(wire,geom)
+    char *		wire;
+    XkbGeometryPtr 	geom;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomDoodads(char *wire,int num_doodads,XkbDoodadPtr doodad)
+#else
+_WriteGeomDoodads(wire,num_doodads,doodad)
+    char *		dpy;
+    int			num_doodads;
+    XkbDoodadPtr	doodad;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomOverlay(char *wire,XkbOverlayPtr ol)
+#else
+_WriteGeomOverlay(wire,ol)
+    char *		wire;
+    XkbOverlayPtr	ol;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomSections(char *wire,XkbGeometryPtr geom)
+#else
+_WriteGeomSections(wire,geom)
+    char *		wire;
+    XkbGeometryPtr 	geom;
+#endif
+{
+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 *
+#if NeedFunctionPrototypes
+_WriteGeomKeyAliases(char *wire,XkbGeometryPtr geom)
+#else
+_WriteGeomKeyAliases(wire,geom)
+    char *		wire;
+    XkbGeometryPtr 	geom;
+#endif
+{
+register int sz;
+    
+    sz= geom->num_key_aliases*(XkbKeyNameLength*2);
+    if (sz>0) {
+	memcpy(wire,(char *)geom->key_aliases,sz);
+	wire+= sz;
+    }
+    return wire;
+}
+
+/***====================================================================***/
+
+Status
+#if NeedFunctionPrototypes
+_SendSetGeometry(Display *dpy,XkbGeometryPtr geom,xkbSetGeometryReq *req)
+#else
+_SendSetGeometry(dpy,geom,req)
+    Display *		dpy;
+    XkbGeometryPtr	geom;
+    xkbSetGeometryReq *	req;
+#endif
+{
+xkbSetGeometryReq	tmp;
+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);
+    tmp= *req;
+    if (sz<BUFSIZE) {
+	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;
+}
+
+/***====================================================================***/
+
+Status
+#if NeedFunctionPrototypes
+XkbSetGeometry(Display *dpy,unsigned deviceSpec,XkbGeometryPtr geom)
+#else
+XkbSetGeometry(dpy,deviceSpec,geom)
+    Display *		dpy;
+    unsigned		deviceSpec;
+    XkbGeometryPtr	geom;
+#endif
+{
+xkbSetGeometryReq	*req;
+
+    if ( (!geom) || (dpy->flags & XlibDisplayNoXkb) ||
+	(!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
+	return BadAccess;
+    
+    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);
+    _SendSetGeometry(dpy,geom,req);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return Success;
+}
+
diff --git a/lib/X11/XKBUse.c b/lib/X11/XKBUse.c
index 7f3ee4c2a..ab2dc965d 100644
--- a/lib/X11/XKBUse.c
+++ b/lib/X11/XKBUse.c
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBUse.c /main/10 1996/01/14 16:43:53 kaleb $ */
+/* $XConsortium: XKBUse.c /main/11 1996/02/02 14:38:38 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -716,19 +716,39 @@ XkbUseExtension(dpy,major_rtrn,minor_rtrn)
     req->wantedMajor = XkbMajorVersion;
     req->wantedMinor = XkbMinorVersion;
     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.supported ) {
+	Bool	fail;
+	fail= True;
 	if (debugMsg)
 	    fprintf(stderr,
 		"XKB version mismatch (want %d.%02d, got %d.%02d)\n", 
 		XkbMajorVersion,XkbMinorVersion,
 		rep.serverMajor, rep.serverMinor);
-	/* could theoretically try for an older version here */
-	dpy->flags |= XlibDisplayNoXkb;
-	UnlockDisplay(dpy);
-	SyncHandle();
-	Xfree(xkbi);
-	if (major_rtrn)	*major_rtrn= rep.serverMajor;
-	if (minor_rtrn) *minor_rtrn= rep.serverMinor;
-	return False;
+
+	/* 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();
+	    Xfree(xkbi);
+	    if (major_rtrn)	*major_rtrn= rep.serverMajor;
+	    if (minor_rtrn) *minor_rtrn= rep.serverMinor;
+	    return False;
+	}
     }
 #ifdef DEBUG
     else if ( forceIgnore ) {
diff --git a/lib/X11/XKBlib.h b/lib/X11/XKBlib.h
index 68de1fe20..c6136f891 100644
--- a/lib/X11/XKBlib.h
+++ b/lib/X11/XKBlib.h
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBlib.h /main/13 1996/01/14 16:44:02 kaleb $ */
+/* $XConsortium: XKBlib.h /main/16 1996/02/02 16:43:21 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -286,6 +286,7 @@ typedef struct	_XkbKbdDpyState	XkbKbdDpyStateRec,*XkbKbdDpyStatePtr;
 #define	XkbLC_ComposeLED		(1<<30)
 #define	XkbLC_BeepOnComposeFail		(1<<31)
 
+#define XkbLC_AllComposeControls	(0xc0000000)
 #define	XkbLC_AllControls	(0xc000000f)
 
 _XFUNCPROTOBEGIN
@@ -389,7 +390,7 @@ extern	unsigned int	XkbKeysymToModifiers(
 #endif
 );
 
-extern	int		XkbLookupKeySym(
+extern	Bool		XkbLookupKeySym(
 #if NeedFunctionPrototypes
     Display *			/* dpy */,
     KeyCode 			/* keycode */,
@@ -402,7 +403,7 @@ extern	int		XkbLookupKeySym(
 extern	int		XkbLookupKeyBinding(
 #if NeedFunctionPrototypes
     Display *			/* dpy */,
-    KeySym *			/* sym_rtrn */,
+    KeySym 			/* sym_rtrn */,
     unsigned int 		/* mods */,
     char *			/* buffer */,
     int 			/* nbytes */,
@@ -410,7 +411,7 @@ extern	int		XkbLookupKeyBinding(
 #endif
 );
 
-extern	int		XkbTranslateKeyCode(
+extern	Bool		XkbTranslateKeyCode(
 #if NeedFunctionPrototypes
     XkbDescPtr			/* xkb */,
     KeyCode 			/* keycode */,
@@ -426,7 +427,8 @@ extern	int		XkbTranslateKeySym(
     register KeySym *		/* sym_return */,
     unsigned int 		/* modifiers */,
     char *			/* buffer */,
-    int 			/* nbytes */
+    int 			/* nbytes */,
+    int *			/* extra_rtrn */
 #endif
 );
 
@@ -961,6 +963,15 @@ extern Bool XkbSetCompatMap(
 #endif
 );
 
+extern	XkbSymInterpretPtr XkbAddSymInterpret(
+#if NeedFunctionPrototypes
+	XkbDescPtr		/* xkb */,
+	XkbSymInterpretPtr	/* si */,
+	Bool			/* updateMap */,
+	XkbChangesPtr		/* changes */
+#endif
+);
+
 extern	Status XkbAllocNames(
 #if NeedFunctionPrototypes
 	XkbDescPtr		/* xkb */,
@@ -1153,9 +1164,10 @@ extern XkbDescPtr XkbGetKeyboardByName(
 
 extern	int	XkbKeyTypesForCoreSymbols(	/* returns # of groups */
 #if NeedFunctionPrototypes
+    XkbDescPtr	/* xkb */,			/* keyboard device */
     int		/* map_width */,		/* width of core KeySym array */
     KeySym *	/* core_syms */,		/* always mapWidth symbols */
-    unsigned int	/* protected */,		/* explicit key types */
+    unsigned int	/* protected */,	/* explicit key types */
     int *	/* types_inout */,		/* always four type indices */
     KeySym * 	/* xkb_syms_rtrn */		/* must have enough space */
 #endif
@@ -1310,8 +1322,10 @@ extern	Bool XkbSetDebuggingFlags(
     unsigned int	/* mask */,
     unsigned int	/* flags */,
     char *		/* msg */,
-    unsigned int *	/* rtrnFlags */,
-    Bool *		/* disableLocks */
+    unsigned int	/* ctrls_mask */,
+    unsigned int	/* ctrls */,
+    unsigned int *	/* rtrn_flags */,
+    unsigned int *	/* rtrn_ctrls */
 #endif
 );
 
diff --git a/lib/X11/XKBlibint.h b/lib/X11/XKBlibint.h
index 039b1459f..8b13707c2 100644
--- a/lib/X11/XKBlibint.h
+++ b/lib/X11/XKBlibint.h
@@ -1,4 +1,4 @@
-/* $XConsortium: XKBlibint.h /main/10 1996/01/14 16:44:08 kaleb $ */
+/* $XConsortium: XKBlibint.h /main/11 1996/02/02 14:10:04 kaleb $ */
 /************************************************************
 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
 
@@ -40,7 +40,7 @@ typedef int	(*XkbKSToMBFunc)(
 	KeySym		/* sym */,
 	char *		/* buf */,
 	int		/* len */,
-	Status *	/* status */
+	int *		/* extra_rtrn */
 #endif
 );
 
diff --git a/lib/X11/Xlibint.h b/lib/X11/Xlibint.h
index a0217bc44..d2aa38e70 100644
--- a/lib/X11/Xlibint.h
+++ b/lib/X11/Xlibint.h
@@ -1,4 +1,4 @@
-/* $XConsortium: Xlibint.h /main/110 1995/11/14 22:55:49 gildea $ */
+/* $XConsortium: Xlibint.h /main/111 1996/02/02 14:10:09 kaleb $ */
 
 /*
 
@@ -194,6 +194,9 @@ typedef struct _XSQEvent
 #define NEED_REPLIES
 #endif
 #include <X11/Xproto.h>
+#ifdef __sgi
+#define _SGI_MP_SOURCE  /* turn this on to get MP safe errno */
+#endif
 #include <errno.h>
 #define _XBCOPYFUNC _Xbcopy
 #include <X11/Xfuncs.h>
author	dawes <dawes>	1996-02-04 07:32:31 +0000
committer	dawes <dawes>	1996-02-04 07:32:31 +0000
commit	f672e940f91aaaea21feb4395fcb4f7bd701a9a9 (patch)
tree	70ceaf230f7f0818e408cea639fa90eb0d045333
parent	40f7145e28a483bcd00a9680c5d9d6385d98fcf4 (diff)