Input: Overhaul keyboard initialisation process

XkbInitKeyboardDeviceStruct is now the only valid keyboard
initialisation: all the details are hidden behind here.  This now makes
it impossible to supply a core keymap at startup.

If dev->key is valid, dev->key->xkbInfo->desc is also valid.

Signed-off-by: Daniel Stone <daniel@fooishbar.org>
Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

10 files changed, 220 insertions, 551 deletions

diff --git a/Xi/exevents.c b/Xi/exevents.c
index 1802b1859..323bc8d41 100644
--- a/Xi/exevents.c
+++ b/Xi/exevents.c
@@ -191,7 +191,6 @@ CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master)
 {
     static DeviceIntPtr lastMapNotifyDevice = NULL;
     KeyClassPtr mk, dk; /* master, device */
-    BOOL sendNotify = FALSE;
     int i;
 
     if (device == master)
@@ -240,14 +239,8 @@ CopyKeyClass(DeviceIntPtr device, DeviceIntPtr master)
     for (i = 0; i < 8; i++)
         mk->modifierKeyCount[i] = dk->modifierKeyCount[i];
 
-    if (dk->xkbInfo && dk->xkbInfo->desc) {
-        if (!mk->xkbInfo || !mk->xkbInfo->desc) {
-            XkbInitDevice(master);
-            XkbFinishDeviceInit(master);
-        }
-        if (!XkbCopyKeymap(dk->xkbInfo->desc, mk->xkbInfo->desc, True))
-            FatalError("Couldn't pivot keymap from device to core!\n");
-    }
+    if (!XkbCopyKeymap(dk->xkbInfo->desc, mk->xkbInfo->desc, True))
+        FatalError("Couldn't pivot keymap from device to core!\n");
 
     if (lastMapNotifyDevice != master) {
         SendMappingNotify(master, MappingKeyboard,
diff --git a/dix/devices.c b/dix/devices.c
index 9d6651d48..6748e487d 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -483,54 +483,24 @@ CoreKeyboardCtl(DeviceIntPtr pDev, KeybdCtrl *ctrl)
 static int
 CoreKeyboardProc(DeviceIntPtr pDev, int what)
 {
-    CARD8 *modMap;
-    KeySymsRec keySyms;
-    XkbComponentNamesRec names;
-    ClassesPtr classes;
+    XkbRMLVOSet rmlvo;
 
     switch (what) {
     case DEVICE_INIT:
-        if (!(classes = xcalloc(1, sizeof(ClassesRec))))
-        {
-            ErrorF("[dix] Could not allocate device classes.\n");
-            return BadAlloc;
-        }
-
-        keySyms.minKeyCode = 8;
-        keySyms.maxKeyCode = 255;
-        keySyms.mapWidth = 4;
-        keySyms.map = (KeySym *)xcalloc(sizeof(KeySym),
-                                        (keySyms.maxKeyCode -
-                                         keySyms.minKeyCode + 1) *
-                                        keySyms.mapWidth);
-        if (!keySyms.map) {
-            ErrorF("[dix] Couldn't allocate core keymap\n");
-            xfree(classes);
-            return BadAlloc;
-        }
-
-        modMap = xcalloc(1, MAP_LENGTH);
-        if (!modMap) {
-            ErrorF("[dix] Couldn't allocate core modifier map\n");
-            xfree(classes);
-            return BadAlloc;
-        }
-
-        bzero(&names, sizeof(names));
-        XkbInitKeyboardDeviceStruct(pDev, &names, &keySyms, modMap,
-                                    CoreKeyboardBell, CoreKeyboardCtl);
+        XkbGetRulesDflts(&rmlvo);
+        InitKeyboardDeviceStruct(pDev, &rmlvo, CoreKeyboardBell,
+                                 CoreKeyboardCtl);
+        return Success;
 
-        xfree(keySyms.map);
-        xfree(modMap);
-        break;
+    case DEVICE_ON:
+    case DEVICE_OFF:
+        return Success;
 
     case DEVICE_CLOSE:
-        break;
-
-    default:
-        break;
+        return Success;
     }
-    return Success;
+
+    return BadMatch;
 }
 
 /**
@@ -1102,73 +1072,7 @@ SetKeySymsMap(KeySymsPtr dst, KeySymsPtr src)
     return TRUE;
 }
 
-static Bool
-InitModMap(KeyClassPtr keyc)
-{
-    int i, j;
-    CARD8 keysPerModifier[8];
-    CARD8 mask;
-
-    keyc->maxKeysPerModifier = 0;
-    for (i = 0; i < 8; i++)
-	keysPerModifier[i] = 0;
-    for (i = 8; i < MAP_LENGTH; i++)
-    {
-	for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
-	{
-	    if (mask & keyc->modifierMap[i])
-	    {
-		if (++keysPerModifier[j] > keyc->maxKeysPerModifier)
-		    keyc->maxKeysPerModifier = keysPerModifier[j];
-	    }
-	}
-    }
-    keyc->modifierKeyMap = xcalloc(8, keyc->maxKeysPerModifier);
-    if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
-	return (FALSE);
-    for (i = 0; i < 8; i++)
-	keysPerModifier[i] = 0;
-    for (i = 8; i < MAP_LENGTH; i++)
-    {
-	for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
-	{
-	    if (mask & keyc->modifierMap[i])
-	    {
-		keyc->modifierKeyMap[(j*keyc->maxKeysPerModifier) +
-				     keysPerModifier[j]] = i;
-		keysPerModifier[j]++;
-	    }
-	}
-    }
-    return TRUE;
-}
-
-Bool
-InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers[])
-{
-    KeyClassPtr keyc;
-
-    keyc = xcalloc(1, sizeof(KeyClassRec));
-    if (!keyc)
-	return FALSE;
-    keyc->curKeySyms.minKeyCode = pKeySyms->minKeyCode;
-    keyc->curKeySyms.maxKeyCode = pKeySyms->maxKeyCode;
-    if (pModifiers)
-	memmove((char *)keyc->modifierMap, (char *)pModifiers, MAP_LENGTH);
-    if (!SetKeySymsMap(&keyc->curKeySyms, pKeySyms) || !InitModMap(keyc))
-    {
-	xfree(keyc->curKeySyms.map);
-	xfree(keyc->modifierKeyMap);
-	xfree(keyc);
-	return FALSE;
-    }
-    dev->key = keyc;
-    dev->key->xkbInfo= NULL;
-    XkbInitDevice(dev);
-    return TRUE;
-}
-
-Bool
+_X_EXPORT Bool
 InitButtonClassDeviceStruct(DeviceIntPtr dev, int numButtons,
                             CARD8 *map)
 {
@@ -1349,30 +1253,7 @@ InitFocusClassDeviceStruct(DeviceIntPtr dev)
     return TRUE;
 }
 
-Bool
-InitKbdFeedbackClassDeviceStruct(DeviceIntPtr dev, BellProcPtr bellProc,
-                                 KbdCtrlProcPtr controlProc)
-{
-    KbdFeedbackPtr feedc;
-
-    feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
-    if (!feedc)
-	return FALSE;
-    feedc->BellProc = bellProc;
-    feedc->CtrlProc = controlProc;
-    defaultKeyboardControl.autoRepeat = TRUE;
-    feedc->ctrl = defaultKeyboardControl;
-    feedc->ctrl.id = 0;
-    if ((feedc->next = dev->kbdfeed) != 0)
-	feedc->ctrl.id = dev->kbdfeed->ctrl.id + 1;
-    dev->kbdfeed = feedc;
-    feedc->xkb_sli= NULL;
-    XkbFinishDeviceInit(dev);
-    (*dev->kbdfeed->CtrlProc)(dev,&dev->kbdfeed->ctrl);
-    return TRUE;
-}
-
-Bool
+_X_EXPORT Bool
 InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
 {
     PtrFeedbackPtr feedc;
@@ -1517,19 +1398,7 @@ InitPointerDeviceStruct(DevicePtr device, CARD8 *map, int numButtons,
 	   InitPtrFeedbackClassDeviceStruct(dev, controlProc));
 }
 
-Bool
-InitKeyboardDeviceStruct(DevicePtr device, KeySymsPtr pKeySyms,
-                         CARD8 pModifiers[], BellProcPtr bellProc,
-                         KbdCtrlProcPtr controlProc)
-{
-    DeviceIntPtr dev = (DeviceIntPtr)device;
-
-    return(InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) &&
-	   InitFocusClassDeviceStruct(dev) &&
-	   InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc));
-}
-
-void
+_X_EXPORT void
 SendMappingNotify(DeviceIntPtr pDev, unsigned request, unsigned firstKeyCode,
         unsigned count, ClientPtr client)
 {
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index 670cc372f..92f5216e5 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -746,7 +746,7 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
     DevicePtr   pDev = (DevicePtr)pDevice;
     KdKeyboardInfo *ki;
     Atom xiclass;
-    XkbComponentNamesRec names;
+    XkbRMLVOSet rmlvo;
 
     if (!pDev)
 	return BadImplementation;
@@ -795,16 +795,13 @@ KdKeyboardProc(DeviceIntPtr pDevice, int onoff)
         KdInitModMap(ki);
         KdInitAutoRepeats(ki);
 
-        memset(&names, 0, sizeof(XkbComponentNamesRec));
-
-        XkbSetRulesDflts (ki->xkbRules, ki->xkbModel, ki->xkbLayout,
-                          ki->xkbVariant, ki->xkbOptions);
-
-        ret = XkbInitKeyboardDeviceStruct (pDevice,
-                                           &names,
-                                           &ki->keySyms,
-                                           ki->modmap,
-                                           KdBell, KdKbdCtrl);
+        memset(&rmlvo, 0, sizeof(rmlvo));
+        rmlvo.rules = ki->xkbRules;
+        rmlvo.model = ki->xkbModel;
+        rmlvo.layout = ki->xkbLayout;
+        rmlvo.variant = ki->xkbVariant;
+        rmlvo.options = ki->xkbOptions;
+        ret = InitKeyboardDeviceStruct (pDevice, &rmlvo, KdBell, KdKbdCtrl);
 	if (!ret) {
             ErrorF("Couldn't initialise keyboard %s\n", ki->name);
 	    return BadImplementation;
diff --git a/hw/vfb/InitInput.c b/hw/vfb/InitInput.c
index d2abfc242..e53ac4b29 100644
--- a/hw/vfb/InitInput.c
+++ b/hw/vfb/InitInput.c
@@ -259,21 +259,19 @@ GetLK201Mappings(KeySymsPtr pKeySyms, CARD8 *pModMap)
 static int
 vfbKeybdProc(DeviceIntPtr pDevice, int onoff)
 {
-    KeySymsRec		keySyms;
-    CARD8 		modMap[MAP_LENGTH];
     DevicePtr pDev = (DevicePtr)pDevice;
+    XkbRMLVOSet rmlvo;
 
     switch (onoff)
     {
-    case DEVICE_INIT: 
-	GetLK201Mappings(&keySyms, modMap);
-	InitKeyboardDeviceStruct(pDev, &keySyms, modMap,
-			(BellProcPtr)NoopDDA, (KbdCtrlProcPtr)NoopDDA);
-	    break;
-    case DEVICE_ON: 
+    case DEVICE_INIT:
+        XkbGetRulesDflts(&rmlvo);
+	InitKeyboardDeviceStruct(pDevice, &rmlvo, NULL, NULL);
+        break;
+    case DEVICE_ON:
 	pDev->on = TRUE;
 	break;
-    case DEVICE_OFF: 
+    case DEVICE_OFF:
 	pDev->on = FALSE;
 	break;
     case DEVICE_CLOSE:
diff --git a/hw/xfree86/common/xf86Module.h b/hw/xfree86/common/xf86Module.h
index e6960c84d..cbba3edde 100644
--- a/hw/xfree86/common/xf86Module.h
+++ b/hw/xfree86/common/xf86Module.h
@@ -83,7 +83,7 @@ typedef enum {
  */
 #define ABI_ANSIC_VERSION	SET_ABI_VERSION(0, 4)
 #define ABI_VIDEODRV_VERSION	SET_ABI_VERSION(5, 0)
-#define ABI_XINPUT_VERSION	SET_ABI_VERSION(4, 0)
+#define ABI_XINPUT_VERSION	SET_ABI_VERSION(5, 0)
 #define ABI_EXTENSION_VERSION	SET_ABI_VERSION(2, 0)
 #define ABI_FONT_VERSION	SET_ABI_VERSION(0, 6)
 
diff --git a/include/input.h b/include/input.h
index cf546e076..db75f6c78 100644
--- a/include/input.h
+++ b/include/input.h
@@ -53,6 +53,7 @@ SOFTWARE.
 #include <X11/Xmd.h>
 #include <X11/Xproto.h>
 #include "window.h"     /* for WindowPtr */
+#include "xkbrules.h"
 
 #define DEVICE_INIT	0
 #define DEVICE_ON	1
@@ -268,11 +269,6 @@ extern _X_EXPORT Bool SetKeySymsMap(
     KeySymsPtr /*dst*/,
     KeySymsPtr /*src*/);
 
-extern _X_EXPORT Bool InitKeyClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    KeySymsPtr /*pKeySyms*/,
-    CARD8 /*pModifiers*/[]);
-
 extern _X_EXPORT Bool InitButtonClassDeviceStruct(
     DeviceIntPtr /*device*/,
     int /*numButtons*/,
@@ -304,11 +300,6 @@ typedef void (*KbdCtrlProcPtr)(
     DeviceIntPtr /*device*/,
     KeybdCtrl * /*ctrl*/);
 
-extern _X_EXPORT Bool InitKbdFeedbackClassDeviceStruct(
-    DeviceIntPtr /*device*/,
-    BellProcPtr /*bellProc*/,
-    KbdCtrlProcPtr /*controlProc*/);
-
 typedef void (*PtrCtrlProcPtr)(
     DeviceIntPtr /*device*/,
     PtrCtrl * /*ctrl*/);
@@ -363,9 +354,8 @@ extern _X_EXPORT Bool InitPointerDeviceStruct(
     int /*numAxes*/);
 
 extern _X_EXPORT Bool InitKeyboardDeviceStruct(
-    DevicePtr /*device*/,
-    KeySymsPtr /*pKeySyms*/,
-    CARD8 /*pModifiers*/[],
+    DeviceIntPtr /*device*/,
+    XkbRMLVOSet * /*rmlvo*/,
     BellProcPtr /*bellProc*/,
     KbdCtrlProcPtr /*controlProc*/);
 
diff --git a/include/xkbsrv.h b/include/xkbsrv.h
index af87d8fa5..a28967c22 100644
--- a/include/xkbsrv.h
+++ b/include/xkbsrv.h
@@ -54,6 +54,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #include <X11/extensions/XKBproto.h>
 #include "xkbstr.h"
+#include "xkbrules.h"
 #include "inputstr.h"
 
 typedef struct _XkbInterest {
@@ -870,31 +871,18 @@ extern _X_EXPORT void XkbClearAllLatchesAndLocks(
 	XkbEventCausePtr	/* cause */
 );
 
+extern _X_EXPORT void	XkbGetRulesDflts(
+        XkbRMLVOSet *           /* rmlvo */
+);
+
 extern _X_EXPORT void	XkbSetRulesDflts(
-	char *			/* rulesFile */,
-	char *			/* model */,
-	char *			/* layout */,
-	char *			/* variant */,
-	char *			/* options */
+        XkbRMLVOSet *           /* rmlvo */
 );
 
 extern _X_EXPORT void	XkbDeleteRulesDflts(
 	void
 );
 
-extern _X_EXPORT void	XkbInitDevice(
-	DeviceIntPtr 	/* pXDev */
-);
-
-extern _X_EXPORT Bool	XkbInitKeyboardDeviceStruct(
-	DeviceIntPtr 		/* pXDev */,
-	XkbComponentNamesPtr	/* pNames */,
-	KeySymsPtr		/* pSyms */,
-	CARD8 			/* pMods */[],
-	BellProcPtr		/* bellProc */,
-	KbdCtrlProcPtr		/* ctrlProc */
-);
-
 extern _X_EXPORT int SProcXkbDispatch(
 	ClientPtr		/* client */
 );
@@ -922,10 +910,6 @@ extern _X_EXPORT Status	 XkbChangeKeycodeRange(
 	XkbChangesPtr		/* changes */
 );
 
-extern _X_EXPORT int XkbFinishDeviceInit(
-	DeviceIntPtr		/* pXDev */
-);
-
 extern _X_EXPORT void XkbFreeSrvLedInfo(
 	XkbSrvLedInfoPtr	/* sli */
 );
@@ -1021,6 +1005,11 @@ extern _X_EXPORT Bool XkbDDXNamesFromRules(
 	XkbComponentNamesPtr	/* names */
 );
 
+extern _X_EXPORT XkbDescPtr XkbCompileKeymap(
+        DeviceIntPtr    /* dev */,
+        XkbRMLVOSet *   /* rmlvo */
+);
+
 _XFUNCPROTOEND
 
 #define	XkbAtomGetString(s)	NameForAtom(s)
diff --git a/xkb/ddxLoad.c b/xkb/ddxLoad.c
index b4ac53593..c24b2cc2f 100644
--- a/xkb/ddxLoad.c
+++ b/xkb/ddxLoad.c
@@ -428,3 +428,36 @@ XkbRF_RulesPtr	rules;
 
     return complete;
 }
+
+XkbDescPtr
+XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo)
+{
+    XkbComponentNamesRec kccgst;
+    XkbRF_VarDefsRec mlvo;
+    XkbDescPtr xkb;
+    char name[PATH_MAX];
+
+    if (!dev || !rmlvo) {
+        LogMessage(X_ERROR, "XKB: No device or RMLVO specified\n");
+        return NULL;
+    }
+
+    mlvo.model = rmlvo->model;
+    mlvo.layout = rmlvo->layout;
+    mlvo.variant = rmlvo->variant;
+    mlvo.options = rmlvo->options;
+
+    /* XDNFR already logs for us. */
+    if (!XkbDDXNamesFromRules(dev, rmlvo->rules, &mlvo, &kccgst))
+        return NULL;
+
+    /* XDLKBN too, but it might return 0 as well as allocating. */
+    if (!XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, 0, &xkb, name,
+                                 PATH_MAX)) {
+        if (xkb)
+            XkbFreeKeyboard(xkb, 0, TRUE);
+        return NULL;
+    }
+
+    return xkb;
+}
diff --git a/xkb/xkbInit.c b/xkb/xkbInit.c
index e800482ac..d85fbd4e4 100644
--- a/xkb/xkbInit.c
+++ b/xkb/xkbInit.c
@@ -93,36 +93,35 @@ 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 Bool		XkbWantRulesProp=	XKB_DFLT_RULES_PROP;
 
 /***====================================================================***/
 
-static char *
-XkbGetRulesDflts(XkbRF_VarDefsPtr defs)
+void
+XkbGetRulesDflts(XkbRMLVOSet *rmlvo)
 {
-    if (XkbModelDflt)	defs->model= XkbModelDflt;
-    else		defs->model= XKB_DFLT_MODEL;
-    if (XkbLayoutDflt)	defs->layout= XkbLayoutDflt;
-    else		defs->layout= XKB_DFLT_LAYOUT;
-    if (XkbVariantDflt)	defs->variant= XkbVariantDflt;
-    else		defs->variant= XKB_DFLT_VARIANT;
-    if (XkbOptionsDflt)	defs->options= XkbOptionsDflt;
-    else		defs->options= XKB_DFLT_OPTIONS;
-    return (rulesDefined?XkbRulesFile:XKB_DFLT_RULES);
+    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;
 }
 
 static Bool
@@ -132,9 +131,7 @@ int 			len,out;
 Atom			name;
 char *			pval;
 
-    if (rulesDefined && (!XkbRulesFile))
-	return False;
-    len= (XkbRulesFile?strlen(XkbRulesFile):strlen(XKB_DFLT_RULES));
+    len= (XkbRulesUsed?strlen(XkbRulesUsed):0);
     len+= (XkbModelUsed?strlen(XkbModelUsed):0);
     len+= (XkbLayoutUsed?strlen(XkbLayoutUsed):0);
     len+= (XkbVariantUsed?strlen(XkbVariantUsed):0);
@@ -156,12 +153,9 @@ char *			pval;
 	return True;
     }
     out= 0;
