StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
libxkbcommon/src/xkbcomp/symbols.c

2270 lines
68 KiB
C
Raw Normal View History

Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
/************************************************************
Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
Permission to use, copy, modify, and distribute this
software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting
documentation, and that the name of Silicon Graphics not be
used in advertising or publicity pertaining to distribution
of the software without specific prior written permission.
Silicon Graphics makes no representation about the suitability
of this software for any purpose. It is provided "as is"
without any express or implied warranty.
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
THE USE OR PERFORMANCE OF THIS SOFTWARE.
********************************************************/
#include "xkbcomp.h"
#include "tokens.h"
#include "expr.h"
#include <X11/keysym.h>
#include <stdlib.h>
#include "expr.h"
#include "vmod.h"
#include "action.h"
#include "keycodes.h"
#include "misc.h"
#include "alias.h"
extern Atom tok_ONE_LEVEL;
extern Atom tok_TWO_LEVEL;
extern Atom tok_KEYPAD;
/***====================================================================***/
#define RepeatYes 1
#define RepeatNo 0
#define RepeatUndefined ~((unsigned)0)
#define _Key_Syms (1<<0)
#define _Key_Acts (1<<1)
#define _Key_Repeat (1<<2)
#define _Key_Behavior (1<<3)
#define _Key_Type_Dflt (1<<4)
#define _Key_Types (1<<5)
#define _Key_GroupInfo (1<<6)
#define _Key_VModMap (1<<7)
typedef struct _KeyInfo
{
CommonInfo defs;
unsigned long name; /* the 4 chars of the key name, as long */
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;
/**
* Init the given key info to sane values.
*/
static void
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;
return;
}
/**
* Free memory associated with this key info and reset to sane values.
*/
static void
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;
info->allowNone = 0;
return;
}
/**
* Copy old into new, optionally reset old to 0.
* If old is reset, new simply re-uses old's memory. Otherwise, the memory is
* newly allocated and new points to the new memory areas.
*/
static Bool
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));
}
}
}
return True;
}
/***====================================================================***/
typedef struct _ModMapEntry
{
CommonInfo defs;
Bool haveSymbol;
int modifier;
union
{
unsigned long keyName;
KeySym keySym;
} u;
} ModMapEntry;
#define SYMBOLS_INIT_SIZE 110
#define SYMBOLS_CHUNK 20
typedef struct _SymbolsInfo
{
char *name; /* e.g. pc+us+inet(evdev) */
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
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
InitSymbolsInfo(SymbolsInfo * info, XkbcDescPtr xkb)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
register int i;
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
tok_ONE_LEVEL = XkbcInternAtom("ONE_LEVEL", False);
tok_TWO_LEVEL = XkbcInternAtom("TWO_LEVEL", False);
tok_KEYPAD = XkbcInternAtom("KEYPAD", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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;
return;
}
static void
FreeSymbolsInfo(SymbolsInfo * info)
{
register int i;
if (info->name)
uFree(info->name);
info->name = NULL;
if (info->keys)
{
for (i = 0; i < info->nKeys; i++)
{
FreeKeyInfo(&info->keys[i]);
}
uFree(info->keys);
info->keys = NULL;
}
if (info->modMap)
{
ClearCommonInfo(&info->modMap->defs);
info->modMap = NULL;
}
if (info->aliases)
{
ClearAliases(&info->aliases);
info->aliases = NULL;
}
bzero((char *) info, sizeof(SymbolsInfo));
return;
}
static Bool
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;
return True;
}
static Bool
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
i + 1, group + 1, longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using %s, ignoring %s\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcKeysymText(use), XkbcKeysymText(ignore));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
i + 1, group + 1, longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using %s, ignoring %s\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcActionTypeText(use->type),
XkbcActionTypeText(ignore->type));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
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)
{
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
i, longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using %s, ignoring %s\n",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(use),
XkbcAtomText(ignore));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(into->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Using %s definition for conflicting fields\n",
(from->defs.merge == MergeAugment ? "first" : "last"));
}
return True;
}
static Bool
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
AddKeySymbols(SymbolsInfo * info, KeyInfo * key, XkbcDescPtr xkb)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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;
}
}
return CopyKeyInfo(key, &info->keys[info->nKeys++], True);
}
static Bool
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcKeysymText(new->u.keySym));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using %s, ignoring %s.\n",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(use),
XkbcModIndexText(ignore));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(new->u.keyName));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using %s, ignoring %s.\n",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(use),
XkbcModIndexText(ignore));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(new->modifier));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return False;
}
*mm = *new;
mm->defs.next = &info->modMap->defs;
info->modMap = mm;
return True;
}
/***====================================================================***/
static void
MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
unsigned merge, XkbcDescPtr xkb)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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 */ ,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr /* xkb */ ,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
unsigned /* merge */ ,
SymbolsInfo * /* included */
);
static Bool
HandleIncludeSymbols(IncludeStmt * stmt,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb, SymbolsInfo * info, FileHandler hndlr)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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;
}
(*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);
}
return (info->errorCount == 0);
}
static LookupEntry groupNames[] = {
{"group1", 1},
{"group2", 2},
{"group3", 3},
{"group4", 4},
{"group5", 5},
{"group6", 6},
{"group7", 7},
{"group8", 8},
{NULL, 0}
};
#define SYMBOLS 1
#define ACTIONS 2
static Bool
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), XkbNumKbdGroups + 1);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Ignoring %s defined for extra groups\n", name);
return False;
}
if (!ExprResolveInteger
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(arrayNdx, &tmp, SimpleLookup, (char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
ERROR2("Illegal group index for %s of key %s\n", name,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
name, longText(key->name), XkbNumKbdGroups + 1);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Ignoring %s for group %d\n", name, tmp.uval);
return False;
}
*ndx_rtrn = tmp.uval - 1;
return True;
}
static Bool
AddSymbolsToKey(KeyInfo * key,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return False;
}
if (key->syms[ndx] != NULL)
{
WSGO2("Symbols for key %s, group %d already defined\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), ndx);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return False;
}
if (key->acts[ndx] != NULL)
{
WSGO2("Actions for key %s, group %d already defined\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), ndx);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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)
{
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION("Non-boolean value ignored\n");
return False;
}
if (tmp.uval)
key->allowNone |= radio_groups;
else
key->allowNone &= ~radio_groups;
return True;
}
static LookupEntry lockingEntries[] = {
{"true", XkbKB_Lock},
{"yes", XkbKB_Lock},
{"on", XkbKB_Lock},
{"false", XkbKB_Default},
{"no", XkbKB_Default},
{"off", XkbKB_Default},
{"permanent", XkbKB_Lock | XkbKB_Permanent},
{NULL, 0}
};
static LookupEntry repeatEntries[] = {
{"true", RepeatYes},
{"yes", RepeatYes},
{"on", RepeatYes},
{"false", RepeatNo},
{"no", RepeatNo},
{"off", RepeatNo},
{"default", RepeatUndefined},
{NULL, 0}
};
static LookupEntry rgEntries[] = {
{"none", 0},
{NULL, 0}
};
static Bool
SetSymbolsField(KeyInfo * key,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb,
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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)
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
key->dfltType = XkbcInternAtom(tmp.str, False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
key->defs.defined |= _Key_Type_Dflt;
}
else if (!ExprResolveInteger(arrayNdx, &ndx, SimpleLookup,
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
ERROR1("Illegal group index for type of key %s\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), XkbNumKbdGroups + 1);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Ignoring type for group %d\n", ndx.uval);
return False;
}
else
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
key->types[ndx.uval - 1] = XkbcInternAtom(tmp.str, False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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))
{
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
ok = ExprResolveModMask(value, &tmp, LookupVModMask, (char *) xkb);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
}
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,
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(char *) rgEntries);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
if (!ok)
{
ERROR1("Illegal radio group specification for %s\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
overlayNdx, longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION("Ignored\n");
return False;
}
}
else if (*which == '\0')
overlayNdx = 1;
else if (warningLevel > 0)
{
ERROR2("Illegal overlay \"%s\" specified for %s\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
which, longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION("Ignored\n");
return False;
}
ok = ExprResolveKeyName(value, &tmp, NULL, NULL);
if (!ok)
{
ERROR1("Illegal overlay key specification for %s\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(value, &tmp, SimpleLookup, (char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
ERROR1("Illegal group index for redirect of key %s\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
XkbNumKbdGroups, longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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)
{
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
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
(arrayNdx, &tmp, SimpleLookup, (char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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] =
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
XkbcInternAtom(name.str, False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return True;
}
static int
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
HandleSymbolsVar(VarDef * stmt, XkbcDescPtr xkb, SymbolsInfo * info)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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,
libxkbcomp: s/XPointer/char */ Replace XPointer with its definition since we don't have the privilege of using Xlib.h. Why this is char * and not void *, I'll never know.
2009-03-27 21:13:22 -06:00
SimpleLookup, (char *) groupNames))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb, KeyInfo * key, SymbolsInfo * info)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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)
{
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb, unsigned merge, SymbolsInfo * info)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
KeyInfo key;
InitKeyInfo(&key);
CopyKeyInfo(&info->dflt, &key, False);
key.defs.merge = stmt->merge;
key.name = KeyNameToLong(stmt->keyName);
if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
{
info->errorCount++;
return False;
}
if (!SetExplicitGroup(info, &key))
{
info->errorCount++;
return False;
}
if (!AddKeySymbols(info, &key, xkb))
{
info->errorCount++;
return False;
}
return True;
}
static Bool
HandleModMapDef(ModMapDef * def,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb, unsigned merge, SymbolsInfo * info)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(def->modifier));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(tmp.modifier));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
continue;
}
ok = AddModMapEntry(info, &tmp) && ok;
}
return ok;
}
static void
HandleSymbolsFile(XkbFile * file,
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
XkbcDescPtr xkb, unsigned merge, SymbolsInfo * info)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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");
#endif
ACTION1("Abandoning symbols file \"%s\"\n", file->topName);
break;
}
}
return;
}
static Bool
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
FindKeyForSymbol(XkbcDescPtr xkb, KeySym sym, unsigned int *kc_rtrn)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
register int i, j;
register Bool gotOne;
j = 0;
do
{
gotOne = False;
for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++)
{
if (j < (int) XkbKeyNumSyms(xkb, i))
{
gotOne = True;
if ((XkbKeySym(xkb, i, j) == sym))
{
*kc_rtrn = i;
return True;
}
}
}
j++;
}
while (gotOne);
return False;
}
/**
* Find the given name in the xkb->map->types and return its index.
*
* @param name The atom to search for.
* @param type_rtrn Set to the index of the name if found.
*
* @return True if found, False otherwise.
*/
static Bool
libxkbcomp: s/XkbDescPtr/XkbcDescPtr/ We need to use the keyboard description structure from XKBcommon.h since it doesn't have the Display field.
2009-03-27 21:01:32 -06:00
FindNamedType(XkbcDescPtr xkb, Atom name, unsigned *type_rtrn)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
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;
}
/**
* Assign a type to the given sym and return the Atom for the type assigned.
*
* Simple recipe:
* - ONE_LEVEL for width 0/1
* - ALPHABETIC for 2 shift levels, with lower/upercase
* - KEYPAD for keypad keys.
* - TWO_LEVEL for other 2 shift level keys.
* and the same for four level keys.
*
* @param width Number of sysms in syms.
* @param syms The keysyms for the given key (must be size width).
* @param typeNameRtrn Set to the Atom of the type name.
*
* @returns True if a type could be found, False otherwise.
*/
static Bool
FindAutomaticType(int width, KeySym * syms, Atom * typeNameRtrn,
Bool * autoType)
{
*autoType = False;
if ((width == 1) || (width == 0))
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("ONE_LEVEL", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
*autoType = True;
}
else if (width == 2)
{
Copy xkbfile IsUpper/IsLower macros xkbcomp was using Xlib's XConvertCase to check upper/lowercase. That's a lot of code, so hopefully the xkbfile macros using _XkbKSCheckCase are good enough. This also required that <X11/keysym.h> is included to get all the XK_* definitions.
2009-03-28 20:21:18 -06:00
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("ALPHABETIC", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
Add xkbcommon macro for XkbKSIsKeypad and XkbKSIsDeadKey(k) IsKeypad is used in symbols, but we'll just grab them both. It might be better to split parts of XKBfile.h out eventually.
2009-03-28 16:51:06 -06:00
else if (syms && (XkbcKSIsKeypad(syms[0]) || XkbcKSIsKeypad(syms[1])))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("KEYPAD", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
*autoType = True;
}
else
{
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("TWO_LEVEL", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
*autoType = True;
}
}
else if (width <= 4)
{
Copy xkbfile IsUpper/IsLower macros xkbcomp was using Xlib's XConvertCase to check upper/lowercase. That's a lot of code, so hopefully the xkbfile macros using _XkbKSCheckCase are good enough. This also required that <X11/keysym.h> is included to get all the XK_* definitions.
2009-03-28 20:21:18 -06:00
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
*typeNameRtrn =
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
XkbcInternAtom("FOUR_LEVEL_ALPHABETIC", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
else
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("FOUR_LEVEL_SEMIALPHABETIC",
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
False);
Add xkbcommon macro for XkbKSIsKeypad and XkbKSIsDeadKey(k) IsKeypad is used in symbols, but we'll just grab them both. It might be better to split parts of XKBfile.h out eventually.
2009-03-28 16:51:06 -06:00
else if (syms && (XkbcKSIsKeypad(syms[0]) || XkbcKSIsKeypad(syms[1])))
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("FOUR_LEVEL_KEYPAD", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
else
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
*typeNameRtrn = XkbcInternAtom("FOUR_LEVEL", False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
/* XXX: why not set autoType here? */
}
return ((width >= 0) && (width <= 4));
}
/**
* Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
* groups, and reduce to one group if all groups are identical anyway.
*/
static void
PrepareKeyDef(KeyInfo * key)
{
int i, j, width, defined, lastGroup;
Bool identical;
defined = key->symsDefined | key->actsDefined | key->typesDefined;
/* get highest group number */
for (i = XkbNumKbdGroups - 1; i >= 0; i--)
{
if (defined & (1 << i))
break;
}
lastGroup = i;
if (lastGroup == 0)
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))
continue;
width = key->numLevels[0];
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->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->syms[i] == NULL)
continue;
memcpy((void *) key->syms[i], (void *) key->syms[0],
width * sizeof(KeySym));
key->symsDefined |= 1 << i;
}
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--)
{
if ((key->numLevels[i] != key->numLevels[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;
}
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])))
{
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;
}
return;
}
/**
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
* Copy the KeyInfo into the keyboard description.
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
*
* This function recurses.
*/
static Bool
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
CopySymbolsDef(XkbcDescPtr xkb, KeyInfo *key, int start_from)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
register int i;
unsigned okc, kc, width, tmp, nGroups;
XkbKeyTypePtr type;
Bool haveActions, autoType, useAlias;
KeySym *outSyms;
XkbAction *outActs;
unsigned types[XkbNumKbdGroups];
useAlias = (start_from == 0);
/* get the keycode for the key. */
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name),
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(xkb->names->keycodes));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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;
/* Assign the type to the key, if it is missing. */
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(key->types[i]),
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), kc);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
}
}
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(key->types[i]));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION2("Using TWO_LEVEL for the %s key (keycode %d)\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), kc);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
types[i] = XkbTwoLevelIndex;
}
/* if the type specifies less syms than the key has, shrink the key */
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(type->name),
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
(unsigned int) type->num_levels,
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name),
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
(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;
}
/* width is now the largest width found */
i = width * nGroups;
outSyms = XkbResizeKeySyms(xkb, kc, i);
if (outSyms == NULL)
{
WSGO2("Could not enlarge symbols for %s (keycode %d)\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), kc);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return False;
}
if (haveActions)
{
outActs = XkbResizeKeyActions(xkb, kc, i);
if (outActs == NULL)
{
WSGO2("Could not enlarge actions for %s (key %d)\n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name), kc);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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++)
{
/* assign kt_index[i] to the index of the type in map->types.
* kt_index[i] may have been set by a previous run (if we have two
* layouts specified). Let's not overwrite it with the ONE_LEVEL
* default group if we dont even have keys for this group anyway.
*
* FIXME: There should be a better fix for this.
*/
if (key->numLevels[i])
xkb->map->key_sym_map[kc].kt_index[i] = types[i];
if (key->syms[i] != NULL)
{
/* fill key to "width" symbols*/
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->nameForOverlayKey),
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(xkb->names->keycodes));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Not treating %s as an overlay key \n",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(key->name));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
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;
}
/* do the same thing for the next key */
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
CopySymbolsDef(xkb, key, kc + 1);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
return True;
}
static Bool
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
CopyModMapDef(XkbcDescPtr xkb, ModMapEntry *entry)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
unsigned kc;
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",
Drop another unneeded format argument Almost cleared of XkbMessage...
2009-03-28 16:24:06 -06:00
longText(entry->u.keyName),
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcAtomText(xkb->names->keycodes));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Modifier map entry for %s not updated\n",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(entry->modifier));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
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",
Add more *Text functions from xkbfile This should cover all the usage in xkbcomp. The format arguments were dropped except for the special case of XkbModMaskText, which needs to write in XkbCFile format in HandleVModDef. This was just changed to a Bool to avoid the need for the macros in XKBfile.h. The function prefixes have been renamed to be unique from xkbfile.
2009-03-28 15:06:26 -06:00
XkbcKeysymText(entry->u.keySym),
XkbcAtomText(xkb->names->symbols));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
ACTION1("Modifier map entry for %s not updated\n",
Add XkbModIndexText replacement Now, I think we should have all the *Text functions we need.
2009-03-28 16:32:51 -06:00
XkbcModIndexText(entry->modifier));
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
}
return False;
}
xkb->map->modmap[kc] |= (1 << entry->modifier);
return True;
}
/**
* Handle the xkb_symbols section of an xkb file.
*
* @param file The parsed xkb_symbols section of the xkb file.
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
* @param xkb Handle to the keyboard description to store the symbols in.
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
* @param merge Merge strategy (e.g. MergeOverride).
*/
Bool
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
CompileSymbols(XkbFile *file, XkbcDescPtr xkb, unsigned merge)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
register int i;
SymbolsInfo info;
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;
/* alloc memory in the xkb struct */
xkbcomp: Use xkbcommon allocation functions s/XkbAlloc/XkbcAlloc/ so we don't know XKBlib.
2009-03-28 12:45:05 -06:00
if (XkbcAllocNames(xkb, XkbSymbolsNameMask | XkbGroupNamesMask, 0, 0)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
!= Success)
{
WSGO("Can not allocate names in CompileSymbols\n");
ACTION("Symbols not added\n");
return False;
}
xkbcomp: Use xkbcommon allocation functions s/XkbAlloc/XkbcAlloc/ so we don't know XKBlib.
2009-03-28 12:45:05 -06:00
if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
!= Success)
{
WSGO("Could not allocate client map in CompileSymbols\n");
ACTION("Symbols not added\n");
return False;
}
xkbcomp: Use xkbcommon allocation functions s/XkbAlloc/XkbcAlloc/ so we don't know XKBlib.
2009-03-28 12:45:05 -06:00
if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
WSGO("Could not allocate server map in CompileSymbols\n");
ACTION("Symbols not added\n");
return False;
}
xkbcomp: Use xkbcommon allocation functions s/XkbAlloc/XkbcAlloc/ so we don't know XKBlib.
2009-03-28 12:45:05 -06:00
if (XkbcAllocControls(xkb, XkbPerKeyRepeatMask) != Success)
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
{
WSGO("Could not allocate controls in CompileSymbols\n");
ACTION("Symbols not added\n");
return False;
}
/* now copy info into xkb. */
xkbcomp: Drop unused Display argument in Atom functions The xkbcommon Atom implementation doesn't take Display into account.
2009-03-28 07:56:26 -06:00
xkb->names->symbols = XkbcInternAtom(info.name, False);
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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];
}
/* sanitize keys */
for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
{
PrepareKeyDef(key);
}
/* copy! */
for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
{
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
if (!CopySymbolsDef(xkb, key, 0))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
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)
{
libxkbcomp: Eradicate XkbFileInfo usage The only real usage was in the frontend to generate a .xkm file. The rest of the code just operated on the attached XkbDescPtr. Note that here we've replaced the usage of the defined field in CompileKeymap with the equivalent field in a XkbcDescPtr.
2009-03-27 20:54:50 -06:00
if (!CopyModMapDef(xkb, mm))
Import xkbcomp sources for CompileKeymap A copy of the xkbcomp sources (except the frontend) have been copied in to provide a means to compile a XkbDescPtr. This definitely doesn't build or do the right thing yet.
2009-03-27 07:55:32 -06:00
info.errorCount++;
next = (ModMapEntry *) mm->defs.next;
}
}
return True;
}
return False;
}