R6.6 is the Xorg base-lineXORG-MAIN

1 files changed, 1467 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;
+}
+