In preparation of contextualizing the atom table.
Since we touch every function call, also rename the function to
xkb_atom_intern, to match better with the rest (which will also be
renamed).
Signed-off-by: Ran Benita <ran234@gmail.com>
[daniels: Fixed for 'xkb' -> 'keymap'.]
}
xkb_atom_t
-xkb_intern_atom(const char *string)
+xkb_atom_intern(struct xkb_context *context, const char *string)
{
NodePtr *np;
NodePtr nd;
#define XKB_ATOM_NONE 0
extern xkb_atom_t
-xkb_intern_atom(const char *string);
+xkb_atom_intern(struct xkb_context *context, const char *string);
extern char *
XkbcAtomGetString(xkb_atom_t atom);
}
static void
-ActionsInit(void);
+ActionsInit(struct xkb_context *context);
int
HandleActionDef(ExprDef * def,
unsigned tmp, hndlrType;
if (!actionsInitialized)
- ActionsInit();
+ ActionsInit(xkb->context);
if (def->op != ExprActionDecl)
{
if ((arg->op == OpNot) || (arg->op == OpInvert))
{
field = arg->value.child;
- constFalse.value.str = xkb_intern_atom("false");
+ constFalse.value.str = xkb_atom_intern(xkb->context, "false");
value = &constFalse;
}
else
{
field = arg;
- constTrue.value.str = xkb_intern_atom("true");
+ constTrue.value.str = xkb_atom_intern(xkb->context, "true");
value = &constTrue;
}
}
ActionInfo *new, *old;
if (!actionsInitialized)
- ActionsInit();
+ ActionsInit(xkb->context);
new = uTypedAlloc(ActionInfo);
if (new == NULL)
/***====================================================================***/
static void
-ActionsInit(void)
+ActionsInit(struct xkb_context *context)
{
if (!actionsInitialized)
{
constTrue.common.next = NULL;
constTrue.op = ExprIdent;
constTrue.type = TypeBoolean;
- constTrue.value.str = xkb_intern_atom("true");
+ constTrue.value.str = xkb_atom_intern(context, "true");
constFalse.common.stmtType = StmtExpr;
constFalse.common.next = NULL;
constFalse.op = ExprIdent;
constFalse.type = TypeBoolean;
- constFalse.value.str = xkb_intern_atom("false");
+ constFalse.value.str = xkb_atom_intern(context, "false");
actionsInitialized = 1;
}
}
info->dflt.interp.act.type = XkbSA_NoAction;
for (i = 0; i < sizeof(info->dflt.interp.act.any.data); i++)
info->dflt.interp.act.any.data[i] = 0;
- ClearIndicatorMapInfo(&info->ledDflt);
+ ClearIndicatorMapInfo(xkb->context, &info->ledDflt);
info->ledDflt.defs.fileID = info->fileID;
info->ledDflt.defs.defined = 0;
info->ledDflt.defs.merge = MergeOverride;
info->dflt.interp.act.type = XkbSA_NoAction;
for (i = 0; i < sizeof(info->dflt.interp.act.any.data); i++)
info->dflt.interp.act.any.data[i] = 0;
- ClearIndicatorMapInfo(&info->ledDflt);
+ ClearIndicatorMapInfo(xkb->context, &info->ledDflt);
info->nInterps = 0;
info->interps = (SymInterpInfo *) ClearCommonInfo(&info->interps->defs);
memset(&info->groupCompat[0], 0,
/***====================================================================***/
void
-ClearIndicatorMapInfo(LEDInfo * info)
+ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo * info)
{
- info->name = xkb_intern_atom("default");
+ info->name = xkb_atom_intern(context, "default");
info->indicator = _LED_NotBound;
info->flags = info->which_mods = info->real_mods = 0;
info->vmods = 0;
} LEDInfo;
extern void
-ClearIndicatorMapInfo(LEDInfo *info);
+ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo *info);
extern LEDInfo *
}
static int
-HandleIndicatorNameDef(IndicatorNameDef *def, KeyNamesInfo *info)
+HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *xkb,
+ KeyNamesInfo *info)
{
IndicatorNameInfo ii;
ExprResult tmp;
info->errorCount++;
return ReportBadType("indicator", "name", buf, "string");
}
- ii.name = xkb_intern_atom(tmp.str);
+ ii.name = xkb_atom_intern(xkb->context, tmp.str);
free(tmp.str);
ii.virtual = def->virtual;
if (!AddIndicatorName(info, &ii))
info->errorCount++;
break;
case StmtIndicatorNameDef: /* e.g. indicator 1 = "Caps Lock"; */
- if (!HandleIndicatorNameDef((IndicatorNameDef *) stmt, info))
+ if (!HandleIndicatorNameDef((IndicatorNameDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtInterpDef:
InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap,
KeyTypesInfo *from)
{
- tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
- tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
- tok_ALPHABETIC = xkb_intern_atom("ALPHABETIC");
- tok_KEYPAD = xkb_intern_atom("KEYPAD");
+ tok_ONE_LEVEL = xkb_atom_intern(xkb->context, "ONE_LEVEL");
+ tok_TWO_LEVEL = xkb_atom_intern(xkb->context, "TWO_LEVEL");
+ tok_ALPHABETIC = xkb_atom_intern(xkb->context, "ALPHABETIC");
+ tok_KEYPAD = xkb_atom_intern(xkb->context, "KEYPAD");
info->name = strdup("default");
info->errorCount = 0;
info->stdPresent = 0;
}
static bool
-SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value)
+SetLevelName(KeyTypeInfo *type, struct xkb_keymap *xkb, ExprDef *arrayNdx,
+ ExprDef *value)
{
ExprResult rtrn;
unsigned level;
ACTION("Ignoring illegal level name definition\n");
return false;
}
- level_name = xkb_intern_atom(rtrn.str);
+ level_name = xkb_atom_intern(xkb->context, rtrn.str);
free(rtrn.str);
return AddLevelName(type, level, level_name, true);
}
(strcasecmp(field, "level_name") == 0))
{
type->defs.defined |= _KT_LevelNames;
- return SetLevelName(type, arrayNdx, value);
+ return SetLevelName(type, xkb, arrayNdx, value);
}
ERROR("Unknown field %s in key type %s\n", field, TypeTxt(type));
ACTION("Definition ignored\n");
;
Element : ACTION_TOK
- { $$= xkb_intern_atom("action"); }
+ { $$= xkb_atom_intern(param->context, "action"); }
| INTERPRET
- { $$= xkb_intern_atom("interpret"); }
+ { $$= xkb_atom_intern(param->context, "interpret"); }
| TYPE
- { $$= xkb_intern_atom("type"); }
+ { $$= xkb_atom_intern(param->context, "type"); }
| KEY
- { $$= xkb_intern_atom("key"); }
+ { $$= xkb_atom_intern(param->context, "key"); }
| GROUP
- { $$= xkb_intern_atom("group"); }
+ { $$= xkb_atom_intern(param->context, "group"); }
| MODIFIER_MAP
- {$$= xkb_intern_atom("modifier_map");}
+ {$$= xkb_atom_intern(param->context, "modifier_map");}
| INDICATOR
- { $$= xkb_intern_atom("indicator"); }
+ { $$= xkb_atom_intern(param->context, "indicator"); }
| SHAPE
- { $$= xkb_intern_atom("shape"); }
+ { $$= xkb_atom_intern(param->context, "shape"); }
| ROW
{ $$= XKB_ATOM_NONE; }
| SECTION
KeyName : KEYNAME { $$= $1; }
;
-Ident : IDENT { $$= xkb_intern_atom($1); free($1); }
- | DEFAULT { $$= xkb_intern_atom("default"); }
+Ident : IDENT
+ {
+ $$ = xkb_atom_intern(param->context, $1);
+ free($1);
+ }
+ | DEFAULT
+ {
+ $$ = xkb_atom_intern(param->context, "default");
+ }
;
-String : STRING { $$= xkb_intern_atom($1); free($1); }
+String : STRING
+ {
+ $$ = xkb_atom_intern(param->context, $1);
+ free($1);
+ }
;
OptMapName : MapName { $$= $1; }
}
if (arrayNdx == NULL)
{
- key->dfltType = xkb_intern_atom(tmp.str);
+ key->dfltType = xkb_atom_intern(xkb->context, tmp.str);
key->defs.defined |= _Key_Type_Dflt;
}
else if (!ExprResolveGroup(arrayNdx, &ndx))
}
else
{
- key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
+ key->types[ndx.uval - 1] = xkb_atom_intern(xkb->context, tmp.str);
key->typesDefined |= (1 << (ndx.uval - 1));
}
free(tmp.str);
}
static int
-SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
+SetGroupName(SymbolsInfo *info, struct xkb_keymap *xkb, ExprDef *arrayNdx,
+ ExprDef *value)
{
ExprResult tmp, name;
return false;
}
info->groupNames[tmp.uval - 1 + info->explicit_group] =
- xkb_intern_atom(name.str);
+ xkb_atom_intern(xkb->context, name.str);
free(name.str);
return true;
(strcasecmp(field.str, "groupname") ==
0)))
{
- ret = SetGroupName(info, arrayNdx, stmt->value);
+ ret = SetGroupName(info, xkb, arrayNdx, stmt->value);
}
else if ((elem.str == NULL)
&& ((strcasecmp(field.str, "groupswrap") == 0) ||
* @returns true if a type could be found, false otherwise.
*/
static bool
-FindAutomaticType(int width, xkb_keysym_t * syms, xkb_atom_t * typeNameRtrn,
- bool * autoType)
+FindAutomaticType(struct xkb_keymap *xkb, int width, xkb_keysym_t *syms,
+ xkb_atom_t *typeNameRtrn, bool *autoType)
{
*autoType = false;
if ((width == 1) || (width == 0))
{
- *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "ONE_LEVEL");
*autoType = true;
}
else if (width == 2)
{
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
{
- *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "ALPHABETIC");
}
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
{
- *typeNameRtrn = xkb_intern_atom("KEYPAD");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "KEYPAD");
*autoType = true;
}
else
{
- *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "TWO_LEVEL");
*autoType = true;
}
}
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
*typeNameRtrn =
- xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
+ xkb_atom_intern(xkb->context, "FOUR_LEVEL_ALPHABETIC");
else
- *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
+ *typeNameRtrn = xkb_atom_intern(xkb->context,
+ "FOUR_LEVEL_SEMIALPHABETIC");
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
- *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "FOUR_LEVEL_KEYPAD");
else
- *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(xkb->context, "FOUR_LEVEL");
/* XXX: why not set autoType here? */
}
return ((width >= 0) && (width <= 4));
{
if (key->dfltType != XKB_ATOM_NONE)
key->types[i] = key->dfltType;
- else if (FindAutomaticType(key->numLevels[i], key->syms[i],
+ else if (FindAutomaticType(xkb, key->numLevels[i], key->syms[i],
&key->types[i], &autoType))
{
}
xkb_atom_t name;
ExprResult rtrn;
- name = xkb_intern_atom("NumLock");
+ name = xkb_intern_atom(keymap->context, "NumLock");
if (keymap && LookupVModIndex(keymap, name, TypeInt, &rtrn))
{
return rtrn.ival;