Update to xserver 1.8. Tested by many. Ok oga@, todd@.

1 files changed, 243 insertions, 398 deletions

diff --git a/xserver/xkb/xkbInit.c b/xserver/xkb/xkbInit.c
index 1c3496a8c..4a3219e2a 100644
--- a/xserver/xkb/xkbInit.c
+++ b/xserver/xkb/xkbInit.c
@@ -28,16 +28,13 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#ifdef HAVE_XKB_CONFIG_H
 #include <xkb-config.h>
-#endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <unistd.h>
 #include <math.h>
-#define NEED_EVENTS 1
 #include <X11/X.h>
 #include <X11/Xproto.h>
 #include <X11/keysym.h>
@@ -86,69 +83,73 @@ typedef struct	_SrvXkmInfo {
 
 /***====================================================================***/
 
-#ifndef XKB_BASE_DIRECTORY
-#define	XKB_BASE_DIRECTORY	"/usr/lib/X11/xkb"
-#endif
-#ifndef XKB_BIN_DIRECTORY
-#define	XKB_BIN_DIRECTORY	XKB_BASE_DIRECTORY
-#endif
-#ifndef XKB_DFLT_RULES_FILE
-#define	XKB_DFLT_RULES_FILE	"xorg"
-#endif
-#ifndef XKB_DFLT_KB_LAYOUT
-#define	XKB_DFLT_KB_LAYOUT	"us"
-#endif
-#ifndef XKB_DFLT_KB_MODEL
-#define	XKB_DFLT_KB_MODEL	"dflt"
-#endif
-#ifndef XKB_DFLT_KB_VARIANT
-#define	XKB_DFLT_KB_VARIANT	NULL
-#endif
-#ifndef XKB_DFLT_KB_OPTIONS
-#define	XKB_DFLT_KB_OPTIONS	NULL
-#endif
-#ifndef XKB_DFLT_DISABLED
-#define	XKB_DFLT_DISABLED	True
-#endif
 #ifndef XKB_DFLT_RULES_PROP
-#define	XKB_DFLT_RULES_PROP	True
+#define	XKB_DFLT_RULES_PROP	TRUE
 #endif
 
 char	*		XkbBaseDirectory=	XKB_BASE_DIRECTORY;
 char	*		XkbBinDirectory=	XKB_BIN_DIRECTORY;
 static int	 	XkbWantAccessX=		0;	
 
-static Bool		rulesDefined=		False;
-static char *		XkbRulesFile=		NULL;
+static char *		XkbRulesDflt=		NULL;
 static char *		XkbModelDflt=		NULL;
 static char *		XkbLayoutDflt=		NULL;
 static char *		XkbVariantDflt=		NULL;
 static char *		XkbOptionsDflt=		NULL;
 
+static char *           XkbRulesUsed=   NULL;
 static char *		XkbModelUsed=	NULL;
 static char *		XkbLayoutUsed=	NULL;
 static char *		XkbVariantUsed=	NULL;
 static char *		XkbOptionsUsed=	NULL;
 
-static XkbDescPtr       xkb_cached_map = NULL;
+static XkbDescPtr	xkb_cached_map = NULL;
 
-_X_EXPORT Bool		noXkbExtension=		XKB_DFLT_DISABLED;
 static Bool		XkbWantRulesProp=	XKB_DFLT_RULES_PROP;
 
 /***====================================================================***/
 
-static char *
-XkbGetRulesDflts(XkbRF_VarDefsPtr defs)
+/**
+ * Get the current default XKB rules.
+ * Caller must free the data in rmlvo.
+ */
+void
+XkbGetRulesDflts(XkbRMLVOSet *rmlvo)
+{
+    if (XkbRulesDflt)   rmlvo->rules = XkbRulesDflt;
+    else                rmlvo->rules = XKB_DFLT_RULES;
+    if (XkbModelDflt)	rmlvo->model= XkbModelDflt;
+    else		rmlvo->model= XKB_DFLT_MODEL;
+    if (XkbLayoutDflt)	rmlvo->layout= XkbLayoutDflt;
+    else		rmlvo->layout= XKB_DFLT_LAYOUT;
+    if (XkbVariantDflt)	rmlvo->variant= XkbVariantDflt;
+    else		rmlvo->variant= XKB_DFLT_VARIANT;
+    if (XkbOptionsDflt)	rmlvo->options= XkbOptionsDflt;
+    else		rmlvo->options= XKB_DFLT_OPTIONS;
+
+    rmlvo->rules = strdup(rmlvo->rules);
+    rmlvo->model = strdup(rmlvo->model);
+    rmlvo->layout = strdup(rmlvo->layout);
+    rmlvo->variant = strdup(rmlvo->variant);
+    rmlvo->options = strdup(rmlvo->options);
+}
+
+void
+XkbFreeRMLVOSet(XkbRMLVOSet *rmlvo, Bool freeRMLVO)
 {
-    if (XkbModelDflt)	defs->model= XkbModelDflt;
-    else		defs->model= XKB_DFLT_KB_MODEL;
-    if (XkbLayoutDflt)	defs->layout= XkbLayoutDflt;
-    else		defs->layout= XKB_DFLT_KB_LAYOUT;
-    if (XkbVariantDflt)	defs->variant= XkbVariantDflt;
-    else		defs->variant= XKB_DFLT_KB_VARIANT;
-    if (XkbOptionsDflt)	defs->options= XkbOptionsDflt;
-    else		defs->options= XKB_DFLT_KB_OPTIONS;
-    return (rulesDefined?XkbRulesFile:XKB_DFLT_RULES_FILE);
+    if (!rmlvo)
+        return;
+
+    xfree(rmlvo->rules);
+    xfree(rmlvo->model);
+    xfree(rmlvo->layout);
+    xfree(rmlvo->variant);
+    xfree(rmlvo->options);
+
+    if (freeRMLVO)
+        xfree(rmlvo);
+    else
+        memset(rmlvo, 0, sizeof(XkbRMLVOSet));
 }
 
 static Bool
@@ -158,36 +159,31 @@ int 			len,out;
 Atom			name;
 char *			pval;
 
-    if (rulesDefined && (!XkbRulesFile))
-	return False;
-    len= (XkbRulesFile?strlen(XkbRulesFile):strlen(XKB_DFLT_RULES_FILE));
+    len= (XkbRulesUsed?strlen(XkbRulesUsed):0);
     len+= (XkbModelUsed?strlen(XkbModelUsed):0);
     len+= (XkbLayoutUsed?strlen(XkbLayoutUsed):0);
     len+= (XkbVariantUsed?strlen(XkbVariantUsed):0);
     len+= (XkbOptionsUsed?strlen(XkbOptionsUsed):0);
     if (len<1)
-	return True;
+	return TRUE;
 
     len+= 5; /* trailing NULs */
 
     name= MakeAtom(_XKB_RF_NAMES_PROP_ATOM,strlen(_XKB_RF_NAMES_PROP_ATOM),1);
     if (name==None) {
 	ErrorF("[xkb] Atom error: %s not created\n",_XKB_RF_NAMES_PROP_ATOM);
-	return True;
+	return TRUE;
     }
     pval= (char*) xalloc(len);
     if (!pval) {
 	ErrorF("[xkb] Allocation error: %s proprerty not created\n",
 						_XKB_RF_NAMES_PROP_ATOM);
-	return True;
+	return TRUE;
     }
     out= 0;
-    if (XkbRulesFile) {
-	strcpy(&pval[out],XkbRulesFile);
-	out+= strlen(XkbRulesFile);
-    } else {
-	strcpy(&pval[out],XKB_DFLT_RULES_FILE);
-	out+= strlen(XKB_DFLT_RULES_FILE);
+    if (XkbRulesUsed) {
+	strcpy(&pval[out],XkbRulesUsed);
+	out+= strlen(XkbRulesUsed);
     }
     pval[out++]= '\0';
     if (XkbModelUsed) {
@@ -215,99 +211,99 @@ char *			pval;
 								out,len);
     }
     dixChangeWindowProperty(serverClient, WindowTable[0], name, XA_STRING, 8,
-			    PropModeReplace, len, pval, True);
+			    PropModeReplace, len, pval, TRUE);
     xfree(pval);
