R6.6 is the Xorg base-lineXORG-MAIN

1 files changed, 1920 insertions, 0 deletions

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