summaryrefslogtreecommitdiff
path: root/symbols.c
diff options
context:
space:
mode:
authorPeter Hutterer <peter.hutterer@redhat.com>2008-08-11 15:47:09 +0930
committerPeter Hutterer <peter.hutterer@redhat.com>2008-08-12 10:54:45 +0930
commitca32570cf16494fb8e0577de8b05ba18cb927ce1 (patch)
treee216eb5c189e3f73fcaab49fbc094f581fab9364 /symbols.c
parent12e8f5e5b3f33dbd1290c76dd0d6a4cf832993d7 (diff)
Indent fixes.
indent -cbi 0 -nprs -nut -npcs -i4 -bli 0 *.c *.h
Diffstat (limited to 'symbols.c')
-rw-r--r--symbols.c3462
1 files changed, 1883 insertions, 1579 deletions
diff --git a/symbols.c b/symbols.c
index 40203f2..7c1807a 100644
--- a/symbols.c
+++ b/symbols.c
@@ -39,9 +39,9 @@
#include "misc.h"
#include "alias.h"
-extern Atom tok_ONE_LEVEL;
-extern Atom tok_TWO_LEVEL;
-extern Atom tok_KEYPAD;
+extern Atom tok_ONE_LEVEL;
+extern Atom tok_TWO_LEVEL;
+extern Atom tok_KEYPAD;
/***====================================================================***/
@@ -58,688 +58,805 @@ extern Atom tok_KEYPAD;
#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;
+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
-InitKeyInfo(KeyInfo *info)
+InitKeyInfo(KeyInfo * info)
{
-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;
+ 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
-FreeKeyInfo(KeyInfo *info)
+FreeKeyInfo(KeyInfo * info)
{
-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;
+ 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
-CopyKeyInfo(KeyInfo *old,KeyInfo *new,Bool clearOld)
+CopyKeyInfo(KeyInfo * old, KeyInfo * new, Bool clearOld)
{
-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));
- }
- }
+ 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;
+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 explicit_group;
- unsigned groupInfo;
- unsigned szKeys;
- unsigned nKeys;
- KeyInfo * keys;
- KeyInfo dflt;
- VModInfo vmods;
- ActionInfo * action;
- Atom groupNames[XkbNumKbdGroups];
-
- ModMapEntry * modMap;
- AliasInfo * aliases;
+typedef struct _SymbolsInfo
+{
+ char *name;
+ int errorCount;
+ unsigned fileID;
+ unsigned merge;
+ unsigned explicit_group;
+ unsigned groupInfo;
+ unsigned szKeys;
+ unsigned nKeys;
+ KeyInfo *keys;
+ KeyInfo dflt;
+ VModInfo vmods;
+ ActionInfo *action;
+ Atom groupNames[XkbNumKbdGroups];
+
+ ModMapEntry *modMap;
+ AliasInfo *aliases;
} SymbolsInfo;
static void
-InitSymbolsInfo(SymbolsInfo *info,XkbDescPtr xkb)
+InitSymbolsInfo(SymbolsInfo * info, XkbDescPtr xkb)
{
-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->explicit_group= 0;
- 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;
+ 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->explicit_group = 0;
+ 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;
+ InitVModInfo(&info->vmods, xkb);
+ info->action = NULL;
+ info->aliases = NULL;
return;
}
static void
-FreeSymbolsInfo(SymbolsInfo *info)
+FreeSymbolsInfo(SymbolsInfo * info)
{
-register int i;
+ 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));
+ 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
-ResizeKeyGroup( KeyInfo * key,
- unsigned group,
- unsigned atLeastSize,
- Bool forceActions)
+ResizeKeyGroup(KeyInfo * key,
+ unsigned group, unsigned atLeastSize, Bool forceActions)
{
-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;
+ 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
-MergeKeyGroups( SymbolsInfo * info,
- KeyInfo * into,
- KeyInfo * from,
- unsigned group)
+MergeKeyGroups(SymbolsInfo * info,
+ KeyInfo * into, KeyInfo * from, unsigned group)
{
-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]);
- if ((into->acts[group]!=NULL)&&(resultActs!=into->acts[group]))
- uFree(into->acts[group]);
- if ((from->acts[group]!=NULL)&&(resultActs!=from->acts[group]))
- uFree(from->acts[group]);
- into->numLevels[group]= resultWidth;
- into->syms[group]= resultSyms;
- from->syms[group]= NULL;
- into->acts[group]= resultActs;
- from->acts[group]= NULL;
- into->symsDefined|= (1<<group);
- from->symsDefined&= ~(1<<group);
- into->actsDefined|= (1<<group);
- from->actsDefined&= ~(1<<group);
+ 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]);
+ if ((into->acts[group] != NULL) && (resultActs != into->acts[group]))
+ uFree(into->acts[group]);
+ if ((from->acts[group] != NULL) && (resultActs != from->acts[group]))
+ uFree(from->acts[group]);
+ into->numLevels[group] = resultWidth;
+ into->syms[group] = resultSyms;
+ from->syms[group] = NULL;
+ into->acts[group] = resultActs;
+ from->acts[group] = NULL;
+ into->symsDefined |= (1 << group);
+ from->symsDefined &= ~(1 << group);
+ into->actsDefined |= (1 << group);
+ from->actsDefined &= ~(1 << group);
return True;
}
static Bool
-MergeKeys(SymbolsInfo *info,KeyInfo *into,KeyInfo *from)
+MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from)
{
-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"));
+ 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
-AddKeySymbols(SymbolsInfo *info,KeyInfo *key,XkbDescPtr xkb)
+AddKeySymbols(SymbolsInfo * info, KeyInfo * key, XkbDescPtr xkb)
{
-register int i;
-unsigned long real_name;
-
- for (i=0;i<info->nKeys;i++) {
- if (info->keys[i].name==key->name)
- return MergeKeys(info,&info->keys[i],key);
- }
- if(FindKeyNameForAlias(xkb, key->name, &real_name)) {
- for (i=0;i<info->nKeys;i++) {
- if (info->keys[i].name==real_name)
- return MergeKeys(info,&info->keys[i],key);
+ register int i;
+ unsigned long real_name;
+
+ for (i = 0; i < info->nKeys; i++)
+ {
+ if (info->keys[i].name == key->name)
+ return MergeKeys(info, &info->keys[i], key);
+ }
+ if (FindKeyNameForAlias(xkb, key->name, &real_name))
+ {
+ for (i = 0; i < info->nKeys; i++)
+ {
+ if (info->keys[i].name == real_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;
- }
+ 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);
+ return CopyKeyInfo(key, &info->keys[info->nKeys++], True);
}
static Bool
-AddModMapEntry(SymbolsInfo *info,ModMapEntry *new)
+AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
{
-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;
+ 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
-MergeIncludedSymbols(SymbolsInfo *into,SymbolsInfo *from,
- unsigned merge,XkbDescPtr xkb)
+MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
+ unsigned merge, XkbDescPtr xkb)
{
-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,xkb))
- 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++;
+ 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, xkb))
+ 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)(
- XkbFile * /* rtrn */,
- XkbDescPtr /* xkb */,
- unsigned /* merge */,
- SymbolsInfo * /* included */
-);
+typedef void (*FileHandler) (XkbFile * /* rtrn */ ,
+ XkbDescPtr /* xkb */ ,
+ unsigned /* merge */ ,
+ SymbolsInfo * /* included */
+ );
static Bool
-HandleIncludeSymbols( IncludeStmt * stmt,
- XkbDescPtr xkb,
- SymbolsInfo * info,
- FileHandler hndlr)
+HandleIncludeSymbols(IncludeStmt * stmt,
+ XkbDescPtr xkb, SymbolsInfo * info, FileHandler hndlr)
{
-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;
- if (stmt->modifier) {
- included.explicit_group= atoi(stmt->modifier) - 1;
- } else {
- included.explicit_group= info->explicit_group;
- }
- (*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,xkb);
- 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;
- if (next->modifier) {
- next_incl.explicit_group= atoi(next->modifier) - 1;
- } else {
- next_incl.explicit_group= info->explicit_group;
+ 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;
+ if (stmt->modifier)
+ {
+ included.explicit_group = atoi(stmt->modifier) - 1;
+ }
+ else
+ {
+ included.explicit_group = info->explicit_group;
+ }
+ (*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, xkb);
+ 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;
+ if (next->modifier)
+ {
+ next_incl.explicit_group = atoi(next->modifier) - 1;
}
- (*hndlr)(rtrn,xkb,MergeOverride,&next_incl);
- MergeIncludedSymbols(&included,&next_incl,op,xkb);
- FreeSymbolsInfo(&next_incl);
- }
- else {
- info->errorCount+= 10;
- return False;
- }
- }
+ else
+ {
+ next_incl.explicit_group = info->explicit_group;
+ }
+ (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
+ MergeIncludedSymbols(&included, &next_incl, op, xkb);
+ FreeSymbolsInfo(&next_incl);
+ }
+ else
+ {
+ info->errorCount += 10;
+ return False;
+ }
+ }
}
if (haveSelf)
- *info= included;
- else {
- MergeIncludedSymbols(info,&included,newMerge,xkb);
- FreeSymbolsInfo(&included);
+ *info = included;
+ else
+ {
+ MergeIncludedSymbols(info, &included, newMerge, xkb);
+ FreeSymbolsInfo(&included);
}
- return (info->errorCount==0);
+ 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 }
+static LookupEntry groupNames[] = {
+ {"group1", 1},
+ {"group2", 2},
+ {"group3", 3},
+ {"group4", 4},
+ {"group5", 5},
+ {"group6", 6},
+ {"group7", 7},
+ {"group8", 8},
+ {NULL, 0}
};
@@ -747,765 +864,873 @@ static LookupEntry groupNames[]= {
#define ACTIONS 2
static Bool
-GetGroupIndex( KeyInfo * key,
- ExprDef * arrayNdx,
- unsigned what,
- unsigned * ndx_rtrn)
+GetGroupIndex(KeyInfo * key,
+ ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
{
-const 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;
+ const 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
-AddSymbolsToKey( KeyInfo * key,
- XkbDescPtr xkb,
- char * field,
- ExprDef * arrayNdx,
- ExprDef * value,
- SymbolsInfo * info)
+AddSymbolsToKey(KeyInfo * key,
+ XkbDescPtr xkb,
+ char *field,
+ ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
{
-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));
- for (i=key->numLevels[ndx]-1;(i>=0)&&(key->syms[ndx][i]==NoSymbol);i--) {
- key->numLevels[ndx]--;
+ 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));
+ for (i = key->numLevels[ndx] - 1;
+ (i >= 0) && (key->syms[ndx][i] == NoSymbol); i--)
+ {
+ key->numLevels[ndx]--;
}
return True;
}
static Bool
-AddActionsToKey( KeyInfo * key,
- XkbDescPtr xkb,
- char * field,
- ExprDef * arrayNdx,
- ExprDef * value,
- SymbolsInfo * info)
+AddActionsToKey(KeyInfo * key,
+ XkbDescPtr xkb,
+ char *field,
+ ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
{
-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;
+ 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
-SetAllowNone(KeyInfo *key,ExprDef *arrayNdx,ExprDef *value)
+SetAllowNone(KeyInfo * key, ExprDef * arrayNdx, ExprDef * value)
{
-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;
+ 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 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 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 LookupEntry rgEntries[] = {
+ {"none", 0},
+ {NULL, 0}
};
static Bool
-SetSymbolsField( KeyInfo * key,
- XkbDescPtr xkb,
- char * field,
- ExprDef * arrayNdx,
- ExprDef * value,
- SymbolsInfo * info)
+SetSymbolsField(KeyInfo * key,
+ XkbDescPtr xkb,
+ char *field,
+ ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
{
-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;
+ 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
-SetGroupName(SymbolsInfo *info,ExprDef *arrayNdx,ExprDef *value)
+SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
{
-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+info->explicit_group]=
- XkbInternAtom(NULL,name.str,False);
-
+ 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 + info->explicit_group] =
+ XkbInternAtom(NULL, name.str, False);
+
return True;
}
static int
-HandleSymbolsVar(VarDef *stmt,XkbDescPtr xkb,SymbolsInfo *info)
+HandleSymbolsVar(VarDef * stmt, XkbDescPtr xkb, SymbolsInfo * info)
{
-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);
+ 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
-HandleSymbolsBody( VarDef * def,
- XkbDescPtr xkb,
- KeyInfo * key,
- SymbolsInfo * info)
+HandleSymbolsBody(VarDef * def,
+ XkbDescPtr xkb, KeyInfo * key, SymbolsInfo * info)
{
-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);
- }
+ 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 Bool
-SetExplicitGroup( SymbolsInfo * info,
- KeyInfo * key)
+SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
{
unsigned group = info->explicit_group;
if (group == 0)
- return True;
-
- if ((key->typesDefined|key->symsDefined|key->actsDefined) & ~1) {
- int i;
- WARN1("For the map %s an explicit group specified\n", info->name);
- WARN1("but key %s has more than one group defined\n",
- longText(key->name,XkbMessage));
- ACTION("All groups except first one will be ignored\n");
- for (i = 1; i < XkbNumKbdGroups ; i++) {
- key->numLevels[i]= 0;
- if (key->syms[i]!=NULL)
- uFree(key->syms[i]);
- key->syms[i]= (KeySym*) NULL;
- if (key->acts[i]!=NULL)
- uFree(key->acts[i]);
- key->acts[i]= (XkbAction*) NULL;
- key->types[i]= (Atom) 0;
- }
- }
- key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
-
- key->numLevels[group]= key->numLevels[0];
- key->numLevels[0]= 0;
- key->syms[group]= key->syms[0];
- key->syms[0]= (KeySym*) NULL;
- key->acts[group]= key->acts[0];
- key->acts[0]= (XkbAction*) NULL;
- key->types[group]= key->types[0];
- key->types[0]= (Atom) 0;
- return True;
+ return True;
+
+ if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
+ {
+ int i;
+ WARN1("For the map %s an explicit group specified\n", info->name);
+ WARN1("but key %s has more than one group defined\n",
+ longText(key->name, XkbMessage));
+ ACTION("All groups except first one will be ignored\n");
+ for (i = 1; i < XkbNumKbdGroups; i++)
+ {
+ key->numLevels[i] = 0;
+ if (key->syms[i] != NULL)
+ uFree(key->syms[i]);
+ key->syms[i] = (KeySym *) NULL;
+ if (key->acts[i] != NULL)
+ uFree(key->acts[i]);
+ key->acts[i] = (XkbAction *) NULL;
+ key->types[i] = (Atom) 0;
+ }
+ }
+ key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
+
+ key->numLevels[group] = key->numLevels[0];
+ key->numLevels[0] = 0;
+ key->syms[group] = key->syms[0];
+ key->syms[0] = (KeySym *) NULL;
+ key->acts[group] = key->acts[0];
+ key->acts[0] = (XkbAction *) NULL;
+ key->types[group] = key->types[0];
+ key->types[0] = (Atom) 0;
+ return True;
}
static int
-HandleSymbolsDef( SymbolsDef * stmt,
- XkbDescPtr xkb,
- unsigned merge,
- SymbolsInfo * info)
+HandleSymbolsDef(SymbolsDef * stmt,
+ XkbDescPtr xkb, unsigned merge, SymbolsInfo * info)
{
-KeyInfo key;
-
+ 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;
+ 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 (!SetExplicitGroup(info,&key)) {
+ if (!SetExplicitGroup(info, &key))
+ {
info->errorCount++;
return False;
}
- if (!AddKeySymbols(info,&key,xkb)) {
- info->errorCount++;
- return False;
+ if (!AddKeySymbols(info, &key, xkb))
+ {
+ info->errorCount++;
+ return False;
}
return True;
}
static Bool
-HandleModMapDef( ModMapDef * def,
- XkbDescPtr xkb,
- unsigned merge,
- SymbolsInfo * info)
+HandleModMapDef(ModMapDef * def,
+ XkbDescPtr xkb, unsigned merge, SymbolsInfo * info)
{
-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;
+ 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
-HandleSymbolsFile( XkbFile * file,
- XkbDescPtr xkb,
- unsigned merge,
- SymbolsInfo * info)
+HandleSymbolsFile(XkbFile * file,
+ XkbDescPtr xkb, unsigned merge, SymbolsInfo * info)
{
-ParseCommon *stmt;
-
- info->name= uStringDup(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) {
+ ParseCommon *stmt;
+
+ info->name = uStringDup(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");
+ ERROR("Too many errors\n");
#endif
- ACTION1("Abandoning symbols file \"%s\"\n",file->topName);
- break;
- }
+ ACTION1("Abandoning symbols file \"%s\"\n", file->topName);
+ break;
+ }
}
return;
}
static Bool
-FindKeyForSymbol(XkbDescPtr xkb,KeySym sym,unsigned int *kc_rtrn)
+FindKeyForSymbol(XkbDescPtr xkb, KeySym sym, unsigned int *kc_rtrn)
{
-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) ) {
+ 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;
+ if ((XkbKeySym(xkb, i, j) == sym))
+ {
+ *kc_rtrn = i;
return True;
- }
+ }
}
}
j++;
- } while (gotOne);
+ }
+ while (gotOne);
return False;
}
static Bool
-FindNamedType(XkbDescPtr xkb,Atom name,unsigned *type_rtrn)
+FindNamedType(XkbDescPtr xkb, Atom name, unsigned *type_rtrn)
{
-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;
- }
- }
+ 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
-KSIsLower (KeySym ks)
+KSIsLower(KeySym ks)
{
KeySym lower, upper;
XConvertCase(ks, &lower, &upper);
@@ -1516,7 +1741,7 @@ KSIsLower (KeySym ks)
}
static Bool
-KSIsUpper (KeySym ks)
+KSIsUpper(KeySym ks)
{
KeySym lower, upper;
XConvertCase(ks, &lower, &upper);
@@ -1527,393 +1752,472 @@ KSIsUpper (KeySym ks)
}
static Bool
-FindAutomaticType(int width,KeySym *syms,Atom *typeNameRtrn, Bool *autoType)
+FindAutomaticType(int width, KeySym * syms, Atom * typeNameRtrn,
+ Bool * autoType)
{
*autoType = False;
- if ((width==1)||(width==0)) {
- *typeNameRtrn= XkbInternAtom(NULL,"ONE_LEVEL",False);
- *autoType = True;
- } else if (width == 2) {
- if ( syms && KSIsLower(syms[0]) && KSIsUpper(syms[1]) ) {
- *typeNameRtrn= XkbInternAtom(NULL,"ALPHABETIC",False);
- } else if ( syms &&
- (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])) ) {
- *typeNameRtrn= XkbInternAtom(NULL,"KEYPAD",False);
- *autoType = True;
- } else {
- *typeNameRtrn= XkbInternAtom(NULL,"TWO_LEVEL",False);
- *autoType = True;
- }
- } else if (width <= 4 ) {
- if ( syms && KSIsLower(syms[0]) && KSIsUpper(syms[1]) )
- if ( KSIsLower(syms[2]) && KSIsUpper(syms[3]) )
- *typeNameRtrn= XkbInternAtom(NULL,
- "FOUR_LEVEL_ALPHABETIC",False);
- else
- *typeNameRtrn= XkbInternAtom(NULL,
- "FOUR_LEVEL_SEMIALPHABETIC",False);
-
- else if ( syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])) )
- *typeNameRtrn= XkbInternAtom(NULL,
- "FOUR_LEVEL_KEYPAD",False);
- else *typeNameRtrn= XkbInternAtom(NULL,"FOUR_LEVEL",False);
- }
- return ((width>=0)&&(width<=4));
+ if ((width == 1) || (width == 0))
+ {
+ *typeNameRtrn = XkbInternAtom(NULL, "ONE_LEVEL", False);
+ *autoType = True;
+ }
+ else if (width == 2)
+ {
+ if (syms && KSIsLower(syms[0]) && KSIsUpper(syms[1]))
+ {
+ *typeNameRtrn = XkbInternAtom(NULL, "ALPHABETIC", False);
+ }
+ else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
+ {
+ *typeNameRtrn = XkbInternAtom(NULL, "KEYPAD", False);
+ *autoType = True;
+ }
+ else
+ {
+ *typeNameRtrn = XkbInternAtom(NULL, "TWO_LEVEL", False);
+ *autoType = True;
+ }
+ }
+ else if (width <= 4)
+ {
+ if (syms && KSIsLower(syms[0]) && KSIsUpper(syms[1]))
+ if (KSIsLower(syms[2]) && KSIsUpper(syms[3]))
+ *typeNameRtrn =
+ XkbInternAtom(NULL, "FOUR_LEVEL_ALPHABETIC", False);
+ else
+ *typeNameRtrn = XkbInternAtom(NULL,
+ "FOUR_LEVEL_SEMIALPHABETIC",
+ False);
+
+ else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
+ *typeNameRtrn = XkbInternAtom(NULL, "FOUR_LEVEL_KEYPAD", False);
+ else
+ *typeNameRtrn = XkbInternAtom(NULL, "FOUR_LEVEL", False);
+ }
+ return ((width >= 0) && (width <= 4));
}
static void
-PrepareKeyDef(KeyInfo *key)
+PrepareKeyDef(KeyInfo * key)
{
int i, j, width, defined, lastGroup;
Bool identical;
-
+
defined = key->symsDefined | key->actsDefined | key->typesDefined;
- for (i = XkbNumKbdGroups - 1; i >= 0; i--) {
- if (defined & (1<<i))
- break;
+ for (i = XkbNumKbdGroups - 1; i >= 0; i--)
+ {
+ if (defined & (1 << i))
+ break;
}
lastGroup = i;
if (lastGroup == 0)
- return;
+ return;
/* If there are empty groups between non-empty ones fill them with data */
/* from the first group. */
/* We can make a wrong assumption here. But leaving gaps is worse. */
- for (i = lastGroup; i > 0; i--) {
- if (defined & (1<<i))
+ for (i = lastGroup; i > 0; i--)
+ {
+ if (defined & (1 << i))
continue;
width = key->numLevels[0];
- if (key->typesDefined & 1) {
- for (j = 0; j < width; j++) {
+ if (key->typesDefined & 1)
+ {
+ for (j = 0; j < width; j++)
+ {
key->types[i] = key->types[0];
}
key->typesDefined |= 1 << i;
}
- if ((key->actsDefined & 1) && key->acts[0]) {
- key->acts[i]= uTypedCalloc(width, XkbAction);
+ if ((key->actsDefined & 1) && key->acts[0])
+ {
+ key->acts[i] = uTypedCalloc(width, XkbAction);
if (key->acts[i] == NULL)
continue;
memcpy((void *) key->acts[i], (void *) key->acts[0],
width * sizeof(XkbAction));
key->actsDefined |= 1 << i;
}
- if ((key->symsDefined & 1) && key->syms[0]) {
- key->syms[i]= uTypedCalloc(width, KeySym);
+ if ((key->symsDefined & 1) && key->syms[0])
+ {
+ key->syms[i] = uTypedCalloc(width, KeySym);
if (key->syms[i] == NULL)
continue;
memcpy((void *) key->syms[i], (void *) key->syms[0],
width * sizeof(KeySym));
key->symsDefined |= 1 << i;
}
- if (defined & 1) {
+ if (defined & 1)
+ {
key->numLevels[i] = key->numLevels[0];
}
}
/* If all groups are completely identical remove them all */
/* exept the first one. */
identical = True;
- for (i = lastGroup; i > 0; i--) {
+ for (i = lastGroup; i > 0; i--)
+ {
if ((key->numLevels[i] != key->numLevels[0]) ||
- (key->types[i] != key->types[0])) {
+ (key->types[i] != key->types[0]))
+ {
identical = False;
break;
}
if ((key->syms[i] != key->syms[0]) &&
- (key->syms[i] == NULL || key->syms[0] == NULL ||
- memcmp((void*) key->syms[i], (void*) key->syms[0],
- sizeof(KeySym) * key->numLevels[0])) ) {
- identical = False;
- break;
- }
+ (key->syms[i] == NULL || key->syms[0] == NULL ||
+ memcmp((void *) key->syms[i], (void *) key->syms[0],
+ sizeof(KeySym) * key->numLevels[0])))
+ {
+ identical = False;
+ break;
+ }
if ((key->acts[i] != key->acts[0]) &&
- (key->acts[i] == NULL || key->acts[0] == NULL ||
- memcmp((void*) key->acts[i], (void*) key->acts[0],
- sizeof(XkbAction) * key->numLevels[0]))) {
+ (key->acts[i] == NULL || key->acts[0] == NULL ||
+ memcmp((void *) key->acts[i], (void *) key->acts[0],
+ sizeof(XkbAction) * key->numLevels[0])))
+ {
identical = False;
break;
- }
- }
- if (identical) {
- for (i = lastGroup; i > 0; i--) {
- key->numLevels[i]= 0;
- if (key->syms[i] != NULL)
- uFree(key->syms[i]);
- key->syms[i]= (KeySym*) NULL;
- if (key->acts[i] != NULL)
- uFree(key->acts[i]);
- key->acts[i]= (XkbAction*) NULL;
- key->types[i]= (Atom) 0;
- }
- key->symsDefined &= 1;
- key->actsDefined &= 1;
- key->typesDefined &= 1;
+ }
+ }
+ if (identical)
+ {
+ for (i = lastGroup; i > 0; i--)
+ {
+ key->numLevels[i] = 0;
+ if (key->syms[i] != NULL)
+ uFree(key->syms[i]);
+ key->syms[i] = (KeySym *) NULL;
+ if (key->acts[i] != NULL)
+ uFree(key->acts[i]);
+ key->acts[i] = (XkbAction *) NULL;
+ key->types[i] = (Atom) 0;
+ }
+ key->symsDefined &= 1;
+ key->actsDefined &= 1;
+ key->typesDefined &= 1;
}
return;
}
static Bool
-CopySymbolsDef(XkbFileInfo *result,KeyInfo *key,int start_from)
+CopySymbolsDef(XkbFileInfo * result, KeyInfo * key, int start_from)
{
-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)) {
- }
- 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 || key->numLevels[i] > 2)
- 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);
+ 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))
+ {
+ }
+ 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 || key->numLevels[i] > 2)
+ 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
-CopyModMapDef(XkbFileInfo *result,ModMapEntry *entry)
+CopyModMapDef(XkbFileInfo * result, ModMapEntry * entry)
{
-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);
+ 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
-CompileSymbols(XkbFile *file,XkbFileInfo *result,unsigned merge)
+CompileSymbols(XkbFile * file, XkbFileInfo * result, unsigned merge)
{
-register int i;
-SymbolsInfo info;
-XkbDescPtr xkb;
+ 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);
+ xkb = result->xkb;
+ InitSymbolsInfo(&info, xkb);
+ info.dflt.defs.fileID = file->id;
+ info.dflt.defs.merge = merge;
+ HandleSymbolsFile(file, xkb, merge, &info);
if (info.nKeys == 0)
return True;
- 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++) {
- PrepareKeyDef(key);
- }
- 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;
+ 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++)
+ {
+ PrepareKeyDef(key);
+ }
+ 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;
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 17:47:13 +0000