-    return True;
+    return TRUE;
 }
 
 static void
-XkbSetRulesUsed(XkbRF_VarDefsPtr defs)
+XkbSetRulesUsed(XkbRMLVOSet *rmlvo)
 {
+    if (XkbRulesUsed)
+        xfree(XkbRulesUsed);
+    XkbRulesUsed= (rmlvo->rules?_XkbDupString(rmlvo->rules):NULL);
     if (XkbModelUsed)
-	_XkbFree(XkbModelUsed);
-    XkbModelUsed= (defs->model?_XkbDupString(defs->model):NULL);
+	xfree(XkbModelUsed);
+    XkbModelUsed= (rmlvo->model?_XkbDupString(rmlvo->model):NULL);
     if (XkbLayoutUsed)
-	_XkbFree(XkbLayoutUsed);
-    XkbLayoutUsed= (defs->layout?_XkbDupString(defs->layout):NULL);
+	xfree(XkbLayoutUsed);
+    XkbLayoutUsed= (rmlvo->layout?_XkbDupString(rmlvo->layout):NULL);
     if (XkbVariantUsed)
-	_XkbFree(XkbVariantUsed);
-    XkbVariantUsed= (defs->variant?_XkbDupString(defs->variant):NULL);
+	xfree(XkbVariantUsed);
+    XkbVariantUsed= (rmlvo->variant?_XkbDupString(rmlvo->variant):NULL);
     if (XkbOptionsUsed)
-	_XkbFree(XkbOptionsUsed);
-    XkbOptionsUsed= (defs->options?_XkbDupString(defs->options):NULL);
+	xfree(XkbOptionsUsed);
+    XkbOptionsUsed= (rmlvo->options?_XkbDupString(rmlvo->options):NULL);
     if (XkbWantRulesProp)
 	QueueWorkProc(XkbWriteRulesProp,NULL,NULL);
     return;
 }
 