-    if (XkbRulesFile) {
-	strcpy(&pval[out],XkbRulesFile);
-	out+= strlen(XkbRulesFile);
-    } else {
-	strcpy(&pval[out],XKB_DFLT_RULES);
-	out+= strlen(XKB_DFLT_RULES);
+    if (XkbRulesUsed) {
+	strcpy(&pval[out],XkbRulesUsed);
+	out+= strlen(XkbRulesUsed);
     }
     pval[out++]= '\0';
     if (XkbModelUsed) {
@@ -195,71 +189,55 @@ char *			pval;
 }
 
 static void
-XkbSetRulesUsed(XkbRF_VarDefsPtr defs)
+XkbSetRulesUsed(XkbRMLVOSet *rmlvo)
 {
+    if (XkbRulesUsed)
+        _XkbFree(XkbRulesUsed);
+    XkbRulesUsed= (rmlvo->rules?_XkbDupString(rmlvo->rules):NULL);
     if (XkbModelUsed)
 	_XkbFree(XkbModelUsed);
-    XkbModelUsed= (defs->model?_XkbDupString(defs->model):NULL);
+    XkbModelUsed= (rmlvo->model?_XkbDupString(rmlvo->model):NULL);
     if (XkbLayoutUsed)
 	_XkbFree(XkbLayoutUsed);
-    XkbLayoutUsed= (defs->layout?_XkbDupString(defs->layout):NULL);
+    XkbLayoutUsed= (rmlvo->layout?_XkbDupString(rmlvo->layout):NULL);
     if (XkbVariantUsed)
 	_XkbFree(XkbVariantUsed);
-    XkbVariantUsed= (defs->variant?_XkbDupString(defs->variant):NULL);
+    XkbVariantUsed= (rmlvo->variant?_XkbDupString(rmlvo->variant):NULL);
     if (XkbOptionsUsed)
 	_XkbFree(XkbOptionsUsed);
-    XkbOptionsUsed= (defs->options?_XkbDupString(defs->options):NULL);
+    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.
- */
 void
-XkbSetRulesDflts(char *rulesFile,char *model,char *layout,
-					char *variant,char *options)
+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);
-	rulesFile = XKB_DFLT_RULES;
+    if (rmlvo->rules) {
+        if (XkbRulesDflt)
+	    _XkbFree(XkbRulesDflt);
+        XkbRulesDflt= _XkbDupString(rmlvo->rules);
     }
-
-    if (rulesFile) {
-	if (XkbRulesFile)
-	    _XkbFree(XkbRulesFile);
-	XkbRulesFile= _XkbDupString(rulesFile);
-	rulesDefined= True;
-    }
-
-    if (model) {
+    if (rmlvo->model) {
 	if (XkbModelDflt)
 	    _XkbFree(XkbModelDflt);
-	XkbModelDflt= _XkbDupString(model);
+	XkbModelDflt= _XkbDupString(rmlvo->model);
     }
-    if (layout) {
+    if (rmlvo->layout) {
 	if (XkbLayoutDflt)
 	    _XkbFree(XkbLayoutDflt);
-	XkbLayoutDflt= _XkbDupString(layout);
+	XkbLayoutDflt= _XkbDupString(rmlvo->layout);
     }
-    if (variant) {
+    if (rmlvo->variant) {
 	if (XkbVariantDflt)
 	    _XkbFree(XkbVariantDflt);
-	XkbVariantDflt= _XkbDupString(variant);
+	XkbVariantDflt= _XkbDupString(rmlvo->variant);
     }
-    if (options) {
+    if (rmlvo->options) {
 	if (XkbOptionsDflt)
 	    _XkbFree(XkbOptionsDflt);
-	XkbOptionsDflt= _XkbDupString(options);
+	XkbOptionsDflt= _XkbDupString(rmlvo->options);
     }
     return;
 }
@@ -267,8 +245,8 @@ XkbSetRulesDflts(char *rulesFile,char *model,char *layout,
 void
 XkbDeleteRulesDflts(void)
 {
-    _XkbFree(XkbRulesFile);
-    XkbRulesFile = NULL;
+    _XkbFree(XkbRulesDflt);
+    XkbRulesDflt = NULL;
     _XkbFree(XkbModelDflt);
     XkbModelDflt = NULL;
     _XkbFree(XkbLayoutDflt);
@@ -277,9 +255,6 @@ XkbDeleteRulesDflts(void)
     XkbVariantDflt = NULL;
     _XkbFree(XkbOptionsDflt);
     XkbOptionsDflt = NULL;
-
-    XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, True);
-    xkb_cached_map = NULL;
 }
 
 /***====================================================================***/
@@ -467,292 +442,123 @@ 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;
+
+    if (dev->key || dev->kbdfeed || !rmlvo)
+	return False;
 
-        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;
-        }
-	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;
+    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;
     }
-    return;
-}
 
-#if MAP_LENGTH > XkbMaxKeyCount
-#undef  XkbMaxKeyCount
-#define XkbMaxKeyCount MAP_LENGTH
-#endif
+    dev->kbdfeed = xcalloc(1, sizeof(*dev->kbdfeed));
+    if (!dev->kbdfeed) {
+        ErrorF("XKB: Failed to allocate key feedback class\n");
+        goto unwind_key;
+    }
 
-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);
-	}
+    xkbi = xcalloc(1, sizeof(*xkbi));
+    if (!xkbi) {
+        ErrorF("XKB: Failed to allocate XKB info\n");
+        goto unwind_kbdfeed;
+    }
+    dev->key->xkbInfo = xkbi;
+
+    xkb = XkbCompileKeymap(dev, rmlvo);
+    if (!xkb) {
+        ErrorF("XKB: Failed to compile keymap\n");
+        goto unwind_info;
     }
