write_buf(buf, "\txkb_keycodes {\n");
xkb_foreach_key(key, keymap) {
- if (key->name[0] == '\0')
+ if (key->name == XKB_ATOM_NONE)
continue;
write_buf(buf, "\t\t%6s = %d;\n",
- KeyNameText(key->name), key->keycode);
+ KeyNameText(keymap->ctx, key->name), key->keycode);
}
for (i = 0; i < XKB_NUM_INDICATORS; i++) {
darray_foreach(alias, keymap->key_aliases)
- write_buf(buf, "\t\talias %6s = %6s;\n",
- KeyNameText(alias->alias),
- KeyNameText(alias->real));
+ write_buf(buf, "\t\talias %6s = %s;\n",
+ KeyNameText(keymap->ctx, alias->alias),
+ KeyNameText(keymap->ctx, alias->real));
write_buf(buf, "\t};\n\n");
return true;
if (key->num_groups == 0)
continue;
- write_buf(buf, "\t\tkey %6s {", KeyNameText(key->name));
+ write_buf(buf, "\t\tkey %6s {", KeyNameText(keymap->ctx, key->name));
for (group = 0; group < key->num_groups; group++) {
if (key->groups[group].explicit_type)
continue;
write_buf(buf, "\t\tmodifier_map %s { %s };\n",
- ModIndexToName(mod), KeyNameText(key->name));
+ ModIndexToName(mod),
+ KeyNameText(keymap->ctx, key->name));
}
}
#include "utils.h"
#include "context.h"
-#define XKB_KEY_NAME_LENGTH 4
-
/* This limit is artificially enforced, we do not depend on it any where.
* The reason it's still here is that the rules file format does not
* support multiple groups very well, and the rules shipped with
};
struct xkb_key_alias {
- char real[XKB_KEY_NAME_LENGTH];
- char alias[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t real;
+ xkb_atom_t alias;
};
struct xkb_controls {
struct xkb_key {
xkb_keycode_t keycode;
- char name[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t name;
enum xkb_explicit_components explicit;
}
const char *
-KeyNameText(const char name[XKB_KEY_NAME_LENGTH])
+KeyNameText(struct xkb_context *ctx, xkb_atom_t name)
{
- char *buf;
- int len;
-
- buf = GetBuffer(7);
- buf[0] = '<';
- strncpy(&buf[1], name, 4);
- buf[5] = '\0';
- len = strlen(buf);
- buf[len++] = '>';
- buf[len] = '\0';
-
+ const char *sname = xkb_atom_text(ctx, name);
+ size_t len = strlen(sname) + 3;
+ char *buf = GetBuffer(len);
+ snprintf(buf, len, "<%s>", sname);
return buf;
}
KeysymText(xkb_keysym_t sym);
const char *
-KeyNameText(const char name[XKB_KEY_NAME_LENGTH]);
+KeyNameText(struct xkb_context *ctx, xkb_atom_t name);
const char *
SIMatchText(unsigned type);
}
KeycodeDef *
-KeycodeCreate(char keyName[XKB_KEY_NAME_LENGTH], unsigned long value)
+KeycodeCreate(xkb_atom_t name, unsigned long value)
{
KeycodeDef *def;
def->common.type = STMT_KEYCODE;
def->common.next = NULL;
- strncpy(def->name, keyName, XKB_KEY_NAME_LENGTH);
+ def->name = name;
def->value = value;
return def;
}
KeyAliasDef *
-KeyAliasCreate(char alias[XKB_KEY_NAME_LENGTH], char real[XKB_KEY_NAME_LENGTH])
+KeyAliasCreate(xkb_atom_t alias, xkb_atom_t real)
{
KeyAliasDef *def;
def->common.type = STMT_ALIAS;
def->common.next = NULL;
- strncpy(def->alias, alias, XKB_KEY_NAME_LENGTH);
- strncpy(def->real, real, XKB_KEY_NAME_LENGTH);
+ def->alias = alias;
+ def->real = real;
return def;
}
}
SymbolsDef *
-SymbolsCreate(char keyName[XKB_KEY_NAME_LENGTH], ExprDef *symbols)
+SymbolsCreate(xkb_atom_t keyName, ExprDef *symbols)
{
SymbolsDef *def;
def->common.type = STMT_SYMBOLS;
def->common.next = NULL;
def->merge = MERGE_DEFAULT;
- strncpy(def->keyName, keyName, XKB_KEY_NAME_LENGTH);
+ def->keyName = keyName;
def->symbols = symbols;
return def;
}
ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right);
KeycodeDef *
-KeycodeCreate(char keyName[XKB_KEY_NAME_LENGTH], unsigned long value);
+KeycodeCreate(xkb_atom_t name, unsigned long value);
KeyAliasDef *
-KeyAliasCreate(char keyName[XKB_KEY_NAME_LENGTH], char real[XKB_KEY_NAME_LENGTH]);
+KeyAliasCreate(xkb_atom_t alias, xkb_atom_t real);
VModDef *
VModCreate(xkb_atom_t name, ExprDef *value);
KeyTypeCreate(xkb_atom_t name, VarDef *body);
SymbolsDef *
-SymbolsCreate(char keyName[XKB_KEY_NAME_LENGTH], ExprDef *symbols);
+SymbolsCreate(xkb_atom_t keyName, ExprDef *symbols);
GroupCompatDef *
GroupCompatCreate(int group, ExprDef *def);
xkb_atom_t str;
unsigned uval;
int ival;
- char keyName[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t keyName;
} value;
} ExprDef;
typedef struct _KeycodeDef {
ParseCommon common;
enum merge_mode merge;
- char name[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t name;
unsigned long value;
} KeycodeDef;
typedef struct _KeyAliasDef {
ParseCommon common;
enum merge_mode merge;
- char alias[XKB_KEY_NAME_LENGTH];
- char real[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t alias;
+ xkb_atom_t real;
} KeyAliasDef;
typedef struct _KeyTypeDef {
typedef struct _SymbolsDef {
ParseCommon common;
enum merge_mode merge;
- char keyName[XKB_KEY_NAME_LENGTH];
+ xkb_atom_t keyName;
ExprDef *symbols;
} SymbolsDef;
* This is the simplest section type, and is the first one to be
* compiled. The purpose of this is mostly to map between the
* hardware/evdev scancodes and xkb keycodes. Each key is given a name
- * of up to 4 letters, by which it can be referred to later, e.g. in the
- * symbols section.
+ * by which it can be referred to later, e.g. in the symbols section.
*
* Keycode statements
* ------------------
* or same keycode given different names, it is resolved according to the
* merge mode which applies to the definitions.
*
- * The reason for the 4 characters limit is that the name is sometimes
- * converted to an unsigned long (in a direct mapping), instead of a char
- * array (see KeyNameToLong, LongToKeyName).
- *
* Alias statements
* ----------------
* Statements of the form:
enum merge_mode merge;
unsigned file_id;
- unsigned long alias;
- unsigned long real;
+ xkb_atom_t alias;
+ xkb_atom_t real;
} AliasInfo;
typedef struct {
unsigned int file_id;
- unsigned long name;
+ xkb_atom_t name;
} KeyNameInfo;
typedef struct _IndicatorNameInfo {
static void
InitAliasInfo(AliasInfo *info, enum merge_mode merge, unsigned file_id,
- char alias[XKB_KEY_NAME_LENGTH], char real[XKB_KEY_NAME_LENGTH])
+ xkb_atom_t alias, xkb_atom_t real)
{
memset(info, 0, sizeof(*info));
info->merge = merge;
info->file_id = file_id;
- info->alias = KeyNameToLong(alias);
- info->real = KeyNameToLong(real);
+ info->alias = alias;
+ info->real = real;
}
static IndicatorNameInfo *
}
static xkb_keycode_t
-FindKeyByLong(KeyNamesInfo * info, unsigned long name)
+FindKeyByName(KeyNamesInfo * info, xkb_atom_t name)
{
xkb_keycode_t i;
}
static bool
-AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, unsigned long name,
+AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
enum merge_mode merge, unsigned file_id, bool report)
{
KeyNameInfo *namei;
verbosity > 7);
if (namei->name != 0) {
- const char *lname = LongKeyNameText(namei->name);
- const char *kname = LongKeyNameText(name);
+ const char *lname = KeyNameText(info->ctx, namei->name);
+ const char *kname = KeyNameText(info->ctx, name);
if (namei->name == name) {
if (report)
}
}
- old = FindKeyByLong(info, name);
+ old = FindKeyByName(info, name);
if (old != XKB_KEYCODE_INVALID && old != kc) {
- const char *kname = LongKeyNameText(name);
+ const char *kname = KeyNameText(info->ctx, name);
if (merge == MERGE_OVERRIDE) {
darray_item(info->key_names, old).name = 0;
darray_foreach(alias, from->aliases) {
def.merge = (merge == MERGE_DEFAULT) ? alias->merge : merge;
- LongToKeyName(alias->alias, def.alias);
- LongToKeyName(alias->real, def.real);
+ def.alias = alias->alias;
+ def.real = alias->real;
if (!HandleAliasDef(into, &def, def.merge, alias->file_id))
return false;
darray_resize0(into->key_names, darray_size(from->key_names));
for (i = from->min_key_code; i <= from->max_key_code; i++) {
- unsigned long name = darray_item(from->key_names, i).name;
- if (name == 0)
+ xkb_atom_t name = darray_item(from->key_names, i).name;
+ if (name == XKB_ATOM_NONE)
continue;
if (!AddKeyName(into, i, name, merge, from->file_id, false))
merge = stmt->merge;
}
- return AddKeyName(info, stmt->value, KeyNameToLong(stmt->name), merge,
+ return AddKeyName(info, stmt->value, stmt->name, merge,
info->file_id, true);
}
if (report)
log_warn(info->ctx, "Alias of %s for %s declared more than once; "
"First definition ignored\n",
- LongKeyNameText(new->alias), LongKeyNameText(new->real));
+ KeyNameText(info->ctx, new->alias),
+ KeyNameText(info->ctx, new->real));
}
else {
- unsigned long use, ignore;
+ xkb_atom_t use, ignore;
use = (new->merge == MERGE_AUGMENT ? old->real : new->real);
ignore = (new->merge == MERGE_AUGMENT ? new->real : old->real);
if (report)
log_warn(info->ctx, "Multiple definitions for alias %s; "
"Using %s, ignoring %s\n",
- LongKeyNameText(old->alias), LongKeyNameText(use),
- LongKeyNameText(ignore));
+ KeyNameText(info->ctx, old->alias),
+ KeyNameText(info->ctx, use),
+ KeyNameText(info->ctx, ignore));
old->real = use;
}
AliasInfo *alias, new;
darray_foreach(alias, info->aliases) {
- if (alias->alias == KeyNameToLong(def->alias)) {
+ if (alias->alias == def->alias) {
InitAliasInfo(&new, merge, file_id, def->alias, def->real);
HandleAliasCollision(info, alias, &new);
return true;
if (!key) {
log_vrb(info->ctx, 5,
"Attempt to alias %s to non-existent key %s; Ignored\n",
- LongKeyNameText(alias->alias),
- LongKeyNameText(alias->real));
+ KeyNameText(info->ctx, alias->alias),
+ KeyNameText(info->ctx, alias->real));
continue;
}
log_vrb(info->ctx, 5,
"Attempt to create alias with the name of a real key; "
"Alias \"%s = %s\" ignored\n",
- LongKeyNameText(alias->alias),
- LongKeyNameText(alias->real));
+ KeyNameText(info->ctx, alias->alias),
+ KeyNameText(info->ctx, alias->real));
continue;
}
darray_foreach(a, keymap->key_aliases) {
AliasInfo old_alias;
- if (KeyNameToLong(a->alias) != alias->alias)
+ if (a->alias != alias->alias)
continue;
InitAliasInfo(&old_alias, MERGE_AUGMENT, 0, a->alias, a->real);
HandleAliasCollision(info, &old_alias, alias);
- LongToKeyName(old_alias.alias, a->alias);
- LongToKeyName(old_alias.real, a->real);
+ a->alias = old_alias.alias;
+ a->real = old_alias.real;
alias->alias = 0;
}
if (alias->alias == 0)
continue;
/* Add the alias. */
- LongToKeyName(alias->alias, new.alias);
- LongToKeyName(alias->real, new.real);
+ new.alias = alias->alias;
+ new.real = alias->real;
darray_append(keymap->key_aliases, new);
}
for (kc = info->min_key_code; kc <= info->max_key_code; kc++) {
struct xkb_key *key = &darray_item(keymap->keys, kc);
key->keycode = kc;
- LongToKeyName(darray_item(info->key_names, kc).name,
- key->name);
+ key->name = darray_item(info->key_names, kc).name;
}
keymap->keycodes_section_name = strdup_safe(info->name);
}
struct xkb_key *
-FindNamedKey(struct xkb_keymap *keymap, unsigned long name, bool use_aliases)
+FindNamedKey(struct xkb_keymap *keymap, xkb_atom_t name, bool use_aliases)
{
struct xkb_key *key;
xkb_foreach_key(key, keymap)
- if (KeyNameToLong(key->name) == name)
+ if (key->name == name)
return key;
if (use_aliases) {
- unsigned long new_name;
+ xkb_atom_t new_name;
if (FindKeyNameForAlias(keymap, name, &new_name))
return FindNamedKey(keymap, new_name, false);
}
}
bool
-FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
- unsigned long *real_name)
+FindKeyNameForAlias(struct xkb_keymap *keymap, xkb_atom_t name,
+ xkb_atom_t *real_name)
{
- char name[XKB_KEY_NAME_LENGTH];
struct xkb_key_alias *a;
- LongToKeyName(lname, name);
darray_foreach(a, keymap->key_aliases) {
- if (strncmp(name, a->alias, XKB_KEY_NAME_LENGTH) == 0) {
- *real_name = KeyNameToLong(a->real);
+ if (name == a->alias) {
+ *real_name = a->real;
return true;
}
}
#ifndef XKBCOMP_KEYCODES_H
#define XKBCOMP_KEYCODES_H
-static inline unsigned long
-KeyNameToLong(const char name[XKB_KEY_NAME_LENGTH])
-{
- return
- (((unsigned long)name[0]) << 24) |
- (((unsigned long)name[1]) << 16) |
- (((unsigned long)name[2]) << 8) |
- (((unsigned long)name[3]) << 0);
-}
-
-static inline void
-LongToKeyName(unsigned long val, char name[XKB_KEY_NAME_LENGTH])
-{
- name[0] = ((val >> 24) & 0xff);
- name[1] = ((val >> 16) & 0xff);
- name[2] = ((val >> 8) & 0xff);
- name[3] = ((val >> 0) & 0xff);
-}
-
-static inline const char *
-LongKeyNameText(unsigned long val)
-{
- char buf[XKB_KEY_NAME_LENGTH];
- LongToKeyName(val, buf);
- return KeyNameText(buf);
-}
-
struct xkb_key *
-FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
- bool use_aliases);
+FindNamedKey(struct xkb_keymap *keymap, xkb_atom_t name, bool use_aliases);
bool
-FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
- unsigned long *real_name);
+FindKeyNameForAlias(struct xkb_keymap *keymap, xkb_atom_t name,
+ xkb_atom_t *real_name);
#endif
int64_t num;
enum xkb_file_type file_type;
char *str;
- char keyName[XKB_KEY_NAME_LENGTH];
xkb_atom_t sval;
enum merge_mode merge;
enum xkb_map_flags mapFlags;
%type <num> INTEGER FLOAT
%type <str> IDENT STRING
-%type <keyName> KEYNAME KeyName
+%type <sval> KEYNAME
%type <ival> Number Integer Float SignedNumber
%type <merge> MergeMode OptMergeMode
%type <file_type> XkbCompositeType FileType
{ $$ = BoolVarCreate($2, 0); }
;
-KeyNameDecl : KeyName EQUALS KeyCode SEMI
+KeyNameDecl : KEYNAME EQUALS KeyCode SEMI
{ $$ = KeycodeCreate($1, $3); }
;
-KeyAliasDecl : ALIAS KeyName EQUALS KeyName SEMI
+KeyAliasDecl : ALIAS KEYNAME EQUALS KEYNAME SEMI
{ $$ = KeyAliasCreate($2, $4); }
;
{ $$ = KeyTypeCreate($2, $4); }
;
-SymbolsDecl : KEY KeyName OBRACE
+SymbolsDecl : KEY KEYNAME OBRACE
SymbolsBody
CBRACE SEMI
{ $$ = SymbolsCreate($2, (ExprDef *)$4); }
| Key { $$ = NULL; }
;
-Key : KeyName
+Key : KEYNAME
{ $$ = NULL; }
| OBRACE ExprList CBRACE
{ FreeStmt(&$2->common); $$ = NULL; }
| OverlayKey { $$ = NULL; }
;
-OverlayKey : KeyName EQUALS KeyName { $$ = NULL; }
+OverlayKey : KEYNAME EQUALS KEYNAME { $$ = NULL; }
;
OutlineList : OutlineList COMMA OutlineInList
{
$$ = NULL;
}
- | KeyName
+ | KEYNAME
{
ExprDef *expr;
expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_KEYNAME);
- strncpy(expr->value.keyName, $1, XKB_KEY_NAME_LENGTH);
+ expr->value.keyName = $1;
$$ = expr;
}
;
KeyCode : INTEGER { $$ = $1; }
;
-KeyName : KEYNAME { strncpy($$, $1, XKB_KEY_NAME_LENGTH); }
- ;
-
Ident : IDENT { $$ = xkb_atom_steal(param->ctx, $1); }
| DEFAULT { $$ = xkb_atom_intern(param->ctx, "default"); }
;
%option never-interactive
%option case-insensitive
-%x S_STR S_KEY
+%x S_STR
%%
"#"[^\n]*
\" yyextra->s = yyextra->scanBuf; BEGIN(S_STR);
-\< yyextra->s = yyextra->scanBuf; BEGIN(S_KEY);
<S_STR>\" {
BEGIN(INITIAL);
yylval->str = strdup(yyextra->scanBuf);
return STRING;
}
-<S_KEY>\> {
- BEGIN(INITIAL);
-
- *yyextra->s = '\0';
- if (yyextra->s - yyextra->scanBuf > XKB_KEY_NAME_LENGTH) {
- scanner_error_extra(yylloc, yyextra,
- "Key name too long");
- return ERROR_TOK;
- }
- strncpy(yylval->keyName, yyextra->scanBuf, XKB_KEY_NAME_LENGTH);
- return KEYNAME;
- }
-
-<S_STR,S_KEY>\\[0-7]{1,3} {
+<S_STR>\\[0-7]{1,3} {
/* octal escape sequence */
unsigned int result;
APPEND_S(result);
}
-<S_STR,S_KEY>\\[0-9]+ {
+<S_STR>\\[0-9]+ {
scanner_error_extra(yylloc, yyextra,
"Illegal octal escape");
return ERROR_TOK;
}
-<S_STR,S_KEY>\\n APPEND_S('\n');
-<S_STR,S_KEY>\\t APPEND_S('\t');
-<S_STR,S_KEY>\\r APPEND_S('\r');
-<S_STR,S_KEY>\\b APPEND_S('\b');
-<S_STR,S_KEY>\\f APPEND_S('\f');
-<S_STR,S_KEY>\\v APPEND_S('\v');
-<S_STR,S_KEY>\\e APPEND_S('\033');
-
-<S_STR,S_KEY>. APPEND_S(yytext[0]);
+<S_STR>\\n APPEND_S('\n');
+<S_STR>\\t APPEND_S('\t');
+<S_STR>\\r APPEND_S('\r');
+<S_STR>\\b APPEND_S('\b');
+<S_STR>\\f APPEND_S('\f');
+<S_STR>\\v APPEND_S('\v');
+<S_STR>\\e APPEND_S('\033');
+
+<S_STR>. APPEND_S(yytext[0]);
+
+\<[a-zA-Z0-9_+-]+\> {
+ /* We don't want the brackets. */
+ yytext[yyleng - 1] = '\0';
+ yytext++;
+ yylval->sval = xkb_atom_intern(yyextra->ctx, yytext);
+ return KEYNAME;
+ }
xkb_keymap return XKB_KEYMAP;
xkb_keycodes return XKB_KEYCODES;
unsigned file_id;
enum merge_mode merge;
- unsigned long name; /* the 4 chars of the key name, as long */
+ xkb_atom_t name;
darray(GroupInfo) groups;
}
static void
-InitKeyInfo(KeyInfo *keyi, unsigned file_id)
+InitKeyInfo(struct xkb_context *ctx, KeyInfo *keyi, unsigned file_id)
{
- static const char dflt_key_name[XKB_KEY_NAME_LENGTH] = "*";
-
memset(keyi, 0, sizeof(*keyi));
keyi->file_id = file_id;
keyi->merge = MERGE_OVERRIDE;
- keyi->name = KeyNameToLong(dflt_key_name);
+ keyi->name = xkb_atom_intern(ctx, "*");
keyi->out_of_range_group_action = RANGE_WRAP;
}
bool haveSymbol;
int modifier;
union {
- unsigned long keyName;
+ xkb_atom_t keyName;
xkb_keysym_t keySym;
} u;
} ModMapEntry;
info->keymap = keymap;
info->file_id = file_id;
info->merge = MERGE_OVERRIDE;
- InitKeyInfo(&info->dflt, file_id);
+ InitKeyInfo(keymap->ctx, &info->dflt, file_id);
InitVModInfo(&info->vmods, keymap);
info->actions = actions;
info->explicit_group = XKB_LAYOUT_INVALID;
ClearKeyInfo(&info->dflt);
}
+static const char *
+KeyInfoText(SymbolsInfo *info, KeyInfo *keyi)
+{
+ return KeyNameText(info->keymap->ctx, keyi->name);
+}
+
static bool
MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
- bool report, xkb_layout_index_t group, unsigned long key_name)
+ bool report, xkb_layout_index_t group, xkb_atom_t key_name)
{
xkb_level_index_t i, levels_in_both;
+ struct xkb_context *ctx = info->keymap->ctx;
/* First find the type of the merged group. */
if (into->type != from->type) {
log_warn(info->keymap->ctx,
"Multiple definitions for group %d type of key %s; "
"Using %s, ignoring %s\n",
- group + 1, LongKeyNameText(key_name),
- xkb_atom_text(info->keymap->ctx, use),
- xkb_atom_text(info->keymap->ctx, ignore));
+ group + 1, KeyNameText(ctx, key_name),
+ xkb_atom_text(ctx, use), xkb_atom_text(ctx, ignore));
into->type = use;
}
ignore = (clobber ? &intoLevel->action : &fromLevel->action);
if (report)
- log_warn(info->keymap->ctx,
+ log_warn(ctx,
"Multiple actions for level %d/group %u on key %s; "
"Using %s, ignoring %s\n",
- i + 1, group + 1, LongKeyNameText(key_name),
+ i + 1, group + 1, KeyNameText(ctx, key_name),
ActionTypeText(use->type),
ActionTypeText(ignore->type));
}
else {
if (report)
- log_warn(info->keymap->ctx,
+ log_warn(ctx,
"Multiple symbols for level %d/group %u on key %s; "
"Using %s, ignoring %s\n",
- i + 1, group + 1, LongKeyNameText(key_name),
+ i + 1, group + 1, KeyNameText(ctx, key_name),
(clobber ? "from" : "to"),
(clobber ? "to" : "from"));
if (from->merge == MERGE_REPLACE) {
ClearKeyInfo(into);
*into = *from;
- InitKeyInfo(from, info->file_id);
+ InitKeyInfo(info->keymap->ctx, from, info->file_id);
return true;
}
log_warn(info->keymap->ctx,
"Symbol map for key %s redefined; "
"Using %s definition for conflicting fields\n",
- LongKeyNameText(into->name),
+ KeyNameText(info->keymap->ctx, into->name),
(clobber ? "first" : "last"));
ClearKeyInfo(from);
- InitKeyInfo(from, info->file_id);
+ InitKeyInfo(info->keymap->ctx, from, info->file_id);
return true;
}
static bool
AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi)
{
- unsigned long real_name;
+ xkb_atom_t real_name;
KeyInfo *iter;
/*
return MergeKeys(info, iter, keyi);
darray_append(info->keys, *keyi);
- InitKeyInfo(keyi, info->file_id);
+ InitKeyInfo(info->keymap->ctx, keyi, info->file_id);
return true;
}
log_err(info->keymap->ctx,
"Key %s added to map for multiple modifiers; "
"Using %s, ignoring %s.\n",
- LongKeyNameText(new->u.keyName), ModIndexText(use),
- ModIndexText(ignore));
+ KeyNameText(info->keymap->ctx, new->u.keyName),
+ ModIndexText(use), ModIndexText(ignore));
mm->modifier = use;
}
return true;
log_err(info->keymap->ctx,
"Too many groups of %s for key %s (max %u); "
"Ignoring %s defined for extra groups\n",
- name, LongKeyNameText(keyi->name), XKB_NUM_GROUPS + 1, name);
+ name, KeyInfoText(info, keyi), XKB_NUM_GROUPS + 1, name);
return false;
}
log_err(info->keymap->ctx,
"Illegal group index for %s of key %s\n"
"Definition with non-integer array index ignored\n",
- name, LongKeyNameText(keyi->name));
+ name, KeyInfoText(info, keyi));
return false;
}
"Expected a list of symbols, found %s; "
"Ignoring symbols for group %u of %s\n",
expr_op_type_to_string(value->op), ndx + 1,
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
log_err(info->keymap->ctx,
"Symbols for key %s, group %u already defined; "
"Ignoring duplicate definition\n",
- LongKeyNameText(keyi->name), ndx + 1);
+ KeyInfoText(info, keyi), ndx + 1);
return false;
}
log_warn(info->keymap->ctx,
"Could not resolve keysym %s for key %s, group %u (%s), level %u\n",
- sym_name, LongKeyNameText(keyi->name), ndx + 1,
+ sym_name, KeyInfoText(info, keyi), ndx + 1,
group_name, i);
ClearLevelInfo(leveli);
log_wsgo(info->keymap->ctx,
"Bad expression type (%d) for action list value; "
"Ignoring actions for group %u of %s\n",
- value->op, ndx, LongKeyNameText(keyi->name));
+ value->op, ndx, KeyInfoText(info, keyi));
return false;
}
if (groupi->defined & GROUP_FIELD_ACTS) {
log_wsgo(info->keymap->ctx,
"Actions for key %s, group %u already defined\n",
- LongKeyNameText(keyi->name), ndx);
+ KeyInfoText(info, keyi), ndx);
return false;
}
log_err(info->keymap->ctx,
"Illegal action definition for %s; "
"Action for group %u/level %u ignored\n",
- LongKeyNameText(keyi->name), ndx + 1, i + 1);
+ KeyInfoText(info, keyi), ndx + 1, i + 1);
act = (ExprDef *) act->common.next;
}
log_err(ctx,
"Illegal group index for type of key %s; "
"Definition with non-integer array index ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
else {
"Expected a virtual modifier mask, found %s; "
"Ignoring virtual modifiers definition for key %s\n",
expr_op_type_to_string(value->op),
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
}
}
else if (istreq(field, "locking") ||
log_err(info->keymap->ctx,
"Key behaviors not supported; "
"Ignoring locking specification for key %s\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
}
else if (istreq(field, "radiogroup") ||
istreq(field, "permanentradiogroup") ||
log_err(info->keymap->ctx,
"Radio groups not supported; "
"Ignoring radio group specification for key %s\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
}
else if (istreq_prefix("overlay", field) ||
istreq_prefix("permanentoverlay", field)) {
log_err(info->keymap->ctx,
"Overlays not supported; "
"Ignoring overlay specification for key %s\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
}
else if (istreq(field, "repeating") ||
istreq(field, "repeats") ||
log_err(info->keymap->ctx,
"Illegal repeat setting for %s; "
"Non-boolean repeat setting ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
keyi->repeat = val;
log_err(info->keymap->ctx,
"Illegal groupsWrap setting for %s; "
"Non-boolean value ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
log_err(info->keymap->ctx,
"Illegal groupsClamp setting for %s; "
"Non-boolean value ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
log_err(info->keymap->ctx,
"Illegal group index for redirect of key %s; "
"Definition with non-integer group ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
"For the map %s an explicit group specified, "
"but key %s has more than one group defined; "
"All groups except first one will be ignored\n",
- info->name, LongKeyNameText(keyi->name));
+ info->name, KeyInfoText(info, keyi));
darray_resize0(keyi->groups, info->explicit_group + 1);
if (info->explicit_group > 0) {
CopyGroupInfo(&darray_item(keyi.groups, i),
&darray_item(info->dflt.groups, i));
keyi.merge = stmt->merge;
- keyi.name = KeyNameToLong(stmt->keyName);
+ keyi.name = stmt->keyName;
if (!HandleSymbolsBody(info, (VarDef *) stmt->symbols, &keyi)) {
info->errorCount++;
if (key->op == EXPR_VALUE && key->value_type == EXPR_TYPE_KEYNAME) {
tmp.haveSymbol = false;
- tmp.u.keyName = KeyNameToLong(key->value.keyName);
+ tmp.u.keyName = key->value.keyName;
}
else if (ExprResolveKeySym(ctx, key, &sym)) {
tmp.haveSymbol = true;
log_warn(keymap->ctx,
"Couldn't find an automatic type for key '%s' group %d with %lu levels; "
"Using the default type\n",
- LongKeyNameText(keyi->name), group + 1,
+ KeyNameText(keymap->ctx, keyi->name), group + 1,
(unsigned long) darray_size(groupi->levels));
goto use_default;
}
"The type \"%s\" for key '%s' group %d was not previously defined; "
"Using the default type\n",
xkb_atom_text(keymap->ctx, type_name),
- LongKeyNameText(keyi->name), group + 1);
+ KeyNameText(keymap->ctx, keyi->name), group + 1);
goto use_default;
}
if (!key) {
log_vrb(info->keymap->ctx, 5,
"Key %s not found in keycodes; Symbols ignored\n",
- LongKeyNameText(keyi->name));
+ KeyInfoText(info, keyi));
return false;
}
"Type \"%s\" has %d levels, but %s has %d levels; "
"Ignoring extra symbols\n",
xkb_atom_text(keymap->ctx, type->name), type->num_levels,
- LongKeyNameText(keyi->name),
+ KeyInfoText(info, keyi),
(int) darray_size(groupi->levels));
darray_foreach_from(leveli, groupi->levels, type->num_levels)
log_vrb(info->keymap->ctx, 5,
"Key %s not found in keycodes; "
"Modifier map entry for %s not updated\n",
- LongKeyNameText(entry->u.keyName),
+ KeyNameText(keymap->ctx, entry->u.keyName),
ModIndexText(entry->modifier));
return false;
}
if (xkb_context_get_log_verbosity(keymap->ctx) > 3) {
xkb_foreach_key(key, keymap) {
- if (key->name[0] == '\0')
+ if (key->name == XKB_ATOM_NONE)
continue;
if (key->num_groups < 1)
log_info(keymap->ctx,
"No symbols defined for %s\n",
- KeyNameText(key->name));
+ KeyNameText(keymap->ctx, key->name));
}
}
projects / platform / upstream / libxkbcommon.git / commitdiff