-/**
- * Set the default RMLVO for the next device to be initialised.
- * If a parameter is NULL, the previous setting will be used. Use empty
- * strings if you want to delete a previous setting.
- *
- * If @rulesFile is NULL and no previous @rulesFile has been set, the
- * built-in default is chosen as default.
- */
-_X_EXPORT void
-XkbSetRulesDflts(char *rulesFile,char *model,char *layout,
-					char *variant,char *options)
+void
+XkbSetRulesDflts(XkbRMLVOSet *rmlvo)
 {
-    if (!rulesFile && !XkbRulesFile)
-    {
-	LogMessage(X_WARNING, "[xkb] No rule given, and no previous rule "
-		              "defined. Defaulting to '%s'.\n",
-                              XKB_DFLT_RULES_FILE);
-	rulesFile = XKB_DFLT_RULES_FILE;
-    }
-
-    if (rulesFile) {
-	if (XkbRulesFile)
-	    _XkbFree(XkbRulesFile);
-	XkbRulesFile= _XkbDupString(rulesFile);
-	rulesDefined= True;
+    if (rmlvo->rules) {
+        if (XkbRulesDflt)
+	    xfree(XkbRulesDflt);
+        XkbRulesDflt= _XkbDupString(rmlvo->rules);
     }
-
-    if (model) {
+    if (rmlvo->model) {
 	if (XkbModelDflt)
-	    _XkbFree(XkbModelDflt);
-	XkbModelDflt= _XkbDupString(model);
+	    xfree(XkbModelDflt);
+	XkbModelDflt= _XkbDupString(rmlvo->model);
     }
-    if (layout) {
+    if (rmlvo->layout) {
 	if (XkbLayoutDflt)
-	    _XkbFree(XkbLayoutDflt);
-	XkbLayoutDflt= _XkbDupString(layout);
+	    xfree(XkbLayoutDflt);
+	XkbLayoutDflt= _XkbDupString(rmlvo->layout);
     }
-    if (variant) {
+    if (rmlvo->variant) {
 	if (XkbVariantDflt)
-	    _XkbFree(XkbVariantDflt);
-	XkbVariantDflt= _XkbDupString(variant);
+	    xfree(XkbVariantDflt);
+	XkbVariantDflt= _XkbDupString(rmlvo->variant);
     }
-    if (options) {
+    if (rmlvo->options) {
 	if (XkbOptionsDflt)
-	    _XkbFree(XkbOptionsDflt);
-	XkbOptionsDflt= _XkbDupString(options);
+	    xfree(XkbOptionsDflt);
+	XkbOptionsDflt= _XkbDupString(rmlvo->options);
     }
     return;
 }
 
 void
-XkbDeleteRulesDflts()
+XkbDeleteRulesDflts(void)
 {
-    _XkbFree(XkbRulesFile);
-    XkbRulesFile = NULL;
-    _XkbFree(XkbModelDflt);
+    xfree(XkbRulesDflt);
+    XkbRulesDflt = NULL;
+    xfree(XkbModelDflt);
     XkbModelDflt = NULL;
-    _XkbFree(XkbLayoutDflt);
+    xfree(XkbLayoutDflt);
     XkbLayoutDflt = NULL;
-    _XkbFree(XkbVariantDflt);
+    xfree(XkbVariantDflt);
     XkbVariantDflt = NULL;
-    _XkbFree(XkbOptionsDflt);
+    xfree(XkbOptionsDflt);
     XkbOptionsDflt = NULL;
 
-    XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, True);
+    XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE);
     xkb_cached_map = NULL;
 }
 
+#define DIFFERS(a, b) (strcmp((a) ? (a) : "", (b) ? (b) : "") != 0)
+
+static Bool
+XkbCompareUsedRMLVO(XkbRMLVOSet *rmlvo)
+{
+    if (DIFFERS(rmlvo->rules, XkbRulesUsed) ||
+        DIFFERS(rmlvo->model, XkbModelUsed) ||
+        DIFFERS(rmlvo->layout, XkbLayoutUsed) ||
+        DIFFERS(rmlvo->variant, XkbVariantUsed) ||
+        DIFFERS(rmlvo->options, XkbOptionsUsed))
+        return FALSE;
+    return TRUE;
+}
+
+#undef DIFFERS
+
 /***====================================================================***/
 
 #include "xkbDflts.h"
@@ -316,17 +312,17 @@ static Bool
 XkbInitKeyTypes(XkbDescPtr xkb)
 {
     if (xkb->defined & XkmTypesMask)
-        return True;
+        return TRUE;
 
     initTypeNames(NULL);
     if (XkbAllocClientMap(xkb,XkbKeyTypesMask,num_dflt_types)!=Success)
-	return False;
+	return FALSE;
     if (XkbCopyKeyTypes(dflt_types,xkb->map->types,num_dflt_types)!=
     								 Success) {
-	return False;
+	return FALSE;
     }
     xkb->map->size_types= xkb->map->num_types= num_dflt_types;
-    return True;
+    return TRUE;
 }
 
 static void
@@ -345,7 +341,7 @@ register int 	i;
 XkbCompatMapPtr	compat;
 
     if (xkb->defined & XkmCompatMapMask)
-        return True;
+        return TRUE;
 
     if (XkbAllocCompatMap(xkb,XkbAllCompatMask,num_dfltSI)!=Success)
 	return BadAlloc;
@@ -493,292 +489,151 @@ XkbControlsPtr	ctrls;
     return Success;
 }
 
-void
-XkbInitDevice(DeviceIntPtr pXDev)
+_X_EXPORT Bool
+InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
+                         BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func)
 {
-int			i;
-XkbSrvInfoPtr		xkbi;
-XkbChangesRec		changes;
-unsigned		check;
-XkbEventCauseRec	cause;
-
-    bzero(&changes,sizeof(XkbChangesRec));
-    pXDev->key->xkbInfo= xkbi= _XkbTypedCalloc(1,XkbSrvInfoRec);
-    if ( xkbi ) {
-	XkbDescPtr	xkb;
+    int	i;
+    unsigned int check;
+    XkbSrvInfoPtr xkbi;
+    XkbDescPtr xkb;
+    XkbSrvLedInfoPtr sli;
+    XkbChangesRec changes;
+    XkbEventCauseRec cause;
+    XkbRMLVOSet rmlvo_dflts = { NULL };
+
+    if (dev->key || dev->kbdfeed)
+	return FALSE;
+
+    if (!rmlvo)
+    {
+        rmlvo = &rmlvo_dflts;
+        XkbGetRulesDflts(rmlvo);
+    }
 
-        if (xkb_cached_map) {
-            xkbi->desc = xkb_cached_map;
-            xkb_cached_map = NULL;
-        }
-        else {
-            xkbi->desc= XkbAllocKeyboard();
-            if (!xkbi->desc)
-                FatalError("Couldn't allocate keyboard description\n");
-            xkbi->desc->min_key_code = pXDev->key->curKeySyms.minKeyCode;
-            xkbi->desc->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
+
+    memset(&changes, 0, sizeof(changes));
+    XkbSetCauseUnknown(&cause);
+
+    dev->key = xcalloc(1, sizeof(*dev->key));
+    if (!dev->key) {
+        ErrorF("XKB: Failed to allocate key class\n");
+        return FALSE;
+    }
+    dev->key->sourceid = dev->id;
+
+    dev->kbdfeed = xcalloc(1, sizeof(*dev->kbdfeed));
+    if (!dev->kbdfeed) {
+        ErrorF("XKB: Failed to allocate key feedback class\n");
+        goto unwind_key;
+    }
+
+    xkbi = xcalloc(1, sizeof(*xkbi));
+    if (!xkbi) {
+        ErrorF("XKB: Failed to allocate XKB info\n");
+        goto unwind_kbdfeed;
+    }
+    dev->key->xkbInfo = xkbi;
+
+    if (xkb_cached_map && !XkbCompareUsedRMLVO(rmlvo)) {
+        XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE);
+        xkb_cached_map = NULL;
+    }
+
+    if (xkb_cached_map)
+        LogMessageVerb(X_INFO, 4, "XKB: Reusing cached keymap\n");
+    else {
+        xkb_cached_map = XkbCompileKeymap(dev, rmlvo);
+        if (!xkb_cached_map) {
+            ErrorF("XKB: Failed to compile keymap\n");
+            goto unwind_info;
         }
-	xkb= xkbi->desc;
-	if (xkb->min_key_code == 0)
-	    xkb->min_key_code = pXDev->key->curKeySyms.minKeyCode;
-	if (xkb->max_key_code == 0)
-	    xkb->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
-	if ((pXDev->key->curKeySyms.minKeyCode!=xkbi->desc->min_key_code)||
-	    (pXDev->key->curKeySyms.maxKeyCode!=xkbi->desc->max_key_code)) {
-	    /* 12/9/95 (ef) -- XXX! Maybe we should try to fix up one or */
-	    /*                 the other here, but for now just complain */
-	    /*                 can't just update the core range without */
-	    /*                 reallocating the KeySymsRec (pain)       */
-	    ErrorF("[xkb] Internal Error!! XKB and core keymap have different range\n");
-	}
-	if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success)
-	    FatalError("Couldn't allocate client map in XkbInitDevice\n");
-	i= XkbNumKeys(xkb)/3+1;
-	if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,i)!=Success)
-	    FatalError("Couldn't allocate server map in XkbInitDevice\n");
-
-	xkbi->dfltPtrDelta=1;
-	xkbi->device = pXDev;
-
-	XkbInitSemantics(xkb);
-	XkbInitNames(xkbi);
-	XkbInitRadioGroups(xkbi);
-
-	/* 12/31/94 (ef) -- XXX! Should check if state loaded from file */
-	bzero(&xkbi->state,sizeof(XkbStateRec));
-
-	XkbInitControls(pXDev,xkbi);
-
-        if (xkb->defined & XkmSymbolsMask)
-            memcpy(pXDev->key->modifierMap, xkb->map->modmap,
-                   xkb->max_key_code + 1);
-        else
-            memcpy(xkb->map->modmap, pXDev->key->modifierMap,
-                   xkb->max_key_code + 1);
-
-	XkbInitIndicatorMap(xkbi);
-
-	XkbDDXInitDevice(pXDev);
-
-        if (xkb->defined & XkmSymbolsMask)
-            XkbUpdateCoreDescription(pXDev, True);
-        else
-            XkbUpdateKeyTypesFromCore(pXDev, xkb->min_key_code,
-                                      XkbNumKeys(xkb), &changes);
-
-	XkbSetCauseUnknown(&cause);
-	XkbUpdateActions(pXDev,xkb->min_key_code, XkbNumKeys(xkb),&changes,
-								&check,&cause);
-        /* For sanity.  The first time the connection
-         * is opened, the client side min and max are set
-         * using QueryMinMaxKeyCodes() which grabs them 
-	 * from pXDev.
-	 */
-	pXDev->key->curKeySyms.minKeyCode = xkb->min_key_code;
-	pXDev->key->curKeySyms.maxKeyCode = xkb->max_key_code;
     }