+    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;
-}
+    /* XXX: Doesn't XUCD make this redundant? */
+    memcpy(dev->key->modifierMap, xkb->map->modmap, xkb->max_key_code + 1);
 
-/***====================================================================***/
+    XkbInitIndicatorMap(xkbi);
 
-	/*
-	 * 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;
+    XkbDDXInitDevice(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;
+    XkbUpdateCoreDescription(dev, True);
+
+    XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &changes,
+                     &check, &cause);
+    dev->key->curKeySyms.minKeyCode = xkb->min_key_code;
+    dev->key->curKeySyms.maxKeyCode = xkb->max_key_code;
+
+    InitFocusClassDeviceStruct(dev);
+
+    xkbi->kbdProc = ctrl_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);
+
+    return TRUE;
+
+unwind_desc:
+    XkbFreeKeyboard(xkb, 0, TRUE);
+unwind_info:
+    xfree(xkbi);
+unwind_kbdfeed:
+    xfree(dev->kbdfeed);
+unwind_key:
+    xfree(dev->key);
+    return FALSE;
 }
 
+
+/***====================================================================***/
+
 	/*
 	 * Be very careful about what does and doesn't get freed by this 
 	 * function.  To reduce fragmentation, XkbInitDevice allocates a 
diff --git a/xkb/xkbUtils.c b/xkb/xkbUtils.c
index abfd6fb97..c7a6d99d0 100644
--- a/xkb/xkbUtils.c
+++ b/xkb/xkbUtils.c
@@ -382,10 +382,6 @@ int			maxNumberOfGroups;
     else if (resize) {
 	keyc->curKeySyms.minKeyCode= xkb->min_key_code;
 	keyc->curKeySyms.maxKeyCode= xkb->max_key_code;
-	tmp= keyc->curKeySyms.mapWidth*_XkbCoreNumKeys(keyc);
-	keyc->curKeySyms.map= _XkbTypedRealloc(keyc->curKeySyms.map,tmp,KeySym);
-	if (!keyc->curKeySyms.map)
-	   FatalError("Couldn't allocate keysyms\n");
 	first= firstCommon= xkb->min_key_code;
 	last= lastCommon= xkb->max_key_code;
     }
@@ -622,8 +618,6 @@ XkbEventCauseRec	cause;
 XkbChangesRec	 	changes;
 unsigned	 	check;
 
-    if (kbd->key->xkbInfo==NULL)
-	XkbInitDevice(kbd);
     bzero(&changes,sizeof(XkbChangesRec));
     check= 0;
     if (request==MappingKeyboard) {