In preparation of contextualizing atom handling.
Since we touch every function call, we also rename the function to
xkb_atom_strdup to match xkb_atom_intern, and be more descriptive.
Signed-off-by: Ran Benita <ran234@gmail.com>
[daniels: Updated for xkb -> keymap.]
}
char *
-XkbcAtomGetString(xkb_atom_t atom)
+xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom)
{
const char *ret = XkbcAtomText(atom);
return ret ? strdup(ret) : NULL;
xkb_atom_intern(struct xkb_context *context, const char *string);
extern char *
-XkbcAtomGetString(xkb_atom_t atom);
+xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom);
extern const char *
XkbcAtomText(xkb_atom_t atm);
case F_Data:
if (array_ndx == NULL)
{
- if (!ExprResolveString(value, &rtrn))
+ if (!ExprResolveString(keymap, value, &rtrn))
return ReportMismatch(action->type, field, "string");
else
{
case F_Data:
if (array_ndx == NULL)
{
- if (!ExprResolveString(value, &rtrn))
+ if (!ExprResolveString(keymap, value, &rtrn))
return ReportMismatch(action->type, field, "string");
else
{
unsigned tmp, hndlrType;
if (!actionsInitialized)
- ActionsInit(xkb->context);
+ ActionsInit(keymap->context);
if (def->op != ExprActionDecl)
{
if ((arg->op == OpNot) || (arg->op == OpInvert))
{
field = arg->value.child;
- constFalse.value.str = xkb_atom_intern(xkb->context, "false");
+ constFalse.value.str = xkb_atom_intern(keymap->context, "false");
value = &constFalse;
}
else
{
field = arg;
- constTrue.value.str = xkb_atom_intern(xkb->context, "true");
+ constTrue.value.str = xkb_atom_intern(keymap->context, "true");
value = &constTrue;
}
}
- if (!ExprResolveLhs(field, &elemRtrn, &fieldRtrn, &arrayRtrn))
+ if (!ExprResolveLhs(keymap, field, &elemRtrn, &fieldRtrn, &arrayRtrn))
return false; /* internal error -- already reported */
if (elemRtrn.str != NULL)
ActionInfo *new, *old;
if (!actionsInitialized)
- ActionsInit(xkb->context);
+ ActionsInit(keymap->context);
new = uTypedAlloc(ActionInfo);
if (new == NULL)
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(xkb->context, &info->ledDflt);
+ ClearIndicatorMapInfo(keymap->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(xkb->context, &info->ledDflt);
+ ClearIndicatorMapInfo(keymap->context, &info->ledDflt);
info->nInterps = 0;
info->interps = (SymInterpInfo *) ClearCommonInfo(&info->interps->defs);
memset(&info->groupCompat[0], 0,
ExprDef *ndx;
int ret;
- if (ExprResolveLhs(stmt->name, &elem, &field, &ndx) == 0)
+ if (ExprResolveLhs(keymap, stmt->name, &elem, &field, &ndx) == 0)
ret = 0; /* internal error, already reported */
else if (elem.str && (strcasecmp(elem.str, "interpret") == 0))
ret = SetInterpField(&info->dflt, keymap, field.str, ndx, stmt->value,
ok = HandleInterpVar(def, keymap, info);
continue;
}
- ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
+ ok = ExprResolveLhs(keymap, def->name, &tmp, &field, &arrayNdx);
if (ok) {
ok = SetInterpField(si, keymap, field.str, arrayNdx, def->value,
info);
}
int
-ExprResolveLhs(ExprDef * expr,
- ExprResult * elem_rtrn,
- ExprResult * field_rtrn, ExprDef ** index_rtrn)
+ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *elem_rtrn, ExprResult *field_rtrn,
+ ExprDef **index_rtrn)
{
switch (expr->op)
{
case ExprIdent:
elem_rtrn->str = NULL;
- field_rtrn->str = XkbcAtomGetString(expr->value.str);
+ field_rtrn->str = xkb_atom_strdup(keymap->context,
+ expr->value.str);
*index_rtrn = NULL;
return true;
case ExprFieldRef:
- elem_rtrn->str = XkbcAtomGetString(expr->value.field.element);
- field_rtrn->str = XkbcAtomGetString(expr->value.field.field);
+ elem_rtrn->str = xkb_atom_strdup(keymap->context,
+ expr->value.field.element);
+ field_rtrn->str = xkb_atom_strdup(keymap->context,
+ expr->value.field.field);
*index_rtrn = NULL;
return true;
case ExprArrayRef:
- elem_rtrn->str = XkbcAtomGetString(expr->value.array.element);
- field_rtrn->str = XkbcAtomGetString(expr->value.array.field);
+ elem_rtrn->str = xkb_atom_strdup(keymap->context,
+ expr->value.array.element);
+ field_rtrn->str = xkb_atom_strdup(keymap->context,
+ expr->value.array.field);
*index_rtrn = expr->value.array.entry;
return true;
}
}
int
-ExprResolveString(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *val_rtrn)
{
ExprResult leftRtrn, rightRtrn;
ExprDef *left;
exprTypeText(expr->type));
return false;
}
- val_rtrn->str = XkbcAtomGetString(expr->value.str);
+ val_rtrn->str = xkb_atom_strdup(keymap->context, expr->value.str);
if (val_rtrn->str == NULL)
val_rtrn->str = strdup("");
return true;
case OpAdd:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveString(left, &leftRtrn) &&
- ExprResolveString(right, &rightRtrn))
+ if (ExprResolveString(keymap, left, &leftRtrn) &&
+ ExprResolveString(keymap, right, &rightRtrn))
{
int len;
char *new;
} ExprResult;
extern int
-ExprResolveLhs(ExprDef *expr, ExprResult *elem_rtrn, ExprResult *field_rtrn,
+ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *elem_rtrn, ExprResult *field_rtrn,
ExprDef **index_rtrn);
typedef struct _LookupEntry
ExprResolveFloat(ExprDef *expr, ExprResult *val_rtrn);
extern int
-ExprResolveString(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
ExprResolveKeyName(ExprDef *expr, ExprResult *val_rtrn);
{
ExprResult elem, field;
ExprDef *arrayNdx;
- if (!ExprResolveLhs(var->name, &elem, &field, &arrayNdx))
+ if (!ExprResolveLhs(keymap, var->name, &elem, &field, &arrayNdx))
{
ok = false;
continue;
{
free(UNCONSTIFY(keymap->names->indicators[led->indicator - 1]));
keymap->names->indicators[led->indicator-1] =
- XkbcAtomGetString(led->name);
+ xkb_atom_strdup(keymap->context, led->name);
}
free(led);
}
if (keymap->names->indicators[i] == NULL)
{
keymap->names->indicators[i] =
- XkbcAtomGetString(led->name);
+ xkb_atom_strdup(keymap->context, led->name);
led->indicator = i + 1;
break;
}
* @return 1 on success, 0 otherwise.
*/
static int
-HandleKeyNameVar(VarDef *stmt, KeyNamesInfo *info)
+HandleKeyNameVar(VarDef *stmt, struct xkb_keymap *keymap, KeyNamesInfo *info)
{
ExprResult tmp, field;
ExprDef *arrayNdx;
int which;
- if (ExprResolveLhs(stmt->name, &tmp, &field, &arrayNdx) == 0)
+ if (ExprResolveLhs(keymap, stmt->name, &tmp, &field, &arrayNdx) == 0)
return 0; /* internal error, already reported */
if (tmp.str != NULL)
}
static int
-HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *xkb,
+HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *keymap,
KeyNamesInfo *info)
{
IndicatorNameInfo ii;
}
InitIndicatorNameInfo(&ii, info);
ii.ndx = def->ndx;
- if (!ExprResolveString(def->name, &tmp))
+ if (!ExprResolveString(keymap, def->name, &tmp))
{
char buf[20];
snprintf(buf, sizeof(buf), "%d", def->ndx);
info->errorCount++;
return ReportBadType("indicator", "name", buf, "string");
}
- ii.name = xkb_atom_intern(xkb->context, tmp.str);
+ ii.name = xkb_atom_intern(keymap->context, tmp.str);
free(tmp.str);
ii.virtual = def->virtual;
if (!AddIndicatorName(info, &ii))
info->errorCount++;
break;
case StmtVarDef: /* e.g. minimum, maximum */
- if (!HandleKeyNameVar((VarDef *) stmt, info))
+ if (!HandleKeyNameVar((VarDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtIndicatorNameDef: /* e.g. indicator 1 = "Caps Lock"; */
for (ii = info.leds; ii; ii = (IndicatorNameInfo *)ii->defs.next) {
free(UNCONSTIFY(keymap->names->indicators[ii->ndx - 1]));
- keymap->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name);
+ keymap->names->indicators[ii->ndx - 1] =
+ xkb_atom_strdup(keymap->context, ii->name);
}
}
InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap,
KeyTypesInfo *from)
{
- 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");
+ tok_ONE_LEVEL = xkb_atom_intern(keymap->context, "ONE_LEVEL");
+ tok_TWO_LEVEL = xkb_atom_intern(keymap->context, "TWO_LEVEL");
+ tok_ALPHABETIC = xkb_atom_intern(keymap->context, "ALPHABETIC");
+ tok_KEYPAD = xkb_atom_intern(keymap->context, "KEYPAD");
info->name = strdup("default");
info->errorCount = 0;
info->stdPresent = 0;
}
static bool
-SetLevelName(KeyTypeInfo *type, struct xkb_keymap *xkb, ExprDef *arrayNdx,
+SetLevelName(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx,
ExprDef *value)
{
ExprResult rtrn;
if (!ExprResolveLevel(arrayNdx, &rtrn))
return ReportTypeBadType(type, "level name", "integer");
level = rtrn.ival - 1;
- if (!ExprResolveString(value, &rtrn))
+ if (!ExprResolveString(keymap, value, &rtrn))
{
ERROR("Non-string name for level %d in key type %s\n", level + 1,
XkbcAtomText(type->name));
ACTION("Ignoring illegal level name definition\n");
return false;
}
- level_name = xkb_atom_intern(xkb->context, rtrn.str);
+ level_name = xkb_atom_intern(keymap->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, xkb, arrayNdx, value);
+ return SetLevelName(type, keymap, arrayNdx, value);
}
ERROR("Unknown field %s in key type %s\n", field, TypeTxt(type));
ACTION("Definition ignored\n");
ExprResult elem, field;
ExprDef *arrayNdx;
- if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx))
+ if (!ExprResolveLhs(keymap, stmt->name, &elem, &field, &arrayNdx))
return false; /* internal error, already reported */
if (elem.str && (strcasecmp(elem.str, "type") == 0))
return SetKeyTypeField(&info->dflt, keymap, field.str, arrayNdx,
ok = HandleKeyTypeVar(def, keymap, info);
continue;
}
- ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
+ ok = ExprResolveLhs(keymap, def->name, &tmp, &field, &arrayNdx);
if (ok) {
ok = SetKeyTypeField(type, keymap, field.str, arrayNdx,
def->value, info);
}
else
type->preserve = NULL;
- type->name = XkbcAtomGetString(def->name);
+ type->name = xkb_atom_strdup(keymap->context, def->name);
if (def->szNames > 0)
{
type->level_names = uTypedCalloc(def->numLevels, const char *);
/* assert def->szNames<=def->numLevels */
for (i = 0; i < def->szNames; i++)
{
- type->level_names[i] = XkbcAtomGetString(def->lvlNames[i]);
+ type->level_names[i] = xkb_atom_strdup(keymap->context,
+ def->lvlNames[i]);
}
}
else
if (missing & XkbOneLevelMask)
keymap->map->types[XkbOneLevelIndex].name =
- XkbcAtomGetString(tok_ONE_LEVEL);
+ xkb_atom_strdup(keymap->context, tok_ONE_LEVEL);
if (missing & XkbTwoLevelMask)
keymap->map->types[XkbTwoLevelIndex].name =
- XkbcAtomGetString(tok_TWO_LEVEL);
+ xkb_atom_strdup(keymap->context, tok_TWO_LEVEL);
if (missing & XkbAlphabeticMask)
keymap->map->types[XkbAlphabeticIndex].name =
- XkbcAtomGetString(tok_ALPHABETIC);
+ xkb_atom_strdup(keymap->context, tok_ALPHABETIC);
if (missing & XkbKeypadMask)
keymap->map->types[XkbKeypadIndex].name =
- XkbcAtomGetString(tok_KEYPAD);
+ xkb_atom_strdup(keymap->context, tok_KEYPAD);
}
next = &keymap->map->types[XkbLastRequiredType + 1];
const char *file_name, XkbFile **out);
extern bool
-XKBParseString(struct xkb_context *contex, const char *string,
+XKBParseString(struct xkb_context *context, const char *string,
const char *file_name, XkbFile **out);
extern void
if (strcasecmp(field, "type") == 0)
{
ExprResult ndx;
- if ((!ExprResolveString(value, &tmp))
+ if ((!ExprResolveString(keymap, value, &tmp))
&& (warningLevel > 0))
{
WARN("The type field of a key symbol map must be a string\n");
}
if (arrayNdx == NULL)
{
- key->dfltType = xkb_atom_intern(xkb->context, tmp.str);
+ key->dfltType = xkb_atom_intern(keymap->context, tmp.str);
key->defs.defined |= _Key_Type_Dflt;
}
else if (!ExprResolveGroup(arrayNdx, &ndx))
}
else
{
- key->types[ndx.uval - 1] = xkb_atom_intern(xkb->context, tmp.str);
+ key->types[ndx.uval - 1] = xkb_atom_intern(keymap->context,
+ tmp.str);
key->typesDefined |= (1 << (ndx.uval - 1));
}
free(tmp.str);
}
static int
-SetGroupName(SymbolsInfo *info, struct xkb_keymap *xkb, ExprDef *arrayNdx,
+SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx,
ExprDef *value)
{
ExprResult tmp, name;
ACTION("Definition with non-integer array index ignored\n");
return false;
}
- if (!ExprResolveString(value, &name))
+ if (!ExprResolveString(keymap, value, &name))
{
ERROR("Group name must be a string\n");
ACTION("Illegal name for group %d ignored\n", tmp.uval);
return false;
}
info->groupNames[tmp.uval - 1 + info->explicit_group] =
- xkb_atom_intern(xkb->context, name.str);
+ xkb_atom_intern(keymap->context, name.str);
free(name.str);
return true;
ExprDef *arrayNdx;
bool ret;
- if (ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx) == 0)
+ if (ExprResolveLhs(keymap, stmt->name, &elem, &field, &arrayNdx) == 0)
return 0; /* internal error, already reported */
if (elem.str && (strcasecmp(elem.str, "key") == 0))
{
(strcasecmp(field.str, "groupname") ==
0)))
{
- ret = SetGroupName(info, xkb, arrayNdx, stmt->value);
+ ret = SetGroupName(info, keymap, arrayNdx, stmt->value);
}
else if ((elem.str == NULL)
&& ((strcasecmp(field.str, "groupswrap") == 0) ||
}
else
{
- ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
+ ok = ExprResolveLhs(keymap, def->name, &tmp, &field,
+ &arrayNdx);
}
if (ok)
ok = SetSymbolsField(key, keymap, field.str, arrayNdx,
* @returns true if a type could be found, false otherwise.
*/
static bool
-FindAutomaticType(struct xkb_keymap *xkb, int width, xkb_keysym_t *syms,
+FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms,
xkb_atom_t *typeNameRtrn, bool *autoType)
{
*autoType = false;
if ((width == 1) || (width == 0))
{
- *typeNameRtrn = xkb_atom_intern(xkb->context, "ONE_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(keymap->context, "ONE_LEVEL");
*autoType = true;
}
else if (width == 2)
{
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
{
- *typeNameRtrn = xkb_atom_intern(xkb->context, "ALPHABETIC");
+ *typeNameRtrn = xkb_atom_intern(keymap->context, "ALPHABETIC");
}
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
{
- *typeNameRtrn = xkb_atom_intern(xkb->context, "KEYPAD");
+ *typeNameRtrn = xkb_atom_intern(keymap->context, "KEYPAD");
*autoType = true;
}
else
{
- *typeNameRtrn = xkb_atom_intern(xkb->context, "TWO_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(keymap->context, "TWO_LEVEL");
*autoType = true;
}
}
if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
*typeNameRtrn =
- xkb_atom_intern(xkb->context, "FOUR_LEVEL_ALPHABETIC");
+ xkb_atom_intern(keymap->context, "FOUR_LEVEL_ALPHABETIC");
else
- *typeNameRtrn = xkb_atom_intern(xkb->context,
+ *typeNameRtrn = xkb_atom_intern(keymap->context,
"FOUR_LEVEL_SEMIALPHABETIC");
else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
- *typeNameRtrn = xkb_atom_intern(xkb->context, "FOUR_LEVEL_KEYPAD");
+ *typeNameRtrn = xkb_atom_intern(keymap->context, "FOUR_LEVEL_KEYPAD");
else
- *typeNameRtrn = xkb_atom_intern(xkb->context, "FOUR_LEVEL");
+ *typeNameRtrn = xkb_atom_intern(keymap->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(xkb, key->numLevels[i], key->syms[i],
+ else if (FindAutomaticType(keymap, key->numLevels[i], key->syms[i],
&key->types[i], &autoType))
{
}
for (i = 0; i < XkbNumKbdGroups; i++) {
if (info.groupNames[i] != XKB_ATOM_NONE) {
free(UNCONSTIFY(keymap->names->groups[i]));
- keymap->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
+ keymap->names->groups[i] = xkb_atom_strdup(keymap->context,
+ info.groupNames[i]);
}
}
info->defined |= (1 << nextFree);
info->newlyDefined |= (1 << nextFree);
info->available |= (1 << nextFree);
- names->vmods[nextFree] = XkbcAtomGetString(stmt->name);
+ names->vmods[nextFree] = xkb_atom_strdup(keymap->context, stmt->name);
if (stmt->value == NULL)
return true;
if (ExprResolveModMask(stmt->value, &mod))
xkb_atom_t name;
ExprResult rtrn;
- name = xkb_intern_atom(keymap->context, "NumLock");
+ name = xkb_atom_intern(keymap->context, "NumLock");
if (keymap && LookupVModIndex(keymap, name, TypeInt, &rtrn))
{
return rtrn.ival;