-    return;
-}
 
-#if MAP_LENGTH > XkbMaxKeyCount
-#undef  XkbMaxKeyCount
-#define XkbMaxKeyCount MAP_LENGTH
-#endif
+    xkb = XkbAllocKeyboard();
+    if (!xkb) {
+        ErrorF("XKB: Failed to allocate keyboard description\n");
+        goto unwind_info;
+    }
 
-_X_EXPORT Bool
-XkbInitKeyboardDeviceStruct(
-    DeviceIntPtr		dev,
-    XkbComponentNamesPtr	names,
-    KeySymsPtr                  pSymsIn,
-    CARD8                       pModsIn[],
-    void                        (*bellProc)(
-        int /*percent*/,
-        DeviceIntPtr /*device*/,
-        pointer /*ctrl*/,
-        int),
-    void                        (*ctrlProc)(
-        DeviceIntPtr /*device*/,
-        KeybdCtrl * /*ctrl*/))
-{
-KeySymsRec		tmpSyms,*pSyms;
-CARD8			tmpMods[XkbMaxLegalKeyCode+1],*pMods;
-char			name[PATH_MAX],*rules;
-Bool			ok=False;
-XkbRF_VarDefsRec	defs;
-XkbDescPtr              xkb;
-
-    if ((dev->key!=NULL)||(dev->kbdfeed!=NULL))
-	return False;
-    pSyms= pSymsIn;
-    pMods= pModsIn;
-    bzero(&defs,sizeof(XkbRF_VarDefsRec));
-    rules= XkbGetRulesDflts(&defs);
-
-    /*
-     * The strings are duplicated because it is not guaranteed that
-     * they are allocated, or that they are allocated for every server
-     * generation. Eventually they will be freed at the end of this
-     * function.
-     */
-    names->keymap = NULL;
-    if (names->keycodes) names->keycodes = _XkbDupString(names->keycodes);
-    if (names->types) names->types = _XkbDupString(names->types);
-    if (names->compat) names->compat = _XkbDupString(names->compat);
-    if (names->geometry) names->geometry = _XkbDupString(names->geometry);
-    if (names->symbols) names->symbols = _XkbDupString(names->symbols);
-
-    if (defs.model && defs.layout && rules) {
-	XkbComponentNamesRec	rNames;
-	bzero(&rNames,sizeof(XkbComponentNamesRec));
-	if (XkbDDXNamesFromRules(dev,rules,&defs,&rNames)) {
-	    if (rNames.keycodes) {
-		if (!names->keycodes)
-		    names->keycodes =  rNames.keycodes;
-		else
-		    _XkbFree(rNames.keycodes);
-	    }
-	    if (rNames.types) {
-		if (!names->types)
-		    names->types = rNames.types;
-		else  _XkbFree(rNames.types);
-	    }
-	    if (rNames.compat) {
-		if (!names->compat) 
-		    names->compat =  rNames.compat;
-		else  _XkbFree(rNames.compat);
-	    }
-	    if (rNames.symbols) {
-		if (!names->symbols)
-		    names->symbols =  rNames.symbols;
-		else _XkbFree(rNames.symbols);
-	    }
-	    if (rNames.geometry) {
-		if (!names->geometry)
-		    names->geometry = rNames.geometry;
-		else _XkbFree(rNames.geometry);
-	    }
-	    XkbSetRulesUsed(&defs);
-	}
+    if (!XkbCopyKeymap(xkb, xkb_cached_map)) {
+        ErrorF("XKB: Failed to copy keymap\n");
+        goto unwind_desc;
     }
+    xkb->defined = xkb_cached_map->defined;
+    xkb->flags = xkb_cached_map->flags;
+    xkb->device_spec = xkb_cached_map->device_spec;
+    xkbi->desc = xkb;
 
-    ok = (Bool) XkbDDXLoadKeymapByNames(dev,names,XkmAllIndicesMask,0,
-                                        &xkb,name,PATH_MAX);
+    if (xkb->min_key_code == 0)
+        xkb->min_key_code = 8;
+    if (xkb->max_key_code == 0)
+        xkb->max_key_code = 255;
 
-    if (ok && (xkb!=NULL)) {
-	KeyCode		minKC,maxKC;
+    i = XkbNumKeys(xkb) / 3 + 1;
+    if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success)
+        goto unwind_desc;
+    if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, i) != Success)
+        goto unwind_desc;
 
