R6.6 is the Xorg base-lineXORG-MAIN

32 files changed, 20167 insertions, 0 deletions

diff --git a/action.c b/action.c
new file mode 100644
index 0000000..bc2b281
--- /dev/null
+++ b/action.c
@@ -0,0 +1,1467 @@
+/* $Xorg: action.c,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+
+#include "keycodes.h"
+#include "vmod.h"
+#include "action.h"
+#include "misc.h"
+
+static Bool	actionsInitialized;
+static ExprDef	constTrue;
+static ExprDef	constFalse;
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+stringToAction(char *str,unsigned *type_rtrn)
+#else
+stringToAction(str,type_rtrn)
+    char *	str;
+    unsigned *	type_rtrn;
+#endif
+{
+    if (str==NULL)
+	return False;
+
+    if (uStrCaseCmp(str,"noaction")==0)	 	*type_rtrn= XkbSA_NoAction;
+    else if (uStrCaseCmp(str,"setmods")==0)	*type_rtrn= XkbSA_SetMods;
+    else if (uStrCaseCmp(str,"latchmods")==0)	*type_rtrn= XkbSA_LatchMods;
+    else if (uStrCaseCmp(str,"lockmods")==0)	*type_rtrn= XkbSA_LockMods;
+    else if (uStrCaseCmp(str,"setgroup")==0)	*type_rtrn= XkbSA_SetGroup;
+    else if (uStrCaseCmp(str,"latchgroup")==0)	*type_rtrn= XkbSA_LatchGroup;
+    else if (uStrCaseCmp(str,"lockgroup")==0)	*type_rtrn= XkbSA_LockGroup;
+    else if (uStrCaseCmp(str,"moveptr")==0)	*type_rtrn= XkbSA_MovePtr;
+    else if (uStrCaseCmp(str,"movepointer")==0)	*type_rtrn= XkbSA_MovePtr;
+    else if (uStrCaseCmp(str,"ptrbtn")==0)	*type_rtrn= XkbSA_PtrBtn;
+    else if (uStrCaseCmp(str,"pointerbutton")==0)
+						*type_rtrn= XkbSA_PtrBtn;
+    else if (uStrCaseCmp(str,"lockptrbtn")==0)	*type_rtrn= XkbSA_LockPtrBtn;
+    else if (uStrCaseCmp(str,"lockpointerbutton")==0)	
+						*type_rtrn= XkbSA_LockPtrBtn;
+    else if (uStrCaseCmp(str,"lockptrbutton")==0)	
+						*type_rtrn= XkbSA_LockPtrBtn;
+    else if (uStrCaseCmp(str,"lockpointerbtn")==0)	
+						*type_rtrn= XkbSA_LockPtrBtn;
+    else if (uStrCaseCmp(str,"setptrdflt")==0)	*type_rtrn= XkbSA_SetPtrDflt;
+    else if (uStrCaseCmp(str,"setpointerdefault")==0)	
+						*type_rtrn= XkbSA_SetPtrDflt;
+    else if (uStrCaseCmp(str,"isolock")==0)	*type_rtrn= XkbSA_ISOLock;
+    else if (uStrCaseCmp(str,"terminate")==0)	*type_rtrn= XkbSA_Terminate;
+    else if (uStrCaseCmp(str,"terminateserver")==0)
+						*type_rtrn= XkbSA_Terminate;
+    else if (uStrCaseCmp(str,"switchscreen")==0)*type_rtrn= XkbSA_SwitchScreen;
+    else if (uStrCaseCmp(str,"setcontrols")==0)	*type_rtrn= XkbSA_SetControls;
+    else if (uStrCaseCmp(str,"lockcontrols")==0)*type_rtrn= XkbSA_LockControls;
+    else if (uStrCaseCmp(str,"actionmessage")==0)*type_rtrn= XkbSA_ActionMessage;
+    else if (uStrCaseCmp(str,"messageaction")==0)*type_rtrn= XkbSA_ActionMessage;
+    else if (uStrCaseCmp(str,"message")==0)	*type_rtrn= XkbSA_ActionMessage;
+    else if (uStrCaseCmp(str,"redirect")==0)	*type_rtrn= XkbSA_RedirectKey;
+    else if (uStrCaseCmp(str,"redirectkey")==0)	*type_rtrn= XkbSA_RedirectKey;
+    else if (uStrCaseCmp(str,"devbtn")==0)	*type_rtrn= XkbSA_DeviceBtn;
+    else if (uStrCaseCmp(str,"devicebtn")==0)	*type_rtrn= XkbSA_DeviceBtn;
+    else if (uStrCaseCmp(str,"devbutton")==0)	*type_rtrn= XkbSA_DeviceBtn;
+    else if (uStrCaseCmp(str,"devicebutton")==0)*type_rtrn= XkbSA_DeviceBtn;
+    else if (uStrCaseCmp(str,"lockdevbtn")==0)	*type_rtrn= XkbSA_DeviceBtn;
+    else if (uStrCaseCmp(str,"lockdevicebtn")==0)	
+						*type_rtrn= XkbSA_LockDeviceBtn;
+    else if (uStrCaseCmp(str,"lockdevbutton")==0)	
+						*type_rtrn= XkbSA_LockDeviceBtn;
+    else if (uStrCaseCmp(str,"lockdevicebutton")==0)
+						*type_rtrn= XkbSA_LockDeviceBtn;
+    else if (uStrCaseCmp(str,"devval")==0)	*type_rtrn=XkbSA_DeviceValuator;
+    else if (uStrCaseCmp(str,"deviceval")==0)	*type_rtrn=XkbSA_DeviceValuator;
+    else if (uStrCaseCmp(str,"devvaluator")==0)	*type_rtrn=XkbSA_DeviceValuator;
+    else if (uStrCaseCmp(str,"devicevaluator")==0)
+						*type_rtrn=XkbSA_DeviceValuator;
+    else if (uStrCaseCmp(str,"private")==0)	*type_rtrn= PrivateAction;
+    else return False;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+stringToField(char *str,unsigned *field_rtrn)
+#else
+stringToField(str,field_rtrn)
+   char *	str;
+   unsigned *	field_rtrn;
+#endif
+{
+
+    if (str==NULL)
+	return False;
+
+    if (uStrCaseCmp(str,"clearlocks")==0)	*field_rtrn= F_ClearLocks;
+    else if (uStrCaseCmp(str,"latchtolock")==0)	*field_rtrn= F_LatchToLock;
+    else if (uStrCaseCmp(str,"genkeyevent")==0)	*field_rtrn= F_GenKeyEvent;
+    else if (uStrCaseCmp(str,"generatekeyevent")==0)	
+						*field_rtrn= F_GenKeyEvent;
+    else if (uStrCaseCmp(str,"report")==0)	*field_rtrn= F_Report;
+    else if (uStrCaseCmp(str,"default")==0)	*field_rtrn= F_Default;
+    else if (uStrCaseCmp(str,"affect")==0)	*field_rtrn= F_Affect;
+    else if (uStrCaseCmp(str,"increment")==0)	*field_rtrn= F_Increment;
+    else if (uStrCaseCmp(str,"mods")==0)	*field_rtrn= F_Modifiers;
+    else if (uStrCaseCmp(str,"modifiers")==0)	*field_rtrn= F_Modifiers;
+    else if (uStrCaseCmp(str,"group")==0)	*field_rtrn= F_Group;
+    else if (uStrCaseCmp(str,"x")==0)		*field_rtrn= F_X;
+    else if (uStrCaseCmp(str,"y")==0)		*field_rtrn= F_Y;
+    else if (uStrCaseCmp(str,"accel")==0)	*field_rtrn= F_Accel;
+    else if (uStrCaseCmp(str,"accelerate")==0)	*field_rtrn= F_Accel;
+    else if (uStrCaseCmp(str,"repeat")==0)	*field_rtrn= F_Accel;
+    else if (uStrCaseCmp(str,"button")==0)	*field_rtrn= F_Button;
+    else if (uStrCaseCmp(str,"value")==0)	*field_rtrn= F_Value;
+    else if (uStrCaseCmp(str,"controls")==0)	*field_rtrn= F_Controls;
+    else if (uStrCaseCmp(str,"ctrls")==0)	*field_rtrn= F_Controls;
+    else if (uStrCaseCmp(str,"type")==0)	*field_rtrn= F_Type;
+    else if (uStrCaseCmp(str,"count")==0)	*field_rtrn= F_Count;
+    else if (uStrCaseCmp(str,"screen")==0)	*field_rtrn= F_Screen;
+    else if (uStrCaseCmp(str,"same")==0)	*field_rtrn= F_Same;
+    else if (uStrCaseCmp(str,"sameserver")==0)	*field_rtrn= F_Same;
+    else if (uStrCaseCmp(str,"data")==0)	*field_rtrn= F_Data;
+    else if (uStrCaseCmp(str,"device")==0)	*field_rtrn= F_Device;
+    else if (uStrCaseCmp(str,"dev")==0)		*field_rtrn= F_Device;
+    else if (uStrCaseCmp(str,"key")==0)		*field_rtrn= F_Keycode;
+    else if (uStrCaseCmp(str,"keycode")==0)	*field_rtrn= F_Keycode;
+    else if (uStrCaseCmp(str,"kc")==0)		*field_rtrn= F_Keycode;
+    else if (uStrCaseCmp(str,"clearmods")==0)	*field_rtrn= F_ModsToClear;
+    else if (uStrCaseCmp(str,"clearmodifiers")==0) *field_rtrn= F_ModsToClear;
+    else return False;
+    return True;
+}
+
+static char *
+#if NeedFunctionPrototypes
+fieldText(unsigned field)
+#else
+fieldText(field)
+   unsigned field;
+#endif
+{
+static char buf[32];
+
+    switch (field) {
+	case F_ClearLocks:	strcpy(buf,"clearLocks"); break;
+	case F_LatchToLock:	strcpy(buf,"latchToLock"); break;
+	case F_GenKeyEvent:	strcpy(buf,"genKeyEvent"); break;
+	case F_Report:		strcpy(buf,"report"); break;
+	case F_Default:		strcpy(buf,"default"); break;
+	case F_Affect:		strcpy(buf,"affect"); break;
+	case F_Increment:	strcpy(buf,"increment"); break;
+	case F_Modifiers:	strcpy(buf,"modifiers"); break;
+	case F_Group:		strcpy(buf,"group"); break;
+	case F_X:		strcpy(buf,"x"); break;
+	case F_Y:		strcpy(buf,"y"); break;
+	case F_Accel:		strcpy(buf,"accel"); break;
+	case F_Button:		strcpy(buf,"button"); break;
+	case F_Value:		strcpy(buf,"value"); break;
+	case F_Controls:	strcpy(buf,"controls"); break;
+	case F_Type:		strcpy(buf,"type"); break;
+	case F_Count:		strcpy(buf,"count"); break;
+	case F_Screen:		strcpy(buf,"screen"); break;
+	case F_Same:		strcpy(buf,"sameServer"); break;
+	case F_Data:		strcpy(buf,"data"); break;
+	case F_Device:		strcpy(buf,"device"); break;
+	case F_Keycode:		strcpy(buf,"keycode"); break;
+	case F_ModsToClear:	strcpy(buf,"clearmods"); break;
+	default:		strcpy(buf,"unknown"); break;
+    }
+    return buf;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+ReportMismatch(unsigned action,unsigned field,char *type)
+#else
+ReportMismatch(action,field,type)
+    unsigned		action;
+    unsigned		field;
+    char *		type;
+#endif
+{
+    ERROR2("Value of %s field must be of type %s\n",fieldText(field),type);
+    ACTION1("Action %s definition ignored\n",
+    					XkbActionTypeText(action,XkbMessage));
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+ReportIllegal(unsigned action,unsigned field)
+#else
+ReportIllegal(action,field)
+    unsigned		action;
+    unsigned		field;
+#endif
+{
+    ERROR2("Field %s is not defined for an action of type %s\n",
+				fieldText(field),
+				XkbActionTypeText(action,XkbMessage));
+    ACTION("Action definition ignored\n");
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+ReportActionNotArray(unsigned action,unsigned field)
+#else
+ReportActionNotArray(action,field)
+    unsigned		action;
+    unsigned		field;
+#endif
+{
+    ERROR2("The %s field in the %s action is not an array\n",
+				fieldText(field),
+				XkbActionTypeText(action,XkbMessage));
+    ACTION("Action definition ignored\n");
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+ReportNotFound(unsigned action,unsigned field,char *what,char *bad)
+#else
+ReportNotFound(action,field,what,bad)
+    unsigned	action;
+    unsigned	field;
+    char *	what;
+    char *	bad;
+#endif
+{
+    ERROR2("%s named %s not found\n",what,bad);
+    ACTION2("Ignoring the %s field of an %s action\n",fieldText(field),
+				XkbActionTypeText(action,XkbMessage));
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleNoAction(	XkbDescPtr	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandleNoAction(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CheckLatchLockFlags(	unsigned	action,
+			unsigned	field,
+			ExprDef *	value,
+			unsigned *	flags_inout)
+#else
+CheckLatchLockFlags(action,field,value,flags_inout)
+    unsigned	action;
+    unsigned	field;
+    ExprDef *	value;
+    unsigned *	flags_inout;
+#endif
+{
+unsigned	tmp;
+ExprResult	result;
+
+    if (field==F_ClearLocks)		tmp= XkbSA_ClearLocks;
+    else if (field==F_LatchToLock)	tmp= XkbSA_LatchToLock;
+    else 				return False; /* WSGO! */
+    if (!ExprResolveBoolean(value,&result,NULL,NULL))
+	return ReportMismatch(action,field,"boolean");
+    if (result.uval)	*flags_inout|= tmp;
+    else		*flags_inout&= ~tmp;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CheckModifierField(	XkbDescPtr	xkb,
+			unsigned	action,
+			ExprDef *	value,
+			unsigned *	flags_inout,
+			unsigned *	mods_rtrn)
+#else
+CheckModifierField(xkb,action,value,flags_inout,mods_rtrn)
+    XkbDescPtr		xkb;
+    unsigned		action;
+    ExprDef *		value;
+    unsigned *		flags_inout;
+    unsigned *		mods_rtrn;
+#endif
+{
+ExprResult	rtrn;
+
+    if (value->op==ExprIdent) {
+	register char *valStr;
+	valStr= XkbAtomGetString(NULL,value->value.str);
+	if (valStr&&((uStrCaseCmp(valStr,"usemodmapmods")==0)||
+		     (uStrCaseCmp(valStr,"modmapmods")==0))) {
+	
+	    *mods_rtrn= 0;
+	    *flags_inout|= XkbSA_UseModMapMods;
+	    return True;
+	}
+    }
+    if (!ExprResolveModMask(value,&rtrn,LookupVModMask,(XPointer)xkb))
+	return ReportMismatch(action,F_Modifiers,"modifier mask");
+    *mods_rtrn= rtrn.uval;
+    *flags_inout&= ~XkbSA_UseModMapMods;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSetLatchMods(	XkbDescPtr	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleSetLatchMods(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+XkbModAction *	act;
+unsigned	rtrn;
+unsigned	t1,t2;
+
+    act= (XkbModAction *)action;
+    if (array_ndx!=NULL) {
+	switch (field) {
+	    case F_ClearLocks: case F_LatchToLock:
+	    case F_Modifiers:
+		return ReportActionNotArray(action->type,field);
+	}
+    }
+    switch (field) {
+	case F_ClearLocks:
+	case F_LatchToLock:
+	    rtrn= act->flags;
+	    if (CheckLatchLockFlags(action->type,field,value,&rtrn)) {
+		act->flags= rtrn;
+		return True;
+	    }
+	    return False;
+	case F_Modifiers:
+	    t1= act->flags;
+	    if (CheckModifierField(xkb,action->type,value,&t1,&t2)) {
+		act->flags= t1;
+		act->real_mods= act->mask= (t2&0xff);
+		t2= (t2>>8)&0xffff;
+		XkbSetModActionVMods(act,t2);
+		return True;
+	    }
+	    return False;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleLockMods(	XkbDescPtr	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandleLockMods(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+XkbModAction *	act;
+unsigned	t1,t2;
+
+    act= (XkbModAction *)action;
+    if ((array_ndx!=NULL)&&(field==F_Modifiers))
+	return ReportActionNotArray(action->type,field);
+    switch (field) {
+	case F_Modifiers:
+	    t1= act->flags;
+	    if (CheckModifierField(xkb,action->type,value,&t1,&t2)) {
+		act->flags= t1;
+		act->real_mods= act->mask= (t2&0xff);
+		t2= (t2>>8)&0xffff;
+		XkbSetModActionVMods(act,t2);
+		return True;
+	    }
+	    return False;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static LookupEntry groupNames[] = {
+	{	"group1",	1	},
+	{	"group2",	2	},
+	{	"group3",	3	},
+	{	"group4",	4	},
+	{	"group5",	5	},
+	{	"group6",	6	},
+	{	"group7",	7	},
+	{	"group8",	8	},
+	{	NULL,		0	},
+};
+
+static Bool
+#if NeedFunctionPrototypes
+CheckGroupField(	unsigned	action,
+			ExprDef *	value,
+			unsigned *	flags_inout,
+			int *		grp_rtrn)
+#else
+CheckGroupField(action,value,flags_inout,grp_rtrn)
+    unsigned		action;
+    ExprDef *		value;
+    unsigned *		flags_inout;
+    int *		grp_rtrn;
+#endif
+{
+ExprDef *	spec;
+ExprResult 	rtrn;
+
+    if ((value->op==OpNegate)||(value->op==OpUnaryPlus)) {
+	*flags_inout&= ~XkbSA_GroupAbsolute;
+	spec= value->value.child;
+    }
+    else {
+	*flags_inout|= XkbSA_GroupAbsolute;
+	spec= value;
+    }
+
+    if (!ExprResolveInteger(spec,&rtrn,SimpleLookup,(XPointer)groupNames))
+	return ReportMismatch(action,F_Group,"integer (range 1..8)");
+    if ((rtrn.ival<1)||(rtrn.ival>XkbNumKbdGroups)) {
+	ERROR2("Illegal group %d (must be in the range 1..%d)\n",rtrn.ival,
+							XkbNumKbdGroups);
+	ACTION1("Action %s definition ignored\n",
+					XkbActionTypeText(action,XkbMessage));
+	return False;
+    }
+    if (value->op==OpNegate)		*grp_rtrn= -rtrn.ival;
+    else if (value->op==OpUnaryPlus)	*grp_rtrn= rtrn.ival;
+    else				*grp_rtrn= rtrn.ival-1;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSetLatchGroup(	XkbDescPtr	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleSetLatchGroup(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+XkbGroupAction *	act;
+unsigned		rtrn;
+unsigned		t1;
+int			t2;
+
+    act= (XkbGroupAction *)action;
+    if (array_ndx!=NULL) {
+	switch (field) {
+	    case F_ClearLocks: case F_LatchToLock:
+	    case F_Group:
+		return ReportActionNotArray(action->type,field);
+	}
+    }
+    switch (field) {
+	case F_ClearLocks:
+	case F_LatchToLock:
+	    rtrn= act->flags;
+	    if (CheckLatchLockFlags(action->type,field,value,&rtrn)) {
+		act->flags= rtrn;
+		return True;
+	    }
+	    return False;
+	case F_Group:
+	    t1= act->flags;
+	    if (CheckGroupField(action->type,value,&t1,&t2)) {
+		act->flags= t1;
+		XkbSASetGroup(act,t2);
+		return True;
+	    }
+	    return False;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleLockGroup(	XkbDescPtr	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleLockGroup(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+XkbGroupAction *	act;
+unsigned		t1;
+int			t2;
+
+    act= (XkbGroupAction *)action;
+    if ((array_ndx!=NULL) && (field==F_Group))
+	return ReportActionNotArray(action->type,field);
+    if (field==F_Group) {
+	t1= act->flags;
+	if (CheckGroupField(action->type,value,&t1,&t2)) {
+	    act->flags= t1;
+	    XkbSASetGroup(act,t2);
+	    return True;
+	}
+	return False;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleMovePtr(	XkbDescPtr 	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandleMovePtr(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	rtrn;
+XkbPtrAction *	act;
+Bool		absolute;
+
+    act= (XkbPtrAction *)action;
+    if ((array_ndx!=NULL)&&((field==F_X)||(field==F_Y)))
+	return ReportActionNotArray(action->type,field);
+  
+    if ((field==F_X)||(field==F_Y)) {
+	if ((value->op==OpNegate)||(value->op==OpUnaryPlus)) 
+	     absolute= False;
+	else absolute= True;
+	if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"integer");
+	if (field==F_X) {
+	    if (absolute)
+		act->flags|= XkbSA_MoveAbsoluteX;
+	    XkbSetPtrActionX(act,rtrn.ival);
+	}
+	else {
+	    if (absolute)
+		act->flags|= XkbSA_MoveAbsoluteY;
+	    XkbSetPtrActionY(act,rtrn.ival);
+	}
+	return True;
+    }
+    else if (field==F_Accel) {
+	if (!ExprResolveBoolean(value,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"boolean");
+	if (rtrn.uval)	act->flags&= ~XkbSA_NoAcceleration;
+	else 			act->flags|= XkbSA_NoAcceleration;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static LookupEntry btnNames[] = {
+	{	"button1",	1	},
+	{	"button2",	2	},
+	{	"button3",	3	},
+	{	"button4",	4	},
+	{	"button5",	5	},
+	{	"default",	0	},
+	{	NULL,		0	}
+};
+
+static LookupEntry lockWhich[] = {
+	{	"both",		0					},
+	{	"lock",		XkbSA_LockNoUnlock			},
+	{	"neither",	(XkbSA_LockNoLock|XkbSA_LockNoUnlock)	},
+	{	"unlock",	XkbSA_LockNoLock			},
+	{	NULL,		0	}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+HandlePtrBtn(	XkbDescPtr 	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandlePtrBtn(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbPtrBtnAction	*	act;
+
+    act= (XkbPtrBtnAction *)action;
+    if (field==F_Button) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveInteger(value,&rtrn,SimpleLookup,(XPointer)btnNames))
+	    return ReportMismatch(action->type,field,"integer (range 1..5)");
+	if ((rtrn.ival<0)||(rtrn.ival>5)) {
+	    ERROR("Button must specify default or be in the range 1..5\n");
+	    ACTION1("Illegal button value %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	act->button= rtrn.ival;
+	return True;
+    }
+    else if ((action->type==XkbSA_LockPtrBtn)&&(field==F_Affect)) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveEnum(value,&rtrn,lockWhich))
+	    return ReportMismatch(action->type,field,"lock or unlock");
+	act->flags&= ~(XkbSA_LockNoLock|XkbSA_LockNoUnlock);
+	act->flags|= rtrn.ival;
+	return True;
+    }
+    else if (field==F_Count) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveInteger(value,&rtrn,SimpleLookup,(XPointer)btnNames))
+	    return ReportMismatch(action->type,field,"integer");
+	if ((rtrn.ival<0)||(rtrn.ival>255)) {
+	    ERROR("The count field must have a value in the range 0..255\n");
+	    ACTION1("Illegal count %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	act->count= rtrn.ival;
+	return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static LookupEntry ptrDflts[] = {
+	{	"dfltbtn",		XkbSA_AffectDfltBtn	},
+	{	"defaultbutton",	XkbSA_AffectDfltBtn	},
+	{	"button",		XkbSA_AffectDfltBtn	},
+	{ 	NULL,			0			}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSetPtrDflt(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleSetPtrDflt(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbPtrDfltAction *	act;
+
+    act= (XkbPtrDfltAction *)action;
+    if (field==F_Affect) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveEnum(value,&rtrn,ptrDflts))
+	    return ReportMismatch(action->type,field,"pointer component");
+	act->affect= rtrn.uval;
+	return True;
+    }
+    else if ((field==F_Button)||(field==F_Value)) {
+	ExprDef *btn;
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if ((value->op==OpNegate)||(value->op==OpUnaryPlus))  {
+	    act->flags&= ~XkbSA_DfltBtnAbsolute;
+	    btn= value->value.child;
+	}
+	else {
+	    act->flags|= XkbSA_DfltBtnAbsolute;
+	    btn= value;
+	}
+
+	if (!ExprResolveInteger(btn,&rtrn,SimpleLookup,(XPointer)btnNames))
+	    return ReportMismatch(action->type,field,"integer (range 1..5)");
+	if ((rtrn.ival<0)||(rtrn.ival>5)) {
+	    ERROR("New default button value must be in the range 1..5\n");
+	    ACTION1("Illegal default button value %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	if (rtrn.ival==0) {
+	    ERROR("Cannot set default pointer button to \"default\"\n");
+	    ACTION("Illegal default button setting ignored\n");
+	    return False;
+	}
+	if (value->op==OpNegate)
+	     XkbSASetPtrDfltValue(act,-rtrn.ival);
+	else XkbSASetPtrDfltValue(act,rtrn.ival);
+	return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static LookupEntry	isoNames[] = {
+	{	"mods",		XkbSA_ISONoAffectMods	},
+	{	"modifiers",	XkbSA_ISONoAffectMods	},
+	{	"group",	XkbSA_ISONoAffectGroup	},
+	{	"groups",	XkbSA_ISONoAffectGroup	},
+	{	"ptr",		XkbSA_ISONoAffectPtr	},
+	{	"pointer",	XkbSA_ISONoAffectPtr	},
+	{	"ctrls",	XkbSA_ISONoAffectCtrls	},
+	{	"controls",	XkbSA_ISONoAffectCtrls	},
+	{	"all",		~((unsigned)0)		},
+	{	"none",		0			},
+	{	NULL,		0			},
+};
+
+static Bool
+#if NeedFunctionPrototypes
+HandleISOLock(	XkbDescPtr 	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandleISOLock(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	rtrn;
+XkbISOAction *	act;
+unsigned	flags,mods;
+int		group;
+
+    act= (XkbISOAction *)action;
+    switch (field) {
+	case F_Modifiers:
+	    if (array_ndx!=NULL)
+		return ReportActionNotArray(action->type,field);
+	    flags= act->flags;
+	    if (CheckModifierField(xkb,action->type,value,&flags,&mods)) {
+		act->flags= flags&(~XkbSA_ISODfltIsGroup);
+		act->real_mods= mods&0xff;
+		mods= (mods>>8)&0xff;
+		XkbSetModActionVMods(act,mods);
+		return True;
+	    }
+	    return False;
+	case F_Group:
+	    if (array_ndx!=NULL)
+		return ReportActionNotArray(action->type,field);
+	    flags= act->flags;
+	    if (CheckGroupField(action->type,value,&flags,&group)) {
+		act->flags= flags|XkbSA_ISODfltIsGroup;
+		XkbSASetGroup(act,group);
+		return True;
+	    }
+	    return False;
+	case F_Affect:
+	    if (array_ndx!=NULL)
+		return ReportActionNotArray(action->type,field);
+	    if (!ExprResolveMask(value,&rtrn,SimpleLookup,(XPointer)isoNames))
+		return ReportMismatch(action->type,field,"keyboard component");
+	    act->affect= (~rtrn.uval)&XkbSA_ISOAffectMask;
+	    return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSwitchScreen(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleSwitchScreen(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbSwitchScreenAction *	act;
+
+    act= (XkbSwitchScreenAction *)action;
+    if (field==F_Screen) {
+	ExprDef *scrn;
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if ((value->op==OpNegate)||(value->op==OpUnaryPlus)) {
+	    act->flags&= ~XkbSA_SwitchAbsolute;
+	    scrn= value->value.child;
+	}
+	else {
+	    act->flags|= XkbSA_SwitchAbsolute;
+	    scrn= value;
+	}
+
+	if (!ExprResolveInteger(scrn,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"integer (0..255)");
+	if ((rtrn.ival<0)||(rtrn.ival>255)) {
+	    ERROR("Screen index must be in the range 1..255\n");
+	    ACTION1("Illegal screen value %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	if (value->op==OpNegate)
+	     XkbSASetScreen(act,-rtrn.ival);
+	else XkbSASetScreen(act,rtrn.ival);
+	return True;
+    }
+    else if (field==F_Same) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveBoolean(value,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"boolean");
+	if (rtrn.uval)	act->flags&= ~XkbSA_SwitchApplication;
+	else		act->flags|= XkbSA_SwitchApplication;
+	return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+LookupEntry	ctrlNames[]= {
+	{	"repeatkeys",		XkbRepeatKeysMask	},
+	{	"repeat",		XkbRepeatKeysMask	},
+	{	"autorepeat",		XkbRepeatKeysMask	},
+	{	"slowkeys",		XkbSlowKeysMask		},
+	{	"bouncekeys",		XkbBounceKeysMask	},
+	{	"stickykeys",		XkbStickyKeysMask	},
+	{	"mousekeys",		XkbMouseKeysMask	},
+	{	"mousekeysaccel",	XkbMouseKeysAccelMask	},
+	{	"accessxkeys",		XkbAccessXKeysMask	},
+	{	"accessxtimeout",	XkbAccessXTimeoutMask	},
+	{	"accessxfeedback",	XkbAccessXFeedbackMask	},
+	{	"groupswrap",		XkbGroupsWrapMask	},
+	{	"audiblebell",		XkbAudibleBellMask	},
+	{	"overlay1",		XkbOverlay1Mask		},
+	{	"overlay2",		XkbOverlay2Mask		},
+	{	"ignoregrouplock",	XkbIgnoreGroupLockMask	},
+	{	"all",			XkbAllBooleanCtrlsMask	},
+	{	"none",			0			},
+	{	NULL,			0			}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSetLockControls(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleSetLockControls(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbCtrlsAction *	act;
+
+    act= (XkbCtrlsAction *)action;
+    if (field==F_Controls) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveMask(value,&rtrn,SimpleLookup,(XPointer)ctrlNames))
+	    return ReportMismatch(action->type,field,"controls mask");
+	XkbActionSetCtrls(act,rtrn.uval);
+	return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static LookupEntry evNames[]= {
+	{	"press",	XkbSA_MessageOnPress	},
+	{	"keypress",	XkbSA_MessageOnPress	},
+	{	"release",	XkbSA_MessageOnRelease	},
+	{	"keyrelease",	XkbSA_MessageOnRelease	},
+	{	"all",		XkbSA_MessageOnPress|XkbSA_MessageOnRelease },
+	{	"none",		0			},
+	{	NULL,		0			}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+HandleActionMessage(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleActionMessage(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbMessageAction *	act;
+
+    act= (XkbMessageAction *)action;
+    switch (field) {
+	case F_Report:
+	    if (array_ndx!=NULL)
+		return ReportActionNotArray(action->type,field);
+	    if (!ExprResolveMask(value,&rtrn,SimpleLookup,(XPointer)evNames))
+		return ReportMismatch(action->type,field,"key event mask");
+	    act->flags&= ~(XkbSA_MessageOnPress|XkbSA_MessageOnRelease);
+	    act->flags= rtrn.uval&(XkbSA_MessageOnPress|XkbSA_MessageOnRelease);
+	    return True;
+	case F_GenKeyEvent:
+	    if (array_ndx!=NULL)
+		return ReportActionNotArray(action->type,field);
+	    if (!ExprResolveBoolean(value,&rtrn,NULL,NULL))
+		return ReportMismatch(action->type,field,"boolean");
+	    if (rtrn.uval)	act->flags|= XkbSA_MessageGenKeyEvent;
+	    else		act->flags&= ~XkbSA_MessageGenKeyEvent;
+	    return True;
+	case F_Data:  
+	    if (array_ndx==NULL) {
+		if (!ExprResolveString(value,&rtrn,NULL,NULL))
+		    return ReportMismatch(action->type,field,"string");
+		else {
+		    int len= strlen(rtrn.str);
+		    if ((len<1)||(len>6)) {
+			WARN("An action message can hold only 6 bytes\n");
+			ACTION1("Extra %d bytes ignored\n",len-6);
+		    }
+		    strncpy((char *)act->message,rtrn.str,6);
+		}
+		return True;
+	    }
+	    else {
+		unsigned ndx;
+		if (!ExprResolveInteger(array_ndx,&rtrn,NULL,NULL)) {
+		    ERROR("Array subscript must be integer\n");
+		    ACTION("Illegal subscript ignored\n");
+		    return False;
+		}
+		ndx= rtrn.uval;
+		if (ndx>5) {
+		    ERROR("An action message is at most 6 bytes long\n");
+		    ACTION1("Attempt to use data[%d] ignored\n",ndx);
+		    return False;
+		}
+		if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+		    return ReportMismatch(action->type,field,"integer");
+		if ((rtrn.ival<0)||(rtrn.ival>255)) {
+		    ERROR("Message data must be in the range 0..255\n");
+		    ACTION1("Illegal datum %d ignored\n",rtrn.ival);
+		    return False;
+		}
+		act->message[ndx]= rtrn.uval;
+	    }
+	    return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleRedirectKey(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleRedirectKey(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbRedirectKeyAction *	act;
+unsigned		t1,t2,vmods,vmask;
+unsigned long 		tmp;
+
+    if (array_ndx!=NULL)
+	return ReportActionNotArray(action->type,field);
+
+    act= (XkbRedirectKeyAction *)action;
+    switch (field) {
+	case F_Keycode:
+	    if (!ExprResolveKeyName(value,&rtrn,NULL,NULL))
+		return ReportMismatch(action->type,field,"key name");
+	    tmp= KeyNameToLong(rtrn.keyName.name);
+	    if (!FindNamedKey(xkb,tmp,&t1,True,CreateKeyNames(xkb),0)) {
+		return ReportNotFound(action->type,field,"Key",
+				XkbKeyNameText(rtrn.keyName.name,XkbMessage));
+	    }
+	    act->new_key= t1;
+	    return True;
+	case F_ModsToClear:
+	case F_Modifiers:
+	    t1= 0;
+	    if (CheckModifierField(xkb,action->type,value,&t1,&t2)) {
+		act->mods_mask|= (t2&0xff);
+		if (field==F_Modifiers)
+		     act->mods|= (t2&0xff);
+		else act->mods&= ~(t2&0xff);
+
+		t2= (t2>>8)&0xffff;
+		vmods= XkbSARedirectVMods(act);
+		vmask= XkbSARedirectVModsMask(act);
+		vmask|= t2;
+		if (field==F_Modifiers)
+		     vmods|= t2;
+		else vmods&= ~t2;
+		XkbSARedirectSetVMods(act,vmods);
+		XkbSARedirectSetVModsMask(act,vmask);
+		return True;
+	    }
+	    return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleDeviceBtn(	XkbDescPtr 	xkb,
+			XkbAnyAction *	action,
+			unsigned	field,
+			ExprDef *	array_ndx,
+			ExprDef *	value)
+#else
+HandleDeviceBtn(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbDeviceBtnAction *	act;
+
+    act= (XkbDeviceBtnAction *)action;
+    if (field==F_Button) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"integer (range 1..255)");
+	if ((rtrn.ival<0)||(rtrn.ival>255)) {
+	    ERROR("Button must specify default or be in the range 1..255\n");
+	    ACTION1("Illegal button value %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	act->button= rtrn.ival;
+	return True;
+    }
+    else if ((action->type==XkbSA_LockDeviceBtn)&&(field==F_Affect)) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveEnum(value,&rtrn,lockWhich))
+	    return ReportMismatch(action->type,field,"lock or unlock");
+	act->flags&= ~(XkbSA_LockNoLock|XkbSA_LockNoUnlock);
+	act->flags|= rtrn.ival;
+	return True;
+    }
+    else if (field==F_Count) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveInteger(value,&rtrn,SimpleLookup,(XPointer)btnNames))
+	    return ReportMismatch(action->type,field,"integer");
+	if ((rtrn.ival<0)||(rtrn.ival>255)) {
+	    ERROR("The count field must have a value in the range 0..255\n");
+	    ACTION1("Illegal count %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	act->count= rtrn.ival;
+	return True;
+    }
+    else if (field==F_Device) {
+	if (array_ndx!=NULL)
+	    return ReportActionNotArray(action->type,field);
+	if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+	    return ReportMismatch(action->type,field,"integer (range 1..255)");
+	if ((rtrn.ival<0)||(rtrn.ival>255)) {
+	    ERROR("Device must specify default or be in the range 1..255\n");
+	    ACTION1("Illegal device value %d ignored\n",rtrn.ival);
+	    return False;
+	}
+	act->device= rtrn.ival;
+	return True;
+    }
+    return ReportIllegal(action->type,field);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandlePrivate(	XkbDescPtr 	xkb,
+		XkbAnyAction *	action,
+		unsigned	field,
+		ExprDef *	array_ndx,
+		ExprDef *	value)
+#else
+HandlePrivate(xkb,action,field,array_ndx,value)
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	rtrn;
+
+    switch (field) {
+	case F_Type:
+	    if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+		return ReportMismatch(PrivateAction,field,"integer");
+	    if ((rtrn.ival<0)||(rtrn.ival>255)) {
+		ERROR("Private action type must be in the range 0..255\n");
+		ACTION1("Illegal type %d ignored\n",rtrn.ival);
+		return False;
+	    }
+	    action->type= rtrn.uval;
+	    return True;
+	case F_Data:  
+	    if (array_ndx==NULL) {
+		if (!ExprResolveString(value,&rtrn,NULL,NULL))
+		    return ReportMismatch(action->type,field,"string");
+		else {
+		    int len= strlen(rtrn.str);
+		    if ((len<1)||(len>7)) {
+			WARN("A private action has 7 data bytes\n");
+			ACTION1("Extra %d bytes ignored\n",len-6);
+			return False;
+		    }
+		    strncpy((char *)action->data,rtrn.str,7);
+		}
+		return True;
+	    }
+	    else {
+		unsigned ndx;
+		if (!ExprResolveInteger(array_ndx,&rtrn,NULL,NULL)) {
+		    ERROR("Array subscript must be integer\n");
+		    ACTION("Illegal subscript ignored\n");
+		    return False;
+		}
+		ndx= rtrn.uval;
+		if (ndx>6) {
+		    ERROR("The data for a private action is 7 bytes long\n");
+		    ACTION1("Attempt to use data[%d] ignored\n",ndx);
+		    return False;
+		}
+		if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+		    return ReportMismatch(action->type,field,"integer");
+		if ((rtrn.ival<0)||(rtrn.ival>255)) {
+		    ERROR("All data for a private action must be 0..255\n");
+		    ACTION1("Illegal datum %d ignored\n",rtrn.ival);
+		    return False;
+		}
+		action->data[ndx]= rtrn.uval;
+		return True;
+	    }
+    }
+    return ReportIllegal(PrivateAction,field);
+}
+
+typedef	Bool	(*actionHandler)(
+#if NeedFunctionPrototypes
+	XkbDescPtr 	/* xkb */,
+	XkbAnyAction *	/* action */,
+	unsigned	/* field */,
+	ExprDef *	/* array_ndx */,
+	ExprDef *	/* value */
+#endif
+);
+
+static actionHandler	handleAction[XkbSA_NumActions+1] = {
+	HandleNoAction			/* NoAction	*/,
+	HandleSetLatchMods		/* SetMods	*/,
+	HandleSetLatchMods		/* LatchMods	*/,
+	HandleLockMods			/* LockMods	*/,
+	HandleSetLatchGroup		/* SetGroup	*/,
+	HandleSetLatchGroup		/* LatchGroup	*/,
+	HandleLockGroup			/* LockGroup	*/,
+	HandleMovePtr			/* MovePtr	*/,
+	HandlePtrBtn			/* PtrBtn	*/,
+	HandlePtrBtn			/* LockPtrBtn	*/,
+	HandleSetPtrDflt		/* SetPtrDflt	*/,
+	HandleISOLock			/* ISOLock	*/,
+	HandleNoAction			/* Terminate	*/,
+	HandleSwitchScreen		/* SwitchScreen	*/,
+	HandleSetLockControls		/* SetControls	*/,
+	HandleSetLockControls		/* LockControls	*/,
+	HandleActionMessage		/* ActionMessage*/,
+	HandleRedirectKey		/* RedirectKey	*/,
+	HandleDeviceBtn			/* DeviceBtn	*/,
+	HandleDeviceBtn			/* LockDeviceBtn*/,
+	HandlePrivate			/* Private	*/
+};
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+ApplyActionFactoryDefaults(XkbAction *action)
+#else
+ApplyActionFactoryDefaults(action)
+    XkbAction *	action;
+#endif
+{
+    if (action->type==XkbSA_SetPtrDflt) { /* increment default button */
+	action->dflt.affect= XkbSA_AffectDfltBtn;
+	action->dflt.flags= 0;
+	XkbSASetPtrDfltValue(&action->dflt,1);
+    }
+    else if (action->type==XkbSA_ISOLock) {
+	action->iso.real_mods=  LockMask;
+    }
+    return;
+}
+
+
+int 
+#if NeedFunctionPrototypes
+HandleActionDef(	ExprDef *	def,
+			XkbDescPtr	xkb,
+			XkbAnyAction *	action,
+			unsigned	mergeMode,
+			ActionInfo *	info)
+#else
+HandleActionDef(def,xkb,action,mergeMode,info)
+    ExprDef *		def;
+    XkbDescPtr		xkb;
+    XkbAnyAction *	action;
+    unsigned		mergeMode;
+    ActionInfo *	info;
+#endif
+{
+ExprDef *		arg;
+register char *		str;
+unsigned 		tmp,hndlrType;
+
+    if (!actionsInitialized)
+	ActionsInit();
+
+    if (def->op!=ExprActionDecl) {
+	ERROR1("Expected an action definition, found %s\n",exprOpText(def->op));
+	return False;
+    }
+    str= XkbAtomGetString(NULL,def->value.action.name);
+    if (!str) {
+	WSGO("Missing name in action definition!!\n");
+	return False;
+    }
+    if (!stringToAction(str,&tmp)) {
+	ERROR1("Unknown action %s\n",str);
+	return False;
+    }
+    action->type= hndlrType= tmp;
+    if (action->type!=XkbSA_NoAction) {
+	ApplyActionFactoryDefaults((XkbAction *)action);
+	while (info) {
+	    if ((info->action==XkbSA_NoAction)||(info->action==hndlrType)) {
+		if (!(*handleAction[hndlrType])(xkb,action,
+						info->field,info->array_ndx,
+						info->value)) {
+		    return False;
+		}
+	    }
+	    info= info->next;
+	}
+    }
+    for (arg=def->value.action.args;arg!=NULL;arg=(ExprDef*)arg->common.next) {
+	ExprDef *field,*value,*arrayRtrn;
+	ExprResult elemRtrn,fieldRtrn;
+	unsigned fieldNdx;
+
+	if (arg->op==OpAssign) {
+	    field= arg->value.binary.left;
+	    value= arg->value.binary.right;
+	}
+	else {
+	    if ((arg->op==OpNot)||(arg->op==OpInvert)) {
+		field= arg->value.child;
+		value= &constFalse;
+	    }
+	    else {
+		field= arg;
+		value= &constTrue;
+	    }
+	}
+	if (!ExprResolveLhs(field,&elemRtrn,&fieldRtrn,&arrayRtrn))
+	    return False;	/* internal error -- already reported */
+	
+	if (elemRtrn.str!=NULL) {
+	    ERROR("Cannot change defaults in an action definition\n");
+	    ACTION2("Ignoring attempt to change %s.%s\n",elemRtrn.str,
+							 fieldRtrn.str);
+	    return False;
+	}
+	if (!stringToField(fieldRtrn.str,&fieldNdx)) {
+	    ERROR1("Unknown field name %s\n",uStringText(fieldRtrn.str));
+	    return False;
+	}
+	if (!(*handleAction[hndlrType])(xkb,action,fieldNdx,arrayRtrn,value)) {
+	    return False;
+	}
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+int 
+#if NeedFunctionPrototypes
+SetActionField(	XkbDescPtr	xkb,
+		char *		elem,
+		char *		field,
+		ExprDef *	array_ndx,
+		ExprDef *	value,
+		ActionInfo **	info_rtrn)
+#else
+SetActionField(xkb,elem,field,array_ndx,value,info_rtrn)
+    XkbDescPtr		xkb;
+    char *		elem;
+    char *		field;
+    ExprDef *		array_ndx;
+    ExprDef *		value;
+    ActionInfo **	info_rtrn;
+#endif
+{
+ActionInfo *new,*old;
+
+    if (!actionsInitialized)
+	ActionsInit();
+
+    new= uTypedAlloc(ActionInfo);
+    if (new==NULL) {
+	WSGO("Couldn't allocate space for action default\n");
+	return False;
+    }
+    if (uStrCaseCmp(elem,"action")==0)
+	new->action= XkbSA_NoAction;
+    else {
+	if (!stringToAction(elem,&new->action))
+	    return False;
+	if (new->action==XkbSA_NoAction) {
+	    ERROR1("\"%s\" is not a valid field in a NoAction action\n",field);
+	    return False;
+	}
+    }
+    if (!stringToField(field,&new->field)) {
+	ERROR1("\"%s\" is not a legal field name\n",field);
+	return False;
+    }
+    new->array_ndx= array_ndx;
+    new->value= value;
+    new->next= NULL;
+    old= *info_rtrn;
+    while ((old)&&(old->next))
+	old= old->next;
+    if (old==NULL)	*info_rtrn= new;
+    else		old->next= new;
+    return True;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+ActionsInit(void)
+#else
+ActionsInit()
+#endif
+{
+    if (!actionsInitialized) {
+	bzero((char *)&constTrue,sizeof(constTrue));
+	bzero((char *)&constFalse,sizeof(constFalse));
+	constTrue.common.stmtType= StmtExpr;
+	constTrue.common.next= NULL;
+	constTrue.op= ExprIdent;
+	constTrue.type= TypeBoolean;
+	constTrue.value.str= XkbInternAtom(NULL,"true",False);
+	constFalse.common.stmtType= StmtExpr;
+	constFalse.common.next= NULL;
+	constFalse.op= ExprIdent;
+	constFalse.type= TypeBoolean;
+	constFalse.value.str= XkbInternAtom(NULL,"false",False);
+	actionsInitialized= 1;
+    }
+    return;
+}
+
diff --git a/action.h b/action.h
new file mode 100644
index 0000000..f588ff4
--- /dev/null
+++ b/action.h
@@ -0,0 +1,94 @@
+/* $Xorg: action.h,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 ACTION_H
+#define ACTION_H 1
+
+#define	F_ClearLocks	0
+#define	F_LatchToLock	1
+#define	F_GenKeyEvent	2
+#define	F_Report	3
+#define	F_Default	4
+#define	F_Affect	5
+#define	F_Increment	6
+#define	F_Modifiers	7
+#define	F_Group		8
+#define	F_X		9
+#define	F_Y		10
+#define	F_Accel		11
+#define	F_Button	12
+#define	F_Value		13
+#define	F_Controls	14
+#define	F_Type		15
+#define	F_Count		16
+#define	F_Screen	17
+#define	F_Same		18
+#define	F_Data		19
+#define	F_Device	20
+#define	F_Keycode	21
+#define	F_ModsToClear	22
+#define	F_LastField	F_ModsToClear
+#define	F_NumFields	(F_LastField+1)
+
+#define	PrivateAction	(XkbSA_LastAction+1)
+
+typedef struct _ActionInfo {
+	unsigned		action;
+	unsigned		field;
+	ExprDef *		array_ndx;
+	ExprDef *		value;
+	struct _ActionInfo *	next;
+} ActionInfo;
+
+extern int HandleActionDef(
+#if NeedFunctionPrototypes
+	ExprDef *		/* def */,
+	XkbDescPtr		/* xkb */,
+	XkbAnyAction *		/* action */,
+	unsigned		/* mergeMode */,
+	ActionInfo *		/* info */
+#endif
+);
+
+extern int SetActionField(
+#if NeedFunctionPrototypes
+	XkbDescPtr		/* xkb */,
+	char *			/* elem */,
+	char *			/* field */,
+	ExprDef *		/* index */,
+	ExprDef *		/* value */,
+	ActionInfo **		/* info_rtrn */
+#endif
+);
+
+extern void ActionsInit(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+
+#endif /* ACTION_H */
diff --git a/alias.c b/alias.c
new file mode 100644
index 0000000..dc51b82
--- /dev/null
+++ b/alias.c
@@ -0,0 +1,302 @@
+/* $Xorg: alias.c,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc.
+
+ Permission to use, copy, modify, and distribute this
+ software and its documentation for any purpose and without
+ fee is hereby granted, provided that the above copyright
+ notice appear in all copies and that both that copyright
+ notice and this permission notice appear in supporting
+ documentation, and that the name of Silicon Graphics not be 
+ used in advertising or publicity pertaining to distribution 
+ of the software without specific prior written permission.
+ Silicon Graphics makes no representation about the suitability 
+ of this software for any purpose. It is provided "as is"
+ without any express or implied warranty.
+ 
+ SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+ OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "misc.h"
+#include "alias.h"
+#include "keycodes.h"
+
+#include <X11/extensions/XKBgeom.h>
+
+static void
+#if NeedFunctionPrototypes
+HandleCollision(AliasInfo *old,AliasInfo *new)
+#else
+HandleCollision(old,new)
+    AliasInfo *		old;
+    AliasInfo *		new;
+#endif
+{
+    if (strncmp(new->real,old->real,XkbKeyNameLength)==0) {
+	if (((new->def.fileID==old->def.fileID)&&(warningLevel>0))||
+							(warningLevel>9)) {
+	    WARN2("Alias of %s for %s declared more than once\n",
+					XkbKeyNameText(new->alias,XkbMessage),
+					XkbKeyNameText(new->real,XkbMessage));
+	    ACTION("First definition ignored\n");
+	}
+    }
+    else {
+	char *use,*ignore;
+	if (new->def.merge==MergeAugment) {
+	    use= old->real;
+	    ignore= new->real;
+	}
+	else {
+	    use= new->real;
+	    ignore= old->real;
+	}
+	if (((old->def.fileID==new->def.fileID)&&(warningLevel>0))||
+							(warningLevel>9)){
+	    WARN1("Multiple definitions for alias %s\n",
+					XkbKeyNameText(old->alias,XkbMessage));
+	    ACTION2("Using %s, ignoring %s\n", XkbKeyNameText(use,XkbMessage),
+					XkbKeyNameText(ignore,XkbMessage));
+	}
+	if (use!=old->real)
+	    memcpy(old->real,use,XkbKeyNameLength);
+    }
+    old->def.fileID= new->def.fileID;
+    old->def.merge= new->def.merge;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitAliasInfo(	AliasInfo *	info,
+		unsigned	merge,
+		unsigned	file_id,
+		char *		alias,
+		char *		real)
+#else
+InitAliasInfo(info,merge,file_id,alias,real)
+    AliasInfo *		info;
+    unsigned		merge;
+    unsigned		file_id;
+    char *		alias;
+    char *		real;
+#endif
+{
+    bzero(info,sizeof(AliasInfo));
+    info->def.merge= merge;
+    info->def.fileID= file_id;
+    strncpy(info->alias,alias,XkbKeyNameLength);
+    strncpy(info->real,real,XkbKeyNameLength);
+    return;
+}
+
+int 
+#if NeedFunctionPrototypes
+HandleAliasDef(	KeyAliasDef *	def,
+		unsigned 	merge,
+		unsigned 	file_id,
+		AliasInfo **	info_in)
+#else
+HandleAliasDef(def,merge,file_id,info_in)
+    KeyAliasDef *	def;
+    unsigned		merge;
+    unsigned		file_id;
+    AliasInfo **	info_in;
+#endif
+{
+AliasInfo *	info;
+
+    for (info= *info_in;info!=NULL;info= (AliasInfo *)info->def.next) {
+	if (strncmp(info->alias,def->alias,XkbKeyNameLength)==0) {
+	    AliasInfo new;
+	    InitAliasInfo(&new,merge,file_id,def->alias,def->real);
+	    HandleCollision(info,&new);
+	    return True;
+	}
+    }
+    info= uTypedCalloc(1,AliasInfo);
+    if (info==NULL) {
+	WSGO("Allocation failure in HandleAliasDef\n");
+	return False;
+    }
+    info->def.fileID= file_id;
+    info->def.merge= merge;
+    info->def.next= (CommonInfo *)*info_in;
+    memcpy(info->alias,def->alias,XkbKeyNameLength);
+    memcpy(info->real,def->real,XkbKeyNameLength);
+    *info_in= (AliasInfo *)AddCommonInfo(&(*info_in)->def,&info->def);
+    return True;
+}
+
+void
+#if NeedFunctionPrototypes
+ClearAliases(AliasInfo **info_in)
+#else
+ClearAliases(info_in)
+    AliasInfo **	info_in;
+#endif
+{
+    if ((info_in)&&(*info_in))
+	ClearCommonInfo(&(*info_in)->def);
+    return;
+}
+
+Bool
+#if NeedFunctionPrototypes
+MergeAliases(AliasInfo **into,AliasInfo **merge,unsigned how_merge)
+#else
+MergeAliases(into,merge,how_merge)
+    AliasInfo **	into;
+    AliasInfo **	merge;
+    unsigned		how_merge;
+#endif
+{
+AliasInfo *	tmp;
+KeyAliasDef 	def;
+
+    if ((*merge)==NULL)
+	return True;
+    if ((*into)==NULL) {
+	*into= *merge;
+	*merge= NULL;
+	return True;
+    }	
+    bzero((char *)&def,sizeof(KeyAliasDef));
+    for (tmp= *merge;tmp!=NULL;tmp= (AliasInfo *)tmp->def.next) {
+	if (how_merge==MergeDefault)
+	     def.merge= tmp->def.merge;
+	else def.merge= how_merge;
+	memcpy(def.alias,tmp->alias,XkbKeyNameLength);
+	memcpy(def.real,tmp->real,XkbKeyNameLength);
+	if (!HandleAliasDef(&def,def.merge,tmp->def.fileID,into))
+	    return False;
+    }
+    return True;
+}
+
+int
+#if NeedFunctionPrototypes
+ApplyAliases(XkbDescPtr	xkb,Bool toGeom,AliasInfo **info_in)
+#else
+ApplyAliases(xkb,toGeom,info_in)
+    XkbDescPtr		xkb;
+    Bool		toGeom;
+    AliasInfo **	info_in;
+#endif
+{
+register int 	i;
+XkbKeyAliasPtr	old,a;
+AliasInfo *	info;
+int		nNew,nOld;
+Status		status;
+
+    if (*info_in==NULL)
+	return True;
+    if (toGeom) {
+	nOld= (xkb->geom?xkb->geom->num_key_aliases:0);
+	old= (xkb->geom?xkb->geom->key_aliases:NULL);
+    }
+    else {
+	nOld= (xkb->names?xkb->names->num_key_aliases:0);
+	old= (xkb->names?xkb->names->key_aliases:NULL);
+    }
+    for (nNew=0,info= *info_in;info!=NULL;info= (AliasInfo *)info->def.next) {
+	unsigned long lname;
+	unsigned int kc;
+
+	lname= KeyNameToLong(info->real);
+	if (!FindNamedKey(xkb,lname,&kc,False,CreateKeyNames(xkb),0)) {
+	    if (warningLevel>4) {
+		WARN2("Attempt to alias %s to non-existent key %s\n",
+					XkbKeyNameText(info->alias,XkbMessage),
+					XkbKeyNameText(info->real,XkbMessage));
+		ACTION("Ignored\n");
+	    }
+	    info->alias[0]= '\0';
+	    continue;
+	}
+	lname= KeyNameToLong(info->alias);
+	if (FindNamedKey(xkb,lname,&kc,False,False,0)) {
+	    if (warningLevel>4) {
+		WARN("Attempt to create alias with the name of a real key\n");
+		ACTION2("Alias \"%s = %s\" ignored\n",
+					XkbKeyNameText(info->alias,XkbMessage),
+					XkbKeyNameText(info->real,XkbMessage));
+	    }
+	    info->alias[0]= '\0';
+	    continue;
+	}
+	nNew++;
+	if ( old ) {
+	    for (i=0,a=old;i<nOld;i++,a++) {
+		if (strncmp(a->alias,info->alias,XkbKeyNameLength)==0) {
+		    AliasInfo old;
+		    InitAliasInfo(&old,MergeAugment,0,a->alias,a->real);
+		    HandleCollision(&old,info);
+		    memcpy(old.real,a->real,XkbKeyNameLength);
+		    info->alias[0]= '\0';
+		    nNew--;
+		    break;
+		}
+	    }
+	}
+    }
+    if (nNew==0) {
+	ClearCommonInfo(&(*info_in)->def);
+	*info_in= NULL;
+	return True;
+    }
+    status= Success;
+    if (toGeom) {
+	if (!xkb->geom) {
+	    XkbGeometrySizesRec	sizes;
+	    bzero((char *)&sizes,sizeof(XkbGeometrySizesRec));
+	    sizes.which= XkbGeomKeyAliasesMask;
+	    sizes.num_key_aliases= nOld+nNew;
+	    status= XkbAllocGeometry(xkb,&sizes);
+	}
+	else {
+	    status= XkbAllocGeomKeyAliases(xkb->geom,nOld+nNew);
+	}
+	if (xkb->geom)
+	    old= xkb->geom->key_aliases;
+    }
+    else {
+	status= XkbAllocNames(xkb,XkbKeyAliasesMask,0,nOld+nNew);
+	if (xkb->names)
+	    old= xkb->names->key_aliases;
+    }
+    if (status!=Success) {
+	WSGO("Allocation failure in ApplyAliases\n");
+	return False;
+    }
+    if (toGeom) 
+	 a= &xkb->geom->key_aliases[nOld];
+    else a= &xkb->names->key_aliases[nOld];
+    for (info= *info_in;info!=NULL;info= (AliasInfo *)info->def.next) {
+	if (info->alias[0]!='\0') {
+	    strncpy(a->alias,info->alias,XkbKeyNameLength);
+	    strncpy(a->real,info->real,XkbKeyNameLength);
+	    a++;
+	}
+    }
+#ifdef DEBUG
+    if ((a-old)!=(nOld+nNew)) {
+	WSGO2("Expected %d aliases total but created %d\n",nOld+nNew,a-old);
+    }
+#endif
+    if (toGeom)	
+	xkb->geom->num_key_aliases+= nNew;
+    ClearCommonInfo(&(*info_in)->def);
+    *info_in= NULL;
+    return True;
+}
diff --git a/alias.h b/alias.h
new file mode 100644
index 0000000..7c76083
--- /dev/null
+++ b/alias.h
@@ -0,0 +1,68 @@
+/* $Xorg: alias.h,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc.
+
+ Permission to use, copy, modify, and distribute this
+ software and its documentation for any purpose and without
+ fee is hereby granted, provided that the above copyright
+ notice appear in all copies and that both that copyright
+ notice and this permission notice appear in supporting
+ documentation, and that the name of Silicon Graphics not be 
+ used in advertising or publicity pertaining to distribution 
+ of the software without specific prior written permission.
+ Silicon Graphics makes no representation about the suitability 
+ of this software for any purpose. It is provided "as is"
+ without any express or implied warranty.
+ 
+ SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+ OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ********************************************************/
+
+#ifndef ALIAS_H
+#define ALIAS_H 1
+
+typedef struct _AliasInfo {
+	CommonInfo		def;
+	char			alias[XkbKeyNameLength+1];
+	char			real[XkbKeyNameLength+1];
+} AliasInfo;
+
+extern int HandleAliasDef(
+#if NeedFunctionPrototypes
+	KeyAliasDef *		/* def   */,
+	unsigned		/* merge */,
+	unsigned		/* file_id */,
+	AliasInfo **		/* info  */
+#endif
+);
+
+extern void ClearAliases(
+#if NeedFunctionPrototypes
+	AliasInfo **		/* info */
+#endif
+);
+
+extern Bool MergeAliases(
+#if NeedFunctionPrototypes
+	AliasInfo **		/* into */,
+	AliasInfo **		/* merge */,
+	unsigned		/* how_merge */
+#endif
+);
+
+extern int ApplyAliases(
+#if NeedFunctionPrototypes
+	XkbDescPtr		/* xkb */,
+	Bool			/* toGeom */,
+	AliasInfo **		/* info */
+#endif
+);
+
+#endif /* ALIAS_H */
diff --git a/compat.c b/compat.c
new file mode 100644
index 0000000..2b44523
--- /dev/null
+++ b/compat.c
@@ -0,0 +1,913 @@
+/* $Xorg: compat.c,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include <X11/Xos.h>
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "misc.h"
+#include "indicators.h"
+#include "action.h"
+
+typedef struct _SymInterpInfo {
+    CommonInfo		defs;
+    XkbSymInterpretRec	interp;
+} SymInterpInfo;
+
+#define	_SI_VirtualMod		(1<<0)
+#define	_SI_Action		(1<<1)
+#define	_SI_AutoRepeat		(1<<2)
+#define	_SI_LockingKey		(1<<3)
+#define	_SI_LevelOneOnly	(1<<4)
+
+typedef struct _GroupCompatInfo {
+    unsigned char	fileID;
+    unsigned char	merge;
+    unsigned char	real_mods;
+    unsigned short	vmods;
+} GroupCompatInfo;
+
+typedef struct _CompatInfo {
+    char *		name;
+    unsigned 		fileID;
+    int			errorCount;
+    int			nInterps;
+    SymInterpInfo *	interps;
+    SymInterpInfo 	dflt;
+    LEDInfo		ledDflt;
+    GroupCompatInfo	groupCompat[XkbNumKbdGroups];
+    LEDInfo *		leds;
+    VModInfo		vmods;
+    ActionInfo *	act;
+    XkbDescPtr		xkb;
+} CompatInfo;
+
+/***====================================================================***/
+
+#define	ReportSINotArray(si,f,i) \
+	ReportNotArray("symbol interpretation",(f),siText((si),(i)))
+#define	ReportSIBadType(si,f,w,i) \
+	ReportBadType("symbol interpretation",(f),siText((si),(i)),(w))
+
+/***====================================================================***/
+
+static char *
+#if NeedFunctionPrototypes
+siText(SymInterpInfo *	si,CompatInfo *	info)
+#else
+siText(si,info)
+    SymInterpInfo *	si;
+    CompatInfo *	info;
+#endif
+{
+static char buf[128];
+
+    if (si==&info->dflt) {
+	sprintf(buf,"default");
+    }
+    else {
+	sprintf(buf,"%s+%s(%s)",XkbKeysymText(si->interp.sym,XkbMessage),
+				XkbSIMatchText(si->interp.match,XkbMessage),
+				XkbModMaskText(si->interp.mods,XkbMessage));
+    }
+    return buf;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitCompatInfo(CompatInfo *info,XkbDescPtr xkb)
+#else
+InitCompatInfo(info,xkb)
+    CompatInfo *	info;
+    XkbDescPtr		xkb;
+#endif
+{
+register int i;
+
+    info->xkb= xkb;
+    info->name= NULL;
+    info->fileID= 0;
+    info->errorCount= 0;
+    info->nInterps= 0;
+    info->interps= NULL;
+    info->act= NULL;
+    info->dflt.defs.fileID= info->fileID;
+    info->dflt.defs.defined= 0;
+    info->dflt.defs.merge= MergeOverride;
+    info->dflt.interp.flags=	0;
+    info->dflt.interp.virtual_mod= XkbNoModifier;
+    info->dflt.interp.act.type= XkbSA_NoAction;
+    for (i=0;i<XkbAnyActionDataSize;i++) {
+	info->dflt.interp.act.data[i]= 0;
+    }
+    ClearIndicatorMapInfo(xkb->dpy,&info->ledDflt);
+    info->ledDflt.defs.fileID= info->fileID;
+    info->ledDflt.defs.defined= 0;
+    info->ledDflt.defs.merge= MergeOverride;
+    bzero((char *)&info->groupCompat[0],XkbNumKbdGroups*sizeof(GroupCompatInfo));
+    info->leds= NULL;
+    InitVModInfo(&info->vmods,xkb);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearCompatInfo(CompatInfo *info,XkbDescPtr xkb)
+#else
+ClearCompatInfo(info,xkb)
+    CompatInfo *	info;
+    XkbDescPtr		xkb;
+#endif
+{
+register int i;
+
+    if (info->name!=NULL)
+	uFree(info->name);
+    info->name= NULL;
+    info->dflt.defs.defined= 0;
+    info->dflt.defs.merge= MergeAugment;
+    info->dflt.interp.flags= 0;
+    info->dflt.interp.virtual_mod= XkbNoModifier;
+    info->dflt.interp.act.type= XkbSA_NoAction;
+    for (i=0;i<XkbAnyActionDataSize;i++) {
+	info->dflt.interp.act.data[i]= 0;
+    }
+    ClearIndicatorMapInfo(xkb->dpy,&info->ledDflt);
+    info->nInterps= 0;
+    info->interps= (SymInterpInfo *)ClearCommonInfo(&info->interps->defs);
+    bzero((char *)&info->groupCompat[0],XkbNumKbdGroups*sizeof(GroupCompatInfo));
+    info->leds= (LEDInfo *)ClearCommonInfo(&info->leds->defs);
+    /* 3/30/94 (ef) -- XXX! Should free action info here */
+    ClearVModInfo(&info->vmods,xkb);
+    return;
+}
+
+static SymInterpInfo *
+#if NeedFunctionPrototypes
+NextInterp(CompatInfo *info)
+#else
+NextInterp(info)
+    CompatInfo *	info;
+#endif
+{
+SymInterpInfo *	si;
+
+    si= uTypedAlloc(SymInterpInfo);
+    if (si) {
+	bzero((char *)si,sizeof(SymInterpInfo));
+	info->interps= (SymInterpInfo *)AddCommonInfo(&info->interps->defs,
+							(CommonInfo *)si);
+	info->nInterps++;
+    }
+    return si;
+}
+
+static SymInterpInfo *
+#if NeedFunctionPrototypes
+FindMatchingInterp(CompatInfo *info,SymInterpInfo *new)
+#else
+FindMatchingInterp(info,new)
+    CompatInfo *	info;
+    SymInterpInfo *	new;
+#endif
+{
+SymInterpInfo *	old;
+
+    for (old= info->interps;old!=NULL;old=(SymInterpInfo *)old->defs.next) {
+	if ((old->interp.sym==new->interp.sym)&&
+				(old->interp.mods==new->interp.mods)&&
+				(old->interp.match==new->interp.match)) {
+	    return  old;
+	}
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddInterp(CompatInfo *info,SymInterpInfo *new)
+#else
+AddInterp(info,new)
+    CompatInfo *	info;
+    SymInterpInfo *	new;
+#endif
+{
+unsigned		collide;
+SymInterpInfo	*	old;
+
+    collide= 0;
+    old= FindMatchingInterp(info,new);
+    if (old!=NULL) {
+	if (new->defs.merge==MergeReplace) {
+	    SymInterpInfo *next= (SymInterpInfo *)old->defs.next;
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN1("Multiple definitions for \"%s\"\n",siText(new,info));
+		ACTION("Earlier interpretation ignored\n");
+	    }
+	    *old= *new;
+	    old->defs.next= &next->defs;
+	    return True;
+	}
+	if (UseNewField(_SI_VirtualMod,&old->defs,&new->defs,&collide)) {
+	    old->interp.virtual_mod= new->interp.virtual_mod;
+	    old->defs.defined|= _SI_VirtualMod;
+	}
+	if (UseNewField(_SI_Action,&old->defs,&new->defs,&collide)) {
+	    old->interp.act= new->interp.act;
+	    old->defs.defined|= _SI_Action;
+	}
+	if (UseNewField(_SI_AutoRepeat,&old->defs,&new->defs,&collide)) {
+	    old->interp.flags&= ~XkbSI_AutoRepeat;
+	    old->interp.flags|= (new->interp.flags&XkbSI_AutoRepeat);
+	    old->defs.defined|= _SI_AutoRepeat;
+	}
+	if (UseNewField(_SI_LockingKey,&old->defs,&new->defs,&collide)) {
+	    old->interp.flags&= ~XkbSI_LockingKey;
+	    old->interp.flags|= (new->interp.flags&XkbSI_LockingKey);
+	    old->defs.defined|= _SI_LockingKey;
+	}
+	if (UseNewField(_SI_LevelOneOnly,&old->defs,&new->defs,&collide)) {
+	    old->interp.match&= ~XkbSI_LevelOneOnly;
+	    old->interp.match|= (new->interp.match&XkbSI_LevelOneOnly);
+	    old->defs.defined|= _SI_LevelOneOnly;
+	}
+	if (collide) {
+	    WARN1("Multiple interpretations of \"%s\"\n",siText(new,info));
+	    ACTION1("Using %s definition for duplicate fields\n",
+				(new->defs.merge!=MergeAugment?"last":"first"));
+	}
+	return True;
+    }
+    old= new;
+    if ((new= NextInterp(info))==NULL)
+	return False;
+    *new= *old;
+    new->defs.next= NULL;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddGroupCompat(CompatInfo *info,unsigned group,GroupCompatInfo *newGC)
+#else
+AddGroupCompat(info,group,newGC)
+    CompatInfo *	info;
+    unsigned		group;
+    GroupCompatInfo *	newGC;
+#endif
+{
+GroupCompatInfo *	gc;
+unsigned		merge;
+
+    merge= newGC->merge;
+    gc= &info->groupCompat[group];
+    if ((gc->fileID<1)||
+	((gc->real_mods==newGC->real_mods)&&(gc->vmods==newGC->vmods))) {
+	*gc= *newGC;
+	return True;
+    }
+    if (((gc->fileID==newGC->fileID)&&(warningLevel>0))||(warningLevel>9)) {
+	WARN1("Compat map for group %d redefined\n",group+1);
+	ACTION1("Using %s definition\n",(merge==MergeAugment?"old":"new"));
+    }
+    if (merge!=MergeAugment)
+	*gc= *newGC;
+    return True;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+ResolveStateAndPredicate(	ExprDef *	expr,
+				unsigned *	pred_rtrn,
+				unsigned *	mods_rtrn,
+				CompatInfo *	info)
+#else
+ResolveStateAndPredicate(expr,pred_rtrn,mods_rtrn,info)
+    ExprDef *		expr;
+    unsigned *		pred_rtrn;
+    unsigned *		mods_rtrn;
+    CompatInfo *	info;
+#endif
+{
+ExprResult	result;
+
+    if (expr==NULL) {
+	*pred_rtrn= XkbSI_AnyOfOrNone;
+	*mods_rtrn= ~0;
+	return True;
+    }
+
+    *pred_rtrn= XkbSI_Exactly;
+    if (expr->op==ExprActionDecl) {
+	char *pred_txt= XkbAtomText(NULL,expr->value.action.name,XkbMessage);
+	if (uStrCaseCmp(pred_txt,"noneof")==0)
+	     *pred_rtrn= XkbSI_NoneOf;
+	else if (uStrCaseCmp(pred_txt,"anyofornone")==0)
+	     *pred_rtrn= XkbSI_AnyOfOrNone;
+	else if (uStrCaseCmp(pred_txt,"anyof")==0)
+	     *pred_rtrn= XkbSI_AnyOf;
+	else if (uStrCaseCmp(pred_txt,"allof")==0)
+	     *pred_rtrn= XkbSI_AllOf;
+	else if (uStrCaseCmp(pred_txt,"exactly")==0)
+	     *pred_rtrn= XkbSI_Exactly;
+	else {
+	     ERROR1("Illegal modifier predicate \"%s\"\n",pred_txt);
+	     ACTION("Ignored\n");
+	     return False;
+	}
+	expr= expr->value.action.args;
+    }
+    else if (expr->op==ExprIdent) {
+	char *pred_txt= XkbAtomText(NULL,expr->value.str,XkbMessage);
+	if ((pred_txt)&&(uStrCaseCmp(pred_txt,"any")==0)) {
+	    *pred_rtrn= XkbSI_AnyOf;
+	    *mods_rtrn= 0xff;
+	    return True;
+	}
+    }
+
+    if (ExprResolveModMask(expr,&result,NULL,NULL)) {
+	*mods_rtrn= result.uval;
+	return True;
+    }
+    return False;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+MergeIncludedCompatMaps(	CompatInfo *	into,
+				CompatInfo *	from,
+				unsigned	merge)
+#else
+MergeIncludedCompatMaps(into,from,merge)
+    CompatInfo *	into;
+    CompatInfo *	from;
+    unsigned		merge;
+#endif
+{
+SymInterpInfo * 	si;
+LEDInfo *		led,*rtrn,*next;
+GroupCompatInfo *	gcm;
+register int		i;
+
+    if (from->errorCount>0) {
+	into->errorCount+= from->errorCount;
+	return;
+    }
+    if (into->name==NULL) {
+	into->name= from->name;
+	from->name= NULL;
+    }
+    for (si=from->interps;si;si=(SymInterpInfo *)si->defs.next) {
+	if (merge!=MergeDefault)
+	    si->defs.merge= merge;
+	if (!AddInterp(into,si))
+	    into->errorCount++;
+    }
+    for (i=0,gcm=&from->groupCompat[0];i<XkbNumKbdGroups;i++,gcm++) {
+	if (merge!=MergeDefault)
+	    gcm->merge= merge;
+	if (!AddGroupCompat(into,i,gcm))
+	    into->errorCount++;
+    }
+    for (led=from->leds;led!=NULL;led=next) {
+	next= (LEDInfo *)led->defs.next;
+	if (merge!=MergeDefault)
+	    led->defs.merge= merge;
+	rtrn= AddIndicatorMap(into->leds,led);
+	if (rtrn!=NULL) 
+	     into->leds= rtrn;
+	else into->errorCount++;
+    }
+    return;
+}
+
+typedef void	(*FileHandler)(
+#if NeedFunctionPrototypes
+	XkbFile *	/* rtrn */,
+	XkbDescPtr	/* xkb */,
+	unsigned	/* merge */,
+	CompatInfo *	/* info */
+#endif
+);
+
+static Bool
+#if NeedFunctionPrototypes
+HandleIncludeCompatMap(	IncludeStmt *	  stmt,
+			XkbDescPtr	  xkb,
+			CompatInfo *	  info,
+			FileHandler	  hndlr)
+#else
+HandleIncludeCompatMap(stmt,xkb,info,hndlr)
+    IncludeStmt	*	stmt;
+    XkbDescPtr		xkb;
+    CompatInfo *	info;
+    FileHandler		hndlr;
+#endif
+{
+unsigned 	newMerge;
+XkbFile	*	rtrn;
+CompatInfo	included;
+Bool		haveSelf;
+
+    haveSelf= False;
+    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
+	haveSelf= True;
+	included= *info;
+	bzero(info,sizeof(CompatInfo));
+    }
+    else if (ProcessIncludeFile(stmt,XkmCompatMapIndex,&rtrn,&newMerge)) {
+	InitCompatInfo(&included,xkb);
+	included.fileID= rtrn->id;
+	included.dflt= info->dflt;
+	included.dflt.defs.fileID= rtrn->id;
+	included.dflt.defs.merge= newMerge;
+	included.ledDflt.defs.fileID= rtrn->id;
+	included.ledDflt.defs.merge= newMerge;
+	included.act= info->act;
+	(*hndlr)(rtrn,xkb,MergeOverride,&included);
+	if (stmt->stmt!=NULL) {
+	    if (included.name!=NULL)
+		uFree(included.name);
+	    included.name= stmt->stmt;
+	    stmt->stmt= NULL;
+	}
+    }
+    else {
+	info->errorCount+= 10;
+	return False;
+    }
+    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
+	IncludeStmt *	next;
+	unsigned	op;
+	CompatInfo	next_incl;
+
+	for (next=stmt->next;next!=NULL;next=next->next) {
+	    if ((next->file==NULL)&&(next->map==NULL)) {
+		haveSelf= True;
+		MergeIncludedCompatMaps(&included,info,next->merge);
+		ClearCompatInfo(info,xkb);
+	    }
+	    else if (ProcessIncludeFile(next,XkmCompatMapIndex,&rtrn,&op)) {
+		InitCompatInfo(&next_incl,xkb);
+		next_incl.fileID= rtrn->id;
+		next_incl.dflt= info->dflt;
+		next_incl.dflt.defs.fileID= rtrn->id;
+		next_incl.dflt.defs.merge= op;
+		next_incl.ledDflt.defs.fileID= rtrn->id;
+		next_incl.ledDflt.defs.merge= op;
+		next_incl.act= info->act;
+		(*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
+		MergeIncludedCompatMaps(&included,&next_incl,op);
+		ClearCompatInfo(&next_incl,xkb);
+	    }
+	    else {
+		info->errorCount+= 10;
+		return False;
+	    }
+	}
+    }
+    if (haveSelf)
+	*info= included;
+    else {
+	MergeIncludedCompatMaps(info,&included,newMerge);
+	ClearCompatInfo(&included,xkb);
+    }
+    return (info->errorCount==0);
+}
+
+static LookupEntry useModMapValues[] = {
+	{	"levelone",	1	},
+	{	"level1",	1	},
+	{	"anylevel",	0	},
+	{	"any",		0	},
+	{	NULL,		0	}
+};
+
+static int
+#if NeedFunctionPrototypes
+SetInterpField(	SymInterpInfo *	si,
+		XkbDescPtr	xkb,
+		char *		field,
+		ExprDef *	arrayNdx,
+		ExprDef *	value,
+		CompatInfo *	info)
+#else
+SetInterpField(si,xkb,field,arrayNdx,value,info)
+    SymInterpInfo *	si;
+    XkbDescPtr		xkb;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    CompatInfo *	info;
+#endif
+{
+int 		ok= 1;
+ExprResult	tmp;
+
+    if (uStrCaseCmp(field,"action")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportSINotArray(si,field,info);
+	ok= HandleActionDef(value,xkb,&si->interp.act,si->defs.merge,info->act);
+	if (ok) 
+	     si->defs.defined|= _SI_Action;
+    }
+    else if ((uStrCaseCmp(field,"virtualmodifier")==0)||
+	     (uStrCaseCmp(field,"virtualmod")==0)) {
+	if (arrayNdx!=NULL)
+	    return ReportSINotArray(si,field,info);
+	ok= ResolveVirtualModifier(value,&tmp,&info->vmods);
+	if (ok) {
+	    si->interp.virtual_mod= tmp.uval;
+	    si->defs.defined|= _SI_VirtualMod;
+	}
+	else return ReportSIBadType(si,field,"virtual modifier",info);
+    }
+    else if (uStrCaseCmp(field,"repeat")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportSINotArray(si,field,info);
+	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
+	if (ok) {
+	    if (tmp.uval)	si->interp.flags|= XkbSI_AutoRepeat;
+	    else		si->interp.flags&= ~XkbSI_AutoRepeat;
+	    si->defs.defined|= _SI_AutoRepeat;
+	}
+	else return ReportSIBadType(si,field,"boolean",info);
+    }
+    else if (uStrCaseCmp(field,"locking")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportSINotArray(si,field,info);
+	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
+	if (ok) {
+	    if (tmp.uval)	si->interp.flags|= XkbSI_LockingKey;
+	    else		si->interp.flags&= ~XkbSI_LockingKey;
+	    si->defs.defined|= _SI_LockingKey;
+	}
+	else return ReportSIBadType(si,field,"boolean",info);
+    }
+    else if ((uStrCaseCmp(field,"usemodmap")==0)||
+	 	(uStrCaseCmp(field,"usemodmapmods")==0)) {
+	if (arrayNdx!=NULL)
+	    return ReportSINotArray(si,field,info);
+	ok= ExprResolveEnum(value,&tmp,useModMapValues);
+	if (ok) {
+	    if (tmp.uval)	si->interp.match|= XkbSI_LevelOneOnly;
+	    else		si->interp.match&= ~XkbSI_LevelOneOnly;
+	    si->defs.defined|= _SI_LevelOneOnly;
+	}
+	else return ReportSIBadType(si,field,"level specification",info);
+    }
+    else {
+	ok= ReportBadField("symbol interpretation",field,siText(si,info));
+    }
+    return ok;
+}
+
+LookupEntry groupNames[]= {
+	{	"group1",	0x01	},
+	{	"group2",	0x02	},
+	{	"group3",	0x04	},
+	{	"group4",	0x08	},
+	{	"group5",	0x10	},
+	{	"group6",	0x20	},
+	{	"group7",	0x40	},
+	{	"group8",	0x80	},
+	{	"none",		0x00	},
+	{	"all",		0xff	},
+	{	NULL,		0	}
+};
+
+static int
+#if NeedFunctionPrototypes
+HandleInterpVar(VarDef *stmt,XkbDescPtr xkb,CompatInfo *info)
+#else
+HandleInterpVar(stmt,xkb,info)
+    VarDef *		stmt;
+    XkbDescPtr		xkb;
+    CompatInfo *	info;
+#endif
+{
+ExprResult	elem,field;
+ExprDef *	ndx;
+
+    if (ExprResolveLhs(stmt->name,&elem,&field,&ndx)==0) 
+	return 0; /* internal error, already reported */
+    if (elem.str&&(uStrCaseCmp(elem.str,"interpret")==0))
+	return SetInterpField(&info->dflt,xkb,field.str,ndx,stmt->value,info);	
+    if (elem.str&&(uStrCaseCmp(elem.str,"indicator")==0)) {
+	return SetIndicatorMapField(&info->ledDflt,xkb,field.str,ndx,
+								stmt->value);
+    }
+    return SetActionField(xkb,elem.str,field.str,ndx,stmt->value,&info->act);
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleInterpBody(VarDef *def,XkbDescPtr xkb,SymInterpInfo *si,CompatInfo *info)
+#else
+HandleInterpBody(def,xkb,si,info)
+    VarDef *		def;
+    XkbDescPtr		xkb;
+    SymInterpInfo *	si;
+    CompatInfo *	info;
+#endif
+{
+int		ok= 1;
+ExprResult	tmp,field;
+ExprDef *	arrayNdx;
+
+    for (;def!=NULL;def= (VarDef *)def->common.next) {
+	if ((def->name)&&(def->name->type==ExprFieldRef)) {
+	    ok= HandleInterpVar(def,xkb,info);
+	    continue;
+	}
+	ok= ExprResolveLhs(def->name,&tmp,&field,&arrayNdx);
+	if (ok)
+	    ok= SetInterpField(si,xkb,field.str,arrayNdx,def->value,info);
+    }
+    return ok;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleInterpDef(InterpDef *def,XkbDescPtr xkb,unsigned merge,CompatInfo *info)
+#else
+HandleInterpDef(def,xkb,merge,info)
+    InterpDef *		def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    CompatInfo *	info;
+#endif
+{
+unsigned		pred,mods;
+SymInterpInfo		si;
+ 
+    if (!ResolveStateAndPredicate(def->match,&pred,&mods,info)) {
+	ERROR("Couldn't determine matching modifiers\n");
+	ACTION("Symbol interpretation ignored\n");
+	return False;
+    }
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+
+    si= info->dflt;
+    si.defs.merge= merge;
+    si.interp.sym= def->sym;
+    si.interp.match= (si.interp.match&(~XkbSI_OpMask))|(pred&XkbSI_OpMask);
+    si.interp.mods= mods;
+    if (!HandleInterpBody(def->def,xkb,&si,info)) {
+	info->errorCount++;
+	return False;
+    }
+
+    if (!AddInterp(info,&si)) {
+	info->errorCount++;
+	return False;
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleGroupCompatDef(	GroupCompatDef *	def,
+			XkbDescPtr		xkb,
+			unsigned 		merge,
+			CompatInfo *		info)
+#else
+HandleGroupCompatDef(def,xkb,merge,info)
+    GroupCompatDef *	def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    CompatInfo *	info;
+#endif
+{
+ExprResult	val;
+GroupCompatInfo	tmp;
+
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+    if (!XkbIsLegalGroup(def->group-1)) {
+	ERROR1("Keyboard group must be in the range 1..%d\n",XkbNumKbdGroups+1);
+	ACTION1("Compatibility map for illegal group %d ignored\n",def->group);
+	return False;
+    }
+    tmp.fileID= info->fileID;
+    tmp.merge= merge;
+    if (!ExprResolveModMask(def->def,&val,LookupVModMask,(XPointer)xkb)) {
+	ERROR("Expected a modifier mask in group compatibility definition\n");
+	ACTION1("Ignoring illegal compatibility map for group %d\n",def->group);
+	return False;
+    }
+    tmp.real_mods= val.uval&0xff;
+    tmp.vmods= (val.uval>>8)&0xffff;
+    return AddGroupCompat(info,def->group-1,&tmp);
+}
+
+static void
+#if NeedFunctionPrototypes
+HandleCompatMapFile(	XkbFile	*	file,
+			XkbDescPtr 	 xkb,
+			unsigned	 merge,
+			CompatInfo *	info)
+#else
+HandleCompatMapFile(file,xkb,merge,info)
+    XkbFile		*file;
+    XkbDescPtr	 	 xkb;
+    unsigned		 merge;
+    CompatInfo	*info;
+#endif
+{
+ParseCommon	*stmt;
+
+    if (merge==MergeDefault)
+	merge= MergeAugment;
+    info->name= uStringDup(file->name);
+    stmt= file->defs;
+    while (stmt) {
+	switch (stmt->stmtType) {
+	    case StmtInclude:
+		if (!HandleIncludeCompatMap((IncludeStmt *)stmt,xkb,info,
+						HandleCompatMapFile))
+		    info->errorCount++;
+		break;
+	    case StmtInterpDef:
+		if (!HandleInterpDef((InterpDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtGroupCompatDef:
+		if (!HandleGroupCompatDef((GroupCompatDef*)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtIndicatorMapDef:
+		{
+		    LEDInfo *rtrn;
+		    rtrn= HandleIndicatorMapDef((IndicatorMapDef *)stmt,xkb,
+						&info->ledDflt,info->leds,
+						merge);
+		    if (rtrn!=NULL)
+		 	 info->leds= rtrn;
+		    else info->errorCount++;
+		}
+		break;
+	    case StmtVarDef:
+		if (!HandleInterpVar((VarDef *)stmt,xkb,info))
+		    info->errorCount++;
+		break;
+	    case StmtVModDef:
+		if (!HandleVModDef((VModDef *)stmt,merge,&info->vmods))
+		    info->errorCount++;
+		break;
+	    case StmtKeycodeDef:
+		ERROR("Interpretation files may not include other types\n");
+		ACTION("Ignoring definition of key name\n");
+		info->errorCount++;
+		break;
+	    default:
+		WSGO1("Unexpected statement type %d in HandleCompatMapFile\n",
+								stmt->stmtType);
+		break;
+	}
+	stmt= stmt->next;
+	if (info->errorCount>10) {
+#ifdef NOISY
+	    ERROR("Too many errors\n");
+#endif
+	    ACTION1("Abandoning compatibility map \"%s\"\n",file->topName);
+	    break;
+	}
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+CopyInterps(	CompatInfo *	info,
+		XkbCompatMapPtr	compat,
+		Bool		needSymbol,
+		unsigned	pred)
+#else
+CopyInterps(info,compat,needSymbol,pred)
+    CompatInfo *	info;
+    XkbCompatMapPtr	compat;
+    Bool		needSymbol;
+    unsigned		pred;
+#endif
+{
+SymInterpInfo *		si;
+
+    for (si=info->interps;si;si=(SymInterpInfo *)si->defs.next) {
+	if (((si->interp.match&XkbSI_OpMask)!=pred)||
+		(needSymbol&&(si->interp.sym==NoSymbol))||
+		((!needSymbol)&&(si->interp.sym!=NoSymbol)))
+	    continue;
+	if (compat->num_si>=compat->size_si) {
+	    WSGO("No room to merge symbol interpretations\n");
+	    ACTION("Symbol interpretations lost\n");
+	    return;
+	}
+	compat->sym_interpret[compat->num_si++]= si->interp;
+    }
+    return;
+}
+
+Bool
+#if NeedFunctionPrototypes
+CompileCompatMap(	XkbFile *	file,
+			XkbFileInfo *	result,
+			unsigned	merge,
+			LEDInfo **	unboundLEDs)
+#else
+CompileCompatMap(file,result,merge,unboundLEDs)
+    XkbFile *		file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+    LEDInfo **		unboundLEDs;
+#endif
+{
+int			i;
+CompatInfo		info;
+XkbDescPtr		xkb;
+GroupCompatInfo *	gcm;
+
+    xkb= result->xkb;
+    InitCompatInfo(&info,xkb);
+    info.dflt.defs.merge= merge;
+    info.ledDflt.defs.merge= merge;
+    HandleCompatMapFile(file,xkb,merge,&info);
+
+    if (info.errorCount==0) {
+	int size;
+	if (XkbAllocCompatMap(xkb,XkbAllCompatMask,info.nInterps)!=Success) {
+	    WSGO("Couldn't allocate compatibility map\n");
+	    ACTION("Exiting\n");
+	    return False;
+	}
+	if (info.name!=NULL) {
+	    if (XkbAllocNames(xkb,XkbCompatNameMask,0,0)==Success)
+		xkb->names->compat= XkbInternAtom(xkb->dpy,info.name,False);
+	    else {
+		WSGO("Couldn't allocate space for compat name\n");
+		ACTION2("Name \"%s\" (from %s) NOT assigned\n",scanFile,
+								info.name);
+	    }
+	}
+	size= info.nInterps*sizeof(XkbSymInterpretRec);
+	if (size>0) {
+	    CopyInterps(&info,xkb->compat,True,XkbSI_Exactly);
+	    CopyInterps(&info,xkb->compat,True,XkbSI_AllOf|XkbSI_NoneOf);
+	    CopyInterps(&info,xkb->compat,True,XkbSI_AnyOf);
+	    CopyInterps(&info,xkb->compat,True,XkbSI_AnyOfOrNone);
+	    CopyInterps(&info,xkb->compat,False,XkbSI_Exactly);
+	    CopyInterps(&info,xkb->compat,False,XkbSI_AllOf|XkbSI_NoneOf);
+	    CopyInterps(&info,xkb->compat,False,XkbSI_AnyOf);
+	    CopyInterps(&info,xkb->compat,False,XkbSI_AnyOfOrNone);
+	}
+	for (i=0,gcm=&info.groupCompat[0];i<XkbNumKbdGroups;i++,gcm++) {
+	    if ((gcm->fileID!=0)||(gcm->real_mods!=0)||(gcm->vmods!=0)) {
+	 	xkb->compat->groups[i].mask= gcm->real_mods;
+	 	xkb->compat->groups[i].real_mods= gcm->real_mods;
+	 	xkb->compat->groups[i].vmods= gcm->vmods;
+	    }
+	}
+	if (info.leds!=NULL) {
+	    if (!CopyIndicatorMapDefs(result,info.leds,unboundLEDs))
+		info.errorCount++;
+	    info.leds= NULL;
+	}
+	ClearCompatInfo(&info,xkb);
+	return True;
+    }
+    if (info.interps!=NULL)
+	uFree(info.interps);
+    return False;
+}
diff --git a/expr.c b/expr.c
new file mode 100644
index 0000000..0e1bded
--- /dev/null
+++ b/expr.c
@@ -0,0 +1,1106 @@
+/* $Xorg: expr.c,v 1.5 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+
+#include <ctype.h>
+
+/***====================================================================***/
+
+char *
+#if NeedFunctionPrototypes
+exprOpText(unsigned type)
+#else
+exprOpText(type)
+    unsigned type;
+#endif
+{
+static char buf[32];
+
+     switch (type) {
+	case ExprValue:
+	    strcpy(buf,"literal");
+	    break;
+	case ExprIdent:
+	    strcpy(buf,"identifier");
+	    break;
+	case ExprActionDecl:
+	    strcpy(buf,"action declaration");
+	    break;
+	case ExprFieldRef:
+	    strcpy(buf,"field reference");
+	    break;
+	case ExprArrayRef:
+	    strcpy(buf,"array reference");
+	    break;
+	case ExprKeysymList:
+	    strcpy(buf,"list of keysyms");
+	    break;
+	case ExprActionList:
+	    strcpy(buf,"list of actions");
+	    break;
+	case OpAdd:
+	    strcpy(buf,"addition");
+	    break;
+	case OpSubtract:
+	    strcpy(buf,"subtraction");
+	    break;
+	case OpMultiply:
+	    strcpy(buf,"multiplication");
+	    break;
+	case OpDivide:
+	    strcpy(buf,"division");
+	    break;
+	case OpAssign:
+	    strcpy(buf,"assignment");
+	    break;
+	case OpNot:
+	    strcpy(buf,"logical not");
+	    break;
+	case OpNegate:
+	    strcpy(buf,"arithmetic negation");
+	    break;
+	case OpInvert:
+	    strcpy(buf,"bitwise inversion");
+	    break;
+	case OpUnaryPlus:
+	    strcpy(buf,"plus sign");
+	    break;
+	default:
+	    sprintf(buf,"illegal(%d)",type);
+	    break;
+     }
+     return buf;
+}
+
+char *
+#if NeedFunctionPrototypes
+exprTypeText(unsigned type)
+#else
+exprTypeText(type)
+    unsigned type;
+#endif
+{
+static char buf[20];
+
+     switch (type) {
+	case TypeUnknown:
+	    strcpy(buf,"unknown");
+	    break;
+	case TypeBoolean:
+	    strcpy(buf,"boolean");
+	    break;
+	case TypeInt:
+	    strcpy(buf,"int");
+	    break;
+	case TypeString:
+	    strcpy(buf,"string");
+	    break;
+	case TypeAction:
+	    strcpy(buf,"action");
+	    break;
+	case TypeKeyName:
+	    strcpy(buf,"keyname");
+	    break;
+	default:
+	    sprintf(buf,"illegal(%d)",type);
+	    break;
+     }
+     return buf;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveLhs(	ExprDef *	expr,
+		ExprResult *	elem_rtrn,
+		ExprResult *	field_rtrn,
+		ExprDef **	index_rtrn)
+#else
+ExprResolveLhs(expr,elem_rtrn,field_rtrn,index_rtrn)
+    ExprDef *		expr;
+    ExprResult *	elem_rtrn;
+    ExprResult *	field_rtrn;
+    ExprDef **		index_rtrn;
+#endif
+{
+    switch (expr->op) {
+	case ExprIdent:
+	    elem_rtrn->str=  NULL;
+	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.str);
+	    *index_rtrn= NULL;
+	    return True;
+	case ExprFieldRef:
+	    elem_rtrn->str= XkbAtomGetString(NULL,expr->value.field.element);
+	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.field.field);
+	    *index_rtrn= NULL;
+	    return True;
+	case ExprArrayRef:
+	    elem_rtrn->str= XkbAtomGetString(NULL,expr->value.array.element);
+	    field_rtrn->str= XkbAtomGetString(NULL,expr->value.array.field);
+	    *index_rtrn= expr->value.array.entry;
+	    return True;
+    }
+    WSGO1("Unexpected operator %d in ResolveLhs\n",expr->op);
+    return False;
+}
+
+Bool
+#if NeedFunctionPrototypes
+SimpleLookup(	XPointer 	priv,
+		Atom		elem,
+		Atom		field,
+		unsigned	type,
+		ExprResult *	val_rtrn)
+#else
+SimpleLookup(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+LookupEntry *	entry;
+register char *	str;
+
+    if ((priv==NULL)||
+	(field==None)||(elem!=None)||
+	((type!=TypeInt)&&(type!=TypeFloat))) {
+	return False;
+    }
+    str= XkbAtomGetString(NULL,field);
+    for (entry=(LookupEntry *)priv;(entry!=NULL)&&(entry->name!=NULL);entry++) {
+	if (uStrCaseCmp(str,entry->name)==0) {
+	    val_rtrn->uval= entry->result;
+	    if (type==TypeFloat)
+		val_rtrn->uval*= XkbGeomPtsPerMM;
+	    return True;
+	}
+    }
+    return False;
+}
+
+Bool
+#if NeedFunctionPrototypes
+RadioLookup(	XPointer 	priv,
+		Atom		elem,
+		Atom		field,
+		unsigned	type,
+		ExprResult *	val_rtrn)
+#else
+RadioLookup(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+register char *	str;
+int		rg;
+
+    if ((field==None)||(elem!=None)||(type!=TypeInt))
+	return False;
+    str= XkbAtomGetString(NULL,field);
+    if (str) {
+	if (uStrCasePrefix("group",str))
+	    str+= strlen("group");
+	else if (uStrCasePrefix("radiogroup",str))
+	    str+= strlen("radiogroup");
+	else if (uStrCasePrefix("rg",str))
+	    str+= strlen("rg");
+	else if (!isdigit(str[0]))
+	    str= NULL;
+    }
+    if ((!str)||(sscanf(str,"%i",&rg)<1)||(rg<1)||(rg>XkbMaxRadioGroups))
+	return False;
+    val_rtrn->uval= rg;
+    return True;
+}
+
+int
+#if NeedFunctionPrototypes
+TableLookup(	XPointer 	priv,
+		Atom		elem,
+		Atom		field,
+		unsigned	type,
+		ExprResult *	val_rtrn)
+#else
+TableLookup(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+LookupTable *	tbl= (LookupTable *)priv;
+register char *	str;
+
+    if ((priv==NULL)||(field==None)||(type!=TypeInt))
+	return False;
+    str= XkbAtomGetString(NULL,elem);
+    while (tbl) {
+	if (((str==NULL)&&(tbl->element==NULL))||
+	    ((str!=NULL)&&(tbl->element!=NULL)&&
+			  (uStrCaseCmp(str,tbl->element)==0))) {
+	    break;
+	}
+	tbl= tbl->nextElement;
+    }
+    if (tbl==NULL)	/* didn't find a matching element */
+	return False;
+    priv= (XPointer)tbl->entries;
+    return SimpleLookup(priv,(Atom)None,field,type,val_rtrn);
+}
+
+static LookupEntry modIndexNames[] = {
+	{	"shift",	ShiftMapIndex 	},
+	{	"control",	ControlMapIndex	},
+	{	"lock",		LockMapIndex	},
+	{	"mod1",		Mod1MapIndex	},
+	{	"mod2",		Mod2MapIndex	},
+	{	"mod3",		Mod3MapIndex	},
+	{	"mod4",		Mod4MapIndex	},
+	{	"mod5",		Mod5MapIndex	},
+	{	NULL,		0		}
+};
+
+int
+#if NeedFunctionPrototypes
+LookupModIndex(	XPointer 	priv,
+		Atom		elem,
+		Atom		field,
+		unsigned	type,
+		ExprResult *	val_rtrn)
+#else
+LookupModIndex(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+    return SimpleLookup((XPointer)modIndexNames,elem,field,type,val_rtrn);
+}
+
+int
+#if NeedFunctionPrototypes
+LookupModMask(	XPointer 	priv,
+		Atom		elem,
+		Atom		field,
+		unsigned	type,
+    		ExprResult *	val_rtrn)
+#else
+LookupModMask(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+char *str;
+
+    if ((elem!=None)||(type!=TypeInt))
+	return False;
+    str= XkbAtomGetString(NULL,field);
+    if (str==NULL)
+	 return False;
+    if (uStrCaseCmp(str,"all")==0)
+	 val_rtrn->uval= 0xff;
+    else if (uStrCaseCmp(str,"none")==0)
+	 val_rtrn->uval= 0;
+    else if (LookupModIndex(priv,elem,field,type,val_rtrn))
+	 val_rtrn->uval= (1<<val_rtrn->uval);
+    else if (priv != NULL) {
+	LookupPriv *lpriv= (LookupPriv *)priv;
+	if ((lpriv->chain==NULL)||
+	    (!(*lpriv->chain)(lpriv->chainPriv,elem,field,type,val_rtrn)))
+	    return False;
+    }
+    else return False;
+    return True;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveModIndex(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveModIndex(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+char		*bogus= NULL;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type!=TypeInt) {
+		ERROR1("Found constant of type %s where a modifier mask was expected\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    else if ((expr->value.ival>=XkbNumModifiers)||(expr->value.ival<0)){
+		ERROR2("Illegal modifier index (%d, must be 0..%d)\n",
+					expr->value.ival,XkbNumModifiers-1);
+		return False;
+	    }
+	    val_rtrn->ival= expr->value.ival;
+	    return True;
+	case ExprIdent:
+	    if (LookupModIndex(lookupPriv,(Atom)None,expr->value.str,
+				 		(unsigned)TypeInt,val_rtrn)) {
+		return True;
+	    }
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeInt,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Cannot determine modifier index for \"%s\"\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    break;
+	case ExprFieldRef:
+	    bogus= "field reference";
+	    break;
+	case ExprArrayRef:
+	    bogus= "array reference";
+	    break;
+	case ExprActionDecl:
+	    bogus= "function";
+	    break;
+	case OpAdd:
+	case OpSubtract:
+	case OpMultiply:
+	case OpDivide:
+	case OpInvert:
+	case OpNegate:
+	case OpNot:
+	case OpUnaryPlus:
+	    bogus= "arithmetic operations";
+	    break;
+	case OpAssign:
+	    bogus= "assignment";
+	    break;
+	default:
+	    WSGO1("Unknown operator %d in ResolveModIndex\n",expr->op);
+	    return False;
+    }
+    if (bogus) {
+	ERROR1("Modifier index must be a name or number, %s ignored\n",bogus);
+	return False;
+    }
+    return ok;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveModMask(	ExprDef *		expr,
+			ExprResult *		val_rtrn,
+			IdentLookupFunc		lookup,
+			XPointer		lookupPriv)
+#else
+ExprResolveModMask(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+LookupPriv	priv;
+
+    priv.priv= NULL;
+    priv.chain= lookup;
+    priv.chainPriv= lookupPriv;
+    return ExprResolveMask(expr,val_rtrn,LookupModMask,(XPointer)&priv);
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveBoolean(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveBoolean(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+char *	bogus= NULL;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type!=TypeBoolean) {
+		ERROR1("Found constant of type %s where boolean was expected\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    val_rtrn->ival= expr->value.ival;
+	    return True;
+	case ExprIdent:
+	    bogus= XkbAtomGetString(NULL,expr->value.str);
+	    if (bogus) {
+		if ((uStrCaseCmp(bogus,"true")==0)||
+				(uStrCaseCmp(bogus,"yes")==0)||
+				(uStrCaseCmp(bogus,"on")==0)) {
+		    val_rtrn->uval= 1;
+		    return True;
+		}
+		else if ((uStrCaseCmp(bogus,"false")==0)||
+				(uStrCaseCmp(bogus,"no")==0)||
+				(uStrCaseCmp(bogus,"off")==0)) {
+		    val_rtrn->uval= 0;
+		    return True;
+		}
+	    }
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeBoolean,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Identifier \"%s\" of type int is unknown\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeBoolean,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Default \"%s.%s\" of type boolean is unknown\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case OpInvert: 
+	case OpNot:
+	    ok= ExprResolveBoolean(expr,val_rtrn,lookup,lookupPriv);
+	    if (ok)
+		val_rtrn->uval= !val_rtrn->uval;
+	    return ok;
+	case OpAdd:	 if (bogus==NULL) 	bogus= "Addition";
+	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
+	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
+	case OpDivide:   if (bogus==NULL)	bogus= "Division";
+	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
+	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
+	    ERROR1("%s of boolean values not permitted\n",bogus);
+	    break;
+	case OpUnaryPlus:
+	    ERROR("Unary \"+\" operator not permitted for boolean values\n");
+	    break;
+	default:
+	    WSGO1("Unknown operator %d in ResolveBoolean\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveFloat(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveFloat(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+ExprResult	leftRtrn,rightRtrn;
+ExprDef		*left,*right;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type==TypeString) {
+		register char *str;
+		str= XkbAtomGetString(NULL,expr->value.str);
+		if ((str!=None)&&(strlen(str)==1)) {
+		    val_rtrn->uval= str[0]*XkbGeomPtsPerMM;
+		    return True;
+		}
+	    }
+	    if ((expr->type!=TypeInt)&&(expr->type!=TypeFloat)) {
+		ERROR1("Found constant of type %s, expected a number\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    val_rtrn->ival= expr->value.ival;
+	    if (expr->type==TypeInt)
+		val_rtrn->ival*= XkbGeomPtsPerMM;
+	    return True;
+	case ExprIdent:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeFloat,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Numeric identifier \"%s\" unknown\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeFloat,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Numeric default \"%s.%s\" unknown\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case OpAdd:
+	case OpSubtract:
+	case OpMultiply:
+	case OpDivide:
+	    left= expr->value.binary.left;
+	    right= expr->value.binary.right;
+	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)&&
+		ExprResolveFloat(right,&rightRtrn,lookup,lookupPriv)) {
+		switch (expr->op) {
+		    case OpAdd: 
+			val_rtrn->ival= leftRtrn.ival+rightRtrn.ival;
+			break;
+		    case OpSubtract: 
+			val_rtrn->ival= leftRtrn.ival-rightRtrn.ival;
+			break;
+		    case OpMultiply: 
+			val_rtrn->ival= leftRtrn.ival*rightRtrn.ival;
+			break;
+		    case OpDivide: 
+			val_rtrn->ival= leftRtrn.ival/rightRtrn.ival;
+			break;
+		}
+		return True;
+	    }
+	    return False;
+	case OpAssign:
+	    WSGO("Assignment operator not implemented yet\n");
+	    break;
+	case OpNot:
+	    left= expr->value.child;
+	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The ! operator cannot be applied to a number\n");
+	    }
+	    return False;
+	case OpInvert:
+	case OpNegate:
+	    left= expr->value.child;
+	    if (ExprResolveFloat(left,&leftRtrn,lookup,lookupPriv)) {
+		if (expr->op==OpNegate)	
+		     val_rtrn->ival= -leftRtrn.ival;
+		else val_rtrn->ival= ~leftRtrn.ival;
+		return True;
+	    }
+	    return False;
+	case OpUnaryPlus:
+	    left= expr->value.child;
+	    return ExprResolveFloat(left,val_rtrn,lookup,lookupPriv);
+	default:
+	    WSGO1("Unknown operator %d in ResolveFloat\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveInteger(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveInteger(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+ExprResult	leftRtrn,rightRtrn;
+ExprDef		*left,*right;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type==TypeString) {
+		register char *str;
+		str= XkbAtomGetString(NULL,expr->value.str);
+		if ((str!=None)&&(strlen(str)==1)) {
+		    val_rtrn->uval= str[0];
+		    return True;
+		}
+	    }
+	    if ((expr->type!=TypeInt)&&(expr->type!=TypeFloat)) {
+		ERROR1("Found constant of type %s where an int was expected\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    val_rtrn->ival= expr->value.ival;
+	    if (expr->type==TypeFloat)
+		val_rtrn->ival/= XkbGeomPtsPerMM;
+	    return True;
+	case ExprIdent:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeInt,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Identifier \"%s\" of type int is unknown\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeInt,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Default \"%s.%s\" of type int is unknown\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case OpAdd:
+	case OpSubtract:
+	case OpMultiply:
+	case OpDivide:
+	    left= expr->value.binary.left;
+	    right= expr->value.binary.right;
+	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)&&
+		ExprResolveInteger(right,&rightRtrn,lookup,lookupPriv)) {
+		switch (expr->op) {
+		    case OpAdd: 
+			val_rtrn->ival= leftRtrn.ival+rightRtrn.ival;
+			break;
+		    case OpSubtract: 
+			val_rtrn->ival= leftRtrn.ival-rightRtrn.ival;
+			break;
+		    case OpMultiply: 
+			val_rtrn->ival= leftRtrn.ival*rightRtrn.ival;
+			break;
+		    case OpDivide: 
+			val_rtrn->ival= leftRtrn.ival/rightRtrn.ival;
+			break;
+		}
+		return True;
+	    }
+	    return False;
+	case OpAssign:
+	    WSGO("Assignment operator not implemented yet\n");
+	    break;
+	case OpNot:
+	    left= expr->value.child;
+	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The ! operator cannot be applied to an integer\n");
+	    }
+	    return False;
+	case OpInvert:
+	case OpNegate:
+	    left= expr->value.child;
+	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
+		if (expr->op==OpNegate)	
+		     val_rtrn->ival= -leftRtrn.ival;
+		else val_rtrn->ival= ~leftRtrn.ival;
+		return True;
+	    }
+	    return False;
+	case OpUnaryPlus:
+	    left= expr->value.child;
+	    return ExprResolveInteger(left,val_rtrn,lookup,lookupPriv);
+	default:
+	    WSGO1("Unknown operator %d in ResolveInteger\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveString(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveString(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int		ok= 0;
+ExprResult	leftRtrn,rightRtrn;
+ExprDef	*	left;
+ExprDef *	right;
+char *		bogus= NULL;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type!=TypeString) {
+		ERROR1("Found constant of type %s, expected a string\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    val_rtrn->str= XkbAtomGetString(NULL,expr->value.str);
+	    if (val_rtrn->str==NULL) {
+		static char *empty= "";
+		val_rtrn->str= empty;
+	    }
+	    return True;
+	case ExprIdent:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeString,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Identifier \"%s\" of type string not found\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeString,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Default \"%s.%s\" of type string not found\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case OpAdd:
+	    left= expr->value.binary.left;
+	    right= expr->value.binary.right;
+	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)&&
+		ExprResolveString(right,&rightRtrn,lookup,lookupPriv)) {
+		int len;
+		char *new;
+		len= strlen(leftRtrn.str)+strlen(rightRtrn.str)+1;
+		new= (char *)uAlloc(len);
+		if (new) {
+		    sprintf(new,"%s%s",leftRtrn.str,rightRtrn.str);
+		    val_rtrn->str= new;
+		    return True;
+		}
+	    }
+	    return False;
+	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
+	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
+	case OpDivide:   if (bogus==NULL)	bogus= "Division";
+	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
+	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
+	case OpInvert:	 if (bogus==NULL)	bogus= "Bitwise complement";
+	    ERROR1("%s of string values not permitted\n",bogus);
+	    return False;
+	case OpNot:	 
+	    left= expr->value.child;
+	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The ! operator cannot be applied to a string\n");
+	    }
+	    return False;
+	case OpUnaryPlus:
+	    left= expr->value.child;
+	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The + operator cannot be applied to a string\n");
+	    }
+	    return False;
+	default:
+	    WSGO1("Unknown operator %d in ResolveString\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveKeyName(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveKeyName(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int		ok= 0;
+ExprDef	*	left;
+ExprResult 	leftRtrn;
+char *		bogus= NULL;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type!=TypeKeyName) {
+		ERROR1("Found constant of type %s, expected a key name\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    memcpy(val_rtrn->keyName.name,expr->value.keyName,XkbKeyNameLength);
+	    return True;
+	case ExprIdent:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeString,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Identifier \"%s\" of type string not found\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeString,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Default \"%s.%s\" of type key name not found\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case OpAdd:	 if (bogus==NULL)	bogus= "Addition";
+	case OpSubtract: if (bogus==NULL)	bogus= "Subtraction";
+	case OpMultiply: if (bogus==NULL)	bogus= "Multiplication";
+	case OpDivide:   if (bogus==NULL)	bogus= "Division";
+	case OpAssign:   if (bogus==NULL)	bogus= "Assignment";
+	case OpNegate:	 if (bogus==NULL)	bogus= "Negation";
+	case OpInvert:	 if (bogus==NULL)	bogus= "Bitwise complement";
+	    ERROR1("%s of key name values not permitted\n",bogus);
+	    return False;
+	case OpNot:	 
+	    left= expr->value.binary.left;
+	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The ! operator cannot be applied to a key name\n");
+	    }
+	    return False;
+	case OpUnaryPlus:
+	    left= expr->value.binary.left;
+	    if (ExprResolveString(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR("The + operator cannot be applied to a key name\n");
+	    }
+	    return False;
+	default:
+	    WSGO1("Unknown operator %d in ResolveKeyName\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+/***====================================================================***/
+
+int
+#if NeedFunctionPrototypes
+ExprResolveEnum(ExprDef *expr,ExprResult *val_rtrn,LookupEntry	*values)
+#else
+ExprResolveEnum(expr,val_rtrn,values)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    LookupEntry	*	values;
+#endif
+{
+    if (expr->op!=ExprIdent) {
+	ERROR1("Found a %s where an enumerated value was expected\n",
+							exprOpText(expr->op));
+	return False;
+    }
+    if (!SimpleLookup((XPointer)values,(Atom)None,expr->value.str,
+						(unsigned)TypeInt,val_rtrn)) {
+	int	nOut=0;
+	ERROR1("Illegal identifier %s (expected one of: ",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	while (values && values->name) {
+	    if (nOut!=0)	INFO1(", %s",values->name);
+	    else		INFO1("%s",values->name);
+	}
+	INFO(")\n");
+	return False;
+    }
+    return True;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveMask(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveMask(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+ExprResult	leftRtrn,rightRtrn;
+ExprDef		*left,*right;
+char *		bogus= NULL;
+
+    switch (expr->op) {
+	case ExprValue:
+	    if (expr->type!=TypeInt) {
+		ERROR1("Found constant of type %s where a mask was expected\n",
+						exprTypeText(expr->type));
+		return False;
+	    }
+	    val_rtrn->ival= expr->value.ival;
+	    return True;
+	case ExprIdent:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+				 None,expr->value.str,
+				 TypeInt,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR1("Identifier \"%s\" of type int is unknown\n",
+				XkbAtomText(NULL,expr->value.str,XkbMessage));
+	    return ok;
+	case ExprFieldRef:
+	    if (lookup) {
+		ok= (*lookup)(lookupPriv,
+			 expr->value.field.element,expr->value.field.field,
+			 TypeInt,val_rtrn);
+	    }
+	    if (!ok)
+		ERROR2("Default \"%s.%s\" of type int is unknown\n",
+			XkbAtomText(NULL,expr->value.field.element,XkbMessage),
+			XkbAtomText(NULL,expr->value.field.field,XkbMessage));
+	    return ok;
+	case ExprArrayRef:
+	    bogus= "array reference";
+	case ExprActionDecl:
+	    if (bogus==NULL)
+		bogus= "function use";
+	    ERROR1("Unexpected %s in mask expression\n",bogus);
+	    ACTION("Expression ignored\n");
+	    return False;
+	case OpAdd:
+	case OpSubtract:
+	case OpMultiply:
+	case OpDivide:
+	    left= expr->value.binary.left;
+	    right= expr->value.binary.right;
+	    if (ExprResolveMask(left,&leftRtrn,lookup,lookupPriv)&&
+		ExprResolveMask(right,&rightRtrn,lookup,lookupPriv)) {
+		switch (expr->op) {
+		    case OpAdd: 
+			val_rtrn->ival= leftRtrn.ival|rightRtrn.ival;
+			break;
+		    case OpSubtract: 
+			val_rtrn->ival= leftRtrn.ival&(~rightRtrn.ival);
+			break;
+		    case OpMultiply: 
+		    case OpDivide: 
+			ERROR1("Cannot %s masks\n",
+					expr->op==OpDivide?"divide":"multiply");
+			ACTION("Illegal operation ignored\n");
+			return False;
+		}
+		return True;
+	    }
+	    return False;
+	case OpAssign:
+	    WSGO("Assignment operator not implemented yet\n");
+	    break;
+	case OpInvert:
+	    left= expr->value.child;
+	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
+		val_rtrn->ival= ~leftRtrn.ival;
+		return True;
+	    }
+	    return False;
+	case OpUnaryPlus:
+	case OpNegate:
+	case OpNot:
+	    left= expr->value.child;
+	    if (ExprResolveInteger(left,&leftRtrn,lookup,lookupPriv)) {
+		ERROR1("The %s operator cannot be used with a mask\n",
+					(expr->op==OpNegate?"-":"!"));
+	    }
+	    return False;
+	default:
+	    WSGO1("Unknown operator %d in ResolveMask\n",expr->op);
+	    break;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ExprResolveKeySym(	ExprDef *	expr,
+			ExprResult *	val_rtrn,
+			IdentLookupFunc	lookup,
+			XPointer	lookupPriv)
+#else
+ExprResolveKeySym(expr,val_rtrn,lookup,lookupPriv)
+    ExprDef *		expr;
+    ExprResult *	val_rtrn;
+    IdentLookupFunc	lookup;
+    XPointer		lookupPriv;
+#endif
+{
+int	ok= 0;
+KeySym	sym;
+
+    if (expr->op==ExprIdent) {
+	char *str;
+	str= XkbAtomGetString(NULL,expr->value.str);
+	if ((str!=NULL)&&((sym= XStringToKeysym(str))!=NoSymbol)) {
+	    val_rtrn->uval= sym;
+	    return True;
+	}
+    }
+    ok= ExprResolveInteger(expr,val_rtrn,lookup,lookupPriv);
+    if ((ok)&&(val_rtrn->uval<10))
+	val_rtrn->uval+= '0';
+    return ok;
+}
diff --git a/expr.h b/expr.h
new file mode 100644
index 0000000..53263b8
--- /dev/null
+++ b/expr.h
@@ -0,0 +1,234 @@
+/* $Xorg: expr.h,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 EXPR_H
+#define EXPR_H 1
+
+typedef union _ExprResult  {
+    char *		str;
+    int			ival;
+    unsigned		uval;
+    XkbKeyNameRec	keyName;
+} ExprResult;
+
+_XFUNCPROTOBEGIN
+
+typedef	Bool	(*IdentLookupFunc)(
+#if NeedFunctionPrototypes
+	XPointer	/* priv */,
+	Atom		/* elem */,
+	Atom		/* field */,
+	unsigned	/* type */,
+	ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern	char *exprTypeText(
+#if NeedFunctionPrototypes
+    unsigned 		/* type */
+#endif
+);
+
+_XFUNCPROTOEND
+
+extern	int ExprResolveLhs(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* elem_rtrn */,
+    ExprResult *	/* field_rtrn */,
+    ExprDef **		/* index_rtrn */
+#endif
+);
+
+typedef	struct _LookupPriv {
+    XPointer 		priv;
+    IdentLookupFunc	chain;
+    XPointer 		chainPriv;
+} LookupPriv;
+
+typedef struct _LookupEntry {
+    char *	name;
+    unsigned	result;
+} LookupEntry;
+
+typedef struct _LookupTable {
+    char *	 		element;
+    LookupEntry	*		entries;
+    struct _LookupTable *	nextElement;
+} LookupTable;
+
+_XFUNCPROTOBEGIN
+
+
+extern char *exprOpText(
+#if NeedFunctionPrototypes
+    unsigned 		/* type */
+#endif
+);
+
+extern int RadioLookup(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int SimpleLookup(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int TableLookup(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int LookupModIndex(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int LookupModMask(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int ExprResolveModIndex(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveModMask(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* priv */
+#endif
+);
+
+extern int ExprResolveBoolean(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveInteger(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveFloat(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveString(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveKeyName(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveEnum(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    LookupEntry	*	/* values */
+#endif
+);
+
+extern int ExprResolveMask(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+extern int ExprResolveKeySym(
+#if NeedFunctionPrototypes
+    ExprDef *		/* expr */,
+    ExprResult *	/* val_rtrn */,
+    IdentLookupFunc	/* lookup */,
+    XPointer		/* lookupPriv */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* EXPR_H */
diff --git a/geometry.c b/geometry.c
new file mode 100644
index 0000000..3e84a96
--- /dev/null
+++ b/geometry.c
@@ -0,0 +1,3782 @@
+/* $Xorg: geometry.c,v 1.3 2000/08/17 19:54:30 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "misc.h"
+#include "indicators.h"
+#include "action.h"
+#include "keycodes.h"
+#include "alias.h"
+
+#include "X11/extensions/XKBgeom.h"
+
+#define	DFLT_FONT	"helvetica"
+#define	DFLT_SLANT	"r"
+#define	DFLT_WEIGHT	"medium"
+#define	DFLT_SET_WIDTH	"normal"
+#define	DFLT_VARIANT	""
+#define	DFLT_ENCODING	"iso8859-1"
+#define	DFLT_SIZE	120
+
+typedef struct _PropertyInfo {
+    CommonInfo		defs;
+    char *		name;
+    char *		value;
+} PropertyInfo;
+
+#define	_GSh_Outlines	(1<<1)
+#define	_GSh_Approx	(1<<2)
+#define	_GSh_Primary	(1<<3)
+typedef struct _ShapeInfo {
+    CommonInfo		defs;
+    Atom		name;
+    short		index;
+    unsigned short	nOutlines;
+    unsigned short	szOutlines;
+    XkbOutlinePtr	outlines;
+    XkbOutlinePtr	approx;
+    XkbOutlinePtr	primary;
+    int			dfltCornerRadius;
+} ShapeInfo;
+
+#define	shText(d,s)	\
+		((s)?XkbAtomText((d),(s)->name,XkbMessage):"default shape")
+
+#define	_GD_Priority	(1<<0)
+#define	_GD_Top		(1<<1)
+#define	_GD_Left	(1<<2)
+#define	_GD_Angle	(1<<3)
+#define	_GD_Shape	(1<<4)
+#define	_GD_FontVariant	(1<<4)	/* CHEATING */
+#define	_GD_Corner	(1<<5)
+#define	_GD_Width	(1<<5)	/* CHEATING */
+#define	_GD_Color	(1<<6)
+#define	_GD_OffColor	(1<<7)
+#define	_GD_Height	(1<<7)	/* CHEATING */
+#define	_GD_Text	(1<<8)
+#define	_GD_Font	(1<<9)
+#define	_GD_FontSlant	(1<<10)
+#define	_GD_FontWeight	(1<<11)
+#define	_GD_FontSetWidth (1<<12)
+#define	_GD_FontSize	(1<<13)
+#define	_GD_FontEncoding (1<<14)
+#define	_GD_FontSpec	(1<<15)
+
+
+#define	_GD_FontParts	(_GD_Font|_GD_FontSlant|_GD_FontWeight|_GD_FontSetWidth|_GD_FontSize|_GD_FontEncoding|_GD_FontVariant)
+
+typedef struct _DoodadInfo {
+    CommonInfo		defs;
+    Atom		name;
+    unsigned char	type;
+    unsigned char	priority;
+    short		top;
+    short		left;
+    short		angle;
+    unsigned short	corner;
+    unsigned short	width;
+    unsigned short	height;
+    Atom		shape;
+    Atom		color;
+    Atom		offColor;
+    Atom		text;
+    Atom		font;
+    Atom		fontSlant;
+    Atom		fontWeight;
+    Atom		fontSetWidth;
+    Atom		fontVariant;
+    unsigned short	fontSize;
+    Atom		fontEncoding;
+    Atom		fontSpec;
+    char *		logoName;
+    struct _SectionInfo *section;
+} DoodadInfo;
+
+#define	Yes		1
+#define	No		0
+#define	Undefined	-1
+
+#define	_GK_Default	(1<<0)
+#define	_GK_Name	(1<<1)
+#define	_GK_Gap		(1<<2)
+#define	_GK_Shape	(1<<3)
+#define	_GK_Color	(1<<4)
+typedef struct _KeyInfo {
+    CommonInfo		defs;
+    char		name[8];
+    short		gap;
+    short		index;
+    Atom		shape;
+    Atom		color;
+    struct _RowInfo *	row;
+} KeyInfo;
+#define	keyText(k)	((k)&&(k)->name[0]?(k)->name:"default")
+
+#define	_GR_Default	(1<<0)
+#define	_GR_Vertical	(1<<1)
+#define	_GR_Top		(1<<2)
+#define	_GR_Left	(1<<3)
+typedef struct _RowInfo {
+    CommonInfo		defs;
+    unsigned short	top;
+    unsigned short	left;
+    short		index;
+    Bool		vertical;
+    unsigned short	nKeys;
+    KeyInfo *		keys;
+    KeyInfo		dfltKey;
+    struct _SectionInfo *section;
+} RowInfo;
+#define	rowText(d,r)	\
+	((r)?XkbAtomText((d),(r)->section->name,XkbMessage):"default")
+
+#define	_GOK_UnknownRow	-1
+typedef struct _OverlayKeyInfo {
+	CommonInfo	defs;
+	short		sectionRow;
+	short		overlayRow;
+	char		over[XkbKeyNameLength+1];
+	char		under[XkbKeyNameLength+1];
+} OverlayKeyInfo;
+
+typedef struct _OverlayInfo {
+	CommonInfo	defs;
+	Atom		name;
+	unsigned short	nRows;
+	unsigned short	nKeys;
+	OverlayKeyInfo *keys;
+} OverlayInfo;
+#define	oiText(d,o)	((o)?XkbAtomText((d),(o)->name,XkbMessage):"default")
+
+
+#define	_GS_Default	(1<<0)
+#define	_GS_Name	(1<<1)
+#define	_GS_Top		(1<<2)
+#define	_GS_Left	(1<<3)
+#define	_GS_Width	(1<<4)
+#define	_GS_Height	(1<<5)
+#define	_GS_Angle	(1<<6)
+#define	_GS_Priority	(1<<7)
+typedef struct _SectionInfo {
+    CommonInfo		defs;
+    Atom		name;
+    unsigned short	top;
+    unsigned short	left;
+    unsigned short	width;
+    unsigned short	height;
+    unsigned short	angle;
+    unsigned short	nRows;
+    unsigned short	nDoodads;
+    unsigned short	nOverlays;
+    unsigned char	priority;
+    unsigned char	nextDoodadPriority;
+    RowInfo *		rows;
+    DoodadInfo *	doodads;
+    RowInfo		dfltRow;
+    DoodadInfo *	dfltDoodads;
+    OverlayInfo *	overlays;
+    struct _GeometryInfo *geometry;
+} SectionInfo;
+#define	scText(d,s)	((s)?XkbAtomText((d),(s)->name,XkbMessage):"default")
+
+typedef struct _GeometryInfo {
+    char *		name;
+    Display *		dpy;
+    unsigned 		fileID;
+    unsigned		merge;
+    int			errorCount;
+    unsigned		nextPriority;
+    int			nProps;
+    int			nShapes;
+    int			nSections;
+    int			nDoodads;
+    PropertyInfo *	props;
+    ShapeInfo *		shapes;
+    SectionInfo *	sections;
+    DoodadInfo *	doodads;
+    int			widthMM;
+    int			heightMM;
+    Atom		font;
+    Atom		fontSlant;
+    Atom		fontWeight;
+    Atom		fontSetWidth;
+    Atom		fontVariant;
+    unsigned		fontSize;
+    Atom		fontEncoding;
+    Atom		fontSpec;
+    Atom		baseColor;
+    Atom		labelColor;
+    int			dfltCornerRadius;
+    SectionInfo		dfltSection;
+    DoodadInfo *	dfltDoodads;
+    AliasInfo *		aliases;
+} GeometryInfo;
+
+static char *
+#if NeedFunctionPrototypes
+ddText(Display *dpy,DoodadInfo *di)
+#else
+ddText(dpy,di)
+    Display *		dpy;
+    DoodadInfo *	di;
+#endif
+{
+static char	buf[64];
+
+    if (di==NULL) {
+	strcpy(buf,"default");
+	return buf;
+    }
+    if (di->section) {
+	 sprintf(buf,"%s in section %s",XkbAtomText(dpy,di->name,XkbMessage),
+	 				scText(dpy,di->section));
+	 return buf;
+    }
+    return XkbAtomText(dpy,di->name,XkbMessage);
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+InitPropertyInfo(PropertyInfo *pi,GeometryInfo *info)
+#else
+InitPropertyInfo(pi,info)
+    PropertyInfo *	pi;
+    GeometryInfo *	info;
+#endif
+{
+    pi->defs.defined= 0;
+    pi->defs.fileID= info->fileID;
+    pi->defs.merge= info->merge;
+    pi->name= pi->value= NULL;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeProperties(PropertyInfo *pi,GeometryInfo *info)
+#else
+FreeProperties(pi,info)
+    PropertyInfo *	pi;
+    GeometryInfo *	info;
+#endif
+{
+PropertyInfo *	tmp;
+PropertyInfo *	next;
+
+    if (info->props==pi) {
+	info->props= NULL;
+	info->nProps= 0;
+    }
+    for (tmp=pi;tmp!=NULL;tmp=next) {
+	if (pi->name)
+	    uFree(pi->name);
+	if (pi->value)
+	    uFree(pi->value);
+	pi->name= pi->value=NULL;
+	next= (PropertyInfo *)tmp->defs.next;
+	uFree(tmp);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitKeyInfo(KeyInfo *key,RowInfo *row,GeometryInfo *info)
+#else
+InitKeyInfo(key,row,info)
+    KeyInfo *		key;
+    RowInfo *		row;
+    GeometryInfo *	info;
+#endif
+{
+
+    if (key!=&row->dfltKey) {
+	*key= row->dfltKey;
+	strcpy(key->name,"unknown");
+	key->defs.defined&= ~_GK_Default;
+    }
+    else {
+	bzero(key,sizeof(KeyInfo));
+	strcpy(key->name,"default");
+	key->defs.defined= _GK_Default;
+	key->defs.fileID= info->fileID;
+	key->defs.merge= info->merge;
+	key->defs.next= NULL;
+	key->row= row;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearKeyInfo(KeyInfo *key)
+#else
+ClearKeyInfo(key)
+    KeyInfo *		key;
+#endif
+{
+    key->defs.defined&= ~_GK_Default;
+    strcpy(key->name,"default");
+    key->gap= 0;
+    key->shape= None;
+    key->color= None;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeKeys(KeyInfo *key,RowInfo *row,GeometryInfo *info)
+#else
+FreeKeys(key,row,info)
+    KeyInfo *		key;
+    RowInfo *		row;
+    GeometryInfo *	info;
+#endif
+{
+KeyInfo *	tmp;
+KeyInfo *	next;
+
+    if (row->keys==key) {
+	row->nKeys= 0;
+	row->keys= NULL;
+    }
+    for (tmp=key;tmp!=NULL;tmp=next) {
+	ClearKeyInfo(tmp);
+	next= (KeyInfo *)tmp->defs.next;
+	uFree(tmp);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitRowInfo(RowInfo *row,SectionInfo *section,GeometryInfo *info)
+#else
+InitRowInfo(row,section,info)
+    RowInfo *		row;
+    SectionInfo *	section;
+    GeometryInfo *	info;
+#endif
+{
+    if (row!= &section->dfltRow) {
+	*row= section->dfltRow;
+	row->defs.defined&= ~_GR_Default;
+    }
+    else {
+	bzero(row,sizeof(RowInfo *));
+	row->defs.defined= _GR_Default;
+	row->defs.fileID= info->fileID;
+	row->defs.merge= info->merge;
+	row->defs.next= NULL;
+	row->section= section;
+	row->nKeys= 0;
+	row->keys= NULL;
+	InitKeyInfo(&row->dfltKey,row,info);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearRowInfo(RowInfo *row,GeometryInfo *info)
+#else
+ClearRowInfo(row,info)
+    RowInfo *		row;
+    GeometryInfo *	info;
+#endif
+{
+    row->defs.defined&= ~_GR_Default;
+    row->top= row->left= 0;
+    row->vertical= False;
+    row->nKeys= 0;
+    if (row->keys)
+	FreeKeys(row->keys,row,info);
+    ClearKeyInfo(&row->dfltKey);
+    row->dfltKey.defs.defined|= _GK_Default;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeRows(RowInfo *row,SectionInfo *section,GeometryInfo *info)
+#else
+FreeRows(row,section,info)
+    RowInfo *		row;
+    SectionInfo *	section;
+    GeometryInfo *	info;
+#endif
+{
+RowInfo *	next;
+RowInfo *	tmp;
+
+    if (row==section->rows) {
+	section->nRows= 0;
+	section->rows= NULL;
+    }
+    for (tmp=row;tmp!=NULL;tmp=next) {
+	ClearRowInfo(tmp,info);
+	next= (RowInfo *)tmp->defs.next;
+	uFree(tmp);
+    }
+    return;
+}
+
+static DoodadInfo *
+#if NeedFunctionPrototypes
+FindDoodadByType(DoodadInfo *di,unsigned type)
+#else
+FindDoodadByType(di,type)
+    DoodadInfo *	di;
+    unsigned		type;
+#endif
+{
+    while (di) {
+	if (di->type==type)
+	    return di;
+	di= (DoodadInfo *)di->defs.next;
+    }
+    return NULL;
+}
+
+static DoodadInfo *
+#if NeedFunctionPrototypes
+FindDoodadByName(DoodadInfo *di,Atom name)
+#else
+FindDoodadByName(di,name)
+    DoodadInfo *	di;
+    Atom		name;
+#endif
+{
+    while (di) {
+	if (di->name==name)
+	    return di;
+	di= (DoodadInfo *)di->defs.next;
+    }
+    return NULL;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitDoodadInfo(DoodadInfo *di,unsigned type,SectionInfo *si,GeometryInfo *info)
+#else
+InitDoodadInfo(di,type,si,info)
+    DoodadInfo *	di;
+    unsigned		type;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+DoodadInfo *	dflt;
+
+    dflt= NULL;
+    if (si && si->dfltDoodads)
+	dflt= FindDoodadByType(si->dfltDoodads,type);
+    if ((dflt==NULL)&&(info->dfltDoodads))
+	dflt= FindDoodadByType(info->dfltDoodads,type);
+    if (dflt!=NULL) {
+	*di= *dflt;
+	di->defs.next= NULL;
+    }
+    else {
+	bzero(di,sizeof(DoodadInfo));
+	di->defs.fileID= info->fileID;
+	di->type= type;
+    }
+    di->section= si;
+    if (si!=NULL) {
+	di->priority= si->nextDoodadPriority++;
+	if (si->nextDoodadPriority>XkbGeomMaxPriority)
+	    si->nextDoodadPriority= XkbGeomMaxPriority;
+    }
+    else {
+	di->priority= info->nextPriority++;
+	if (info->nextPriority>XkbGeomMaxPriority)
+	    info->nextPriority= XkbGeomMaxPriority;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearDoodadInfo(DoodadInfo *di)
+#else
+ClearDoodadInfo(di)
+    DoodadInfo *	di;
+#endif
+{
+CommonInfo	defs;
+
+    defs= di->defs;
+    bzero(di,sizeof(DoodadInfo));
+    di->defs= defs;
+    di->defs.defined= 0;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearOverlayInfo(OverlayInfo *ol)
+#else
+ClearOverlayInfo(ol)
+    OverlayInfo *	ol;
+#endif
+{
+    if (ol && ol->keys) {
+	ol->keys= (OverlayKeyInfo *)ClearCommonInfo(&ol->keys->defs);
+	ol->nKeys= 0;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeDoodads(DoodadInfo *di,SectionInfo *si,GeometryInfo *info)
+#else
+FreeDoodads(di,si,info)
+    DoodadInfo *	di;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+DoodadInfo *	tmp;
+DoodadInfo *	next;
+
+    if (si) {
+	if (si->doodads==di) {
+	    si->doodads= NULL;
+	    si->nDoodads= 0;
+	}
+	if (si->dfltDoodads==di) 
+	    si->dfltDoodads= NULL;
+    }
+    if (info->doodads==di) {
+	info->doodads= NULL;
+	info->nDoodads= 0;
+    }
+    if (info->dfltDoodads==di)
+	info->dfltDoodads= NULL;
+    for (tmp=di;tmp!=NULL;tmp=next) {
+	next= (DoodadInfo *)tmp->defs.next;
+	ClearDoodadInfo(tmp);
+	uFree(tmp);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitSectionInfo(SectionInfo *si,GeometryInfo *info)
+#else
+InitSectionInfo(si,info)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+    if (si!=&info->dfltSection) {
+	*si= info->dfltSection;
+	si->defs.defined&= ~_GS_Default;
+	si->name= XkbInternAtom(info->dpy,"unknown",False);
+	si->priority= info->nextPriority++;
+	if (info->nextPriority>XkbGeomMaxPriority)
+	    info->nextPriority= XkbGeomMaxPriority;
+    }
+    else {
+	bzero(si,sizeof(SectionInfo));
+	si->defs.fileID= info->fileID;
+	si->defs.merge= info->merge;
+	si->defs.next= NULL;
+	si->geometry= info;
+	si->name= XkbInternAtom(info->dpy,"default",False);
+	InitRowInfo(&si->dfltRow,si,info);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+DupSectionInfo(SectionInfo *into,SectionInfo *from,GeometryInfo *info)
+#else
+DupSectionInfo(into,from,info)
+    SectionInfo *	into;
+    SectionInfo *	from;
+    GeometryInfo *	info;
+#endif
+{
+CommonInfo	defs;
+
+    defs= into->defs;
+    *into= *from;
+    into->defs.fileID= defs.fileID;
+    into->defs.merge= defs.merge;
+    into->defs.next= NULL;
+    into->dfltRow.defs.fileID= defs.fileID;
+    into->dfltRow.defs.merge= defs.merge;
+    into->dfltRow.defs.next= NULL;
+    into->dfltRow.section= into;
+    into->dfltRow.dfltKey.defs.fileID= defs.fileID;
+    into->dfltRow.dfltKey.defs.merge= defs.merge;
+    into->dfltRow.dfltKey.defs.next= NULL;
+    into->dfltRow.dfltKey.row= &into->dfltRow;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearSectionInfo(SectionInfo *si,GeometryInfo *info)
+#else
+ClearSectionInfo(si,info)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+
+    si->defs.defined&= ~_GS_Default;
+    si->name= XkbInternAtom(info->dpy,"default",False);
+    si->top= si->left= 0;
+    si->width= si->height= 0;
+    si->angle= 0;
+    if (si->rows) {
+	FreeRows(si->rows,si,info);
+	si->rows= NULL;
+    }
+    ClearRowInfo(&si->dfltRow,info);
+    if (si->doodads) {
+	FreeDoodads(si->doodads,si,info);
+	si->doodads= NULL;
+    }
+    si->dfltRow.defs.defined= _GR_Default;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeSections(SectionInfo *si,GeometryInfo *info)
+#else
+FreeSections(si,info)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+SectionInfo *	tmp;
+SectionInfo *	next;
+
+    if (si==info->sections) {
+	info->nSections= 0;
+	info->sections= NULL;
+    }
+    for (tmp=si;tmp!=NULL;tmp=next) {
+	ClearSectionInfo(tmp,info);
+	next= (SectionInfo *)tmp->defs.next;
+	uFree(tmp);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeShapes(ShapeInfo *si,GeometryInfo *info)
+#else
+FreeShapes(si,info)
+    ShapeInfo *		si;
+    GeometryInfo *	info;
+#endif
+{
+ShapeInfo *	tmp;
+ShapeInfo *	next;
+
+    if (si==info->shapes) {
+	info->nShapes= 0;
+	info->shapes= NULL;
+    }
+    for (tmp=si;tmp!=NULL;tmp=next) {
+	if (tmp->outlines) {
+	    register int i;
+	    for (i=0;i<tmp->nOutlines;i++) {
+		if (tmp->outlines[i].points!=NULL) {
+		    uFree(tmp->outlines[i].points);
+		    tmp->outlines[i].num_points= 0;
+		    tmp->outlines[i].points= NULL;
+		}
+	    }
+	    uFree(tmp->outlines);
+	    tmp->szOutlines= 0;
+	    tmp->nOutlines= 0;
+	    tmp->outlines= NULL;
+	    tmp->primary= tmp->approx=NULL;
+	}
+	next= (ShapeInfo *)tmp->defs.next;
+	uFree(tmp);
+    }
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+InitGeometryInfo(GeometryInfo *info,unsigned fileID,unsigned merge)
+#else
+InitGeometryInfo(info,fileID,merge)
+    GeometryInfo *	info;
+    unsigned		fileID;
+    unsigned		merge;
+#endif
+{
+    bzero(info,sizeof(GeometryInfo));
+    info->fileID= fileID;
+    info->merge= merge;
+    InitSectionInfo(&info->dfltSection,info);
+    info->dfltSection.defs.defined= _GS_Default;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearGeometryInfo(GeometryInfo *info)
+#else
+ClearGeometryInfo(info)
+    GeometryInfo *	info;
+#endif
+{
+    if (info->name)
+	uFree(info->name);
+    info->name= NULL;
+    if (info->props)
+	FreeProperties(info->props,info);
+    if (info->shapes)
+	FreeShapes(info->shapes,info);
+    if (info->sections)
+	FreeSections(info->sections,info);
+    info->widthMM= 0;
+    info->heightMM= 0;
+    info->dfltCornerRadius= 0;
+    ClearSectionInfo(&info->dfltSection,info);
+    info->dfltSection.defs.defined= _GS_Default;
+    if (info->aliases)
+	ClearAliases(&info->aliases);
+    return;
+}
+
+/***====================================================================***/
+
+static PropertyInfo *
+#if NeedFunctionPrototypes
+NextProperty(GeometryInfo *info)
+#else
+NextProperty(info)
+    GeometryInfo *	info;
+#endif
+{
+PropertyInfo *	pi;
+
+    pi= uTypedAlloc(PropertyInfo);
+    if (pi) {
+	bzero((char *)pi,sizeof(PropertyInfo));
+	info->props= (PropertyInfo *)AddCommonInfo(&info->props->defs,
+							(CommonInfo *)pi);
+	info->nProps++;
+    }
+    return pi;
+}
+
+static PropertyInfo *
+#if NeedFunctionPrototypes
+FindProperty(GeometryInfo *info,char *name)
+#else
+FindProperty(info,name)
+    GeometryInfo *	info;
+    char *		name;
+#endif
+{
+PropertyInfo *	old;
+
+    if (!name)
+	return NULL;
+    for (old= info->props;old!=NULL;old=(PropertyInfo *)old->defs.next) {
+	if ((old->name)&&(uStringEqual(name,old->name)))
+	    return old;
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddProperty(GeometryInfo *info,PropertyInfo *new)
+#else
+AddProperty(info,new)
+    GeometryInfo *	info;
+    PropertyInfo *	new;
+#endif
+{
+PropertyInfo	*	old;
+
+    if ((!new)||(!new->value)||(!new->name))
+	return False;
+    old= FindProperty(info,new->name);
+    if (old!=NULL) {
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN1("Multiple definitions for the \"%s\" property\n",
+								new->name);
+		ACTION2("Ignoring \"%s\", using \"%s\"\n",old->value,
+								new->value);
+	    }
+	    if (old->value)
+	 	uFree(old->value);
+	    old->value= uStringDup(new->value);
+	    return True;
+	}
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple definitions for \"%s\" property\n",new->name);
+	    ACTION2("Using \"%s\", ignoring \"%s\" \n",old->value,new->value);
+	}
+	return True;
+    }
+    old= new;
+    if ((new= NextProperty(info))==NULL)
+	return False;
+    new->defs.next= NULL;
+    new->name= uStringDup(old->name);
+    new->value= uStringDup(old->value);
+    return True;
+}
+
+/***====================================================================***/
+
+static ShapeInfo *
+#if NeedFunctionPrototypes
+NextShape(GeometryInfo *info)
+#else
+NextShape(info)
+    GeometryInfo *	info;
+#endif
+{
+ShapeInfo *	si;
+
+    si= uTypedAlloc(ShapeInfo);
+    if (si) {
+	bzero((char *)si,sizeof(ShapeInfo));
+	info->shapes= (ShapeInfo *)AddCommonInfo(&info->shapes->defs,
+							(CommonInfo *)si);
+	info->nShapes++;
+	si->dfltCornerRadius= info->dfltCornerRadius;
+    }
+    return si;
+}
+
+static ShapeInfo *
+#if NeedFunctionPrototypes
+FindShape(GeometryInfo *info,Atom name,char *type,char *which)
+#else
+FindShape(info,name,type,which)
+    GeometryInfo *	info;
+    Atom		name;
+    char *		type;
+    char *		which;
+#endif
+{
+ShapeInfo *	old;
+
+    for (old= info->shapes;old!=NULL;old=(ShapeInfo *)old->defs.next) {
+	if (name==old->name)
+	    return old;
+    }
+    if (type!=NULL) {
+	old= info->shapes;
+	WARN3("Unknown shape \"%s\" for %s %s\n",
+			XkbAtomText(info->dpy,name,XkbMessage),type,which);
+	if (old) {
+	    ACTION1("Using default shape %s instead\n",shText(info->dpy,old));
+	    return old;
+	}
+	ACTION("No default shape; definition ignored\n");
+	return NULL;
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddShape(GeometryInfo *info,ShapeInfo *new)
+#else
+AddShape(info,new)
+    GeometryInfo *	info;
+    ShapeInfo *		new;
+#endif
+{
+ShapeInfo	*	old;
+
+    old= FindShape(info,new->name,NULL,NULL);
+    if (old!=NULL) {
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    ShapeInfo *next= (ShapeInfo *)old->defs.next;
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN1("Duplicate shape name \"%s\"\n",shText(info->dpy,old));
+		ACTION("Using last definition\n");
+	    }
+	    *old= *new;
+	    old->defs.next= &next->defs;
+	    return True;
+	}
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple shapes named \"%s\"\n",shText(info->dpy,old));
+	    ACTION("Using first definition\n");
+	}
+	return True;
+    }
+    old= new;
+    if ((new= NextShape(info))==NULL)
+	return False;
+    *new= *old;
+    new->defs.next= NULL;
+    old->szOutlines= old->nOutlines= 0;
+    old->outlines= NULL;
+    old->approx= NULL;
+    old->primary= NULL;
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+ReplaceDoodad(DoodadInfo *into,DoodadInfo *from)
+#else
+ReplaceDoodad(into,from)
+    DoodadInfo *	into;
+    DoodadInfo *	from;
+#endif
+{
+CommonInfo *	next;
+
+    next= into->defs.next;
+    ClearDoodadInfo(into);
+    *into= *from;
+    into->defs.next= next;
+    next= from->defs.next;
+    ClearDoodadInfo(from);
+    from->defs.next= next;
+    return;
+}
+
+static DoodadInfo *
+#if NeedFunctionPrototypes
+NextDfltDoodad(SectionInfo *si,GeometryInfo *info)
+#else
+NextDfltDoodad(si,info)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+DoodadInfo *	di;
+
+    di= uTypedCalloc(1,DoodadInfo);
+    if (!di) 
+	return NULL;
+    if (si) {
+	si->dfltDoodads= (DoodadInfo *)AddCommonInfo(&si->dfltDoodads->defs,
+							(CommonInfo *)di);
+    }
+    else {
+	info->dfltDoodads= (DoodadInfo *)AddCommonInfo(&info->dfltDoodads->defs,
+							(CommonInfo *)di);
+    }
+    return di;
+}
+
+static DoodadInfo *
+#if NeedFunctionPrototypes
+NextDoodad(SectionInfo *si,GeometryInfo *info)
+#else
+NextDoodad(si,info)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+DoodadInfo *	di;
+
+    di= uTypedCalloc(1,DoodadInfo);
+    if (di) {
+	if (si) {
+	    si->doodads= (DoodadInfo *)AddCommonInfo(&si->doodads->defs,
+							(CommonInfo *)di);
+	    si->nDoodads++;
+	}
+	else {
+	    info->doodads= (DoodadInfo *)AddCommonInfo(&info->doodads->defs,
+							(CommonInfo *)di);
+	    info->nDoodads++;
+	}
+    }
+    return di;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddDoodad(SectionInfo *si,GeometryInfo *info,DoodadInfo *new)
+#else
+AddDoodad(si,info,new)
+    SectionInfo *	si;
+    GeometryInfo *	info;
+    DoodadInfo *	new;
+#endif
+{
+DoodadInfo	*	old;
+
+    old= FindDoodadByName((si?si->doodads:info->doodads),new->name);
+    if (old!=NULL) {
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN1("Multiple doodads named \"%s\"\n",
+		        XkbAtomText(info->dpy,old->name,XkbMessage));
+		ACTION("Using last definition\n");
+	    }
+	    ReplaceDoodad(old,new);
+	    old->section= si;
+	    return True;
+	}
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple doodads named \"%s\"\n",
+		        XkbAtomText(info->dpy,old->name,XkbMessage));
+	    ACTION("Using first definition\n");
+	}
+	return True;
+    }
+    old= new;
+    if ((new= NextDoodad(si,info))==NULL)
+	return False;
+    ReplaceDoodad(new,old);
+    new->section= si;
+    new->defs.next= NULL;
+    return True;
+}
+
+static DoodadInfo *
+#if NeedFunctionPrototypes
+FindDfltDoodadByTypeName(char *name,SectionInfo *si,GeometryInfo *info)
+#else
+FindDfltDoodadByTypeName(name,si,info)
+    char *		name;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+DoodadInfo *	dflt;
+unsigned	type;
+
+    if (uStrCaseCmp(name,"outline")==0)		type= XkbOutlineDoodad;
+    else if (uStrCaseCmp(name,"solid")==0)	type= XkbSolidDoodad;
+    else if (uStrCaseCmp(name,"text")==0)	type= XkbTextDoodad;
+    else if (uStrCaseCmp(name,"indicator")==0)	type= XkbIndicatorDoodad;
+    else if (uStrCaseCmp(name,"logo")==0)	type= XkbLogoDoodad;
+    else 					return NULL;
+    if ((si)&&(si->dfltDoodads))
+	 dflt= FindDoodadByType(si->dfltDoodads,type);
+    else dflt= NULL;
+    if ((!dflt)&&(info->dfltDoodads))
+	dflt= FindDoodadByType(info->dfltDoodads,type);
+    if (dflt==NULL) {
+	dflt= NextDfltDoodad(si,info);
+	if (dflt!=NULL) {
+	    dflt->name= None;
+	    dflt->type= type;
+	}
+    }
+    return dflt;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+AddOverlay(SectionInfo	*si,GeometryInfo *info,OverlayInfo *new)
+#else
+AddOverlay(si,info,new)
+    SectionInfo		*si;
+    GeometryInfo	*info;
+    OverlayInfo		*new;
+#endif
+{
+OverlayInfo	*	old;
+
+    for (old=si->overlays;old!=NULL;old=(OverlayInfo *)old->defs.next) {
+	if (old->name==new->name)
+	    break;
+    }
+    if (old!=NULL) {
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN2("Multiple overlays named \"%s\" for section \"%s\"\n",
+		        XkbAtomText(info->dpy,old->name,XkbMessage),
+			XkbAtomText(info->dpy,si->name,XkbMessage));
+		ACTION("Using last definition\n");
+	    }
+	    ClearOverlayInfo(old);
+	    old->nKeys= new->nKeys;
+	    old->keys= new->keys;
+	    new->nKeys= 0;
+	    new->keys= NULL;
+	    return True;
+	}
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN2("Multiple doodads named \"%s\" in section \"%s\"\n",
+		        XkbAtomText(info->dpy,old->name,XkbMessage),
+			XkbAtomText(info->dpy,si->name,XkbMessage));
+	    ACTION("Using first definition\n");
+	}
+	return True;
+    }
+    old= new;
+    new= uTypedCalloc(1,OverlayInfo);
+    if (!new) {
+	if (warningLevel>0) {
+	    WSGO("Couldn't allocate a new OverlayInfo\n");
+	    ACTION2("Overlay \"%s\" in section \"%s\" will be incomplete\n",
+			XkbAtomText(info->dpy,old->name,XkbMessage),
+			XkbAtomText(info->dpy,si->name,XkbMessage));
+	}
+	return False;
+    }
+    *new= *old;
+    old->nKeys= 0;
+    old->keys= NULL;
+    si->overlays= (OverlayInfo *)AddCommonInfo(&si->overlays->defs,
+							(CommonInfo *)new);
+    si->nOverlays++;
+    return True;
+}
+
+/***====================================================================***/
+
+static SectionInfo *
+#if NeedFunctionPrototypes
+NextSection(GeometryInfo *info)
+#else
+NextSection(info)
+    GeometryInfo *	info;
+#endif
+{
+SectionInfo *	si;
+
+    si= uTypedAlloc(SectionInfo);
+    if (si) {
+	*si= info->dfltSection;
+	si->defs.defined&= ~_GS_Default;
+	si->defs.next= NULL;
+	si->nRows= 0;
+	si->rows= NULL;
+	info->sections= (SectionInfo *)AddCommonInfo(&info->sections->defs,
+							(CommonInfo *)si);
+	info->nSections++;
+    }
+    return si;
+}
+
+static SectionInfo *
+#if NeedFunctionPrototypes
+FindMatchingSection(GeometryInfo *info,SectionInfo *new)
+#else
+FindMatchingSection(info,new)
+    GeometryInfo *	info;
+    SectionInfo *		new;
+#endif
+{
+SectionInfo *	old;
+
+    for (old=info->sections;old!=NULL;old=(SectionInfo *)old->defs.next) {
+	if (new->name==old->name)
+	    return old;
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddSection(GeometryInfo *info,SectionInfo *new)
+#else
+AddSection(info,new)
+    GeometryInfo *	info;
+    SectionInfo *		new;
+#endif
+{
+SectionInfo	*	old;
+
+    old= FindMatchingSection(info,new);
+    if (old!=NULL) {
+#ifdef NOTDEF
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    SectionInfo *next= (SectionInfo *)old->defs.next;
+	    if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+		WARN1("Duplicate shape name \"%s\"\n",shText(info->dpy,old));
+		ACTION("Using last definition\n");
+	    }
+	    *old= *new;
+	    old->defs.next= &next->defs;
+	    return True;
+	}
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple shapes named \"%s\"\n",shText(info->dpy,old));
+	    ACTION("Using first definition\n");
+	}
+	return True;
+#else
+	WARN("Don't know how to merge sections yet\n");
+#endif
+    }
+    old= new;
+    if ((new= NextSection(info))==NULL)
+	return False;
+    *new= *old;
+    new->defs.next= NULL;
+    old->nRows= old->nDoodads= old->nOverlays= 0;
+    old->rows= NULL;
+    old->doodads= NULL;
+    old->overlays= NULL;
+    if (new->doodads) {
+	DoodadInfo *di;
+	for (di=new->doodads;di;di=(DoodadInfo *)di->defs.next) {
+	    di->section= new;
+	}
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+static RowInfo *
+#if NeedFunctionPrototypes
+NextRow(SectionInfo *si)
+#else
+NextRow(si)
+    SectionInfo *	si;
+#endif
+{
+RowInfo *	row;
+
+    row= uTypedAlloc(RowInfo);
+    if (row) {
+	*row= si->dfltRow;
+	row->defs.defined&= ~_GR_Default;
+	row->defs.next= NULL;
+	row->nKeys= 0;
+	row->keys= NULL;
+	si->rows= (RowInfo *)AddCommonInfo(&si->rows->defs,(CommonInfo *)row);
+	row->index= si->nRows++;
+    }
+    return row;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddRow(SectionInfo *si,RowInfo *new)
+#else
+AddRow(si,new)
+    SectionInfo *	si;
+    RowInfo *		new;
+#endif
+{
+RowInfo	*	old;
+
+    old= new;
+    if ((new= NextRow(si))==NULL)
+	return False;
+    *new= *old;
+    new->defs.next= NULL;
+    old->nKeys= 0;
+    old->keys= NULL;
+    return True;
+}
+
+/***====================================================================***/
+
+static KeyInfo *
+#if NeedFunctionPrototypes
+NextKey(RowInfo *row)
+#else
+NextKey(row)
+    RowInfo *	row;
+#endif
+{
+KeyInfo *	key;
+
+    key= uTypedAlloc(KeyInfo);
+    if (key) {
+	*key= row->dfltKey;
+	key->defs.defined&= ~_GK_Default;
+	key->defs.next= NULL;
+	key->index= row->nKeys++;
+    }
+    return key;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddKey(RowInfo *row,KeyInfo *new)
+#else
+AddKey(row,new)
+    RowInfo *	row;
+    KeyInfo *	new;
+#endif
+{
+KeyInfo	*	old;
+
+    old= new;
+    if ((new= NextKey(row))==NULL)
+	return False;
+    *new= *old;
+    new->defs.next= NULL;
+    row->keys= (KeyInfo *)AddCommonInfo(&row->keys->defs,(CommonInfo *)new);
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+MergeIncludedGeometry(GeometryInfo *into,GeometryInfo *from,unsigned merge)
+#else
+MergeIncludedGeometry(into,from,merge)
+    GeometryInfo *	into;
+    GeometryInfo *	from;
+    unsigned		merge;
+#endif
+{
+Bool clobber;
+
+    if (from->errorCount>0) {
+	into->errorCount+= from->errorCount;
+	return;
+    }
+    clobber= (merge==MergeOverride)||(merge==MergeReplace);
+    if (into->name==NULL) {
+	into->name= from->name;
+	from->name= NULL;
+    }
+    if ((into->widthMM==0)||((from->widthMM!=0)&&clobber))
+	into->widthMM= from->widthMM;
+    if ((into->heightMM==0)||((from->heightMM!=0)&&clobber))
+	into->heightMM= from->heightMM;
+    if ((into->font==None)||((from->font!=None)&&clobber))
+	into->font= from->font;
+    if ((into->fontSlant==None)||((from->fontSlant!=None)&&clobber))
+	into->fontSlant= from->fontSlant;
+    if ((into->fontWeight==None)||((from->fontWeight!=None)&&clobber))
+	into->fontWeight= from->fontWeight;
+    if ((into->fontSetWidth==None)||((from->fontSetWidth!=None)&&clobber))
+	into->fontSetWidth= from->fontSetWidth;
+    if ((into->fontVariant==None)||((from->fontVariant!=None)&&clobber))
+	into->fontVariant= from->fontVariant;
+    if ((into->fontSize==0)||((from->fontSize!=0)&&clobber))
+	into->fontSize= from->fontSize;
+    if ((into->fontEncoding==None)||((from->fontEncoding!=None)&&clobber))
+	into->fontEncoding= from->fontEncoding;
+    if ((into->fontSpec==None)||((from->fontSpec!=None)&&clobber))
+	into->fontSpec= from->fontSpec;
+    if ((into->baseColor==None)||((from->baseColor!=None)&&clobber))
+	into->baseColor= from->baseColor;
+    if ((into->labelColor==None)||((from->labelColor!=None)&&clobber))
+	into->labelColor= from->labelColor;
+    into->nextPriority= from->nextPriority;
+    if (from->props!=NULL) {
+	PropertyInfo *pi;
+	for (pi=from->props;pi;pi=(PropertyInfo *)pi->defs.next) {
+	    if (!AddProperty(into,pi))
+		into->errorCount++;
+	}
+    }
+    if (from->shapes!=NULL) {
+	ShapeInfo * si;
+
+	for (si=from->shapes;si;si=(ShapeInfo *)si->defs.next) {
+	    if (!AddShape(into,si))
+		into->errorCount++;
+	}
+    }
+    if (from->sections!=NULL) {
+	SectionInfo * si;
+
+	for (si=from->sections;si;si=(SectionInfo *)si->defs.next) {
+	    if (!AddSection(into,si))
+		into->errorCount++;
+	}
+    }
+    if (from->doodads!=NULL) {
+	DoodadInfo * di;
+
+	for (di=from->doodads;di;di=(DoodadInfo *)di->defs.next) {
+	    if (!AddDoodad(NULL,into,di))
+		into->errorCount++;
+ 	}
+    }
+    if (!MergeAliases(&into->aliases,&from->aliases,merge))
+	into->errorCount++;
+    return;
+}
+
+typedef void	(*FileHandler)(
+#if NeedFunctionPrototypes
+	XkbFile *	/* file */,
+	XkbDescPtr	/* xkb */,
+	unsigned	/* merge */,
+	GeometryInfo *	/* info */
+#endif
+);
+
+static Bool
+#if NeedFunctionPrototypes
+HandleIncludeGeometry(IncludeStmt *stmt,XkbDescPtr xkb,GeometryInfo *info,
+							FileHandler hndlr)
+#else
+HandleIncludeGeometry(stmt,xkb,info,hndlr)
+    IncludeStmt	*	  stmt;
+    XkbDescPtr		  xkb;
+    GeometryInfo *	  info;
+    FileHandler		  hndlr;
+#endif
+{
+unsigned 	newMerge;
+XkbFile	*	rtrn;
+GeometryInfo 	included;
+Bool		haveSelf;
+
+    haveSelf= False;
+    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
+	haveSelf= True;
+	included= *info;
+	bzero(info,sizeof(GeometryInfo));
+    }
+    else if (ProcessIncludeFile(stmt,XkmGeometryIndex,&rtrn,&newMerge)) {
+	InitGeometryInfo(&included,rtrn->id,newMerge);
+	included.nextPriority= info->nextPriority;
+	included.dfltCornerRadius= info->dfltCornerRadius;
+	DupSectionInfo(&included.dfltSection,&info->dfltSection,info);
+	(*hndlr)(rtrn,xkb,MergeOverride,&included);
+	if (stmt->stmt!=NULL) {
+	    if (included.name!=NULL)
+		uFree(included.name);
+	    included.name= stmt->stmt;
+	    stmt->stmt= NULL;
+	}
+    }
+    else {
+	info->errorCount+= 10;
+	return False;
+    }
+    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
+        IncludeStmt *   next;
+        unsigned        op;
+        GeometryInfo	next_incl;
+
+        for (next=stmt->next;next!=NULL;next=next->next) {
+	    if ((next->file==NULL)&&(next->map==NULL)) {
+		haveSelf= True;
+		MergeIncludedGeometry(&included,info,next->merge);
+		ClearGeometryInfo(info);
+	    }
+	    else if (ProcessIncludeFile(next,XkmGeometryIndex,&rtrn,&op)) {
+		InitGeometryInfo(&next_incl,rtrn->id,op);
+		next_incl.nextPriority= included.nextPriority;
+		next_incl.dfltCornerRadius= included.dfltCornerRadius;
+		DupSectionInfo(&next_incl.dfltSection,&included.dfltSection,
+								&included);
+		(*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
+		MergeIncludedGeometry(&included,&next_incl,op);
+		ClearGeometryInfo(&next_incl);
+	    }
+	    else {
+		info->errorCount+= 10;
+		return False;
+	    }
+	}
+    }
+    if (haveSelf)
+	*info= included;
+    else {
+	MergeIncludedGeometry(info,&included,newMerge);
+	ClearGeometryInfo(&included);
+    }
+    return (info->errorCount==0);
+}
+
+static int
+#if NeedFunctionPrototypes
+SetShapeField(	ShapeInfo *	si,
+		char *		field,
+		ExprDef *	arrayNdx,
+		ExprDef *	value,
+		GeometryInfo *	info)
+#else
+SetShapeField(si,field,arrayNdx,value,info)
+    ShapeInfo *		si;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+
+    if ((uStrCaseCmp(field,"radius")==0)||(uStrCaseCmp(field,"corner")==0)||
+				  (uStrCaseCmp(field,"cornerradius")==0)) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("key shape",field,shText(info->dpy,si));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("key shape",field,
+	    				     shText(info->dpy,si),"number");
+	}
+	if (si)
+	     si->dfltCornerRadius= tmp.ival;
+	else info->dfltCornerRadius= tmp.ival;
+	return True;
+    }
+    info->errorCount++;
+    return ReportBadField("key shape",field,shText(info->dpy,si));
+}
+
+static int
+#if NeedFunctionPrototypes
+SetShapeDoodadField(	DoodadInfo *	di,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SectionInfo *	si,
+			GeometryInfo *	info)
+#else
+SetShapeDoodadField(di,field,arrayNdx,value,si,info)
+    DoodadInfo *	di;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+char *		typeName;
+
+    typeName= (di->type==XkbSolidDoodad?"solid doodad":"outline doodad");
+    if ((!uStrCaseCmp(field,"corner"))||(!uStrCaseCmp(field,"cornerradius"))) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Corner;
+	di->corner= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"angle")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Angle;
+	di->angle= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"shape")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"string");
+	}
+	di->shape= XkbInternAtom(info->dpy,tmp.str,False);
+	di->defs.defined|= _GD_Shape;
+	return True;
+    }
+    return ReportBadField(typeName,field,ddText(info->dpy,di));
+}
+
+#define	FIELD_STRING	0
+#define	FIELD_SHORT	1
+#define	FIELD_USHORT	2
+
+static int
+#if NeedFunctionPrototypes
+SetTextDoodadField(	DoodadInfo *	di,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SectionInfo *	si,
+			GeometryInfo *	info)
+#else
+SetTextDoodadField(di,field,arrayNdx,value,si,info)
+    DoodadInfo *	di;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+unsigned	def;
+unsigned	type;
+char *		typeName= "text doodad";
+union {
+    Atom *	str;
+    short *		ival;
+    unsigned short *	uval;
+}		pField;
+
+    if (uStrCaseCmp(field,"angle")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Angle;
+	di->angle= tmp.ival;
+	return True;
+    }
+    if (uStrCaseCmp(field,"width")==0) {
+	type= FIELD_USHORT;
+	pField.uval= &di->width;
+	def= _GD_Width;
+    }
+    else if (uStrCaseCmp(field,"height")==0) {
+	type= FIELD_USHORT;
+	pField.uval= &di->height;
+	def= _GD_Height;
+    }
+    else if (uStrCaseCmp(field,"text")==0) {
+	type= FIELD_STRING;
+	pField.str= &di->text;
+	def= _GD_Text;
+    }
+    else if (uStrCaseCmp(field,"font")==0) {
+	type= FIELD_STRING;
+	pField.str= &di->font;
+	def= _GD_Font;
+    }
+    else if ((uStrCaseCmp(field,"fontslant")==0)||
+					    (uStrCaseCmp(field,"slant")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontSlant;
+	def= _GD_FontSlant;
+    }
+    else if ((uStrCaseCmp(field,"fontweight")==0)||
+					    (uStrCaseCmp(field,"weight")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontWeight;
+	def= _GD_FontWeight;
+    }
+    else if ((uStrCaseCmp(field,"fontwidth")==0)||
+				    (uStrCaseCmp(field,"setwidth")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontSetWidth;
+	def= _GD_FontSetWidth;
+    }
+    else if ((uStrCaseCmp(field,"fontvariant")==0)||
+				    (uStrCaseCmp(field,"variant")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontVariant;
+	def= _GD_FontVariant;
+    }
+    else if ((uStrCaseCmp(field,"fontencoding")==0)||
+				    (uStrCaseCmp(field,"encoding")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontEncoding;
+	def= _GD_FontEncoding;
+    }
+    else if ((uStrCaseCmp(field,"xfont")==0)||
+				    (uStrCaseCmp(field,"xfontname")==0)) {
+	type= FIELD_STRING;
+	pField.str= &di->fontSpec;
+	def= _GD_FontSpec;
+    }
+    else if (uStrCaseCmp(field,"fontsize")==0) {
+	type= FIELD_USHORT;
+	pField.uval= &di->fontSize;
+	def= _GD_FontSize;
+    }
+    else {
+	return ReportBadField(typeName,field,ddText(info->dpy,di));
+    }
+    if (arrayNdx!=NULL) {
+	info->errorCount++;
+	return ReportNotArray(typeName,field,ddText(info->dpy,di));
+    }
+    if (type==FIELD_STRING) {
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),
+	    							"string");
+	}
+	di->defs.defined|= def;
+	*pField.str= XkbInternAtom(NULL,tmp.str,False);
+    }
+    else {
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	if ((type==FIELD_USHORT)&&(tmp.ival<0)) {
+	    info->errorCount++;
+	    return 
+		  ReportBadType(typeName,field,ddText(info->dpy,di),"unsigned");
+	}
+	di->defs.defined|= def;
+	if (type==FIELD_USHORT)
+	     *pField.uval= tmp.uval;
+	else *pField.ival= tmp.ival;
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetIndicatorDoodadField(	DoodadInfo *	di,
+				char *		field,
+				ExprDef *	arrayNdx,
+				ExprDef *	value,
+				SectionInfo *	si,
+				GeometryInfo *	info)
+#else
+SetIndicatorDoodadField(di,field,arrayNdx,value,si,info)
+    DoodadInfo *	di;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+
+    if ((uStrCaseCmp(field,"oncolor")==0)||(uStrCaseCmp(field,"offcolor")==0)
+					 ||(uStrCaseCmp(field,"shape")==0)) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("indicator doodad",field,
+	    						ddText(info->dpy,di));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("indicator doodad",field,ddText(info->dpy,di),
+	    							"string");
+	}
+	if (uStrCaseCmp(field,"oncolor")==0) {
+	    di->defs.defined|= _GD_Color;
+	    di->color= XkbInternAtom(NULL,tmp.str,False);
+	}
+	else if (uStrCaseCmp(field,"offcolor")==0) {
+	    di->defs.defined|= _GD_OffColor;
+	    di->offColor= XkbInternAtom(NULL,tmp.str,False);
+	}
+	else if (uStrCaseCmp(field,"shape")==0) {
+	    di->defs.defined|= _GD_Shape;
+	    di->shape= XkbInternAtom(info->dpy,tmp.str,False);
+	}
+	return True;
+    }
+    return ReportBadField("indicator doodad",field,ddText(info->dpy,di));
+}
+
+static int
+#if NeedFunctionPrototypes
+SetLogoDoodadField(	DoodadInfo *	di,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SectionInfo *	si,
+			GeometryInfo *	info)
+#else
+SetLogoDoodadField(di,field,arrayNdx,value,si,info)
+    DoodadInfo *	di;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+char *		typeName= "logo doodad";
+
+    if ((!uStrCaseCmp(field,"corner"))||(!uStrCaseCmp(field,"cornerradius"))) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Corner;
+	di->corner= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"angle")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Angle;
+	di->angle= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"shape")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"string");
+	}
+	di->shape= XkbInternAtom(info->dpy,tmp.str,False);
+	di->defs.defined|= _GD_Shape;
+	return True;
+    }
+    else if ((!uStrCaseCmp(field,"logoname"))||(!uStrCaseCmp(field,"name"))) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray(typeName,field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType(typeName,field,ddText(info->dpy,di),"string");
+	}
+	di->logoName= uStringDup(tmp.str);
+	return True;
+    }
+    return ReportBadField(typeName,field,ddText(info->dpy,di));
+}
+
+static int
+#if NeedFunctionPrototypes
+SetDoodadField(	DoodadInfo *	di,
+		char *		field,
+		ExprDef *	arrayNdx,
+		ExprDef *	value,
+		SectionInfo *	si,
+		GeometryInfo *	info)
+#else
+SetDoodadField(di,field,arrayNdx,value,si,info)
+    DoodadInfo *	di;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+
+    if (uStrCaseCmp(field,"priority")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("doodad",field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveInteger(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("doodad",field,ddText(info->dpy,di),"integer");
+	}
+	if ((tmp.ival<0)||(tmp.ival>XkbGeomMaxPriority)) {
+	    info->errorCount++;
+	    ERROR2("Doodad priority %d out of range (must be 0..%d)\n",
+						tmp.ival,XkbGeomMaxPriority);
+	    ACTION1("Priority for doodad %s not changed",ddText(info->dpy,di));
+	    return False;
+	}
+	di->defs.defined|= _GD_Priority;
+	di->priority= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"left")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("doodad",field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("doodad",field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Left;
+	di->left= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"top")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("doodad",field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("doodad",field,ddText(info->dpy,di),"number");
+	}
+	di->defs.defined|= _GD_Top;
+	di->top= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"color")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("doodad",field,ddText(info->dpy,di));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("doodad",field,ddText(info->dpy,di),"string");
+	}
+	di->defs.defined|= _GD_Color;
+	di->color= XkbInternAtom(NULL,tmp.str,False);
+	return True;
+    }
+    switch (di->type) {
+	case XkbOutlineDoodad:
+	case XkbSolidDoodad:
+	    return SetShapeDoodadField(di,field,arrayNdx,value,si,info);
+	case XkbTextDoodad:
+	    return SetTextDoodadField(di,field,arrayNdx,value,si,info);
+	case XkbIndicatorDoodad:
+	    return SetIndicatorDoodadField(di,field,arrayNdx,value,si,info);
+	case XkbLogoDoodad:
+	    return SetLogoDoodadField(di,field,arrayNdx,value,si,info);
+    }
+    WSGO1("Unknown doodad type %d in SetDoodadField\n",(unsigned int)di->type);
+    ACTION2("Definition of %s in %s ignored\n",field,ddText(info->dpy,di));
+    return False;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetSectionField(	SectionInfo *	si,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			GeometryInfo *	info)
+#else
+SetSectionField(si,field,arrayNdx,value,info)
+    SectionInfo *	si;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    GeometryInfo *	info;
+#endif
+{
+unsigned short *	pField;
+unsigned		def;
+ExprResult		tmp;
+
+    pField= NULL;
+    def= 0;
+    if (uStrCaseCmp(field,"priority")==0) {
+	if (arrayNdx!=NULL) {
+	   info->errorCount++;
+	   return ReportNotArray("keyboard section",field,scText(info->dpy,si));
+	}
+	if (!ExprResolveInteger(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    ReportBadType("keyboard section",field,scText(info->dpy,si),
+	    							   "integer");
+	    return False;
+	}
+	if ((tmp.ival<0)||(tmp.ival>XkbGeomMaxPriority)) {
+	    info->errorCount++;
+	    ERROR2("Section priority %d out of range (must be 0..%d)\n",
+						tmp.ival,XkbGeomMaxPriority);
+	    ACTION1("Priority for section %s not changed",scText(info->dpy,si));
+	    return False;
+	}
+	si->priority= tmp.ival;
+	si->defs.defined|= _GS_Priority;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"top")==0)  {
+	pField= &si->top;
+	def= _GS_Top;
+    }
+    else if (uStrCaseCmp(field,"left")==0) {
+	pField= &si->left;
+	def= _GS_Left;
+    }
+    else if (uStrCaseCmp(field,"width")==0) {
+	pField= &si->width;
+	def= _GS_Width;
+    }
+    else if (uStrCaseCmp(field,"height")==0) {
+	pField= &si->height;
+	def= _GS_Height;
+    }
+    else if (uStrCaseCmp(field,"angle")==0) {
+	pField= &si->angle;
+	def= _GS_Angle;
+    }
+    else {
+	info->errorCount++;
+	return ReportBadField("keyboard section",field,scText(info->dpy,si));
+    }
+    if (arrayNdx!=NULL) {
+	info->errorCount++;
+	return ReportNotArray("keyboard section",field,scText(info->dpy,si));
+    }
+    if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	info->errorCount++;
+	ReportBadType("keyboard section",field,scText(info->dpy,si),"number");
+	return False;
+    }
+    si->defs.defined|= def;
+    *pField= tmp.uval;
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetRowField(	RowInfo *	row,
+		char *		field,
+		ExprDef *	arrayNdx,
+		ExprDef *	value,
+		GeometryInfo *	info)
+#else
+SetRowField(row,field,arrayNdx,value,info)
+    RowInfo *		row;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	tmp;
+
+    if (uStrCaseCmp(field,"top")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard row",field,rowText(info->dpy,row));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard row",field,rowText(info->dpy,row),
+	    							"number");
+	}
+	row->defs.defined|= _GR_Top;
+	row->top= tmp.uval;
+    }
+    else if (uStrCaseCmp(field,"left")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard row",field,rowText(info->dpy,row));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard row",field,rowText(info->dpy,row),
+	    							"number");
+	}
+	row->defs.defined|= _GR_Left;
+	row->left= tmp.uval;
+    }
+    else if (uStrCaseCmp(field,"vertical")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard row",field,rowText(info->dpy,row));
+	}
+	if (!ExprResolveBoolean(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard row",field,rowText(info->dpy,row),
+	    							"boolean");
+	}
+	row->defs.defined|= _GR_Vertical;
+	row->vertical= tmp.uval;
+    }
+    else {
+	info->errorCount++;
+	return ReportBadField("keyboard row",field,rowText(info->dpy,row));
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetKeyField(	KeyInfo *key,
+		char *field,
+		ExprDef *arrayNdx,
+		ExprDef *value,
+		GeometryInfo *info)
+#else
+SetKeyField(key,field,arrayNdx,value,info)
+    KeyInfo *		key;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult tmp;
+
+    if (uStrCaseCmp(field,"gap")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("key",field,keyText(key));
+	}
+	if (!ExprResolveFloat(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("key",field,keyText(key),"number");
+	}
+	key->defs.defined|= _GK_Gap;
+	key->gap= tmp.ival;
+    }
+    else if (uStrCaseCmp(field,"shape")==0) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("key",field,keyText(key));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("key",field,keyText(key),"string");
+	}
+	key->defs.defined|= _GK_Shape;
+	key->shape= XkbInternAtom(info->dpy,tmp.str,False);
+    }
+    else if ((uStrCaseCmp(field,"color")==0)||
+					   (uStrCaseCmp(field,"keycolor")==0)) {
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("key",field,keyText(key));
+	}
+	if (!ExprResolveString(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("key",field,keyText(key),"string");
+	}
+	key->defs.defined|= _GK_Color;
+	key->color= XkbInternAtom(NULL,tmp.str,False);
+    }
+    else if ((uStrCaseCmp(field,"name")==0)||(uStrCaseCmp(field,"keyname")==0)){
+	if (arrayNdx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("key",field,keyText(key));
+	}
+	if (!ExprResolveKeyName(value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("key",field,keyText(key),"key name");
+	}
+	key->defs.defined|= _GK_Name;
+	bzero(key->name,XkbKeyNameLength+1);
+	strncpy(key->name,tmp.keyName.name,XkbKeyNameLength);
+    }
+    else {
+	info->errorCount++;
+	return ReportBadField("key",field,keyText(key));
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetGeometryProperty(GeometryInfo *info,char *property,ExprDef *value)
+#else
+SetGeometryProperty(info,property,value)
+    GeometryInfo *	info;
+    char *		property;
+    ExprDef *		value;
+#endif
+{
+PropertyInfo	pi;
+ExprResult	result;
+
+    InitPropertyInfo(&pi,info);
+    pi.name= property;
+    if (!ExprResolveString(value,&result,NULL,NULL)) {
+	info->errorCount++;
+	ERROR("Property values must be type string\n");
+	ACTION1("Ignoring illegal definition of \"%s\" property\n",property);
+	return False;
+    }
+    pi.value= result.str;
+    return AddProperty(info,&pi);
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleGeometryVar(VarDef *stmt,XkbDescPtr xkb,GeometryInfo *info)
+#else
+HandleGeometryVar(stmt,xkb,info)
+    VarDef *		stmt;
+    XkbDescPtr		xkb;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	elem,field,tmp;
+ExprDef *	ndx;
+DoodadInfo *	di;
+Atom *		pField;
+
+    if (ExprResolveLhs(stmt->name,&elem,&field,&ndx)==0) 
+	return 0; /* internal error, already reported */
+    if (elem.str&&(uStrCaseCmp(elem.str,"shape")==0))
+	return SetShapeField(NULL,field.str,ndx,stmt->value,info);
+    if (elem.str&&(uStrCaseCmp(elem.str,"key")==0))
+	return SetKeyField(&info->dfltSection.dfltRow.dfltKey,
+					      field.str,ndx,stmt->value,info);	
+    if (elem.str&&(uStrCaseCmp(elem.str,"row")==0))
+	return SetRowField(&info->dfltSection.dfltRow,field.str,ndx,
+							    stmt->value,info);	
+    if (elem.str&&(uStrCaseCmp(elem.str,"section")==0)) {
+	return SetSectionField(&info->dfltSection,field.str,ndx,stmt->value,
+									info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"property")==0)) {
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    ERROR1("The %s geometry property is not an array\n",field.str);
+	    ACTION("Ignoring illegal property definition\n");
+	    return False;
+	}
+	return SetGeometryProperty(info,field.str,stmt->value);
+    }
+    if (elem.str&&((di=FindDfltDoodadByTypeName(elem.str,NULL,info))!=NULL)) {
+	return SetDoodadField(di,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"solid")==0)) {
+	DoodadInfo *dflt;
+	dflt= FindDoodadByType(info->dfltDoodads,XkbSolidDoodad);
+	if (dflt==NULL)
+	    dflt= NextDfltDoodad(NULL,info);
+	return SetDoodadField(dflt,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"outline")==0)) {
+	DoodadInfo *dflt;
+	dflt= FindDoodadByType(info->dfltDoodads,XkbOutlineDoodad);
+	if (dflt==NULL)
+	    dflt= NextDfltDoodad(NULL,info);
+	return SetDoodadField(dflt,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"text")==0)) {
+	DoodadInfo *dflt;
+	dflt= FindDoodadByType(info->dfltDoodads,XkbTextDoodad);
+	if (dflt==NULL)
+	    dflt= NextDfltDoodad(NULL,info);
+	return SetDoodadField(dflt,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"indicator")==0)) {
+	DoodadInfo *dflt;
+	dflt= FindDoodadByType(info->dfltDoodads,XkbIndicatorDoodad);
+	if (dflt==NULL)
+	    dflt= NextDfltDoodad(NULL,info);
+	return SetDoodadField(dflt,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str&&(uStrCaseCmp(elem.str,"logo")==0)) {
+	DoodadInfo *dflt;
+	dflt= FindDoodadByType(info->dfltDoodads,XkbLogoDoodad);
+	if (dflt==NULL)
+	    dflt= NextDfltDoodad(NULL,info);
+	return SetDoodadField(dflt,field.str,ndx,stmt->value,NULL,info);
+    }
+    if (elem.str) {
+	WARN("Assignment to field of unknown element\n");
+	ACTION2("No value assigned to %s.%s\n",elem.str,field.str);
+	return False;
+    }
+
+    if ((uStrCaseCmp(field.str,"width")==0)||
+	     (uStrCaseCmp(field.str,"widthmm")==0)) {
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard",field.str,"geometry");
+	}
+	if (!ExprResolveFloat(stmt->value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard",field.str,"geometry","number");
+	}
+	if (tmp.ival<1) {
+	    WARN("Keyboard width must be positive\n");
+	    ACTION1("Ignoring illegal keyboard width %s\n",
+	    				XkbGeomFPText(tmp.ival,XkbMessage));
+	    return True;
+	}
+	if (info->widthMM!=0) {
+	    WARN("Keyboard width multiply defined\n");
+	    ACTION1("Using last definition (%s),",
+				XkbGeomFPText(tmp.ival,XkbMessage));
+	    INFO1(" ignoring first (%s)\n",
+				XkbGeomFPText(info->widthMM,XkbMessage));
+	}
+	info->widthMM= tmp.ival;
+	return True;
+    }
+    else if ((uStrCaseCmp(field.str,"height")==0)||
+	     (uStrCaseCmp(field.str,"heightmm")==0)) {
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard",field.str,"geometry");
+	}
+	if (!ExprResolveFloat(stmt->value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard",field.str,"geometry","number");
+	}
+	if (tmp.ival<1) {
+	    WARN("Keyboard height must be positive\n");
+	    ACTION1("Ignoring illegal keyboard height %s\n",
+					XkbGeomFPText(tmp.ival,XkbMessage));
+	    return True;
+	}
+	if (info->heightMM!=0) {
+	    WARN("Keyboard height multiply defined\n");
+	    ACTION1("Using last definition (%s),",
+				XkbGeomFPText(tmp.ival,XkbMessage));
+	    INFO1(" ignoring first (%s)\n",
+				XkbGeomFPText(info->heightMM,XkbMessage));
+	}
+	info->heightMM= tmp.ival;
+	return True;
+    }
+    else if (uStrCaseCmp(field.str,"font")==0) {
+	pField= &info->font;
+    }
+    else if ((uStrCaseCmp(field.str,"fontslant")==0)||
+				    (uStrCaseCmp(field.str,"slant")==0)) {
+	pField= &info->fontSlant;
+    }
+    else if ((uStrCaseCmp(field.str,"fontweight")==0)||
+				    (uStrCaseCmp(field.str,"weight")==0)) {
+	pField= &info->fontWeight;
+    }
+    else if ((uStrCaseCmp(field.str,"fontwidth")==0)||
+				    (uStrCaseCmp(field.str,"setwidth")==0)) {
+	pField= &info->fontWeight;
+    }
+    else if ((uStrCaseCmp(field.str,"fontencoding")==0)||
+				    (uStrCaseCmp(field.str,"encoding")==0)) {
+	pField= &info->fontEncoding;
+    }
+    else if ((uStrCaseCmp(field.str,"xfont")==0)||
+				    (uStrCaseCmp(field.str,"xfontname")==0)) {
+	pField= &info->fontSpec;
+    }
+    else if (uStrCaseCmp(field.str,"fontsize")==0) {
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard",field.str,"geometry");
+	}
+	if (!ExprResolveFloat(stmt->value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard",field.str,"geometry","number");
+	}
+	if ((tmp.ival<40)||(tmp.ival>2550)) {
+	    info->errorCount++;
+	    ERROR1("Illegal font size %d (must be 4..255)\n",tmp.ival);
+	    ACTION("Ignoring font size in keyboard geometry\n");
+	    return False;
+	}
+	info->fontSize= tmp.ival;
+	return True;
+    }
+    else if ((uStrCaseCmp(field.str,"color")==0)||
+				(uStrCaseCmp(field.str,"basecolor")==0)){
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard",field.str,"geometry");
+	}
+	if (!ExprResolveString(stmt->value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard",field.str,"geometry","string");
+	}
+	info->baseColor= XkbInternAtom(NULL,tmp.str,False);
+	return True;
+    }
+    else if (uStrCaseCmp(field.str,"labelcolor")==0){
+	if (ndx!=NULL) {
+	    info->errorCount++;
+	    return ReportNotArray("keyboard",field.str,"geometry");
+	}
+	if (!ExprResolveString(stmt->value,&tmp,NULL,NULL)) {
+	    info->errorCount++;
+	    return ReportBadType("keyboard",field.str,"geometry","string");
+	}
+	info->labelColor= XkbInternAtom(NULL,tmp.str,False);
+	return True;
+    }
+    else {
+	return SetGeometryProperty(info,field.str,stmt->value);
+    }
+
+    if (ndx!=NULL) {
+	info->errorCount++;
+	return ReportNotArray("keyboard",field.str,"geometry");
+    }
+    if (!ExprResolveString(stmt->value,&tmp,NULL,NULL)) {
+	info->errorCount++;
+	return ReportBadType("keyboard",field.str,"geometry","string");
+    }
+    *pField= XkbInternAtom(NULL,tmp.str,False);
+    return True;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+HandleShapeBody(ShapeDef *def,ShapeInfo *si,unsigned merge,GeometryInfo *info)
+#else
+HandleShapeBody(def,si,merge,info)
+    ShapeDef *		def;
+    ShapeInfo *		si;
+    unsigned 		merge;
+    GeometryInfo *	info;
+#endif
+{
+OutlineDef *	ol;
+int		nOut,nPt;
+XkbOutlinePtr 	outline;
+ExprDef *	pt;
+
+    if (def->nOutlines<1) {
+	WARN1("Shape \"%s\" has no outlines\n",shText(info->dpy,si));
+	ACTION("Definition ignored\n");
+	return True;
+    }
+    si->nOutlines= def->nOutlines;
+    si->outlines= uTypedCalloc(def->nOutlines,XkbOutlineRec);
+    if (!si->outlines) {
+	ERROR1("Couldn't allocate outlines for \"%s\"\n",shText(info->dpy,si));
+	ACTION("Definition ignored\n");
+	info->errorCount++;
+	return False;
+    }
+    for (nOut=0,ol=def->outlines;ol!=NULL;ol=(OutlineDef *)ol->common.next) {
+	if (ol->nPoints<1) {
+	    SetShapeField(si,XkbAtomGetString(NULL,ol->field),NULL,
+	    						ol->points,info);
+	    continue;
+	}
+	outline= NULL;
+	outline= &si->outlines[nOut++];
+	outline->num_points= ol->nPoints;
+	outline->corner_radius= si->dfltCornerRadius;
+	outline->points= uTypedCalloc(ol->nPoints,XkbPointRec);
+	if (!outline->points) {
+	    ERROR1("Can't allocate points for \"%s\"\n",shText(info->dpy,si));
+	    ACTION("Definition ignored\n");
+	    info->errorCount++;
+	    return False;
+	}
+	for (nPt=0,pt=ol->points;pt!=NULL;pt=(ExprDef *)pt->common.next) {
+	    outline->points[nPt].x= pt->value.coord.x;
+	    outline->points[nPt].y= pt->value.coord.y;
+	    nPt++;
+	}
+	if (ol->field!=None) {
+	    char *str= XkbAtomText(NULL,ol->field,XkbMessage);
+	    if ((uStrCaseCmp(str,"approximation")==0)||
+					      (uStrCaseCmp(str,"approx")==0)) {
+		if (si->approx==NULL)
+		    si->approx= outline;
+		else {
+		    WARN1("Multiple approximations for \"%s\"\n",
+		    					shText(info->dpy,si));
+		    ACTION("Treating all but the first as normal outlines\n");
+		}
+	    }
+	    else if (uStrCaseCmp(str,"primary")==0) {
+		if (si->primary==NULL)
+		    si->primary= outline;
+		else {
+		    WARN1("Multiple primary outlines for \"%s\"\n",
+							shText(info->dpy,si));
+		    ACTION("Treating all but the first as normal outlines\n");
+		}
+	    }
+	    else {
+		WARN2("Unknown outline type %s for \"%s\"\n",str,
+							shText(info->dpy,si));
+		ACTION("Treated as a normal outline\n");
+	    }
+	}
+    }
+    if (nOut!=si->nOutlines) {
+	WSGO2("Expected %d outlines, got %d\n",(unsigned int)si->nOutlines,
+									nOut);
+	si->nOutlines= nOut;
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleShapeDef(ShapeDef *def,XkbDescPtr xkb,unsigned merge,GeometryInfo *info)
+#else
+HandleShapeDef(def,xkb,merge,info)
+    ShapeDef *		def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    GeometryInfo *	info;
+#endif
+{
+ShapeInfo		si;
+
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+
+    bzero(&si,sizeof(ShapeInfo));
+    si.defs.merge= merge;
+    si.name= XkbInternAtom(info->dpy,XkbAtomGetString(NULL,def->name),False);
+    si.dfltCornerRadius= info->dfltCornerRadius;
+    if (!HandleShapeBody(def,&si,merge,info))
+	return False;
+    if (!AddShape(info,&si))
+	return False;
+    return True;
+}
+
+/***====================================================================***/
+
+static int
+#if NeedFunctionPrototypes
+HandleDoodadDef(	DoodadDef *def,
+			unsigned merge,
+			SectionInfo *si,
+			GeometryInfo *info)
+#else
+HandleDoodadDef(def,merge,si,info)
+    DoodadDef *		def;
+    unsigned		merge;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+ExprResult	elem,field;
+ExprDef *	ndx;
+DoodadInfo	new;
+VarDef *	var;
+    
+    if (def->common.stmtType==StmtIndicatorMapDef) {
+	IndicatorMapDef *imap= (IndicatorMapDef *)def;
+	Atom		name= imap->name;
+	VarDef *	body= imap->body;
+	def->common.stmtType= StmtDoodadDef;
+	def->type= XkbIndicatorDoodad;
+	def->name= name;
+	def->body= body;
+    }
+    InitDoodadInfo(&new,def->type,si,info);
+    new.name= XkbInternAtom(info->dpy,XkbAtomGetString(NULL,def->name),False);
+    for (var=def->body;var!=NULL;var= (VarDef *)var->common.next) {
+	if (ExprResolveLhs(var->name,&elem,&field,&ndx)==0) 
+	    return 0; /* internal error, already reported */
+	if (elem.str!=NULL) {
+	    WARN1("Assignment to field of unknown element in doodad %s\n",
+						ddText(info->dpy,&new));
+	    ACTION2("No value assigned to %s.%s\n",elem.str,field.str);
+	}
+	else if (!SetDoodadField(&new,field.str,ndx,var->value,si,info))
+	    return False;
+    }
+    if (!AddDoodad(si,info,&new))
+	return False;
+    ClearDoodadInfo(&new);
+    return True;
+}
+
+/***====================================================================***/
+
+static int
+#if NeedFunctionPrototypes
+HandleOverlayDef(	OverlayDef *	def,
+			unsigned 	merge,
+			SectionInfo *	si,
+			GeometryInfo *	info)
+#else
+HandleOverlayDef(def,merge,si,info)
+    OverlayDef *	def;
+    unsigned		merge;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+OverlayKeyDef *	keyDef;
+OverlayKeyInfo *key;
+OverlayInfo	ol;
+
+    if ((def->nKeys<1)&&(warningLevel>3)) {
+	WARN2("Overlay \"%s\" in section \"%s\" has no keys\n",
+					XkbAtomText(NULL,def->name,XkbMessage),
+					scText(info->dpy,si));
+	ACTION("Overlay ignored\n");
+	return True;
+    }
+    bzero(&ol,sizeof(OverlayInfo));
+    ol.name= XkbInternAtom(info->dpy,XkbAtomGetString(NULL,def->name),False);
+    for (keyDef= def->keys;keyDef;keyDef=(OverlayKeyDef *)keyDef->common.next) {
+	key= uTypedCalloc(1,OverlayKeyInfo);
+	if ((!key)&&warningLevel>0) {
+	    WSGO("Couldn't allocate OverlayKeyInfo\n");
+	    ACTION2("Overlay %s for section %s will be incomplete\n",
+					oiText(info->dpy,&ol),
+					scText(info->dpy,si));
+	    return False;
+	}
+	strncpy(key->over,keyDef->over,XkbKeyNameLength);
+	strncpy(key->under,keyDef->under,XkbKeyNameLength);
+	key->sectionRow= _GOK_UnknownRow;
+	key->overlayRow= _GOK_UnknownRow;
+	ol.keys= (OverlayKeyInfo *)AddCommonInfo(&ol.keys->defs,
+							(CommonInfo *)key);
+	ol.nKeys++;
+    }
+    if (!AddOverlay(si,info,&ol))
+	return False;
+    ClearOverlayInfo(&ol);
+    return True;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+HandleComplexKey(KeyDef *def,KeyInfo *key,GeometryInfo *info)
+#else
+HandleComplexKey(def,key,info)
+    KeyDef *		def;
+    KeyInfo *		key;
+    GeometryInfo *	info;
+#endif
+{
+RowInfo *	row;
+ExprDef *	expr;
+
+    row= key->row;
+    for (expr=def->expr;expr!=NULL;expr=(ExprDef *)expr->common.next) {
+	if (expr->op==OpAssign) {
+	    ExprResult elem,f;
+	    ExprDef *ndx;
+	    if (ExprResolveLhs(expr->value.binary.left,&elem,&f,&ndx)==0)
+		return False; /* internal error, already reported */
+	    if ((elem.str==NULL)||(uStrCaseCmp(elem.str,"key")==0)) {
+		if (!SetKeyField(key,f.str,ndx,expr->value.binary.right,info))
+		    return False;
+	    }
+	    else {
+		ERROR("Illegal element used in a key definition\n");
+		ACTION2("Assignment to %s.%s ignored\n",elem.str,f.str);
+		return False;
+	    }
+	}
+	else {
+	    switch (expr->type) {
+		case TypeInt: case TypeFloat:
+		    if (!SetKeyField(key,"gap",NULL,expr,info))
+			return False;
+		    break;
+		case TypeString:
+		    if (!SetKeyField(key,"shape",NULL,expr,info))
+			return False;
+		    break;
+		case TypeKeyName:
+		    if (!SetKeyField(key,"name",NULL,expr,info))
+			return False;
+		    break;
+		default:
+		    ERROR("Cannot determine field for unnamed expression\n");
+		    ACTION3("Ignoring key %d in row %d of section %s\n",
+					row->nKeys+1,row->section->nRows+1,
+					rowText(info->dpy,row));
+		    return False;
+	    }
+	}
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleRowBody(RowDef *def,RowInfo *row,unsigned merge,GeometryInfo *info)
+#else
+HandleRowBody(def,row,merge,info)
+    RowDef *		def;
+    RowInfo *		row;
+    unsigned 		merge;
+    GeometryInfo *	info;
+#endif
+{
+KeyDef *	keyDef;
+
+    if ((def->nKeys<1)&&(warningLevel>3)) {
+	ERROR1("Row in section %s has no keys\n",rowText(info->dpy,row));
+	ACTION("Section ignored\n");
+	return True;
+    }
+    for (keyDef= def->keys; keyDef!=NULL;keyDef=(KeyDef *)keyDef->common.next) {
+	if (keyDef->common.stmtType==StmtVarDef) {
+	    VarDef *var= (VarDef *)keyDef;
+	    ExprResult elem,field;
+	    ExprDef *ndx;
+	    if (ExprResolveLhs(var->name,&elem,&field,&ndx)==0) 
+		return 0; /* internal error, already reported */
+	    if ((elem.str==NULL)||(uStrCaseCmp(elem.str,"row")==0)) {
+		if (!SetRowField(row,field.str,ndx,var->value,info))
+		    return False;
+	    }
+	    else if (uStrCaseCmp(elem.str,"key")==0) {
+		if (!SetKeyField(&row->dfltKey,field.str,ndx,var->value,info))
+		    return False;
+	    }
+	    else {
+		WARN("Assignment to field of unknown element in row\n");
+		ACTION2("No value assigned to %s.%s\n",elem.str,field.str);
+	    }
+	}
+	else if (keyDef->common.stmtType==StmtKeyDef) {
+	    KeyInfo key;
+	    InitKeyInfo(&key,row,info);
+	    if (keyDef->name!=NULL) {
+		int len= strlen(keyDef->name);
+		if ((len<1)||(len>XkbKeyNameLength)) {
+		    ERROR2("Illegal name %s for key in section %s\n",
+						keyDef->name,
+						rowText(info->dpy,row));
+		    ACTION("Section not compiled\n");
+		    return False;
+		}
+		bzero(key.name,XkbKeyNameLength+1);
+		strncpy(key.name,keyDef->name,XkbKeyNameLength);
+		key.defs.defined|= _GK_Name;
+	    }
+	    else if (!HandleComplexKey(keyDef,&key,info))
+		return False;
+	    if (!AddKey(row,&key))
+		return False;
+	}
+	else {
+	    WSGO1("Unexpected statement (type %d) in row body\n",
+						     keyDef->common.stmtType);
+	    return False;
+	}
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSectionBody(	SectionDef *	def,
+			SectionInfo *	si,
+			unsigned 	merge,
+			GeometryInfo *	info)
+#else
+HandleSectionBody(def,si,merge,info)
+    SectionDef *	def;
+    SectionInfo *	si;
+    unsigned 		merge;
+    GeometryInfo *	info;
+#endif
+{
+RowDef *	rowDef;
+DoodadInfo *	di;
+
+    for (rowDef= def->rows;rowDef!=NULL;rowDef=(RowDef *)rowDef->common.next) {
+	if (rowDef->common.stmtType==StmtVarDef) {
+	    VarDef *var= (VarDef *)rowDef;
+	    ExprResult elem,field;
+	    ExprDef *ndx;
+	    if (ExprResolveLhs(var->name,&elem,&field,&ndx)==0) 
+		return 0; /* internal error, already reported */
+	    if ((elem.str==NULL)||(uStrCaseCmp(elem.str,"section")==0)) {
+		if (!SetSectionField(si,field.str,ndx,var->value,info))
+		    return False;
+	    }
+	    else if (uStrCaseCmp(elem.str,"row")==0) {
+		if (!SetRowField(&si->dfltRow,field.str,ndx,var->value,info))
+		    return False;
+	    }
+	    else if (uStrCaseCmp(elem.str,"key")==0) {
+		if(!SetKeyField(&si->dfltRow.dfltKey,field.str,ndx,
+							   var->value,info))
+		    return False;
+	    }
+	    else if ((di=FindDfltDoodadByTypeName(elem.str,si,info))!=NULL) {
+		if (!SetDoodadField(di,field.str,ndx,var->value,si,info))
+		    return False;
+	    }
+	    else {
+		WARN("Assignment to field of unknown element in section\n");
+		ACTION2("No value assigned to %s.%s\n",elem.str,field.str);
+	    }
+	}
+	else if (rowDef->common.stmtType==StmtRowDef) {
+	    RowInfo row;
+	    InitRowInfo(&row,si,info);
+	    if (!HandleRowBody(rowDef,&row,merge,info)) 
+		return False;
+	    if (!AddRow(si,&row))
+		return False;
+/*	    ClearRowInfo(&row,info);*/
+	}
+	else if ((rowDef->common.stmtType==StmtDoodadDef)||
+		 (rowDef->common.stmtType==StmtIndicatorMapDef)) {
+	    if (!HandleDoodadDef((DoodadDef *)rowDef,merge,si,info))
+		return False;
+	}
+	else if (rowDef->common.stmtType==StmtOverlayDef) {
+	    if (!HandleOverlayDef((OverlayDef *)rowDef,merge,si,info))
+		return False;
+	}
+	else {
+	    WSGO1("Unexpected statement (type %d) in section body\n",
+						     rowDef->common.stmtType);
+	    return False;
+	}
+    }
+    if (si->nRows!=def->nRows) {
+	WSGO2("Expected %d rows, found %d\n",(unsigned int)def->nRows,
+						(unsigned int)si->nRows);
+	ACTION1("Definition of section %s might be incorrect\n",
+						scText(info->dpy,si));
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleSectionDef(	SectionDef *	def,
+			XkbDescPtr 	xkb,
+			unsigned 	merge,
+			GeometryInfo *	info)
+#else
+HandleSectionDef(def,xkb,merge,info)
+    SectionDef *	def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    GeometryInfo *	info;
+#endif
+{
+SectionInfo 	si;
+char *	 	str;
+
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+    InitSectionInfo(&si,info);
+    si.defs.merge= merge;
+    str= XkbAtomGetString(NULL,def->name);
+    if ((str==NULL)||(strlen(str)<1)) {
+	ERROR("Section defined without a name\n");
+	ACTION("Definition ignored\n");
+	return False;
+    }
+    si.name= XkbInternAtom(info->dpy,XkbAtomGetString(NULL,def->name),False);
+    if (!HandleSectionBody(def,&si,merge,info))
+	return False;
+    if (!AddSection(info,&si))
+	return False;
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+HandleGeometryFile(	XkbFile *	file,
+			XkbDescPtr 	xkb,
+			unsigned 	merge,
+			GeometryInfo *	info)
+#else
+HandleGeometryFile(file,xkb,merge,info)
+    XkbFile *		file;
+    XkbDescPtr 		xkb;
+    unsigned		merge;
+    GeometryInfo *	info;
+#endif
+{
+ParseCommon *	stmt;
+char *		failWhat;
+
+    if (merge==MergeDefault)
+	merge= MergeAugment;
+    info->name= uStringDup(file->name);
+    stmt= file->defs;
+    while (stmt) {
+	failWhat= NULL;
+	switch (stmt->stmtType) {
+	    case StmtInclude:
+		if (!HandleIncludeGeometry((IncludeStmt *)stmt,xkb,info,
+							HandleGeometryFile))
+		    info->errorCount++;
+		break;
+	    case StmtKeyAliasDef:
+		if (!HandleAliasDef((KeyAliasDef *)stmt,
+					merge,info->fileID,&info->aliases)) {
+		    info->errorCount++;
+		}
+		break;
+	    case StmtVarDef:
+		if (!HandleGeometryVar((VarDef *)stmt,xkb,info))
+		    info->errorCount++;
+		break;
+	    case StmtShapeDef:
+		if (!HandleShapeDef((ShapeDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtSectionDef:
+		if (!HandleSectionDef((SectionDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtIndicatorMapDef:
+	    case StmtDoodadDef:
+		if (!HandleDoodadDef((DoodadDef *)stmt,merge,NULL,info))
+		    info->errorCount++;
+		break;
+	    case StmtVModDef:
+		if (!failWhat)	failWhat= "virtual modfier";
+	    case StmtInterpDef:
+		if (!failWhat)	failWhat= "symbol interpretation";
+	    case StmtGroupCompatDef:
+		if (!failWhat)	failWhat= "group compatibility map";
+	    case StmtKeycodeDef:
+		if (!failWhat)	failWhat= "key name";
+		ERROR("Interpretation files may not include other types\n");
+		ACTION1("Ignoring %s definition.\n",failWhat);
+		info->errorCount++;
+		break;
+	    default:
+		WSGO1("Unexpected statement type %d in HandleGeometryFile\n",
+								stmt->stmtType);
+		break;
+	}
+	stmt= stmt->next;
+	if (info->errorCount>10) {
+#ifdef NOISY
+	    ERROR("Too many errors\n");
+#endif
+	    ACTION1("Abandoning geometry file \"%s\"\n",file->topName);
+	    break;
+	}
+    }
+    return;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+CopyShapeDef(Display *dpy,XkbGeometryPtr geom,ShapeInfo *si)
+#else
+CopyShapeDef(dpy,geom,si)
+    Display *		dpy;
+    XkbGeometryPtr	geom;
+    ShapeInfo *		si;
+#endif
+{
+register int	i,n;
+XkbShapePtr	shape;
+XkbOutlinePtr	old_outline,outline;
+Atom		name;
+
+    si->index= geom->num_shapes;
+    name= XkbInternAtom(dpy,XkbAtomGetString(NULL,si->name),False);
+    shape= XkbAddGeomShape(geom,name,si->nOutlines);
+    if (!shape) {
+	WSGO("Couldn't allocate shape in geometry\n");
+	ACTION1("Shape %s not compiled\n",shText(dpy,si));
+	return False;
+    }
+    old_outline= si->outlines;
+    for (i=0;i<si->nOutlines;i++,old_outline++) {
+	outline= XkbAddGeomOutline(shape,old_outline->num_points);
+	if (!outline) {
+	    WSGO("Couldn't allocate outline in shape\n");
+	    ACTION1("Shape %s is incomplete\n",shText(dpy,si));
+	    return False;
+	}
+	n= old_outline->num_points;
+	memcpy(outline->points,old_outline->points,n*sizeof(XkbPointRec));
+	outline->num_points= old_outline->num_points;
+	outline->corner_radius= old_outline->corner_radius;
+    }
+    if (si->approx) {
+	n= (si->approx-si->outlines);
+	shape->approx= &shape->outlines[n];
+    }
+    if (si->primary) {
+	n= (si->primary-si->outlines);
+	shape->primary= &shape->outlines[n];
+    }
+    XkbComputeShapeBounds(shape);
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+VerifyDoodadInfo(DoodadInfo *di,GeometryInfo *info)
+#else
+VerifyDoodadInfo(di,info)
+    DoodadInfo *	di;
+    GeometryInfo *	info;
+#endif
+{
+    if ((di->defs.defined&(_GD_Top|_GD_Left))!=(_GD_Top|_GD_Left)) {
+	if (warningLevel<9) {
+	    ERROR1("No position defined for doodad %s\n",ddText(info->dpy,di));
+	    ACTION("Illegal doodad ignored\n");
+	    return False;
+	}
+    }
+    if (di->defs.defined&_GD_Priority==0) {
+	/* calculate priority -- should be just above previous doodad/row */
+    }
+    switch (di->type) {
+	case XkbOutlineDoodad:
+	case XkbSolidDoodad:
+	    if ((di->defs.defined&_GD_Shape)==0) {
+		ERROR2("No shape defined for %s doodad %s\n",
+			(di->type==XkbOutlineDoodad?"outline":"filled"),
+			ddText(info->dpy,di));
+		ACTION("Incomplete definition ignored\n");
+		return False;
+	    }
+	    else {
+		ShapeInfo *si;
+		si= FindShape(info,di->shape,	(di->type==XkbOutlineDoodad?
+		    					      "outline doodad":
+							      "solid doodad"),
+						ddText(info->dpy,di));
+		if (si)
+		    di->shape= si->name;
+		else {
+		    ERROR1("No legal shape for %s\n",ddText(info->dpy,di));
+		    ACTION("Incomplete definition ignored\n");
+		    return False;
+		}
+	    }
+	    if ((di->defs.defined&_GD_Color)==0) {
+		if (warningLevel>5) {
+		    WARN1("No color for doodad %s\n",ddText(info->dpy,di));
+		    ACTION("Using black\n");
+		}
+		di->color= XkbInternAtom(NULL,"black",False);
+	    }
+	    break;
+	case XkbTextDoodad:
+	    if ((di->defs.defined&_GD_Text)==0) {
+		ERROR1("No text specified for text doodad %s\n",
+							ddText(info->dpy,di));
+		ACTION("Illegal doodad definition ignored\n");
+		return False;
+	    }
+	    if ((di->defs.defined&_GD_Angle)==0)
+		di->angle= 0;
+	    if ((di->defs.defined&_GD_Color)==0) {
+		if (warningLevel>5) {
+		    WARN1("No color specified for doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION("Using black\n");
+		}
+		di->color= XkbInternAtom(NULL,"black",False);
+	    }
+	    if ((di->defs.defined&_GD_FontSpec)!=0) {
+		if ((di->defs.defined&_GD_FontParts)==0)
+		    return True;
+		if (warningLevel<9) {
+		    WARN1("Text doodad %s has full and partial font definition\n",
+							ddText(info->dpy,di));
+		    ACTION("Full specification ignored\n");
+		}
+		di->defs.defined&= ~_GD_FontSpec;
+		di->fontSpec= None;
+	    }
+	    if ((di->defs.defined&_GD_Font)==0) {
+		if (warningLevel>5) {
+		    WARN1("No font specified for doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_FONT);
+		}
+		di->font= XkbInternAtom(NULL,DFLT_FONT,False);
+	    }
+	    if ((di->defs.defined&_GD_FontSlant)==0) {
+		if (warningLevel>7) {
+		    WARN1("No font slant for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_SLANT);
+		}
+		di->fontSlant= XkbInternAtom(NULL,DFLT_SLANT,False);
+	    }
+	    if ((di->defs.defined&_GD_FontWeight)==0) {
+		if (warningLevel>7) {
+		    WARN1("No font weight for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_WEIGHT);
+		}
+		di->fontWeight= XkbInternAtom(NULL,DFLT_WEIGHT,False);
+	    }
+	    if ((di->defs.defined&_GD_FontSetWidth)==0) {
+		if (warningLevel>9) {
+		    WARN1("No font set width for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_SET_WIDTH);
+		}
+		di->fontSetWidth= XkbInternAtom(NULL,DFLT_SET_WIDTH,False);
+	    }
+	    if ((di->defs.defined&_GD_FontVariant)==0) {
+		if (warningLevel>9) {
+		    WARN1("No font variant for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_VARIANT);
+		}
+		di->fontVariant= XkbInternAtom(NULL,DFLT_VARIANT,False);
+	    }
+	    if ((di->defs.defined&_GD_FontEncoding)==0) {
+		if (warningLevel>7) {
+		    WARN1("No font encoding for doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using \"%s\"\n",DFLT_ENCODING);
+		}
+		di->fontEncoding= XkbInternAtom(NULL,DFLT_ENCODING,False);
+	    }
+	    if ((di->defs.defined&_GD_FontSize)==0) {
+		if (warningLevel>7) {
+		    WARN1("No font size for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using %s point text\n",
+					XkbGeomFPText(DFLT_SIZE,XkbMessage));
+		}
+		di->fontSize= DFLT_SIZE;
+	    }
+	    if ((di->defs.defined&_GD_Height)==0) {
+		unsigned size,nLines;
+		char *tmp;
+		size= (di->fontSize*120)/100;
+		size= (size*254)/720;		/* convert to mm/10 */
+		for (nLines=1,tmp=XkbAtomGetString(NULL,di->text);*tmp;tmp++) {
+		    if (*tmp=='\n')	nLines++;
+		}
+		size*= nLines;
+		if (warningLevel>5) {
+		    WARN1("No height for text doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION1("Using calculated height %s millimeters\n",
+						XkbGeomFPText(size,XkbMessage));
+		}
+		di->height= size;
+	    }
+	    if ((di->defs.defined&_GD_Width)==0) {
+		unsigned width,tmp;
+		char *str;
+		width= tmp= 0;
+		for (str=XkbAtomGetString(NULL,di->text);*str;str++) {
+		    if (*str!='\n')
+			tmp++;
+		    else {
+			if (tmp>width)
+			    width= tmp;
+			tmp= 1;
+		    }
+		}
+		if (width==0)
+		    width= tmp;
+		width*= (di->height*2)/3;
+		if (warningLevel>5) {
+		    WARN1("No width for text doodad %s\n",ddText(info->dpy,di));
+		    ACTION1("Using calculated width %s millimeters\n",
+					XkbGeomFPText(width,XkbMessage));
+		}
+		di->width= width;
+	    }
+	    break;
+	case XkbIndicatorDoodad:
+	    if ((di->defs.defined&_GD_Shape)==0) {
+		ERROR1("No shape defined for indicator doodad %s\n",
+							ddText(info->dpy,di));
+		ACTION("Incomplete definition ignored\n");
+		return False;
+	    }
+	    else {
+		ShapeInfo *si;
+		si= FindShape(info,di->shape,"indicator doodad",
+							ddText(info->dpy,di));
+		if (si)
+		    di->shape= si->name;
+		else {
+		    ERROR1("No legal shape for doodad %s\n",
+		    					ddText(info->dpy,di));
+		    ACTION("Incomplete definition ignored\n");
+		    return False;
+		}
+	    }
+	    if ((di->defs.defined&_GD_Color)==0) {
+		if (warningLevel>5) {
+		    WARN1("No \"on\" color for indicator doodad %s\n",
+							ddText(info->dpy,di));
+		    ACTION("Using green\n");
+		}
+		di->color= XkbInternAtom(NULL,"green",False);
+	    }
+	    if ((di->defs.defined&_GD_OffColor)==0) {
+		if (warningLevel>5) {
+		    WARN1("No \"off\" color for indicator doodad %s\n",
+							ddText(info->dpy,di));
+		    ACTION("Using black\n");
+		}
+		di->offColor= XkbInternAtom(NULL,"black",False);
+	    }
+	    break;
+	case XkbLogoDoodad:
+	    if (di->logoName==NULL)  {
+		ERROR1("No logo name defined for logo doodad %s\n",
+							ddText(info->dpy,di));
+		ACTION("Incomplete definition ignored\n");
+		return False;
+	    }
+	    if ((di->defs.defined&_GD_Shape)==0) {
+		ERROR1("No shape defined for logo doodad %s\n",
+							ddText(info->dpy,di));
+		ACTION("Incomplete definition ignored\n");
+		return False;
+	    }
+	    else {
+		ShapeInfo *si;
+		si= FindShape(info,di->shape,"logo doodad",
+							ddText(info->dpy,di));
+		if (si)
+		    di->shape= si->name;
+		else {
+		    ERROR1("No legal shape for %s\n",ddText(info->dpy,di));
+		    ACTION("Incomplete definition ignored\n");
+		    return False;
+		}
+	    }
+	    if ((di->defs.defined&_GD_Color)==0) {
+		if (warningLevel>5) {
+		    WARN1("No color for doodad %s\n",ddText(info->dpy,di));
+		    ACTION("Using black\n");
+		}
+		di->color= XkbInternAtom(NULL,"black",False);
+	    }
+	    break;
+	default:
+	    WSGO1("Uknown doodad type %d in VerifyDoodad\n",(unsigned int)di->type);
+	    return False;
+    }
+    return True;
+}
+
+#define	FONT_TEMPLATE	"-*-%s-%s-%s-%s-%s-*-%d-*-*-*-*-%s"
+
+static char *
+#if NeedFunctionPrototypes
+FontFromParts(	Atom	fontTok,
+    		Atom	weightTok,
+		Atom	slantTok,
+		Atom	setWidthTok,
+		Atom	varTok,
+		int	size,
+		Atom	encodingTok)
+#else
+FontFromParts(fontTok,weightTok,slantTok,setWidthTok,varTok,size,encodingTok)
+    Atom	fontTok;
+    Atom	weightTok;
+    Atom	slantTok;
+    Atom	setWidthTok;
+    Atom	varTok;
+    int		size;
+    Atom	encodingTok;
+#endif
+{
+int	totalSize;
+char 	*font,*weight,*slant,*setWidth,*variant,*encoding;
+char *	rtrn;
+
+   font= (fontTok!=None?XkbAtomGetString(NULL,fontTok):DFLT_FONT);
+   weight= (weightTok!=None?XkbAtomGetString(NULL,weightTok):DFLT_WEIGHT);
+   slant= (slantTok!=None?XkbAtomGetString(NULL,slantTok):DFLT_SLANT);
+   setWidth= (setWidthTok!=None?XkbAtomGetString(NULL,setWidthTok):
+				DFLT_SET_WIDTH);
+   variant= (varTok!=None?XkbAtomGetString(NULL,varTok):DFLT_VARIANT);
+   encoding= (encodingTok!=None?XkbAtomGetString(NULL,encodingTok):
+				DFLT_ENCODING);
+   if (size==0)
+	size= DFLT_SIZE;
+   totalSize= strlen(FONT_TEMPLATE)+strlen(font)+strlen(weight)+strlen(slant);
+   totalSize+= strlen(setWidth)+strlen(variant)+strlen(encoding);
+   rtrn= uCalloc(totalSize,1);
+   if (rtrn) {
+	sprintf(rtrn,FONT_TEMPLATE,font,weight,slant,setWidth,variant,
+								size,encoding);
+   }
+   return rtrn;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopyDoodadDef(	XkbGeometryPtr	geom,
+    		XkbSectionPtr	section,
+    		DoodadInfo *	di,
+    		GeometryInfo *	info)
+#else
+CopyDoodadDef(geom,section,di,info)
+    XkbGeometryPtr	geom;
+    XkbSectionPtr	section;
+    DoodadInfo *	di;
+    GeometryInfo *	info;
+#endif
+{
+Atom		name;
+XkbDoodadPtr	doodad;
+XkbColorPtr	color;
+XkbShapePtr	shape;
+ShapeInfo *	si;
+
+    if (!VerifyDoodadInfo(di,info))
+	return False;
+    name= XkbInternAtom(NULL,XkbAtomGetString(NULL,di->name),False);
+    doodad= XkbAddGeomDoodad(geom,section,name);
+    if (!doodad) {
+	WSGO1("Couldn't allocate doodad in %s\n",
+					(section?"section":"geometry"));
+	ACTION1("Cannot copy doodad %s\n",ddText(info->dpy,di));
+	return False;
+    }
+    doodad->any.type= di->type;
+    doodad->any.priority= di->priority;
+    doodad->any.top= di->top;
+    doodad->any.left= di->left;
+    switch (di->type) {
+	case XkbOutlineDoodad:
+	case XkbSolidDoodad:
+	    si= FindShape(info,di->shape,NULL,NULL);
+	    if (!si)
+		return False;
+	    doodad->shape.angle= di->angle;
+	    color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,di->color),geom->num_colors);
+	    shape= &geom->shapes[si->index];
+	    XkbSetShapeDoodadColor(geom,&doodad->shape,color);
+	    XkbSetShapeDoodadShape(geom,&doodad->shape,shape);
+	    break;
+	case XkbTextDoodad:
+	    doodad->text.angle= di->angle;
+	    doodad->text.width= di->width;
+	    doodad->text.height= di->height;
+	    if (di->fontSpec==None)
+		 doodad->text.font= FontFromParts(di->font,di->fontWeight,
+						di->fontSlant,di->fontSetWidth,
+						di->fontVariant,
+						di->fontSize,di->fontEncoding);
+	    else doodad->text.font= XkbAtomGetString(NULL,di->fontSpec);
+	    doodad->text.text= XkbAtomGetString(NULL,di->text);
+	    color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,di->color),geom->num_colors);
+	    XkbSetTextDoodadColor(geom,&doodad->text,color);
+	    break;
+	case XkbIndicatorDoodad:
+	    si= FindShape(info,di->shape,NULL,NULL);
+	    if (!si)
+		return False;
+	    shape= &geom->shapes[si->index];
+	    color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,di->color),geom->num_colors);
+	    XkbSetIndicatorDoodadShape(geom,&doodad->indicator,shape);
+	    XkbSetIndicatorDoodadOnColor(geom,&doodad->indicator,color);
+	    color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,di->offColor),geom->num_colors);
+	    XkbSetIndicatorDoodadOffColor(geom,&doodad->indicator,color);
+	    break;
+	case XkbLogoDoodad:
+	    si= FindShape(info,di->shape,NULL,NULL);
+	    if (!si)
+		return False;
+	    doodad->logo.angle= di->angle;
+	    color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,di->color),geom->num_colors);
+	    shape= &geom->shapes[si->index];
+	    XkbSetLogoDoodadColor(geom,&doodad->logo,color);
+	    XkbSetLogoDoodadShape(geom,&doodad->logo,shape);
+	    doodad->logo.logo_name= di->logoName;
+	    di->logoName= NULL;
+	    break;
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+VerifyOverlayInfo(	XkbGeometryPtr	geom,
+			XkbSectionPtr	section,
+			OverlayInfo *	oi,
+			GeometryInfo *	info,
+			short		rowMap[256],
+			short		rowSize[256])
+#else
+VerifyOverlayInfo(geom,section,oi,info,rowMap,rowSize)
+    XkbGeometryPtr	geom;
+    XkbSectionPtr	section;
+    OverlayInfo *	oi;
+    GeometryInfo *	info;
+    short		rowMap[256];
+    short		rowSize[256];
+#endif
+{
+register OverlayKeyInfo *	ki,*next;
+unsigned long			oKey,uKey,sKey;
+XkbRowPtr			row;
+XkbKeyPtr			key;
+int				r,k;
+
+    /* find out which row each key is in */
+    for (ki=oi->keys;ki!=NULL;ki=(OverlayKeyInfo *)ki->defs.next) {
+	oKey= KeyNameToLong(ki->over);
+	uKey= KeyNameToLong(ki->under);
+	for (r=0,row=section->rows;(r<section->num_rows)&&oKey;r++,row++) {
+	    for (k=0,key=row->keys;(k<row->num_keys)&&oKey;k++,key++) {
+		sKey= KeyNameToLong(key->name.name);
+		if (sKey==oKey) {
+		    if (warningLevel>0) {
+		       WARN3("Key %s in section \"%s\" and overlay \"%s\"\n",
+				XkbKeyNameText(key->name.name,XkbMessage),
+				XkbAtomText(info->dpy,section->name,XkbMessage),
+				XkbAtomText(info->dpy,oi->name,XkbMessage));
+			ACTION("Overlay definition ignored\n");
+		    }
+		    oKey= 0;
+		}
+		else if (sKey==uKey) {
+		    ki->sectionRow= r;
+		    oKey= 0;
+		}
+	    }
+	}
+	if ((ki->sectionRow==_GOK_UnknownRow)&&(warningLevel>0)) {
+	    WARN3("Key %s not in \"%s\", but has an overlay key in \"%s\"\n",
+				XkbKeyNameText(ki->under,XkbMessage),
+				XkbAtomText(info->dpy,section->name,XkbMessage),
+				XkbAtomText(info->dpy,oi->name,XkbMessage));
+	    ACTION("Definition ignored\n");
+	}
+    }
+    /* now prune out keys that aren't in the section */
+    while ((oi->keys!=NULL)&&(oi->keys->sectionRow==_GOK_UnknownRow)) {
+	next= (OverlayKeyInfo *)oi->keys->defs.next;
+	uFree(oi->keys);
+	oi->keys= next;
+	oi->nKeys--;
+    }
+    for (ki=oi->keys;(ki!=NULL)&&(ki->defs.next!=NULL);ki=next) {
+	next= (OverlayKeyInfo *)ki->defs.next;
+	if (next->sectionRow==_GOK_UnknownRow) {
+	    ki->defs.next= next->defs.next; 
+	    oi->nKeys--;
+	    uFree(next);
+	    next= (OverlayKeyInfo *)ki->defs.next;
+	}
+    }
+    if (oi->nKeys<1) {
+	ERROR2("Overlay \"%s\" for section \"%s\" has no legal keys\n",
+			       XkbAtomText(info->dpy,oi->name,XkbMessage),
+			       XkbAtomText(info->dpy,section->name,XkbMessage));
+	ACTION("Overlay definition ignored\n");
+	return False;
+    }
+    /* now figure out how many rows are defined for the overlay */
+    bzero(rowSize,sizeof(short)*256);
+    for (k=0;k<256;k++) {
+	rowMap[k]= -1;
+    }
+    oi->nRows= 0;
+    for (ki=oi->keys;ki!=NULL;ki=(OverlayKeyInfo *)ki->defs.next) {
+	if (rowMap[ki->sectionRow]==-1)
+	    rowMap[ki->sectionRow]= oi->nRows++;
+	ki->overlayRow= rowMap[ki->sectionRow];
+	rowSize[ki->overlayRow]++;
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopyOverlayDef(	XkbGeometryPtr	geom,
+		XkbSectionPtr	section,
+		OverlayInfo *	oi,
+		GeometryInfo *	info)
+#else
+CopyOverlayDef(geom,section,oi,info)
+    XkbGeometryPtr	geom;
+    XkbSectionPtr	section;
+    OverlayInfo *	oi;
+    GeometryInfo *	info;
+#endif
+{
+Atom			name;
+XkbOverlayPtr		ol;
+XkbOverlayRowPtr	row;
+XkbOverlayKeyPtr	key;
+OverlayKeyInfo *	ki;
+short			rowMap[256],rowSize[256];
+int			i;
+
+    if (!VerifyOverlayInfo(geom,section,oi,info,rowMap,rowSize))
+	return False;
+    name= XkbInternAtom(NULL,XkbAtomGetString(NULL,oi->name),False);
+    ol= XkbAddGeomOverlay(section,name,oi->nRows);
+    if (!ol) {
+	WSGO2("Couldn't add overlay \"%s\" to section \"%s\"\n",
+			XkbAtomText(info->dpy,name,XkbMessage),
+			XkbAtomText(info->dpy,section->name,XkbMessage));
+	return False;
+    }
+    for (i=0;i<oi->nRows;i++) {
+	int tmp,row_under;
+	for (tmp=0,row_under=-1;(tmp<section->num_rows)&&(row_under<0);tmp++) {
+	    if (rowMap[tmp]==i)
+		row_under= tmp;
+	}
+	if (!XkbAddGeomOverlayRow(ol,row_under,rowSize[i])) {
+	WSGO3("Can't add row %d to overlay \"%s\" of section \"%s\"\n",
+			i,XkbAtomText(info->dpy,name,XkbMessage),
+			XkbAtomText(info->dpy,section->name,XkbMessage));
+	    return False;
+	}
+    }
+    for (ki=oi->keys;ki!=NULL;ki=(OverlayKeyInfo *)ki->defs.next) {
+	row= &ol->rows[ki->overlayRow];
+	key= &row->keys[row->num_keys++];
+	bzero(key,sizeof(XkbOverlayKeyRec));
+	strncpy(key->over.name,ki->over,XkbKeyNameLength);
+	strncpy(key->under.name,ki->under,XkbKeyNameLength);
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+CopySectionDef(XkbGeometryPtr geom,SectionInfo *si,GeometryInfo *info)
+#else
+CopySectionDef(geom,si,info)
+    XkbGeometryPtr	geom;
+    SectionInfo *	si;
+    GeometryInfo *	info;
+#endif
+{
+XkbSectionPtr	section;
+XkbRowPtr	row;
+XkbKeyPtr	key;
+KeyInfo *	ki;
+RowInfo *	ri;
+Atom		name;
+
+    name= XkbInternAtom(NULL,XkbAtomGetString(NULL,si->name),False);
+    section= XkbAddGeomSection(geom,name,si->nRows,si->nDoodads,si->nOverlays);
+    if (section==NULL) {
+	WSGO("Couldn't allocate section in geometry\n");
+	ACTION1("Section %s not compiled\n",scText(info->dpy,si));
+	return False;
+    }
+    section->top= si->top;
+    section->left= si->left;
+    section->width= si->width;
+    section->height= si->height;
+    section->angle= si->angle;
+    section->priority= si->priority;
+    for (ri=si->rows;ri!=NULL;ri=(RowInfo *)ri->defs.next) {
+	row= XkbAddGeomRow(section,ri->nKeys);
+	if (row==NULL) {
+	    WSGO("Couldn't allocate row in section\n");
+	    ACTION1("Section %s is incomplete\n",scText(info->dpy,si));
+	    return False;
+	}
+	row->top= ri->top;
+	row->left= ri->left;
+	row->vertical= ri->vertical;
+	for (ki=ri->keys;ki!=NULL;ki=(KeyInfo *)ki->defs.next) {
+	    XkbColorPtr	color;
+	    if ((ki->defs.defined&_GK_Name)==0) {
+		ERROR3("Key %d of row %d in section %s has no name\n",
+						(int)ki->index,(int)ri->index,
+						scText(info->dpy,si));
+		ACTION1("Section %s ignored\n",scText(info->dpy,si));
+		return False;
+	    }
+	    key= XkbAddGeomKey(row);
+	    if (key==NULL) {
+		WSGO("Couldn't allocate key in row\n");
+		ACTION1("Section %s is incomplete\n",scText(info->dpy,si));
+		return False;
+	    }
+	    memcpy(key->name.name,ki->name,XkbKeyNameLength);
+	    key->gap= ki->gap;
+	    if (ki->shape==None)
+		 key->shape_ndx= 0;
+	    else {
+		ShapeInfo *si;
+		si= FindShape(info,ki->shape,"key",keyText(ki));
+		if (!si)
+		    return False;
+		key->shape_ndx= si->index;
+	    }
+	    if (ki->color!=None)
+		 color= XkbAddGeomColor(geom,XkbAtomGetString(NULL,ki->color),geom->num_colors);
+	    else color= XkbAddGeomColor(geom,"white",geom->num_colors);
+	    XkbSetKeyColor(geom,key,color);
+	}
+    }
+    if (si->doodads!=NULL) {
+	DoodadInfo *di;
+	for (di=si->doodads;di!=NULL;di=(DoodadInfo *)di->defs.next) {
+	    CopyDoodadDef(geom,section,di,info);
+	}
+    }
+    if (si->overlays!=NULL) {
+	OverlayInfo *oi;
+	for (oi=si->overlays;oi!=NULL;oi=(OverlayInfo *)oi->defs.next) {
+	    CopyOverlayDef(geom,section,oi,info);
+	}
+    }
+    if (XkbComputeSectionBounds(geom,section)) {
+	/* 7/6/94 (ef) --  check for negative origin and translate */
+	if ((si->defs.defined&_GS_Width)==0)
+	    section->width= section->bounds.x2;
+	if ((si->defs.defined&_GS_Height)==0)
+	    section->height= section->bounds.y2;
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+CompileGeometry(XkbFile *file,XkbFileInfo *result,unsigned merge)
+#else
+CompileGeometry(file,result,merge)
+    XkbFile *		file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+#endif
+{
+GeometryInfo	info;
+XkbDescPtr	xkb;
+
+    xkb= result->xkb;
+    InitGeometryInfo(&info,file->id,merge);
+    info.dpy= xkb->dpy;
+    HandleGeometryFile(file,xkb,merge,&info);
+
+    if (info.errorCount==0) {
+	XkbGeometryPtr	geom;
+	XkbGeometrySizesRec sizes;
+	bzero(&sizes,sizeof(sizes));
+	sizes.which= XkbGeomAllMask;
+	sizes.num_properties= info.nProps;
+	sizes.num_colors= 8;
+	sizes.num_shapes= info.nShapes;
+	sizes.num_sections= info.nSections;
+	sizes.num_doodads= info.nDoodads;
+	if (XkbAllocGeometry(xkb,&sizes)!=Success) {
+	    WSGO("Couldn't allocate GeometryRec\n");
+	    ACTION("Geometry not compiled\n");
+	    return False;
+	}
+	geom= xkb->geom;
+
+	geom->width_mm= info.widthMM;
+	geom->height_mm= info.heightMM;
+	if (info.name!=NULL) {
+	    geom->name= XkbInternAtom(xkb->dpy,info.name,False);
+	    if (XkbAllocNames(xkb,XkbGeometryNameMask,0,0)==Success)
+		xkb->names->geometry= geom->name;
+	}
+	if (info.fontSpec!=None)
+	     geom->label_font= uStringDup(XkbAtomGetString(NULL,info.fontSpec));
+	else geom->label_font= FontFromParts(info.font,info.fontWeight,
+					     info.fontSlant,info.fontSetWidth,
+					     info.fontVariant,
+					     info.fontSize,info.fontEncoding);
+	XkbAddGeomColor(geom,"black",geom->num_colors);
+	XkbAddGeomColor(geom,"white",geom->num_colors);
+
+	if (info.baseColor==None)
+	    info.baseColor= XkbInternAtom(NULL,"white",False);
+	if (info.labelColor==None)
+	    info.labelColor= XkbInternAtom(NULL,"black",False);
+	geom->base_color= 
+		XkbAddGeomColor(geom,XkbAtomGetString(NULL,info.baseColor),geom->num_colors);
+	geom->label_color= 
+		XkbAddGeomColor(geom,XkbAtomGetString(NULL,info.labelColor),geom->num_colors);
+
+	if (info.props) {
+	    PropertyInfo *pi;
+	    for (pi= info.props;pi!=NULL;pi=(PropertyInfo *)pi->defs.next) {
+		if (!XkbAddGeomProperty(geom,pi->name,pi->value))
+		    return False;
+	    }
+	}
+	if (info.shapes) {
+	    ShapeInfo *si;
+	    for (si= info.shapes;si!=NULL;si=(ShapeInfo *)si->defs.next) {
+		if (!CopyShapeDef(xkb->dpy,geom,si))
+		    return False;
+	    }
+	}
+	if (info.sections) {
+	    SectionInfo *si;
+	    for (si= info.sections;si!=NULL;si=(SectionInfo *)si->defs.next) {
+		if (!CopySectionDef(geom,si,&info))
+		    return False;
+	    }
+	}
+	if (info.doodads) {
+	    DoodadInfo *di;
+	    for (di= info.doodads;di!=NULL;di=(DoodadInfo *)di->defs.next) {
+		if (!CopyDoodadDef(geom,NULL,di,&info))
+		    return False;
+	    }
+	}
+	if (info.aliases)
+	    ApplyAliases(xkb,True,&info.aliases);
+	ClearGeometryInfo(&info);
+	return True;
+    }
+    return False;
+}
diff --git a/indicators.c b/indicators.c
new file mode 100644
index 0000000..cb09da9
--- /dev/null
+++ b/indicators.c
@@ -0,0 +1,535 @@
+/* $Xorg: indicators.c,v 1.3 2000/08/17 19:54:31 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "misc.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "indicators.h"
+
+/***====================================================================***/
+
+#define	ReportIndicatorBadType(d,l,f,w)	\
+		ReportBadType("indicator map",(f),\
+		      	XkbAtomText((d),(l)->name,XkbMessage),(w))
+#define	ReportIndicatorNotArray(d,l,f)	\
+		ReportNotArray("indicator map",(f),\
+			XkbAtomText((d),(l)->name,XkbMessage))
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+ClearIndicatorMapInfo(Display *dpy,LEDInfo *info)
+#else
+ClearIndicatorMapInfo(dpy,info)
+    Display *		dpy;
+    LEDInfo *	info;
+#endif
+{
+    info->name= 	XkbInternAtom(dpy,"default",False);
+    info->indicator=	_LED_NotBound;
+    info->flags= info->which_mods= info->real_mods= 0;
+    info->vmods= 0;
+    info->which_groups= info->groups= 0;
+    info->ctrls= 0;
+    return;
+}
+
+LEDInfo *
+#if NeedFunctionPrototypes
+AddIndicatorMap(LEDInfo *oldLEDs,LEDInfo *new)
+#else
+AddIndicatorMap(oldLEDs,new)
+    LEDInfo *	oldLEDs;
+    LEDInfo *	new;
+#endif
+{
+LEDInfo *old,*last;
+unsigned collide;
+
+    last= NULL;
+    for (old=oldLEDs;old!=NULL;old=(LEDInfo *)old->defs.next) {
+	if (old->name==new->name) {
+	    if ((old->real_mods==new->real_mods)&&
+		(old->vmods==new->vmods)&&
+		(old->groups==new->groups)&&
+		(old->ctrls==new->ctrls)&&
+		(old->which_mods==new->which_mods)&&
+		(old->which_groups==new->which_groups)) {
+		old->defs.defined|= new->defs.defined;
+		return oldLEDs;
+	    }
+	    if (new->defs.merge==MergeReplace) {
+		CommonInfo *next= old->defs.next;
+		if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		   					   (warningLevel>9)) {
+		    WARN1("Map for indicator %s redefined\n",
+				  XkbAtomText(NULL,old->name,XkbMessage));
+		    ACTION("Earlier definition ignored\n");
+		}
+		*old= *new;
+		old->defs.next= next;
+		return oldLEDs;
+	    }
+	    collide= 0;
+	    if (UseNewField(_LED_Index,&old->defs,&new->defs,&collide)) {
+		old->indicator= new->indicator;
+		old->defs.defined|= _LED_Index;
+	    }
+	    if (UseNewField(_LED_Mods,&old->defs,&new->defs,&collide)) {
+		old->which_mods= new->which_mods;
+		old->real_mods= new->real_mods;
+		old->vmods= new->vmods;
+		old->defs.defined|= _LED_Mods;
+	    }
+	    if (UseNewField(_LED_Groups,&old->defs,&new->defs,&collide)) {
+		old->which_groups= new->which_groups;
+		old->groups= new->groups;
+		old->defs.defined|= _LED_Groups;
+	    }
+	    if (UseNewField(_LED_Ctrls,&old->defs,&new->defs,&collide)) {
+		old->ctrls= new->ctrls;
+		old->defs.defined|= _LED_Ctrls;
+	    }
+	    if (UseNewField(_LED_Explicit,&old->defs,&new->defs,&collide)) {
+		old->flags&= ~XkbIM_NoExplicit;
+		old->flags|= (new->flags&XkbIM_NoExplicit);
+		old->defs.defined|= _LED_Explicit;
+	    }
+	    if (UseNewField(_LED_Automatic,&old->defs,&new->defs,&collide)) {
+		old->flags&= ~XkbIM_NoAutomatic;
+		old->flags|= (new->flags&XkbIM_NoAutomatic);
+		old->defs.defined|= _LED_Automatic;
+	    }
+	    if (UseNewField(_LED_DrivesKbd,&old->defs,&new->defs,&collide)) {
+		old->flags&= ~XkbIM_LEDDrivesKB;
+		old->flags|= (new->flags&XkbIM_LEDDrivesKB);
+		old->defs.defined|= _LED_DrivesKbd;
+	    }
+	    if (collide) {
+		WARN1("Map for indicator %s redefined\n",
+				XkbAtomText(NULL,old->name,XkbMessage));
+		ACTION1("Using %s definition for duplicate fields\n",
+				(new->defs.merge==MergeAugment?"first":"last"));
+	    }
+	    return oldLEDs;
+	}
+	if (old->defs.next==NULL)
+	    last= old;
+    }
+    /* new definition */
+    old= uTypedAlloc(LEDInfo);
+    if (!old) {
+	WSGO("Couldn't allocate indicator map\n");
+	ACTION1("Map for indicator %s not compiled\n",
+				XkbAtomText(NULL,new->name,XkbMessage));
+	return False;
+    }
+    *old= *new;
+    old->defs.next= NULL;
+    if (last) {
+	last->defs.next= &old->defs;
+	return oldLEDs;
+    }
+    return old;
+}
+
+LookupEntry	modComponentNames[] = {
+	{	"base",		XkbIM_UseBase		},
+	{	"latched",	XkbIM_UseLatched	},
+	{	"locked",	XkbIM_UseLocked		},
+	{	"effective",	XkbIM_UseEffective	},
+	{	"compat",	XkbIM_UseCompat		},
+	{	"any",		XkbIM_UseAnyMods	},
+	{	"none",		0			},
+	{	NULL,		0			}
+};
+LookupEntry	groupComponentNames[] = {
+	{	"latched",	XkbIM_UseLatched	},
+	{	"locked",	XkbIM_UseLocked		},
+	{	"effective",	XkbIM_UseEffective	},
+	{	"any",		XkbIM_UseAnyGroup	},
+	{	"none",		0			},
+	{	NULL,		0			}
+};
+
+int
+#if NeedFunctionPrototypes
+SetIndicatorMapField(	LEDInfo *	led,
+			XkbDescPtr 	xkb,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value)
+#else
+SetIndicatorMapField(led,xkb,field,arrayNdx,value)
+    LEDInfo *	led;
+    XkbDescPtr	xkb;
+    char *	field;
+    ExprDef *	arrayNdx;
+    ExprDef *	value;
+#endif
+{
+ExprResult	rtrn;
+Bool		ok;
+
+    ok= True;
+    if ((uStrCaseCmp(field,"modifiers")==0)||(uStrCaseCmp(field,"mods")==0)) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveModMask(value,&rtrn,LookupVModMask,(XPointer)xkb))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"modifier mask");
+	led->real_mods= rtrn.uval&0xff;
+	led->vmods= (rtrn.uval>>8)&0xff;
+	led->defs.defined|= _LED_Mods;
+    }
+    else if (uStrCaseCmp(field,"groups")==0) {
+	extern LookupEntry	groupNames[];
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveMask(value,&rtrn,SimpleLookup,(XPointer)groupNames))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"group mask");
+	led->groups= rtrn.uval;
+	led->defs.defined|= _LED_Groups;
+    }
+    else if ((uStrCaseCmp(field,"controls")==0)||
+	     (uStrCaseCmp(field,"ctrls")==0)) {
+	extern LookupEntry ctrlNames[];
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveMask(value,&rtrn,SimpleLookup,(XPointer)ctrlNames))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"controls mask");
+	led->ctrls= rtrn.uval;
+	led->defs.defined|= _LED_Ctrls;
+    }
+    else if (uStrCaseCmp(field,"allowexplicit")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveBoolean(value,&rtrn,NULL,NULL))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"boolean");
+	if (rtrn.uval)	led->flags&= ~XkbIM_NoExplicit;
+	else		led->flags|=  XkbIM_NoExplicit;
+	led->defs.defined|= _LED_Explicit;
+    }
+    else if ((uStrCaseCmp(field,"whichmodstate")==0)||
+	     (uStrCaseCmp(field,"whichmodifierstate")==0)) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveMask(value,&rtrn,SimpleLookup,
+						(XPointer)modComponentNames)) {
+	    return ReportIndicatorBadType(xkb->dpy,led,field,
+    					"mask of modifier state components");
+	}
+	led->which_mods= rtrn.uval;
+    }
+    else if (uStrCaseCmp(field,"whichgroupstate")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveMask(value,&rtrn,SimpleLookup,
+						(XPointer)groupComponentNames)){
+	    return ReportIndicatorBadType(xkb->dpy,led,field,
+					"mask of group state components");
+	}
+	if ((rtrn.uval&XkbIM_UseCompat)&&(warningLevel>0)) {
+	    WARN("Cannot use the compatibilty state for groups\n");
+	    ACTION2("Not set in the %s field of the map for indicator %s\n",
+				field,
+				XkbAtomText(NULL,led->name,XkbMessage));
+	    rtrn.uval&= ~XkbIM_UseCompat;
+	}
+	led->which_groups= rtrn.uval;
+    } 
+    else if ((uStrCaseCmp(field,"driveskbd")==0)||
+	     (uStrCaseCmp(field,"driveskeyboard")==0)||
+	     (uStrCaseCmp(field,"leddriveskbd")==0)||
+	     (uStrCaseCmp(field,"leddriveskeyboard")==0)||
+	     (uStrCaseCmp(field,"indicatordriveskbd")==0)||
+	     (uStrCaseCmp(field,"indicatordriveskeyboard")==0)) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveBoolean(value,&rtrn,NULL,NULL))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"boolean");
+	if (rtrn.uval)	led->flags|=  XkbIM_LEDDrivesKB;
+	else		led->flags&= ~XkbIM_LEDDrivesKB;
+	led->defs.defined|= _LED_DrivesKbd;
+    }
+    else if (uStrCaseCmp(field,"index")==0) {
+	if (arrayNdx!=NULL)
+	    return ReportIndicatorNotArray(xkb->dpy,led,field);
+	if (!ExprResolveInteger(value,&rtrn,NULL,NULL))
+	    return ReportIndicatorBadType(xkb->dpy,led,field,"indicator index");
+	if ((rtrn.uval<1)||(rtrn.uval>32)) {
+	    ERROR2("Illegal indicator index %d (range 1..%d)\n",rtrn.uval,
+							XkbNumIndicators);
+	    ACTION1("Index definition for %s indicator ignored\n",
+				XkbAtomText(NULL,led->name,XkbMessage));
+	    return False;
+	}
+	led->indicator= rtrn.uval;
+	led->defs.defined|= _LED_Index;
+    }
+    else {
+	ERROR2("Unknown field %s in map for %s indicator\n",field,
+				XkbAtomText(NULL,led->name,XkbMessage));
+	ACTION("Definition ignored\n");
+	ok= False;
+    }
+    return ok;
+}
+
+LEDInfo *
+#if NeedFunctionPrototypes
+HandleIndicatorMapDef(	IndicatorMapDef *	def,
+			XkbDescPtr		xkb,
+			LEDInfo *		dflt,
+			LEDInfo *		oldLEDs,
+			unsigned 		merge)
+#else
+HandleIndicatorMapDef(def,xkb,dflt,oldLEDs,merge)
+    IndicatorMapDef *	def;
+    XkbDescPtr		xkb;
+    LEDInfo *		dflt;
+    LEDInfo *		oldLEDs;
+    unsigned 		merge;
+#endif
+{
+LEDInfo			led,*rtrn;
+VarDef *		var;
+Bool			ok;
+ 
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+
+    led= *dflt;
+    led.defs.merge= merge;
+    led.name= def->name;
+
+    ok= True;
+    for (var= def->body;var!=NULL;var= (VarDef *)var->common.next) {
+	ExprResult	elem,field;
+	ExprDef *	arrayNdx;
+	if (!ExprResolveLhs(var->name,&elem,&field,&arrayNdx)) {
+	    ok= False;
+	    continue;
+	}
+	if (elem.str!=NULL) {
+	    ERROR1("Cannot set defaults for \"%s\" element in indicator map\n",
+								elem.str);
+	    ACTION2("Assignment to %s.%s ignored\n",elem.str,field.str);
+	    ok= False;
+	}
+	else {
+	    ok=SetIndicatorMapField(&led,xkb,field.str,arrayNdx,var->value)&&ok;
+	}
+    }
+    if (ok) {
+	rtrn= AddIndicatorMap(oldLEDs,&led);
+	return rtrn;
+    }
+    return NULL;
+}
+
+Bool 
+#if NeedFunctionPrototypes
+CopyIndicatorMapDefs(XkbFileInfo *result,LEDInfo *leds,LEDInfo **unboundRtrn)
+#else
+CopyIndicatorMapDefs(result,leds,unboundRtrn)
+    XkbFileInfo *	result;
+    LEDInfo *		leds;
+    LEDInfo **		unboundRtrn;
+#endif
+{
+LEDInfo *		led,*next;
+LEDInfo *		unbound,*last;
+XkbDescPtr		xkb;
+
+    xkb= result->xkb;
+    if (XkbAllocNames(xkb,XkbIndicatorNamesMask,0,0)!=Success) {
+	WSGO("Couldn't allocate names\n");
+	ACTION("Indicator names may be incorrect\n");
+    }
+    if (XkbAllocIndicatorMaps(xkb)!=Success) {
+	WSGO("Can't allocate indicator maps\n");
+	ACTION("Indicator map definitions may be lost\n");
+	return False;
+    }
+    last= unbound= (unboundRtrn?*unboundRtrn:NULL);
+    while ((last!=NULL) && (last->defs.next!=NULL)) {
+	last= (LEDInfo *)last->defs.next;
+    }
+    for (led=leds;led!=NULL;led=next) {
+	next= (LEDInfo *)led->defs.next;
+	if ((led->groups!=0)&&(led->which_groups==0)) 
+	    led->which_groups= XkbIM_UseEffective;
+	if ((led->which_mods==0)&&((led->real_mods)||(led->vmods)))
+	    led->which_mods= XkbIM_UseEffective;
+	if ((led->indicator==_LED_NotBound)||(!xkb->indicators)) {
+	    if (unboundRtrn!=NULL) {
+		led->defs.next= NULL;
+		if (last!=NULL) 	last->defs.next= (CommonInfo *)led;
+		else			unbound= led;
+		last= led;
+	    }
+	    else uFree(led);
+	}
+	else {
+	    register XkbIndicatorMapPtr im;
+	    im= &xkb->indicators->maps[led->indicator-1];
+	    im->flags= led->flags;
+	    im->which_groups= led->which_groups;
+	    im->groups= led->groups;
+	    im->which_mods= led->which_mods;
+	    im->mods.mask= led->real_mods;
+	    im->mods.real_mods= led->real_mods;
+	    im->mods.vmods= led->vmods;
+	    im->ctrls= led->ctrls;
+	    if (xkb->names!=NULL)
+		xkb->names->indicators[led->indicator-1]= led->name;
+	    uFree(led);
+	}
+    }
+    if (unboundRtrn!=NULL) {
+	*unboundRtrn= unbound;
+    }
+    return True;
+}
+
+Bool
+#if NeedFunctionPrototypes
+BindIndicators(	XkbFileInfo *	result,
+		Bool		force,
+		LEDInfo *	unbound,
+		LEDInfo **	unboundRtrn)
+#else
+BindIndicators(result,force,unbound,unboundRtrn)
+    XkbFileInfo *	result;
+    Bool		force;
+    LEDInfo *		unbound;
+    LEDInfo **		unboundRtrn;
+#endif
+{
+XkbDescPtr		xkb;
+register int 		i;
+register LEDInfo	 *led,*next,*last;
+
+    xkb= result->xkb;
+    if (xkb->names!=NULL) {
+	for (led=unbound;led!=NULL;led= (LEDInfo *)led->defs.next) {
+	    if (led->indicator==_LED_NotBound) {
+		for (i=0;i<XkbNumIndicators;i++) {
+		    if (xkb->names->indicators[i]==led->name) {
+			led->indicator= i+1;
+			break;
+		    }
+		}
+	    }
+	}
+	if (force) {
+	    for (led=unbound;led!=NULL;led= (LEDInfo *)led->defs.next) {
+		if (led->indicator==_LED_NotBound) {
+		    for (i=0;i<XkbNumIndicators;i++) {
+			if (xkb->names->indicators[i]==None) {
+			    xkb->names->indicators[i]= led->name;
+			    led->indicator= i+1;
+			    xkb->indicators->phys_indicators&= ~(1<<i);
+			    break;
+			}
+		    }
+		    if (led->indicator==_LED_NotBound) {
+			ERROR("No unnamed indicators found\n");
+			ACTION1("Virtual indicator map \"%s\" not bound\n",
+				XkbAtomGetString(xkb->dpy,led->name));
+			continue;
+		    }
+		}
+	    }
+	}
+    }
+    for (last=NULL,led=unbound;led!=NULL;led= next) {
+	next= (LEDInfo *)led->defs.next;
+	if (led->indicator==_LED_NotBound) {
+	    if (force) {
+		unbound= next;
+		uFree(led);
+	    }
+	    else {
+		if (last)
+		     last->defs.next= &led->defs;
+		else unbound= led;
+		last= led;
+	    }
+	}
+	else {
+	    if ((xkb->names!=NULL)&&
+		(xkb->names->indicators[led->indicator-1]!=led->name)) {
+		Atom old= xkb->names->indicators[led->indicator-1];
+		ERROR1("Multiple names bound to indicator %d\n",(unsigned int)led->indicator);
+		ACTION2("Using %s, ignoring %s\n",
+				XkbAtomGetString(xkb->dpy,old),
+				XkbAtomGetString(xkb->dpy,led->name));
+		led->indicator= _LED_NotBound;
+		if (force) {
+		    uFree(led);
+		    unbound= next;
+		}
+		else {
+		    if (last)
+			 last->defs.next= &led->defs;
+		    else unbound= led;
+		    last= led;
+		}
+	    }
+	    else {
+		XkbIndicatorMapPtr map;
+		map= &xkb->indicators->maps[led->indicator-1];
+		map->flags= led->flags;
+		map->which_groups= led->which_groups;
+		map->groups= led->groups;
+		map->which_mods= led->which_mods;
+		map->mods.mask= led->real_mods;
+		map->mods.real_mods= led->real_mods;
+		map->mods.vmods= led->vmods;
+		map->ctrls= led->ctrls;
+		if (last)	last->defs.next= &next->defs;
+		else		unbound= next;
+		led->defs.next= NULL;
+		uFree(led);
+	    }
+	}
+    }
+    if (unboundRtrn) {
+	*unboundRtrn= unbound;
+    }
+    else if (unbound) {
+	for (led=unbound;led!=NULL;led=next) {
+	    next= (LEDInfo *)led->defs.next;
+	    uFree(led);
+	}
+    }
+    return True;
+}
diff --git a/indicators.h b/indicators.h
new file mode 100644
index 0000000..461866b
--- /dev/null
+++ b/indicators.h
@@ -0,0 +1,106 @@
+/* $Xorg: indicators.h,v 1.3 2000/08/17 19:54:32 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 INDICATORS_H
+#define INDICATORS_H 1
+
+#define	_LED_Index	(1<<0)
+#define	_LED_Mods	(1<<1)
+#define	_LED_Groups	(1<<2)
+#define	_LED_Ctrls	(1<<3)
+#define	_LED_Explicit	(1<<4)
+#define	_LED_Automatic	(1<<5)
+#define	_LED_DrivesKbd	(1<<6)
+
+#define	_LED_NotBound	255
+
+typedef struct _LEDInfo {
+    CommonInfo		defs;
+    Atom		name;
+    unsigned char	indicator;
+    unsigned char	flags;
+    unsigned char	which_mods;
+    unsigned char	real_mods;
+    unsigned short	vmods;
+    unsigned char	which_groups;
+    unsigned char	groups;
+    unsigned int	ctrls;
+} LEDInfo;
+
+extern	void	ClearIndicatorMapInfo(
+#if NeedFunctionPrototypes
+    Display *		/* dpy */,
+    LEDInfo *		/* info */
+#endif
+);
+
+
+extern LEDInfo *AddIndicatorMap(
+#if NeedFunctionPrototypes
+    LEDInfo *		/* oldLEDs */,
+    LEDInfo *		/* newLED */
+#endif
+);
+
+extern int	SetIndicatorMapField(
+#if NeedFunctionPrototypes
+    LEDInfo *		/* led */,
+    XkbDescPtr		/* xkb */,
+    char *		/* field */,
+    ExprDef *		/* arrayNdx */,
+    ExprDef *		/* value */
+#endif
+);
+
+extern LEDInfo *HandleIndicatorMapDef(
+#if NeedFunctionPrototypes
+    IndicatorMapDef *	/* stmt */,
+    XkbDescPtr		/* xkb */,
+    LEDInfo *		/* dflt */,
+    LEDInfo *		/* oldLEDs */,
+    unsigned 		/* mergeMode */
+#endif
+);
+
+extern Bool CopyIndicatorMapDefs(
+#if NeedFunctionPrototypes
+    XkbFileInfo *	/* result */,
+    LEDInfo *		/* leds */,
+    LEDInfo **		/* unboundRtrn */
+#endif
+);
+
+extern Bool BindIndicators(
+#if NeedFunctionPrototypes
+    XkbFileInfo *	/* result */,
+    Bool		/* force */,
+    LEDInfo *		/* unbound */,
+    LEDInfo **		/* unboundRtrn */
+#endif
+);
+
+#endif /* INDICATORS_H */
diff --git a/keycodes.c b/keycodes.c
new file mode 100644
index 0000000..6acf0ac
--- /dev/null
+++ b/keycodes.c
@@ -0,0 +1,877 @@
+/* $Xorg: keycodes.c,v 1.4 2000/08/17 19:54:32 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "keycodes.h"
+#include "misc.h"
+#include "alias.h"
+
+char *
+#if NeedFunctionPrototypes
+longText(unsigned long val,unsigned format)
+#else
+longText(val,format)
+    unsigned long val;
+    unsigned format;
+#endif
+{
+char buf[4];
+
+    LongToKeyName(val,buf);
+    return XkbKeyNameText(buf,format);
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+LongToKeyName(unsigned long val,char *name)
+#else
+LongToKeyName(val,name)
+    unsigned long 	val;
+    char *		name;
+#endif
+{
+    name[0]= ((val>>24)&0xff);
+    name[1]= ((val>>16)&0xff);
+    name[2]= ((val>>8)&0xff);
+    name[3]= (val&0xff);
+    return;
+}
+
+/***====================================================================***/
+
+typedef struct _IndicatorNameInfo {
+    CommonInfo		defs;
+    int			ndx;
+    Atom		name;
+    Bool		virtual;
+} IndicatorNameInfo;
+
+typedef struct _KeyNamesInfo {
+    char *		name;
+    int			errorCount;
+    unsigned		fileID;
+    unsigned		merge;
+    int			computedMin;
+    int			computedMax;
+    int			explicitMin;
+    int			explicitMax;
+    int			effectiveMin;
+    int			effectiveMax;
+    unsigned long	names[XkbMaxLegalKeyCode+1];
+    unsigned 		files[XkbMaxLegalKeyCode+1];
+    unsigned char	has_alt_forms[XkbMaxLegalKeyCode+1];
+    IndicatorNameInfo *	leds;
+    AliasInfo *		aliases;
+} KeyNamesInfo;
+
+static void
+#if NeedFunctionPrototypes
+InitIndicatorNameInfo(IndicatorNameInfo *ii,KeyNamesInfo *info)
+#else
+InitIndicatorNameInfo(ii,info)
+    IndicatorNameInfo *	ii;
+    KeyNamesInfo *		info;
+#endif
+{
+    ii->defs.defined= 0;
+    ii->defs.merge= info->merge;
+    ii->defs.fileID= info->fileID;
+    ii->defs.next= NULL;
+    ii->ndx= 0;
+    ii->name= None;
+    ii->virtual= False;
+    return;
+}
+
+static void 
+#if NeedFunctionPrototypes
+ClearIndicatorNameInfo(IndicatorNameInfo *ii,KeyNamesInfo *info)
+#else
+ClearIndicatorNameInfo(ii,info)
+    IndicatorNameInfo *	ii;
+    KeyNamesInfo *		info;
+#endif
+{
+    if (ii==info->leds) {
+	ClearCommonInfo(&ii->defs);
+	info->leds= NULL;
+    }
+    return;
+}
+
+static IndicatorNameInfo *
+#if NeedFunctionPrototypes
+NextIndicatorName(KeyNamesInfo *info)
+#else
+NextIndicatorName(info)
+    KeyNamesInfo *	info;
+#endif
+{
+IndicatorNameInfo *	ii;
+
+    ii= uTypedAlloc(IndicatorNameInfo);
+    if (ii) {
+	InitIndicatorNameInfo(ii,info);
+	info->leds= (IndicatorNameInfo *)AddCommonInfo(&info->leds->defs,
+							(CommonInfo *)ii);
+    }
+    return ii;
+}
+
+static IndicatorNameInfo *
+#if NeedFunctionPrototypes
+FindIndicatorByIndex(KeyNamesInfo *info,int ndx)
+#else
+FindIndicatorByIndex(info,ndx)
+    KeyNamesInfo *	info;
+    int			ndx;
+#endif
+{
+IndicatorNameInfo *	old;
+
+    for (old= info->leds;old!=NULL;old=(IndicatorNameInfo *)old->defs.next) {
+	if (old->ndx==ndx)
+	    return old;
+    }
+    return NULL;
+}
+
+static IndicatorNameInfo *
+#if NeedFunctionPrototypes
+FindIndicatorByName(KeyNamesInfo *info,Atom name)
+#else
+FindIndicatorByName(info,name)
+    KeyNamesInfo *	info;
+    Atom		name;
+#endif
+{
+IndicatorNameInfo *	old;
+
+    for (old= info->leds;old!=NULL;old=(IndicatorNameInfo *)old->defs.next) {
+	if (old->name==name)
+	    return old;
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddIndicatorName(KeyNamesInfo *info,IndicatorNameInfo *new)
+#else
+AddIndicatorName(info,new)
+    KeyNamesInfo *	info;
+    IndicatorNameInfo *new;
+#endif
+{
+IndicatorNameInfo *old;
+Bool 		   replace;
+char *		   action;
+
+    replace= (new->defs.merge==MergeReplace)||
+		 (new->defs.merge==MergeOverride);
+    old= FindIndicatorByName(info,new->name);
+    if (old) {
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple indicators named %s\n",
+	    				XkbAtomText(NULL,new->name,XkbMessage));
+	    if (old->ndx==new->ndx) {
+		if (old->virtual!=new->virtual) {
+		    if (replace)
+			 old->virtual= new->virtual;
+		    action= "Using %s instead of %s\n";
+		}
+		else {
+		    action= "Identical definitions ignored\n";
+		}
+		ACTION2(action,(old->virtual?"virtual":"real"),
+				(old->virtual?"real":"virtual"));
+		return True;
+	    }
+	    else {
+		if (replace)	action= "Ignoring %d, using %d\n";
+		else		action= "Using %d, ignoring %d\n";
+		ACTION2(action,old->ndx,new->ndx);
+	    }
+	    if (replace) {
+		if (info->leds==old)
+		    info->leds= (IndicatorNameInfo *)old->defs.next;
+		else {
+		    IndicatorNameInfo *tmp;
+		    tmp= info->leds;
+		    for (;tmp!=NULL;tmp=(IndicatorNameInfo *)tmp->defs.next) {
+			if (tmp->defs.next==(CommonInfo *)old) {
+			    tmp->defs.next= old->defs.next;
+			    break;
+			}
+		    }
+		}
+		uFree(old);
+	    }
+	}
+    }
+    old= FindIndicatorByIndex(info,new->ndx);
+    if (old) {
+	if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+		    					(warningLevel>9)) {
+	    WARN1("Multiple names for indicator %d\n",new->ndx);
+	    if ((old->name==new->name)&&(old->virtual==new->virtual))
+		action= "Identical definitions ignored\n";
+	    else {
+		char   *oldType,*newType;
+		Atom	using,ignoring;
+		if (old->virtual)	oldType= "virtual indicator";
+		else			oldType= "real indicator";
+		if (new->virtual)	newType= "virtual indicator";
+		else			newType= "real indicator";
+		if (replace) {
+		    using= new->name;
+		    ignoring= old->name;
+		}
+		else {
+		    using= old->name;
+		    ignoring= new->name;
+		}
+		ACTION4("Using %s %s, ignoring %s %s\n",
+				oldType,XkbAtomText(NULL,using,XkbMessage),
+				newType,XkbAtomText(NULL,ignoring,XkbMessage));
+	    }
+	}
+	if (replace) {
+	    old->name= new->name;
+	    old->virtual= new->virtual;
+	}
+	return True;
+    }
+    old= new;
+    new= NextIndicatorName(info);
+    if (!new) {
+	WSGO1("Couldn't allocate name for indicator %d\n",new->ndx);
+	ACTION("Ignored\n");
+	return False;
+    }
+    new->name= old->name;
+    new->ndx= old->ndx;
+    new->virtual= old->virtual;
+    return True;
+}
+
+static void
+#if NeedFunctionPrototypes
+ClearKeyNamesInfo(KeyNamesInfo *info)
+#else
+ClearKeyNamesInfo(info)
+    KeyNamesInfo *info;
+#endif
+{
+    if (info->name!=NULL)
+	uFree(info->name);
+    info->name= NULL;
+    info->computedMax= info->explicitMax= info->explicitMin= -1;
+    info->computedMin= 256;
+    info->effectiveMin= 8;
+    info->effectiveMax= 255;
+    bzero((char *)info->names,sizeof(info->names));
+    bzero((char *)info->files,sizeof(info->files));
+    bzero((char *)info->has_alt_forms,sizeof(info->has_alt_forms));
+    if (info->leds)
+	ClearIndicatorNameInfo(info->leds,info);
+    if (info->aliases)
+	ClearAliases(&info->aliases);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+InitKeyNamesInfo(KeyNamesInfo *info)
+#else
+InitKeyNamesInfo(info)
+    KeyNamesInfo *info;
+#endif
+{
+    info->name= NULL;
+    info->leds= NULL;
+    info->aliases= NULL;
+    ClearKeyNamesInfo(info);
+    info->errorCount= 0;
+    return;
+}
+
+int
+#if NeedFunctionPrototypes
+FindKeyByLong(KeyNamesInfo *info,unsigned long name)
+#else
+FindKeyByLong(info,name)
+    KeyNamesInfo *	info;
+    unsigned long	name;
+#endif
+{
+register int i;
+
+    for (i=info->effectiveMin;i<=info->effectiveMax;i++) {
+	if (info->names[i]==name)
+	    return i;
+    }
+    return 0;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddKeyName(	KeyNamesInfo *	info,
+		int		kc,
+		char *		name,
+		unsigned	merge,
+		unsigned	fileID,
+		Bool		reportCollisions)
+#else
+AddKeyName(info,kc,name,merge,fileID,reportCollisions)
+    KeyNamesInfo *	info;
+    int			kc;
+    char *		name;
+    unsigned		merge;
+    unsigned		fileID;
+    Bool		reportCollisions;
+#endif
+{
+int		old;
+unsigned long	lval;
+
+    if ((kc<info->effectiveMin)||(kc>info->effectiveMax)) {
+	ERROR2("Illegal keycode %d for name <%s>\n",kc,name);
+	ACTION2("Must be in the range %d-%d inclusive\n",info->effectiveMin,
+							 info->effectiveMax);
+	return False;
+    }
+    if (kc<info->computedMin)	info->computedMin= kc;
+    if (kc>info->computedMax)	info->computedMax= kc;
+    lval= KeyNameToLong(name);
+
+    if (reportCollisions) {
+	reportCollisions= ((warningLevel>7)||
+			   ((warningLevel>0)&&(fileID==info->files[kc])));
+    }
+
+    if (info->names[kc]!=0) {
+	char buf[6];
+
+	LongToKeyName(info->names[kc],buf);
+	buf[4]= '\0';
+	if (info->names[kc]==lval) {
+	    if (info->has_alt_forms[kc] || (merge==MergeAltForm)) {
+		info->has_alt_forms[kc]= True;
+	    }
+	    else if (reportCollisions) {
+		WARN("Multiple identical key name definitions\n");
+		ACTION2("Later occurences of \"<%s> = %d\" ignored\n",buf,kc);
+	    }
+	    return True;
+	}
+	if (merge==MergeAugment) {
+	    if (reportCollisions) {
+		WARN1("Multiple names for keycode %d\n",kc);
+		ACTION2("Using <%s>, ignoring <%s>\n",buf,name);
+	    }
+	    return True;
+	}
+	else {
+	    if (reportCollisions) {
+		WARN1("Multiple names for keycode %d\n",kc);
+		ACTION2("Using <%s>, ignoring <%s>\n",name,buf);
+	    }
+	    info->names[kc]= 0;
+	    info->files[kc]= 0;
+	}
+    }
+    old= FindKeyByLong(info,lval);
+    if ((old!=0)&&(old!=kc)) {
+	if (merge==MergeOverride) {
+	    info->names[old]= 0;
+	    info->files[old]= 0;
+	    info->has_alt_forms[old]= True;
+	    if (reportCollisions) {
+		WARN1("Key name <%s> assigned to multiple keys\n",name);
+		ACTION2("Using %d, ignoring %d\n",kc,old);
+	    }
+	}
+	else if (merge!=MergeAltForm) {
+	    if ((reportCollisions)&&(warningLevel>3)) {
+		WARN1("Key name <%s> assigned to multiple keys\n",name);
+		ACTION2("Using %d, ignoring %d\n",old,kc);
+		ACTION("Use 'alternate' keyword to assign the same name to multiple keys\n");
+	    }
+	    return True;
+	}
+	else {
+	    info->has_alt_forms[old]= True;
+	}
+    }
+    info->names[kc]= lval;
+    info->files[kc]= fileID;
+    info->has_alt_forms[kc]= (merge==MergeAltForm);
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+MergeIncludedKeycodes(KeyNamesInfo *into,KeyNamesInfo *from,unsigned merge)
+#else
+MergeIncludedKeycodes(into,from,merge)
+    KeyNamesInfo *	into;
+    KeyNamesInfo *	from;
+    unsigned		merge;
+#endif
+{
+register int i;
+char buf[5];
+
+    if (from->errorCount>0) {
+	into->errorCount+= from->errorCount;
+	return;
+    }
+    if (into->name==NULL) {
+	into->name= from->name;
+	from->name= NULL;
+    }
+    for (i=from->computedMin;i<=from->computedMax;i++) {
+	unsigned thisMerge;
+	if (from->names[i]==0)
+	    continue;
+	LongToKeyName(from->names[i],buf);
+	buf[4]= '\0';
+	if (from->has_alt_forms[i])
+	     thisMerge= MergeAltForm;
+	else thisMerge= merge;
+	if (!AddKeyName(into,i,buf,thisMerge,from->fileID,False))
+	    into->errorCount++;
+    }
+    if (from->leds) {
+	IndicatorNameInfo *led,*next;
+	for (led=from->leds;led!=NULL;led=next) {
+	    if (merge!=MergeDefault)
+		led->defs.merge= merge;
+	    if (!AddIndicatorName(into,led))
+		into->errorCount++;
+	    next= (IndicatorNameInfo *)led->defs.next;
+	}
+    }
+    if (!MergeAliases(&into->aliases,&from->aliases,merge))
+	into->errorCount++;
+    if (from->explicitMin>0) {
+	if ((into->explicitMin<0)||(into->explicitMin>from->explicitMin))
+	    into->effectiveMin= into->explicitMin= from->explicitMin;
+    }
+    if (from->explicitMax>0) {
+	if ((into->explicitMax<0)||(into->explicitMax<from->explicitMax))
+	     into->effectiveMax= into->explicitMax= from->explicitMax;
+    }
+    return;
+}
+
+typedef void (*FileHandler)(
+#if NeedFunctionPrototypes
+    XkbFile *		/* rtrn */,
+    XkbDescPtr		/* xkb */,
+    unsigned		/* merge */,
+    KeyNamesInfo *	/* included */
+#endif
+);
+
+static Bool
+#if NeedFunctionPrototypes
+HandleIncludeKeycodes(	IncludeStmt *	stmt,
+			XkbDescPtr	xkb,
+			KeyNamesInfo *	info,
+			FileHandler	hndlr)
+#else
+HandleIncludeKeycodes(stmt,xkb,info,hndlr)
+    IncludeStmt	*	stmt;
+    XkbDescPtr		xkb;
+    KeyNamesInfo *	info;
+    FileHandler		hndlr;
+#endif
+{
+unsigned 	newMerge;
+XkbFile	*	rtrn;
+KeyNamesInfo 	included;
+Bool		haveSelf;
+
+    haveSelf= False;
+    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
+	haveSelf= True;
+	included= *info;
+	bzero(info,sizeof(KeyNamesInfo));
+    }
+    else if (strcmp(stmt->file,"computed")==0) {
+	xkb->flags|= AutoKeyNames;
+	info->explicitMin= XkbMinLegalKeyCode;
+	info->explicitMax= XkbMaxLegalKeyCode;
+	return (info->errorCount==0);
+    }
+    else if (ProcessIncludeFile(stmt,XkmKeyNamesIndex,&rtrn,&newMerge)) {
+	InitKeyNamesInfo(&included);
+	(*hndlr)(rtrn,xkb,MergeOverride,&included);
+	if (stmt->stmt!=NULL) {
+	    if (included.name!=NULL)
+		uFree(included.name);
+	    included.name= stmt->stmt;
+	    stmt->stmt= NULL;
+	}
+    }
+    else {
+	info->errorCount+= 10;
+	return False;
+    }
+    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
+	IncludeStmt *	next;
+	unsigned	op;
+	KeyNamesInfo	next_incl;
+
+        for (next=stmt->next;next!=NULL;next=next->next) {
+	    if ((next->file==NULL)&&(next->map==NULL)) {
+		haveSelf= True;
+		MergeIncludedKeycodes(&included,info,next->merge);
+		ClearKeyNamesInfo(info);
+	    }
+	    else if (ProcessIncludeFile(next,XkmKeyNamesIndex,&rtrn,&op)) {
+		InitKeyNamesInfo(&next_incl);
+		(*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
+		MergeIncludedKeycodes(&included,&next_incl,op);
+		ClearKeyNamesInfo(&next_incl);
+	    }
+	    else {
+		info->errorCount+= 10;
+		return False;
+	    }
+	}
+    }
+    if (haveSelf)
+	*info= included;
+    else {
+	MergeIncludedKeycodes(info,&included,newMerge);
+	ClearKeyNamesInfo(&included);
+    }
+    return (info->errorCount==0);
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleKeycodeDef(	KeycodeDef *	stmt,
+			XkbDescPtr	xkb,
+			unsigned 	merge,
+			KeyNamesInfo *	info)
+#else
+HandleKeycodeDef(stmt,xkb,merge,info)
+    KeycodeDef *	stmt;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    KeyNamesInfo *	info;
+#endif
+{
+int		code;
+ExprResult	result;
+
+    if (!ExprResolveInteger(stmt->value,&result,NULL,NULL)) {
+	ACTION1("No value keycode assigned to name <%s>\n",stmt->name);
+	return 0;
+    }
+    code= result.ival;
+    if ((code<info->effectiveMin)||(code>info->effectiveMax)) {
+	ERROR2("Illegal keycode %d for name <%s>\n",code,stmt->name);
+	ACTION2("Must be in the range %d-%d inclusive\n",info->effectiveMin,
+							 info->effectiveMax);
+	return 0;
+    }
+    if (stmt->merge!=MergeDefault) {
+	if (stmt->merge==MergeReplace)
+	     merge= MergeOverride;
+	else merge= stmt->merge;
+    }
+    return AddKeyName(info,code,stmt->name,merge,info->fileID,True);
+}
+
+#define	MIN_KEYCODE_DEF		0
+#define	MAX_KEYCODE_DEF		1
+
+static int
+#if NeedFunctionPrototypes
+HandleKeyNameVar(VarDef *stmt,XkbDescPtr xkb,unsigned merge,KeyNamesInfo *info)
+#else
+HandleKeyNameVar(stmt,xkb,merge,info)
+    VarDef *		stmt;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    KeyNamesInfo *	info;
+#endif
+{
+ExprResult	tmp,field;
+ExprDef	*	arrayNdx;
+int		which;
+
+    if (ExprResolveLhs(stmt->name,&tmp,&field,&arrayNdx)==0) 
+	return 0; /* internal error, already reported */
+
+    if (tmp.str!=NULL) {
+	ERROR1("Unknown element %s encountered\n",tmp.str);
+	ACTION1("Default for field %s ignored\n",field.str);
+	return 0;
+    }
+    if (uStrCaseCmp(field.str,"minimum")==0)	 which= MIN_KEYCODE_DEF;
+    else if (uStrCaseCmp(field.str,"maximum")==0) which= MAX_KEYCODE_DEF;
+    else {
+	ERROR("Unknown field encountered\n");
+	ACTION1("Assigment to field %s ignored\n",field.str);
+	return 0;
+    }
+    if (arrayNdx!=NULL) {
+	ERROR1("The %s setting is not an array\n",field.str);
+	ACTION("Illegal array reference ignored\n");
+	return 0;
+    }
+
+    if (ExprResolveInteger(stmt->value,&tmp,NULL,NULL)==0) {
+	ACTION1("Assignment to field %s ignored\n",field.str);
+	return 0;
+    }
+    if ((tmp.ival<XkbMinLegalKeyCode)||(tmp.ival>XkbMaxLegalKeyCode)) {
+	ERROR3("Illegal keycode %d (must be in the range %d-%d inclusive)\n",
+			tmp.ival,XkbMinLegalKeyCode,XkbMaxLegalKeyCode);
+	ACTION1("Value of \"%s\" not changed\n",field.str);
+	return 0;
+    }
+    if (which==MIN_KEYCODE_DEF) {
+	if ((info->explicitMax>0)&&(info->explicitMax<tmp.ival)) {
+	    ERROR2("Minimum key code (%d) must be <= maximum key code (%d)\n",
+						tmp.ival,info->explicitMax);
+	    ACTION("Minimum key code value not changed\n");
+	    return 0;
+	}
+	if ((info->computedMax>0)&&(info->computedMin<tmp.ival)) {
+	    ERROR2("Minimum key code (%d) must be <= lowest defined key (%d)\n",
+						tmp.ival,info->computedMin);
+	    ACTION("Minimum key code value not changed\n");
+	    return 0;
+	}
+	info->explicitMin= tmp.ival;
+	info->effectiveMin= tmp.ival;
+    }
+    if (which==MAX_KEYCODE_DEF) {
+	if ((info->explicitMin>0)&&(info->explicitMin>tmp.ival)) {
+	    ERROR2("Maximum code (%d) must be >= minimum key code (%d)\n",
+						tmp.ival,info->explicitMin);
+	    ACTION("Maximum code value not changed\n");
+	    return 0;
+	}
+	if ((info->computedMax>0)&&(info->computedMax>tmp.ival)) {
+	    ERROR2("Maximum code (%d) must be >= highest defined key (%d)\n",
+						tmp.ival,info->computedMax);
+	    ACTION("Maximum code value not changed\n");
+	    return 0;
+	}
+	info->explicitMax= tmp.ival;
+	info->effectiveMax= tmp.ival;
+    }
+    return 1;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleIndicatorNameDef(	IndicatorNameDef *	def,
+			XkbDescPtr		xkb,
+			unsigned 		merge,
+			KeyNamesInfo *		info)
+#else
+HandleIndicatorNameDef(def,xkb,merge,info)
+    IndicatorNameDef *	def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    KeyNamesInfo *	info;
+#endif
+{
+IndicatorNameInfo 	ii;
+ExprResult		tmp;
+
+    if ((def->ndx<1)||(def->ndx>XkbNumIndicators)) {
+	info->errorCount++;
+	ERROR1("Name specified for illegal indicator index %d\n",def->ndx);
+	ACTION("Ignored\n");
+	return False;
+    }
+    InitIndicatorNameInfo(&ii,info);
+    ii.ndx= def->ndx;
+    if (!ExprResolveString(def->name,&tmp,NULL,NULL)) {
+	char buf[20];
+	sprintf(buf,"%d",def->ndx);
+	info->errorCount++;
+	return ReportBadType("indicator","name",buf,"string");
+    }
+    ii.name= XkbInternAtom(NULL,tmp.str,False);
+    ii.virtual= def->virtual;
+    if (!AddIndicatorName(info,&ii))
+	return False;
+    return True;
+}
+
+static void
+#if NeedFunctionPrototypes
+HandleKeycodesFile(	XkbFile *	file,
+			XkbDescPtr 	xkb,
+			unsigned	merge,
+			KeyNamesInfo *	info)
+#else
+HandleKeycodesFile(file,xkb,merge,info)
+    XkbFile		*file;
+    XkbDescPtr	 	 xkb;
+    unsigned		 merge;
+    KeyNamesInfo	*info;
+#endif
+{
+ParseCommon	*stmt;
+
+    info->name= uStringDup(file->name);
+    stmt= file->defs;
+    while (stmt) {
+	switch (stmt->stmtType) {
+	    case StmtInclude:
+		if (!HandleIncludeKeycodes((IncludeStmt *)stmt,xkb,info,
+						HandleKeycodesFile))
+		    info->errorCount++;
+		break;
+	    case StmtKeycodeDef:
+		if (!HandleKeycodeDef((KeycodeDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtKeyAliasDef:
+		if (!HandleAliasDef((KeyAliasDef *)stmt,
+					merge,info->fileID,&info->aliases))
+		    info->errorCount++;
+		break;
+	    case StmtVarDef:
+		if (!HandleKeyNameVar((VarDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtIndicatorNameDef:
+		if (!HandleIndicatorNameDef((IndicatorNameDef *)stmt,xkb,
+								merge,info)) {
+		    info->errorCount++;
+		}
+		break;
+	    case StmtInterpDef:
+	    case StmtVModDef:
+		ERROR("Keycode files may define key and indicator names only\n");
+		ACTION1("Ignoring definition of %s\n",
+				((stmt->stmtType==StmtInterpDef)?
+					"a symbol interpretation":
+					"virtual modifiers"));
+		info->errorCount++;
+		break;
+	    default:
+		WSGO1("Unexpected statement type %d in HandleKeycodesFile\n",
+			stmt->stmtType);
+		break;
+	}
+	stmt= stmt->next;
+	if (info->errorCount>10) {
+#ifdef NOISY
+	    ERROR("Too many errors\n");
+#endif
+	    ACTION1("Abandoning keycodes file \"%s\"\n",file->topName);
+	    break;
+	}
+    }
+    return;
+}
+
+Bool
+#if NeedFunctionPrototypes
+CompileKeycodes(XkbFile	*file,XkbFileInfo *result,unsigned merge)
+#else
+CompileKeycodes(file,result,merge)
+    XkbFile	*	file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+#endif
+{
+KeyNamesInfo	info;
+XkbDescPtr	xkb;
+
+    xkb= result->xkb;
+    InitKeyNamesInfo(&info);
+    HandleKeycodesFile(file,xkb,merge,&info);
+
+    if (info.errorCount==0) {
+	if (info.explicitMin>0)
+	     xkb->min_key_code= info.effectiveMin;
+	else xkb->min_key_code= info.computedMin;
+	if (info.explicitMax>0)
+	     xkb->max_key_code= info.effectiveMax;
+	else xkb->max_key_code= info.computedMax;
+	if (XkbAllocNames(xkb,XkbKeyNamesMask|XkbIndicatorNamesMask,0,0)==Success) {
+	    register int i;
+	    xkb->names->keycodes= XkbInternAtom(xkb->dpy,info.name,False);
+	    uDEBUG2(1,"key range: %d..%d\n",xkb->min_key_code,xkb->max_key_code);
+	    for (i=info.computedMin;i<=info.computedMax;i++) {
+		LongToKeyName(info.names[i],xkb->names->keys[i].name);
+		uDEBUG2(2,"key %d = %s\n",i,
+			XkbKeyNameText(xkb->names->keys[i].name,XkbMessage));
+	    }
+	}
+	else {
+	    WSGO("Cannot create XkbNamesRec in CompileKeycodes\n");
+	    return False;
+	}
+	if (info.leds) {
+	    IndicatorNameInfo	*ii;
+	    if (XkbAllocIndicatorMaps(xkb)!=Success) {
+		WSGO("Couldn't allocate IndicatorRec in CompileKeycodes\n");
+		ACTION("Physical indicators not set\n");
+	    }
+	    for (ii=info.leds;ii!=NULL;ii=(IndicatorNameInfo *)ii->defs.next){
+		xkb->names->indicators[ii->ndx-1]= 
+			XkbInternAtom(xkb->dpy,
+					XkbAtomGetString(NULL,ii->name),False);
+		if (xkb->indicators!=NULL) {
+		    register unsigned bit;
+		    bit= 1<<(ii->ndx-1);
+		    if (ii->virtual)	
+			 xkb->indicators->phys_indicators&= ~bit;
+		    else xkb->indicators->phys_indicators|= bit;
+		}
+	    }
+	}
+	if (info.aliases)
+	    ApplyAliases(xkb,False,&info.aliases);
+	return True;
+    }
+    ClearKeyNamesInfo(&info);
+    return False;
+}
diff --git a/keycodes.h b/keycodes.h
new file mode 100644
index 0000000..3e93054
--- /dev/null
+++ b/keycodes.h
@@ -0,0 +1,47 @@
+/* $Xorg: keycodes.h,v 1.3 2000/08/17 19:54:32 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 KEYCODES_H
+#define KEYCODES_H 1
+
+#define	KeyNameToLong(n)	((((unsigned long)n[0])<<24)|(((unsigned long)n[1])<<16)|(((unsigned long)n[2])<<8)|n[3])
+
+extern char * longText(
+#if NeedFunctionPrototypes
+    unsigned long 	/* val */,
+    unsigned		/* format */
+#endif
+);
+
+extern void LongToKeyName(
+#if NeedFunctionPrototypes
+	unsigned long	/* val */,
+	char *		/* name_rtrn */
+#endif
+);
+
+#endif /* KEYCODES_H */
diff --git a/keymap.c b/keymap.c
new file mode 100644
index 0000000..e696e8d
--- /dev/null
+++ b/keymap.c
@@ -0,0 +1,174 @@
+/* $Xorg: keymap.c,v 1.3 2000/08/17 19:54:32 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "action.h"
+#include "misc.h"
+#include "indicators.h"
+
+#define	KEYCODES	0
+#define	GEOMETRY	1
+#define	TYPES		2
+#define	COMPAT		3
+#define	SYMBOLS		4
+#define	MAX_SECTIONS	5
+
+XkbFile *	sections[MAX_SECTIONS];
+
+Bool
+#if NeedFunctionPrototypes
+CompileKeymap(XkbFile *file,XkbFileInfo *result,unsigned merge)
+#else
+CompileKeymap(file,result,merge)
+    XkbFile	*	file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+#endif
+{
+unsigned	have;
+Bool		ok;
+unsigned	required,legal;
+unsigned	mainType;
+char *		mainName;
+LEDInfo	*	unbound= NULL;
+
+    bzero(sections,MAX_SECTIONS*sizeof(XkbFile *));
+    mainType= file->type;
+    mainName= file->name;
+    switch (mainType) {
+	case XkmSemanticsFile:
+	    required= XkmSemanticsRequired;
+	    legal= XkmSemanticsLegal;
+	    break;
+	case XkmLayoutFile:
+	    required= XkmLayoutRequired;
+	    legal= XkmKeymapLegal;
+	    break;
+	case XkmKeymapFile:
+	    required= XkmKeymapRequired;
+	    legal= XkmKeymapLegal;
+	    break;
+	default:
+	    ERROR1("Cannot compile %s alone into an XKM file\n",
+					XkbConfigText(mainType,XkbMessage));
+	    return False;
+    }
+    have= 0;
+    ok= 1;
+    file= (XkbFile *)file->defs;
+    while ((file)&&(ok)) {
+	file->topName= mainName;
+	if ((have&(1<<file->type))!=0) {
+	    ERROR2("More than one %s section in a %s file\n",
+					XkbConfigText(file->type,XkbMessage),
+					XkbConfigText(mainType,XkbMessage));
+	    ACTION("All sections after the first ignored\n");
+	    ok= False;
+	}
+	else if ((1<<file->type)&(~legal)) {
+	    ERROR2("Cannot define %s in a %s file\n",
+	    				XkbConfigText(file->type,XkbMessage),
+	    			     	XkbConfigText(mainType,XkbMessage));
+	    ok= False;
+	}
+	else switch (file->type) {
+	    case XkmSemanticsFile:
+	    case XkmLayoutFile:
+	    case XkmKeymapFile:
+		WSGO2("Illegal %s configuration in a %s file\n",
+					XkbConfigText(file->type,XkbMessage),
+					XkbConfigText(mainType,XkbMessage));
+		ACTION("Ignored\n");
+		ok= False;
+		break;
+	    case XkmKeyNamesIndex:
+		sections[KEYCODES]= file;
+		break;
+	    case XkmTypesIndex:
+		sections[TYPES]= file;
+		break;
+	    case XkmSymbolsIndex:
+		sections[SYMBOLS]= file;
+		break;
+	    case XkmCompatMapIndex:
+		sections[COMPAT]= file;
+		break;
+	    case XkmGeometryIndex:
+	    case XkmGeometryFile:
+		sections[GEOMETRY]= file;
+		break;
+	    case XkmVirtualModsIndex:
+	    case XkmIndicatorsIndex:
+		WSGO1("Found an isolated %s section\n",
+					XkbConfigText(file->type,XkbMessage));
+		break;
+	    default:
+		WSGO1("Unknown file type %d\n",file->type);
+		break;
+	}
+	if (ok)
+	    have|= (1<<file->type);
+	file= (XkbFile*)file->common.next;
+    }
+    if (ok) {
+	if (ok && (sections[KEYCODES]!=NULL))
+	    ok= CompileKeycodes(sections[KEYCODES],result,MergeOverride);
+	if (ok && (sections[GEOMETRY]!=NULL))
+	    ok= CompileGeometry(sections[GEOMETRY],result,MergeOverride);
+	if (ok && (sections[TYPES]!=NULL))
+	    ok= CompileKeyTypes(sections[TYPES],result,MergeOverride);
+	if (ok && (sections[COMPAT]!=NULL))
+	    ok=CompileCompatMap(sections[COMPAT],result,MergeOverride,&unbound);
+	if (ok && (sections[SYMBOLS]!=NULL))
+	    ok= CompileSymbols(sections[SYMBOLS],result,MergeOverride);
+    }
+    if (!ok)
+   	return False; 
+    result->defined= have;
+    if (required&(~have)) {
+	register int i,bit;
+	unsigned missing;
+	missing= required&(~have);
+	for (i=0,bit=1;missing!=0;i++,bit<<=1) {
+	    if (missing&bit) {
+		ERROR2("Missing %s section in a %s file\n",
+					XkbConfigText(i,XkbMessage),
+					XkbConfigText(mainType,XkbMessage));
+		missing&=~bit;
+	    }
+	}
+	ACTION1("Description of %s not compiled\n",
+					XkbConfigText(mainType,XkbMessage));
+	ok= False;
+    }
+    ok= BindIndicators(result,True,unbound,NULL);
+    return ok;
+}
+
diff --git a/keytypes.c b/keytypes.c
new file mode 100644
index 0000000..2b2db13
--- /dev/null
+++ b/keytypes.c
@@ -0,0 +1,1353 @@
+/* $Xorg: keytypes.c,v 1.3 2000/08/17 19:54:32 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "vmod.h"
+#include "action.h"
+#include "misc.h"
+
+typedef struct _PreserveInfo {
+    CommonInfo 		defs;
+    short		matchingMapIndex;
+    unsigned char	indexMods;
+    unsigned char	preMods;
+    unsigned short	indexVMods;
+    unsigned short	preVMods;
+} PreserveInfo;
+
+#define	_KT_Name	(1<<0)
+#define	_KT_Mask	(1<<1)
+#define	_KT_Map		(1<<2)
+#define	_KT_Preserve	(1<<3)
+#define	_KT_LevelNames	(1<<4)
+
+typedef struct _KeyTypeInfo {
+    CommonInfo 		defs;
+    Display *		dpy;
+    Atom		name;
+    int			fileID;
+    unsigned		mask;
+    unsigned		vmask;
+    Bool		groupInfo;
+    int			numLevels;
+    int			nEntries;
+    int			szEntries;
+    XkbKTMapEntryPtr	entries;
+    PreserveInfo *	preserve;
+    int			szNames;
+    Atom	*	lvlNames;
+} KeyTypeInfo;
+
+typedef struct _KeyTypesInfo {
+    Display *		dpy;
+    char *		name;
+    int			errorCount;
+    int			fileID;
+    unsigned		stdPresent;
+    int			nTypes;
+    KeyTypeInfo *	types;
+    KeyTypeInfo		dflt;
+    VModInfo		vmods;
+} KeyTypesInfo;
+
+Atom	tok_ONE_LEVEL;
+Atom	tok_TWO_LEVEL;
+Atom	tok_ALPHABETIC;
+Atom	tok_KEYPAD;
+
+/***====================================================================***/
+
+#define	ReportTypeShouldBeArray(t,f) \
+	ReportShouldBeArray("key type",(f),TypeTxt(t))
+#define	ReportTypeBadType(t,f,w) \
+	ReportBadType("key type",(f),TypeTxt(t),(w))
+
+/***====================================================================***/
+
+_XFUNCPROTOBEGIN
+
+extern Bool AddMapEntry(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */,
+    KeyTypeInfo *	/* type */,
+    XkbKTMapEntryPtr	/* new */,
+    Bool		/* clobber */,
+    Bool		/* report */
+#endif
+);
+
+extern Bool AddPreserve(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */,
+    KeyTypeInfo *	/* type */,
+    PreserveInfo *	/* new */,
+    Bool		/* clobber */,
+    Bool		/* report */
+#endif
+);
+
+extern Bool AddLevelName(
+#if NeedFunctionPrototypes
+    KeyTypeInfo *	/* type */,
+    unsigned		/* level */,
+    Atom		/* name */,
+    Bool		/* clobber */,
+    Bool		/* report */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#define	MapEntryTxt(t,x,e)	\
+    XkbVModMaskText((t)->dpy,(x),(e)->mods.real_mods,(e)->mods.vmods,XkbMessage)
+#define	PreserveIndexTxt(t,x,p)	\
+	XkbVModMaskText((t)->dpy,(x),(p)->indexMods,(p)->indexVMods,XkbMessage)
+#define	PreserveTxt(t,x,p)	\
+	XkbVModMaskText((t)->dpy,(x),(p)->preMods,(p)->preVMods,XkbMessage)
+#define	TypeTxt(t)	XkbAtomText((t)->dpy,(t)->name,XkbMessage)
+#define	TypeMaskTxt(t,x)	\
+	XkbVModMaskText((t)->dpy,(x),(t)->mask,(t)->vmask,XkbMessage)
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+InitKeyTypesInfo(KeyTypesInfo *info,XkbDescPtr xkb,KeyTypesInfo *from)
+#else
+InitKeyTypesInfo(info,xkb,from)
+    KeyTypesInfo *	info;
+    XkbDescPtr		xkb;
+    KeyTypesInfo *	from;
+#endif
+{
+    tok_ONE_LEVEL= XkbInternAtom(NULL,"ONE_LEVEL",False);
+    tok_TWO_LEVEL= XkbInternAtom(NULL,"TWO_LEVEL",False);
+    tok_ALPHABETIC= XkbInternAtom(NULL,"ALPHABETIC",False);
+    tok_KEYPAD= XkbInternAtom(NULL,"KEYPAD",False);
+    info->dpy= NULL;
+    info->name= uStringDup("default");
+    info->errorCount= 0;
+    info->stdPresent= 0;
+    info->nTypes= 0;
+    info->types= NULL;
+    info->dflt.defs.defined= 0;
+    info->dflt.defs.fileID= 0;
+    info->dflt.defs.merge= MergeOverride;
+    info->dflt.defs.next= NULL;
+    info->dflt.name= None;
+    info->dflt.mask= 0;
+    info->dflt.vmask= 0;
+    info->dflt.groupInfo= False;
+    info->dflt.numLevels= 1;
+    info->dflt.nEntries= info->dflt.szEntries= 0;
+    info->dflt.entries= NULL;
+    info->dflt.szNames= 0;
+    info->dflt.lvlNames= NULL;
+    info->dflt.preserve= NULL;
+    InitVModInfo(&info->vmods,xkb);
+    if (from!=NULL) {
+	info->dpy= from->dpy;
+	info->dflt= from->dflt;
+	if (from->dflt.entries) {
+	    info->dflt.entries= uTypedCalloc(from->dflt.szEntries,
+							XkbKTMapEntryRec);
+	    if (info->dflt.entries) {
+		unsigned sz = from->dflt.nEntries*sizeof(XkbKTMapEntryRec);
+		memcpy(info->dflt.entries,from->dflt.entries,sz);
+	    }
+	}
+	if (from->dflt.lvlNames) {
+	    info->dflt.lvlNames= uTypedCalloc(from->dflt.szNames,Atom);
+	    if (info->dflt.lvlNames) {
+		register unsigned sz = from->dflt.szNames*sizeof(Atom);
+		memcpy(info->dflt.lvlNames,from->dflt.lvlNames,sz);
+	    }
+	}
+	if (from->dflt.preserve) {
+	    PreserveInfo *old,*new,*last;
+	    last= NULL;
+	    old= from->dflt.preserve;
+	    for (;old;old=(PreserveInfo *)old->defs.next) {
+		new= uTypedAlloc(PreserveInfo);
+		if (!new)
+		    return;
+		*new= *old;
+		new->defs.next= NULL;
+		if (last)	last->defs.next= 	(CommonInfo *)new;
+		else		info->dflt.preserve= 	new;
+		last= new;
+	    }
+	}
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeKeyTypeInfo(KeyTypeInfo *type)
+#else
+FreeKeyTypeInfo(type)
+    KeyTypeInfo *	type;
+#endif
+{
+    if (type->entries!=NULL) {
+	uFree(type->entries);
+	type->entries= NULL;
+    }
+    if (type->lvlNames!=NULL) {
+	uFree(type->lvlNames);
+	type->lvlNames= NULL;
+    }
+    if (type->preserve!=NULL)  {
+	ClearCommonInfo(&type->preserve->defs);
+	type->preserve= NULL;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeKeyTypesInfo(KeyTypesInfo *info)
+#else
+FreeKeyTypesInfo(info)
+    KeyTypesInfo *	info;
+#endif
+{
+    info->dpy= NULL;
+    if (info->name)
+	uFree(info->name);
+    info->name= NULL;
+    if (info->types) {
+	register KeyTypeInfo *type;
+	for (type= info->types;type;type=(KeyTypeInfo *)type->defs.next) {
+	    FreeKeyTypeInfo(type);
+	}
+	info->types= (KeyTypeInfo *)ClearCommonInfo(&info->types->defs);
+    }
+    FreeKeyTypeInfo(&info->dflt);
+    return;
+}
+
+static KeyTypeInfo *
+#if NeedFunctionPrototypes
+NextKeyType(KeyTypesInfo *info)
+#else
+NextKeyType(info)
+    KeyTypesInfo *	info;
+#endif
+{
+KeyTypeInfo *		type;
+
+    type= uTypedAlloc(KeyTypeInfo);
+    if (type!=NULL) {
+	bzero(type,sizeof(KeyTypeInfo));
+	type->defs.fileID= info->fileID;
+	type->dpy= info->dpy;
+	info->types= (KeyTypeInfo *)AddCommonInfo(&info->types->defs,
+						  	(CommonInfo *)type);
+	info->nTypes++;
+    }
+    return type;
+}
+
+static KeyTypeInfo *
+#if NeedFunctionPrototypes
+FindMatchingKeyType(KeyTypesInfo *info,KeyTypeInfo *new)
+#else
+FindMatchingKeyType(info,new)
+    KeyTypesInfo *	info;
+    KeyTypeInfo	*	new;
+#endif
+{
+KeyTypeInfo	*old;
+
+    for (old=info->types;old;old=(KeyTypeInfo *)old->defs.next) {
+	if (old->name==new->name)
+	    return old;
+    }
+    return NULL;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+ReportTypeBadWidth(char *type,int has,int needs)
+#else
+ReportTypeBadWidth(type,has,needs)
+    char *	type;
+    int		has;
+    int		needs;
+#endif
+{
+    ERROR3("Key type \"%s\" has %d levels, must have %d\n",type,has,needs);
+    ACTION("Illegal type definition ignored\n");
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddKeyType(XkbDescPtr xkb,KeyTypesInfo *info,KeyTypeInfo *new)
+#else
+AddKeyType(xkb,info,new)
+    XkbDescPtr		xkb;
+    KeyTypesInfo *	info;
+    KeyTypeInfo	*	new;
+#endif
+{
+KeyTypeInfo *		old;
+   
+    if (new->name==tok_ONE_LEVEL) {
+	if (new->numLevels>1)
+	    return ReportTypeBadWidth("ONE_LEVEL",new->numLevels,1);
+	info->stdPresent|= XkbOneLevelMask;
+    }
+    else if (new->name==tok_TWO_LEVEL) {
+	if (new->numLevels>2) 
+	    return ReportTypeBadWidth("TWO_LEVEL",new->numLevels,2);
+	else if (new->numLevels<2)
+	    new->numLevels= 2;
+	info->stdPresent|= XkbTwoLevelMask;
+    }
+    else if (new->name==tok_ALPHABETIC) {
+	if (new->numLevels>2) 
+	    return ReportTypeBadWidth("ALPHABETIC",new->numLevels,2);
+	else if (new->numLevels<2)
+	    new->numLevels= 2;
+	info->stdPresent|= XkbAlphabeticMask;
+    }
+    else if (new->name==tok_KEYPAD) {
+	if (new->numLevels>2)
+	    return ReportTypeBadWidth("KEYPAD",new->numLevels,2);
+	else if (new->numLevels<2)
+	    new->numLevels= 2;
+	info->stdPresent|= XkbKeypadMask;
+    }
+
+    old= FindMatchingKeyType(info,new);
+    if (old!=NULL) {
+	Bool	report;
+	if ((new->defs.merge==MergeReplace)||(new->defs.merge==MergeOverride)) {
+	    KeyTypeInfo *next= (KeyTypeInfo *)old->defs.next;
+            if (((old->defs.fileID==new->defs.fileID)&&(warningLevel>0))||
+                                                        (warningLevel>9)) {
+		WARN1("Multiple definitions of the %s key type\n",
+					XkbAtomGetString(NULL,new->name));
+		ACTION("Earlier definition ignored\n");
+	    }
+	    FreeKeyTypeInfo(old);
+	    *old= *new;
+	    new->szEntries= new->nEntries= 0;
+	    new->entries= NULL;
+	    new->preserve= NULL;
+	    new->lvlNames= NULL;
+	    old->defs.next= &next->defs;
+	    return True;
+	}
+	report= (old->defs.fileID==new->defs.fileID)&&(warningLevel>0);
+	if (report) {
+	    WARN1("Multiple definitions of the %s key type\n",
+					XkbAtomGetString(NULL,new->name));
+	    ACTION("Later definition ignored\n");
+	}
+	FreeKeyTypeInfo(new);
+	return True;
+    }
+    old= NextKeyType(info);
+    if (old==NULL)
+	return False;
+    *old= *new;
+    old->defs.next= NULL;
+    new->nEntries= new->szEntries= 0;
+    new->entries= NULL;
+    new->szNames= 0;
+    new->lvlNames= NULL;
+    new->preserve= NULL;
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+MergeIncludedKeyTypes(	KeyTypesInfo *	into,
+			KeyTypesInfo *	from,
+			unsigned	merge,
+			XkbDescPtr	xkb)
+#else
+MergeIncludedKeyTypes(into,from,merge,xkb)
+    KeyTypesInfo	*into;
+    KeyTypesInfo	*from;
+    unsigned		 merge;
+    XkbDescPtr		 xkb;
+#endif
+{
+KeyTypeInfo *	type;
+
+    if (from->errorCount>0) {
+	into->errorCount+= from->errorCount;
+	return;
+    }
+    if (into->name==NULL) {
+	into->name= from->name;
+	from->name= NULL;
+    }
+    for (type=from->types;type;type=(KeyTypeInfo *)type->defs.next) {
+	if (merge!=MergeDefault)
+	    type->defs.merge= merge;
+	if (!AddKeyType(xkb,into,type))
+	    into->errorCount++;
+    }
+    into->stdPresent|= from->stdPresent;
+    return;
+}
+
+typedef void (*FileHandler)(
+#if NeedFunctionPrototypes
+    XkbFile *		/* file */,
+    XkbDescPtr		/* xkb */,
+    unsigned		/* merge */,
+    KeyTypesInfo *	/* included */
+#endif
+);
+
+static Bool
+#if NeedFunctionPrototypes
+HandleIncludeKeyTypes(	IncludeStmt *	stmt,
+			XkbDescPtr	xkb,
+			KeyTypesInfo *	info,
+			FileHandler	hndlr)
+#else
+HandleIncludeKeyTypes(stmt,xkb,info,hndlr)
+    IncludeStmt	*	stmt;
+    XkbDescPtr		xkb;
+    KeyTypesInfo *	info;
+    FileHandler		hndlr;
+#endif
+{
+unsigned	newMerge;
+XkbFile	*	rtrn;
+KeyTypesInfo 	included;
+Bool		haveSelf;
+
+    haveSelf= False;
+    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
+	haveSelf= True;
+	included= *info;
+	bzero(info,sizeof(KeyTypesInfo));
+    }
+    else if (ProcessIncludeFile(stmt,XkmTypesIndex,&rtrn,&newMerge)) {
+	InitKeyTypesInfo(&included,xkb,info);
+	included.fileID= included.dflt.defs.fileID= rtrn->id;
+	included.dflt.defs.merge= newMerge;
+
+	(*hndlr)(rtrn,xkb,newMerge,&included);
+	if (stmt->stmt!=NULL) {
+	    if (included.name!=NULL)
+		uFree(included.name);
+	    included.name= stmt->stmt;
+	    stmt->stmt= NULL;
+	}
+    }
+    else {
+	info->errorCount+= 10;
+	return False;
+    }
+    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
+	IncludeStmt *	next;
+	unsigned	op;
+	KeyTypesInfo	next_incl;
+
+        for (next=stmt->next;next!=NULL;next=next->next) {
+	    if ((next->file==NULL)&&(next->map==NULL)) {
+		haveSelf= True;
+		MergeIncludedKeyTypes(&included,info,next->merge,xkb);
+		FreeKeyTypesInfo(info);
+	    }
+	    else if (ProcessIncludeFile(next,XkmTypesIndex,&rtrn,&op)) {
+		InitKeyTypesInfo(&next_incl,xkb,&included);
+		next_incl.fileID= next_incl.dflt.defs.fileID= rtrn->id;
+		next_incl.dflt.defs.merge= op;
+		(*hndlr)(rtrn,xkb,op,&next_incl);
+		MergeIncludedKeyTypes(&included,&next_incl,op,xkb);
+		FreeKeyTypesInfo(&next_incl);
+	    }
+	    else {
+		info->errorCount+= 10;
+		return False;
+	    }
+	}
+    }
+    if (haveSelf)
+	*info= included;
+    else {
+	MergeIncludedKeyTypes(info,&included,newMerge,xkb);
+	FreeKeyTypesInfo(&included);
+    }
+    return (info->errorCount==0);
+}
+
+/***====================================================================***/
+
+static XkbKTMapEntryPtr
+#if NeedFunctionPrototypes
+FindMatchingMapEntry(KeyTypeInfo *type,unsigned mask,unsigned vmask)
+#else
+FindMatchingMapEntry(type,mask,vmask)
+    KeyTypeInfo *	type;
+    unsigned		mask;
+    unsigned		vmask;
+#endif
+{
+register int 		i;
+XkbKTMapEntryPtr	entry;
+
+    for (i=0,entry=type->entries;i<type->nEntries;i++,entry++) {
+	if ((entry->mods.real_mods==mask)&&(entry->mods.vmods==vmask))
+	    return entry;
+    }
+    return NULL;
+}
+
+static void
+#if NeedFunctionPrototypes
+DeleteLevel1MapEntries(KeyTypeInfo *type)
+#else
+DeleteLevel1MapEntries(type)
+    KeyTypeInfo *	type;
+#endif
+{
+register int i,n;
+
+    for (i=0;i<type->nEntries;i++) {
+	if (type->entries[i].level==0) {
+	    for (n=i;n<type->nEntries-1;n++) {
+		type->entries[n]= type->entries[n+1];
+	    }
+	    type->nEntries--;
+	}
+    }
+    return;
+}
+
+static XkbKTMapEntryPtr
+#if NeedFunctionPrototypes
+NextMapEntry(KeyTypeInfo *type)
+#else
+NextMapEntry(type)
+    KeyTypeInfo *	type;
+#endif
+{
+    if (type->entries==NULL) {
+	type->entries= uTypedCalloc(2,XkbKTMapEntryRec);
+	if (type->entries==NULL) {
+	    ERROR1("Couldn't allocate map entries for %s\n",TypeTxt(type));
+	    ACTION("Map entries lost\n");
+	    return NULL;
+	}
+	type->szEntries= 2;
+	type->nEntries= 0;
+    }
+    else if (type->nEntries>=type->szEntries) {
+	type->szEntries*=2;
+	type->entries= uTypedRecalloc(type->entries,
+					type->nEntries,type->szEntries,
+					XkbKTMapEntryRec);
+	if (type->entries==NULL) {
+	    ERROR1("Couldn't reallocate map entries for %s\n",TypeTxt(type));
+	    ACTION("Map entries lost\n");
+	    return NULL;
+	}
+    }
+    return &type->entries[type->nEntries++];
+}
+
+Bool
+#if NeedFunctionPrototypes
+AddPreserve(	XkbDescPtr	xkb,
+		KeyTypeInfo *	type,
+		PreserveInfo *	new,
+		Bool		clobber,
+		Bool		report)
+#else
+AddPreserve(xkb,type,new,clobber,report)
+    XkbDescPtr		xkb;
+    KeyTypeInfo *	type;
+    PreserveInfo *	new;
+    Bool		clobber;
+    Bool		report;
+#endif
+{
+PreserveInfo	*old;
+
+    old= type->preserve;
+    while (old!=NULL) {
+	if ((old->indexMods!=new->indexMods)||
+					(old->indexVMods!=new->indexVMods)) {
+	    old= (PreserveInfo *)old->defs.next;
+	    continue;
+	}
+	if ((old->preMods==new->preMods)&&(old->preVMods==new->preVMods)) {
+	    if (warningLevel>9) {
+                WARN2("Identical definitions for preserve[%s] in %s\n",
+				PreserveIndexTxt(type,xkb,old),TypeTxt(type));
+                ACTION("Ignored\n");
+	    }
+	    return True;
+	}
+	if (report && (warningLevel>0)) {
+	    char *str;
+	    WARN2("Multiple definitions for preserve[%s] in %s\n",
+				PreserveIndexTxt(type,xkb,old),TypeTxt(type));
+
+	    if (clobber)	str= PreserveTxt(type,xkb,new);
+	    else 		str= PreserveTxt(type,xkb,old);
+	    ACTION1("Using %s, ",str);
+	    if (clobber)	str= PreserveTxt(type,xkb,old);
+	    else 		str= PreserveTxt(type,xkb,new);
+	    INFO1("ignoring %s\n",str);
+	}
+	if (clobber) {
+	    old->preMods= new->preMods;
+	    old->preVMods= new->preVMods;
+	}
+	return True;
+    }
+    old= uTypedAlloc(PreserveInfo);
+    if (!old) {
+	WSGO1("Couldn't allocate preserve in %s\n",TypeTxt(type));
+	ACTION1("Preserve[%s] lost\n",PreserveIndexTxt(type,xkb,old));
+	return False;
+    }
+    *old= *new;
+    old->matchingMapIndex= -1;
+    type->preserve=(PreserveInfo*)AddCommonInfo(&type->preserve->defs,&old->defs);
+    return True;
+}
+
+Bool
+#if NeedFunctionPrototypes
+AddMapEntry(	XkbDescPtr		xkb,
+		KeyTypeInfo *		type,
+		XkbKTMapEntryPtr	new,
+		Bool			clobber,
+		Bool			report)
+#else
+AddMapEntry(xkb,type,new,clobber,report)
+    XkbDescPtr		xkb;
+    KeyTypeInfo *	type;
+    XkbKTMapEntryPtr	new;
+    Bool		clobber;
+    Bool		report;
+#endif
+{
+XkbKTMapEntryPtr	old;
+
+    if ((old=FindMatchingMapEntry(type,new->mods.real_mods,new->mods.vmods))) {
+	if (report&&(old->level!=new->level)) {
+	    unsigned use,ignore;
+	    if (clobber) { 
+		use= new->level+1;
+		ignore= old->level+1;
+	    }
+	    else {
+		use= old->level+1;
+		ignore= new->level+1;
+	    }
+	    WARN2("Multiple map entries for %s in %s\n",
+				MapEntryTxt(type,xkb,new),TypeTxt(type));
+	    ACTION2("Using %d, ignoring %d\n",use,ignore);
+	}
+	else if (warningLevel>9) {
+	    WARN3("Multiple occurences of map[%s]= %d in %s\n",
+			MapEntryTxt(type,xkb,new),new->level+1,TypeTxt(type));
+	    ACTION("Ignored\n");
+	    return True;
+	}
+	if (clobber)
+	    old->level= new->level;
+	return True;
+    }
+    if ((old=NextMapEntry(type))==NULL)
+	return False;	/* allocation failure, already reported */
+    if (new->level>=type->numLevels)
+	type->numLevels= new->level+1;
+    if (new->mods.vmods==0)	old->active= True;
+    else			old->active= False;
+    old->mods.mask= new->mods.real_mods;
+    old->mods.real_mods= new->mods.real_mods;
+    old->mods.vmods= new->mods.vmods;
+    old->level= new->level;
+    return True;
+}
+
+static LookupEntry lnames[] = {
+	{	"level1",	1	},
+	{	"level2",	2	},
+	{	"level3",	3	},
+	{	"level4",	4	},
+	{	"level5",	5	},
+	{	"level6",	6	},
+	{	"level7",	7	},
+	{	"level8",	8	},
+	{	NULL,		0	}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+SetMapEntry(	KeyTypeInfo *	type,
+		XkbDescPtr	xkb,
+		ExprDef *	arrayNdx,
+		ExprDef *	value)
+#else
+SetMapEntry(type,xkb,arrayNdx,value)
+    KeyTypeInfo *	type;
+    XkbDescPtr		xkb;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+#endif
+{
+ExprResult		rtrn;
+XkbKTMapEntryRec	entry;
+
+    if (arrayNdx==NULL)
+	return ReportTypeShouldBeArray(type,"map entry");
+    if (!ExprResolveModMask(arrayNdx,&rtrn,LookupVModMask,(XPointer)xkb))
+	return ReportTypeBadType(type,"map entry","modifier mask");
+    entry.mods.real_mods= rtrn.uval&0xff;
+    entry.mods.vmods= (rtrn.uval>>8)&0xffff;
+    if ((entry.mods.real_mods&(~type->mask))||
+				((entry.mods.vmods&(~type->vmask))!=0)) {
+	if (warningLevel>0) {
+	    WARN1("Map entry for unused modifiers in %s\n",TypeTxt(type));
+	    ACTION1("Using %s instead of ",XkbVModMaskText(type->dpy,xkb,
+						entry.mods.real_mods&type->mask,
+						entry.mods.vmods&type->vmask,
+						XkbMessage));
+	    INFO1("%s\n",MapEntryTxt(type,xkb,&entry));
+	}
+	entry.mods.real_mods&= type->mask;
+	entry.mods.vmods&= type->vmask;
+    }
+    if (!ExprResolveInteger(value,&rtrn,SimpleLookup,(XPointer)lnames)) {
+	ERROR("Level specifications in a key type must be integer\n");
+	ACTION("Ignoring malformed level specification\n");
+	return False;
+    }
+    if ((rtrn.ival<1)||(rtrn.ival>XkbMaxShiftLevel+1)) {
+	ERROR3("Shift level %d out of range (1..%d) in key type %s\n",
+						XkbMaxShiftLevel+1,
+						rtrn.ival,TypeTxt(type));
+	ACTION1("Ignoring illegal definition of map[%s]\n",
+						MapEntryTxt(type,xkb,&entry));
+	return False;
+    }
+    entry.level= rtrn.ival-1;
+    return AddMapEntry(xkb,type,&entry,True,True);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+SetPreserve(	KeyTypeInfo *	type,
+		XkbDescPtr	xkb,
+		ExprDef *	arrayNdx,
+		ExprDef *	value)
+#else
+SetPreserve(type,xkb,arrayNdx,value)
+    KeyTypeInfo *	type;
+    XkbDescPtr		xkb;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	 rtrn;
+PreserveInfo 	 new;
+
+    if (arrayNdx==NULL)
+	return ReportTypeShouldBeArray(type,"preserve entry");
+    if (!ExprResolveModMask(arrayNdx,&rtrn,LookupVModMask,(XPointer)xkb))
+	return ReportTypeBadType(type,"preserve entry","modifier mask");
+    new.defs= type->defs;
+    new.defs.next= NULL;
+    new.indexMods= rtrn.uval&0xff;
+    new.indexVMods= (rtrn.uval>>8)&0xffff;
+    if ((new.indexMods&(~type->mask))||(new.indexVMods&(~type->vmask))) {
+	if (warningLevel>0) {
+	    WARN1("Preserve for modifiers not used by the %s type\n",
+							TypeTxt(type));
+	    ACTION1("Index %s converted to ",PreserveIndexTxt(type,xkb,&new));
+	}
+	new.indexMods&= type->mask;
+	new.indexVMods&= type->vmask;
+	if (warningLevel>0)
+	    INFO1("%s\n",PreserveIndexTxt(type,xkb,&new));
+    }
+    if (!ExprResolveModMask(value,&rtrn,LookupVModMask,(XPointer)xkb)) {
+	ERROR("Preserve value in a key type is not a modifier mask\n");
+	ACTION2("Ignoring preserve[%s] in type %s\n",
+					PreserveIndexTxt(type,xkb,&new),
+					TypeTxt(type));
+	return False;
+    }
+    new.preMods= rtrn.uval&0xff;
+    new.preVMods= (rtrn.uval>>16)&0xffff;
+    if ((new.preMods&(~new.indexMods))||(new.preVMods&&(~new.indexVMods))) {
+	if (warningLevel>0) {
+	    WARN2("Illegal value for preserve[%s] in type %s\n",
+					PreserveTxt(type,xkb,&new),
+					TypeTxt(type));
+	    ACTION1("Converted %s to ",PreserveIndexTxt(type,xkb,&new));
+	}
+	new.preMods&= new.indexMods;
+	new.preVMods&= new.indexVMods;
+	if (warningLevel>0) {
+	    INFO1("%s\n",PreserveIndexTxt(type,xkb,&new));
+	}
+    }
+    return AddPreserve(xkb,type,&new,True,True);
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+AddLevelName(	KeyTypeInfo *	type,
+		unsigned 	level,
+		Atom 		name,
+		Bool 		clobber,
+		Bool 		report)
+#else
+AddLevelName(type,level,name,clobber,report)
+    KeyTypeInfo *	type;
+    unsigned		level;
+    Atom		name;
+    Bool		clobber;
+    Bool		report;
+#endif
+{
+    if ((type->lvlNames==NULL)||(type->szNames<=level)) {
+	type->lvlNames= 
+		      uTypedRecalloc(type->lvlNames,type->szNames,level+1,Atom);
+	if (type->lvlNames==NULL) {
+	    ERROR1("Couldn't allocate level names for type %s\n",TypeTxt(type));
+	    ACTION("Level names lost\n");
+	    type->szNames= 0;
+	    return False;
+	}
+	type->szNames= level+1;
+    }
+    else if (type->lvlNames[level]==name) {
+	if (warningLevel>9) {
+	    WARN2("Duplicate names for level %d of key type %s\n",level+1,
+								TypeTxt(type));
+	    ACTION("Ignored\n");
+	}
+	return True;
+    }
+    else if (type->lvlNames[level]!=None) {
+	if (warningLevel>0) {
+	    char *old,*new;
+	    old= XkbAtomText(type->dpy,type->lvlNames[level],XkbMessage);
+	    new= XkbAtomText(type->dpy,name,XkbMessage);
+	    WARN2("Multiple names for level %d of key type %s\n",level+1,
+								TypeTxt(type));
+	    if (clobber)
+		 ACTION2("Using %s, ignoring %s\n",new,old);
+	    else ACTION2("Using %s, ignoring %s\n",old,new);
+	}
+	if (!clobber)
+	    return True;
+    }
+    if (level>=type->numLevels)
+	type->numLevels= level+1;
+    type->lvlNames[level]= name;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+SetLevelName(KeyTypeInfo *type,ExprDef *arrayNdx,ExprDef *value)
+#else
+SetLevelName(type,arrayNdx,value)
+    KeyTypeInfo *	type;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	rtrn;
+unsigned 	level;
+
+    if (arrayNdx==NULL)
+	return ReportTypeShouldBeArray(type,"level name");
+    if (!ExprResolveInteger(arrayNdx,&rtrn,SimpleLookup,(XPointer)lnames))
+	return ReportTypeBadType(type,"level name","integer");
+    if ((rtrn.ival<1)||(rtrn.ival>XkbMaxShiftLevel+1)) {
+	ERROR3("Level name %d out of range (1..%d) in key type %s\n",
+				rtrn.ival,
+				XkbMaxShiftLevel+1,
+				XkbAtomText(type->dpy,type->name,XkbMessage));
+	ACTION("Ignoring illegal level name definition\n");
+	return False;
+    }
+    level= rtrn.ival-1;
+    if (!ExprResolveString(value,&rtrn,NULL,NULL)) {
+	ERROR2("Non-string name for level %d in key type %s\n",level+1,
+				XkbAtomText(type->dpy,type->name,XkbMessage));
+	ACTION("Ignoring illegal level name definition\n");
+	return False;
+    }
+    return 
+    	AddLevelName(type,level,XkbInternAtom(NULL,rtrn.str,False),True,True);
+}
+
+/***====================================================================***/
+
+static Bool
+#if NeedFunctionPrototypes
+SetKeyTypeField(	KeyTypeInfo *	type,
+			XkbDescPtr	xkb,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			KeyTypesInfo *	info)
+#else
+SetKeyTypeField(type,xkb,field,arrayNdx,value,info)
+    KeyTypeInfo *	type;
+    XkbDescPtr		xkb;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    KeyTypesInfo *	info;
+#endif
+{
+ExprResult	tmp;
+
+    if (uStrCaseCmp(field,"modifiers")==0) {
+	unsigned mods,vmods;
+	if (arrayNdx!=NULL) {
+	    WARN("The modifiers field of a key type is not an array\n");
+	    ACTION("Illegal array subscript ignored\n");
+	}
+	if (!ExprResolveModMask(value,&tmp,LookupVModMask,(XPointer)xkb)) {
+	    ERROR("Key type mask field must be a modifier mask\n");
+	    ACTION("Key type definition ignored\n");
+	    return False;
+	}
+	mods= tmp.uval&0xff;
+	vmods= (tmp.uval>>8)&0xffff;
+	if (type->defs.defined&_KT_Mask) {
+	    WARN1("Multiple modifier mask definitions for key type %s\n",
+				XkbAtomText(type->dpy,type->name,XkbMessage));
+	    ACTION1("Using %s, ",TypeMaskTxt(type,xkb));
+	    INFO1("ignoring %s\n",XkbVModMaskText(type->dpy,xkb,mods,
+								vmods,
+								XkbMessage));
+	    return False;
+	}
+	type->mask= mods;
+	type->vmask= vmods;
+	type->defs.defined|= _KT_Mask;
+	return True;
+    }
+    else if (uStrCaseCmp(field,"map")==0) {
+	type->defs.defined|= _KT_Map;
+	return SetMapEntry(type,xkb,arrayNdx,value);
+    }
+    else if (uStrCaseCmp(field,"preserve")==0) {
+	type->defs.defined|= _KT_Preserve;
+	return SetPreserve(type,xkb,arrayNdx,value);
+    }
+    else if ((uStrCaseCmp(field,"levelname")==0)||
+	     (uStrCaseCmp(field,"level_name")==0)) {
+	type->defs.defined|= _KT_LevelNames;
+	return SetLevelName(type,arrayNdx,value);
+    }
+    ERROR2("Unknown field %s in key type %s\n",field,TypeTxt(type));
+    ACTION("Definition ignored\n");
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleKeyTypeVar(VarDef *stmt,XkbDescPtr xkb,KeyTypesInfo *info)
+#else
+HandleKeyTypeVar(stmt,xkb,info)
+    VarDef *		stmt;
+    XkbDescPtr		xkb;
+    KeyTypesInfo *	info;
+#endif
+{
+ExprResult	elem,field;
+ExprDef *	arrayNdx;
+
+    if (!ExprResolveLhs(stmt->name,&elem,&field,&arrayNdx)) 
+	return False; /* internal error, already reported */
+    if (elem.str&&(uStrCaseCmp(elem.str,"type")==0))
+	return SetKeyTypeField(&info->dflt,xkb,field.str,arrayNdx,stmt->value,
+							     		info);	
+    if (elem.str!=NULL) {
+	ERROR1("Default for unknown element %s\n",uStringText(elem.str));
+	ACTION1("Value for field %s ignored\n",uStringText(field.str));
+    }
+    else if (field.str!=NULL) {
+	ERROR1("Default defined for unknown field %s\n",uStringText(field.str));
+	ACTION("Ignored\n");
+    }
+    return False;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleKeyTypeBody(	VarDef *	def,
+			XkbDescPtr	xkb,
+			KeyTypeInfo *	type,
+			KeyTypesInfo *	info)
+#else
+HandleKeyTypeBody(def,xkb,type,info)
+    VarDef *		def;
+    XkbDescPtr		xkb;
+    KeyTypeInfo *	type;
+    KeyTypesInfo *	info;
+#endif
+{
+int		ok= 1;
+ExprResult	tmp,field;
+ExprDef *	arrayNdx;
+
+    for (;def!=NULL;def= (VarDef *)def->common.next) {
+	if ((def->name)&&(def->name->type==ExprFieldRef)) {
+	    ok= HandleKeyTypeVar(def,xkb,info);
+	    continue;
+	}
+	ok= ExprResolveLhs(def->name,&tmp,&field,&arrayNdx);
+	if (ok)
+	    ok= SetKeyTypeField(type,xkb,field.str,arrayNdx,def->value,info);
+    }
+    return ok;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleKeyTypeDef(	KeyTypeDef *	def,
+			XkbDescPtr	xkb,
+			unsigned 	merge,
+			KeyTypesInfo *	info)
+#else
+HandleKeyTypeDef(def,xkb,merge,info)
+    KeyTypeDef *	def;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    KeyTypesInfo *	info;
+#endif
+{
+register int		i;
+KeyTypeInfo 		type;
+ 
+    if (def->merge!=MergeDefault)
+	merge= def->merge;
+
+    type.defs.defined= 	0;
+    type.defs.fileID= 	info->fileID;
+    type.defs.merge=	merge;
+    type.defs.next=	0;
+    type.dpy= 		info->dpy;
+    type.name= def->name;
+    type.mask= info->dflt.mask;
+    type.vmask= info->dflt.vmask;
+    type.groupInfo= info->dflt.groupInfo;
+    type.numLevels= 1;
+    type.nEntries= type.szEntries= 0;
+    type.entries= NULL;
+    type.szNames= 0;
+    type.lvlNames= NULL;
+    type.preserve= NULL;
+
+    if (!HandleKeyTypeBody(def->body,xkb,&type,info)) {
+	info->errorCount++;
+	return False;
+    }
+
+    /* now copy any appropriate map, preserve or level names from the */
+    /* default type */
+    for (i=0;i<info->dflt.nEntries;i++) {
+	XkbKTMapEntryPtr dflt;
+	dflt= &info->dflt.entries[i];
+	if (((dflt->mods.real_mods&type.mask)==dflt->mods.real_mods)&&
+	    ((dflt->mods.vmods&type.vmask)==dflt->mods.vmods)) {
+	    AddMapEntry(xkb,&type,dflt,False,False);
+	}
+    }
+    if (info->dflt.preserve) {
+	PreserveInfo *dflt= info->dflt.preserve;
+	while (dflt) {
+	    if (((dflt->indexMods&type.mask)==dflt->indexMods)&&
+		((dflt->indexVMods&type.vmask)==dflt->indexVMods)) {
+		AddPreserve(xkb,&type,dflt,False,False);
+	    }
+	    dflt= (PreserveInfo *)dflt->defs.next;
+	}
+    }
+    for (i=0;i<info->dflt.szNames;i++) {
+	if ((i<type.numLevels)&&(info->dflt.lvlNames[i]!=None)) {
+	    AddLevelName(&type,i,info->dflt.lvlNames[i],False,False);
+	}
+    }
+    if (!AddKeyType(xkb,info,&type)) {
+	info->errorCount++;
+	return False;
+    }
+    return True;
+}
+
+static void
+#if NeedFunctionPrototypes
+HandleKeyTypesFile(	XkbFile	 *	file,
+			XkbDescPtr	xkb,
+			unsigned	merge,
+			KeyTypesInfo *	info)
+#else
+HandleKeyTypesFile(file,xkb,merge,info)
+    XkbFile		*file;
+    XkbDescPtr	 	 xkb;
+    unsigned		 merge;
+    KeyTypesInfo	*info;
+#endif
+{
+ParseCommon	*stmt;
+
+    if ((merge==MergeOverride)||(info->name==None))
+	info->name= file->name;
+
+    info->name= file->name;
+    stmt= file->defs;
+    while (stmt) {
+	switch (stmt->stmtType) {
+	    case StmtInclude:
+		if (!HandleIncludeKeyTypes((IncludeStmt *)stmt,xkb,info,
+						HandleKeyTypesFile))
+		    info->errorCount++;
+		break;
+	    case StmtKeyTypeDef:
+		if (!HandleKeyTypeDef((KeyTypeDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtVarDef:
+		if (!HandleKeyTypeVar((VarDef *)stmt,xkb,info))
+		    info->errorCount++;
+		break;
+	    case StmtVModDef:
+		if (!HandleVModDef((VModDef *)stmt,merge,&info->vmods))
+		    info->errorCount++;
+		break;
+	    case StmtKeyAliasDef:
+		ERROR("Key type files may not include other declarations\n");
+		ACTION("Ignoring definition of key alias\n");
+		info->errorCount++;
+		break;
+	    case StmtKeycodeDef:
+		ERROR("Key type files may not include other declarations\n");
+		ACTION("Ignoring definition of key name\n");
+		info->errorCount++;
+		break;
+	    case StmtInterpDef:
+		ERROR("Key type files may not include other declarations\n");
+		ACTION("Ignoring definition of symbol interpretation\n");
+		info->errorCount++;
+		break;
+	    default:
+		WSGO1("Unexpected statement type %d in HandleKeyTypesFile\n",
+								stmt->stmtType);
+		break;
+	}
+	stmt= stmt->next;
+	if (info->errorCount>10) {
+#ifdef NOISY
+	    ERROR("Too many errors\n");
+#endif
+	    ACTION1("Abandoning keytypes file \"%s\"\n",file->topName);
+	    break;
+	}
+    }
+    return;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopyDefToKeyType(XkbDescPtr xkb,XkbKeyTypePtr type,KeyTypeInfo *def)
+#else
+CopyDefToKeyType(xkb,type,def)
+    XkbDescPtr		xkb;
+    XkbKeyTypePtr	type;
+    KeyTypeInfo *	def;
+#endif
+{
+register int i;
+PreserveInfo *pre;
+
+    for (pre=def->preserve;pre!=NULL;pre=(PreserveInfo *)pre->defs.next) {
+	XkbKTMapEntryPtr match;
+	XkbKTMapEntryRec tmp;
+	tmp.mods.real_mods= pre->indexMods;
+	tmp.mods.vmods= pre->indexVMods;
+	tmp.level= 0;
+	AddMapEntry(xkb,def,&tmp,False,False);
+	match= FindMatchingMapEntry(def,pre->indexMods,pre->indexVMods);
+	if (!match) {
+	    WSGO("Couldn't find matching entry for preserve\n");
+	    ACTION("Aborting\n");
+	    return False;
+	}
+	pre->matchingMapIndex= match-def->entries;
+    }
+    type->mods.real_mods= def->mask;
+    type->mods.vmods= def->vmask;
+    type->num_levels= def->numLevels;
+    type->map_count= def->nEntries;
+    type->map= def->entries;
+    if (def->preserve) {
+	type->preserve= uTypedCalloc(type->map_count,XkbModsRec);
+	if (!type->preserve) {
+	    WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");
+	    ACTION1("Preserve setting for type %s lost\n",
+				XkbAtomText(def->dpy,def->name,XkbMessage));
+	}
+	else {
+	    pre= def->preserve;
+	    for (;pre!=NULL;pre=(PreserveInfo *)pre->defs.next) {
+		int ndx= pre->matchingMapIndex;
+		type->preserve[ndx].mask= pre->preMods;
+		type->preserve[ndx].real_mods= pre->preMods;
+		type->preserve[ndx].vmods= pre->preVMods;
+	    }
+	}
+    }
+    else type->preserve= NULL;
+    type->name= (Atom)def->name;
+    if (def->szNames>0) {
+	type->level_names= uTypedCalloc(def->numLevels,Atom);
+
+	/* assert def->szNames<=def->numLevels */
+	for (i=0;i<def->szNames;i++) {
+	    type->level_names[i]= (Atom)def->lvlNames[i];
+	}
+    }
+    else {
+	type->level_names= NULL;
+    }
+
+    def->nEntries= def->szEntries= 0;
+    def->entries= NULL;
+    return XkbComputeEffectiveMap(xkb,type,NULL);
+}
+
+Bool
+#if NeedFunctionPrototypes
+CompileKeyTypes(XkbFile *file,XkbFileInfo *result,unsigned merge)
+#else
+CompileKeyTypes(file,result,merge)
+    XkbFile *		file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+#endif
+{
+KeyTypesInfo	info;
+XkbDescPtr	xkb;
+
+    xkb= result->xkb;
+    InitKeyTypesInfo(&info,xkb,NULL);
+    info.fileID= file->id;
+    HandleKeyTypesFile(file,xkb,merge,&info);
+
+    if (info.errorCount==0) {
+	register int i;
+	register KeyTypeInfo *def;
+	register XkbKeyTypePtr type,next;
+
+	if (info.name!=None) {
+	    if (XkbAllocNames(xkb,XkbTypesNameMask,0,0)==Success)
+		xkb->names->types= XkbInternAtom(xkb->dpy,info.name,False);
+	    else {
+		WSGO("Couldn't allocate space for types name\n");
+		ACTION2("Name \"%s\" (from %s) NOT assigned\n",scanFile,
+								info.name);
+	    }
+	}
+	i= info.nTypes;
+	if ((info.stdPresent&XkbOneLevelMask)==0)
+	    i++;
+	if ((info.stdPresent&XkbTwoLevelMask)==0)
+	    i++;
+	if ((info.stdPresent&XkbKeypadMask)==0)
+	    i++;
+	if ((info.stdPresent&XkbAlphabeticMask)==0)
+	    i++;
+	if (XkbAllocClientMap(xkb,XkbKeyTypesMask,i)!=Success) {
+	    WSGO("Couldn't allocate client map\n");
+	    ACTION("Exiting\n");
+	    return False;
+	}
+	xkb->map->num_types= i;
+	if (XkbAllRequiredTypes&(~info.stdPresent)) {
+	    unsigned missing,keypadVMod;
+
+	    missing= XkbAllRequiredTypes&(~info.stdPresent);
+	    keypadVMod= FindKeypadVMod(xkb);
+	    if (XkbInitCanonicalKeyTypes(xkb,missing,keypadVMod)!=Success) {
+		WSGO("Couldn't initialize canonical key types\n");
+		ACTION("Exiting\n");
+		return False;
+	    }
+	    if (missing&XkbOneLevelMask)
+		xkb->map->types[XkbOneLevelIndex].name= tok_ONE_LEVEL;
+	    if (missing&XkbTwoLevelMask)
+		xkb->map->types[XkbTwoLevelIndex].name= tok_TWO_LEVEL;
+	    if (missing&XkbAlphabeticMask)
+		xkb->map->types[XkbAlphabeticIndex].name= tok_ALPHABETIC;
+	    if (missing&XkbKeypadMask)
+		xkb->map->types[XkbKeypadIndex].name= tok_KEYPAD;
+	}
+	next= &xkb->map->types[XkbLastRequiredType+1];
+	for (i=0,def=info.types;i<info.nTypes;i++) {
+	    if (def->name==tok_ONE_LEVEL)
+		 type= &xkb->map->types[XkbOneLevelIndex];
+	    else if (def->name==tok_TWO_LEVEL)
+		 type= &xkb->map->types[XkbTwoLevelIndex];
+	    else if (def->name==tok_ALPHABETIC)
+		 type= &xkb->map->types[XkbAlphabeticIndex];
+	    else if (def->name==tok_KEYPAD)
+		 type= &xkb->map->types[XkbKeypadIndex];
+	    else type= next++;
+	    DeleteLevel1MapEntries(def);
+	    if (!CopyDefToKeyType(xkb,type,def))
+		return False;
+	    def= (KeyTypeInfo *)def->defs.next;
+	}
+	return True;
+    }
+    return False;
+}
+
diff --git a/listing.c b/listing.c
new file mode 100644
index 0000000..c87e178
--- /dev/null
+++ b/listing.c
@@ -0,0 +1,500 @@
+/* $Xorg: listing.c,v 1.5 2001/02/09 02:05:49 xorgcvs Exp $ */
+/************************************************************
+ Copyright 1996 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.
+
+ ********************************************************/
+/***********************************************************
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+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 Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL 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.
+
+******************************************************************/
+
+
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <X11/keysym.h>
+
+#if defined(sgi)
+#include <malloc.h>
+#endif
+
+#define	DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR listingDebug
+#include "xkbcomp.h"
+#ifndef X_NOT_STDC_ENV
+#include <stdlib.h>
+#endif
+#ifndef X_NOT_POSIX
+#ifdef _POSIX_SOURCE
+#include <limits.h>
+#else
+#define _POSIX_SOURCE
+#include <limits.h>
+#undef _POSIX_SOURCE
+#endif
+#endif
+#ifndef PATH_MAX
+#ifdef WIN32
+#define PATH_MAX 512
+#else
+#include <sys/param.h>
+#endif
+#ifndef PATH_MAX
+#ifdef MAXPATHLEN
+#define PATH_MAX MAXPATHLEN
+#else
+#define PATH_MAX 1024
+#endif
+#endif
+#endif
+
+#ifdef WIN32
+#define BOOL wBOOL
+#include <windows.h>
+#undef BOOL
+#define FileName(file) file.cFileName
+#else
+#define FileName(file) file->d_name
+#ifndef X_NOT_POSIX
+#include <dirent.h>
+#else
+#ifdef SYSV
+#include <dirent.h>
+#else
+#ifdef USG
+#include <dirent.h>
+#else
+#include <sys/dir.h>
+#ifndef dirent
+#define dirent direct
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#include "xkbpath.h"
+#include "parseutils.h"
+#include "misc.h"
+#include "tokens.h"
+#include <X11/extensions/XKBgeom.h>
+
+#define	lowbit(x)	((x) & (-(x)))
+
+static	int		szListing= 0;
+static	int		nListed= 0;
+static	int		nFilesListed= 0;
+
+typedef struct _Listing {
+	char *		file;
+	char *		map;
+} Listing;
+
+static	int		szMapOnly;
+static	int		nMapOnly;
+static	char **		mapOnly;
+
+static	Listing *	list= NULL;
+
+/***====================================================================***/
+
+int
+#if NeedFunctionPrototypes
+AddMapOnly(char *map)
+#else
+AddMapOnly(map)
+    char *map;
+#endif
+{
+    if (nMapOnly>=szMapOnly) {
+	if (szMapOnly<1)	szMapOnly= 5;
+	else			szMapOnly*= 2;
+	mapOnly= uTypedRealloc(list,szMapOnly,char *);
+	if (!mapOnly) {
+	    WSGO("Couldn't allocate list of maps\n");
+	    return 0;
+	}
+    }
+    mapOnly[nMapOnly++]= map;
+    return 1;
+}
+
+int
+#if NeedFunctionPrototypes
+AddListing(char *file,char *map)
+#else
+AddListing(file,map)
+    char *file;
+    char *map;
+#endif
+{
+    if (nListed>=szListing) {
+	if (szListing<1)	szListing= 10;
+	else			szListing*= 2;
+	list= uTypedRealloc(list,szListing,Listing);
+	if (!list) {
+	    WSGO("Couldn't allocate list of files and maps\n");
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+    }
+
+    list[nListed].file= file;
+    list[nListed].map= map;
+    nListed++;
+    if (file!=NULL)
+	nFilesListed++;
+    return 1;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+ListFile(FILE *outFile,char *fileName,XkbFile *map)
+#else
+ListFile(outFile,fileName,map)
+FILE *		outFile;
+char *		fileName;
+XkbFile *	map;
+#endif
+{
+register unsigned	flags;
+char *			mapName;
+
+    flags= map->flags;
+    if ((flags&XkbLC_Hidden)&&(!(verboseLevel&WantHiddenMaps)))
+	return;
+    if ((flags&XkbLC_Partial)&&(!(verboseLevel&WantPartialMaps)))
+	return;
+    if (verboseLevel&WantLongListing) {
+	fprintf(outFile,(flags&XkbLC_Hidden)?"h":"-");
+	fprintf(outFile,(flags&XkbLC_Default)?"d":"-");
+	fprintf(outFile,(flags&XkbLC_Partial)?"p":"-");
+	fprintf(outFile,"----- ");
+	if (map->type==XkmSymbolsIndex) {
+	    fprintf(outFile,(flags&XkbLC_AlphanumericKeys)?"a":"-");
+	    fprintf(outFile,(flags&XkbLC_ModifierKeys)?"m":"-");
+	    fprintf(outFile,(flags&XkbLC_KeypadKeys)?"k":"-");
+	    fprintf(outFile,(flags&XkbLC_FunctionKeys)?"f":"-");
+	    fprintf(outFile,(flags&XkbLC_AlternateGroup)?"g":"-");
+	    fprintf(outFile,"--- ");
+	}
+        else fprintf(outFile,"-------- ");
+    }
+    mapName= map->name;
+    if ((!(verboseLevel&WantFullNames))&&((flags&XkbLC_Default)!=0))
+	mapName= NULL;
+    if (dirsToStrip>0) {
+	char *tmp,*last;
+	int	i;
+	for (i=0,tmp=last=fileName;(i<dirsToStrip)&&tmp;i++) {
+	    last= tmp;
+	    tmp= strchr(tmp,'/');
+	    if (tmp!=NULL)
+		tmp++;
+	}
+	fileName= (tmp?tmp:last);
+    }
+    if (mapName)
+	 fprintf(outFile,"%s(%s)\n",fileName,mapName);
+    else fprintf(outFile,"%s\n",fileName);
+    return;
+}
+
+/***====================================================================***/
+
+static int
+#if NeedFunctionPrototypes
+AddDirectory(char *head,char *ptrn,char *rest,char *map)
+#else
+AddDirectory(head,ptrn,rest,map)
+    char *	head;
+    char *	ptrn;
+    char *	rest;
+    char *	map;
+#endif
+{
+#ifdef WIN32
+    HANDLE		dirh;
+    WIN32_FIND_DATA	file;
+#else
+    DIR			*dirp;
+    struct dirent	*file;
+#endif
+    int			nMatch;
+
+    if (map==NULL) {
+	char *tmp = ptrn;
+	if ((rest==NULL)&&(ptrn!=NULL)&&(strchr(ptrn,'/')==NULL)) {
+	    tmp= ptrn;
+	    map= strchr(ptrn,'(');
+	}
+	else if ((rest==NULL)&&(ptrn==NULL)&&
+				(head!=NULL)&&(strchr(head,'/')==NULL)) {
+	    tmp= head;
+	    map= strchr(head,'(');
+	}
+	if (map!=NULL) {
+	    tmp= strchr(tmp,')');
+	    if ((tmp==NULL)||(tmp[1]!='\0')) {
+		ERROR("File and map must have the format file(map)\n");
+		return 0;
+	    }
+	    *map= '\0'; map++;
+	    *tmp= '\0';
+	}
+    }
+#ifdef WIN32
+    if ((dirh = FindFirstFile("*.*", &file)) == INVALID_HANDLE_VALUE)
+	return 0;
+#else
+    if ((dirp = opendir ((head?head:"."))) == NULL)
+	return 0;
+    nMatch= 0;
+#endif
+#ifdef WIN32
+    do
+#else
+    while ((file = readdir (dirp)) != NULL)
+#endif
+    {
+	char *tmp,*filename;
+	struct stat sbuf;
+
+	filename= FileName(file);
+	if (!filename || filename[0]=='.') 
+	    continue;
+	if (ptrn && (!XkbNameMatchesPattern(filename,ptrn)))
+	    continue;
+	tmp= (char *)uAlloc((head?strlen(head):0)+strlen(filename)+2);
+	if (!tmp)
+	    continue;
+	sprintf(tmp,"%s%s%s",(head?head:""),(head?"/":""),filename);
+	if (stat(tmp,&sbuf)<0) {
+	    uFree(tmp);
+	    continue;
+	}
+	if (((rest!=NULL)&&(!S_ISDIR(sbuf.st_mode)))||
+				    ((map!=NULL)&&(S_ISDIR(sbuf.st_mode)))) {
+	    uFree(tmp);
+	    continue;
+	}
+	if (S_ISDIR(sbuf.st_mode)) {
+	     if ((rest!=NULL)||(verboseLevel&ListRecursive))
+		nMatch+= AddDirectory(tmp,rest,NULL,map);
+	}
+	else nMatch+= AddListing(tmp,map);
+    }
+#ifdef WIN32
+    while (FindNextFile(dirh, &file));
+#endif
+    return nMatch;
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+AddMatchingFiles(char *head_in)
+#else
+AddMatchingFiles(head_in)
+    char *	head_in;
+#endif
+{
+char 	*str,*head,*ptrn,*rest= NULL;
+
+    if (head_in==NULL)
+	return 0;
+    ptrn= NULL;
+    for (str=head_in;(*str!='\0')&&(*str!='?')&&(*str!='*');str++) {
+	if ((str!=head_in)&&(*str=='/'))
+	    ptrn= str;
+    }
+    if (*str=='\0') { /* no wildcards */
+	head= head_in;
+	ptrn= NULL;
+	rest= NULL;
+    }
+    else if (ptrn==NULL) { /* no slash before the first wildcard */
+	head= NULL;
+	ptrn= head_in;
+    }
+    else {	/* slash followed by wildcard */
+	head= head_in;
+	*ptrn= '\0'; ptrn++;
+    }
+    if (ptrn) {
+	rest= strchr(ptrn,'/');
+	if (rest!=NULL) {
+	    *rest= '\0';
+	    rest++;
+	}
+    }
+    if(((rest && ptrn)&&((strchr(ptrn,'(')!=NULL)||(strchr(ptrn,')')!=NULL)))||
+	(head && ((strchr(head,'(')!=NULL)||(strchr(head,')')!=NULL)))) {
+	ERROR("Files/maps to list must have the form file(map)\n");
+	ACTION("Illegal specifier ignored\n");
+	return 0;
+    }
+    return AddDirectory(head,ptrn,rest,NULL);
+}
+
+/***====================================================================***/
+
+Bool
+MapMatches(mapToConsider,ptrn)
+    char *	mapToConsider;
+    char *	ptrn;
+{
+int	i;
+
+    if (ptrn!=NULL)
+	return XkbNameMatchesPattern(mapToConsider,ptrn);
+    if (nMapOnly<1)
+	return True;
+    for (i=0;i<nMapOnly;i++) {
+	if (XkbNameMatchesPattern(mapToConsider,mapOnly[i]))
+	    return True;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+GenerateListing(char *out_name)
+#else
+GenerateListing(out_name)
+    char *	out_name;
+#endif
+{
+int		i;
+FILE *		inputFile,*outFile;
+XkbFile *	rtrn,*mapToUse;
+unsigned	oldWarningLevel;
+char *		mapName;
+
+    if (nFilesListed<1) {
+	ERROR("Must specify at least one file or pattern to list\n");
+	return 0;
+    }
+    if ((!out_name)||((out_name[0]=='-')&&(out_name[1]=='\0')))
+	outFile= stdout;
+    else if ((outFile=fopen(out_name,"w"))==NULL) {
+	ERROR1("Cannot open \"%s\" to write keyboard description\n",out_name);
+	ACTION("Exiting\n");
+	return 0;
+    }
+#ifdef DEBUG
+    if (warningLevel>9)
+	fprintf(stderr,"should list:\n");
+#endif
+    for (i=0;i<nListed;i++) {
+#ifdef DEBUG
+	if (warningLevel>9) {
+	    fprintf(stderr,"%s(%s)\n",(list[i].file?list[i].file:"*"),
+					(list[i].map?list[i].map:"*"));
+	}
+#endif
+	oldWarningLevel= warningLevel;
+	warningLevel= 0;
+	if (list[i].file) {
+	    struct stat sbuf;
+	    
+	    if (stat(list[i].file,&sbuf)<0) {
+		if (oldWarningLevel>5)
+		    WARN1("Couldn't open \"%s\"\n",list[i].file);
+		continue;
+	    }
+	    if (S_ISDIR(sbuf.st_mode)) {
+		if (verboseLevel&ListRecursive)
+		    AddDirectory(list[i].file,NULL,NULL,NULL);
+		continue;
+	    }
+
+	    inputFile= fopen(list[i].file,"r");
+	    if (!inputFile) {
+		if (oldWarningLevel>5)
+		    WARN1("Couldn't open \"%s\"\n",list[i].file);
+		continue;
+	    }
+	    if (XKBParseFile(inputFile,&rtrn)&&(rtrn!=NULL)) {
+		mapName= list[i].map;
+		mapToUse= rtrn;
+		for (;mapToUse;mapToUse= (XkbFile *)mapToUse->common.next) {
+		    if (!MapMatches(mapToUse->name,mapName))
+			continue;
+		    ListFile(outFile,list[i].file,mapToUse);
+		}
+	    }
+	    fclose(inputFile);
+	}
+	warningLevel= oldWarningLevel;
+    }
+    return 1;
+}
+
diff --git a/misc.c b/misc.c
new file mode 100644
index 0000000..d9dd413
--- /dev/null
+++ b/misc.c
@@ -0,0 +1,605 @@
+/* $Xorg: misc.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "xkbpath.h"
+#include "tokens.h"
+#include "keycodes.h"
+#include "misc.h"
+#include <X11/keysym.h>
+#include "parseutils.h"
+
+#include <X11/extensions/XKBgeom.h>
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+ProcessIncludeFile(	IncludeStmt	*	stmt,
+			unsigned		file_type,
+			XkbFile **		file_rtrn,
+			unsigned *		merge_rtrn)
+#else
+ProcessIncludeFile(stmt,file_type,file_rtrn,merge_rtrn)
+    IncludeStmt	*	stmt;
+    unsigned		file_type;
+    XkbFile **		file_rtrn;
+    unsigned *		merge_rtrn;
+#endif
+{
+FILE	*file;
+XkbFile	*rtrn,*mapToUse;
+char	 oldFile[1024];
+int	 oldLine = lineNum;
+
+    rtrn= XkbFindFileInCache(stmt->file,file_type,&stmt->path);
+    if (rtrn==NULL) {
+	file= XkbFindFileInPath(stmt->file,file_type,&stmt->path);
+	if (file==NULL) {
+	    ERROR2("Can't find file \"%s\" for %s include\n",stmt->file,
+					XkbDirectoryForInclude(file_type));
+	    ACTION("Exiting\n");
+	    return False;
+	}
+	strcpy(oldFile,scanFile);
+	oldLine= lineNum;
+	setScanState(stmt->file,1);
+	if (debugFlags&2)
+	    INFO1("About to parse include file %s\n",stmt->file);
+	if ((XKBParseFile(file,&rtrn)==0)||(rtrn==NULL)) {
+	    setScanState(oldFile,oldLine);
+	    ERROR1("Error interpreting include file \"%s\"\n",stmt->file);
+	    ACTION("Exiting\n");
+	    fclose(file);
+	    return False;
+	}
+	fclose(file);
+	XkbAddFileToCache(stmt->file,file_type,stmt->path,rtrn);
+    }
+    mapToUse= rtrn;
+    if (stmt->map!=NULL) {
+	while ((mapToUse)&&((!uStringEqual(mapToUse->name,stmt->map))||
+						(mapToUse->type!=file_type))) {
+	    mapToUse= (XkbFile *)mapToUse->common.next;
+	}
+	if (!mapToUse) {
+	    ERROR3("No %s named \"%s\" in the include file \"%s\"\n",
+					XkbConfigText(file_type,XkbMessage),
+    					stmt->map,stmt->file);
+	    ACTION("Exiting\n");
+	    return False;
+	}
+    }
+    else if ((rtrn->common.next!=NULL)&&(warningLevel>5)) {
+	WARN1("No map in include statement, but \"%s\" contains several\n",
+								stmt->file);
+	ACTION1("Using first defined map, \"%s\"\n",rtrn->name);
+    }
+    setScanState(oldFile,oldLine);
+    if (mapToUse->type!=file_type) {
+	ERROR2("Include file wrong type (expected %s, got %s)\n",
+				XkbConfigText(file_type,XkbMessage),
+				XkbConfigText(mapToUse->type,XkbMessage));
+	ACTION1("Include file \"%s\" ignored\n",stmt->file);
+	return False;
+    }
+    if (mapToUse->compiled)  {
+	ERROR2("Map \"%s(%s)\" included more than once\n",stmt->file,
+								rtrn->name);
+	ACTION("Later inclusion ignored\n");
+	return False;
+    }
+    mapToUse->compiled= True;
+    *file_rtrn= mapToUse;
+    *merge_rtrn= stmt->merge;
+    return True;
+}
+
+/***====================================================================***/
+
+int
+#if NeedFunctionPrototypes
+ReportNotArray(char *type,char *field,char *name)
+#else
+ReportNotArray(type,field,name)
+    char *	type;
+    char *	field;
+    char *	name;
+#endif
+{
+    ERROR2("The %s %s field is not an array\n",type,field);
+    ACTION1("Ignoring illegal assignment in %s\n",name);
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ReportShouldBeArray(char *type,char *field,char *name)
+#else
+ReportShouldBeArray(type,field,name)
+    char *	type;
+    char *	field;
+    char *	name;
+#endif
+{
+    ERROR2("Missing subscript for %s %s\n",type,field);
+    ACTION1("Ignoring illegal assignment in %s\n",name);
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ReportBadType(char *type,char *field,char *name,char *wanted)
+#else
+ReportBadType(type,field,name,wanted)
+    char *type;
+    char *field;
+    char *name;
+    char *wanted;
+#endif
+{
+    ERROR3("The %s %s field must be a %s\n",type,field,wanted);
+    ACTION1("Ignoring illegal assignment in %s\n",name);
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ReportBadIndexType(char *type,char *field,char *name,char *wanted)
+#else
+ReportBadIndexType(type,field,name,wanted)
+    char *type;
+    char *field;
+    char *name;
+    char *wanted;
+#endif
+{
+    ERROR3("Index for the %s %s field must be a %s\n",type,field,wanted);
+    ACTION1("Ignoring assignment to illegal field in %s\n",name);
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ReportBadField(char *type,char *field,char *name)
+#else
+ReportBadField(type,field,name)
+    char *type;
+    char *field;
+    char *name;
+#endif
+{
+    ERROR3("Unknown %s field %s in %s\n",type,field,name);
+    ACTION1("Ignoring assignment to unknown field in %s\n",name);
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+ReportMultipleDefs(char *type,char *field,char *name)
+#else
+ReportMultipleDefs(type,field,name)
+    char *type;
+    char *field;
+    char *name;
+#endif
+{
+    WARN3("Multiple definitions of %s in %s \"%s\"\n",field,type,name);
+    ACTION("Using last definition\n");
+    return False;
+}
+
+/***====================================================================***/
+
+Bool	
+#if NeedFunctionPrototypes
+UseNewField(	unsigned	field,
+		CommonInfo *	oldDefs,
+		CommonInfo *	newDefs,
+		unsigned *	pCollide)
+#else
+UseNewField(field,oldDefs,newDefs,pCollide)
+    unsigned		field;
+    CommonInfo * 	oldDefs;
+    CommonInfo *	newDefs;
+    unsigned *		pCollide;
+#endif
+{
+Bool	useNew;
+
+    useNew= False;
+    if (oldDefs->defined&field) {
+	if (newDefs->defined&field) {
+	    if (((oldDefs->fileID==newDefs->fileID)&&(warningLevel>0))||
+							(warningLevel>9)) {
+		*pCollide|= field;
+	    }
+	    if (newDefs->merge!=MergeAugment)
+		useNew= True;
+	}
+    }
+    else if (newDefs->defined&field)
+	useNew= True;
+    return useNew;
+}
+
+Bool	
+#if NeedFunctionPrototypes
+MergeNewField(	unsigned	field,
+		CommonInfo * 	oldDefs,
+		CommonInfo *	newDefs,
+		unsigned *	pCollide)
+#else
+MergeNewField(field,oldDefs,newDefs,pCollide)
+    unsigned		field;
+    CommonInfo * 	oldDefs;
+    CommonInfo *	newDefs;
+    unsigned *		pCollide;
+#endif
+{
+    if ((oldDefs->defined&field)&&(newDefs->defined&field)) {
+	if (((oldDefs->fileID==newDefs->fileID)&&(warningLevel>0))||
+						 (warningLevel>9)) {
+	    *pCollide|= field;
+	}
+	if (newDefs->merge==MergeAugment)
+	    return True;
+    }
+    return False;
+}
+
+XPointer
+#if NeedFunctionPrototypes
+ClearCommonInfo(CommonInfo *cmn)
+#else
+ClearCommonInfo(cmn)
+    CommonInfo *	 cmn;
+#endif
+{
+    if (cmn!=NULL) {
+	CommonInfo *this,*next;
+	for (this=cmn;this!=NULL;this=next) {
+	    next= this->next;
+	    uFree(this);
+	}
+    }
+    return NULL;
+}
+
+XPointer
+#if NeedFunctionPrototypes
+AddCommonInfo(CommonInfo *old,CommonInfo *new)
+#else
+AddCommonInfo(old,new)
+    CommonInfo *	old;
+    CommonInfo *	new;
+#endif
+{
+CommonInfo *	first;
+
+    first= old;
+    while ( old && old->next ) {
+	old= old->next;
+    }
+    new->next= NULL;
+    if (old) {
+	old->next= new;
+	return (XPointer)first;
+    }
+    return (XPointer)new;
+}
+
+/***====================================================================***/
+
+typedef struct _KeyNameDesc {
+	KeySym	level1;
+	KeySym	level2;
+	char	name[5];
+	Bool	used;
+} KeyNameDesc;
+
+KeyNameDesc dfltKeys[] = {
+	{	XK_Escape,	NoSymbol,	"ESC\0"		},
+	{	XK_quoteleft,	XK_asciitilde,	"TLDE"		},
+	{	XK_1,		XK_exclam,	"AE01"		},
+	{	XK_2,		XK_at,		"AE02"		},
+	{	XK_3,		XK_numbersign,	"AE03"		},
+	{	XK_4,		XK_dollar,	"AE04"		},
+	{	XK_5,		XK_percent,	"AE05"		},
+	{	XK_6,		XK_asciicircum,	"AE06"		},
+	{	XK_7,		XK_ampersand,	"AE07"		},
+	{	XK_8,		XK_asterisk,	"AE08"		},
+	{	XK_9,		XK_parenleft,	"AE09"		},
+	{	XK_0,		XK_parenright,	"AE10"		},
+	{	XK_minus,	XK_underscore,	"AE11"		},
+	{	XK_equal,	XK_plus,	"AE12"		},
+	{	XK_BackSpace,	NoSymbol,	"BKSP"		},
+	{	XK_Tab,		NoSymbol,	"TAB\0"		},
+	{	XK_q,		XK_Q,		"AD01"		},
+	{	XK_w,		XK_W,		"AD02"		},
+	{	XK_e,		XK_E,		"AD03"		},
+	{	XK_r,		XK_R,		"AD04"		},
+	{	XK_t,		XK_T,		"AD05"		},
+	{	XK_y,		XK_Y,		"AD06"		},
+	{	XK_u,		XK_U,		"AD07"		},
+	{	XK_i,		XK_I,		"AD08"		},
+	{	XK_o,		XK_O,		"AD09"		},
+	{	XK_p,		XK_P,		"AD10"		},
+	{	XK_bracketleft,	XK_braceleft,	"AD11"		},
+	{	XK_bracketright,XK_braceright,	"AD12"		},
+	{	XK_Return,	NoSymbol,	"RTRN"		},
+	{	XK_Caps_Lock,	NoSymbol,	"CAPS"		},
+	{	XK_a,		XK_A,		"AC01"		},
+	{	XK_s,		XK_S,		"AC02"		},
+	{	XK_d,		XK_D,		"AC03"		},
+	{	XK_f,		XK_F,		"AC04"		},
+	{	XK_g,		XK_G,		"AC05"		},
+	{	XK_h,		XK_H,		"AC06"		},
+	{	XK_j,		XK_J,		"AC07"		},
+	{	XK_k,		XK_K,		"AC08"		},
+	{	XK_l,		XK_L,		"AC09"		},
+	{	XK_semicolon,	XK_colon,	"AC10"		},
+	{	XK_quoteright,	XK_quotedbl,	"AC11"		},
+	{	XK_Shift_L,	NoSymbol,	"LFSH"		},
+	{	XK_z,		XK_Z,		"AB01"		},
+	{	XK_x,		XK_X,		"AB02"		},
+	{	XK_c,		XK_C,		"AB03"		},
+	{	XK_v,		XK_V,		"AB04"		},
+	{	XK_b,		XK_B,		"AB05"		},
+	{	XK_n,		XK_N,		"AB06"		},
+	{	XK_m,		XK_M,		"AB07"		},
+	{	XK_comma,	XK_less,	"AB08"		},
+	{	XK_period,	XK_greater,	"AB09"		},
+	{	XK_slash,	XK_question,	"AB10"		},
+	{	XK_backslash,	XK_bar,		"BKSL"		},
+	{	XK_Control_L,	NoSymbol,	"LCTL"		},
+	{	XK_space,	NoSymbol,	"SPCE"		},
+	{	XK_Shift_R,	NoSymbol,	"RTSH"		},
+	{	XK_Alt_L,	NoSymbol,	"LALT"		},
+	{	XK_space,	NoSymbol,	"SPCE"		},
+	{	XK_Control_R,	NoSymbol,	"RCTL"		},
+	{	XK_Alt_R,	NoSymbol,	"RALT"		},
+	{	XK_F1,		NoSymbol,	"FK01"		},
+	{	XK_F2,		NoSymbol,	"FK02"		},
+	{	XK_F3,		NoSymbol,	"FK03"		},
+	{	XK_F4,		NoSymbol,	"FK04"		},
+	{	XK_F5,		NoSymbol,	"FK05"		},
+	{	XK_F6,		NoSymbol,	"FK06"		},
+	{	XK_F7,		NoSymbol,	"FK07"		},
+	{	XK_F8,		NoSymbol,	"FK08"		},
+	{	XK_F9,		NoSymbol,	"FK09"		},
+	{	XK_F10,		NoSymbol,	"FK10"		},
+	{	XK_F11,		NoSymbol,	"FK11"		},
+	{	XK_F12,		NoSymbol,	"FK12"		},
+	{	XK_Print,	NoSymbol,	"PRSC"		},
+	{	XK_Scroll_Lock,	NoSymbol,	"SCLK"		},
+	{	XK_Pause,	NoSymbol,	"PAUS"		},
+	{	XK_Insert,	NoSymbol,	"INS\0"		},
+	{	XK_Home,	NoSymbol,	"HOME"		},
+	{	XK_Prior,	NoSymbol,	"PGUP"		},
+	{	XK_Delete,	NoSymbol,	"DELE"		},
+	{	XK_End,		NoSymbol,	"END"		},
+	{	XK_Next,	NoSymbol,	"PGDN"		},
+	{	XK_Up,		NoSymbol,	"UP\0\0"	},
+	{	XK_Left,	NoSymbol,	"LEFT"		},
+	{	XK_Down,	NoSymbol,	"DOWN"		},
+	{	XK_Right,	NoSymbol,	"RGHT"		},
+	{	XK_Num_Lock,	NoSymbol,	"NMLK"		},
+	{	XK_KP_Divide,	NoSymbol,	"KPDV"		},
+	{	XK_KP_Multiply,	NoSymbol,	"KPMU"		},
+	{	XK_KP_Subtract,	NoSymbol,	"KPSU"		},
+	{	NoSymbol,	XK_KP_7,	"KP7\0"		},
+	{	NoSymbol,	XK_KP_8,	"KP8\0"		},
+	{	NoSymbol,	XK_KP_9,	"KP9\0"		},
+	{	XK_KP_Add,	NoSymbol,	"KPAD"		},
+	{	NoSymbol,	XK_KP_4,	"KP4\0"		},
+	{	NoSymbol,	XK_KP_5,	"KP5\0"		},
+	{	NoSymbol,	XK_KP_6,	"KP6\0"		},
+	{	NoSymbol,	XK_KP_1,	"KP1\0"		},
+	{	NoSymbol,	XK_KP_2,	"KP2\0"		},
+	{	NoSymbol,	XK_KP_3,	"KP3\0"		},
+	{	XK_KP_Enter,	NoSymbol,	"KPEN"		},
+	{	NoSymbol,	XK_KP_0,	"KP0\0"		},
+	{	XK_KP_Delete,	NoSymbol,	"KPDL"		},
+	{	XK_less,	XK_greater,	"LSGT"		},
+	{	XK_KP_Separator,NoSymbol,	"KPCO"		},
+	{	XK_Find,	NoSymbol,	"FIND"		},
+	{	NoSymbol,	NoSymbol,	"\0\0\0\0"	}
+};
+
+Status
+#if NeedFunctionPrototypes
+ComputeKbdDefaults(XkbDescPtr xkb)
+#else
+ComputeKbdDefaults(xkb)
+    XkbDescPtr		xkb;
+#endif
+{
+Status		rtrn;
+register int	i,tmp,nUnknown;
+KeyNameDesc *	name;
+KeySym *	syms;
+
+    if ((xkb->names==NULL)||(xkb->names->keys==NULL)) {
+	if ((rtrn=XkbAllocNames(xkb,XkbKeyNamesMask,0,0))!=Success)
+	    return rtrn;
+    }
+    for (name=dfltKeys;(name->name[0]!='\0');name++) {
+	name->used= False;
+    }
+    nUnknown= 0;
+    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+	tmp= XkbKeyNumSyms(xkb,i);
+	if ((xkb->names->keys[i].name[0]=='\0')&&(tmp>0)) {
+	    tmp= XkbKeyGroupsWidth(xkb,i);
+	    syms= XkbKeySymsPtr(xkb,i);
+	    for (name=dfltKeys;(name->name[0]!='\0');name++) {
+		Bool match= True;
+		if (((name->level1!=syms[0])&&(name->level1!=NoSymbol))||
+		   ((name->level2!=NoSymbol)&&(tmp<2))||
+		   ((name->level2!=syms[1])&&(name->level2!=NoSymbol))) {
+		    match= False;
+		}
+		if (match) {
+		    if (!name->used) {
+			memcpy(xkb->names->keys[i].name,name->name,
+							XkbKeyNameLength);
+			name->used= True;
+		    }
+		    else {
+			if (warningLevel>2) {
+			    WARN1("Several keys match pattern for %s\n",
+				XkbKeyNameText(name->name,XkbMessage));
+			    ACTION2("Using <U%03d> for key %d\n",nUnknown,i);
+			}
+			sprintf(xkb->names->keys[i].name,"U%03d",nUnknown++);
+		    }
+		    break;
+		}
+	    }
+	    if (xkb->names->keys[i].name[0]=='\0') {
+		if (warningLevel>2) {
+		    WARN1("Key %d does not match any defaults\n",i);
+		    ACTION1("Using name <U%03d>\n",nUnknown);
+		    sprintf(xkb->names->keys[i].name,"U%03d",nUnknown++);
+		}
+	    }
+	}
+    }
+    return Success;
+}
+
+Bool
+#if NeedFunctionPrototypes
+FindNamedKey(	XkbDescPtr	xkb,
+		unsigned long	name,
+		unsigned int *	kc_rtrn,
+		Bool		use_aliases,
+		Bool		create,
+		int		start_from)
+#else
+FindNamedKey(xkb,name,kc_rtrn,use_aliases,create,start_from)
+    XkbDescPtr		xkb;
+    unsigned long	name;
+    unsigned int *	kc_rtrn;
+    Bool		use_aliases;
+    Bool		create;
+    int			start_from;
+#endif
+{
+register unsigned n;
+
+    if (start_from<xkb->min_key_code) {
+	start_from= xkb->min_key_code;
+    }
+    else if (start_from>xkb->max_key_code) {
+	return False;
+    }
+
+    *kc_rtrn= 0;	/* some callers rely on this */
+    if (xkb&&xkb->names&&xkb->names->keys) {
+	for (n=start_from;n<=xkb->max_key_code;n++) {
+	    unsigned long tmp;
+	    tmp= KeyNameToLong(xkb->names->keys[n].name);
+	    if (tmp==name) {
+		*kc_rtrn= n;
+		return True;
+	    }
+	}
+	if (use_aliases) {
+	    unsigned long new_name;
+	    if (FindKeyNameForAlias(xkb,name,&new_name))
+		return FindNamedKey(xkb,new_name,kc_rtrn,False,create,0);
+	}
+    }
+    if (create) {
+	if ((!xkb->names)||(!xkb->names->keys)) {
+	    if (xkb->min_key_code<XkbMinLegalKeyCode) {
+		xkb->min_key_code= XkbMinLegalKeyCode;
+		xkb->max_key_code= XkbMaxLegalKeyCode;
+	    }
+	    if (XkbAllocNames(xkb,XkbKeyNamesMask,0,0)!=Success) {
+		if (warningLevel>0) {
+		    WARN("Couldn't allocate key names in FindNamedKey\n");
+		    ACTION1("Key \"%s\" not automatically created\n",
+						longText(name,XkbMessage));
+		}
+		return False;
+	    }
+	}
+	for (n=xkb->min_key_code;n<=xkb->max_key_code;n++) {
+	    if (xkb->names->keys[n].name[0]=='\0') {
+		char buf[XkbKeyNameLength+1];
+		LongToKeyName(name,buf);
+		memcpy(xkb->names->keys[n].name,buf,XkbKeyNameLength);
+		*kc_rtrn= n;
+		return True;
+	    }
+	}
+    }
+    return False;
+}
+
+Bool
+#if NeedFunctionPrototypes
+FindKeyNameForAlias(XkbDescPtr xkb,unsigned long lname,unsigned long *real_name)
+#else
+FindKeyNameForAlias(xkb,lname,real_name)
+    XkbDescPtr		xkb;
+    unsigned long	lname;
+    unsigned long *	real_name;
+#endif
+{
+register int	i;
+char		name[XkbKeyNameLength+1];
+
+    if (xkb&&xkb->geom&&xkb->geom->key_aliases) {
+	XkbKeyAliasPtr	a;
+	a= xkb->geom->key_aliases;
+	LongToKeyName(lname,name);
+	name[XkbKeyNameLength]= '\0';
+	for (i=0;i<xkb->geom->num_key_aliases;i++,a++) {
+	    if (strncmp(name,a->alias,XkbKeyNameLength)==0) {
+		*real_name= KeyNameToLong(a->real);
+		return True;
+	    }
+	}
+    }
+    if (xkb&&xkb->names&&xkb->names->key_aliases) {
+	XkbKeyAliasPtr	a;
+	a= xkb->names->key_aliases;
+	LongToKeyName(lname,name);
+	name[XkbKeyNameLength]= '\0';
+	for (i=0;i<xkb->names->num_key_aliases;i++,a++) {
+	    if (strncmp(name,a->alias,XkbKeyNameLength)==0) {
+		*real_name= KeyNameToLong(a->real);
+		return True;
+	    }
+	}
+    }
+    return False;
+}
diff --git a/misc.h b/misc.h
new file mode 100644
index 0000000..24dfc7d
--- /dev/null
+++ b/misc.h
@@ -0,0 +1,157 @@
+/* $Xorg: misc.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 MISC_H
+#define MISC_H 1
+
+typedef	struct	_CommonInfo {
+    unsigned short		defined;
+    unsigned char		fileID;
+    unsigned char		merge;
+    struct _CommonInfo *	next;
+} CommonInfo;
+
+_XFUNCPROTOBEGIN
+
+extern Bool	UseNewField(
+#if NeedFunctionPrototypes
+    unsigned		/* field */,
+    CommonInfo * 	/* oldDefs */,
+    CommonInfo *	/* newDefs */,
+    unsigned *		/* pCollide */
+#endif
+);
+
+extern Bool	MergeNewField(
+#if NeedFunctionPrototypes
+    unsigned		/* field */,
+    CommonInfo * 	/* oldDefs */,
+    CommonInfo *	/* newDefs */,
+    unsigned *		/* pCollide */
+#endif
+);
+
+extern XPointer ClearCommonInfo(
+#if NeedFunctionPrototypes
+    CommonInfo *	/* cmn */
+#endif
+);
+
+extern XPointer AddCommonInfo(
+#if NeedFunctionPrototypes
+    CommonInfo *	/* old */,
+    CommonInfo *	/* new */
+#endif
+);
+
+extern int	ReportNotArray(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* name */
+#endif
+);
+
+extern int	ReportShouldBeArray(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* name */
+#endif
+);
+
+extern int	ReportBadType(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* name */,
+    char *	/* wanted */
+#endif
+);
+
+extern int	ReportBadIndexType(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* name */,
+    char *	/* wanted */
+#endif
+);
+
+extern int	ReportBadField(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* name */
+#endif
+);
+
+extern int	ReportMultipleDefs(
+#if NeedFunctionPrototypes
+    char *	/* type */,
+    char *	/* field */,
+    char *	/* which */
+#endif
+);
+
+extern Bool	ProcessIncludeFile(
+#if NeedFunctionPrototypes
+    IncludeStmt	*	/* stmt */,
+    unsigned		/* file_type */,
+    XkbFile **		/* file_rtrn */,
+    unsigned *		/* merge_rtrn */
+#endif
+);
+
+extern Status	ComputeKbdDefaults(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */
+#endif
+);
+
+extern Bool FindNamedKey(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */,
+    unsigned long	/* name */,
+    unsigned int *	/* kc_rtrn */,
+    Bool		/* use_aliases */,
+    Bool		/* create */,
+    int			/* start_from */
+#endif
+);
+
+extern Bool FindKeyNameForAlias(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */,
+    unsigned long	/* lname */,
+    unsigned long *	/* real_name */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* MISC_H */
diff --git a/parseutils.c b/parseutils.c
new file mode 100644
index 0000000..468d620
--- /dev/null
+++ b/parseutils.c
@@ -0,0 +1,966 @@
+/* $Xorg: parseutils.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
+
+ Permission to use, copy, modify, and distribute this
+ software and its documentation for any purpose and without
+ fee is hereby granted, provided that the above copyright
+ notice appear in all copies and that both that copyright
+ notice and this permission notice appear in supporting
+ documentation, and that the name of Silicon Graphics not be 
+ used in advertising or publicity pertaining to distribution 
+ of the software without specific prior written permission.
+ Silicon Graphics makes no representation about the suitability 
+ of this software for any purpose. It is provided "as is"
+ without any express or implied warranty.
+ 
+ SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+ OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ********************************************************/
+#define DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR parseDebug
+#include "parseutils.h"
+#include "xkbpath.h"
+#include <X11/keysym.h>
+#include <X11/extensions/XKBgeom.h>
+#include <X11/Xalloca.h>
+
+XkbFile	*rtrnValue;
+
+ParseCommon *
+#if NeedFunctionPrototypes
+AppendStmt(ParseCommon *to,ParseCommon *append)
+#else
+AppendStmt(to,append)
+    ParseCommon *	to;
+    ParseCommon *	append;
+#endif
+{
+ParseCommon	*start= to;
+
+    if (append==NULL)
+	return to;
+    while ((to!=NULL) && (to->next!=NULL)) {
+	to= to->next;
+    }
+    if (to) {
+	to->next= append;
+	return start;
+    }
+    return append;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+ExprCreate(unsigned op,unsigned type)
+#else
+ExprCreate(op,type)
+    unsigned	op;
+    unsigned	type;
+#endif
+{
+ExprDef *expr;
+    expr= uTypedAlloc(ExprDef);
+    if (expr) {
+	expr->common.stmtType= StmtExpr;
+	expr->common.next= NULL;
+	expr->op= op;
+	expr->type= type;
+    }
+    else {
+	FATAL("Couldn't allocate expression in parser\n");
+	/* NOTREACHED */
+    }
+    return expr;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+ExprCreateUnary(unsigned op,unsigned type,ExprDef *child)
+#else
+ExprCreateUnary(op,type,child)
+    unsigned	 op;
+    unsigned	 type;
+    ExprDef	*child;
+#endif
+{
+ExprDef *expr;
+    expr= uTypedAlloc(ExprDef);
+    if (expr) {
+	expr->common.stmtType= StmtExpr;
+	expr->common.next= NULL;
+	expr->op= op;
+	expr->type= type;
+	expr->value.child= child;
+    }
+    else {
+	FATAL("Couldn't allocate expression in parser\n");
+	/* NOTREACHED */
+    }
+    return expr;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+ExprCreateBinary(unsigned op,ExprDef *left,ExprDef *right)
+#else
+ExprCreateBinary(op,left,right)
+    unsigned	 op;
+    ExprDef	*left;
+    ExprDef	*right;
+#endif
+{
+ExprDef *expr;
+    expr= uTypedAlloc(ExprDef);
+    if (expr) {
+	expr->common.stmtType= StmtExpr;
+	expr->common.next= NULL;
+	expr->op= op;
+	if ((op==OpAssign)||(left->type==TypeUnknown))
+	     expr->type= right->type;
+	else if ((left->type==right->type)||(right->type==TypeUnknown))
+	     expr->type= left->type;
+	else expr->type= TypeUnknown;
+	expr->value.binary.left= left;
+	expr->value.binary.right= right;
+    }
+    else {
+	FATAL("Couldn't allocate expression in parser\n");
+	/* NOTREACHED */
+    }
+    return expr;
+}
+
+KeycodeDef *
+#if NeedFunctionPrototypes
+KeycodeCreate(char *name,ExprDef *value)
+#else
+KeycodeCreate(name,value)
+    char *	name;
+    ExprDef *	value;
+#endif
+{
+KeycodeDef *def;
+
+    def= uTypedAlloc(KeycodeDef);
+    if (def) {
+	def->common.stmtType= StmtKeycodeDef;
+	def->common.next= NULL;
+	strncpy(def->name,name,XkbKeyNameLength);
+	def->name[XkbKeyNameLength]= '\0';
+	def->value= value;
+    }
+    else {
+	FATAL("Couldn't allocate key name definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+KeyAliasDef *
+#if NeedFunctionPrototypes
+KeyAliasCreate(char *alias,char *real)
+#else
+KeyAliasCreate(alias,real)
+    char *	alias;
+    char *	real;
+#endif
+{
+KeyAliasDef *def;
+
+    def= uTypedAlloc(KeyAliasDef);
+    if (def) {
+	def->common.stmtType= StmtKeyAliasDef;
+	def->common.next= NULL;
+	strncpy(def->alias,alias,XkbKeyNameLength);
+	def->alias[XkbKeyNameLength]= '\0';
+	strncpy(def->real,real,XkbKeyNameLength);
+	def->real[XkbKeyNameLength]= '\0';
+    }
+    else {
+	FATAL("Couldn't allocate key alias definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+VModDef *
+#if NeedFunctionPrototypes
+VModCreate(Atom name,ExprDef *value)
+#else
+VModCreate(name,value)
+    Atom	name;
+    ExprDef *	value;
+#endif
+{
+VModDef *def;
+    def= uTypedAlloc(VModDef);
+    if (def) {
+	def->common.stmtType= StmtVModDef;
+	def->common.next= NULL;
+	def->name= name;
+	def->value= value;
+    }
+    else {
+	FATAL("Couldn't allocate variable definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+VarDef *
+#if NeedFunctionPrototypes
+VarCreate(ExprDef *name,ExprDef *value)
+#else
+VarCreate(name,value)
+    ExprDef *	name;
+    ExprDef *	value;
+#endif
+{
+VarDef *def;
+    def= uTypedAlloc(VarDef);
+    if (def) {
+	def->common.stmtType= StmtVarDef;
+	def->common.next= NULL;
+	def->name= name;
+	def->value= value;
+    }
+    else {
+	FATAL("Couldn't allocate variable definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+VarDef *
+#if NeedFunctionPrototypes
+BoolVarCreate(Atom nameToken,unsigned set)
+#else
+BoolVarCreate(nameToken,set)
+    Atom	nameToken;
+    unsigned	set;
+#endif
+{
+ExprDef	*name,*value;
+
+    name= ExprCreate(ExprIdent,TypeUnknown);
+    name->value.str= nameToken;
+    value= ExprCreate(ExprValue,TypeBoolean);
+    value->value.uval= set;
+    return VarCreate(name,value);
+}
+
+InterpDef *
+#if NeedFunctionPrototypes
+InterpCreate(KeySym sym,ExprDef *match)
+#else
+InterpCreate(sym,match)
+    KeySym	sym;
+    ExprDef *	match;
+#endif
+{
+InterpDef *def;
+
+    def= uTypedAlloc(InterpDef);
+    if (def) {
+	def->common.stmtType= StmtInterpDef;
+	def->common.next= NULL;
+	def->sym= sym;
+	def->match= match;
+    }
+    else {
+	FATAL("Couldn't allocate interp definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+KeyTypeDef *
+#if NeedFunctionPrototypes
+KeyTypeCreate(Atom name,VarDef *body)
+#else
+KeyTypeCreate(name,body)
+    Atom	name;
+    VarDef *	body;
+#endif
+{
+KeyTypeDef *def;
+
+    def= uTypedAlloc(KeyTypeDef);
+    if (def) {
+	def->common.stmtType= StmtKeyTypeDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	def->name= name;
+	def->body= body;
+    }
+    else {
+	FATAL("Couldn't allocate key type definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+SymbolsDef *
+#if NeedFunctionPrototypes
+SymbolsCreate(char *keyName,ExprDef *symbols)
+#else
+SymbolsCreate(keyName,symbols)
+    char *	keyName;
+    ExprDef *	symbols;
+#endif
+{
+SymbolsDef *def;
+
+    def= uTypedAlloc(SymbolsDef);
+    if (def) {
+	def->common.stmtType= StmtSymbolsDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	bzero(def->keyName,5);
+	strncpy(def->keyName,keyName,4);
+	def->symbols= symbols;
+    }
+    else {
+	FATAL("Couldn't allocate symbols definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+GroupCompatDef *
+#if NeedFunctionPrototypes
+GroupCompatCreate(int group,ExprDef *val)
+#else
+GroupCompatCreate(group,val)
+    int		group;
+    ExprDef *	val;
+#endif
+{
+GroupCompatDef *def;
+
+    def= uTypedAlloc(GroupCompatDef);
+    if (def) {
+	def->common.stmtType= StmtGroupCompatDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	def->group= group;
+	def->def= val;
+    }
+    else {
+	FATAL("Couldn't allocate group compat definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+ModMapDef *
+#if NeedFunctionPrototypes
+ModMapCreate(Atom modifier,ExprDef *keys)
+#else
+ModMapCreate(modifier,keys)
+    Atom	modifier;
+    ExprDef *	keys;
+#endif
+{
+ModMapDef *def;
+
+    def= uTypedAlloc(ModMapDef);
+    if (def) {
+	def->common.stmtType= StmtModMapDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	def->modifier= modifier;
+	def->keys= keys;
+    }
+    else {
+	FATAL("Couldn't allocate mod mask definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+IndicatorMapDef *
+#if NeedFunctionPrototypes
+IndicatorMapCreate(Atom name,VarDef *body)
+#else
+IndicatorMapCreate(name,body)
+    Atom	name;
+    VarDef *	body;
+#endif
+{
+IndicatorMapDef *def;
+
+    def= uTypedAlloc(IndicatorMapDef);
+    if (def) {
+	def->common.stmtType= StmtIndicatorMapDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	def->name= name;
+	def->body= body;
+    }
+    else {
+	FATAL("Couldn't allocate indicator map definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+IndicatorNameDef *
+#if NeedFunctionPrototypes
+IndicatorNameCreate(int	ndx,ExprDef *name,Bool virtual)
+#else
+IndicatorNameCreate(ndx,name,virtual)
+    int		ndx;
+    ExprDef *	name;
+    Bool	virtual;
+#endif
+{
+IndicatorNameDef *def;
+
+    def= uTypedAlloc(IndicatorNameDef);
+    if (def) {
+	def->common.stmtType= StmtIndicatorNameDef;
+	def->common.next= NULL;
+	def->merge= MergeDefault;
+	def->ndx= ndx;
+	def->name= name;
+	def->virtual= virtual;
+    }
+    else {
+	FATAL("Couldn't allocate indicator index definition in parser\n");
+	/* NOTREACHED */
+    }
+    return def;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+ActionCreate(Atom name,ExprDef *args)
+#else
+ActionCreate(name,args)
+    Atom	 name;
+    ExprDef	*args;
+#endif
+{
+ExprDef *act;
+
+    act= uTypedAlloc(ExprDef);
+    if (act) {
+	act->common.stmtType= StmtExpr;
+	act->common.next= NULL;
+	act->op= ExprActionDecl;
+	act->value.action.name= name;
+        act->value.action.args= args;
+	return act;
+    }
+    FATAL("Couldn't allocate ActionDef in parser\n");
+    return NULL;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+CreateKeysymList(KeySym sym)
+#else
+CreateKeysymList(sym)
+    KeySym	sym;
+#endif
+{
+ExprDef	 *def;
+
+    def= ExprCreate(ExprKeysymList,TypeSymbols);
+    if (def) {
+	def->value.list.nSyms= 1;
+	def->value.list.szSyms= 2;
+	def->value.list.syms= uTypedCalloc(2,KeySym);
+	if (def->value.list.syms!=NULL) {
+	    def->value.list.syms[0]= sym;
+	    return def;
+	}
+    }
+    FATAL("Couldn't allocate expression for keysym list in parser\n");
+    return NULL;
+}
+
+ShapeDef *
+#if NeedFunctionPrototypes
+ShapeDeclCreate(Atom name,OutlineDef *outlines)
+#else
+ShapeDeclCreate(name,outlines)
+    Atom		name;
+    OutlineDef *	outlines;
+#endif
+{
+ShapeDef *	shape;
+OutlineDef *	ol;
+
+    shape= uTypedAlloc(ShapeDef);
+    if (shape!=NULL) {
+	bzero(shape,sizeof(ShapeDef));
+	shape->common.stmtType=	StmtShapeDef;
+	shape->common.next=	NULL;
+	shape->merge=		MergeDefault;
+	shape->name=		name;
+	shape->nOutlines=	0;
+	shape->outlines=	outlines;
+	for (ol=outlines;ol!=NULL;ol= (OutlineDef *)ol->common.next) {
+	    if (ol->nPoints>0)
+		shape->nOutlines++;
+	}
+    }
+    return shape;
+}
+
+OutlineDef *
+#if NeedFunctionPrototypes
+OutlineCreate(Atom field,ExprDef *points)
+#else
+OutlineCreate(field,points)
+    Atom		field;
+    ExprDef *		points;
+#endif
+{
+OutlineDef *	outline;
+ExprDef *	pt;
+
+    outline= uTypedAlloc(OutlineDef);
+    if (outline!=NULL) {
+	bzero(outline,sizeof(OutlineDef));
+	outline->common.stmtType= 	StmtOutlineDef;
+	outline->common.next=		NULL;
+	outline->field=		field;
+	outline->nPoints=	0;
+	if (points->op==ExprCoord) {
+	    for (pt=points;pt!=NULL;pt= (ExprDef *)pt->common.next) {
+		outline->nPoints++;
+	    }
+	}
+	outline->points= points;
+    }
+    return outline;
+}
+
+KeyDef *
+#if NeedFunctionPrototypes
+KeyDeclCreate(char *name,ExprDef *expr)
+#else
+KeyDeclCreate(name,expr)
+    char *	name;
+    ExprDef *	expr;
+#endif
+{
+KeyDef *	key;
+
+    key= uTypedAlloc(KeyDef);
+    if (key!=NULL) {
+	bzero(key,sizeof(KeyDef));
+	key->common.stmtType= StmtKeyDef;
+	key->common.next= NULL;
+	if (name)	key->name= name;
+	else		key->expr= expr;
+    }
+    return key;
+}
+
+KeyDef *
+#if NeedFunctionPrototypes
+KeyDeclMerge(KeyDef *into,KeyDef *from)
+#else
+KeyDeclMerge(into,from)
+    KeyDef *	into;
+    KeyDef *	from;
+#endif
+{
+    into->expr= (ExprDef *)AppendStmt(&into->expr->common,&from->expr->common);
+    from->expr= NULL;
+    uFree(from);
+    return into;
+}
+
+RowDef *
+#if NeedFunctionPrototypes
+RowDeclCreate(KeyDef *	keys)
+#else
+RowDeclCreate(keys)
+    KeyDef *	keys;
+#endif
+{
+RowDef *	row;
+KeyDef *	key;
+
+    row= uTypedAlloc(RowDef);
+    if (row!=NULL) {
+	bzero(row,sizeof(RowDef));
+	row->common.stmtType= StmtRowDef;
+	row->common.next= NULL;
+	row->nKeys= 0;
+	row->keys= keys;
+	for (key=keys;key!=NULL;key=(KeyDef *)key->common.next) {
+	    if (key->common.stmtType==StmtKeyDef)
+		row->nKeys++;
+	}
+    }
+    return row;
+}
+
+SectionDef *
+#if NeedFunctionPrototypes
+SectionDeclCreate(Atom name,RowDef *rows)
+#else
+SectionDeclCreate(name,rows)
+    Atom	name;
+    RowDef *	rows;
+#endif
+{
+SectionDef *	section;
+RowDef *	row;
+
+    section= uTypedAlloc(SectionDef);
+    if (section!=NULL) {
+	bzero(section,sizeof(SectionDef));
+	section->common.stmtType= StmtSectionDef;
+	section->common.next= NULL;
+	section->name= name;
+	section->nRows= 0;
+	section->rows= rows;
+	for (row=rows;row!=NULL;row=(RowDef *)row->common.next) {
+	    if (row->common.stmtType==StmtRowDef)
+		section->nRows++;
+	}
+    }
+    return section;
+}
+
+OverlayKeyDef *
+#if NeedFunctionPrototypes
+OverlayKeyCreate(char *	under,char *over)
+#else
+OverlayKeyCreate(under,over)
+    char *	under;
+    char *	over;
+#endif
+{
+OverlayKeyDef *	key;
+
+    key= uTypedAlloc(OverlayKeyDef);
+    if (key!=NULL) {
+	bzero(key,sizeof(OverlayKeyDef));
+	key->common.stmtType= StmtOverlayKeyDef;
+	strncpy(key->over,over,XkbKeyNameLength);
+	strncpy(key->under,under,XkbKeyNameLength);
+	if (over)	uFree(over);
+	if (under)	uFree(under);
+    }
+    return key;
+}
+
+OverlayDef *
+#if NeedFunctionPrototypes
+OverlayDeclCreate(Atom name,OverlayKeyDef *keys)
+#else
+OverlayDeclCreate(name,keys)
+    Atom		name;
+    OverlayKeyDef *	keys;
+#endif
+{
+OverlayDef *	ol;
+OverlayKeyDef *	key;
+
+    ol= uTypedAlloc(OverlayDef);
+    if (ol!=NULL) {
+	bzero(ol,sizeof(OverlayDef));
+	ol->common.stmtType= 	StmtOverlayDef;
+	ol->name=		name;
+	ol->keys=		keys;
+	for (key=keys;key!=NULL;key=(OverlayKeyDef *)key->common.next) {
+	    ol->nKeys++;
+	}
+    }
+    return ol;
+}
+
+DoodadDef *
+#if NeedFunctionPrototypes
+DoodadCreate(unsigned type,Atom name,VarDef *body)
+#else
+DoodadCreate(type,name,body)
+    unsigned	type;
+    Atom	name;
+    VarDef *	body;
+#endif
+{
+DoodadDef *	doodad;
+
+    doodad= uTypedAlloc(DoodadDef);
+    if (doodad!=NULL) {
+	bzero(doodad,sizeof(DoodadDef));
+	doodad->common.stmtType= StmtDoodadDef;
+	doodad->common.next= NULL;
+	doodad->type= type;
+	doodad->name= name;
+	doodad->body= body;
+    }
+    return doodad;
+}
+
+ExprDef *
+#if NeedFunctionPrototypes
+AppendKeysymList(ExprDef *list,KeySym sym)
+#else
+AppendKeysymList(list,sym)
+    ExprDef *	list;
+    KeySym	sym;
+#endif
+{
+    if (list->value.list.nSyms>=list->value.list.szSyms) {
+	list->value.list.szSyms*=2;
+	list->value.list.syms= uTypedRecalloc(list->value.list.syms,
+						list->value.list.nSyms,
+						list->value.list.szSyms,
+						KeySym);
+	if (list->value.list.syms==NULL) {
+	    FATAL("Couldn't resize list of symbols for append\n");
+	    return NULL;
+	}
+    }
+    list->value.list.syms[list->value.list.nSyms++]= sym;
+    return list;
+}
+
+int
+#if NeedFunctionPrototypes
+LookupKeysym(char *str,KeySym *sym_rtrn)
+#else
+LookupKeysym(str,sym_rtrn)
+    char	*str;
+    KeySym	*sym_rtrn;
+#endif
+{
+KeySym sym;
+
+    if ((!str)||(uStrCaseCmp(str,"any")==0)||(uStrCaseCmp(str,"nosymbol")==0)) {
+	*sym_rtrn= NoSymbol;
+	return 1;
+    }
+    else if ((uStrCaseCmp(str,"none")==0)||(uStrCaseCmp(str,"voidsymbol")==0)) {
+	*sym_rtrn= XK_VoidSymbol;
+	return 1;
+    }
+    sym= XStringToKeysym(str);
+    if (sym!=NoSymbol) {
+	*sym_rtrn= sym;
+	return 1;
+    }
+    return 0;
+}
+
+IncludeStmt *
+#if NeedFunctionPrototypes
+IncludeCreate(char *str,unsigned merge)
+#else
+IncludeCreate(str,merge)
+    char *	str;
+    unsigned	merge;
+#endif
+{
+IncludeStmt *	incl,*first;
+char *		file,*map,*stmt,*tmp;
+char 		nextop;
+Bool		haveSelf;
+
+    haveSelf= False;
+    incl= first= NULL;
+    file= map= NULL;
+    tmp= str;
+    stmt= uStringDup(str);
+    while ((tmp)&&(*tmp)) {
+	if (XkbParseIncludeMap(&tmp,&file,&map,&nextop)) {
+	    if ((file==NULL)&&(map==NULL)) {
+		if (haveSelf)
+		    goto BAIL;
+		haveSelf= True;
+	    }
+	    if (first==NULL)
+		first= incl= uTypedAlloc(IncludeStmt);
+	    else {
+		incl->next= uTypedAlloc(IncludeStmt);
+		incl= incl->next;
+	    }
+	    if (incl) {
+		incl->common.stmtType= StmtInclude;
+		incl->common.next= NULL;
+		incl->merge= merge;
+		incl->stmt= NULL;
+		incl->file= file;
+		incl->map= map;
+		incl->path= NULL;
+		incl->next= NULL;
+	    }
+	    else {
+		WSGO("Allocation failure in IncludeCreate\n");
+		ACTION("Using only part of the include\n");
+		break;
+	    }
+	    if (nextop=='|')	merge= MergeAugment;
+	    else		merge= MergeOverride;
+	}
+	else {
+	    goto BAIL;
+	}
+    }
+    if (first)		first->stmt= stmt;
+    else if (stmt)	uFree(stmt);
+    return first;
+BAIL:
+    ERROR1("Illegal include statement \"%s\"\n",stmt);
+    ACTION("Ignored\n");
+    while (first) {
+	incl= first->next;
+	if (first->file) uFree(first->file);
+	if (first->map) uFree(first->map);
+	if (first->path) uFree(first->path);
+	first->file= first->map= first->path= NULL;
+	uFree(first);
+	first= incl;
+    }
+    if (stmt)
+	uFree(stmt);
+    return NULL;
+}
+
+#ifdef DEBUG
+void
+#if NeedFunctionPrototypes
+PrintStmtAddrs(ParseCommon *stmt)
+#else
+PrintStmtAddrs(stmt)
+    ParseCommon *	stmt;
+#endif
+{
+    fprintf(stderr,"0x%x",stmt);
+    if (stmt) {
+	do {
+	    fprintf(stderr,"->0x%x",stmt->next);
+	    stmt= stmt->next;
+	} while (stmt);
+    }
+    fprintf(stderr,"\n");
+}
+#endif
+
+static void
+#if NeedFunctionPrototypes
+CheckDefaultMap(XkbFile	*maps)
+#else
+CheckDefaultMap(maps)
+XkbFile	*maps;
+#endif
+{
+XkbFile * dflt,*tmp;
+
+    dflt= NULL;
+    for (tmp=maps,dflt=NULL;tmp!=NULL;tmp=(XkbFile *)tmp->common.next) {
+	if (tmp->flags&XkbLC_Default) {
+	    if (dflt==NULL) 
+		dflt= tmp;
+	    else {
+		if (warningLevel>2) {
+		    WARN1("Multiple default components in %s\n",
+					(scanFile?scanFile:"(unknown)"));
+		    ACTION2("Using %s, ignoring %s\n",
+					(dflt->name?dflt->name:"(first)"),
+					(tmp->name?tmp->name:"(subsequent)"));
+		}
+		tmp->flags&= (~XkbLC_Default);
+	    }
+	}
+    }
+    return;
+}
+
+_XFUNCPROTOBEGIN
+extern int yyparse(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+_XFUNCPROTOEND
+
+extern FILE *	yyin;
+
+int
+#if NeedFunctionPrototypes
+XKBParseFile(FILE *file,XkbFile	**pRtrn)
+#else
+XKBParseFile(file,pRtrn)
+FILE 		 *file;
+XkbFile		**pRtrn;
+#endif
+{
+    if (file) {
+	yyin= file;
+	rtrnValue= NULL;
+	if (yyparse()==0) {
+	    *pRtrn= rtrnValue;
+	    CheckDefaultMap(rtrnValue);
+	    rtrnValue= NULL;
+	    return 1;
+	}
+	*pRtrn= NULL;
+	return 0;
+    }
+    *pRtrn= NULL;
+    return 1;
+}
+
+XkbFile *
+#if NeedFunctionPrototypes
+CreateXKBFile(int type,char *name,ParseCommon *defs,unsigned flags)
+#else
+CreateXKBFile(type,name,defs,flags)
+int		type;
+char *		name;
+ParseCommon *	defs;
+unsigned	flags;
+#endif
+{
+XkbFile *	file;
+static int	fileID;
+
+    file= uTypedAlloc(XkbFile);
+    if (file) {
+	XkbEnsureSafeMapName(name);
+	bzero(file,sizeof(XkbFile));
+	file->type= type;
+	file->topName= uStringDup(name);
+	file->name= name;
+	file->defs= defs;
+	file->id= fileID++;
+	file->compiled= False;
+	file->flags= flags;
+    }
+    return file;
+}
+
+unsigned 
+#if NeedFunctionPrototypes
+StmtSetMerge(ParseCommon *stmt,unsigned	merge)
+#else
+StmtSetMerge(stmt,merge)
+    ParseCommon *	stmt;
+    unsigned		merge;
+#endif
+{
+    if ((merge==MergeAltForm) && (stmt->stmtType!=StmtKeycodeDef)) {
+	yyerror("illegal use of 'alternate' merge mode");
+	merge= MergeDefault;
+    }
+    return merge;
+}
diff --git a/parseutils.h b/parseutils.h
new file mode 100644
index 0000000..6393747
--- /dev/null
+++ b/parseutils.h
@@ -0,0 +1,319 @@
+/* $Xorg: parseutils.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 XKBPARSE_H
+#define	XKBPARSE_H 1
+
+#ifndef DEBUG_VAR
+#define	DEBUG_VAR	parseDebug
+#endif
+
+#include "xkbcomp.h"
+
+extern	char	*scanStr;
+extern	int	 scanInt;
+extern	int	 lineNum;
+
+extern	XkbFile	*rtrnValue;
+
+#ifdef DEBUG
+#define	d(str)		fprintf(stderr,"%s\n",str);
+#define d1(str,a)	fprintf(stderr,str,a);
+#define d2(str,a,b)	fprintf(stderr,str,a,b);
+#else
+#define	d(str)
+#define	d1(str,a)
+#define d2(str,a,b)
+#endif
+
+_XFUNCPROTOBEGIN
+
+extern ParseCommon *AppendStmt(
+#if NeedFunctionPrototypes
+    ParseCommon *	/* to */,
+    ParseCommon *	/* append */
+#endif
+);
+
+extern ExprDef *ExprCreate(
+#if NeedFunctionPrototypes
+    unsigned		/* op */,
+    unsigned		/* type */
+#endif
+);
+
+extern ExprDef *ExprCreateUnary(
+#if NeedFunctionPrototypes
+    unsigned	 	/* op */,
+    unsigned	 	/* type */,
+    ExprDef	*	/* child */
+#endif
+);
+
+extern ExprDef *ExprCreateBinary(
+#if NeedFunctionPrototypes
+    unsigned	 	/* op */,
+    ExprDef	*	/* left */,
+    ExprDef	*	/* right */
+#endif
+);
+
+extern KeycodeDef *KeycodeCreate(
+#if NeedFunctionPrototypes
+    char *		/* name */,
+    ExprDef *		/* value */
+#endif
+);
+
+extern KeyAliasDef *KeyAliasCreate(
+#if NeedFunctionPrototypes
+    char *		/* alias */,
+    char *		/* real */
+#endif
+);
+
+extern VModDef *VModCreate(
+#if NeedFunctionPrototypes
+    Atom		/* name */,
+    ExprDef *		/* value */
+#endif
+);
+
+extern VarDef *VarCreate(
+#if NeedFunctionPrototypes
+    ExprDef *		/* name */,
+    ExprDef *		/* value */
+#endif
+);
+
+extern VarDef *BoolVarCreate(
+#if NeedFunctionPrototypes
+    Atom		/* nameToken */,
+    unsigned		/* set */
+#endif
+);
+
+extern InterpDef *InterpCreate(
+#if NeedFunctionPrototypes
+    KeySym		/* sym */,
+    ExprDef *		/* match */
+#endif
+);
+
+extern KeyTypeDef *KeyTypeCreate(
+#if NeedFunctionPrototypes
+    Atom		/* name */,
+    VarDef *		/* body */
+#endif
+);
+
+extern SymbolsDef *SymbolsCreate(
+#if NeedFunctionPrototypes
+    char *		/* keyName */,
+    ExprDef *		/* symbols */
+#endif
+);
+
+extern GroupCompatDef *GroupCompatCreate(
+#if NeedFunctionPrototypes
+    int			/* group */,
+    ExprDef *		/* def */
+#endif
+);
+
+extern ModMapDef *ModMapCreate(
+#if NeedFunctionPrototypes
+    Atom		/* modifier */,
+    ExprDef *		/* keys */
+#endif
+);
+
+extern IndicatorMapDef *IndicatorMapCreate(
+#if NeedFunctionPrototypes
+    Atom		/* name */,
+    VarDef *		/* body */
+#endif
+);
+
+extern IndicatorNameDef *IndicatorNameCreate(
+#if NeedFunctionPrototypes
+    int			/* ndx */,
+    ExprDef *		/* name */,
+    Bool		/* virtual */
+#endif
+);
+
+extern ExprDef *ActionCreate(
+#if NeedFunctionPrototypes
+    Atom	 	/* name */,
+    ExprDef	*	/* args */
+#endif
+);
+
+extern ExprDef *CreateKeysymList(
+#if NeedFunctionPrototypes
+    KeySym		/* sym */
+#endif
+);
+
+extern ShapeDef *ShapeDeclCreate(
+#if NeedFunctionPrototypes
+    Atom		/* name */,
+    OutlineDef *	/* outlines */
+#endif
+);
+
+extern OutlineDef *OutlineCreate(
+#if NeedFunctionPrototypes
+    Atom		/* field */,
+    ExprDef *		/* points */
+#endif
+);
+
+extern KeyDef *KeyDeclCreate(
+#if NeedFunctionPrototypes
+    char *	/* name */,
+    ExprDef *	/* expr */
+#endif
+);
+
+extern KeyDef *KeyDeclMerge(
+#if NeedFunctionPrototypes
+    KeyDef *	/* into */,
+    KeyDef *	/* from */
+#endif
+);
+
+extern RowDef *RowDeclCreate(
+#if NeedFunctionPrototypes
+    KeyDef *	/* keys */
+#endif
+);
+
+extern SectionDef *SectionDeclCreate(
+#if NeedFunctionPrototypes
+    Atom	/* name */,
+    RowDef *	/* rows */
+#endif
+);
+
+extern OverlayKeyDef *OverlayKeyCreate(
+#if NeedFunctionPrototypes
+    char *		/* under */,
+    char *		/* over  */
+#endif
+);
+
+extern OverlayDef *OverlayDeclCreate(
+#if NeedFunctionPrototypes
+    Atom		/* name */,
+    OverlayKeyDef *	/* rows */
+#endif
+);
+
+extern DoodadDef *DoodadCreate(
+#if NeedFunctionPrototypes
+    unsigned	/* type */,
+    Atom	/* name */,
+    VarDef *	/* body */
+#endif
+);
+
+extern ExprDef *AppendKeysymList(
+#if NeedFunctionPrototypes
+    ExprDef *	/* list */,
+    KeySym	/* sym */
+#endif
+);
+
+extern int LookupKeysym(
+#if NeedFunctionPrototypes
+    char *	/* str */,
+    KeySym *	/* sym_rtrn */
+#endif
+);
+
+extern	IncludeStmt *IncludeCreate(
+#if NeedFunctionPrototypes
+    char *	/* str */,
+    unsigned	/* merge */
+#endif
+);
+
+extern unsigned StmtSetMerge(
+#if NeedFunctionPrototypes
+    ParseCommon *	/* stmt */,
+    unsigned		/* merge */
+#endif
+);
+
+#ifdef DEBUG
+extern void PrintStmtAddrs(
+#if NeedFunctionPrototypes
+    ParseCommon *	/* stmt */
+#endif
+);
+#endif
+
+extern int XKBParseFile(
+#if NeedFunctionPrototypes
+FILE  *			/* file */,
+    XkbFile **		/* pRtrn */
+#endif
+);
+
+extern XkbFile *CreateXKBFile(
+#if NeedFunctionPrototypes
+    int			/* type */,
+    char *		/* name */,
+    ParseCommon *	/* defs */,
+    unsigned		/* flags */
+#endif
+);
+
+extern void yyerror(
+#if NeedFunctionPrototypes
+    char *		/* s */
+#endif
+);
+
+extern int yywrap(
+#if NeedFunctionPrototypes
+    void
+#endif
+);
+
+extern int setScanState(
+#if NeedFunctionPrototypes
+    char *	/* file */,
+    int 	/* line */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* XKBPARSE_H */
diff --git a/symbols.c b/symbols.c
new file mode 100644
index 0000000..79f76de
--- /dev/null
+++ b/symbols.c
@@ -0,0 +1,1920 @@
+/* $Xorg: symbols.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+
+#include <X11/keysym.h>
+#include <X11/Xutil.h>
+
+#include "expr.h"
+#include "vmod.h"
+#include "action.h"
+#include "keycodes.h"
+#include "misc.h"
+#include "alias.h"
+
+extern Atom	tok_ONE_LEVEL;
+extern Atom	tok_TWO_LEVEL;
+extern Atom	tok_KEYPAD;
+
+/***====================================================================***/
+
+#define	RepeatYes	1
+#define	RepeatNo	0
+#define	RepeatUndefined	~((unsigned)0)
+
+#define	_Key_Syms	(1<<0)
+#define	_Key_Acts	(1<<1)
+#define	_Key_Repeat	(1<<2)
+#define	_Key_Behavior	(1<<3)
+#define	_Key_Type_Dflt	(1<<4)
+#define	_Key_Types	(1<<5)
+#define	_Key_GroupInfo	(1<<6)
+#define	_Key_VModMap	(1<<7)
+
+typedef struct _KeyInfo {
+    CommonInfo 		defs;
+    unsigned long	name;
+    unsigned char	groupInfo;
+    unsigned char	typesDefined;
+    unsigned char	symsDefined;
+    unsigned char	actsDefined;
+    short		numLevels[XkbNumKbdGroups];
+    KeySym *		syms[XkbNumKbdGroups];
+    XkbAction *		acts[XkbNumKbdGroups];
+    Atom		types[XkbNumKbdGroups];
+    unsigned		repeat;
+    XkbBehavior		behavior;
+    unsigned short	vmodmap;
+    unsigned long	nameForOverlayKey;
+    unsigned long	allowNone;
+    Atom		dfltType;
+} KeyInfo;
+
+static void
+#if NeedFunctionPrototypes
+InitKeyInfo(KeyInfo *info)
+#else
+InitKeyInfo(info)
+    KeyInfo *	info;
+#endif
+{
+register int i;
+static char dflt[4]= "*";
+
+    info->defs.defined= 0;
+    info->defs.fileID= 0;
+    info->defs.merge= MergeOverride;
+    info->defs.next= NULL;
+    info->name= KeyNameToLong(dflt);
+    info->groupInfo= 0;
+    info->typesDefined= info->symsDefined= info->actsDefined= 0;
+    for (i=0;i<XkbNumKbdGroups;i++) {
+	info->numLevels[i]= 0;
+	info->types[i]= None;
+	info->syms[i]= NULL;
+	info->acts[i]= NULL;
+    }
+    info->dfltType= None;
+    info->behavior.type= XkbKB_Default;
+    info->behavior.data= 0;
+    info->vmodmap= 0;
+    info->nameForOverlayKey= 0;
+    info->repeat= RepeatUndefined;
+    info->allowNone= 0;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeKeyInfo(KeyInfo *info)
+#else
+FreeKeyInfo(info)
+    KeyInfo *	info;
+#endif
+{
+register int i;
+
+    info->defs.defined= 0;
+    info->defs.fileID= 0;
+    info->defs.merge= MergeOverride;
+    info->defs.next= NULL;
+    info->groupInfo= 0;
+    info->typesDefined= info->symsDefined= info->actsDefined= 0;
+    for (i=0;i<XkbNumKbdGroups;i++) {
+	info->numLevels[i]= 0;
+	info->types[i]= None;
+	if (info->syms[i]!=NULL)
+	    uFree(info->syms[i]);
+	info->syms[i]= NULL;
+	if (info->acts[i]!=NULL)
+	    uFree(info->acts[i]);
+	info->acts[i]= NULL;
+    }
+    info->dfltType= None;
+    info->behavior.type= XkbKB_Default;
+    info->behavior.data= 0;
+    info->vmodmap= 0;
+    info->nameForOverlayKey= 0;
+    info->repeat= RepeatUndefined;
+    return;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopyKeyInfo(KeyInfo *old,KeyInfo *new,Bool clearOld)
+#else
+CopyKeyInfo(old,new,clearOld)
+    KeyInfo *	old;
+    KeyInfo *	new;
+    Bool	clearOld;
+#endif
+{
+register int i;
+
+    *new= *old;
+    new->defs.next= NULL;
+    if (clearOld) {
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    old->numLevels[i]= 0;
+	    old->syms[i]= NULL;
+	    old->acts[i]= NULL;
+	}
+    }
+    else {
+	int width;
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    width= new->numLevels[i];
+	    if (old->syms[i]!=NULL) {
+		new->syms[i]= uTypedCalloc(width,KeySym);
+		if (!new->syms[i]) {
+		    new->syms[i]= NULL;
+		    new->numLevels[i]= 0;
+		    return False;
+		}
+		memcpy((char *)new->syms[i],(char *)old->syms[i],
+						width*sizeof(KeySym));
+	    }
+	    if (old->acts[i]!=NULL) {
+		new->acts[i]= uTypedCalloc(width,XkbAction);
+		if (!new->acts[i]) {
+		    new->acts[i]= NULL;
+		    return False;
+		}
+		memcpy((char *)new->acts[i],(char *)old->acts[i],
+						width*sizeof(XkbAction));
+	    }
+	}
+    }
+    return True;
+}
+
+/***====================================================================***/
+
+typedef struct _ModMapEntry {
+    CommonInfo 			defs;
+    Bool			haveSymbol;
+    int				modifier;
+    union {
+	unsigned long		keyName;
+	KeySym			keySym;
+    } u;
+} ModMapEntry;
+
+#define	SYMBOLS_INIT_SIZE	110
+#define	SYMBOLS_CHUNK		20
+typedef struct _SymbolsInfo {
+    char *			name;
+    int				errorCount;
+    unsigned			fileID;
+    unsigned			merge;
+    unsigned			groupInfo;
+    unsigned			szKeys;
+    unsigned			nKeys;
+    KeyInfo *			keys;
+    KeyInfo			dflt;
+    VModInfo			vmods;
+    ActionInfo *		action;
+    Atom			groupNames[XkbNumKbdGroups];
+
+    ModMapEntry *		modMap;
+    AliasInfo *			aliases;
+} SymbolsInfo;
+
+static void
+#if NeedFunctionPrototypes
+InitSymbolsInfo(SymbolsInfo *info,XkbDescPtr xkb)
+#else
+InitSymbolsInfo(info,xkb)
+    SymbolsInfo *	info;
+    XkbDescPtr		xkb;
+#endif
+{
+register int i;
+
+    tok_ONE_LEVEL= XkbInternAtom(NULL,"ONE_LEVEL",False);
+    tok_TWO_LEVEL= XkbInternAtom(NULL,"TWO_LEVEL",False);
+    tok_KEYPAD= XkbInternAtom(NULL,"KEYPAD",False);
+    info->name= NULL;
+    info->errorCount= 0;
+    info->fileID= 0;
+    info->merge= MergeOverride;
+    info->groupInfo= 0;
+    info->szKeys= SYMBOLS_INIT_SIZE;
+    info->nKeys= 0;
+    info->keys= uTypedCalloc(SYMBOLS_INIT_SIZE,KeyInfo);
+    info->modMap= NULL;
+    for (i=0;i<XkbNumKbdGroups;i++)
+	info->groupNames[i]= None;
+    InitKeyInfo(&info->dflt);
+    InitVModInfo(&info->vmods,xkb);
+    info->action= NULL;
+    info->aliases= NULL;
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+FreeSymbolsInfo(SymbolsInfo *info)
+#else
+FreeSymbolsInfo(info)
+    SymbolsInfo *	info;
+#endif
+{
+register int	i;
+
+    if (info->name)
+	uFree(info->name);
+    info->name= NULL;
+    if (info->keys) {
+	for (i=0;i<info->nKeys;i++) {
+	    FreeKeyInfo(&info->keys[i]);
+	}
+	uFree(info->keys);
+	info->keys= NULL;
+    }
+    if (info->modMap) {
+	ClearCommonInfo(&info->modMap->defs);
+	info->modMap= NULL;
+    }
+    if (info->aliases) {
+	ClearAliases(&info->aliases);
+	info->aliases= NULL;
+    }
+    bzero((char *)info,sizeof(SymbolsInfo));
+    return;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+ResizeKeyGroup(	KeyInfo *	key,
+		unsigned	group,
+		unsigned 	atLeastSize,
+		Bool 		forceActions)
+#else
+ResizeKeyGroup(key,group,atLeastSize,forceActions)
+    KeyInfo *		key;
+    unsigned		group;
+    unsigned		atLeastSize;
+    Bool		forceActions;
+#endif
+{
+Bool		tooSmall;
+unsigned	newWidth;
+
+    tooSmall= (key->numLevels[group]<atLeastSize);
+    if (tooSmall)	newWidth= atLeastSize;
+    else		newWidth= key->numLevels[group];
+
+    if ((key->syms[group]==NULL)||tooSmall) {
+	key->syms[group]= uTypedRecalloc(key->syms[group],
+					key->numLevels[group],newWidth,
+					KeySym);
+	if (!key->syms[group])
+	    return False;
+    }
+    if (((forceActions)&&(tooSmall||(key->acts[group]==NULL)))||
+				(tooSmall&&(key->acts[group]!=NULL))) {
+	key->acts[group]= uTypedRecalloc(key->acts[group],
+					key->numLevels[group],newWidth,
+					XkbAction);
+	if (!key->acts[group])
+	    return False;
+    }
+    key->numLevels[group]= newWidth;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+MergeKeyGroups(	SymbolsInfo *	info,
+		KeyInfo *	into,
+		KeyInfo *	from,
+		unsigned	group)
+#else
+MergeKeyGroups(info,into,from,group)
+    SymbolsInfo *	info;
+    KeyInfo *		into;
+    KeyInfo *		from;
+    unsigned		group;
+#endif
+{
+KeySym	*	resultSyms;
+XkbAction *	resultActs;
+int		resultWidth;
+register int	i;
+Bool		report,clobber;
+
+    clobber= (from->defs.merge!=MergeAugment);
+    report= (warningLevel>9)||
+	    ((into->defs.fileID==from->defs.fileID)&&(warningLevel>0));
+    if (into->numLevels[group]>=from->numLevels[group]) {
+	resultSyms= into->syms[group];
+	resultActs= into->acts[group];
+	resultWidth= into->numLevels[group];
+    }
+    else {
+	resultSyms= from->syms[group];
+	resultActs= from->acts[group];
+	resultWidth= from->numLevels[group];
+    }
+    if (resultSyms==NULL) {
+	resultSyms= uTypedCalloc(resultWidth,KeySym);
+	if (!resultSyms) {
+	    WSGO("Could not allocate symbols for group merge\n");
+	    ACTION2("Group %d of key %s not merged\n",group,
+					longText(into->name,XkbMessage));
+	    return False;
+	}
+    }
+    if ((resultActs==NULL)&&(into->acts[group]||from->acts[group])) {
+	resultActs= uTypedCalloc(resultWidth,XkbAction);
+	if (!resultActs) {
+	    WSGO("Could not allocate actions for group merge\n");
+	    ACTION2("Group %d of key %s not merged\n",group,
+					longText(into->name,XkbMessage));
+	    return False;
+	}
+    }
+    for (i=0;i<resultWidth;i++) {
+	KeySym fromSym,toSym;
+	if (from->syms[group] && (i<from->numLevels[group]))
+	     fromSym= from->syms[group][i];
+	else fromSym= NoSymbol;
+	if (into->syms[group] && (i<into->numLevels[group]))
+	     toSym= into->syms[group][i];
+	else toSym= NoSymbol;
+	if ((fromSym==NoSymbol)||(fromSym==toSym))
+	    resultSyms[i]= toSym;
+	else if (toSym==NoSymbol)
+	    resultSyms[i]= fromSym;
+	else {
+	    KeySym use,ignore;
+	    if (clobber) 	{ use= fromSym; ignore= toSym; 		}
+	    else 		{ use= toSym;	ignore= fromSym;	}
+	    if (report) {
+		WARN3("Multiple symbols for level %d/group %d on key %s\n",
+				i+1,group+1,longText(into->name,XkbMessage));
+		ACTION2("Using %s, ignoring %s\n",XkbKeysymText(use,XkbMessage),
+					XkbKeysymText(ignore,XkbMessage));
+	    }
+	    resultSyms[i]= use;
+	}
+	if (resultActs!=NULL) {
+	    XkbAction *fromAct,*toAct;
+	    fromAct= (from->acts[group]?&from->acts[group][i]:NULL);
+	    toAct= (into->acts[group]?&into->acts[group][i]:NULL);
+	    if (((fromAct==NULL)||(fromAct->type==XkbSA_NoAction))&&
+						(toAct!=NULL)) {
+		resultActs[i]= *toAct;
+	    }
+	    else if (((toAct==NULL)||(toAct->type==XkbSA_NoAction))&&
+						(fromAct!=NULL)) {
+		resultActs[i]= *fromAct;
+	    }
+	    else {
+		XkbAction *use,*ignore;
+		if (clobber) 	{ use= fromAct; ignore= toAct; 		}
+		else 		{ use= toAct;	ignore= fromAct;	}
+		if (report) {
+		  WARN3("Multiple actions for level %d/group %d on key %s\n",
+				i+1,group+1,longText(into->name,XkbMessage));
+		  ACTION2("Using %s, ignoring %s\n",
+				XkbActionTypeText(use->type,XkbMessage),
+				XkbActionTypeText(ignore->type,XkbMessage));
+		}
+		resultActs[i]= *use;
+	    }
+	}
+    }
+    if ((into->syms[group]!=NULL)&&(resultSyms!=into->syms[group]))
+	uFree(into->syms[group]);
+    if ((from->syms[group]!=NULL)&&(resultSyms!=from->syms[group]))
+	uFree(from->syms[group]);
+    into->numLevels[group]= resultWidth;
+    into->syms[group]= resultSyms;
+    from->syms[group]= NULL;
+    into->symsDefined|= (1<<group);
+    from->symsDefined&= ~(1<<group);
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+MergeKeys(SymbolsInfo *info,KeyInfo *into,KeyInfo *from)
+#else
+MergeKeys(info,into,from)
+    SymbolsInfo *	info;
+    KeyInfo *		into;
+    KeyInfo *		from;
+#endif
+{
+register int	i;
+unsigned	collide= 0;
+Bool		report;
+    
+    if (from->defs.merge==MergeReplace) {
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    if (into->numLevels[i]!=0) {
+		if (into->syms[i])
+		    uFree(into->syms[i]);
+		if (into->acts[i])
+		    uFree(into->acts[i]);
+	    }
+	}
+	*into= *from;
+	bzero(from,sizeof(KeyInfo));
+	return True;
+    }
+    report= ((warningLevel>9)||
+	     ((into->defs.fileID==from->defs.fileID)&&(warningLevel>0)));
+    for (i=0;i<XkbNumKbdGroups;i++) {
+	if (from->numLevels[i]>0) {
+	    if (into->numLevels[i]==0) {
+		into->numLevels[i]= from->numLevels[i];
+		into->syms[i]= from->syms[i];
+		into->acts[i]= from->acts[i];
+		into->symsDefined|= (1<<i);
+		from->syms[i]= NULL;
+		from->acts[i]= NULL;
+		from->numLevels[i]= 0;
+		from->symsDefined&= ~(1<<i);
+		if (into->syms[i])	into->defs.defined|= _Key_Syms;
+		if (into->acts[i])	into->defs.defined|= _Key_Acts;
+	    }
+	    else {
+		if (report) {
+		    if (into->syms[i])	collide|= _Key_Syms;
+		    if (into->acts[i])	collide|= _Key_Acts;
+		}
+		MergeKeyGroups(info,into,from,(unsigned)i);
+	    }
+	}
+	if (from->types[i]!=None) {
+	    if ((into->types[i]!=None)&&(report)&&
+				(into->types[i]!=from->types[i])) {
+		Atom	use,ignore;
+		collide|= _Key_Types;
+		if (from->defs.merge!=MergeAugment) {
+		    use= from->types[i];
+		    ignore= into->types[i];
+		}
+		else {
+		    use= into->types[i];
+		    ignore= from->types[i];
+		}
+		WARN2("Multiple definitions for group %d type of key %s\n",
+	    				i,longText(into->name,XkbMessage));
+		ACTION2("Using %s, ignoring %s\n",
+	    				XkbAtomText(NULL,use,XkbMessage),
+					XkbAtomText(NULL,ignore,XkbMessage));
+	    }
+	    if ((from->defs.merge!=MergeAugment)||(into->types[i]==None)) {
+		into->types[i]= from->types[i];
+	    }
+	}
+    }
+    if (UseNewField(_Key_Behavior,&into->defs,&from->defs,&collide)) {
+	into->behavior= from->behavior;
+	into->nameForOverlayKey= from->nameForOverlayKey;
+	into->defs.defined|= _Key_Behavior;
+    }
+    if (UseNewField(_Key_VModMap,&into->defs,&from->defs,&collide)) {
+	into->vmodmap= from->vmodmap;
+	into->defs.defined|= _Key_VModMap;
+    }
+    if (UseNewField(_Key_Repeat,&into->defs,&from->defs,&collide)) {
+	into->repeat= from->repeat;
+	into->defs.defined|= _Key_Repeat;
+    }
+    if (UseNewField(_Key_Type_Dflt,&into->defs,&from->defs,&collide)) {
+	into->dfltType= from->dfltType;
+	into->defs.defined|= _Key_Type_Dflt;
+    }
+    if (UseNewField(_Key_GroupInfo,&into->defs,&from->defs,&collide)) {
+	into->groupInfo= from->groupInfo;
+	into->defs.defined|= _Key_GroupInfo;
+    }
+    if ( collide ) {
+	WARN1("Symbol map for key %s redefined\n",
+			longText(into->name,XkbMessage));
+	ACTION1("Using %s definition for conflicting fields\n",
+			(from->defs.merge==MergeAugment?"first":"last"));
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddKeySymbols(SymbolsInfo *info,KeyInfo *key)
+#else
+AddKeySymbols(info,key)
+    SymbolsInfo *	  info;
+    KeyInfo *		  key;
+#endif
+{
+register int i;
+
+    for (i=0;i<info->nKeys;i++) {
+	if (info->keys[i].name==key->name)
+	    return MergeKeys(info,&info->keys[i],key);
+    }
+    if (info->nKeys>=info->szKeys) {
+	info->szKeys+= SYMBOLS_CHUNK;
+	info->keys= uTypedRecalloc(info->keys,info->nKeys,info->szKeys,KeyInfo);
+	if (!info->keys) {
+	    WSGO("Could not allocate key symbols descriptions\n");
+	    ACTION("Some key symbols definitions may be lost\n");
+	    return False;
+	}
+    }
+    return CopyKeyInfo(key,&info->keys[info->nKeys++],True);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddModMapEntry(SymbolsInfo *info,ModMapEntry *new)
+#else
+AddModMapEntry(info,new)
+    SymbolsInfo *	info;
+    ModMapEntry *	new;
+#endif
+{
+ModMapEntry *	mm;
+Bool		clobber;
+
+    clobber= (new->defs.merge!=MergeAugment);
+    for (mm=info->modMap;mm!=NULL;mm= (ModMapEntry *)mm->defs.next) {
+	if (new->haveSymbol&&mm->haveSymbol&&(new->u.keySym==mm->u.keySym)) {
+	    unsigned	use,ignore;
+	    if (mm->modifier!=new->modifier) {
+		if (clobber) {
+		    use= new->modifier;
+		    ignore= mm->modifier;
+		}
+		else {
+		    use= mm->modifier;
+		    ignore= new->modifier;
+		}
+		ERROR1("%s added to symbol map for multiple modifiers\n",
+				XkbKeysymText(new->u.keySym,XkbMessage));
+		ACTION2("Using %s, ignoring %s.\n",
+					XkbModIndexText(use,XkbMessage),
+					XkbModIndexText(ignore,XkbMessage));
+		mm->modifier= use;
+	    }
+	    return True;
+	}
+	if ((!new->haveSymbol)&&(!mm->haveSymbol)&&
+					(new->u.keyName==mm->u.keyName)) {
+	    unsigned use,ignore;
+	    if (mm->modifier!=new->modifier) {
+		if (clobber) {
+		    use= new->modifier;
+		    ignore= mm->modifier;
+		}
+		else {
+		    use= mm->modifier;
+		    ignore= new->modifier;
+		}
+		ERROR1("Key %s added to map for multiple modifiers\n",
+					longText(new->u.keyName,XkbMessage));
+		ACTION2("Using %s, ignoring %s.\n",
+					XkbModIndexText(use,XkbMessage),
+					XkbModIndexText(ignore,XkbMessage));
+		mm->modifier= use;
+	    }
+	    return True;
+	}
+    }
+    mm= uTypedAlloc(ModMapEntry);
+    if (mm==NULL) {
+	WSGO("Could not allocate modifier map entry\n");
+	ACTION1("Modifier map for %s will be incomplete\n",
+				XkbModIndexText(new->modifier,XkbMessage));
+	return False;
+    }
+    *mm= *new;
+    mm->defs.next= &info->modMap->defs;
+    info->modMap= mm;
+    return True;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+MergeIncludedSymbols(SymbolsInfo *into,SymbolsInfo *from,unsigned merge)
+#else
+MergeIncludedSymbols(into,from,merge)
+    SymbolsInfo *	into;
+    SymbolsInfo *	from;
+    unsigned		merge;
+#endif
+{
+register int 	i;
+KeyInfo *	key;
+
+    if (from->errorCount>0) {
+	into->errorCount+= from->errorCount;
+	return;
+    }
+    if (into->name==NULL) {
+	into->name= from->name;
+	from->name= NULL;
+    }
+    for (i=0;i<XkbNumKbdGroups;i++) {
+	if (from->groupNames[i]!=None) {
+	    if ((merge!=MergeAugment)||(into->groupNames[i]==None))
+		into->groupNames[i]= from->groupNames[i];
+	}
+    }
+    for (i=0,key=from->keys;i<from->nKeys;i++,key++) {
+	if (merge!=MergeDefault)
+	    key->defs.merge= merge;
+	if (!AddKeySymbols(into,key))
+	    into->errorCount++;
+    }
+    if (from->modMap!=NULL) {
+	ModMapEntry *mm,*next;
+	for (mm=from->modMap;mm!=NULL;mm=next) {
+	    if (merge!=MergeDefault)
+		mm->defs.merge= merge;
+	    if (!AddModMapEntry(into,mm))
+		into->errorCount++;
+	    next= (ModMapEntry *)mm->defs.next;
+	    uFree(mm);
+	}
+	from->modMap= NULL;
+    }
+    if (!MergeAliases(&into->aliases,&from->aliases,merge))
+	into->errorCount++;
+    return;
+}
+
+typedef void	(*FileHandler)(
+#if NeedFunctionPrototypes
+	XkbFile *	/* rtrn */,
+	XkbDescPtr	/* xkb */,
+	unsigned	/* merge */,
+	SymbolsInfo *	/* included */
+#endif
+);
+
+static Bool
+#if NeedFunctionPrototypes
+HandleIncludeSymbols(	IncludeStmt *	stmt,
+			XkbDescPtr	xkb,
+			SymbolsInfo *	info,
+			FileHandler	hndlr)
+#else
+HandleIncludeSymbols(stmt,xkb,info,hndlr)
+    IncludeStmt	*	  stmt;
+    XkbDescPtr		  xkb;
+    SymbolsInfo *	  info;
+    void		(*hndlr)();
+#endif
+{
+unsigned 	newMerge;
+XkbFile	*	rtrn;
+SymbolsInfo	included;
+Bool		haveSelf;
+
+    haveSelf= False;
+    if ((stmt->file==NULL)&&(stmt->map==NULL)) {
+	haveSelf= True;
+	included= *info;
+	bzero(info,sizeof(SymbolsInfo));
+    }
+    else if (ProcessIncludeFile(stmt,XkmSymbolsIndex,&rtrn,&newMerge)) {
+	InitSymbolsInfo(&included,xkb);
+	included.fileID= included.dflt.defs.fileID= rtrn->id;
+	included.merge= included.dflt.defs.merge= MergeOverride;
+	(*hndlr)(rtrn,xkb,MergeOverride,&included);
+	if (stmt->stmt!=NULL) {
+	    if (included.name!=NULL)
+		uFree(included.name);
+	    included.name= stmt->stmt;
+	    stmt->stmt= NULL;
+	}
+    }
+    else {
+	info->errorCount+= 10;
+	return False;
+    }
+    if ((stmt->next!=NULL)&&(included.errorCount<1)) {
+	IncludeStmt *	next;
+	unsigned	op;
+	SymbolsInfo	next_incl;
+
+	for (next=stmt->next;next!=NULL;next=next->next) {
+	    if ((next->file==NULL)&&(next->map==NULL)) {
+		haveSelf= True;
+		MergeIncludedSymbols(&included,info,next->merge);
+		FreeSymbolsInfo(info);
+	    }
+	    else if (ProcessIncludeFile(next,XkmSymbolsIndex,&rtrn,&op)) {
+		InitSymbolsInfo(&next_incl,xkb);
+		next_incl.fileID= next_incl.dflt.defs.fileID= rtrn->id;
+		next_incl.merge= next_incl.dflt.defs.merge= MergeOverride;
+		(*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
+		MergeIncludedSymbols(&included,&next_incl,op);
+		FreeSymbolsInfo(&next_incl);
+	    }
+	    else {
+		info->errorCount+= 10;
+		return False;
+	    }
+	}
+    }
+    if (haveSelf)
+	*info= included;
+    else {
+	MergeIncludedSymbols(info,&included,newMerge);
+	FreeSymbolsInfo(&included);
+    }
+    return (info->errorCount==0);
+}
+
+static LookupEntry	groupNames[]= {
+	{	"group1",	1	},
+	{	"group2",	2	},
+	{	"group3",	3	},
+	{	"group4",	4	},
+	{	"group5",	5	},
+	{	"group6",	6	},
+	{	"group7",	7	},
+	{	"group8",	8	},
+	{	    NULL,	0	}
+};
+
+
+#define	SYMBOLS 1
+#define	ACTIONS	2
+
+static Bool
+#if NeedFunctionPrototypes
+GetGroupIndex(	KeyInfo *	key,
+		ExprDef *	arrayNdx,
+		unsigned	what,
+		unsigned *	ndx_rtrn)
+#else
+GetGroupIndex(key,arrayNdx,what,ndx_rtrn)
+    KeyInfo *	key;
+    ExprDef *	arrayNdx;
+    unsigned	what;
+    unsigned *	ndx_rtrn;
+#endif
+{
+char *		name;
+ExprResult	tmp;
+
+    if (what==SYMBOLS)	name= "symbols";
+    else		name= "actions";
+
+    if (arrayNdx==NULL) {
+	register int	i;
+	unsigned	defined;
+	if (what==SYMBOLS)	defined= key->symsDefined;
+	else			defined= key->actsDefined;
+
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    if ((defined&(1<<i))==0) {
+		*ndx_rtrn= i;
+		return True;
+	    }
+	}
+	ERROR3("Too many groups of %s for key %s (max %d)\n",name,
+						longText(key->name,XkbMessage),
+						XkbNumKbdGroups+1);
+	ACTION1("Ignoring %s defined for extra groups\n",name);
+	return False;
+    }
+    if (!ExprResolveInteger(arrayNdx,&tmp,SimpleLookup,(XPointer)groupNames)) {
+	ERROR2("Illegal group index for %s of key %s\n",name,
+						longText(key->name,XkbMessage));
+	ACTION("Definition with non-integer array index ignored\n");
+	return False;
+    }
+    if ((tmp.uval<1)||(tmp.uval>XkbNumKbdGroups)) {
+	ERROR3("Group index for %s of key %s is out of range (1..%d)\n",name,
+						longText(key->name,XkbMessage),
+						XkbNumKbdGroups+1);
+	ACTION2("Ignoring %s for group %d\n",name,tmp.uval);
+	return False;
+    }
+    *ndx_rtrn= tmp.uval-1;
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddSymbolsToKey(	KeyInfo *	key,
+			XkbDescPtr	xkb,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SymbolsInfo *	info)
+#else
+AddSymbolsToKey(key,xkb,field,arrayNdx,value,info)
+    KeyInfo *		key;
+    XkbDescPtr		xkb;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SymbolsInfo *	info;
+#endif
+{
+unsigned	ndx,nSyms;
+int		i;
+
+    if (!GetGroupIndex(key,arrayNdx,SYMBOLS,&ndx))
+	return False;
+    if (value==NULL) {
+	key->symsDefined|= (1<<ndx);
+	return True;
+    }
+    if (value->op!=ExprKeysymList) {
+	ERROR1("Expected a list of symbols, found %s\n",exprOpText(value->op));
+	ACTION2("Ignoring symbols for group %d of %s\n",ndx,
+						longText(key->name,XkbMessage));
+	return False;
+    }
+    if (key->syms[ndx]!=NULL) {
+	WSGO2("Symbols for key %s, group %d already defined\n",
+						longText(key->name,XkbMessage),
+						ndx);
+	return False;
+    }
+    nSyms= value->value.list.nSyms;
+    if (((key->numLevels[ndx]<nSyms)||(key->syms[ndx]==NULL))&&
+				(!ResizeKeyGroup(key,ndx,nSyms,False))) {
+	WSGO2("Could not resize group %d of key %s\n",ndx,
+						longText(key->name,XkbMessage));
+	ACTION("Symbols lost\n");
+	return False;
+    }
+    key->symsDefined|= (1<<ndx);
+    memcpy((char *)key->syms[ndx],(char *)value->value.list.syms,
+							nSyms*sizeof(KeySym));
+    uFree(value->value.list.syms);
+    value->value.list.syms= NULL;
+    for (i=key->numLevels[ndx]-1;(i>=0)&&(key->syms[ndx][i]==NoSymbol);i--) {
+	key->numLevels[ndx]--;
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+AddActionsToKey(	KeyInfo *	key,
+			XkbDescPtr	xkb,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SymbolsInfo *	info)
+#else
+AddActionsToKey(key,xkb,field,arrayNdx,value,info)
+    KeyInfo *		key;
+    XkbDescPtr		xkb;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SymbolsInfo *	info;
+#endif
+{
+register int	i;
+unsigned	ndx,nActs;
+ExprDef	*	act;
+XkbAnyAction *	toAct;
+
+    if (!GetGroupIndex(key,arrayNdx,ACTIONS,&ndx))
+	return False;
+
+    if (value==NULL) {
+	key->actsDefined|= (1<<ndx);
+	return True;
+    }
+    if (value->op!=ExprActionList) {
+	WSGO1("Bad expression type (%d) for action list value\n",value->op);
+	ACTION2("Ignoring actions for group %d of %s\n",ndx,
+						longText(key->name,XkbMessage));
+	return False;
+    }
+    if (key->acts[ndx]!=NULL) {
+	WSGO2("Actions for key %s, group %d already defined\n",
+						longText(key->name,XkbMessage),
+						ndx);
+	return False;
+    }
+    for (nActs=0,act= value->value.child;act!=NULL;nActs++) {
+	act= (ExprDef *)act->common.next;
+    }
+    if (nActs<1) {
+	WSGO("Action list but not actions in AddActionsToKey\n");
+	return False;
+    }
+    if (((key->numLevels[ndx]<nActs)||(key->acts[ndx]==NULL))&&
+				(!ResizeKeyGroup(key,ndx,nActs,True))) {
+	WSGO2("Could not resize group %d of key %s\n",ndx,
+					longText(key->name,XkbMessage));
+	ACTION("Actions lost\n");
+	return False;
+    }
+    key->actsDefined|= (1<<ndx);
+
+    toAct= (XkbAnyAction *)key->acts[ndx];
+    act= value->value.child;
+    for (i=0;i<nActs;i++,toAct++) {
+	if (!HandleActionDef(act,xkb,toAct,MergeOverride,info->action)) {
+	    ERROR1("Illegal action definition for %s\n",
+	    				longText(key->name,XkbMessage));
+	    ACTION2("Action for group %d/level %d ignored\n",ndx+1,i+1);
+	}
+	act= (ExprDef *)act->common.next;
+    }
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetAllowNone(KeyInfo *key,ExprDef *arrayNdx,ExprDef *value)
+#else
+SetAllowNone(key,arrayNdx,value)
+    KeyInfo *	key;
+    ExprDef *	arrayNdx;
+    ExprDef *	value;
+#endif
+{
+ExprResult	tmp;
+unsigned	radio_groups= 0;
+
+    if (arrayNdx==NULL) {
+	radio_groups= XkbAllRadioGroupsMask;
+    }
+    else {
+        if (!ExprResolveInteger(arrayNdx,&tmp,RadioLookup,NULL)){
+	    ERROR("Illegal index in group name definition\n");
+	    ACTION("Definition with non-integer array index ignored\n");
+	    return False;
+	}
+	if ((tmp.uval<1)||(tmp.uval>XkbMaxRadioGroups)) {
+	    ERROR1("Illegal radio group specified (must be 1..%d)\n",
+							XkbMaxRadioGroups+1);
+	    ACTION1("Value of \"allow none\" for group %d ignored\n",tmp.uval);
+	    return False;
+	}
+	radio_groups|= (1<<(tmp.uval-1));
+    }
+    if (!ExprResolveBoolean(value,&tmp,NULL,NULL)) {
+	ERROR1("Illegal \"allow none\" value for %s\n",
+	    					longText(key->name,XkbMessage));
+	ACTION("Non-boolean value ignored\n"); 
+	return False;
+    }
+    if (tmp.uval)	key->allowNone|= radio_groups;
+    else		key->allowNone&= ~radio_groups;
+    return True;
+}
+
+
+static LookupEntry	lockingEntries[] = {
+	{	"true",		XkbKB_Lock	},
+	{	"yes",		XkbKB_Lock	},
+	{	"on",		XkbKB_Lock	},
+	{	"false",	XkbKB_Default	},
+	{	"no",		XkbKB_Default	},
+	{	"off",		XkbKB_Default	},
+	{	"permanent",	XkbKB_Lock|XkbKB_Permanent },
+	{	NULL,		0	}
+};
+
+static LookupEntry	repeatEntries[]= {
+	{	"true",		RepeatYes	},
+	{	"yes",		RepeatYes	},
+	{	"on",		RepeatYes	},
+	{	"false",	RepeatNo	},
+	{	"no",		RepeatNo	},
+	{	"off",		RepeatNo	},
+	{	"default",	RepeatUndefined	},
+	{	NULL,		0	}
+};
+
+static	LookupEntry	rgEntries[]= {
+	{	"none",		0	},
+	{	NULL,		0	}
+};
+
+static Bool
+#if NeedFunctionPrototypes
+SetSymbolsField(	KeyInfo *	key,
+			XkbDescPtr	xkb,
+			char *		field,
+			ExprDef *	arrayNdx,
+			ExprDef *	value,
+			SymbolsInfo *	info)
+#else
+SetSymbolsField(key,xkb,field,arrayNdx,value,info)
+    KeyInfo *		key;
+    XkbDescPtr		xkb;
+    char *		field;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+    SymbolsInfo *	info;
+#endif
+{
+Bool 		ok= True;
+ExprResult	tmp;
+
+    if (uStrCaseCmp(field,"type")==0) {
+	ExprResult	ndx;
+	if ((!ExprResolveString(value,&tmp,NULL,NULL))&&(warningLevel>0)) {
+	    WARN("The type field of a key symbol map must be a string\n");
+	    ACTION("Ignoring illegal type definition\n");
+	}
+	if (arrayNdx==NULL) {
+	    key->dfltType= XkbInternAtom(NULL,tmp.str,False);
+	    key->defs.defined|= _Key_Type_Dflt;
+	}
+	else if (!ExprResolveInteger(arrayNdx,&ndx,SimpleLookup,
+							(XPointer)groupNames)) {
+	    ERROR1("Illegal group index for type of key %s\n",
+						longText(key->name,XkbMessage));
+	    ACTION("Definition with non-integer array index ignored\n");
+	    return False;
+	}
+	else if ((ndx.uval<1)||(ndx.uval>XkbNumKbdGroups)) {
+	    ERROR2("Group index for type of key %s is out of range (1..%d)\n",
+						longText(key->name,XkbMessage),
+						XkbNumKbdGroups+1);
+	    ACTION1("Ignoring type for group %d\n",ndx.uval);
+	    return False;
+        }
+	else {
+	    key->types[ndx.uval-1]= XkbInternAtom(NULL,tmp.str,False);
+	    key->typesDefined|= (1<<(ndx.uval-1));
+	}
+    }
+    else if (uStrCaseCmp(field,"symbols")==0)
+	return AddSymbolsToKey(key,xkb,field,arrayNdx,value,info);
+    else if (uStrCaseCmp(field,"actions")==0)
+	return AddActionsToKey(key,xkb,field,arrayNdx,value,info);
+    else if ((uStrCaseCmp(field,"vmods")==0)||
+	     (uStrCaseCmp(field,"virtualmods")==0)||
+	     (uStrCaseCmp(field,"virtualmodifiers")==0)) {
+	ok= ExprResolveModMask(value,&tmp,LookupVModMask,(XPointer)xkb);
+	if (ok) {
+	    key->vmodmap= (tmp.uval>>8);
+	    key->defs.defined|= _Key_VModMap;
+	}
+	else {
+	    ERROR1("Expected a virtual modifier mask, found %s\n",
+							exprOpText(value->op));
+	    ACTION1("Ignoring virtual modifiers definition for key %s\n",
+						longText(key->name,XkbMessage));
+	}
+    }
+    else if ((uStrCaseCmp(field,"locking")==0)||(uStrCaseCmp(field,"lock")==0)||
+   	     (uStrCaseCmp(field,"locks")==0)) {
+	ok= ExprResolveEnum(value,&tmp,lockingEntries);
+	if (ok)
+	    key->behavior.type= tmp.uval;
+	key->defs.defined|= _Key_Behavior;
+    }
+    else if ((uStrCaseCmp(field,"radiogroup")==0)||
+	     (uStrCaseCmp(field,"permanentradiogroup")==0)) {
+	Bool permanent= False;
+	if (uStrCaseCmp(field,"permanentradiogroup")==0)
+	    permanent= True;
+	ok= ExprResolveInteger(value,&tmp,SimpleLookup,(XPointer)rgEntries);
+	if (!ok) {
+	    ERROR1("Illegal radio group specification for %s\n",
+					longText(key->name,XkbMessage));
+	    ACTION("Non-integer radio group ignored\n");
+	    return False;
+	}
+	if (tmp.uval==0) {
+	    key->behavior.type= XkbKB_Default;
+	    key->behavior.data= 0;
+	    return ok;
+	}
+	if ((tmp.uval<1)||(tmp.uval>XkbMaxRadioGroups)) {
+	    ERROR1("Radio group specification for %s out of range (1..32)\n",
+						longText(key->name,XkbMessage));
+	    ACTION1("Illegal radio group %d ignored\n",tmp.uval);
+	    return False;
+	}
+	key->behavior.type= XkbKB_RadioGroup|(permanent?XkbKB_Permanent:0);
+	key->behavior.data= tmp.uval-1;
+	if (key->allowNone&(1<<(tmp.uval-1)))
+	    key->behavior.data|= XkbKB_RGAllowNone;
+	key->defs.defined|= _Key_Behavior;
+    }
+    else if (uStrCaseEqual(field,"allownone")) {
+	ok= SetAllowNone(key,arrayNdx,value);
+    }
+    else if (uStrCasePrefix("overlay",field)||
+	     uStrCasePrefix("permanentoverlay",field)) {
+	Bool permanent= False;
+	char *which;
+	int  overlayNdx;
+	if (uStrCasePrefix("permanent",field)) {
+	    permanent= True;
+	    which= &field[sizeof("permanentoverlay")-1];
+	}
+	else {
+	    which= &field[sizeof("overlay")-1];
+	}
+	if (sscanf(which,"%d",&overlayNdx)==1) {
+	    if (((overlayNdx<1)||(overlayNdx>2))&&(warningLevel>0)) {
+		ERROR2("Illegal overlay %d specified for %s\n",
+						overlayNdx,
+						longText(key->name,XkbMessage));
+		ACTION("Ignored\n");
+		return False;
+	    }
+	}
+	else if (*which=='\0')
+	    overlayNdx=1;
+	else if (warningLevel>0) {
+	    ERROR2("Illegal overlay \"%s\" specified for %s\n",
+						which,
+						longText(key->name,XkbMessage));
+	    ACTION("Ignored\n");
+	    return False;
+	}
+	ok= ExprResolveKeyName(value,&tmp,NULL,NULL);
+	if (!ok) {
+	    ERROR1("Illegal overlay key specification for %s\n",
+						longText(key->name,XkbMessage));
+	    ACTION("Overlay key must be specified by name\n");
+	    return False;
+	}
+	if (overlayNdx==1)	key->behavior.type= XkbKB_Overlay1;
+	else			key->behavior.type= XkbKB_Overlay2;
+	if (permanent)
+	    key->behavior.type|= XkbKB_Permanent;
+
+	key->behavior.data= 0;
+	key->nameForOverlayKey= KeyNameToLong(tmp.keyName.name);
+	key->defs.defined|= _Key_Behavior;
+    }
+    else if ((uStrCaseCmp(field,"repeating")==0)||
+	     (uStrCaseCmp(field,"repeats")==0)||
+	     (uStrCaseCmp(field,"repeat")==0)){
+	ok= ExprResolveEnum(value,&tmp,repeatEntries);
+	if (!ok) {
+	    ERROR1("Illegal repeat setting for %s\n",
+	    					longText(key->name,XkbMessage));
+	    ACTION("Non-boolean repeat setting ignored\n");
+	    return False;
+	}
+	key->repeat= tmp.uval;
+	key->defs.defined|= _Key_Repeat;
+    }
+    else if ((uStrCaseCmp(field,"groupswrap")==0)||
+   	     (uStrCaseCmp(field,"wrapgroups")==0)) {
+	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
+	if (!ok) {
+	    ERROR1("Illegal groupsWrap setting for %s\n",
+	    					longText(key->name,XkbMessage));
+	    ACTION("Non-boolean value ignored\n"); 
+	    return False;
+	}
+	if (tmp.uval) 	key->groupInfo= XkbWrapIntoRange;
+	else		key->groupInfo= XkbClampIntoRange;
+	key->defs.defined|= _Key_GroupInfo;
+    }
+    else if ((uStrCaseCmp(field,"groupsclamp")==0)||
+   	     (uStrCaseCmp(field,"clampgroups")==0)) {
+	ok= ExprResolveBoolean(value,&tmp,NULL,NULL);
+	if (!ok) {
+	    ERROR1("Illegal groupsClamp setting for %s\n",
+	    					longText(key->name,XkbMessage));
+	    ACTION("Non-boolean value ignored\n"); 
+	    return False;
+	}
+	if (tmp.uval)	key->groupInfo= XkbClampIntoRange;
+	else		key->groupInfo= XkbWrapIntoRange;
+	key->defs.defined|= _Key_GroupInfo;
+    }
+    else if ((uStrCaseCmp(field,"groupsredirect")==0)||
+	     (uStrCaseCmp(field,"redirectgroups")==0)) {
+	if (!ExprResolveInteger(value,&tmp,SimpleLookup,(XPointer)groupNames)) {
+	    ERROR1("Illegal group index for redirect of key %s\n",
+						longText(key->name,XkbMessage));
+	    ACTION("Definition with non-integer group ignored\n");
+	    return False;
+	}
+	if ((tmp.uval<1)||(tmp.uval>XkbNumKbdGroups)) {
+	    ERROR2("Out-of-range (1..%d) group for redirect of key %s\n",
+						XkbNumKbdGroups,
+						longText(key->name,XkbMessage));
+	    ERROR1("Ignoring illegal group %d\n",tmp.uval);
+	    return False;
+	}
+	key->groupInfo= XkbSetGroupInfo(0,XkbRedirectIntoRange,tmp.uval-1);
+	key->defs.defined|= _Key_GroupInfo;
+    }
+    else {
+	ERROR1("Unknown field %s in a symbol interpretation\n",field);
+	ACTION("Definition ignored\n");
+	ok= False;
+    }
+    return ok;
+}
+
+static int
+#if NeedFunctionPrototypes
+SetGroupName(SymbolsInfo *info,ExprDef *arrayNdx,ExprDef *value)
+#else
+SetGroupName(info,arrayNdx,value)
+    SymbolsInfo *	info;
+    ExprDef *		arrayNdx;
+    ExprDef *		value;
+#endif
+{
+ExprResult	tmp,name;
+
+    if ((arrayNdx==NULL)&&(warningLevel>0)) {
+	WARN("You must specify an index when specifying a group name\n");
+	ACTION("Group name definition without array subscript ignored\n");
+	return False;
+    }
+    if (!ExprResolveInteger(arrayNdx,&tmp,SimpleLookup,(XPointer)groupNames)) {
+	ERROR("Illegal index in group name definition\n");
+	ACTION("Definition with non-integer array index ignored\n");
+	return False;
+    }
+    if ((tmp.uval<1)||(tmp.uval>XkbNumKbdGroups)) {
+	ERROR1("Attempt to specify name for illegal group (must be 1..%d)\n",
+							XkbNumKbdGroups+1);
+	ACTION1("Name for group %d ignored\n",tmp.uval);
+	return False;
+    }
+    if (!ExprResolveString(value,&name,NULL,NULL)) {
+	ERROR("Group name must be a string\n");
+	ACTION1("Illegal name for group %d ignored\n",tmp.uval);
+	return False;
+    }
+    info->groupNames[tmp.uval-1]= XkbInternAtom(NULL,name.str,False);
+    return True;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleSymbolsVar(VarDef *stmt,XkbDescPtr xkb,SymbolsInfo *info)
+#else
+HandleSymbolsVar(stmt,xkb,info)
+    VarDef *		stmt;
+    XkbDescPtr		xkb;
+    SymbolsInfo *	info;
+#endif
+{
+ExprResult	elem,field,tmp;
+ExprDef *	arrayNdx;
+
+    if (ExprResolveLhs(stmt->name,&elem,&field,&arrayNdx)==0) 
+	return 0; /* internal error, already reported */
+    if (elem.str&&(uStrCaseCmp(elem.str,"key")==0)) {
+	return SetSymbolsField(&info->dflt,xkb,field.str,arrayNdx,stmt->value,
+							     		info);	
+    }
+    else if ((elem.str==NULL)&&((uStrCaseCmp(field.str,"name")==0)||
+				(uStrCaseCmp(field.str,"groupname")==0))) {
+	return SetGroupName(info,arrayNdx,stmt->value);
+    }
+    else if ((elem.str==NULL)&&((uStrCaseCmp(field.str,"groupswrap")==0)||
+				(uStrCaseCmp(field.str,"wrapgroups")==0))) {
+	if (!ExprResolveBoolean(stmt->value,&tmp,NULL,NULL)) {
+	    ERROR("Illegal setting for global groupsWrap\n");
+	    ACTION("Non-boolean value ignored\n"); 
+	    return False;
+	}
+	if (tmp.uval) 	info->groupInfo= XkbWrapIntoRange;
+	else		info->groupInfo= XkbClampIntoRange;
+	return True;
+    }
+    else if ((elem.str==NULL)&&((uStrCaseCmp(field.str,"groupsclamp")==0)||
+				(uStrCaseCmp(field.str,"clampgroups")==0))) {
+	if (!ExprResolveBoolean(stmt->value,&tmp,NULL,NULL)) {
+	    ERROR("Illegal setting for global groupsClamp\n");
+	    ACTION("Non-boolean value ignored\n"); 
+	    return False;
+	}
+	if (tmp.uval)	info->groupInfo= XkbClampIntoRange;
+	else		info->groupInfo= XkbWrapIntoRange;
+	return True;
+    }
+    else if ((elem.str==NULL)&&((uStrCaseCmp(field.str,"groupsredirect")==0)||
+				(uStrCaseCmp(field.str,"redirectgroups")==0))) {
+	if (!ExprResolveInteger(stmt->value,&tmp,
+					SimpleLookup,(XPointer)groupNames)) {
+	    ERROR("Illegal group index for global groupsRedirect\n");
+	    ACTION("Definition with non-integer group ignored\n");
+	    return False;
+	}
+	if ((tmp.uval<1)||(tmp.uval>XkbNumKbdGroups)) {
+	    ERROR1("Out-of-range (1..%d) group for global groupsRedirect\n",
+	    						XkbNumKbdGroups);
+	    ACTION1("Ignoring illegal group %d\n",tmp.uval);
+	    return False;
+	}
+	info->groupInfo= XkbSetGroupInfo(0,XkbRedirectIntoRange,tmp.uval);
+	return True;
+    }
+    else if ((elem.str==NULL)&&(uStrCaseCmp(field.str,"allownone")==0)) {
+	return SetAllowNone(&info->dflt,arrayNdx,stmt->value);
+    }
+    return SetActionField(xkb,elem.str,field.str,arrayNdx,stmt->value,
+							     &info->action);
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleSymbolsBody(	VarDef *	def,
+			XkbDescPtr	xkb,
+			KeyInfo *	key,
+			SymbolsInfo *	info)
+#else
+HandleSymbolsBody(def,xkb,key,info)
+    VarDef *		def;
+    XkbDescPtr		xkb;
+    KeyInfo *		key;
+    SymbolsInfo *	info;
+#endif
+{
+Bool		ok= True;
+ExprResult	tmp,field;
+ExprDef *	arrayNdx;
+
+    for (;def!=NULL;def= (VarDef *)def->common.next) {
+	if ((def->name)&&(def->name->type==ExprFieldRef)) {
+	    ok= HandleSymbolsVar(def,xkb,info);
+	    continue;
+	}
+	else {
+	    if (def->name==NULL) {
+		if ((def->value==NULL)||(def->value->op==ExprKeysymList))
+		     field.str= "symbols";
+		else field.str= "actions";
+		arrayNdx= NULL;
+	    }
+	    else {
+		ok= ExprResolveLhs(def->name,&tmp,&field,&arrayNdx);
+	    }
+	    if (ok)
+		ok= SetSymbolsField(key,xkb,field.str,arrayNdx,def->value,info);
+	}
+    }
+    return ok;
+}
+
+static int
+#if NeedFunctionPrototypes
+HandleSymbolsDef(	SymbolsDef *	stmt,
+			XkbDescPtr 	xkb,
+			unsigned 	merge,
+			SymbolsInfo *	info)
+#else
+HandleSymbolsDef(stmt,xkb,merge,info)
+    SymbolsDef *	stmt;
+    XkbDescPtr		xkb;
+    unsigned 		merge;
+    SymbolsInfo *	info;
+#endif
+{
+KeyInfo			key;
+ 
+    InitKeyInfo(&key);
+    CopyKeyInfo(&info->dflt,&key,False);
+    key.defs.merge= stmt->merge;
+    key.name= KeyNameToLong(stmt->keyName);
+    if (!HandleSymbolsBody((VarDef *)stmt->symbols,xkb,&key,info)) {
+	info->errorCount++;
+	return False;
+    }
+
+    if (!AddKeySymbols(info,&key)) {
+	info->errorCount++;
+	return False;
+    }
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+HandleModMapDef(	ModMapDef *	def,
+			XkbDescPtr	xkb,
+			unsigned	merge,
+			SymbolsInfo *	info)
+#else
+HandleModMapDef(def,xkb,merge,info)
+    ModMapDef *		def;
+    XkbDescPtr		xkb;
+    unsigned		merge;
+    SymbolsInfo *	info;
+#endif
+{
+ExprDef	*	key;
+ModMapEntry	tmp;
+ExprResult	rtrn;
+Bool 		ok;
+
+    if (!LookupModIndex(NULL,None,def->modifier,TypeInt,&rtrn)) {
+	ERROR("Illegal modifier map definition\n");
+	ACTION1("Ignoring map for non-modifier \"%s\"\n",
+				XkbAtomText(NULL,def->modifier,XkbMessage));
+	return False;
+    }
+    ok= True;
+    tmp.modifier= rtrn.uval;
+    for (key=def->keys;key!=NULL;key=(ExprDef *)key->common.next) {
+	if ((key->op==ExprValue)&&(key->type==TypeKeyName)) {
+	    tmp.haveSymbol= False;
+	    tmp.u.keyName= KeyNameToLong(key->value.keyName);
+	}
+	else if (ExprResolveKeySym(key,&rtrn,NULL,NULL)) {
+	    tmp.haveSymbol= True;
+	    tmp.u.keySym= rtrn.uval;
+	}
+	else {
+	    ERROR("Modmap entries may contain only key names or keysyms\n");
+	    ACTION1("Illegal definition for %s modifier ignored\n",
+				XkbModIndexText(tmp.modifier,XkbMessage));
+	    continue;
+	}
+
+	ok= AddModMapEntry(info,&tmp)&&ok;
+    }
+    return ok;
+}
+
+static void
+#if NeedFunctionPrototypes
+HandleSymbolsFile(	XkbFile	*	file,
+			XkbDescPtr	xkb,
+			unsigned	merge,
+			SymbolsInfo *	info)
+#else
+HandleSymbolsFile(file,xkb,merge,info)
+    XkbFile	*	file;
+    XkbDescPtr	 	xkb;
+    unsigned		merge;
+    SymbolsInfo	*	info;
+#endif
+{
+ParseCommon	*stmt;
+
+    info->name= file->name;
+    stmt= file->defs;
+    while (stmt) {
+	switch (stmt->stmtType) {
+	    case StmtInclude:
+		if (!HandleIncludeSymbols((IncludeStmt *)stmt,xkb,info,
+						HandleSymbolsFile))
+		    info->errorCount++;
+		break;
+	    case StmtSymbolsDef:
+		if (!HandleSymbolsDef((SymbolsDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    case StmtVarDef:
+		if (!HandleSymbolsVar((VarDef *)stmt,xkb,info))
+		    info->errorCount++;
+		break;
+	    case StmtVModDef:
+		if (!HandleVModDef((VModDef *)stmt,merge,&info->vmods))
+		    info->errorCount++;
+		break;
+	    case StmtInterpDef:
+		ERROR("Interpretation files may not include other types\n");
+		ACTION("Ignoring definition of symbol interpretation\n");
+		info->errorCount++;
+		break;
+	    case StmtKeycodeDef:
+		ERROR("Interpretation files may not include other types\n");
+		ACTION("Ignoring definition of key name\n");
+		info->errorCount++;
+		break;
+	    case StmtModMapDef:
+		if (!HandleModMapDef((ModMapDef *)stmt,xkb,merge,info))
+		    info->errorCount++;
+		break;
+	    default:
+		WSGO1("Unexpected statement type %d in HandleSymbolsFile\n",
+			stmt->stmtType);
+		break;
+	}
+	stmt= stmt->next;
+	if (info->errorCount>10) {
+#ifdef NOISY
+	    ERROR("Too many errors\n");
+#endif
+	    ACTION1("Abandoning symbols file \"%s\"\n",file->topName);
+	    break;
+	}
+    }
+    return;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+FindKeyForSymbol(XkbDescPtr xkb,KeySym sym,unsigned int *kc_rtrn)
+#else
+FindKeyForSymbol(xkb,sym,kc_rtrn)
+    XkbDescPtr		xkb;
+    KeySym		sym;
+    unsigned int *	kc_rtrn;
+#endif
+{
+register int 	i, j;
+register Bool	gotOne;
+
+    j= 0;
+    do {
+        gotOne= False;
+        for (i = xkb->min_key_code; i <= (int)xkb->max_key_code; i++) {
+            if ( j<(int)XkbKeyNumSyms(xkb,i) ) {
+                gotOne = True;
+                if ((XkbKeySym(xkb,i,j)==sym)) {
+		    *kc_rtrn= i;
+                    return True;
+		}
+            }
+        }
+        j++;
+    } while (gotOne);
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+FindNamedType(XkbDescPtr xkb,Atom name,unsigned *type_rtrn)
+#else
+FindNamedType(xkb,name,type_rtrn)
+    XkbDescPtr		xkb;
+    Atom		name;
+    unsigned *		type_rtrn;
+#endif
+{
+register unsigned n;
+
+    if (xkb&&xkb->map&&xkb->map->types) {
+	for (n=0;n<xkb->map->num_types;n++) {
+	    if (xkb->map->types[n].name==(Atom)name) {
+		*type_rtrn= n;
+		return True;
+	    }
+	}
+    }
+    return False;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+FindAutomaticType(int width,KeySym *syms,Atom *typeNameRtrn)
+#else
+FindAutomaticType(width,syms,typeNameRtrn)
+    int		width;
+    KeySym *	syms;
+    Atom *	typeNameRtrn;
+#endif
+{
+    if ((width==1)||(width==0))
+	 *typeNameRtrn= XkbInternAtom(NULL,"ONE_LEVEL",False);
+    else if ( syms && XkbKSIsLower(syms[0]) && XkbKSIsUpper(syms[1]) )
+	 *typeNameRtrn= XkbInternAtom(NULL,"ALPHABETIC",False);
+    else if ( syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])) ) 
+	 *typeNameRtrn= XkbInternAtom(NULL,"KEYPAD",False);
+    else *typeNameRtrn= XkbInternAtom(NULL,"TWO_LEVEL",False);
+    return ((width>=0)&&(width<=2));
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopySymbolsDef(XkbFileInfo *result,KeyInfo *key,int start_from)
+#else
+CopySymbolsDef(result,key,start_from)
+    XkbFileInfo *	result;
+    KeyInfo *		key;
+    int			start_from;
+#endif
+{
+register int	i;
+unsigned	okc,kc,width,tmp,nGroups;
+XkbKeyTypePtr	type;
+Bool		haveActions,autoType,useAlias;
+KeySym *	outSyms;
+XkbAction *	outActs;
+XkbDescPtr	xkb;
+unsigned	types[XkbNumKbdGroups];
+
+    xkb= result->xkb;
+    useAlias= (start_from==0);
+    if (!FindNamedKey(xkb,key->name,&kc,useAlias,CreateKeyNames(xkb),
+								start_from)) {
+	if ((start_from==0)&&(warningLevel>=5)) {
+	    WARN2("Key %s not found in %s keycodes\n",
+	    		longText(key->name,XkbMessage),
+			XkbAtomText(NULL,xkb->names->keycodes,XkbMessage));
+	    ACTION("Symbols ignored\n");
+	}
+	return False;
+    }
+
+    haveActions= False;
+    for (i=width=nGroups=0;i<XkbNumKbdGroups;i++) {
+	if (((i+1)>nGroups)&&(((key->symsDefined|key->actsDefined)&(1<<i))||
+						(key->typesDefined)&(1<<i))) 
+	    nGroups= i+1;
+	if (key->acts[i])
+	    haveActions= True;
+	autoType= False;
+	if (key->types[i]==None) {
+	    if (key->dfltType!=None)
+		key->types[i]= key->dfltType;
+	    else if (FindAutomaticType(key->numLevels[i],key->syms[i],
+  							&key->types[i])) {
+		autoType= True;
+	    }
+	    else {
+		if (warningLevel>=5) {
+		    WARN1("No automatic type for %d symbols\n",
+						(unsigned int)key->numLevels[i]);
+		    ACTION3("Using %s for the %s key (keycode %d)\n",
+				XkbAtomText(NULL,key->types[i],XkbMessage),
+				longText(key->name,XkbMessage),kc);
+		}
+	    }
+	}
+	if (FindNamedType(xkb,key->types[i],&types[i]))  {
+	    if (!autoType)
+		xkb->server->explicit[kc]|= (1<<i);
+	}
+	else {
+	    if (warningLevel>=3) {
+		WARN1("Type \"%s\" is not defined\n",
+	    			XkbAtomText(NULL,key->types[i],XkbMessage));
+		ACTION2("Using TWO_LEVEL for the %s key (keycode %d)\n",
+					longText(key->name,XkbMessage),kc);
+	    }
+	    types[i]= XkbTwoLevelIndex;
+	}
+	type= &xkb->map->types[types[i]];
+	if (type->num_levels<key->numLevels[i]) {
+	    if (warningLevel>0) {
+		WARN4("Type \"%s\" has %d levels, but %s has %d symbols\n",
+					XkbAtomText(NULL,type->name,XkbMessage),
+					(unsigned int)type->num_levels,
+					longText(key->name,XkbMessage),
+					(unsigned int)key->numLevels[i]);
+		ACTION("Ignoring extra symbols\n");
+	    }
+	    key->numLevels[i]= type->num_levels;
+	}
+	if (key->numLevels[i]>width)
+	    width= key->numLevels[i];
+	if (type->num_levels>width)
+	    width= type->num_levels;
+    }
+
+    i= width*nGroups;
+    outSyms= XkbResizeKeySyms(xkb,kc,i);
+    if (outSyms==NULL) {
+	WSGO2("Could not enlarge symbols for %s (keycode %d)\n",
+					longText(key->name,XkbMessage),kc);
+	return False;
+    }
+    if (haveActions) {
+	outActs= XkbResizeKeyActions(xkb,kc,i);
+	if (outActs==NULL) {
+		WSGO2("Could not enlarge actions for %s (key %d)\n",
+					longText(key->name,XkbMessage),kc);
+		return False;
+	}
+	xkb->server->explicit[kc]|= XkbExplicitInterpretMask;
+    }
+    else outActs= NULL;
+    if (key->defs.defined&_Key_GroupInfo)
+	 i= key->groupInfo;
+    else i= xkb->map->key_sym_map[kc].group_info;
+    xkb->map->key_sym_map[kc].group_info= XkbSetNumGroups(i,nGroups);
+    xkb->map->key_sym_map[kc].width= width;
+    for (i=0;i<nGroups;i++) {
+	xkb->map->key_sym_map[kc].kt_index[i]= types[i];
+	if (key->syms[i]!=NULL) {
+	    for (tmp=0;tmp<width;tmp++) {
+		if (tmp<key->numLevels[i])
+		     outSyms[tmp]= key->syms[i][tmp];
+		else outSyms[tmp]= NoSymbol;
+		if ((outActs!=NULL)&&(key->acts[i]!=NULL)) {
+		    if (tmp<key->numLevels[i])
+			 outActs[tmp]= key->acts[i][tmp];
+		    else outActs[tmp].type= XkbSA_NoAction;
+		}
+	    }
+	}
+	outSyms+= width;
+	if (outActs)
+	    outActs+= width;
+    }
+    switch (key->behavior.type&XkbKB_OpMask) {
+	case XkbKB_Default:
+	    break;
+	case XkbKB_Overlay1: 
+	case XkbKB_Overlay2:
+	    /* find key by name! */
+	    if (!FindNamedKey(xkb,key->nameForOverlayKey,&okc,True,
+    						CreateKeyNames(xkb),0)) {
+		if (warningLevel>=1) {
+		    WARN2("Key %s not found in %s keycodes\n",
+			longText(key->nameForOverlayKey,XkbMessage),
+			XkbAtomText(NULL,xkb->names->keycodes,XkbMessage));
+		    ACTION1("Not treating %s as an overlay key \n",
+					longText(key->name,XkbMessage));
+		}
+		break;
+	    }
+	    key->behavior.data= okc;
+	default:
+	    xkb->server->behaviors[kc]= key->behavior;
+	    xkb->server->explicit[kc]|= XkbExplicitBehaviorMask;
+	    break;
+    }
+    if (key->defs.defined&_Key_VModMap) {
+	xkb->server->vmodmap[kc]= key->vmodmap;
+	xkb->server->explicit[kc]|= XkbExplicitVModMapMask;
+    }
+    if (key->repeat!=RepeatUndefined) {
+	if (key->repeat==RepeatYes)
+	     xkb->ctrls->per_key_repeat[kc/8]|= (1<<(kc%8));
+	else xkb->ctrls->per_key_repeat[kc/8]&= ~(1<<(kc%8));
+	xkb->server->explicit[kc]|= XkbExplicitAutoRepeatMask;
+    }
+    CopySymbolsDef(result,key,kc+1);
+    return True;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+CopyModMapDef(XkbFileInfo *result,ModMapEntry *entry)
+#else
+CopyModMapDef(result,entry)
+    XkbFileInfo *	result;
+    ModMapEntry *	entry;
+#endif
+{
+unsigned	kc;
+XkbDescPtr	xkb;
+
+    xkb= result->xkb;
+    if ((!entry->haveSymbol)&&(!FindNamedKey(xkb,entry->u.keyName,&kc,True,
+    						CreateKeyNames(xkb),0))) {
+	if (warningLevel>=5) {
+	    WARN2("Key %s not found in %s keycodes\n",
+			longText(entry->u.keyName,XkbMessage),
+			XkbAtomText(NULL,xkb->names->keycodes,XkbMessage));
+	    ACTION1("Modifier map entry for %s not updated\n",
+				XkbModIndexText(entry->modifier,XkbMessage));
+	}
+	return False;
+    }
+    else if (entry->haveSymbol&&(!FindKeyForSymbol(xkb,entry->u.keySym,&kc))) {
+	if (warningLevel>5) {
+	    WARN2("Key \"%s\" not found in %s symbol map\n",
+			XkbKeysymText(entry->u.keySym,XkbMessage),
+			XkbAtomText(NULL,xkb->names->symbols,XkbMessage));
+	    ACTION1("Modifier map entry for %s not updated\n",
+				XkbModIndexText(entry->modifier,XkbMessage));
+	}
+	return False;
+    }
+    xkb->map->modmap[kc]|= (1<<entry->modifier);
+    return True;
+}
+
+Bool
+#if NeedFunctionPrototypes
+CompileSymbols(XkbFile *file,XkbFileInfo *result,unsigned merge)
+#else
+CompileSymbols(file,result,merge)
+    XkbFile *		file;
+    XkbFileInfo *	result;
+    unsigned	 	merge;
+#endif
+{
+register int	i;
+SymbolsInfo	info;
+XkbDescPtr	xkb;
+
+    xkb= result->xkb;
+    InitSymbolsInfo(&info,xkb);
+    info.dflt.defs.fileID= file->id;
+    info.dflt.defs.merge= merge;
+    HandleSymbolsFile(file,xkb,merge,&info);
+
+    if (info.errorCount==0) {
+	KeyInfo *key;
+	if (XkbAllocNames(xkb,XkbSymbolsNameMask|XkbGroupNamesMask,0,0)
+								!=Success) {
+	    WSGO("Can not allocate names in CompileSymbols\n");
+	    ACTION("Symbols not added\n");
+	    return False;
+	}
+	if(XkbAllocClientMap(xkb,XkbKeySymsMask|XkbModifierMapMask,0)!=Success){
+	    WSGO("Could not allocate client map in CompileSymbols\n");
+	    ACTION("Symbols not added\n");
+	    return False;
+	}
+	if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,32)!=Success) {
+	    WSGO("Could not allocate server map in CompileSymbols\n");
+	    ACTION("Symbols not added\n");
+	    return False;
+	}
+	if (XkbAllocControls(xkb,XkbPerKeyRepeatMask)!=Success) {
+	    WSGO("Could not allocate controls in CompileSymbols\n");
+	    ACTION("Symbols not added\n");
+	    return False;
+	}
+	xkb->names->symbols= XkbInternAtom(xkb->dpy,info.name,False);
+	if (info.aliases)
+	    ApplyAliases(xkb,False,&info.aliases);
+	for (i=0;i<XkbNumKbdGroups;i++) {
+	    if (info.groupNames[i]!=None)
+		xkb->names->groups[i]= info.groupNames[i];
+	}
+	for (key=info.keys,i=0;i<info.nKeys;i++,key++) {
+	    if (!CopySymbolsDef(result,key,0))
+		info.errorCount++;
+	}
+	if (warningLevel>3) {
+	    for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
+		if (xkb->names->keys[i].name[0]=='\0')
+		    continue;
+		if (XkbKeyNumGroups(xkb,i)<1) {
+		    char buf[5];
+		    memcpy(buf,xkb->names->keys[i].name,4);
+		    buf[4]= '\0';
+		    WARN2("No symbols defined for <%s> (keycode %d)\n",buf,i);
+		}
+	    }
+	}
+	if (info.modMap) {
+	    ModMapEntry	*mm,*next;
+	    for (mm=info.modMap;mm!=NULL;mm=next) {
+		if (!CopyModMapDef(result,mm))
+		    info.errorCount++;
+		next= (ModMapEntry *)mm->defs.next;
+	    }
+	}
+	return True;
+    }
+    return False;
+}
diff --git a/tokens.h b/tokens.h
new file mode 100644
index 0000000..c63c393
--- /dev/null
+++ b/tokens.h
@@ -0,0 +1,100 @@
+/* $Xorg: tokens.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 TOKENS_H
+#define	TOKENS_H 1
+
+#define	END_OF_FILE	0
+#define	ERROR_TOK	255
+
+#define	XKB_KEYMAP	1
+#define	XKB_KEYCODES	2
+#define	XKB_TYPES	3
+#define	XKB_SYMBOLS	4
+#define	XKB_COMPATMAP	5
+#define	XKB_GEOMETRY	6
+#define	XKB_SEMANTICS	7
+#define	XKB_LAYOUT	8
+
+#define	INCLUDE		10
+#define	OVERRIDE	11
+#define	AUGMENT		12
+#define	REPLACE		13
+#define	ALTERNATE	14
+
+#define	VIRTUAL_MODS	20
+#define	TYPE		21
+#define	INTERPRET	22
+#define	ACTION_TOK	23
+#define	KEY		24
+#define	ALIAS		25
+#define	GROUP		26
+#define	MODIFIER_MAP	27
+#define	INDICATOR	28
+#define	SHAPE		29
+#define	KEYS		30
+#define	ROW		31
+#define	SECTION		32
+#define	OVERLAY		33
+#define	TEXT		34
+#define	OUTLINE		35
+#define	SOLID		36
+#define	LOGO		37
+#define	VIRTUAL		38
+
+#define	EQUALS		40
+#define	PLUS		41
+#define	MINUS		42
+#define	DIVIDE		43
+#define	TIMES		44
+#define	OBRACE		45
+#define	CBRACE		46
+#define	OPAREN		47
+#define	CPAREN		48
+#define	OBRACKET	49
+#define	CBRACKET	50
+#define	DOT		51
+#define	COMMA		52
+#define	SEMI		53
+#define	EXCLAM		54
+#define	INVERT		55
+
+#define	STRING		60
+#define	INTEGER		61
+#define	FLOAT		62
+#define	IDENT		63
+#define	KEYNAME		64
+
+#define	PARTIAL		70
+#define	DEFAULT		71
+#define	HIDDEN		72
+#define	ALPHANUMERIC_KEYS	73
+#define	MODIFIER_KEYS		74
+#define	KEYPAD_KEYS		75
+#define	FUNCTION_KEYS		76
+#define	ALTERNATE_GROUP		77
+
+#endif
diff --git a/utils.c b/utils.c
new file mode 100644
index 0000000..37058c7
--- /dev/null
+++ b/utils.c
@@ -0,0 +1,530 @@
+
+  /*\
+   * $Xorg: utils.c,v 1.4 2000/08/17 19:54:33 cpqbld Exp $
+   *
+   *		              COPYRIGHT 1990
+   *		        DIGITAL EQUIPMENT CORPORATION
+   *		           MAYNARD, MASSACHUSETTS
+   *			    ALL RIGHTS RESERVED.
+   *
+   * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
+   * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
+   * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE 
+   * FOR ANY PURPOSE.  IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED 
+   * WARRANTY.
+   *
+   * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
+   * RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
+   * ADDITION TO THAT SET FORTH ABOVE.
+   *
+   * 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 Digital Equipment Corporation not be
+   * used in advertising or publicity pertaining to distribution of the 
+   * software without specific, written prior permission.
+  \*/
+
+#include 	"utils.h"
+#include	<ctype.h>
+#ifndef X_NOT_STDC_ENV
+#include <stdlib.h>
+#else
+char *malloc();
+#endif
+
+/***====================================================================***/
+
+Opaque
+#if NeedFunctionPrototypes
+uAlloc(unsigned size)
+#else
+uAlloc(size)
+    unsigned	size;
+#endif
+{
+    return((Opaque)malloc(size));
+}
+
+/***====================================================================***/
+
+Opaque
+#if NeedFunctionPrototypes
+uCalloc(unsigned n,unsigned size)
+#else
+uCalloc(n,size)
+    unsigned	n;
+    unsigned	size;
+#endif
+{
+    return((Opaque)calloc(n,size));
+}
+
+/***====================================================================***/
+
+Opaque
+#if NeedFunctionPrototypes
+uRealloc(Opaque old,unsigned newSize)
+#else
+uRealloc(old,newSize)
+    Opaque	old;
+    unsigned	newSize;
+#endif
+{
+    if (old==NULL)
+	 return((Opaque)malloc(newSize));
+    else return((Opaque)realloc((char *)old,newSize));
+}
+
+/***====================================================================***/
+
+Opaque
+#if NeedFunctionPrototypes
+uRecalloc(Opaque old,unsigned nOld,unsigned nNew,unsigned itemSize)
+#else
+uRecalloc(old,nOld,nNew,itemSize)
+    Opaque	old;
+    unsigned	nOld;
+    unsigned	nNew;
+    unsigned	itemSize;
+#endif
+{
+char *rtrn;
+
+    if (old==NULL)
+	 rtrn= (char *)calloc(nNew,itemSize);
+    else {
+	rtrn= (char *)realloc((char *)old,nNew*itemSize);
+   	if ((rtrn)&&(nNew>nOld)) {
+	    bzero(&rtrn[nOld*itemSize],(nNew-nOld)*itemSize);
+	}
+    }
+    return (Opaque)rtrn;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uFree(Opaque ptr)
+#else
+uFree(ptr)
+    Opaque ptr;
+#endif
+{
+    if (ptr!=(Opaque)NULL)
+	free((char *)ptr);
+    return;
+}
+
+/***====================================================================***/
+/***                  FUNCTION ENTRY TRACKING                           ***/
+/***====================================================================***/
+
+static	FILE	*entryFile=	stderr;
+	int	 uEntryLevel;
+
+Boolean
+#if NeedFunctionPrototypes
+uSetEntryFile(char *name)
+#else
+uSetEntryFile(name)
+    char *name;
+#endif
+{
+    if ((entryFile!=NULL)&&(entryFile!=stderr)) {
+	fprintf(entryFile,"switching to %s\n",name?name:"stderr");
+	fclose(entryFile);
+    }
+    if (name!=NullString)	entryFile=	fopen(name,"w");
+    else			entryFile=	stderr;
+    if (entryFile==NULL) {
+	entryFile=	stderr;
+	return(False);
+    }
+    return(True);
+}
+
+void
+#if NeedFunctionPrototypes
+uEntry(int l,char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,
+								Opaque a6)
+#else
+uEntry(l,s,a1,a2,a3,a4,a5,a6)
+int	l;
+char	*s;
+Opaque	a1,a2,a3,a4,a5,a6;
+#endif
+{
+int	i;
+
+    for (i=0;i<uEntryLevel;i++) {
+	putc(' ',entryFile);
+    }
+    fprintf(entryFile,s,a1,a2,a3,a4,a5,a6);
+    uEntryLevel+= l;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uExit(int l,char *rtVal)
+#else
+uExit(l,rtVal)
+    int		l;
+    char *	rtVal;
+#endif
+{
+int	i;
+
+    uEntryLevel-= l;
+    if (uEntryLevel<0)	uEntryLevel=	0;
+    for (i=0;i<uEntryLevel;i++) {
+	putc(' ',entryFile);
+    }
+    fprintf(entryFile,"---> 0x%x\n",rtVal);
+    return;
+}
+
+/***====================================================================***/
+/***			PRINT FUNCTIONS					***/
+/***====================================================================***/
+
+	FILE	*uDebugFile=		stderr;
+	int	 uDebugIndentLevel=	0;
+	int	 uDebugIndentSize=	4;
+
+Boolean
+#if NeedFunctionPrototypes
+uSetDebugFile(char *name)
+#else
+uSetDebugFile(name)
+    char *name;
+#endif
+{
+    if ((uDebugFile!=NULL)&&(uDebugFile!=stderr)) {
+	fprintf(uDebugFile,"switching to %s\n",name?name:"stderr");
+	fclose(uDebugFile);
+    }
+    if (name!=NullString)	uDebugFile=	fopen(name,"w");
+    else			uDebugFile=	stderr;
+    if (uDebugFile==NULL) {
+	uDebugFile=	stderr;
+	return(False);
+    }
+    return(True);
+}
+
+void
+#if NeedFunctionPrototypes
+uDebug(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uDebug(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+int	i;
+
+    for (i=(uDebugIndentLevel*uDebugIndentSize);i>0;i--) {
+	putc(' ',uDebugFile);
+    }
+    fprintf(uDebugFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(uDebugFile);
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uDebugNOI(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uDebugNOI(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    fprintf(uDebugFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(uDebugFile);
+    return;
+}
+
+/***====================================================================***/
+
+static	FILE	*errorFile=	stderr;
+static	int	 outCount=	0;
+static	char	*preMsg=	NULL;
+static	char	*postMsg=	NULL;
+static	char	*prefix=	NULL;
+
+Boolean
+#if NeedFunctionPrototypes
+uSetErrorFile(char *name)
+#else
+uSetErrorFile(name)
+    char *name;
+#endif
+{
+    if ((errorFile!=NULL)&&(errorFile!=stderr)) {
+	fprintf(errorFile,"switching to %s\n",name?name:"stderr");
+	fclose(errorFile);
+    }
+    if (name!=NullString)	errorFile=	fopen(name,"w");
+    else			errorFile=	stderr;
+    if (errorFile==NULL) {
+	errorFile=	stderr;
+	return(False);
+    }
+    return(True);
+}
+
+void
+#if NeedFunctionPrototypes
+uInformation(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,
+								Opaque a6)
+#else
+uInformation(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(errorFile);
+    return;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uAction(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uAction(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    if (prefix!=NULL)
+	fprintf(errorFile,"%s",prefix);
+    fprintf(errorFile,"                  ");
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(errorFile);
+    return;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uWarning(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uWarning(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    if ((outCount==0)&&(preMsg!=NULL))
+	fprintf(errorFile,"%s\n",preMsg);
+    if (prefix!=NULL)
+	fprintf(errorFile,"%s",prefix);
+    fprintf(errorFile,"Warning:          ");
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(errorFile);
+    outCount++;
+    return;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uError(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uError(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    if ((outCount==0)&&(preMsg!=NULL))
+	fprintf(errorFile,"%s\n",preMsg);
+    if (prefix!=NULL)
+	fprintf(errorFile,"%s",prefix);
+    fprintf(errorFile,"Error:            ");
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(errorFile);
+    outCount++;
+    return;
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uFatalError(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,Opaque a6)
+#else
+uFatalError(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    if ((outCount==0)&&(preMsg!=NULL))
+	fprintf(errorFile,"%s\n",preMsg);
+    if (prefix!=NULL)
+	fprintf(errorFile,"%s",prefix);
+    fprintf(errorFile,"Fatal Error:      ");
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fprintf(errorFile,"                  Exiting\n");
+    fflush(errorFile);
+    outCount++;
+    exit(1);
+    /* NOTREACHED */
+}
+
+/***====================================================================***/
+
+void
+#if NeedFunctionPrototypes
+uInternalError(char *s,Opaque a1,Opaque a2,Opaque a3,Opaque a4,Opaque a5,
+								Opaque a6)
+#else
+uInternalError(s,a1,a2,a3,a4,a5,a6)
+char *s;
+Opaque a1,a2,a3,a4,a5,a6;
+#endif
+{
+    if ((outCount==0)&&(preMsg!=NULL))
+	fprintf(errorFile,"%s\n",preMsg);
+    if (prefix!=NULL)
+	fprintf(errorFile,"%s",prefix);
+    fprintf(errorFile,"Internal error:   ");
+    fprintf(errorFile,s,a1,a2,a3,a4,a5,a6);
+    fflush(errorFile);
+    outCount++;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uSetPreErrorMessage(char *msg)
+#else
+uSetPreErrorMessage(msg)
+    char *msg;
+#endif
+{
+    outCount= 0;
+    preMsg= msg;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uSetPostErrorMessage(char *msg)
+#else
+uSetPostErrorMessage(msg)
+    char *msg;
+#endif
+{
+    postMsg= msg;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uSetErrorPrefix(char *pre)
+#else
+uSetErrorPrefix(pre)
+    char *pre;
+#endif
+{
+    prefix= pre;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+uFinishUp(void)
+#else
+uFinishUp()
+#endif
+{
+    if ((outCount>0)&&(postMsg!=NULL))
+	fprintf(errorFile,"%s\n",postMsg);
+    return;
+}
+
+/***====================================================================***/
+
+#ifndef HAVE_STRDUP
+char *
+#if NeedFunctionPrototypes
+uStringDup(char *str)
+#else
+uStringDup(str)
+    char *str;
+#endif
+{
+char *rtrn;
+
+    if (str==NULL)
+	return NULL;
+    rtrn= (char *)uAlloc(strlen(str)+1);
+    strcpy(rtrn,str);
+    return rtrn;
+}
+#endif
+
+#ifndef HAVE_STRCASECMP
+int
+#if NeedFunctionPrototypes
+uStrCaseCmp(char *str1,char *str2)
+#else
+uStrCaseCmp(str1, str2)
+    char *str1, *str2;
+#endif
+{
+    char buf1[512],buf2[512];
+    char c, *s;
+    register int n;
+
+    for (n=0, s = buf1; (c = *str1++); n++) {
+	if (isupper(c))
+	    c = tolower(c);
+	if (n>510)
+	    break;
+	*s++ = c;
+    }
+    *s = '\0';
+    for (n=0, s = buf2; (c = *str2++); n++) {
+	if (isupper(c))
+	    c = tolower(c);
+	if (n>510)
+	    break;
+	*s++ = c;
+    }
+    *s = '\0';
+    return (strcmp(buf1, buf2));
+}
+
+int
+#if NeedFunctionPrototypes
+uStrCasePrefix(char *prefix,char *str)
+#else
+uStrCasePrefix(prefix, str)
+    char *prefix, *str;
+#endif
+{
+    char c1;
+    char c2;
+    while (((c1=*prefix)!='\0')&&((c2=*str)!='\0')) {
+	if (isupper(c1))	c1= tolower(c1);
+	if (isupper(c2))	c2= tolower(c2);
+	if (c1!=c2)
+	    return 0;
+	prefix++; str++;
+    }
+    if (c1!='\0')
+	return 0;
+    return 1;
+}
+
+#endif
diff --git a/utils.h b/utils.h
new file mode 100644
index 0000000..e3a71c9
--- /dev/null
+++ b/utils.h
@@ -0,0 +1,453 @@
+#ifndef UTILS_H
+#define	UTILS_H 1
+
+  /*\
+   * $Xorg: utils.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $
+   *
+   *		              COPYRIGHT 1990
+   *		        DIGITAL EQUIPMENT CORPORATION
+   *		           MAYNARD, MASSACHUSETTS
+   *			    ALL RIGHTS RESERVED.
+   *
+   * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
+   * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
+   * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE 
+   * FOR ANY PURPOSE.  IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED 
+   * WARRANTY.
+   *
+   * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
+   * RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
+   * ADDITION TO THAT SET FORTH ABOVE.
+   *
+   * 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 Digital Equipment Corporation not be
+   * used in advertising or publicity pertaining to distribution of the 
+   * software without specific, written prior permission.
+  \*/
+
+/***====================================================================***/
+
+#include 	<stdio.h>
+#include	<X11/Xos.h>
+#include	<X11/Xfuncproto.h>
+#include	<X11/Xfuncs.h>
+
+#ifndef	NULL
+#define	NULL	0
+#endif
+
+#ifndef NUL
+#define	NUL	'\0'
+#endif
+
+/***====================================================================***/
+
+#ifndef OPAQUE_DEFINED
+typedef	void *Opaque;
+#endif
+#ifndef NullOpaque
+#define	NullOpaque	((Opaque)NULL)
+#endif
+
+#ifndef BOOLEAN_DEFINED
+typedef	char	Boolean;
+#endif
+
+#ifndef True
+#define	True	((Boolean)1)
+#define	False	((Boolean)0)
+#endif /* ndef True */
+#define	booleanText(b)	((b)?"True":"False")
+
+#ifndef COMPARISON_DEFINED
+typedef	int		Comparison;
+
+#define	Greater		((Comparison)1)
+#define	Equal		((Comparison)0)
+#define	Less		((Comparison)-1)
+#define	CannotCompare	((Comparison)-37)
+#define	comparisonText(c)	((c)?((c)<0?"Less":"Greater"):"Equal")
+#endif
+
+_XFUNCPROTOBEGIN
+
+typedef union {
+	int		 i;
+	unsigned	 u;
+	void		*p;
+	void		*(*fp)();
+} Union;
+
+/***====================================================================***/
+
+extern	Opaque	uAlloc(
+#if NeedFunctionPrototypes
+    unsigned	/* size */
+#endif
+);
+extern	Opaque	uCalloc(
+#if NeedFunctionPrototypes
+    unsigned	/* n */,
+    unsigned	/* size */
+#endif
+);
+extern	Opaque	uRealloc(
+#if NeedFunctionPrototypes
+    Opaque	/* old */,
+    unsigned	/* newSize */
+#endif
+);
+extern	Opaque	uRecalloc(
+#if NeedFunctionPrototypes
+    Opaque 	/* old */,
+    unsigned	/* nOld */,
+    unsigned	/* nNew */,
+    unsigned 	/* newSize */
+#endif
+);
+extern	void	uFree(
+#if NeedFunctionPrototypes
+    Opaque	/* ptr */
+#endif
+);
+
+#define	uTypedAlloc(t)		((t *)uAlloc((unsigned)sizeof(t)))
+#define	uTypedCalloc(n,t)	((t *)uCalloc((unsigned)n,(unsigned)sizeof(t)))
+#define	uTypedRealloc(pO,n,t)	((t *)uRealloc((Opaque)pO,((unsigned)n)*sizeof(t)))
+#define	uTypedRecalloc(pO,o,n,t) ((t *)uRecalloc((Opaque)pO,((unsigned)o),((unsigned)n),sizeof(t)))
+#if (defined mdHasAlloca) && (mdHasAlloca)
+#define	uTmpAlloc(n)	((Opaque)alloca((unsigned)n))
+#define	uTmpFree(p)
+#else
+#define	uTmpAlloc(n)	uAlloc(n)
+#define	uTmpFree(p)	uFree(p)
+#endif
+
+/***====================================================================***/
+
+extern	Boolean	uSetErrorFile(
+#if NeedFunctionPrototypes
+	char *	/* name */
+#endif
+);
+
+#define	INFO6(s,a,b,c,d,e,f)	uInformation((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	INFO5(s,a,b,c,d,e)	INFO6(s,a,b,c,d,e,NULL)
+#define	INFO4(s,a,b,c,d)	INFO5(s,a,b,c,d,NULL)
+#define	INFO3(s,a,b,c)		INFO4(s,a,b,c,NULL)
+#define	INFO2(s,a,b)		INFO3(s,a,b,NULL)
+#define	INFO1(s,a)		INFO2(s,a,NULL)
+#define	INFO(s)			INFO1(s,NULL)
+
+extern	void	uInformation(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+#define	ACTION6(s,a,b,c,d,e,f)	uAction((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	ACTION5(s,a,b,c,d,e)	ACTION6(s,a,b,c,d,e,NULL)
+#define	ACTION4(s,a,b,c,d)	ACTION5(s,a,b,c,d,NULL)
+#define	ACTION3(s,a,b,c)	ACTION4(s,a,b,c,NULL)
+#define	ACTION2(s,a,b)		ACTION3(s,a,b,NULL)
+#define	ACTION1(s,a)		ACTION2(s,a,NULL)
+#define	ACTION(s)		ACTION1(s,NULL)
+extern	void	uAction(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+#define	WARN6(s,a,b,c,d,e,f)	uWarning((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	WARN5(s,a,b,c,d,e)	WARN6(s,a,b,c,d,e,NULL)
+#define	WARN4(s,a,b,c,d)	WARN5(s,a,b,c,d,NULL)
+#define	WARN3(s,a,b,c)		WARN4(s,a,b,c,NULL)
+#define	WARN2(s,a,b)		WARN3(s,a,b,NULL)
+#define	WARN1(s,a)		WARN2(s,a,NULL)
+#define	WARN(s)			WARN1(s,NULL)
+extern	void	uWarning(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+#define	ERROR6(s,a,b,c,d,e,f)	uError((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	ERROR5(s,a,b,c,d,e)	ERROR6(s,a,b,c,d,e,NULL)
+#define	ERROR4(s,a,b,c,d)	ERROR5(s,a,b,c,d,NULL)
+#define	ERROR3(s,a,b,c)		ERROR4(s,a,b,c,NULL)
+#define	ERROR2(s,a,b)		ERROR3(s,a,b,NULL)
+#define	ERROR1(s,a)		ERROR2(s,a,NULL)
+#define	ERROR(s)		ERROR1(s,NULL)
+extern	void	uError(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+#define	FATAL6(s,a,b,c,d,e,f)	uFatalError((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	FATAL5(s,a,b,c,d,e)	FATAL6(s,a,b,c,d,e,NULL)
+#define	FATAL4(s,a,b,c,d)	FATAL5(s,a,b,c,d,NULL)
+#define	FATAL3(s,a,b,c)		FATAL4(s,a,b,c,NULL)
+#define	FATAL2(s,a,b)		FATAL3(s,a,b,NULL)
+#define	FATAL1(s,a)		FATAL2(s,a,NULL)
+#define	FATAL(s)		FATAL1(s,NULL)
+extern	void	uFatalError(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+	/* WSGO stands for "Weird Stuff Going On" */
+#define	WSGO6(s,a,b,c,d,e,f)	uInternalError((s),(Opaque)(a),(Opaque)(b),\
+						(Opaque)(c),(Opaque)(d),\
+						(Opaque)(e),(Opaque)(f))
+#define	WSGO5(s,a,b,c,d,e)	WSGO6(s,a,b,c,d,e,NULL)
+#define	WSGO4(s,a,b,c,d)	WSGO5(s,a,b,c,d,NULL)
+#define	WSGO3(s,a,b,c)		WSGO4(s,a,b,c,NULL)
+#define	WSGO2(s,a,b)		WSGO3(s,a,b,NULL)
+#define	WSGO1(s,a)		WSGO2(s,a,NULL)
+#define	WSGO(s)			WSGO1(s,NULL)
+extern	void	uInternalError(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+extern	void	uSetPreErrorMessage(
+#if NeedFunctionPrototypes
+	char * /* msg */
+#endif
+);
+
+extern	void	uSetPostErrorMessage(
+#if NeedFunctionPrototypes
+	char * /* msg */
+#endif
+);
+
+extern	void	uSetErrorPrefix(
+#if NeedFunctionPrototypes
+	char * /* void */
+#endif
+);
+
+extern	void	uFinishUp(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+
+
+/***====================================================================***/
+
+#define	NullString	((char *)NULL)
+
+#define	uStringText(s)		((s)==NullString?"<NullString>":(s))
+#define	uStringEqual(s1,s2)	(uStringCompare(s1,s2)==Equal)
+#define	uStringPrefix(p,s)	(strncmp(p,s,strlen(p))==0)
+#define	uStringCompare(s1,s2)	(strcmp(s1,s2))
+#define	uStrCaseEqual(s1,s2)	(uStrCaseCmp(s1,s2)==0)
+#ifdef HAVE_STRCASECMP
+#define	uStrCaseCmp(s1,s2)	(strcasecmp(s1,s2))
+#define	uStrCasePrefix(p,s)	(strncasecmp(p,s,strlen(p))==0)
+#else
+extern	int uStrCaseCmp(
+#if NeedFunctionPrototypes
+	char *	/* s1 */,
+	char *	/* s2 */
+#endif
+);
+extern	int uStrCasePrefix(
+#if NeedFunctionPrototypes
+	char *	/* p */,
+	char *	/* str */
+#endif
+);
+#endif
+#ifdef HAVE_STRDUP
+#define	uStringDup(s1)		(strdup(s1))
+#else
+extern	char *uStringDup(
+#if NeedFunctionPrototypes
+	char *	/* s1 */
+#endif
+);
+#endif
+
+/***====================================================================***/
+
+#ifdef	ASSERTIONS_ON
+#define	uASSERT(where,why) \
+	{if (!(why)) uFatalError("assertion botched in %s ( why )\n",where);}
+#else
+#define	uASSERT(where,why)
+#endif
+
+/***====================================================================***/
+
+#ifndef DEBUG_VAR
+#define	DEBUG_VAR	debugFlags
+#endif
+
+#ifdef DEBUG_VAR_NOT_LOCAL
+extern
+#endif
+unsigned	int	DEBUG_VAR;
+
+extern	void	uDebug(
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+extern	void	uDebugNOI(	/* no indent */
+#if NeedFunctionPrototypes
+	char * /* s  */,
+	Opaque /* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque /* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+extern	Boolean	uSetDebugFile(
+#if NeedFunctionPrototypes
+    char *name
+#endif
+);
+
+extern	FILE	*uDebugFile;
+extern	int	uDebugIndentLevel;
+extern	int	uDebugIndentSize;
+#define	uDebugIndent(l)		(uDebugIndentLevel+=(l))
+#define	uDebugOutdent(l)	(uDebugIndentLevel-=(l))
+#ifdef DEBUG_ON
+#define	uDEBUG(f,s)		{ if (DEBUG_VAR&(f)) uDebug(s);}
+#define	uDEBUG1(f,s,a)		{ if (DEBUG_VAR&(f)) uDebug(s,a);}
+#define	uDEBUG2(f,s,a,b)	{ if (DEBUG_VAR&(f)) uDebug(s,a,b);}
+#define	uDEBUG3(f,s,a,b,c)	{ if (DEBUG_VAR&(f)) uDebug(s,a,b,c);}
+#define	uDEBUG4(f,s,a,b,c,d)	{ if (DEBUG_VAR&(f)) uDebug(s,a,b,c,d);}
+#define	uDEBUG5(f,s,a,b,c,d,e)	{ if (DEBUG_VAR&(f)) uDebug(s,a,b,c,d,e);}
+#define	uDEBUG_NOI(f,s)		{ if (DEBUG_VAR&(f)) uDebug(s);}
+#define	uDEBUG_NOI1(f,s,a)	{ if (DEBUG_VAR&(f)) uDebugNOI(s,a);}
+#define	uDEBUG_NOI2(f,s,a,b)	{ if (DEBUG_VAR&(f)) uDebugNOI(s,a,b);}
+#define	uDEBUG_NOI3(f,s,a,b,c)	{ if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c);}
+#define	uDEBUG_NOI4(f,s,a,b,c,d) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c,d);}
+#define	uDEBUG_NOI5(f,s,a,b,c,d,e) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c,d,e);}
+#else
+#define	uDEBUG(f,s)
+#define	uDEBUG1(f,s,a)
+#define	uDEBUG2(f,s,a,b)
+#define	uDEBUG3(f,s,a,b,c)
+#define	uDEBUG4(f,s,a,b,c,d)
+#define	uDEBUG5(f,s,a,b,c,d,e)
+#define	uDEBUG_NOI(f,s)
+#define	uDEBUG_NOI1(f,s,a)
+#define	uDEBUG_NOI2(f,s,a,b)
+#define	uDEBUG_NOI3(f,s,a,b,c)
+#define	uDEBUG_NOI4(f,s,a,b,c,d)
+#define	uDEBUG_NOI5(f,s,a,b,c,d,e)
+#endif
+
+extern	Boolean	uSetEntryFile(
+#if NeedFunctionPrototypes
+    char *name
+#endif
+);
+extern	void	uEntry(
+#if NeedFunctionPrototypes
+	int	/* l */,
+	char *	/* s  */,
+	Opaque	/* a1 */,Opaque /* a2 */,Opaque /* a3 */,
+	Opaque	/* a4 */,Opaque /* a5 */,Opaque /* a6 */
+#endif
+);
+
+extern	void	uExit(
+#if NeedFunctionPrototypes
+    int l,char *rtVal
+#endif
+);
+#ifdef ENTRY_TRACKING_ON
+#define	ENTRY_BIT	0x10
+#define	LOW_ENTRY_BIT	0x1000
+#define	ENTER	(DEBUG_VAR&ENTRY_BIT)
+#define	FLAG(fLag)	(DEBUG_VAR&(fLag))
+
+extern	int	uEntryLevel;
+
+#define	uENTRY(s)			{ if (ENTER) uEntry(1,s);}
+#define	uENTRY1(s,a)			{ if (ENTER) uEntry(1,s,a);}
+#define	uENTRY2(s,a,b)			{ if (ENTER) uEntry(1,s,a,b);}
+#define	uENTRY3(s,a,b,c)		{ if (ENTER) uEntry(1,s,a,b,c);}
+#define	uENTRY4(s,a,b,c,d)		{ if (ENTER) uEntry(1,s,a,b,c,d);}
+#define	uENTRY5(s,a,b,c,d,e)		{ if (ENTER) uEntry(1,s,a,b,c,d,e);}
+#define	uENTRY6(s,a,b,c,d,e,f)		{ if (ENTER) uEntry(1,s,a,b,c,d,e,f);}
+#define	uENTRY7(s,a,b,c,d,e,f,g)	{ if (ENTER) uEntry(1,s,a,b,c,d,e,f,g);}
+#define	uRETURN(v)			{ if (ENTER) uEntryLevel--; return(v); }
+#define	uVOIDRETURN			{ if (ENTER) uEntryLevel--; return; }
+
+#define	uFLAG_ENTRY(w,s)		{ if (FLAG(w)) uEntry(0,s);}
+#define	uFLAG_ENTRY1(w,s,a)		{ if (FLAG(w)) uEntry(0,s,a);}
+#define	uFLAG_ENTRY2(w,s,a,b)		{ if (FLAG(w)) uEntry(0,s,a,b);}
+#define	uFLAG_ENTRY3(w,s,a,b,c)		{ if (FLAG(w)) uEntry(0,s,a,b,c);}
+#define	uFLAG_ENTRY4(w,s,a,b,c,d)	{ if (FLAG(w)) uEntry(0,s,a,b,c,d);}
+#define	uFLAG_ENTRY5(w,s,a,b,c,d,e)	{ if (FLAG(w)) uEntry(0,s,a,b,c,d,e);}
+#define	uFLAG_ENTRY6(w,s,a,b,c,d,e,f)	{ if (FLAG(w)) uEntry(0,s,a,b,c,d,e,f);}
+#define	uFLAG_ENTRY7(w,s,a,b,c,d,e,f,g)	{ if(FLAG(w))uEntry(0,s,a,b,c,d,e,f,g);}
+#define	uFLAG_RETURN(v)			{ return(v);}
+#define	uFLAG_VOIDRETURN		{ return; }
+#else
+#define	uENTRY(s)
+#define	uENTRY1(s,a)
+#define	uENTRY2(s,a1,a2)
+#define	uENTRY3(s,a1,a2,a3)
+#define	uENTRY4(s,a1,a2,a3,a4)
+#define	uENTRY5(s,a1,a2,a3,a4,a5)
+#define	uENTRY6(s,a1,a2,a3,a4,a5,a6)
+#define	uENTRY7(s,a1,a2,a3,a4,a5,a6,a7)
+#define	uRETURN(v)	{ return(v); }
+#define	uVOIDRETURN	{ return; }
+
+#define	uFLAG_ENTRY(f,s)
+#define	uFLAG_ENTRY1(f,s,a)
+#define	uFLAG_ENTRY2(f,s,a,b)
+#define	uFLAG_ENTRY3(f,s,a,b,c)
+#define	uFLAG_ENTRY4(f,s,a,b,c,d)
+#define	uFLAG_ENTRY5(f,s,a,b,c,d,e)
+#define	uFLAG_ENTRY6(f,s,a,b,c,d,e,g)
+#define	uFLAG_ENTRY7(f,s,a,b,c,d,e,g,h)
+#define	uFLAG_RETURN(v)			{ return(v);}
+#define	uFLAG_VOIDRETURN		{ return; }
+#endif 
+
+_XFUNCPROTOEND
+
+#endif /* UTILS_H */
+
+
diff --git a/vmod.c b/vmod.c
new file mode 100644
index 0000000..b67c34e
--- /dev/null
+++ b/vmod.c
@@ -0,0 +1,271 @@
+/* $Xorg: vmod.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
+
+ Permission to use, copy, modify, and distribute this
+ software and its documentation for any purpose and without
+ fee is hereby granted, provided that the above copyright
+ notice appear in all copies and that both that copyright
+ notice and this permission notice appear in supporting
+ documentation, and that the name of Silicon Graphics not be 
+ used in advertising or publicity pertaining to distribution 
+ of the software without specific prior written permission.
+ Silicon Graphics makes no representation about the suitability 
+ of this software for any purpose. It is provided "as is"
+ without any express or implied warranty.
+ 
+ SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
+ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+ AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+ GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
+ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
+ OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+ THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ ********************************************************/
+#define	DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR debugFlags
+#include <stdio.h>
+#include "xkbcomp.h"
+#include "tokens.h"
+#include "expr.h"
+#include "misc.h"
+
+#include <X11/extensions/XKB.h>
+#include <X11/extensions/XKBstr.h>
+
+#include "vmod.h"
+
+void
+#if NeedFunctionPrototypes
+InitVModInfo(VModInfo *info,XkbDescPtr xkb)
+#else
+InitVModInfo(info,xkb)
+    VModInfo *	info;
+    XkbDescPtr	xkb;
+#endif
+{
+    ClearVModInfo(info,xkb);
+    info->errorCount= 0;
+    return;
+}
+
+void
+#if NeedFunctionPrototypes
+ClearVModInfo(VModInfo *info,XkbDescPtr xkb)
+#else
+ClearVModInfo(info,xkb)
+    VModInfo *	info;
+    XkbDescPtr	xkb;
+#endif
+{
+register int i;
+
+    if (XkbAllocNames(xkb,XkbVirtualModNamesMask,0,0)!=Success)
+	return;
+    if (XkbAllocServerMap(xkb,XkbVirtualModsMask,0)!=Success)
+	return;
+    info->xkb= xkb;
+    info->newlyDefined= info->defined= info->available= 0;
+    if (xkb && xkb->names) {
+	register int bit;
+	for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	    if (xkb->names->vmods[i]!=None)
+		info->defined|= bit;
+	}
+    }
+    return;
+}
+
+/***====================================================================***/
+
+Bool
+#if NeedFunctionPrototypes
+HandleVModDef(VModDef *stmt,unsigned mergeMode,VModInfo *info)
+#else
+HandleVModDef(stmt,mergeMode,info)
+    VModDef *	stmt;
+    unsigned	mergeMode;
+    VModInfo * 	info;
+#endif
+{
+register int 	i,bit,nextFree;
+ExprResult 	mod;
+XkbServerMapPtr	srv;
+XkbNamesPtr	names;
+Atom		stmtName;
+    
+    srv= info->xkb->server;
+    names= info->xkb->names;
+    stmtName= XkbInternAtom(info->xkb->dpy,XkbAtomGetString(NULL,stmt->name),
+    									False);
+    for (i=0,bit=1,nextFree= -1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	if (info->defined&bit) {
+	    if (names->vmods[i]==stmtName) {	/* already defined */
+		info->available|= bit;
+		if (stmt->value==NULL)
+		    return True;
+		else {
+		    char *str1,*str2= "";
+		    if (!ExprResolveModMask(stmt->value,&mod,NULL,NULL)) {
+			str1= XkbAtomText(NULL,stmt->name,XkbMessage);
+			ACTION1("Declaration of %s ignored\n",str1);
+			return False;
+		    }
+		    if (mod.uval==srv->vmods[i])
+			return True;
+
+		    str1= XkbAtomText(NULL,stmt->name,XkbMessage);
+		    WARN1("Virtual modifier %s multiply defined\n",str1);
+		    str1= XkbModMaskText(srv->vmods[i],XkbCFile);
+		    if (mergeMode==MergeOverride) {
+			str2= str1;
+			str1= XkbModMaskText(mod.uval,XkbCFile);
+		    }
+		    ACTION2("Using %s, ignoring %s\n",str1,str2);
+		    if (mergeMode==MergeOverride)
+			srv->vmods[i]= mod.uval;
+		    return True;
+		}
+	    }
+	}
+	else if (nextFree<0)
+	    nextFree= i;
+    }
+    if (nextFree<0) {
+	ERROR1("Too many virtual modifiers defined (maximum %d)\n",
+						XkbNumVirtualMods);
+	ACTION("Exiting\n");
+	return False;
+    }
+    info->defined|= (1<<nextFree);
+    info->newlyDefined|= (1<<nextFree);
+    info->available|= (1<<nextFree);
+    names->vmods[nextFree]= stmtName;
+    if (stmt->value==NULL)
+	return True;
+    if (ExprResolveModMask(stmt->value,&mod,NULL,NULL)) {
+	srv->vmods[nextFree]= mod.uval;
+	return True;
+    }
+    ACTION1("Declaration of %s ignored\n",
+    				XkbAtomText(NULL,stmt->name,XkbMessage));
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+LookupVModIndex(	XPointer	priv,
+			Atom 		elem,
+			Atom 		field,
+			unsigned 	type,
+			ExprResult *	val_rtrn)
+#else
+LookupVModIndex(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+register int	i;
+register char *	fieldStr;
+register char *	modStr;
+XkbDescPtr	xkb;
+
+    xkb= (XkbDescPtr)priv;
+    if ((xkb==NULL)||(xkb->names==NULL)||(elem!=None)||(type!=TypeInt)) {
+	return False;
+    }
+    fieldStr= XkbAtomGetString(xkb->dpy,field);
+    if (fieldStr==NULL)
+	return False;
+    for (i=0;i<XkbNumVirtualMods;i++) {
+	modStr= XkbAtomGetString(xkb->dpy,xkb->names->vmods[i]);
+	if ((modStr!=NULL)&&(uStrCaseCmp(fieldStr,modStr)==0)) {
+	    val_rtrn->uval= i;
+	    return True;
+	}
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+LookupVModMask(	XPointer 	priv,
+		Atom 		elem,
+		Atom 		field,
+		unsigned 	type,
+		ExprResult *	val_rtrn)
+#else
+LookupVModMask(priv,elem,field,type,val_rtrn)
+    XPointer 		priv;
+    Atom		elem;
+    Atom		field;
+    unsigned		type;
+    ExprResult *	val_rtrn;
+#endif
+{
+    if (LookupVModIndex(priv,elem,field,type,val_rtrn)) {
+	register unsigned ndx= val_rtrn->uval;
+	val_rtrn->uval= (1<<(XkbNumModifiers+ndx));
+	return True;
+    }
+    return False;
+}
+
+int
+#if NeedFunctionPrototypes
+FindKeypadVMod(XkbDescPtr xkb)
+#else
+FindKeypadVMod(xkb)
+    XkbDescPtr	xkb;
+#endif
+{
+Atom name;
+ExprResult rtrn;
+
+    name= XkbInternAtom(xkb->dpy,"NumLock",False);
+    if ((xkb)&&
+	LookupVModIndex((XPointer)xkb,None,name,TypeInt,&rtrn)) {
+	return rtrn.ival;
+    }
+    return -1;
+}
+
+Bool
+#if NeedFunctionPrototypes
+ResolveVirtualModifier(ExprDef *def,ExprResult *val_rtrn,VModInfo *info)
+#else
+ResolveVirtualModifier(def,val_rtrn,info)
+    ExprDef *		def;
+    ExprResult *	val_rtrn;
+    VModInfo *		info;
+#endif
+{
+XkbNamesPtr	names;
+
+    names= info->xkb->names;
+    if (def->op==ExprIdent) {
+	register int i,bit;
+	for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
+	    char *str1,*str2;
+	    str1= XkbAtomGetString(info->xkb->dpy,names->vmods[i]);
+	    str2= XkbAtomGetString(NULL,def->value.str);
+	    if ((info->available&bit)&&
+		(uStrCaseCmp(str1,str2)==Equal)) {
+		val_rtrn->uval= i;
+		return True;
+	    }
+	}
+    }
+    if (ExprResolveInteger(def,val_rtrn,NULL,NULL)) {
+	if (val_rtrn->uval<XkbNumVirtualMods)
+	    return True;
+	ERROR2("Illegal virtual modifier %d (must be 0..%d inclusive)\n",
+					val_rtrn->uval,XkbNumVirtualMods-1);
+    }
+    return False;
+}
diff --git a/vmod.h b/vmod.h
new file mode 100644
index 0000000..eddf312
--- /dev/null
+++ b/vmod.h
@@ -0,0 +1,101 @@
+/* $Xorg: vmod.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 VMOD_H
+#define VMOD_H 1
+
+typedef struct _VModInfo {
+    XkbDescPtr		xkb;
+    unsigned		defined;
+    unsigned		available;
+    unsigned		newlyDefined;
+    int			errorCount;
+} VModInfo;
+
+extern void	InitVModInfo(
+#if NeedFunctionPrototypes
+    VModInfo *	/* info */,
+    XkbDescPtr	/* xkb */
+#endif
+);
+
+extern void	ClearVModInfo(
+#if NeedFunctionPrototypes
+    VModInfo *	/* info */,
+    XkbDescPtr	/* xkb */
+#endif
+);
+
+extern Bool	HandleVModDef(
+#if NeedFunctionPrototypes
+    VModDef *	/* stmt */,
+    unsigned	/* mergeMode */,
+    VModInfo *	/* info */
+#endif
+);
+
+extern Bool	ApplyVModDefs(
+#if NeedFunctionPrototypes
+    VModInfo *	/* info */,
+    XkbDescPtr	/* xkb */
+#endif
+);
+
+extern int	LookupVModIndex(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int	LookupVModMask(
+#if NeedFunctionPrototypes
+    XPointer 		/* priv */,
+    Atom		/* elem */,
+    Atom		/* field */,
+    unsigned		/* type */,
+    ExprResult *	/* val_rtrn */
+#endif
+);
+
+extern int	FindKeypadVMod(
+#if NeedFunctionPrototypes
+    XkbDescPtr		/* xkb */
+#endif
+);
+
+extern Bool	ResolveVirtualModifier(
+#if NeedFunctionPrototypes
+    ExprDef *		/* def */,
+    ExprResult *	/* value_rtrn */,
+    VModInfo *		/* info */
+#endif
+);
+
+#endif /* VMOD_H */
diff --git a/xkbcomp.c b/xkbcomp.c
new file mode 100644
index 0000000..29df701
--- /dev/null
+++ b/xkbcomp.c
@@ -0,0 +1,932 @@
+/* $Xorg: xkbcomp.c,v 1.4 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <X11/keysym.h>
+
+#if defined(sgi)
+#include <malloc.h>
+#endif
+
+#define	DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR debugFlags
+#include "xkbcomp.h"
+#ifndef X_NOT_STDC_ENV
+#include <stdlib.h>
+#endif
+#include "xkbpath.h"
+#include "parseutils.h"
+#include "misc.h"
+#include "tokens.h"
+#include <X11/extensions/XKBgeom.h>
+
+#define	lowbit(x)	((x) & (-(x)))
+
+/***====================================================================***/
+
+#define	WANT_DEFAULT	0
+#define	WANT_XKM_FILE	1
+#define	WANT_C_HDR	2
+#define	WANT_XKB_FILE	3
+#define	WANT_X_SERVER	4
+#define	WANT_LISTING	5
+
+#define	INPUT_UNKNOWN	0
+#define	INPUT_XKB	1
+#define	INPUT_XKM	2
+
+static char *fileTypeExt[] = {
+	"XXX",
+	"xkm",
+	"h",
+	"xkb",
+	"dir"
+};
+
+static	unsigned	inputFormat,outputFormat;
+	char *		rootDir;
+static	char *		inputFile;
+static	char *		inputMap;
+static	char *		outputFile;
+static	char *		inDpyName;
+static	char *		outDpyName;
+static	Display *	inDpy;
+static	Display *	outDpy;
+static	Bool		showImplicit= False;
+static	Bool		synch= False;
+static	Bool		merge= False;
+static	Bool		computeDflts= False;
+static	Bool		xkblist= False;
+	unsigned	warningLevel= 5;
+	unsigned	verboseLevel= 0;
+	unsigned	dirsToStrip= 0;
+	unsigned	optionalParts= 0;
+static	char *		preErrorMsg= NULL;
+static	char *		postErrorMsg= NULL;
+static	char *		errorPrefix= NULL;
+
+/***====================================================================***/
+
+#define	M(m)	fprintf(stderr,(m))
+#define	M1(m,a)	fprintf(stderr,(m),(a))
+
+static void
+#if NeedFunctionPrototypes
+Usage(int argc,char *argv[])
+#else
+Usage(argc,argv)
+    int 	argc;
+    char *	argv[];
+#endif
+{
+    if (!xkblist)
+	 M1("Usage: %s [options] input-file [ output-file ]\n",argv[0]);
+    else M1("Usage: %s [options] file[(map)] ...\n",argv[0]);
+    M("Legal options:\n");
+    M("-?,-help             Print this message\n");
+    if (!xkblist) {
+	M("-a                   Show all actions\n");
+	M("-C                   Create a C header file\n");
+    }
+#ifdef DEBUG
+    M("-d [flags]           Report debugging information\n");
+#endif
+    M("-em1 <msg>           Print <msg> before printing first error message\n");
+    M("-emp <msg>           Print <msg> at the start of each message line\n");
+    M("-eml <msg>           If there were any errors, print <msg> before exiting\n");
+    if (!xkblist) {
+	M("-dflts               Compute defaults for missing parts\n");
+	M("-I[<dir>]            Specifies a top level directory for include\n");
+	M("                     directives. Multiple directories are legal.\n");
+	M("-l [flags]           List matching maps in the specified files\n");
+	M("                     f: list fully specified names\n");
+	M("                     h: also list hidden maps\n");
+	M("                     l: long listing (show flags)\n");
+	M("                     p: also list partial maps\n");
+	M("                     R: recursively list subdirectories\n");
+	M("                     default is all options off\n");
+    }
+    M("-m[ap] <map>         Specifies map to compile\n");
+    if (!xkblist)
+	M("-merge               Merge file with map on server\n");
+    M("-o <file>            Specifies output file name\n");
+    if (!xkblist) {
+	M("-opt[ional] <parts>  Specifies optional components of keymap\n");
+	M("                     Errors in optional parts are not fatal\n");
+	M("                     <parts> can be any combination of:\n");
+	M("                     c: compat map         g: geometry\n");
+	M("                     k: keycodes           s: symbols\n");
+	M("                     t: types\n");
+    }
+    if (xkblist) {
+	M("-p <count>           Specifies the number of slashes to be stripped\n");
+	M("                     from the front of the map name on output\n");
+    }
+    M("-R[<DIR>]            Specifies the root directory for\n");
+    M("                     relative path names\n");
+    M("-synch               Force synchronization\n");
+    if (xkblist) {
+	M("-v [<flags>]         Set level of detail for listing.\n");
+	M("                     flags are as for the -l option\n");
+    }
+    M("-w [<lvl>]           Set warning level (0=none, 10=all)\n");
+    if (!xkblist) {
+	M("-xkb                 Create an XKB source (.xkb) file\n");
+	M("-xkm                 Create a compiled key map (.xkm) file\n");
+    }
+    return;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+setVerboseFlags(char *str)
+#else
+setVerboseFlags(str)
+    char *	str;
+#endif
+{
+    for (;*str;str++) {
+	switch (*str) {
+	    case 'f': verboseLevel|= WantFullNames; break;
+	    case 'h': verboseLevel|= WantHiddenMaps; break;
+	    case 'l': verboseLevel|= WantLongListing; break;
+	    case 'p': verboseLevel|= WantPartialMaps; break;
+	    case 'R': verboseLevel|= ListRecursive; break;
+	    default:
+		if (warningLevel>4) {
+		    WARN1("Unknown verbose option \"%c\"\n",(unsigned int)*str);
+		    ACTION("Ignored\n");
+		}
+		break;
+	}
+    }
+    return;
+}
+
+static Bool
+#if NeedFunctionPrototypes
+parseArgs(int argc,char *argv[])
+#else
+parseArgs(argc,argv)
+    int		argc;
+    char *	argv[];
+#endif
+{
+register int i,tmp;
+
+    i= strlen(argv[0]);
+    tmp= strlen("xkblist");
+    if ((i>=tmp)&&(strcmp(&argv[0][i-tmp],"xkblist")==0)) {
+	xkblist= True;
+    }
+    for (i=1;i<argc;i++) {
+	if ((argv[i][0]!='-')||(uStringEqual(argv[i],"-"))) {
+	    if (!xkblist) {
+		if (inputFile==NULL)
+		    inputFile= argv[i];
+		else if (outputFile==NULL)
+		    outputFile= argv[i];
+		else if (warningLevel>0) {
+		    WARN("Too many file names on command line\n");
+		    ACTION3("Compiling %s, writing to %s, ignoring %s\n",
+					inputFile,outputFile,argv[i]);
+		}
+	    }
+	    else if (!AddMatchingFiles(argv[i]))
+		return False;
+	}
+	else if ((strcmp(argv[i],"-?")==0)||(strcmp(argv[i],"-help")==0)) {
+	    Usage(argc,argv);
+	    exit(0);
+	}
+	else if ((strcmp(argv[i],"-a")==0)&&(!xkblist)) {
+	    showImplicit= True;
+	}
+	else if ((strcmp(argv[i],"-C")==0)&&(!xkblist)) {
+	    if ((outputFormat!=WANT_DEFAULT)&&(outputFormat!=WANT_C_HDR)) {
+		if (warningLevel>0) {
+		    WARN("Multiple output file formats specified\n");
+		    ACTION1("\"%s\" flag ignored\n",argv[i]);
+		}
+	    }
+	    else outputFormat= WANT_C_HDR;
+	}
+#ifdef DEBUG
+	else if (strcmp(argv[i],"-d")==0) {
+	    if ((i>=(argc-1))||(!isdigit(argv[i+1][0]))) {
+		debugFlags= 1;
+	    }
+	    else {
+		sscanf(argv[++i],"%i",&debugFlags);
+	    }
+	    INFO1("Setting debug flags to %d\n",debugFlags);
+	}
+#endif
+	else if ((strcmp(argv[i],"-dflts")==0)&&(!xkblist)) {
+	    computeDflts= True;
+	}
+	else if (strcmp(argv[i],"-em1")==0) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No pre-error message specified\n");
+		    ACTION("Trailing \"-em1\" option ignored\n");
+		}
+	    }
+	    else if (preErrorMsg!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple pre-error messsages specified\n");
+		    ACTION2("Compiling %s, ignoring %s\n",preErrorMsg,argv[i]);
+	 	}
+	    }
+	    else preErrorMsg= argv[i];
+	}
+	else if (strcmp(argv[i],"-emp")==0) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No error prefix specified\n");
+		    ACTION("Trailing \"-emp\" option ignored\n");
+		}
+	    }
+	    else if (errorPrefix!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple error prefixes specified\n");
+		    ACTION2("Compiling %s, ignoring %s\n",errorPrefix,argv[i]);
+	 	}
+	    }
+	    else errorPrefix= argv[i];
+	}
+	else if (strcmp(argv[i],"-eml")==0) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No post-error message specified\n");
+		    ACTION("Trailing \"-eml\" option ignored\n");
+		}
+	    }
+	    else if (postErrorMsg!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple post-error messages specified\n");
+		    ACTION2("Compiling %s, ignoring %s\n",postErrorMsg,argv[i]);
+	 	}
+	    }
+	    else postErrorMsg= argv[i];
+	}
+	else if ((strncmp(argv[i],"-I",2)==0)&&(!xkblist)) {
+	    if (!XkbAddDirectoryToPath(&argv[i][2])) {
+		ACTION("Exiting\n");
+ 		exit(1);
+	    }
+	}
+	else if ((strncmp(argv[i],"-l",2)==0)&&(!xkblist)) {
+	    if (outputFormat!=WANT_DEFAULT) {
+		if (warningLevel>0) {
+		    WARN("Multiple output file formats specified\n");
+		    ACTION1("\"%s\" flag ignored\n",argv[i]);
+		}
+	    }
+	    else {
+		if (argv[i][2]!='\0')
+		    setVerboseFlags(&argv[i][2]);
+		xkblist= True;
+		if ((inputFile)&&(!AddMatchingFiles(inputFile)))
+		     return False;
+		else inputFile= NULL;
+		if ((outputFile)&&(!AddMatchingFiles(outputFile)))
+		     return False;
+		else outputFile= NULL;
+	    }
+	}
+	else if ((strcmp(argv[i],"-m")==0)||(strcmp(argv[i],"-map")==0)) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No map name specified\n");
+		    ACTION1("Trailing \"%s\" option ignored\n",argv[i-1]);
+		}
+	    }
+	    else if (xkblist) {
+		 if (!AddMapOnly(argv[i]))
+		    return False;
+	    }
+	    else if (inputMap!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple map names specified\n");
+		    ACTION2("Compiling %s, ignoring %s\n",inputMap,argv[i]);
+	 	}
+	    }
+	    else inputMap= argv[i];
+	}
+	else if ((strcmp(argv[i],"-merge")==0)&&(!xkblist)) {
+	    merge= True;
+	}
+	else if (strcmp(argv[i],"-o")==0) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No output file specified\n");
+		    ACTION("Trailing \"-o\" option ignored\n");
+		}
+	    }
+	    else if (outputFile!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple output files specified\n");
+		    ACTION2("Compiling %s, ignoring %s\n",outputFile,argv[i]);
+		}
+	    }
+	    else outputFile= argv[i];
+	}
+	else if (((strcmp(argv[i],"-opt")==0)||(strcmp(argv[i],"optional")==0))
+		 						&&(!xkblist)) {
+	    if (++i>=argc) {
+		if (warningLevel>0) {
+		    WARN("No optional components specified\n");
+		    ACTION1("Trailing \"%s\" option ignored\n",argv[i-1]);
+		}
+	    }
+	    else {
+		char *tmp;
+		for (tmp=argv[i];(*tmp!='\0');tmp++) {
+		    switch (*tmp) {
+			case 'c': case 'C':
+			    optionalParts|= XkmCompatMapMask;
+			    break;
+			case 'g': case 'G':
+			    optionalParts|= XkmGeometryMask;
+			    break;
+			case 'k': case 'K':
+			    optionalParts|= XkmKeyNamesMask;
+			    break;
+			case 's': case 'S':
+			    optionalParts|= XkmSymbolsMask;
+			    break;
+			case 't': case 'T':
+			    optionalParts|= XkmTypesMask;
+			    break;
+			default:
+			    if (warningLevel>0) {
+				WARN1("Illegal component for %s option\n",
+								argv[i-1]);
+				ACTION1("Ignoring unknown specifier \"%c\"\n",
+								(unsigned int)*tmp);
+			    }
+			    break;
+		    }
+		}
+	    }
+	}
+	else if (strncmp(argv[i],"-p",2)==0) {
+	    if (isdigit(argv[i][2])) {
+		sscanf(&argv[i][2],"%i",&dirsToStrip);
+	    }
+	    else if ((i<(argc-1))&&(isdigit(argv[i+1][0]))) {
+		sscanf(argv[++i],"%i",&dirsToStrip);
+	    }
+	    else {
+		dirsToStrip= 0;
+	    }
+	    if (warningLevel>5)
+		INFO1("Setting path count to %d\n",dirsToStrip);
+	}
+	else if (strncmp(argv[i],"-R",2)==0) {
+	    if (argv[i][2]=='\0') {
+		if (warningLevel>0) {
+		    WARN("No root directory specified\n");
+		    ACTION("Ignoring -R option\n");
+		}
+	    }
+	    else if (rootDir!=NULL) {
+		if (warningLevel>0) {
+		    WARN("Multiple root directories specified\n");
+		    ACTION2("Using %s, ignoring %s\n",rootDir,argv[i]);
+		}
+	    }
+	    else {
+		rootDir= &argv[i][2];
+		if (warningLevel>8) {
+		    WARN1("Changing root directory to \"%s\"\n",rootDir);
+		}
+		if ((chdir(rootDir)<0) && (warningLevel>0)) {
+		    WARN1("Couldn't change directory to \"%s\"\n",rootDir);
+		    ACTION("Root directory (-R) option ignored\n");
+		    rootDir= NULL;
+		}
+	    }
+	}
+	else if ((strcmp(argv[i],"-synch")==0)||(strcmp(argv[i],"-s")==0)) {
+	    synch= True;
+	}
+	else if (strncmp(argv[i],"-v",2)==0) {
+	    char *str;
+	    if (argv[i][2]!='\0') 
+		 str= &argv[i][2];
+	    else if ((i<(argc-1))&&(argv[i+1][0]!='-'))
+		 str= argv[++i];
+	    else str= NULL;
+	    if (str)
+		setVerboseFlags(str);
+	}
+	else if (strncmp(argv[i],"-w",2)==0) {
+	    if ((i>=(argc-1))||(!isdigit(argv[i+1][0]))) {
+		if (isdigit(argv[i][1]))
+		     sscanf(&argv[i][1],"%i",&warningLevel);
+		else warningLevel= 0;
+	    }
+	    else {
+		sscanf(argv[++i],"%i",&warningLevel);
+	    }
+	}
+	else if ((strcmp(argv[i],"-xkb")==0)&&(!xkblist)) {
+	    if ((outputFormat!=WANT_DEFAULT)&&(outputFormat!=WANT_XKB_FILE)) {
+		if (warningLevel>0) {
+		    WARN("Multiple output file formats specified\n");
+		    ACTION1("\"%s\" flag ignored\n",argv[i]);
+		}
+	    }
+	    else outputFormat= WANT_XKB_FILE;
+	}
+	else if ((strcmp(argv[i],"-xkm")==0)&&(!xkblist)) {
+	    if ((outputFormat!=WANT_DEFAULT)&&(outputFormat!=WANT_XKM_FILE)) {
+		if (warningLevel>0) {
+		    WARN("Multiple output file formats specified\n");
+		    ACTION1("\"%s\" flag ignored\n",argv[i]);
+		}
+	    }
+	    else outputFormat= WANT_XKM_FILE;
+	}
+	else {
+	    ERROR1("Unknown flag \"%s\" on command line\n",argv[i]);
+	    Usage(argc,argv);
+	    return False;
+	}
+    }
+    if (xkblist)
+	inputFormat= INPUT_XKB;
+    else if (inputFile==NULL) {
+	ERROR("No input file specified\n");
+	return False;
+    }
+    else if (uStringEqual(inputFile,"-")) {
+	inputFormat= INPUT_XKB;
+    }
+    else if (strchr(inputFile,':')==0) {
+	int	len;
+	len= strlen(inputFile);
+	if (inputFile[len-1]==')') {
+	    char *tmp;
+	    if ((tmp=strchr(inputFile,'('))!=0) {
+		*tmp= '\0';  inputFile[len-1]= '\0';
+		tmp++;
+		if (*tmp=='\0') {
+		     WARN("Empty map in filename\n");
+		     ACTION("Ignored\n");
+		}
+		else if (inputMap==NULL) {
+		    inputMap= uStringDup(tmp);
+		}
+		else {
+		    WARN("Map specified in filename and with -m flag\n");
+		    ACTION1("map from name (\"%s\") ignored\n",tmp);
+		}
+	    }
+	    else {
+		ERROR1("Illegal name \"%s\" for input file\n",inputFile);
+		return False;
+	    }
+	}
+	if ((len>4)&&(strcmp(&inputFile[len-4],".xkm")==0)) {
+	    inputFormat= INPUT_XKM;
+	}
+	else {
+	    FILE *file;
+	    file= fopen(inputFile,"r");
+	    if (file) {
+		if (XkmProbe(file))	inputFormat= INPUT_XKM;
+		else			inputFormat= INPUT_XKB;
+		fclose(file);
+	    }
+	    else {
+		fprintf(stderr,"Cannot open \"%s\" for reading\n",inputFile);
+		return False;
+	    }
+	}
+    }
+    else {
+	inDpyName= inputFile;
+	inputFile= NULL;
+	inputFormat= INPUT_XKM;
+    }
+
+    if (outputFormat==WANT_DEFAULT) {
+	if (xkblist)				outputFormat= WANT_LISTING;
+	else if (inputFormat==INPUT_XKB)	outputFormat= WANT_XKM_FILE;
+	else					outputFormat= WANT_XKB_FILE;
+    }
+    if ((outputFormat==WANT_LISTING)&&(inputFormat!=INPUT_XKB)) {
+	if (inputFile)
+	     ERROR("Cannot generate a listing from a .xkm file (yet)\n");
+	else ERROR("Cannot generate a listing from an X connection (yet)\n");
+	return False;
+    }
+    if (xkblist) {
+	if (outputFile==NULL)	outputFile= uStringDup("-");
+	else if (strchr(outputFile,':')!=NULL) {
+	    ERROR("Cannot write a listing to an X connection\n");
+	    return False;
+	}
+    }
+    else if ((!outputFile) && (inputFile) && uStringEqual(inputFile,"-")) {
+	int len= strlen("stdin")+strlen(fileTypeExt[outputFormat])+2;
+	outputFile= uTypedCalloc(len,char);
+	if (outputFile==NULL) {
+	    WSGO("Cannot allocate space for output file name\n");
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+	sprintf(outputFile,"stdin.%s",fileTypeExt[outputFormat]);
+    }
+    else if ((outputFile==NULL)&&(inputFile!=NULL)) {
+	int len;
+	char *base,*ext;
+
+	if (inputMap==NULL)  {
+	    base= strrchr(inputFile,'/');
+	    if (base==NULL)	base= inputFile;
+	    else		base++;
+	}
+	else base= inputMap;
+
+	len= strlen(base)+strlen(fileTypeExt[outputFormat])+2;
+	outputFile= uTypedCalloc(len,char);
+	if (outputFile==NULL) {
+	    WSGO("Cannot allocate space for output file name\n");
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+	ext= strrchr(base,'.');
+	if (ext==NULL)
+	    sprintf(outputFile,"%s.%s",base,fileTypeExt[outputFormat]);
+	else {
+	    strcpy(outputFile,base);
+	    strcpy(&outputFile[ext-base+1],fileTypeExt[outputFormat]);
+	}
+    }
+    else if (outputFile==NULL) {
+	int len;
+	char *ch,*name,buf[128];
+	if (inDpyName[0]==':')	
+	     sprintf(name=buf,"server%s",inDpyName);
+	else name= inDpyName;
+
+	len= strlen(name)+strlen(fileTypeExt[outputFormat])+2;
+	outputFile= uTypedCalloc(len,char);
+	if (outputFile==NULL) {
+	    WSGO("Cannot allocate space for output file name\n");
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+	strcpy(outputFile,name);
+	for (ch=outputFile;(*ch)!='\0';ch++) {
+	    if 	(*ch==':')	*ch= '-';
+	    else if (*ch=='.')	*ch= '_';
+	}
+	*ch++= '.';
+	strcpy(ch,fileTypeExt[outputFormat]);
+    }
+    else if (strchr(outputFile,':')!=NULL) {
+	outDpyName= outputFile;
+	outputFile= NULL;
+	outputFormat=  WANT_X_SERVER;
+    }
+    return True;
+}
+
+static Display *
+#if NeedFunctionPrototypes
+GetDisplay(char *program,char *dpyName)
+#else
+GetDisplay(program,dpyName)
+    char *	program;
+    char *	dpyName;
+#endif
+{
+int	mjr,mnr,error;
+Display	*dpy;
+
+    mjr= XkbMajorVersion;
+    mnr= XkbMinorVersion;
+    dpy= XkbOpenDisplay(dpyName,NULL,NULL,&mjr,&mnr,&error);
+    if (dpy==NULL) {
+	switch (error) {
+	    case XkbOD_BadLibraryVersion:
+		INFO3("%s was compiled with XKB version %d.%02d\n",
+				program,XkbMajorVersion,XkbMinorVersion);
+		ERROR2("X library supports incompatible version %d.%02d\n",
+				mjr,mnr);
+		break;
+	    case XkbOD_ConnectionRefused:
+		ERROR1("Cannot open display \"%s\"\n",dpyName);
+		break;
+	    case XkbOD_NonXkbServer:
+		ERROR1("XKB extension not present on %s\n",dpyName);
+		break;
+	    case XkbOD_BadServerVersion:
+		INFO3("%s was compiled with XKB version %d.%02d\n",
+				program,XkbMajorVersion,XkbMinorVersion);
+		ERROR3("Server %s uses incompatible version %d.%02d\n",
+				dpyName,mjr,mnr);
+		break;
+	    default:
+		WSGO1("Unknown error %d from XkbOpenDisplay\n",error);
+	}
+    }
+    else if (synch)
+	XSynchronize(dpy,True);
+    return dpy;
+}
+
+/***====================================================================***/
+
+extern int yydebug;
+
+int
+#if NeedFunctionPrototypes
+main(int argc,char *argv[])
+#else
+main(argc,argv)
+    int		argc;
+    char *	argv[];
+#endif
+{
+FILE 	*	file;
+XkbFile	*	rtrn;
+XkbFile	*	mapToUse;
+int		ok;
+XkbFileInfo 	result;
+Status		status;
+
+    if (!parseArgs(argc,argv))
+	exit(1);
+#ifdef DEBUG
+    if (debugFlags&0x2)
+	yydebug= 1;
+#endif
+    if (preErrorMsg)
+	uSetPreErrorMessage(preErrorMsg);
+    if (errorPrefix)
+	uSetErrorPrefix(errorPrefix);
+    if (postErrorMsg)
+	uSetPostErrorMessage(postErrorMsg);
+    file= NULL;
+    XkbInitAtoms(NULL);
+    XkbInitIncludePath();
+    if (xkblist) {
+	Bool	gotSome;
+	gotSome= GenerateListing(outputFile);
+	if ((warningLevel>7)&&(!gotSome))
+	    return -1;
+	return 0;
+    }
+    if (inputFile!=NULL) {
+	if (uStringEqual(inputFile,"-")) {
+	    static char *in= "stdin";
+	    file= stdin;
+	    inputFile= in;
+	}
+	else {
+	    file= fopen(inputFile,"r");
+	}
+    }
+    else if (inDpyName!=NULL) {
+	inDpy= GetDisplay(argv[0],inDpyName);
+	if (!inDpy) {
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+    }
+    if (outDpyName!=NULL) {
+	outDpy= GetDisplay(argv[0],outDpyName);
+	if (!outDpy) {
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+    }
+    if ((inDpy==NULL) && (outDpy==NULL)) {
+	int	mjr,mnr;
+	mjr= XkbMajorVersion;
+	mnr= XkbMinorVersion;
+	if (!XkbLibraryVersion(&mjr,&mnr)) {
+	    INFO3("%s was compiled with XKB version %d.%02d\n",
+				argv[0],XkbMajorVersion,XkbMinorVersion);
+	    ERROR2("X library supports incompatible version %d.%02d\n",
+				mjr,mnr);
+	    ACTION("Exiting\n");
+	    exit(1);
+	}
+    }
+    if (file) {
+	ok= True;
+	setScanState(inputFile,1);
+	if ((inputFormat==INPUT_XKB)&&(XKBParseFile(file,&rtrn)&&(rtrn!=NULL))){
+	    fclose(file);
+	    mapToUse= rtrn;
+	    if (inputMap!=NULL) {
+		while ((mapToUse)&&(!uStringEqual(mapToUse->name,inputMap))) {
+		    mapToUse= (XkbFile *)mapToUse->common.next;
+		}
+		if (!mapToUse) {
+		    FATAL2("No map named \"%s\" in \"%s\"\n",inputMap,
+		    						inputFile);
+		    /* NOTREACHED */
+		}
+	    }
+	    else if (rtrn->common.next!=NULL) {
+		mapToUse= rtrn;
+		for (;mapToUse;mapToUse= (XkbFile*)mapToUse->common.next) {
+		    if (mapToUse->flags&XkbLC_Default)
+			break;
+		}
+		if (!mapToUse) {
+		    mapToUse= rtrn;
+		    if (warningLevel>4) {
+			WARN1("No map specified, but \"%s\" has several\n",
+								inputFile);
+			ACTION1("Using the first defined map, \"%s\"\n",
+								mapToUse->name);
+		    }
+		}
+	    }
+	    bzero((char *)&result,sizeof(result));
+	    result.type= mapToUse->type;
+	    if ((result.xkb= XkbAllocKeyboard())==NULL) {
+		WSGO("Cannot allocate keyboard description\n");
+		/* NOTREACHED */
+	    }
+	    switch (mapToUse->type) {
+		case XkmSemanticsFile:
+		case XkmLayoutFile:
+		case XkmKeymapFile:
+		    ok= CompileKeymap(mapToUse,&result,MergeReplace);
+		    break;
+		case XkmKeyNamesIndex:
+		    ok= CompileKeycodes(mapToUse,&result,MergeReplace);
+		    break;
+		case XkmTypesIndex:
+		    ok= CompileKeyTypes(mapToUse,&result,MergeReplace);
+		    break;
+		case XkmSymbolsIndex:
+		    /* if it's just symbols, invent key names */
+		    result.xkb->flags|= AutoKeyNames;
+		    ok= False;
+		    break;
+		case XkmCompatMapIndex:
+		    ok= CompileCompatMap(mapToUse,&result,MergeReplace,NULL);
+		    break;
+		case XkmGeometryFile:
+		case XkmGeometryIndex:
+		    /* if it's just a geometry, invent key names */
+		    result.xkb->flags|= AutoKeyNames;
+		    ok= CompileGeometry(mapToUse,&result,MergeReplace);
+		    break;
+		default:
+		    WSGO1("Unknown file type %d\n",mapToUse->type);
+		    ok= False;
+		    break;
+	    }
+	}
+	else if (inputFormat==INPUT_XKM) {
+	    unsigned tmp;
+	    bzero((char *)&result,sizeof(result));
+	    if ((result.xkb= XkbAllocKeyboard())==NULL) {
+		WSGO("Cannot allocate keyboard description\n");
+		/* NOTREACHED */
+	    }
+	    tmp= XkmReadFile(file,0,XkmKeymapLegal,&result);
+	    if (tmp==XkmKeymapLegal) {
+		ERROR1("Cannot read XKM file \"%s\"\n",inputFile);
+		ok= False;
+	    }
+	}
+	else {
+	    INFO1("Errors encountered in %s; not compiled.\n",inputFile);
+	    ok= False;
+	}
+    }
+    else if (inDpy!=NULL) {
+	bzero((char *)&result,sizeof(result));
+	result.type= XkmKeymapFile;
+	result.xkb= XkbGetMap(inDpy,XkbAllMapComponentsMask,XkbUseCoreKbd);
+	if (result.xkb==NULL)
+	    WSGO("Cannot load keyboard description\n");
+	if (XkbGetIndicatorMap(inDpy,~0,result.xkb)!=Success)
+	    WSGO("Could not load indicator map\n");
+	if (XkbGetControls(inDpy,XkbAllControlsMask,result.xkb)!=Success)
+	    WSGO("Could not load keyboard controls\n");
+	if (XkbGetCompatMap(inDpy,XkbAllCompatMask,result.xkb)!=Success)
+	    WSGO("Could not load compatibility map\n");
+	if (XkbGetNames(inDpy,XkbAllNamesMask,result.xkb)!=Success)
+	    WSGO("Could not load names\n");
+	if ((status=XkbGetGeometry(inDpy,result.xkb))!=Success) {
+	    if (warningLevel>3) {
+		char buf[100];
+		buf[0]= '\0';
+		XGetErrorText(inDpy,status,buf,100);
+		WARN1("Could not load keyboard geometry for %s\n",inDpyName);
+		ACTION1("%s\n",buf);
+		ACTION("Resulting keymap file will not describe geometry\n");
+	    }
+	}
+	if (computeDflts)
+	     ok= (ComputeKbdDefaults(result.xkb)==Success);
+	else ok= True;
+    }
+    else {
+	fprintf(stderr,"Cannot open \"%s\" to compile\n",inputFile);
+	ok= 0;
+    }
+    if (ok) {
+	FILE *out= stdout;
+	if ((inDpy!=outDpy)&&
+	    (XkbChangeKbdDisplay(outDpy,&result)!=Success)) {
+	    WSGO2("Error converting keyboard display from %s to %s\n",
+	    						inDpyName,outDpyName);
+	    exit(1);
+	}
+	if (outputFile!=NULL) {
+	    if (uStringEqual(outputFile,"-"))
+		outputFile= "stdout";
+	    else {
+		out= fopen(outputFile,"w");
+		if (out==NULL) {
+		    ERROR1("Cannot open \"%s\" to write keyboard description\n",
+								outputFile);
+		     ACTION("Exiting\n");
+		     exit(1);
+		}
+	    }
+	}
+	switch (outputFormat) {
+	    case WANT_XKM_FILE:
+		ok= XkbWriteXKMFile(out,&result);
+		break;
+	    case WANT_XKB_FILE:
+		ok= XkbWriteXKBFile(out,&result,showImplicit,NULL,NULL);
+		break;
+	    case WANT_C_HDR:
+		ok= XkbWriteCFile(out,outputFile,&result);
+		break;
+	    case WANT_X_SERVER:
+	    	if (!(ok= XkbWriteToServer(&result))) {
+		    ERROR2("%s in %s\n",_XkbErrMessages[_XkbErrCode],
+				_XkbErrLocation?_XkbErrLocation:"unknown");
+		    ACTION1("Couldn't write keyboard description to %s\n",
+								outDpyName);
+		}
+		break;
+	    default:
+		WSGO1("Unknown output format %d\n",outputFormat);
+		ACTION("No output file created\n");
+		ok= False;
+		break;
+	}
+	if (outputFormat!=WANT_X_SERVER) {
+	    fclose(out);
+	    if (!ok) {
+		ERROR2("%s in %s\n",_XkbErrMessages[_XkbErrCode],
+				_XkbErrLocation?_XkbErrLocation:"unknown");
+		ACTION1("Output file \"%s\" removed\n",outputFile);
+		unlink(outputFile);
+	    }
+	}
+    }
+    if (inDpy) 
+	XCloseDisplay(inDpy);
+    inDpy= NULL;
+    if (outDpy)
+	XCloseDisplay(outDpy);
+    uFinishUp();
+    return (ok==0);
+}
diff --git a/xkbcomp.h b/xkbcomp.h
new file mode 100644
index 0000000..46fe4a4
--- /dev/null
+++ b/xkbcomp.h
@@ -0,0 +1,408 @@
+/* $Xorg: xkbcomp.h,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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 XKBCOMP_H
+#define	XKBCOMP_H 1
+
+#ifndef DEBUG_VAR
+#define	DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR debugFlags
+#endif
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+
+#include "utils.h"
+
+#include <X11/extensions/XKM.h>
+#include <X11/extensions/XKBfile.h>
+
+extern char *scanFile;
+
+#define	TypeUnknown	0
+#define	TypeBoolean	1
+#define	TypeInt		2
+#define	TypeFloat	3
+#define	TypeString	4
+#define	TypeAction	5
+#define	TypeKeyName	6
+#define	TypeSymbols	7
+
+#define	StmtUnknown		0
+#define	StmtInclude		1
+#define	StmtKeycodeDef		2
+#define	StmtKeyAliasDef		3
+#define	StmtExpr		4
+#define	StmtVarDef		5
+#define	StmtKeyTypeDef		6
+#define	StmtInterpDef		7
+#define	StmtVModDef		8
+#define	StmtSymbolsDef		9
+#define	StmtModMapDef		10
+#define	StmtGroupCompatDef 	11
+#define	StmtIndicatorMapDef	12
+#define	StmtIndicatorNameDef	13
+#define	StmtOutlineDef		14
+#define	StmtShapeDef		15
+#define	StmtKeyDef		16
+#define	StmtRowDef		17
+#define	StmtSectionDef		18
+#define	StmtOverlayKeyDef	19
+#define	StmtOverlayDef		20
+#define	StmtDoodadDef		21
+
+#define	FileSymInterp	100
+
+typedef	struct _ParseCommon {
+    unsigned		 stmtType;
+    struct _ParseCommon	*next;
+} ParseCommon;
+
+#define	ExprValue	0
+#define	ExprIdent	1
+#define	ExprActionDecl	2
+#define	ExprFieldRef	3
+#define	ExprArrayRef	4
+#define	ExprKeysymList	5
+#define	ExprActionList	6
+#define	ExprCoord	7
+
+#define	OpAdd		20
+#define	OpSubtract	21
+#define	OpMultiply	22
+#define	OpDivide	23
+#define	OpAssign	24
+#define	OpNot		25
+#define	OpNegate	26
+#define	OpInvert	27
+#define	OpUnaryPlus	28
+
+#define	MergeDefault	0
+#define	MergeAugment	1
+#define	MergeOverride	2
+#define	MergeReplace	3
+#define	MergeAltForm	4
+
+#define	AutoKeyNames	(1L <<  0)
+#define	CreateKeyNames(x)	((x)->flags&AutoKeyNames)
+
+extern	unsigned	warningLevel;
+extern	unsigned	optionalParts;
+
+typedef struct _IncludeStmt {
+    ParseCommon		common;
+    unsigned		merge;
+    char 		*stmt;
+    char		*file;
+    char		*map;
+    char		*path;
+    struct _IncludeStmt	*next;
+} IncludeStmt;
+
+typedef struct _Expr {
+    ParseCommon		common;
+    unsigned		op;
+    unsigned		type;
+    union {
+	struct {
+	    struct _Expr *left;
+	    struct _Expr *right;
+	} binary;
+	struct {
+	    Atom	element;
+	    Atom field;
+	} field;
+	struct {
+	    Atom	element;
+	    Atom	field;
+	    struct _Expr *entry;
+	} array;
+	struct {
+	    Atom	  name;
+	    struct _Expr *args;
+	} action;
+	struct {
+	    int		 nSyms;
+	    int		 szSyms;
+	    KeySym *	 syms;
+	} list;
+	struct {
+	    int		 x;
+	    int		 y;
+	} coord;
+	struct _Expr	*child;
+	Atom	 str;
+	unsigned	 uval;
+	int		 ival;
+	char	 	 keyName[5];
+	Opaque		 ptr;
+    } value;
+} ExprDef;
+
+typedef struct _VarDef {
+    ParseCommon	common;
+    unsigned	 merge;
+    ExprDef 	*name;
+    ExprDef	*value;
+} VarDef;
+
+typedef struct _VModDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 name;
+    ExprDef	*value;
+} VModDef;
+
+typedef struct _KeycodeDef {
+    ParseCommon	common;
+    unsigned	merge;
+    char 	name[5];
+    ExprDef	*value;
+} KeycodeDef;
+
+typedef struct _KeyAliasDef {
+    ParseCommon	common;
+    unsigned	merge;
+    char 	alias[5];
+    char 	real[5];
+} KeyAliasDef;
+
+typedef struct _KeyTypeDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 name;
+    VarDef	*body;
+} KeyTypeDef;
+
+typedef struct _SymbolsDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    char 	 keyName[5];
+    ExprDef *	 symbols;
+} SymbolsDef;
+
+typedef struct _ModMapDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 modifier;
+    ExprDef *	 keys;
+} ModMapDef;
+
+typedef struct _GroupCompatDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    int	 	 group;
+    ExprDef *	 def;
+} GroupCompatDef;
+
+typedef struct _InterpDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    KeySym	 sym;
+    ExprDef	*match;
+    VarDef	*def;
+} InterpDef;
+
+typedef struct _IndicatorMapDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 name;
+    VarDef *	 body;
+} IndicatorMapDef;
+
+typedef struct _IndicatorNameDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    int		 ndx;
+    ExprDef *	 name;
+    Bool	 virtual;
+} IndicatorNameDef;
+
+typedef struct _OutlineDef {
+    ParseCommon	 	common;
+    Atom 	field;
+    int		 	nPoints;
+    ExprDef *		points;
+} OutlineDef;
+
+typedef struct _ShapeDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 name;
+    int		 nOutlines;
+    OutlineDef * outlines;
+} ShapeDef;
+
+typedef struct _KeyDef {
+    ParseCommon	 	common;
+    unsigned		defined;
+    char *		name;
+    ExprDef *		expr;
+} KeyDef;
+
+typedef struct _RowDef {
+    ParseCommon		common;
+    int			nKeys;
+    KeyDef *		keys;
+} RowDef;
+
+typedef struct _SectionDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    Atom	 name;
+    int		 nRows;
+    RowDef *	 rows;
+} SectionDef;
+
+typedef struct _OverlayKeyDef {
+    ParseCommon		common;
+    char 		over[5];
+    char 		under[5];
+} OverlayKeyDef;
+
+typedef struct _OverlayDef {
+    ParseCommon	 	common;
+    unsigned	 	merge;
+    Atom	 	name;
+    int		 	nKeys;
+    OverlayKeyDef *	keys;
+} OverlayDef;
+
+typedef struct _DoodadDef {
+    ParseCommon	 common;
+    unsigned	 merge;
+    unsigned	 type;
+    Atom	 name;
+    VarDef *	 body;
+} DoodadDef;
+
+typedef struct _XkbFile {
+    ParseCommon	 common;
+    int		 type;
+    char *	 topName;
+    char *	 name;
+    ParseCommon	*defs;
+    int		 id;
+    unsigned	 flags;
+    Bool	 compiled;
+} XkbFile;
+
+_XFUNCPROTOBEGIN
+
+extern	Bool	CompileKeymap(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */
+#endif
+);
+
+extern	Bool	CompileKeycodes(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */
+#endif
+);
+
+extern	Bool	CompileGeometry(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */
+#endif
+);
+
+extern	Bool	CompileKeyTypes(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */
+#endif
+);
+
+typedef struct _LEDInfo *LEDInfoPtr;
+
+extern	Bool	CompileCompatMap(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */,
+    LEDInfoPtr *	/* unboundLEDs */
+#endif
+);
+
+extern	Bool	CompileSymbols(
+#if NeedFunctionPrototypes
+    XkbFile	*	/* file */,
+    XkbFileInfo *	/* result */,
+    unsigned	 	/* merge */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#define	WantLongListing	(1<<0)
+#define	WantPartialMaps	(1<<1)
+#define	WantHiddenMaps	(1<<2)
+#define	WantFullNames	(1<<3)
+#define	ListRecursive	(1<<4)
+
+extern char *	rootDir;
+extern unsigned verboseLevel;
+extern unsigned	dirsToStrip;
+
+_XFUNCPROTOBEGIN
+
+extern	Bool	AddListing(
+#if NeedFunctionPrototypes
+    char *	/* file */,
+    char *    /* map */
+#endif
+);
+
+extern Bool AddMatchingFiles(
+#if NeedFunctionPrototypes
+    char *    /* head_in */
+#endif
+);
+
+extern        int AddMapOnly(
+#if NeedFunctionPrototypes
+    char *	/* map */
+#endif
+);
+
+extern	int GenerateListing(
+#if NeedFunctionPrototypes
+    char *	/* filename */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* XKBCOMP_H */
diff --git a/xkbcomp.man b/xkbcomp.man
new file mode 100644
index 0000000..32bb4ff
--- /dev/null
+++ b/xkbcomp.man
@@ -0,0 +1,97 @@
+.\" $Xorg: xkbcomp.man,v 1.3 2000/08/17 19:54:33 cpqbld Exp $
+.TH XKBCOMP 1 "Release 6.4" "X Version 11"
+.SH NAME
+xkbcomp \- compile XKB keyboard description
+.SH SYNOPSIS
+.B xkbcomp
+[option] source [ destination ]
+.SH DESCRIPTION
+.PP
+The
+.I xkbcomp
+keymap compiler converts a description of an XKB keymap into one of several
+output formats.   The most common use for xkbcomp is to create a compiled
+keymap file (.xkm extension) which can be read directly by XKB-capable X
+servers or utilities.   The keymap compiler can also produce C header
+files or XKB source files.  The C header files produced by xkbcomp can be
+included by X servers or utilities that need a built-in default keymap.
+The XKB source files produced by \fIxkbcomp\fP are fully resolved and can be 
+used to verify that the files which typically make up an XKB keymap
+are merged correctly or to create a single file which contains a complete
+description of the keymap.
+.PP
+The \fIsource\fP may specify an X display, or an \fI.xkb\fP or
+\fI.xkm\fP file;  unless explicitly specified, the format of \fIdestination\fP
+depends on the format of the source.   Compiling a \fI.xkb\fP (keymap source) 
+file generates a \fI.xkm\fP (compiled keymap file) by default.   If the 
+source is a \fI.xkm\fP file or an X display, \fIxkbcomp\fP generates a 
+keymap source file by default.
+.PP
+If the \fIdestination\fP is an X display, the keymap for the display
+is updated with the compiled keymap.
+.PP
+The name of the \fIdestination\fP is usually computed from the name
+of the source, with the extension replaced as appropriate.  When compiling
+a single map from a file which contains several maps, \fIxkbcom\fP constructs
+the destination file name by appending an appropriate extension to the
+name of the map to be used.
+.SH OPTIONS
+.TP 8
+.B \-a
+Show all keyboard information, reporting implicit or dervied information
+as a comment.  Only affects \fI.xkb\fP format output.
+.TP 8
+.B \-C
+Produce a C header file as output (.h extension).
+.TP 8
+.B \-dflts
+Compute defaults for any missing components, such as key names.
+.TP 8
+.B \-I\fIdir\fP
+Specifies top-level directories to be searched for files included by the 
+keymap description.
+.TP 8
+.B \-l
+List maps that specify the \fImap\fP pattern in any files listed on the
+command line (not implemented yet).
+.TP 8
+.B \-m\ \fIname\fP
+Specifies a map to be compiled from an file with multiple entries.
+.TP 8
+.B \-merge
+Merge the compiled information with the map from the server (not implemented
+yet).
+.TP 8
+.B \-o\ \fIname\fP
+Specifies a name for the generated output file.  The default is the name of 
+the source file with an appropriate extension for the output format.
+.TP 8
+.B \-opt\ \fIparts\fP
+Specifies a list of optional parts.  Compilation errors in any optional parts
+are not fatal.  Parts may consist of any combination of the letters \fIc\fP,
+\fIg\fP,\fIk\fP,\fIs\fP,\fIt\fP which specify the compatibility map, geometry,
+keycodes, symbols and types, respectively.
+.TP 8
+.B -R\fIdir\fP
+Specifies the root directory for relative path names.
+.TP 8
+.B -synch
+Force synchonization for X requests.
+.TP 8
+.B \-w\ \fIlvl\fP
+Controls the reporting of warnings during compilation.  A warning level 
+of 0 disables all warnings; a warning level of 10 enables them all.
+.TP 8
+.B \-xkb
+Generate a source description of the keyboard as output (.xkb extension).
+.TP 8
+.B \-xkm
+Generate a compiled keymap file as output (.xkm extension).
+.SH "SEE ALSO"
+X(1)
+.SH COPYRIGHT
+Copyright 1994, Silicon Graphics Computer Systems and X Consortium, Inc.
+.br
+See \fIX(1)\fP for a full statement of rights and permissions.
+.SH AUTHOR
+Erik Fortune, Silicon Graphics
diff --git a/xkbparse.y b/xkbparse.y
new file mode 100644
index 0000000..78589f4
--- /dev/null
+++ b/xkbparse.y
@@ -0,0 +1,806 @@
+/* $Xorg: xkbparse.y,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+%token
+	END_OF_FILE	0
+	ERROR_TOK	255
+	XKB_KEYMAP	1
+	XKB_KEYCODES	2
+	XKB_TYPES	3
+	XKB_SYMBOLS	4
+	XKB_COMPATMAP	5
+	XKB_GEOMETRY	6
+	XKB_SEMANTICS	7
+	XKB_LAYOUT	8
+	INCLUDE		10
+	OVERRIDE	11
+	AUGMENT		12
+	REPLACE		13
+	ALTERNATE	14
+	VIRTUAL_MODS	20
+	TYPE		21
+	INTERPRET	22
+	ACTION_TOK	23
+	KEY		24
+	ALIAS		25
+	GROUP		26
+	MODIFIER_MAP	27
+	INDICATOR	28
+	SHAPE		29
+	KEYS		30
+	ROW		31
+	SECTION		32
+	OVERLAY		33
+	TEXT		34
+	OUTLINE		35
+	SOLID		36
+	LOGO		37
+	VIRTUAL		38
+	EQUALS		40
+	PLUS		41
+	MINUS		42
+	DIVIDE		43
+	TIMES		44
+	OBRACE		45
+	CBRACE		46
+	OPAREN		47
+	CPAREN		48
+	OBRACKET	49
+	CBRACKET	50
+	DOT		51
+	COMMA		52
+	SEMI		53
+	EXCLAM		54
+	INVERT		55
+	STRING		60
+	INTEGER		61
+	FLOAT		62
+	IDENT		63
+	KEYNAME		64
+	PARTIAL		70
+	DEFAULT		71
+	HIDDEN		72
+	ALPHANUMERIC_KEYS	73
+	MODIFIER_KEYS		74
+	KEYPAD_KEYS		75
+	FUNCTION_KEYS		76
+	ALTERNATE_GROUP		77
+%{
+#ifdef DEBUG
+#define	YYDEBUG 1
+#endif
+#define	DEBUG_VAR parseDebug
+#include "parseutils.h"
+#include <X11/keysym.h>
+#include <X11/extensions/XKBgeom.h>
+
+_XFUNCPROTOBEGIN
+extern	int yylex(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+_XFUNCPROTOEND
+%}
+%right	EQUALS
+%left	PLUS MINUS
+%left	TIMES DIVIDE
+%left	EXCLAM INVERT
+%left	OPAREN
+%start	XkbFile
+%union	{
+	int		 ival;
+	unsigned	 uval;
+	char		*str;
+	Atom	 	sval;
+	ParseCommon	*any;
+	ExprDef		*expr;
+	VarDef		*var;
+	VModDef		*vmod;
+	InterpDef	*interp;
+	KeyTypeDef	*keyType;
+	SymbolsDef	*syms;
+	ModMapDef	*modMask;
+	GroupCompatDef	*groupCompat;
+	IndicatorMapDef	*ledMap;
+	IndicatorNameDef *ledName;
+	KeycodeDef	*keyName;
+	KeyAliasDef	*keyAlias;
+	ShapeDef	*shape;
+	SectionDef	*section;
+	RowDef		*row;
+	KeyDef		*key;
+	OverlayDef	*overlay;
+	OverlayKeyDef	*olKey;
+	OutlineDef	*outline;
+	DoodadDef	*doodad;
+	XkbFile		*file;
+}
+%type <ival>	Number Integer Float
+%type <uval>	XkbCompositeType FileType MergeMode OptMergeMode KeySym
+%type <uval>	DoodadType Flag Flags OptFlags
+%type <str>	KeyName MapName OptMapName
+%type <sval>	FieldSpec Ident Element String 
+%type <any>	DeclList Decl 
+%type <expr>	OptExprList ExprList Expr Term Lhs Terminal ArrayInit
+%type <expr>	OptKeySymList KeySymList Action ActionList Coord CoordList
+%type <var>	VarDecl VarDeclList SymbolsBody SymbolsVarDecl 
+%type <vmod>	VModDecl VModDefList VModDef
+%type <interp>	InterpretDecl InterpretMatch
+%type <keyType>	KeyTypeDecl
+%type <syms>	SymbolsDecl
+%type <modMask>	ModMapDecl
+%type <groupCompat> GroupCompatDecl
+%type <ledMap>	IndicatorMapDecl
+%type <ledName>	IndicatorNameDecl
+%type <keyName>	KeyNameDecl
+%type <keyAlias> KeyAliasDecl
+%type <shape>	ShapeDecl
+%type <section>	SectionDecl
+%type <row>	SectionBody SectionBodyItem
+%type <key>	RowBody RowBodyItem Keys Key 
+%type <overlay>	OverlayDecl
+%type <olKey>	OverlayKeyList OverlayKey
+%type <outline>	OutlineList OutlineInList
+%type <doodad>	DoodadDecl
+%type <file>	XkbFile XkbMapConfigList XkbMapConfig XkbConfig
+%type <file>	XkbCompositeMap XkbCompMapList
+%%
+XkbFile		:	XkbCompMapList
+			{ $$= rtrnValue= $1; }
+		|	XkbMapConfigList 
+			{ $$= rtrnValue= $1;  }
+		|	XkbConfig
+			{ $$= rtrnValue= $1; }
+		;
+
+XkbCompMapList	:	XkbCompMapList XkbCompositeMap
+			{ $$= (XkbFile *)AppendStmt(&$1->common,&$2->common); }
+		|	XkbCompositeMap
+			{ $$= $1; }
+		;
+
+XkbCompositeMap	:	OptFlags XkbCompositeType OptMapName OBRACE
+			    XkbMapConfigList
+			CBRACE SEMI
+			{ $$= CreateXKBFile($2,$3,&$5->common,$1); }
+		;
+
+XkbCompositeType:	XKB_KEYMAP	{ $$= XkmKeymapFile; }
+		|	XKB_SEMANTICS	{ $$= XkmSemanticsFile; }
+		|	XKB_LAYOUT	{ $$= XkmLayoutFile; }
+		;
+
+XkbMapConfigList :	XkbMapConfigList XkbMapConfig
+			{ $$= (XkbFile *)AppendStmt(&$1->common,&$2->common); }
+		|	XkbMapConfig
+			{ $$= $1; }
+		;
+
+XkbMapConfig	:	OptFlags FileType OptMapName OBRACE
+			    DeclList
+			CBRACE SEMI
+			{ $$= CreateXKBFile($2,$3,$5,$1); }
+		;
+
+XkbConfig	:	OptFlags FileType OptMapName DeclList
+			{ $$= CreateXKBFile($2,$3,$4,$1); }
+		;
+
+
+FileType	:	XKB_KEYCODES		{ $$= XkmKeyNamesIndex; }
+		|	XKB_TYPES		{ $$= XkmTypesIndex; }
+		|	XKB_COMPATMAP		{ $$= XkmCompatMapIndex; }
+		|	XKB_SYMBOLS		{ $$= XkmSymbolsIndex; }
+		|	XKB_GEOMETRY		{ $$= XkmGeometryIndex; }
+		;
+
+OptFlags	:	Flags			{ $$= $1; }
+		|				{ $$= 0; }
+		;
+
+Flags		:	Flags Flag		{ $$= (($1)|($2)); }
+		|	Flag			{ $$= $1; }
+		;
+
+Flag		:	PARTIAL			{ $$= XkbLC_Partial; }
+		|	DEFAULT			{ $$= XkbLC_Default; }
+		|	HIDDEN			{ $$= XkbLC_Hidden; }
+		|	ALPHANUMERIC_KEYS	{ $$= XkbLC_AlphanumericKeys; }
+		|	MODIFIER_KEYS		{ $$= XkbLC_ModifierKeys; }
+		|	KEYPAD_KEYS		{ $$= XkbLC_KeypadKeys; }
+		|	FUNCTION_KEYS		{ $$= XkbLC_FunctionKeys; }
+		|	ALTERNATE_GROUP		{ $$= XkbLC_AlternateGroup; }
+		;
+
+DeclList	:	DeclList Decl
+			{ $$= AppendStmt($1,$2); }
+		|	{ $$= NULL; }
+		;
+
+Decl		:	OptMergeMode VarDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode VModDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode InterpretDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode KeyNameDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode KeyAliasDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode KeyTypeDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode SymbolsDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode ModMapDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode GroupCompatDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode IndicatorMapDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode IndicatorNameDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode ShapeDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode SectionDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	OptMergeMode DoodadDecl
+			{
+			    $2->merge= StmtSetMerge(&$2->common,$1);
+			    $$= &$2->common;
+			}
+		|	MergeMode STRING
+			{
+			    if ($1==MergeAltForm) {
+				yyerror("cannot use 'alternate' to include other maps");
+				$$= &IncludeCreate(scanStr,MergeDefault)->common;
+			    }
+			    else {
+				$$= &IncludeCreate(scanStr,$1)->common;
+			    }
+                        }
+		;
+
+VarDecl		:	Lhs EQUALS Expr SEMI
+			{ $$= VarCreate($1,$3); }
+		|	Ident SEMI
+			{ $$= BoolVarCreate($1,1); }
+		|	EXCLAM Ident SEMI
+			{ $$= BoolVarCreate($2,0); }
+		;
+
+KeyNameDecl	:	KeyName EQUALS Expr SEMI
+                        {
+			    KeycodeDef *def;
+
+			    def= KeycodeCreate($1,$3);
+			    if ($1)
+				free($1);
+			    $$= def;
+			}
+		;
+
+KeyAliasDecl	:	ALIAS KeyName EQUALS KeyName SEMI
+			{ 
+			    KeyAliasDef	*def;
+			    def= KeyAliasCreate($2,$4); 
+			    if ($2)	free($2);	
+			    if ($4)	free($4);	
+			    $$= def;
+			}
+		;
+
+VModDecl	:	VIRTUAL_MODS VModDefList SEMI
+			{ $$= $2; }
+		;
+
+VModDefList	:	VModDefList COMMA VModDef
+			{ $$= (VModDef *)AppendStmt(&$1->common,&$3->common); }
+		|	VModDef
+			{ $$= $1; }
+		;
+
+VModDef		:	Ident
+			{ $$= VModCreate($1,NULL); }
+		|	Ident EQUALS Expr
+			{ $$= VModCreate($1,$3); }
+		;
+
+InterpretDecl	:	INTERPRET InterpretMatch OBRACE
+			    VarDeclList
+			CBRACE SEMI
+			{
+			    $2->def= $4;
+			    $$= $2;
+			}
+		;
+
+InterpretMatch	:	KeySym PLUS Expr	
+			{ $$= InterpCreate((KeySym)$1,$3); }
+		|	KeySym			
+			{ $$= InterpCreate((KeySym)$1,NULL); }
+		;
+
+VarDeclList	:	VarDeclList VarDecl
+			{ $$= (VarDef *)AppendStmt(&$1->common,&$2->common); }
+		|	VarDecl
+			{ $$= $1; }
+		;
+
+KeyTypeDecl	:	TYPE String OBRACE
+			    VarDeclList
+			CBRACE SEMI
+			{ $$= KeyTypeCreate($2,$4); }
+		;
+
+SymbolsDecl	:	KEY KeyName OBRACE
+			    SymbolsBody
+			CBRACE SEMI
+			{ $$= SymbolsCreate($2,(ExprDef *)$4); }
+		;
+
+SymbolsBody	:	SymbolsBody COMMA SymbolsVarDecl
+			{ $$= (VarDef *)AppendStmt(&$1->common,&$3->common); }
+		|	SymbolsVarDecl
+			{ $$= $1; }
+		;
+
+SymbolsVarDecl	:	Lhs EQUALS Expr
+			{ $$= VarCreate($1,$3); }
+		|	Lhs EQUALS ArrayInit
+			{ $$= VarCreate($1,$3); }
+		|	Ident
+			{ $$= BoolVarCreate($1,1); }
+		|	EXCLAM Ident
+			{ $$= BoolVarCreate($2,0); }
+		|	ArrayInit
+			{ $$= VarCreate(NULL,$1); }
+		;
+
+ArrayInit	:	OBRACKET OptKeySymList CBRACKET
+			{ $$= $2; }
+		|	OBRACKET ActionList CBRACKET
+			{ $$= ExprCreateUnary(ExprActionList,TypeAction,$2); }
+		;
+
+GroupCompatDecl	:	GROUP Integer EQUALS Expr SEMI
+			{ $$= GroupCompatCreate($2,$4); }
+		;
+
+ModMapDecl	:	MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI
+			{ $$= ModMapCreate($2,$4); }
+		;
+
+IndicatorMapDecl:	INDICATOR String OBRACE VarDeclList CBRACE SEMI
+			{ $$= IndicatorMapCreate($2,$4); }
+		;
+
+IndicatorNameDecl:	INDICATOR Integer EQUALS Expr SEMI
+			{ $$= IndicatorNameCreate($2,$4,False); }
+		|	VIRTUAL INDICATOR Integer EQUALS Expr SEMI
+			{ $$= IndicatorNameCreate($3,$5,True); }
+		;
+
+ShapeDecl	:	SHAPE String OBRACE OutlineList CBRACE SEMI
+			{ $$= ShapeDeclCreate($2,(OutlineDef *)&$4->common); }
+		;
+		|	SHAPE String OBRACE CoordList CBRACE SEMI
+			{ 
+			    OutlineDef *outlines;
+			    outlines= OutlineCreate(None,$4);
+			    $$= ShapeDeclCreate($2,outlines);
+			}
+		;
+
+SectionDecl	:	SECTION String OBRACE SectionBody CBRACE SEMI
+			{ $$= SectionDeclCreate($2,$4); }
+		;
+
+SectionBody	:	SectionBody SectionBodyItem
+			{ $$=(RowDef *)AppendStmt(&$1->common,&$2->common);}
+		|	SectionBodyItem
+			{ $$= $1; }
+		;
+
+SectionBodyItem	:	ROW OBRACE RowBody CBRACE SEMI
+			{ $$= RowDeclCreate($3); }
+		|	VarDecl
+			{ $$= (RowDef *)$1; }
+		|	DoodadDecl
+			{ $$= (RowDef *)$1; }
+		|	IndicatorMapDecl
+			{ $$= (RowDef *)$1; }
+		|	OverlayDecl
+			{ $$= (RowDef *)$1; }
+		;
+
+RowBody		:	RowBody RowBodyItem
+			{ $$=(KeyDef *)AppendStmt(&$1->common,&$2->common);}
+		|	RowBodyItem
+			{ $$= $1; }
+		;
+
+RowBodyItem	:	KEYS OBRACE Keys CBRACE SEMI
+			{ $$= $3; }
+		|	VarDecl
+			{ $$= (KeyDef *)$1; }
+		;
+
+Keys		:	Keys COMMA Key
+			{ $$=(KeyDef *)AppendStmt(&$1->common,&$3->common);}
+		|	Key
+			{ $$= $1; }
+		;
+
+Key		:	KeyName
+			{ $$= KeyDeclCreate($1,NULL); }
+		|	OBRACE ExprList CBRACE
+			{ $$= KeyDeclCreate(NULL,$2); }
+		;
+
+OverlayDecl	:	OVERLAY String OBRACE OverlayKeyList CBRACE SEMI
+			{ $$= OverlayDeclCreate($2,$4); }
+		;
+
+OverlayKeyList	:	OverlayKeyList COMMA OverlayKey
+			{ 
+			    $$= (OverlayKeyDef *)
+				AppendStmt(&$1->common,&$3->common);
+			};
+		|	OverlayKey
+			{ $$= $1; }
+		;
+
+OverlayKey	:	KeyName EQUALS KeyName
+			{ $$= OverlayKeyCreate($1,$3); }
+		;
+
+OutlineList	:	OutlineList COMMA OutlineInList
+			{ $$=(OutlineDef *)AppendStmt(&$1->common,&$3->common);}
+		|	OutlineInList
+			{ $$= $1; }
+		;
+
+OutlineInList	:	OBRACE CoordList CBRACE
+			{ $$= OutlineCreate(None,$2); }
+		|	Ident EQUALS OBRACE CoordList CBRACE
+			{ $$= OutlineCreate($1,$4); }
+		|	Ident EQUALS Expr
+			{ $$= OutlineCreate($1,$3); }
+		;
+
+CoordList	:	CoordList COMMA Coord
+			{ $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
+		|	Coord
+			{ $$= $1; }
+		;
+
+Coord		:	OBRACKET Number COMMA Number CBRACKET
+			{
+			    ExprDef *expr;
+			    expr= ExprCreate(ExprCoord,TypeUnknown);
+			    expr->value.coord.x= $2;
+			    expr->value.coord.y= $4;
+			    $$= expr;
+			}
+		;
+
+DoodadDecl	:	DoodadType String OBRACE VarDeclList CBRACE SEMI
+			{ $$= DoodadCreate($1,$2,$4); }
+		;
+
+DoodadType	:	TEXT			{ $$= XkbTextDoodad; }
+		|	OUTLINE			{ $$= XkbOutlineDoodad; }
+		|	SOLID			{ $$= XkbSolidDoodad; }
+		|	LOGO			{ $$= XkbLogoDoodad; }
+		;
+
+FieldSpec	:	Ident			{ $$= $1; }
+		|	Element			{ $$= $1; }
+		;
+
+Element		:	ACTION_TOK		
+			{ $$= XkbInternAtom(NULL,"action",False); }
+		|	INTERPRET
+			{ $$= XkbInternAtom(NULL,"interpret",False); }
+		|	TYPE
+			{ $$= XkbInternAtom(NULL,"type",False); }
+		|	KEY
+			{ $$= XkbInternAtom(NULL,"key",False); }
+		|	GROUP
+			{ $$= XkbInternAtom(NULL,"group",False); }
+		|	MODIFIER_MAP
+			{$$=XkbInternAtom(NULL,"modifier_map",False);}
+		|	INDICATOR
+			{ $$= XkbInternAtom(NULL,"indicator",False); }
+		|	SHAPE	
+			{ $$= XkbInternAtom(NULL,"shape",False); }
+		|	ROW	
+			{ $$= XkbInternAtom(NULL,"row",False); }
+		|	SECTION	
+			{ $$= XkbInternAtom(NULL,"section",False); }
+		|	TEXT
+			{ $$= XkbInternAtom(NULL,"text",False); }
+		;
+
+OptMergeMode	:	MergeMode		{ $$= $1; }
+		|				{ $$= MergeDefault; }
+		;
+
+MergeMode	:	INCLUDE			{ $$= MergeDefault; }
+		|	AUGMENT			{ $$= MergeAugment; }
+		|	OVERRIDE		{ $$= MergeOverride; }
+		|	REPLACE			{ $$= MergeReplace; }
+		|	ALTERNATE		{ $$= MergeAltForm; }
+		;
+
+OptExprList	:	ExprList			{ $$= $1; }
+		|				{ $$= NULL; }
+		;
+
+ExprList	:	ExprList COMMA Expr
+			{ $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
+		|	Expr
+			{ $$= $1; }
+		;
+
+Expr		:	Expr DIVIDE Expr
+			{ $$= ExprCreateBinary(OpDivide,$1,$3); }
+		|	Expr PLUS Expr
+			{ $$= ExprCreateBinary(OpAdd,$1,$3); }
+		|	Expr MINUS Expr
+			{ $$= ExprCreateBinary(OpSubtract,$1,$3); }
+		|	Expr TIMES Expr
+			{ $$= ExprCreateBinary(OpMultiply,$1,$3); }
+		|	Lhs EQUALS Expr
+			{ $$= ExprCreateBinary(OpAssign,$1,$3); }
+		|	Term
+			{ $$= $1; }
+		;
+
+Term		:	MINUS Term
+			{ $$= ExprCreateUnary(OpNegate,$2->type,$2); }
+		|	PLUS Term
+			{ $$= ExprCreateUnary(OpUnaryPlus,$2->type,$2); }
+		|	EXCLAM Term
+			{ $$= ExprCreateUnary(OpNot,TypeBoolean,$2); }
+		|	INVERT Term
+			{ $$= ExprCreateUnary(OpInvert,$2->type,$2); }
+		|	Lhs
+			{ $$= $1;  }
+		|	FieldSpec OPAREN OptExprList CPAREN %prec OPAREN
+			{ $$= ActionCreate($1,$3); }
+		|	Terminal
+			{ $$= $1;  }
+		|	OPAREN Expr CPAREN
+			{ $$= $2;  }
+		;
+
+ActionList	:	ActionList COMMA Action
+			{ $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
+		|	Action
+			{ $$= $1; }
+		;
+
+Action		:	FieldSpec OPAREN OptExprList CPAREN
+			{ $$= ActionCreate($1,$3); }
+		;
+
+Lhs		:	FieldSpec
+			{
+			    ExprDef *expr;
+                            expr= ExprCreate(ExprIdent,TypeUnknown);
+                            expr->value.str= $1;
+                            $$= expr;
+			}
+		|	FieldSpec DOT FieldSpec
+                        {
+                            ExprDef *expr;
+                            expr= ExprCreate(ExprFieldRef,TypeUnknown);
+                            expr->value.field.element= $1;
+                            expr->value.field.field= $3;
+                            $$= expr;
+			}
+		|	FieldSpec OBRACKET Expr CBRACKET
+			{
+			    ExprDef *expr;
+			    expr= ExprCreate(ExprArrayRef,TypeUnknown);
+			    expr->value.array.element= None;
+			    expr->value.array.field= $1;
+			    expr->value.array.entry= $3;
+			    $$= expr;
+			}
+		|	FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET
+			{
+			    ExprDef *expr;
+			    expr= ExprCreate(ExprArrayRef,TypeUnknown);
+			    expr->value.array.element= $1;
+			    expr->value.array.field= $3;
+			    expr->value.array.entry= $5;
+			    $$= expr;
+			}
+		;
+
+Terminal	:	String
+			{
+			    ExprDef *expr;
+                            expr= ExprCreate(ExprValue,TypeString);
+                            expr->value.str= $1;
+                            $$= expr;
+			}
+		|	Integer
+			{
+			    ExprDef *expr;
+                            expr= ExprCreate(ExprValue,TypeInt);
+                            expr->value.ival= $1;
+                            $$= expr;
+			}
+		|	Float
+			{
+			    ExprDef *expr;
+			    expr= ExprCreate(ExprValue,TypeFloat);
+			    expr->value.ival= $1;
+			    $$= expr;
+			}
+		|	KeyName
+			{
+			    ExprDef *expr;
+			    expr= ExprCreate(ExprValue,TypeKeyName);
+			    memcpy(expr->value.keyName,$1,4);
+			    free($1);
+			    $$= expr;
+			}
+		;
+
+OptKeySymList	:	KeySymList			{ $$= $1; }
+		|					{ $$= NULL; }
+		;
+
+KeySymList	:	KeySymList COMMA KeySym
+			{ $$= AppendKeysymList($1,(KeySym)$3); }
+		|	KeySym
+			{ $$= CreateKeysymList((KeySym)$1); }
+		;
+
+KeySym		:	IDENT
+			{ 
+			    KeySym sym;
+			    if (LookupKeysym(scanStr,&sym))
+				$$= sym;
+			    else {
+				char buf[120];
+				sprintf(buf,"expected keysym, got %s",
+							uStringText(scanStr));
+				yyerror(buf);
+				yynerrs++;
+				$$= NoSymbol;
+			    }
+			}
+		|	SECTION
+			{
+			    $$= XK_section;
+			}
+		|	Integer		
+			{
+			    if ($1<10)	$$= $1+'0';	/* XK_0 .. XK_9 */
+			    else	$$= $1;
+			}
+		;
+
+Number		:	FLOAT		{ $$= scanInt; }
+		|	INTEGER		{ $$= scanInt*XkbGeomPtsPerMM; }
+		;
+
+Float		:	FLOAT		{ $$= scanInt; }
+		;
+
+Integer		:	INTEGER		{ $$= scanInt; }
+		;
+
+KeyName		:	KEYNAME		{ $$= scanStr; scanStr= NULL; }
+		;
+
+Ident		:	IDENT	{ $$= XkbInternAtom(NULL,scanStr,False); }
+		|	DEFAULT { $$= XkbInternAtom(NULL,"default",False); }
+		;
+
+String		:	STRING	{ $$= XkbInternAtom(NULL,scanStr,False); }
+		;
+
+OptMapName	:	MapName	{ $$= $1; }
+		|		{ $$= NULL; }
+		;
+
+MapName		:	STRING 	{ $$= scanStr; scanStr= NULL; }
+		;
+%%
+void
+#if NeedFunctionPrototypes
+yyerror(char *s)
+#else
+yyerror(s)
+char	*s;
+#endif
+{
+    if (warningLevel>0) {
+	(void)fprintf(stderr,"%s: line %d of %s\n",s,lineNum,
+					(scanFile?scanFile:"(unknown)"));
+	if ((scanStr)&&(warningLevel>3))
+	    (void)fprintf(stderr,"last scanned symbol is: %s\n",scanStr);
+    }
+    return;
+}
+
+
+int
+#if NeedFunctionPrototypes
+yywrap(void)
+#else
+yywrap()
+#endif
+{
+   return 1;
+}
+
diff --git a/xkbpath.c b/xkbpath.c
new file mode 100644
index 0000000..8e21a7b
--- /dev/null
+++ b/xkbpath.c
@@ -0,0 +1,359 @@
+/* $Xorg: xkbpath.c,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+
+#define	DEBUG_VAR_NOT_LOCAL
+#define	DEBUG_VAR debugFlags
+#include "utils.h"
+#ifndef X_NOT_STDC_ENV
+#include <stdlib.h>
+#endif
+#include <X11/extensions/XKM.h>
+#include "xkbpath.h"
+
+#ifndef DFLT_XKB_CONFIG_ROOT
+#define DFLT_XKB_CONFIG_ROOT	"/usr/lib/X11/xkb"
+#endif
+
+#ifndef PATH_MAX
+#define	PATH_MAX 1024
+#endif
+
+#define	PATH_CHUNK	8
+
+static	int	 longestPath;
+static	int	 szPath;
+static	int	 nPathEntries;
+static	char **	 includePath;
+
+Bool
+#if NeedFunctionPrototypes
+XkbParseIncludeMap(char **str_inout,char **file_rtrn,char **map_rtrn,
+							char *nextop_rtrn)
+#else
+XkbParseIncludeMap(str_inout,file_rtrn,map_rtrn,nextop_rtrn)
+    char **	str_inout;
+    char **	file_rtrn;
+    char **	map_rtrn;
+    char *	nextop_rtrn;
+#endif
+{
+char *tmp,*str,*next;
+
+    str= *str_inout;
+    if ((*str=='+')||(*str=='|')) {
+	*file_rtrn= *map_rtrn= NULL;
+	*nextop_rtrn= *str;
+	next= str+1;
+    }
+    else if (*str=='%') {
+	*file_rtrn= *map_rtrn= NULL;
+	*nextop_rtrn= str[1];
+	next= str+2;
+    }
+    else {
+	next= strpbrk(str,"|+");
+	if (next) {
+	    *nextop_rtrn= *next;
+	    *next++= '\0';
+	}
+	else {
+	    *nextop_rtrn= '\0';
+	    next= NULL;
+	}
+	tmp= strchr(str,'(');
+	if (tmp==NULL) {
+	    *file_rtrn= uStringDup(str);
+	    *map_rtrn= NULL;
+	}
+	else if (str[0]=='(') {
+	    return False;
+	}
+	else {
+	    *tmp++= '\0';
+	    *file_rtrn= uStringDup(str);
+	    str= tmp;
+	    tmp= strchr(str,')');
+	    if ((tmp==NULL)||(tmp[1]!='\0')) {
+		uFree(*file_rtrn);
+		return False;
+	    }
+	    *tmp++= '\0';
+	    *map_rtrn= uStringDup(str);
+	}
+    }
+    if (*nextop_rtrn=='\0')
+	*str_inout= NULL;
+    else if ((*nextop_rtrn=='|')||(*nextop_rtrn=='+'))
+	*str_inout= next;
+    else return False;
+    return True;
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbInitIncludePath(void)
+#else
+XkbInitIncludePath()
+#endif
+{
+    szPath= PATH_CHUNK;
+    includePath=  (char **)calloc(szPath,sizeof(char *));
+    if (includePath==NULL)
+	return False;
+    XkbAddDirectoryToPath(".");
+    XkbAddDirectoryToPath(DFLT_XKB_CONFIG_ROOT);
+    return True;
+}
+
+void
+#if NeedFunctionPrototypes
+XkbClearIncludePath(void)
+#else
+XkbClearIncludePath()
+#endif
+{
+register int i;
+
+    if (szPath>0) {
+	for (i=0;i<nPathEntries;i++) {
+	    if (includePath[i]!=NULL) {
+		uFree(includePath[i]);
+		includePath[i]= NULL;
+	    }
+	}
+	nPathEntries= 0;
+	longestPath= 0;
+    }
+    return;
+}
+
+Bool
+#if NeedFunctionPrototypes
+XkbAddDirectoryToPath(char *dir)
+#else
+XkbAddDirectoryToPath(dir)
+    char	*dir;
+#endif
+{
+int	len;
+    if ((dir==NULL)||(dir[0]=='\0')) {
+	XkbClearIncludePath();
+	return True;
+    }
+    len= strlen(dir);
+    if (len+2>=PATH_MAX) { /* allow for '/' and at least one character */
+	ERROR2("Path entry (%s) too long (maxiumum length is %d)\n",
+							dir,PATH_MAX-3);
+	return False;
+    }
+    if (len>longestPath)
+	longestPath= len;
+    if (nPathEntries>=szPath) {
+	szPath+= PATH_CHUNK;
+	includePath= (char **)realloc(includePath,szPath*sizeof(char *));
+	if (includePath==NULL) {
+	    WSGO("Allocation failed (includePath)\n");
+	    return False;
+	}
+    }
+    includePath[nPathEntries]= (char *)calloc(strlen(dir)+1,sizeof(char));
+    if (includePath[nPathEntries]==NULL) {
+	WSGO1("Allocation failed (includePath[%d])\n",nPathEntries);
+	return False;
+    }
+    strcpy(includePath[nPathEntries++],dir);
+    return True;
+}
+
+/***====================================================================***/
+
+char *
+#if NeedFunctionPrototypes
+XkbDirectoryForInclude(unsigned type)
+#else
+XkbDirectoryForInclude(type)
+    unsigned	type;
+#endif
+{
+static char buf[32];
+
+    switch (type) {
+	case XkmSemanticsFile:
+	    strcpy(buf,"semantics");
+	    break;
+	case XkmLayoutFile:
+	    strcpy(buf,"layout");
+	    break;
+	case XkmKeymapFile:
+	    strcpy(buf,"keymap");
+	    break;
+	case XkmKeyNamesIndex:
+	    strcpy(buf,"keycodes");
+	    break;
+	case XkmTypesIndex:
+	    strcpy(buf,"types");
+	    break;
+	case XkmSymbolsIndex:
+	    strcpy(buf,"symbols");
+	    break;
+	case XkmCompatMapIndex:
+	    strcpy(buf,"compat");
+	    break;
+	case XkmGeometryFile:
+	case XkmGeometryIndex:
+	    strcpy(buf,"geometry");
+	    break;
+	default:
+	    strcpy(buf,"");
+	    break;
+    }
+    return buf;
+}
+
+/***====================================================================***/
+
+typedef struct _FileCacheEntry {
+	char *				name;
+	unsigned			type;
+	char *				path;
+	void *				data;
+	struct _FileCacheEntry *	next;
+} FileCacheEntry;
+static FileCacheEntry	*fileCache;
+
+void *
+#if NeedFunctionPrototypes
+XkbAddFileToCache(char *name,unsigned type,char *path,void *data)
+#else
+XkbAddFileToCache(name,type,path,data)
+    char *	name;
+    unsigned	type;
+    char *	path;
+    void *	data;
+#endif
+{
+FileCacheEntry	*entry;
+
+    for (entry=fileCache;entry!=NULL;entry=entry->next) {
+	if ((type==entry->type)&&(uStringEqual(name,entry->name))) {
+	    void *old= entry->data;
+	    WSGO2("Replacing file cache entry (%s/%d)\n",name,type);
+	    entry->path= path;
+	    entry->data= data;
+	    return old;
+	}
+    }
+    entry= uTypedAlloc(FileCacheEntry);
+    if (entry!=NULL) {
+	entry->name= name;
+	entry->type= type;
+	entry->path= path;
+	entry->data= data;
+	entry->next= fileCache;
+	fileCache= entry;
+    }
+    return NULL;
+}
+
+void *
+#if NeedFunctionPrototypes
+XkbFindFileInCache(char *name,unsigned type,char **pathRtrn)
+#else
+XkbFindFileInCache(name,type,pathRtrn)
+    char *	name;
+    unsigned	type;
+    char **	pathRtrn;
+#endif
+{
+FileCacheEntry	*entry;
+
+    for (entry=fileCache;entry!=NULL;entry=entry->next) {
+	if ((type==entry->type)&&(uStringEqual(name,entry->name))) {
+	   *pathRtrn= entry->path;
+	   return entry->data;
+	}
+    }
+    return NULL;
+}
+
+/***====================================================================***/
+
+FILE *
+#if NeedFunctionPrototypes
+XkbFindFileInPath(char *name,unsigned type,char **pathRtrn)
+#else
+XkbFindFileInPath(name,type,pathRtrn)
+    char *	name;
+    unsigned	type;
+    char **	pathRtrn;
+#endif
+{
+register int i;
+FILE	*file= NULL;
+int	 nameLen,typeLen,pathLen;
+char	 buf[PATH_MAX],*typeDir;
+
+    typeDir= XkbDirectoryForInclude(type);
+    nameLen= strlen(name);
+    typeLen= strlen(typeDir);
+    for (i=0;i<nPathEntries;i++) {
+	pathLen= strlen(includePath[i]);
+	if ((nameLen+pathLen+1)>=PATH_MAX) {
+	    ERROR2("File name (%s/%s) too long\n",includePath[i],name);
+	    ACTION("Ignored\n");
+	    continue;
+	}
+	sprintf(buf,"%s/%s",includePath[i],name);
+	file= fopen(buf,"r");
+	if (file!=NULL)
+	     break;
+	else if (typeLen<1)
+	     continue;
+
+	if ((nameLen+typeLen+pathLen+2)>=PATH_MAX) {
+	    ERROR3("File name (%s/%s/%s) too long\n",includePath[i],typeDir,
+	    							    name);
+	    ACTION("Ignored\n");
+	    continue;
+	}
+	sprintf(buf,"%s/%s/%s",includePath[i],typeDir,name);
+	file= fopen(buf,"r");
+	if (file!=NULL)
+	    break;
+    }
+
+    if ((file!=NULL)&&(pathRtrn!=NULL)) {
+	*pathRtrn= (char *)calloc(strlen(buf)+1,sizeof(char));
+	if (*pathRtrn!=NULL)
+	    strcpy(*pathRtrn,buf);
+    }
+    return file;
+}
+
diff --git a/xkbpath.h b/xkbpath.h
new file mode 100644
index 0000000..c12a2ad
--- /dev/null
+++ b/xkbpath.h
@@ -0,0 +1,89 @@
+/* $XConsortium $ */
+/************************************************************
+ Copyright (c) 1994 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 _XKBPATH_H_
+#define _XKBPATH_H_ 1
+
+extern	Bool	XkbInitIncludePath(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+
+extern	void	XkbClearIncludePath(
+#if NeedFunctionPrototypes
+	void
+#endif
+);
+
+extern	Bool	XkbAddDirectoryToPath(
+#if NeedFunctionPrototypes
+	char *	/* dir */
+#endif
+);
+
+extern char *	XkbDirectoryForInclude(
+#if NeedFunctionPrototypes
+    unsigned	/* type */
+#endif
+);
+
+extern	FILE	*XkbFindFileInPath(
+#if NeedFunctionPrototypes
+    char *	/* name */,
+    unsigned	/* type */,
+    char **	/* pathRtrn */
+#endif
+);
+
+extern	void *	XkbAddFileToCache(
+#if NeedFunctionPrototypes
+    char *	/* name */,
+    unsigned	/* type */,
+    char *	/* path */,
+    void *	/* data */
+#endif
+);
+
+extern	void *	XkbFindFileInCache(
+#if NeedFunctionPrototypes
+    char *	/* name */,
+    unsigned	/* type */,
+    char **	/* pathRtrn */
+#endif
+);
+
+extern Bool	XkbParseIncludeMap(
+#if NeedFunctionPrototypes
+    char **	/* str_inout */,
+    char **	/* file_rtrn */,
+    char **	/* map_rtrn */,
+    char *	/* nextop_rtrn */
+#endif
+);
+
+#endif /* _XKBPATH_H_ */
diff --git a/xkbscan.c b/xkbscan.c
new file mode 100644
index 0000000..9cda90d
--- /dev/null
+++ b/xkbscan.c
@@ -0,0 +1,496 @@
+/* $Xorg: xkbscan.c,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ */
+/************************************************************
+ Copyright (c) 1994 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.
+
+ ********************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+
+#include "tokens.h"
+#define	DEBUG_VAR	scanDebug
+#include "utils.h"
+
+FILE	*yyin = stdin;
+
+static char scanFileBuf[1024];
+char *	 scanFile= scanFileBuf;
+int	 lineNum=	0;
+
+int	 scanInt;
+char	*scanIntStr;
+int	 scanIntClass;
+
+char	*scanStr = NULL;
+int	 scanStrLine=	0;
+
+#define	BUFSIZE	512
+static	int	nInBuf = 0;
+static	char	buf[BUFSIZE];
+
+#ifdef DEBUG
+
+extern	unsigned debugFlags;
+
+static char *
+#if NeedFunctionPrototypes
+tokText(int tok)
+#else
+tokText(tok)
+    int tok;
+#endif
+{
+static char buf[32];
+
+    switch (tok) {
+	case END_OF_FILE:	sprintf(buf, "END_OF_FILE");break;
+	case ERROR_TOK:		sprintf(buf, "ERROR");	break;
+
+	case XKB_KEYMAP:	sprintf(buf, "XKB_KEYMAP"); break;
+	case XKB_KEYCODES:	sprintf(buf, "XKB_KEYCODES"); break;
+	case XKB_TYPES:		sprintf(buf, "XKB_TYPES"); break;
+	case XKB_SYMBOLS:	sprintf(buf, "XKB_SYMBOLS"); break;
+	case XKB_COMPATMAP:	sprintf(buf, "XKB_COMPATMAP"); break;
+	case XKB_GEOMETRY:	sprintf(buf, "XKB_GEOMETRY"); break;
+	case XKB_SEMANTICS:	sprintf(buf, "XKB_SEMANTICS"); break;
+	case XKB_LAYOUT:	sprintf(buf, "XKB_LAYOUT"); break;
+
+	case INCLUDE:		sprintf(buf, "INCLUDE"); break;
+	case OVERRIDE:		sprintf(buf, "OVERRIDE"); break;
+	case AUGMENT:		sprintf(buf, "AUGMENT"); break;
+	case REPLACE:		sprintf(buf, "REPLACE"); break;
+	case ALTERNATE:		sprintf(buf, "ALTERNATE"); break;
+
+	case VIRTUAL_MODS:	sprintf(buf, "VIRTUAL_MODS"); break;
+	case TYPE:		sprintf(buf, "TYPE"); break;
+	case INTERPRET:		sprintf(buf, "INTERPRET"); break;
+	case ACTION_TOK:	sprintf(buf, "ACTION"); break;
+	case KEY:		sprintf(buf, "KEY"); break;
+	case ALIAS:		sprintf(buf, "ALIAS"); break;
+	case GROUP:		sprintf(buf, "GROUP"); break;
+	case MODIFIER_MAP:	sprintf(buf, "MODIFIER_MAP"); break;
+	case INDICATOR:		sprintf(buf, "INDICATOR"); break;
+	case SHAPE:		sprintf(buf, "SHAPE"); break;
+	case KEYS:		sprintf(buf, "KEYS"); break;
+	case ROW:		sprintf(buf, "ROW"); break;
+	case SECTION:		sprintf(buf, "SECTION"); break;
+	case OVERLAY:		sprintf(buf, "OVERLAY"); break;
+	case TEXT:		sprintf(buf, "TEXT"); break;
+	case OUTLINE:		sprintf(buf, "OUTLINE"); break;
+	case SOLID:		sprintf(buf, "SOLID"); break;
+	case LOGO:		sprintf(buf, "LOGO"); break;
+	case VIRTUAL:		sprintf(buf, "VIRTUAL"); break;
+
+	case EQUALS:		sprintf(buf, "EQUALS");	break;
+	case PLUS:		sprintf(buf, "PLUS");	break;
+	case MINUS:		sprintf(buf, "MINUS");	break;
+	case DIVIDE:		sprintf(buf, "DIVIDE");	break;
+	case TIMES:		sprintf(buf, "TIMES");	break;
+	case OBRACE:		sprintf(buf, "OBRACE");	break;
+	case CBRACE:		sprintf(buf, "CBRACE");	break;
+	case OPAREN:		sprintf(buf, "OPAREN");	break;
+	case CPAREN:		sprintf(buf, "CPAREN");	break;
+	case OBRACKET:		sprintf(buf, "OBRACKET");break;
+	case CBRACKET:		sprintf(buf, "CBRACKET");break;
+	case DOT:		sprintf(buf, "DOT");	break;
+	case COMMA:		sprintf(buf, "COMMA");	break;
+	case SEMI:		sprintf(buf, "SEMI");	break;
+	case EXCLAM:		sprintf(buf, "EXCLAM");	break;
+	case INVERT:		sprintf(buf, "INVERT");	break;
+
+	case STRING:		sprintf(buf, "STRING (%s)",scanStr);	break;
+	case INTEGER:		sprintf(buf, "INTEGER (0x%x)",scanInt);	break;
+	case FLOAT:		sprintf(buf, "FLOAT (%d.%d)",
+					     scanInt/XkbGeomPtsPerMM,
+					     scanInt%XkbGeomPtsPerMM);break;
+	case IDENT:		sprintf(buf, "IDENT (%s)",scanStr);	break;
+	case KEYNAME:		sprintf(buf, "KEYNAME (%s)",scanStr);	break;
+
+	case PARTIAL:		sprintf(buf, "PARTIAL"); break;
+	case DEFAULT:		sprintf(buf, "DEFAULT"); break;
+	case HIDDEN:		sprintf(buf, "HIDDEN"); break;
+
+	case ALPHANUMERIC_KEYS:	sprintf(buf, "ALPHANUMERIC_KEYS"); break;
+	case MODIFIER_KEYS:	sprintf(buf, "MODIFIER_KEYS"); break;
+	case KEYPAD_KEYS:	sprintf(buf, "KEYPAD_KEYS"); break;
+	case FUNCTION_KEYS:	sprintf(buf, "FUNCTION_KEYS"); break;
+	case ALTERNATE_GROUP:	sprintf(buf, "ALTERNATE_GROUP"); break;
+
+	default:		sprintf(buf, "UNKNOWN");	break;
+    }
+    return buf;
+}
+#endif
+
+int
+#if NeedFunctionPrototypes
+setScanState(char *file,int line)
+#else
+setScanState(file,line)
+    char *	file;
+    int 	line;
+#endif
+{
+    if (file!=NULL)
+	strncpy(scanFile,file,1024);
+    if (line>=0)
+	lineNum= line;
+    return 1;
+}
+
+int
+#if NeedFunctionPrototypes
+yyGetString(void)
+#else
+yyGetString()
+#endif
+{
+int ch;
+
+    nInBuf = 0;
+    while ( ((ch=getc(yyin))!=EOF) && (ch!='"') ) {
+	if ( ch == '\\' ) {
+	    if ((ch = getc(yyin))!=EOF) {
+		if ( ch=='n' )		ch = '\n';
+		else if ( ch == 't' )	ch = '\t';
+		else if ( ch == 'v' )	ch = '\v';
+		else if ( ch == 'b' )	ch = '\b';
+		else if ( ch == 'r' )	ch = '\r';
+		else if ( ch == 'f' )	ch = '\f';
+		else if ( ch == 'e' )	ch = '\033';
+		else if ( ch == '0' ) {
+		    int tmp,stop;
+		    ch = stop = 0;
+		    if (((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		    if ((!stop) && ((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		    if ((!stop) && ((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		}
+	    }
+	    else return ERROR_TOK;
+	}
+
+	if ( nInBuf < BUFSIZE-1 ) 
+	    buf[nInBuf++] = ch;
+    }
+    if ( ch == '"' ) {
+	buf[nInBuf++] = '\0';
+	if  ( scanStr )
+	    uFree( scanStr );
+	scanStr = (char *)uStringDup(buf);
+	scanStrLine = lineNum;
+	return STRING;
+    }
+    return ERROR_TOK;
+}
+
+int
+#if NeedFunctionPrototypes
+yyGetKeyName(void)
+#else
+yyGetKeyName()
+#endif
+{
+int ch;
+
+    nInBuf = 0;
+    while ( ((ch=getc(yyin))!=EOF) && (ch!='>') ) {
+	if ( ch == '\\' ) {
+	    if ((ch = getc(yyin))!=EOF) {
+		if ( ch=='n' )		ch = '\n';
+		else if ( ch == 't' )	ch = '\t';
+		else if ( ch == 'v' )	ch = '\v';
+		else if ( ch == 'b' )	ch = '\b';
+		else if ( ch == 'r' )	ch = '\r';
+		else if ( ch == 'f' )	ch = '\f';
+		else if ( ch == 'e' )	ch = '\033';
+		else if ( ch == '0' ) {
+		    int tmp,stop;
+		    ch = stop = 0;
+		    if (((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		    if ((!stop) && ((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		    if ((!stop) && ((tmp=getc(yyin))!=EOF) && (isdigit(tmp)) && 
+						(tmp!='8') && (tmp!='9')) {
+			ch= (ch*8)+(tmp-'0');
+		    }
+		    else {
+			stop= 1;
+			ungetc(tmp,yyin);
+		    }
+		}
+	    }
+	    else return ERROR_TOK;
+	}
+
+	if ( nInBuf < BUFSIZE-1 ) 
+	    buf[nInBuf++] = ch;
+    }
+    if (( ch == '>' )&&(nInBuf<5)) {
+	buf[nInBuf++] = '\0';
+	if  ( scanStr )
+	    uFree( scanStr );
+	scanStr = (char *)uStringDup(buf);
+	scanStrLine = lineNum;
+	return KEYNAME;
+    }
+    return ERROR_TOK;
+}
+
+struct _Keyword {
+	char	*keyword;
+	int	 token;
+} keywords[] = {
+    { "xkb_keymap",		XKB_KEYMAP		},
+    { "xkb_keycodes",		XKB_KEYCODES		},
+    { "xkb_types",		XKB_TYPES		},
+    { "xkb_symbols",		XKB_SYMBOLS		},
+    { "xkb_compat",		XKB_COMPATMAP		},
+    { "xkb_compat_map",		XKB_COMPATMAP		},
+    { "xkb_compatibility",	XKB_COMPATMAP		},
+    { "xkb_compatibility_map",	XKB_COMPATMAP		},
+    { "xkb_geometry",		XKB_GEOMETRY		},
+    { "xkb_semantics",		XKB_SEMANTICS		},
+    { "xkb_layout",		XKB_LAYOUT		},
+    { "include",		INCLUDE			},
+    { "override",		OVERRIDE		},
+    { "augment",		AUGMENT			},
+    { "replace",		REPLACE			},
+    { "alternate",		ALTERNATE		},
+    { "partial",		PARTIAL			},
+    { "default",		DEFAULT			},
+    { "hidden",			HIDDEN			},
+    { "virtual_modifiers",	VIRTUAL_MODS		},
+    { "type",			TYPE			},
+    { "interpret",		INTERPRET		},
+    { "action",			ACTION_TOK		},
+    { "key",			KEY			},
+    { "alias",			ALIAS			},
+    { "group",			GROUP			},
+    { "modmap",			MODIFIER_MAP		},
+    { "mod_map",		MODIFIER_MAP		},
+    { "modifier_map",		MODIFIER_MAP		},
+    { "indicator",		INDICATOR		},
+    { "shape",			SHAPE			},
+    { "row",			ROW			},
+    { "keys",			KEYS			},
+    { "section",		SECTION			},
+    { "overlay",		OVERLAY			},
+    { "text",			TEXT			},
+    { "outline",		OUTLINE			},
+    { "solid",			SOLID			},
+    { "logo",			LOGO			},
+    { "virtual",		VIRTUAL			},
+    { "alphanumeric_keys",	ALPHANUMERIC_KEYS	},
+    { "modifier_keys",		MODIFIER_KEYS		},
+    { "keypad_keys",		KEYPAD_KEYS		},
+    { "function_keys",		FUNCTION_KEYS		},
+    { "alternate_group",	ALTERNATE_GROUP		}
+};
+int	numKeywords = sizeof(keywords)/sizeof(struct _Keyword);
+
+int
+#if NeedFunctionPrototypes
+yyGetIdent(int first)
+#else
+yyGetIdent(first)
+    int first;
+#endif
+{
+int ch,i,found;
+int	rtrn= IDENT;
+
+    buf[0] = first; nInBuf = 1;
+    while ( ((ch=getc(yyin))!=EOF) && (isalnum(ch)||(ch=='_')) ) {
+	if ( nInBuf < BUFSIZE - 1 )
+	    buf[nInBuf++] = ch;
+    }
+    buf[nInBuf++] = '\0';
+    found= 0;
+
+    for (i=0;(!found)&&(i<numKeywords);i++) {
+	if (uStrCaseCmp(buf,keywords[i].keyword)==0) {
+	    rtrn= keywords[i].token;
+	    found= 1;
+	}
+    }
+    if (!found) {
+	if  ( scanStr )
+	    uFree( scanStr );
+	scanStr = (char *)uStringDup(buf);
+	scanStrLine = lineNum;
+	rtrn = IDENT;
+    }
+
+    if ( (ch!=EOF) && (!isspace(ch)) )
+	ungetc( ch, yyin );
+    else if ( ch=='\n' )
+	lineNum++;
+
+    return rtrn;
+}
+
+int
+#if NeedFunctionPrototypes
+yyGetNumber(int ch)
+#else
+yyGetNumber(ch)
+    int ch;
+#endif
+{
+int	isFloat= 0;
+
+    buf[0]= ch;
+    nInBuf= 1;
+    while (((ch=getc(yyin))!=EOF)&&(isxdigit(ch)||((nInBuf==1)&&(ch=='x')))) {
+	buf[nInBuf++]= ch;
+    }
+    if (ch=='.') {
+	isFloat= 1;
+	buf[nInBuf++]= ch;
+	while (((ch=getc(yyin))!=EOF)&&(isxdigit(ch))) {
+	    buf[nInBuf++]= ch;
+	}
+    }
+    buf[nInBuf++]= '\0';
+    if ((ch!=EOF)&&(!isspace(ch)))
+	ungetc( ch, yyin );
+
+    if (isFloat) {
+	float tmp;
+	if (sscanf(buf,"%g",&tmp)==1) {
+	    scanInt= tmp*XkbGeomPtsPerMM;
+	    return FLOAT;
+	}
+    }
+    else if ( sscanf(buf,"%i",&scanInt)==1 )
+	return INTEGER;
+    fprintf(stderr,"Malformed number %s\n",buf);
+    return ERROR_TOK;
+}
+
+int
+#if NeedFunctionPrototypes
+yylex(void)
+#else
+yylex()
+#endif
+{
+int	ch;
+int	rtrn;
+    
+    do {
+	ch = getc(yyin);
+	if ( ch == '\n' ) {
+	    lineNum++;
+	}
+	else if ( ch=='#' ) {	/* handle shell style '#' comments */
+	    do {
+		ch= getc(yyin);
+	    } while ((ch!='\n')&&(ch!=EOF));
+	    lineNum++;
+	}
+	else if ( ch=='/' ) {	/* handle C++ style double-/ comments */
+	    int newch= getc(yyin);
+	    if (newch=='/') {
+		do {
+		    ch= getc(yyin);
+		} while ((ch!='\n')&&(ch!=EOF));
+		lineNum++;
+	    }
+	    else if (newch!=EOF) {
+		ungetc(newch,yyin);
+	    }
+	}
+    } while ((ch!=EOF)&&(isspace(ch)));
+    if ( ch == '=' )			rtrn = EQUALS;
+    else if ( ch == '+' )		rtrn = PLUS;
+    else if ( ch == '-' )		rtrn = MINUS;
+    else if ( ch == '/' )		rtrn = DIVIDE;
+    else if ( ch == '*' )		rtrn = TIMES;
+    else if ( ch == '{' )		rtrn = OBRACE;
+    else if ( ch == '}' )		rtrn = CBRACE;
+    else if ( ch == '(' )		rtrn = OPAREN;
+    else if ( ch == ')' )		rtrn = CPAREN;
+    else if ( ch == '[' )		rtrn = OBRACKET;
+    else if ( ch == ']' )		rtrn = CBRACKET;
+    else if ( ch == '.' )		rtrn = DOT;
+    else if ( ch == ',' )		rtrn = COMMA;
+    else if ( ch == ';' )		rtrn = SEMI;
+    else if ( ch == '!' )		rtrn = EXCLAM;
+    else if ( ch == '~' )		rtrn = INVERT;
+    else if ( ch == '"' )		rtrn = yyGetString();
+    else if ( ch == '<' )		rtrn = yyGetKeyName();
+    else if ( isalpha(ch) || (ch=='_')) rtrn = yyGetIdent(ch);
+    else if ( isdigit(ch) )		rtrn = yyGetNumber(ch);
+    else if ( ch == EOF )		rtrn = END_OF_FILE;
+    else {
+#ifdef DEBUG
+    if (debugFlags)
+	fprintf(stderr,"Unexpected character %c (%d) in input stream\n",ch,ch);
+#endif
+	rtrn = ERROR_TOK;
+    }
+#ifdef DEBUG
+    if (debugFlags&0x2)
+	fprintf(stderr,"scan: %s\n",tokText(rtrn));
+#endif
+    return rtrn;
+}