Ensure that all names under xkb_desc are strings, rather than atoms.
Signed-off-by: Daniel Stone <daniel@fooishbar.org>
unsigned char map_count;
struct xkb_kt_map_entry * map;
struct xkb_mods * preserve;
- uint32_t name;
- uint32_t *level_names;
+ const char *name;
+ const char **level_names;
};
struct xkb_sym_interpret {
};
struct xkb_names {
- uint32_t vmods[XkbNumVirtualMods];
- uint32_t indicators[XkbNumIndicators];
- uint32_t groups[XkbNumKbdGroups];
+ const char *vmods[XkbNumVirtualMods];
+ const char *indicators[XkbNumIndicators];
+ const char *groups[XkbNumKbdGroups];
struct xkb_key_name * keys;
struct xkb_key_alias * key_aliases;
type = xkb->map->types;
for (i = 0; i < xkb->map->num_types; i++, type++) {
if (!type->level_names) {
- type->level_names = _XkbTypedCalloc(type->num_levels, uint32_t);
+ type->level_names = _XkbTypedCalloc(type->num_levels, const char *);
if (!type->level_names)
return BadAlloc;
}
{
struct xkb_names * names;
struct xkb_client_map * map;
+ int i;
if (!xkb || !xkb->names)
return;
map = xkb->map;
if (map && map->types) {
- int i;
struct xkb_key_type * type = map->types;
for (i = 0; i < map->num_types; i++, type++) {
+ int j;
+ for (j = 0; j < type->num_levels; j++)
+ free((char *) type->level_names[i]);
free(type->level_names);
type->level_names = NULL;
}
}
+ for (i = 0; i < XkbNumVirtualMods; i++)
+ free((char *) names->vmods[i]);
+ for (i = 0; i < XkbNumIndicators; i++)
+ free((char *) names->indicators[i]);
+ for (i = 0; i < XkbNumKbdGroups; i++)
+ free((char *) names->groups[i]);
+
free(names->keys);
free(names->key_aliases);
free(names);
int
XkbcCopyKeyType(struct xkb_key_type * from, struct xkb_key_type * into)
{
+ int i;
+
if (!from || !into)
return BadMatch;
into->map = NULL;
free(into->preserve);
into->preserve= NULL;
+ for (i = 0; i < into->num_levels; i++)
+ free((char *) into->level_names[i]);
free(into->level_names);
into->level_names = NULL;
}
if (from->level_names && (into->num_levels > 0)) {
- into->level_names = _XkbTypedCalloc(into->num_levels, uint32_t);
+ into->level_names = _XkbTypedCalloc(into->num_levels, const char *);
if (!into->level_names)
return BadAlloc;
- memcpy(into->level_names, from->level_names,
- into->num_levels * sizeof(uint32_t));
+ for (i = 0; i < into->num_levels; i++)
+ into->level_names[i] = strdup(from->level_names[i]);
}
return Success;
map = xkb->map;
for (i = 0, type = map->types; i < map->num_types && type; i++, type++) {
+ int j;
free(type->map);
free(type->preserve);
+ for (j = 0; j < type->num_levels; j++)
+ free((char *) type->level_names[j]);
free(type->level_names);
+ free((char *) type->name);
}
free(map->types);
free(map->key_sym_map);
XkbcVModIndexText(struct xkb_desc * xkb, unsigned ndx)
{
int len;
- uint32_t *vmodNames;
- char *rtrn, *tmp = NULL;
-
- if (xkb && xkb->names)
- vmodNames = xkb->names->vmods;
- else
- vmodNames = NULL;
+ char *rtrn;
+ const char *tmp = NULL;
+ char buf[20];
if (ndx >= XkbNumVirtualMods)
- tmp = strdup("illegal");
- else if (vmodNames && (vmodNames[ndx] != None))
- tmp = XkbcAtomGetString(vmodNames[ndx]);
+ tmp = "illegal";
+ else if (xkb && xkb->names)
+ tmp = xkb->names->vmods[ndx];
if (!tmp) {
- tmp = malloc(20 * sizeof(char));
- snprintf(tmp, 20, "%d", ndx);
+ snprintf(buf, sizeof(buf) - 1, "%d", ndx);
+ tmp = buf;
}
len = strlen(tmp) + 1;
rtrn = tbGetBuffer(len);
strncpy(rtrn, tmp, len);
- free(tmp);
-
return rtrn;
}
im->mods.vmods = led->vmods;
im->ctrls = led->ctrls;
if (xkb->names != NULL)
- xkb->names->indicators[led->indicator - 1] = led->name;
+ {
+ free((char *) xkb->names->indicators[led->indicator - 1]);
+ xkb->names->indicators[led->indicator-1] = XkbcAtomGetString(led->name);
+ }
free(led);
}
}
{
for (i = 0; i < XkbNumIndicators; i++)
{
- if (xkb->names->indicators[i] == led->name)
+ if (xkb->names->indicators[i] == XkbcAtomText(led->name))
{
led->indicator = i + 1;
break;
{
for (i = 0; i < XkbNumIndicators; i++)
{
- if (xkb->names->indicators[i] == None)
+ if (xkb->names->indicators[i] == NULL)
{
- xkb->names->indicators[i] = led->name;
+ xkb->names->indicators[i] = XkbcAtomGetString(led->name);
led->indicator = i + 1;
xkb->indicators->phys_indicators &= ~(1 << i);
break;
else
{
if ((xkb->names != NULL) &&
- (xkb->names->indicators[led->indicator - 1] != led->name))
+ (strcmp(xkb->names->indicators[led->indicator - 1],
+ XkbcAtomText(led->name)) != 0))
{
- uint32_t old = xkb->names->indicators[led->indicator - 1];
+ const char *old = xkb->names->indicators[led->indicator - 1];
ERROR("Multiple names bound to indicator %d\n",
(unsigned int) led->indicator);
- ACTION("Using %s, ignoring %s\n",
- XkbcAtomText(old),
- XkbcAtomText(led->name));
+ ACTION("Using %s, ignoring %s\n", old, XkbcAtomText(led->name));
led->indicator = _LED_NotBound;
if (force)
{
for (ii = info.leds; ii != NULL;
ii = (IndicatorNameInfo *) ii->defs.next)
{
- xkb->names->indicators[ii->ndx - 1] = ii->name;
+ free((char *) xkb->names->indicators[ii->ndx - 1]);
+ xkb->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name);
if (xkb->indicators != NULL)
{
unsigned bit;
}
else
type->preserve = NULL;
- type->name = (uint32_t) def->name;
+ type->name = XkbcAtomGetString(def->name);
if (def->szNames > 0)
{
- type->level_names = uTypedCalloc(def->numLevels, uint32_t);
+ type->level_names = uTypedCalloc(def->numLevels, const char *);
/* assert def->szNames<=def->numLevels */
for (i = 0; i < def->szNames; i++)
{
- type->level_names[i] = (uint32_t) def->lvlNames[i];
+ type->level_names[i] = XkbcAtomGetString(def->lvlNames[i]);
}
}
else
return False;
}
if (missing & XkbOneLevelMask)
- xkb->map->types[XkbOneLevelIndex].name = tok_ONE_LEVEL;
+ xkb->map->types[XkbOneLevelIndex].name =
+ XkbcAtomGetString(tok_ONE_LEVEL);
if (missing & XkbTwoLevelMask)
- xkb->map->types[XkbTwoLevelIndex].name = tok_TWO_LEVEL;
+ xkb->map->types[XkbTwoLevelIndex].name =
+ XkbcAtomGetString(tok_TWO_LEVEL);
if (missing & XkbAlphabeticMask)
- xkb->map->types[XkbAlphabeticIndex].name = tok_ALPHABETIC;
+ xkb->map->types[XkbAlphabeticIndex].name =
+ XkbcAtomGetString(tok_ALPHABETIC);
if (missing & XkbKeypadMask)
- xkb->map->types[XkbKeypadIndex].name = tok_KEYPAD;
+ xkb->map->types[XkbKeypadIndex].name =
+ XkbcAtomGetString(tok_KEYPAD);
}
next = &xkb->map->types[XkbLastRequiredType + 1];
for (i = 0, def = info.types; i < info.nTypes; i++)
/**
* Find the given name in the xkb->map->types and return its index.
*
- * @param name The atom to search for.
+ * @param atom 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
-FindNamedType(struct xkb_desc * xkb, uint32_t name, unsigned *type_rtrn)
+FindNamedType(struct xkb_desc * xkb, uint32_t atom, unsigned *type_rtrn)
{
unsigned n;
+ const char *name = XkbcAtomText(atom);
if (xkb && xkb->map && xkb->map->types)
{
for (n = 0; n < xkb->map->num_types; n++)
{
- if (xkb->map->types[n].name == (uint32_t) name)
+ if (strcmp(xkb->map->types[n].name, name) == 0)
{
*type_rtrn = n;
return True;
{
if (warningLevel > 0)
{
- WARN
- ("Type \"%s\" has %d levels, but %s has %d symbols\n",
- XkbcAtomText(type->name),
- (unsigned int) type->num_levels,
- longText(key->name),
- (unsigned int) key->numLevels[i]);
+ WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
+ type->name, type->num_levels,
+ XkbcAtomText(key->name), key->numLevels[i]);
ACTION("Ignoring extra symbols\n");
}
key->numLevels[i] = type->num_levels;
for (i = 0; i < XkbNumKbdGroups; i++)
{
if (info.groupNames[i] != None)
- xkb->names->groups[i] = info.groupNames[i];
+ {
+ free((char *) xkb->names->groups[i]);
+ xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
+ }
}
/* sanitize keys */
for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
int bit;
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
{
- if (xkb->names->vmods[i] != None)
+ if (xkb->names->vmods[i] != NULL)
info->defined |= bit;
}
}
{
if (info->defined & bit)
{
- if (names->vmods[i] == stmt->name)
+ if (names->vmods[i] &&
+ strcmp(names->vmods[i], XkbcAtomText(stmt->name)) == 0)
{ /* already defined */
info->available |= bit;
if (stmt->value == NULL)
info->defined |= (1 << nextFree);
info->newlyDefined |= (1 << nextFree);
info->available |= (1 << nextFree);
- names->vmods[nextFree] = stmt->name;
+ names->vmods[nextFree] = XkbcAtomGetString(stmt->name);
if (stmt->value == NULL)
return True;
if (ExprResolveModMask(stmt->value, &mod))
ExprResult * val_rtrn)
{
int i;
+ const char *name = XkbcAtomText(field);
if ((xkb == NULL) || (xkb->names == NULL) || (type != TypeInt))
{
*/
for (i = 0; i < XkbNumVirtualMods; i++)
{
- if (xkb->names->vmods[i] == field)
+ if (xkb->names->vmods[i] && strcmp(xkb->names->vmods[i], name) == 0)
{
val_rtrn->uval = i;
return True;
if (def->op == ExprIdent)
{
int i, bit;
+ const char *name = XkbcAtomText(def->value.str);
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
{
- if ((info->available & bit) && names->vmods[i] == def->value.str)
+ if ((info->available & bit) && strcmp(names->vmods[i], name) == 0)
{
val_rtrn->uval = i;
return True;