-	minKC= xkb->min_key_code;
-	maxKC= xkb->max_key_code;
-	if (XkbIsLegalKeycode(minKC)&&XkbIsLegalKeycode(maxKC)&&(minKC<=maxKC)&&
-	    ((minKC!=pSyms->minKeyCode)||(maxKC!=pSyms->maxKeyCode))) {
-	    if (xkb->map!=NULL) {
-		KeySym	*inSym,*outSym;
-		int	width= pSymsIn->mapWidth;
+    xkbi->dfltPtrDelta = 1;
+    xkbi->device = dev;
 
-		tmpSyms.minKeyCode= minKC;
-		tmpSyms.maxKeyCode= maxKC;
+    XkbInitSemantics(xkb);
+    XkbInitNames(xkbi);
+    XkbInitRadioGroups(xkbi);
 
-		if (minKC<pSymsIn->minKeyCode)
-		    minKC= pSymsIn->minKeyCode;
-		if (maxKC>pSymsIn->maxKeyCode)
-		    maxKC= pSymsIn->maxKeyCode;
+    XkbInitControls(dev, xkbi);
 
-		tmpSyms.mapWidth= width;
-		tmpSyms.map= _XkbTypedCalloc(width*XkbNumKeys(xkb),KeySym);
-		inSym= &pSymsIn->map[(minKC-pSymsIn->minKeyCode)*width];
-		outSym= &tmpSyms.map[(minKC-tmpSyms.minKeyCode)*width];
-		memcpy(outSym,inSym,((maxKC-minKC+1)*width)*sizeof(KeySym));
-		pSyms= &tmpSyms;
-	    }
-	    if ((xkb->map!=NULL)&&(xkb->map->modmap!=NULL)) {
-		bzero(tmpMods,XkbMaxKeyCount);
-		memcpy(tmpMods,xkb->map->modmap,maxKC+1);
-		pMods= tmpMods;
-	    }
-	}
-        /* Store the map here so we can pick it back up in XkbInitDevice.
-         * Sigh. */
-        xkb_cached_map = xkb;
-    }
-    else {
-	LogMessage(X_WARNING, "Couldn't load XKB keymap, falling back to pre-XKB keymap\n");
-    }
-    ok= InitKeyboardDeviceStruct((DevicePtr)dev,pSyms,pMods,bellProc,ctrlProc);
-    xkb_cached_map = NULL;
-    if ((pSyms==&tmpSyms)&&(pSyms->map!=NULL)) {
-	_XkbFree(pSyms->map);
-	pSyms->map= NULL;
-    }
-
-    if (names->keycodes) _XkbFree(names->keycodes);
-    names->keycodes = NULL;
-    if (names->types) _XkbFree(names->types);
-    names->types = NULL;
-    if (names->compat) _XkbFree(names->compat);
-    names->compat = NULL;
-    if (names->geometry) _XkbFree(names->geometry);
-    names->geometry = NULL;
-    if (names->symbols) _XkbFree(names->symbols);
-    names->symbols = NULL;
-
-    return ok;
-}
+    XkbInitIndicatorMap(xkbi);
 
-/***====================================================================***/
+    XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &changes,
+                     &check, &cause);
 
-	/*
-	 * InitKeyClassDeviceStruct initializes the key class before it
-	 * initializes the keyboard feedback class for a device. 
-	 * UpdateActions can't set up the correct autorepeat for keyboard 
-	 * initialization because the keyboard feedback isn't created yet.   
-	 * Instead, UpdateActions notes the "correct" autorepeat in the 
-	 * SrvInfo structure and InitKbdFeedbackClass calls UpdateAutoRepeat 
-	 * to apply the computed autorepeat once the feedback class exists.
-	 *
-	 * DIX will apply the changed autorepeat, so there's no need to
-	 * do so here.   This function returns True if both RepeatKeys and
-	 * the core protocol autorepeat ctrls are set (i.e. should use 
-	 * software autorepeat), false otherwise.
-	 *
-	 * This function also computes the autorepeat accelerators for the
-	 * default indicator feedback.
-	 */
-int
-XkbFinishDeviceInit(DeviceIntPtr pXDev)
-{
-XkbSrvInfoPtr		xkbi;
-XkbDescPtr		xkb;
-int			softRepeat;
-XkbSrvLedInfoPtr	sli;
+    InitFocusClassDeviceStruct(dev);
 
-    xkbi = NULL;
-    if (pXDev && pXDev->key && pXDev->key->xkbInfo && pXDev->kbdfeed) {
-	xkbi= pXDev->key->xkbInfo;
-	xkb= xkbi->desc;
-        /* If we come from DeepCopyDeviceClasses, the CtrlProc was already set
-         * to XkbDDXKeybdCtrlProc, overwriting it leads to happy recursion.
-         */
-	if (pXDev->kbdfeed && pXDev->kbdfeed->CtrlProc != XkbDDXKeybdCtrlProc) {
-	    xkbi->kbdProc= pXDev->kbdfeed->CtrlProc;
-	    pXDev->kbdfeed->CtrlProc= XkbDDXKeybdCtrlProc;
-	}
-	if (pXDev->kbdfeed->ctrl.autoRepeat)
-	    xkb->ctrls->enabled_ctrls|= XkbRepeatKeysMask;
-	softRepeat= (xkb->ctrls->enabled_ctrls&XkbRepeatKeysMask)!=0;
-	if (pXDev->kbdfeed) {
-	    memcpy(pXDev->kbdfeed->ctrl.autoRepeats,
-		   xkb->ctrls->per_key_repeat,XkbPerKeyBitArraySize);
-	    softRepeat= softRepeat&&pXDev->kbdfeed->ctrl.autoRepeat;
-	}
-    }
-    else softRepeat= 0;
-    sli= XkbFindSrvLedInfo(pXDev,XkbDfltXIClass,XkbDfltXIId,0);
-    if (sli && xkbi)
-	XkbCheckIndicatorMaps(xkbi->device,sli,XkbAllIndicatorsMask);
-    else DebugF("[xkb] No indicator feedback in XkbFinishInit (shouldn't happen)!\n");
-    return softRepeat;
+    xkbi->kbdProc = ctrl_func;
+    dev->kbdfeed->BellProc = bell_func;
+    dev->kbdfeed->CtrlProc = XkbDDXKeybdCtrlProc;
+
+    dev->kbdfeed->ctrl = defaultKeyboardControl;
+    if (dev->kbdfeed->ctrl.autoRepeat)
+        xkb->ctrls->enabled_ctrls |= XkbRepeatKeysMask;
+
+    memcpy(dev->kbdfeed->ctrl.autoRepeats, xkb->ctrls->per_key_repeat,
+           XkbPerKeyBitArraySize);
+
+    sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
+    if (sli)
+	XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
+    else
+        DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
+
+    dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl);
+
+    XkbSetRulesDflts(rmlvo);
+    XkbSetRulesUsed(rmlvo);
+    XkbFreeRMLVOSet(&rmlvo_dflts, FALSE);
+
+    return TRUE;
+
+unwind_desc:
+    XkbFreeKeyboard(xkb, 0, TRUE);
+unwind_info:
+    xfree(xkbi);
+    dev->key->xkbInfo = NULL;
+unwind_kbdfeed:
+    xfree(dev->kbdfeed);
+    dev->kbdfeed = NULL;
+unwind_key:
+    xfree(dev->key);
+    dev->key = NULL;
+    return FALSE;
 }
 
+
+/***====================================================================***/
+
 	/*
 	 * Be very careful about what does and doesn't get freed by this 
 	 * function.  To reduce fragmentation, XkbInitDevice allocates a 
@@ -790,7 +645,7 @@ void
 XkbFreeInfo(XkbSrvInfoPtr xkbi)
 {
     if (xkbi->radioGroups) {
-	_XkbFree(xkbi->radioGroups);
+	xfree(xkbi->radioGroups);
 	xkbi->radioGroups= NULL;
     }
     if (xkbi->mouseKeyTimer) {
@@ -819,10 +674,10 @@ XkbFreeInfo(XkbSrvInfoPtr xkbi)
 	xkbi->beepTimer= NULL;
     }
     if (xkbi->desc) {
-	XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True);
+	XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,TRUE);
 	xkbi->desc= NULL;
     }
-    _XkbFree(xkbi);
+    xfree(xkbi);
     return;
 }
 
@@ -839,15 +694,7 @@ extern unsigned char	XkbDfltAccessXOptions;
 int
 XkbProcessArguments(int argc,char *argv[],int i)
 {
-    if (strcmp(argv[i],"-kb")==0) {
-	noXkbExtension= True;
-	return 1;
-    }
-    else if (strcmp(argv[i],"+kb")==0) {
-	noXkbExtension= False;
-	return 1;
-    }
-    else if (strncmp(argv[i], "-xkbdir", 7) == 0) {
+    if (strncmp(argv[i], "-xkbdir", 7) == 0) {
 	if(++i < argc) {
 #if !defined(WIN32) && !defined(__CYGWIN__)
 	    if (getuid() != geteuid()) {
@@ -925,8 +772,6 @@ XkbProcessArguments(int argc,char *argv[],int i)
 void
 XkbUseMsg(void)
 {
-    ErrorF("-kb                    disable the X Keyboard Extension\n");
-    ErrorF("+kb                    enable the X Keyboard Extension\n");
     ErrorF("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
     ErrorF("                       enable/disable accessx key sequences\n");
     ErrorF("-ardelay               set XKB autorepeat delay\n");