From 38cb639082ec4b31725d4ce4e35af63938691631 Mon Sep 17 00:00:00 2001 From: Daniel Stone Date: Wed, 9 May 2012 15:15:30 +0100 Subject: [PATCH] Change all 'xkb' xkb_keymap names to 'keymap' To make it a bit more clear what it actually is. Signed-off-by: Daniel Stone --- include/xkbcommon/xkbcommon.h | 26 ++--- src/alloc.c | 251 ++++++++++++++++++++++-------------------- src/alloc.h | 29 +++-- src/map.c | 85 +++++++------- src/misc.c | 9 +- src/state.c | 39 +++---- src/text.c | 10 +- src/text.h | 2 +- src/xkb-priv.h | 8 +- src/xkb.c | 18 +-- src/xkbcomp/action.c | 112 ++++++++----------- src/xkbcomp/action.h | 4 +- src/xkbcomp/alias.c | 18 +-- src/xkbcomp/alias.h | 2 +- src/xkbcomp/compat.c | 228 +++++++++++++++++++------------------- src/xkbcomp/expr.c | 16 +-- src/xkbcomp/expr.h | 2 +- src/xkbcomp/indicators.c | 53 ++++----- src/xkbcomp/indicators.h | 8 +- src/xkbcomp/keycodes.c | 65 ++++++----- src/xkbcomp/keymap.c | 20 ++-- src/xkbcomp/keytypes.c | 197 +++++++++++++++++---------------- src/xkbcomp/misc.c | 45 ++++---- src/xkbcomp/symbols.c | 249 +++++++++++++++++++++-------------------- src/xkbcomp/vmod.c | 48 ++++---- src/xkbcomp/vmod.h | 14 +-- src/xkbcomp/xkbcomp-priv.h | 9 +- src/xkbcomp/xkbcomp.c | 26 ++--- src/xkbcomp/xkbcomp.h | 8 +- test/filecomp.c | 17 +-- test/namescomp.c | 8 +- test/rulescomp.c | 8 +- test/state.c | 38 +++---- 33 files changed, 830 insertions(+), 842 deletions(-) diff --git a/include/xkbcommon/xkbcommon.h b/include/xkbcommon/xkbcommon.h index 315f590..c125562 100644 --- a/include/xkbcommon/xkbcommon.h +++ b/include/xkbcommon/xkbcommon.h @@ -329,13 +329,13 @@ xkb_map_new_from_string(struct xkb_context *context, * Takes a new reference on a keymap. */ struct xkb_keymap * -xkb_map_ref(struct xkb_keymap *xkb); +xkb_map_ref(struct xkb_keymap *keymap); /** * Releases a reference on a keymap. */ void -xkb_map_unref(struct xkb_keymap *xkb); +xkb_map_unref(struct xkb_keymap *keymap); /** @} */ @@ -351,61 +351,61 @@ xkb_map_unref(struct xkb_keymap *xkb); * Returns the number of modifiers active in the keymap. */ xkb_mod_index_t -xkb_map_num_mods(struct xkb_keymap *xkb); +xkb_map_num_mods(struct xkb_keymap *keymap); /** * Returns the name of the modifier specified by 'idx', or NULL if invalid. */ const char * -xkb_map_mod_get_name(struct xkb_keymap *xkb, xkb_mod_index_t idx); +xkb_map_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx); /** * Returns the index of the modifier specified by 'name', or XKB_MOD_INVALID. */ xkb_mod_index_t -xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name); +xkb_map_mod_get_index(struct xkb_keymap *keymap, const char *name); /** * Returns the number of groups active in the keymap. */ xkb_group_index_t -xkb_map_num_groups(struct xkb_keymap *xkb); +xkb_map_num_groups(struct xkb_keymap *keymap); /** * Returns the name of the group specified by 'idx', or NULL if invalid. */ const char * -xkb_map_group_get_name(struct xkb_keymap *xkb, xkb_group_index_t idx); +xkb_map_group_get_name(struct xkb_keymap *keymap, xkb_group_index_t idx); /** * Returns the index of the group specified by 'name', or XKB_GROUP_INVALID. */ xkb_group_index_t -xkb_map_group_get_index(struct xkb_keymap *xkb, const char *name); +xkb_map_group_get_index(struct xkb_keymap *keymap, const char *name); /** * Returns the number of groups active for the specified key. */ xkb_group_index_t -xkb_key_num_groups(struct xkb_keymap *xkb, xkb_keycode_t key); +xkb_key_num_groups(struct xkb_keymap *keymap, xkb_keycode_t key); /** * Returns the number of LEDs in the given map. */ xkb_led_index_t -xkb_map_num_leds(struct xkb_keymap *xkb); +xkb_map_num_leds(struct xkb_keymap *keymap); /** * Returns the name of the LED specified by 'idx', or NULL if invalid. */ const char * -xkb_map_led_get_name(struct xkb_keymap *xkb, xkb_led_index_t idx); +xkb_map_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx); /** * Returns the index of the LED specified by 'name', or XKB_LED_INVALID. */ xkb_led_index_t -xkb_map_led_get_index(struct xkb_keymap *xkb, const char *name); +xkb_map_led_get_index(struct xkb_keymap *keymap, const char *name); /** @} */ @@ -422,7 +422,7 @@ xkb_map_led_get_index(struct xkb_keymap *xkb, const char *name); * failure. */ struct xkb_state * -xkb_state_new(struct xkb_keymap *xkb); +xkb_state_new(struct xkb_keymap *keymap); /** * Takes a new reference on a state object. diff --git a/src/alloc.c b/src/alloc.c index 6238f95..81a5b6c 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -27,29 +27,31 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE. #include "alloc.h" int -XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes) +XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which, + unsigned nTotalTypes) { struct xkb_client_map * map; - if (!xkb || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes))) + if (!keymap || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes))) return BadValue; - if ((which & XkbKeySymsMask) && !xkb_keymap_keycode_range_is_legal(xkb)) { + if ((which & XkbKeySymsMask) && + !xkb_keymap_keycode_range_is_legal(keymap)) { #ifdef DEBUG fprintf(stderr, "bad keycode (%d,%d) in XkbAllocClientMap\n", - xkb->min_key_code, xkb->max_key_code); + keymap->min_key_code, keymap->max_key_code); #endif return BadValue; } - if (!xkb->map) { + if (!keymap->map) { map = uTypedCalloc(1, struct xkb_client_map); if (!map) return BadAlloc; - xkb->map = map; + keymap->map = map; } else - map = xkb->map; + map = keymap->map; if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) { if (!map->types) { @@ -79,7 +81,7 @@ XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes if (which & XkbKeySymsMask) { if (!map->key_sym_map) { - map->key_sym_map = uTypedCalloc(xkb->max_key_code + 1, + map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1, struct xkb_sym_map); if (!map->key_sym_map) return BadAlloc; @@ -88,7 +90,8 @@ XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes if (which & XkbModifierMapMask) { if (!map->modmap) { - map->modmap = uTypedCalloc(xkb->max_key_code + 1, unsigned char); + map->modmap = uTypedCalloc(keymap->max_key_code + 1, + unsigned char); if (!map->modmap) return BadAlloc; } @@ -98,15 +101,16 @@ XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes } int -XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions) +XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which, + unsigned nNewActions) { unsigned i; struct xkb_server_map * map; - if (!xkb) + if (!keymap) return BadMatch; - if (!xkb->server) { + if (!keymap->server) { map = uTypedCalloc(1, struct xkb_server_map); if (!map) return BadAlloc; @@ -114,19 +118,19 @@ XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions for (i = 0; i < XkbNumVirtualMods; i++) map->vmods[i] = XkbNoModifierMask; - xkb->server = map; + keymap->server = map; } else - map = xkb->server; + map = keymap->server; if (!which) return Success; - if (!xkb_keymap_keycode_range_is_legal(xkb)) + if (!xkb_keymap_keycode_range_is_legal(keymap)) return BadMatch; if (!map->explicit) { - i = xkb->max_key_code + 1; + i = keymap->max_key_code + 1; map->explicit = uTypedCalloc(i, unsigned char); if (!map->explicit) return BadAlloc; @@ -160,21 +164,21 @@ XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions } if (!map->key_acts) { - i = xkb->max_key_code + 1; + i = keymap->max_key_code + 1; map->key_acts = uTypedCalloc(i, unsigned short); if (!map->key_acts) return BadAlloc; } if (!map->behaviors) { - i = xkb->max_key_code + 1; + i = keymap->max_key_code + 1; map->behaviors = uTypedCalloc(i, struct xkb_behavior); if (!map->behaviors) return BadAlloc; } if (!map->vmodmap) { - i = xkb->max_key_code + 1; + i = keymap->max_key_code + 1; map->vmodmap = uTypedCalloc(i, uint32_t); if (!map->vmodmap) return BadAlloc; @@ -230,62 +234,63 @@ XkbcCopyKeyType(struct xkb_key_type * from, struct xkb_key_type * into) } bool -XkbcResizeKeySyms(struct xkb_keymap * xkb, xkb_keycode_t key, +XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t key, unsigned int needed) { - if (xkb->map->key_sym_map[key].size_syms >= needed) + if (keymap->map->key_sym_map[key].size_syms >= needed) return true; - xkb->map->key_sym_map[key].syms = - uTypedRecalloc(xkb->map->key_sym_map[key].syms, - xkb->map->key_sym_map[key].size_syms, + keymap->map->key_sym_map[key].syms = + uTypedRecalloc(keymap->map->key_sym_map[key].syms, + keymap->map->key_sym_map[key].size_syms, needed, xkb_keysym_t); - if (!xkb->map->key_sym_map[key].syms) { - xkb->map->key_sym_map[key].size_syms = 0; + if (!keymap->map->key_sym_map[key].syms) { + keymap->map->key_sym_map[key].size_syms = 0; return false; } - xkb->map->key_sym_map[key].size_syms = needed; + keymap->map->key_sym_map[key].size_syms = needed; return true; } union xkb_action * -XkbcResizeKeyActions(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed) +XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key, + uint32_t needed) { xkb_keycode_t i, nActs; union xkb_action *newActs; if (needed == 0) { - xkb->server->key_acts[key] = 0; + keymap->server->key_acts[key] = 0; return NULL; } - if (XkbKeyHasActions(xkb, key) && - (XkbKeyGroupsWidth(xkb, key) >= needed)) - return XkbKeyActionsPtr(xkb, key); + if (XkbKeyHasActions(keymap, key) && + (XkbKeyGroupsWidth(keymap, key) >= needed)) + return XkbKeyActionsPtr(keymap, key); - if (xkb->server->size_acts - xkb->server->num_acts >= (int)needed) { - xkb->server->key_acts[key] = xkb->server->num_acts; - xkb->server->num_acts += needed; + if (keymap->server->size_acts - keymap->server->num_acts >= (int)needed) { + keymap->server->key_acts[key] = keymap->server->num_acts; + keymap->server->num_acts += needed; - return &xkb->server->acts[xkb->server->key_acts[key]]; + return &keymap->server->acts[keymap->server->key_acts[key]]; } - xkb->server->size_acts = xkb->server->num_acts + needed + 8; - newActs = uTypedCalloc(xkb->server->size_acts, union xkb_action); + keymap->server->size_acts = keymap->server->num_acts + needed + 8; + newActs = uTypedCalloc(keymap->server->size_acts, union xkb_action); if (!newActs) return NULL; newActs[0].type = XkbSA_NoAction; nActs = 1; - for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { + for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) { xkb_keycode_t nKeyActs, nCopy; - if ((xkb->server->key_acts[i] == 0) && (i != key)) + if ((keymap->server->key_acts[i] == 0) && (i != key)) continue; - nCopy = nKeyActs = XkbKeyNumActions(xkb, i); + nCopy = nKeyActs = XkbKeyNumActions(keymap, i); if (i == key) { nKeyActs= needed; if (needed < nCopy) @@ -293,35 +298,35 @@ XkbcResizeKeyActions(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed } if (nCopy > 0) - memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i), + memcpy(&newActs[nActs], XkbKeyActionsPtr(keymap, i), nCopy * sizeof(union xkb_action)); if (nCopy < nKeyActs) memset(&newActs[nActs + nCopy], 0, (nKeyActs - nCopy) * sizeof(union xkb_action)); - xkb->server->key_acts[i] = nActs; + keymap->server->key_acts[i] = nActs; nActs += nKeyActs; } - free(xkb->server->acts); - xkb->server->acts = newActs; - xkb->server->num_acts = nActs; + free(keymap->server->acts); + keymap->server->acts = newActs; + keymap->server->num_acts = nActs; - return &xkb->server->acts[xkb->server->key_acts[key]]; + return &keymap->server->acts[keymap->server->key_acts[key]]; } void -XkbcFreeClientMap(struct xkb_keymap * xkb) +XkbcFreeClientMap(struct xkb_keymap *keymap) { struct xkb_client_map * map; struct xkb_key_type * type; xkb_keycode_t key; int i; - if (!xkb || !xkb->map) + if (!keymap || !keymap->map) return; - map = xkb->map; + map = keymap->map; for (i = 0, type = map->types; i < map->num_types && type; i++, type++) { int j; @@ -335,7 +340,7 @@ XkbcFreeClientMap(struct xkb_keymap * xkb) free(map->types); if (map->key_sym_map) { - for (key = xkb->min_key_code; key < xkb->max_key_code; key++) { + for (key = keymap->min_key_code; key < keymap->max_key_code; key++) { free(map->key_sym_map[key].sym_index); free(map->key_sym_map[key].num_syms); free(map->key_sym_map[key].syms); @@ -344,43 +349,43 @@ XkbcFreeClientMap(struct xkb_keymap * xkb) free(map->key_sym_map); free(map->modmap); - free(xkb->map); - xkb->map = NULL; + free(keymap->map); + keymap->map = NULL; } void -XkbcFreeServerMap(struct xkb_keymap * xkb) +XkbcFreeServerMap(struct xkb_keymap *keymap) { struct xkb_server_map * map; - if (!xkb || !xkb->server) + if (keymap || keymap->server) return; - map = xkb->server; + map = keymap->server; free(map->explicit); free(map->key_acts); free(map->acts); free(map->behaviors); free(map->vmodmap); - free(xkb->server); - xkb->server = NULL; + free(keymap->server); + keymap->server = NULL; } int -XkbcAllocCompatMap(struct xkb_keymap *xkb, unsigned nSI) +XkbcAllocCompatMap(struct xkb_keymap *keymap, unsigned nSI) { struct xkb_compat_map * compat; struct xkb_sym_interpret *prev_interpret; - if (!xkb) + if (!keymap) return BadMatch; - if (xkb->compat) { - if (xkb->compat->size_si >= nSI) + if (keymap->compat) { + if (keymap->compat->size_si >= nSI) return Success; - compat = xkb->compat; + compat = keymap->compat; compat->size_si = nSI; if (!compat->sym_interpret) compat->num_si = 0; @@ -412,48 +417,49 @@ XkbcAllocCompatMap(struct xkb_keymap *xkb, unsigned nSI) compat->size_si = nSI; compat->num_si = 0; memset(&compat->groups[0], 0, XkbNumKbdGroups * sizeof(struct xkb_mods)); - xkb->compat = compat; + keymap->compat = compat; return Success; } static void -XkbcFreeCompatMap(struct xkb_keymap * xkb) +XkbcFreeCompatMap(struct xkb_keymap *keymap) { struct xkb_compat_map * compat; - if (!xkb || !xkb->compat) + if (!keymap || !keymap->compat) return; - compat = xkb->compat; + compat = keymap->compat; free(compat->sym_interpret); free(compat); - xkb->compat = NULL; + keymap->compat = NULL; } int -XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases) +XkbcAllocNames(struct xkb_keymap *keymap, unsigned which, + unsigned nTotalAliases) { struct xkb_names * names; - if (!xkb) + if (!keymap) return BadMatch; - if (!xkb->names) { - xkb->names = uTypedCalloc(1, struct xkb_names); - if (!xkb->names) + if (!keymap->names) { + keymap->names = uTypedCalloc(1, struct xkb_names); + if (!keymap->names) return BadAlloc; } - names = xkb->names; + names = keymap->names; - if ((which & XkbKTLevelNamesMask) && xkb->map && xkb->map->types) { + if ((which & XkbKTLevelNamesMask) && keymap->map && keymap->map->types) { int i; struct xkb_key_type * type; - type = xkb->map->types; - for (i = 0; i < xkb->map->num_types; i++, type++) { + type = keymap->map->types; + for (i = 0; i < keymap->map->num_types; i++, type++) { if (!type->level_names) { type->level_names = uTypedCalloc(type->num_levels, const char *); if (!type->level_names) @@ -463,10 +469,11 @@ XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases) } if ((which & XkbKeyNamesMask) && !names->keys) { - if (!xkb_keymap_keycode_range_is_legal(xkb)) + if (!xkb_keymap_keycode_range_is_legal(keymap)) return BadMatch; - names->keys = uTypedCalloc(xkb->max_key_code + 1, struct xkb_key_name); + names->keys = uTypedCalloc(keymap->max_key_code + 1, + struct xkb_key_name); if (!names->keys) return BadAlloc; } @@ -498,17 +505,17 @@ XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases) } static void -XkbcFreeNames(struct xkb_keymap * xkb) +XkbcFreeNames(struct xkb_keymap *keymap) { struct xkb_names * names; struct xkb_client_map * map; int i; - if (!xkb || !xkb->names) + if (!keymap || !keymap->names) return; - names = xkb->names; - map = xkb->map; + names = keymap->names; + map = keymap->map; if (map && map->types) { struct xkb_key_type * type = map->types; @@ -532,48 +539,48 @@ XkbcFreeNames(struct xkb_keymap * xkb) free(names->keys); free(names->key_aliases); free(names); - xkb->names = NULL; + keymap->names = NULL; } int -XkbcAllocControls(struct xkb_keymap * xkb) +XkbcAllocControls(struct xkb_keymap *keymap) { - if (!xkb) + if (!keymap) return BadMatch; - if (!xkb->ctrls) { - xkb->ctrls = uTypedCalloc(1, struct xkb_controls); - if (!xkb->ctrls) + if (!keymap->ctrls) { + keymap->ctrls = uTypedCalloc(1, struct xkb_controls); + if (!keymap->ctrls) return BadAlloc; } - xkb->ctrls->per_key_repeat = uTypedCalloc(xkb->max_key_code << 3, - unsigned char); - if (!xkb->ctrls->per_key_repeat) + keymap->ctrls->per_key_repeat = uTypedCalloc(keymap->max_key_code >> 3, + unsigned char); + if (!keymap->ctrls->per_key_repeat) return BadAlloc; return Success; } static void -XkbcFreeControls(struct xkb_keymap * xkb) +XkbcFreeControls(struct xkb_keymap *keymap) { - if (xkb && xkb->ctrls) { - free(xkb->ctrls->per_key_repeat); - free(xkb->ctrls); - xkb->ctrls = NULL; + if (keymap && keymap->ctrls) { + free(keymap->ctrls->per_key_repeat); + free(keymap->ctrls); + keymap->ctrls = NULL; } } int -XkbcAllocIndicatorMaps(struct xkb_keymap * xkb) +XkbcAllocIndicatorMaps(struct xkb_keymap *keymap) { - if (!xkb) + if (!keymap) return BadMatch; - if (!xkb->indicators) { - xkb->indicators = uTypedCalloc(1, struct xkb_indicator); - if (!xkb->indicators) + if (!keymap->indicators) { + keymap->indicators = uTypedCalloc(1, struct xkb_indicator); + if (!keymap->indicators) return BadAlloc; } @@ -581,41 +588,41 @@ XkbcAllocIndicatorMaps(struct xkb_keymap * xkb) } static void -XkbcFreeIndicatorMaps(struct xkb_keymap * xkb) +XkbcFreeIndicatorMaps(struct xkb_keymap *keymap) { - if (xkb) { - free(xkb->indicators); - xkb->indicators = NULL; + if (keymap) { + free(keymap->indicators); + keymap->indicators = NULL; } } struct xkb_keymap * XkbcAllocKeyboard(struct xkb_context *context) { - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; - xkb = uTypedCalloc(1, struct xkb_keymap); - if (!xkb) + keymap = uTypedCalloc(1, struct xkb_keymap); + if (!keymap) return NULL; - xkb->refcnt = 1; - xkb->context = xkb_context_ref(context); + keymap->refcnt = 1; + keymap->context = xkb_context_ref(context); - return xkb; + return keymap; } void -XkbcFreeKeyboard(struct xkb_keymap * xkb) +XkbcFreeKeyboard(struct xkb_keymap *keymap) { - if (!xkb) + if (!keymap) return; - XkbcFreeClientMap(xkb); - XkbcFreeServerMap(xkb); - XkbcFreeCompatMap(xkb); - XkbcFreeIndicatorMaps(xkb); - XkbcFreeNames(xkb); - XkbcFreeControls(xkb); - xkb_context_unref(xkb->context); - free(xkb); + XkbcFreeClientMap(keymap); + XkbcFreeServerMap(keymap); + XkbcFreeCompatMap(keymap); + XkbcFreeIndicatorMaps(keymap); + XkbcFreeNames(keymap); + XkbcFreeControls(keymap); + xkb_context_unref(keymap->context); + free(keymap); } diff --git a/src/alloc.h b/src/alloc.h index 52e7c3e..d7c71d5 100644 --- a/src/alloc.h +++ b/src/alloc.h @@ -30,42 +30,47 @@ authorization from the authors. #include "xkb-priv.h" extern int -XkbcAllocCompatMap(struct xkb_keymap *xkb, unsigned nSI); +XkbcAllocCompatMap(struct xkb_keymap *keymap, unsigned nSI); extern int -XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases); +XkbcAllocNames(struct xkb_keymap *keymap, unsigned which, + unsigned nTotalAliases); extern int -XkbcAllocControls(struct xkb_keymap *xkb); +XkbcAllocControls(struct xkb_keymap *keymap); extern int -XkbcAllocIndicatorMaps(struct xkb_keymap * xkb); +XkbcAllocIndicatorMaps(struct xkb_keymap *keymap); extern struct xkb_keymap * XkbcAllocKeyboard(struct xkb_context *context); extern void -XkbcFreeKeyboard(struct xkb_keymap * xkb); +XkbcFreeKeyboard(struct xkb_keymap *keymap); extern int -XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes); +XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which, + unsigned nTotalTypes); extern int -XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions); +XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which, + unsigned nNewActions); extern int -XkbcCopyKeyType(struct xkb_key_type * from, struct xkb_key_type *into); +XkbcCopyKeyType(struct xkb_key_type *from, struct xkb_key_type *into); extern bool -XkbcResizeKeySyms(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed); +XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t key, + uint32_t needed); extern union xkb_action * -XkbcResizeKeyActions(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed); +XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key, + uint32_t needed); extern void -XkbcFreeClientMap(struct xkb_keymap * xkb); +XkbcFreeClientMap(struct xkb_keymap *keymap); extern void -XkbcFreeServerMap(struct xkb_keymap * xkb); +XkbcFreeServerMap(struct xkb_keymap *keymap); #endif /* ALLOC_H */ diff --git a/src/map.c b/src/map.c index 197a748..7d12765 100644 --- a/src/map.c +++ b/src/map.c @@ -55,12 +55,12 @@ * Returns the total number of modifiers active in the keymap. */ _X_EXPORT xkb_mod_index_t -xkb_map_num_mods(struct xkb_keymap *xkb) +xkb_map_num_mods(struct xkb_keymap *keymap) { xkb_mod_index_t i; for (i = 0; i < XkbNumVirtualMods; i++) - if (!xkb->names->vmods[i]) + if (!keymap->names->vmods[i]) break; /* We always have all the core modifiers (for now), plus any virtual @@ -72,9 +72,9 @@ xkb_map_num_mods(struct xkb_keymap *xkb) * Return the name for a given modifier. */ _X_EXPORT const char * -xkb_map_mod_get_name(struct xkb_keymap *xkb, xkb_mod_index_t idx) +xkb_map_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx) { - if (idx >= xkb_map_num_mods(xkb)) + if (idx >= xkb_map_num_mods(keymap)) return NULL; /* First try to find a legacy modifier name. */ @@ -100,14 +100,14 @@ xkb_map_mod_get_name(struct xkb_keymap *xkb, xkb_mod_index_t idx) } /* If that fails, try to find a virtual mod name. */ - return xkb->names->vmods[idx - Mod5MapIndex]; + return keymap->names->vmods[idx - Mod5MapIndex]; } /** * Returns the index for a named modifier. */ _X_EXPORT xkb_mod_index_t -xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name) +xkb_map_mod_get_index(struct xkb_keymap *keymap, const char *name) { xkb_mod_index_t i; @@ -128,8 +128,8 @@ xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name) if (strcasecmp(name, "Mod5") == 0) return Mod5MapIndex; - for (i = 0; i < XkbNumVirtualMods && xkb->names->vmods[i]; i++) { - if (strcasecmp(name, xkb->names->vmods[i]) == 0) + for (i = 0; i < XkbNumVirtualMods && keymap->names->vmods[i]; i++) { + if (strcasecmp(name, keymap->names->vmods[i]) == 0) return i + Mod5MapIndex; } @@ -140,13 +140,13 @@ xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name) * Return the total number of active groups in the keymap. */ _X_EXPORT xkb_group_index_t -xkb_map_num_groups(struct xkb_keymap *xkb) +xkb_map_num_groups(struct xkb_keymap *keymap) { xkb_group_index_t ret = 0; xkb_group_index_t i; for (i = 0; i < XkbNumKbdGroups; i++) - if (xkb->compat->groups[i].mask) + if (keymap->compat->groups[i].mask) ret++; return ret; @@ -156,25 +156,25 @@ xkb_map_num_groups(struct xkb_keymap *xkb) * Returns the name for a given group. */ _X_EXPORT const char * -xkb_map_group_get_name(struct xkb_keymap *xkb, xkb_group_index_t idx) +xkb_map_group_get_name(struct xkb_keymap *keymap, xkb_group_index_t idx) { - if (idx >= xkb_map_num_groups(xkb)) + if (idx >= xkb_map_num_groups(keymap)) return NULL; - return xkb->names->groups[idx]; + return keymap->names->groups[idx]; } /** * Returns the index for a named group. */ _X_EXPORT xkb_group_index_t -xkb_map_group_get_index(struct xkb_keymap *xkb, const char *name) +xkb_map_group_get_index(struct xkb_keymap *keymap, const char *name) { - xkb_group_index_t num_groups = xkb_map_num_groups(xkb); + xkb_group_index_t num_groups = xkb_map_num_groups(keymap); xkb_group_index_t i; for (i = 0; i < num_groups; i++) { - if (strcasecmp(xkb->names->groups[i], name) == 0) + if (strcasecmp(keymap->names->groups[i], name) == 0) return i; } @@ -185,24 +185,24 @@ xkb_map_group_get_index(struct xkb_keymap *xkb, const char *name) * Returns the number of groups active for a particular key. */ _X_EXPORT xkb_group_index_t -xkb_key_num_groups(struct xkb_keymap *xkb, xkb_keycode_t key) +xkb_key_num_groups(struct xkb_keymap *keymap, xkb_keycode_t key) { - return XkbKeyNumGroups(xkb, key); + return XkbKeyNumGroups(keymap, key); } /** * Return the total number of active LEDs in the keymap. */ _X_EXPORT xkb_led_index_t -xkb_map_num_leds(struct xkb_keymap *xkb) +xkb_map_num_leds(struct xkb_keymap *keymap) { xkb_led_index_t ret = 0; xkb_led_index_t i; for (i = 0; i < XkbNumIndicators; i++) - if (xkb->indicators->maps[i].which_groups || - xkb->indicators->maps[i].which_mods || - xkb->indicators->maps[i].ctrls) + if (keymap->indicators->maps[i].which_groups || + keymap->indicators->maps[i].which_mods || + keymap->indicators->maps[i].ctrls) ret++; return ret; @@ -212,25 +212,25 @@ xkb_map_num_leds(struct xkb_keymap *xkb) * Returns the name for a given group. */ _X_EXPORT const char * -xkb_map_led_get_name(struct xkb_keymap *xkb, xkb_led_index_t idx) +xkb_map_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx) { - if (idx >= xkb_map_num_leds(xkb)) + if (idx >= xkb_map_num_leds(keymap)) return NULL; - return xkb->names->indicators[idx]; + return keymap->names->indicators[idx]; } /** * Returns the index for a named group. */ _X_EXPORT xkb_group_index_t -xkb_map_led_get_index(struct xkb_keymap *xkb, const char *name) +xkb_map_led_get_index(struct xkb_keymap *keymap, const char *name) { - xkb_led_index_t num_leds = xkb_map_num_leds(xkb); + xkb_led_index_t num_leds = xkb_map_num_leds(keymap); xkb_led_index_t i; for (i = 0; i < num_leds; i++) { - if (strcasecmp(xkb->names->indicators[i], name) == 0) + if (strcasecmp(keymap->names->indicators[i], name) == 0) return i; } @@ -244,7 +244,8 @@ _X_EXPORT unsigned int xkb_key_get_level(struct xkb_state *state, xkb_keycode_t key, unsigned int group) { - struct xkb_key_type *type = XkbKeyType(state->xkb, key, group); + struct xkb_keymap *keymap = state->keymap; + struct xkb_key_type *type = XkbKeyType(keymap, key, group); unsigned int active_mods = state->mods & type->mods.mask; int i; @@ -265,11 +266,12 @@ xkb_key_get_level(struct xkb_state *state, xkb_keycode_t key, _X_EXPORT unsigned int xkb_key_get_group(struct xkb_state *state, xkb_keycode_t key) { - unsigned int info = XkbKeyGroupInfo(state->xkb, key); - unsigned int num_groups = XkbKeyNumGroups(state->xkb, key); + struct xkb_keymap *keymap = state->keymap; + unsigned int info = XkbKeyGroupInfo(keymap, key); + unsigned int num_groups = XkbKeyNumGroups(keymap, key); unsigned int ret = state->group; - if (ret < XkbKeyNumGroups(state->xkb, key)) + if (ret < XkbKeyNumGroups(keymap, key)) return ret; switch (XkbOutOfRangeGroupAction(info)) { @@ -294,21 +296,22 @@ xkb_key_get_group(struct xkb_state *state, xkb_keycode_t key) * As below, but takes an explicit group/level rather than state. */ unsigned int -xkb_key_get_syms_by_level(struct xkb_keymap *xkb, xkb_keycode_t key, unsigned int group, - unsigned int level, const xkb_keysym_t **syms_out) +xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t key, + unsigned int group, unsigned int level, + const xkb_keysym_t **syms_out) { int num_syms; - if (group >= XkbKeyNumGroups(xkb, key)) + if (group >= XkbKeyNumGroups(keymap, key)) goto err; - if (level >= XkbKeyGroupWidth(xkb, key, group)) + if (level >= XkbKeyGroupWidth(keymap, key, group)) goto err; - num_syms = XkbKeyNumSyms(xkb, key, group, level); + num_syms = XkbKeyNumSyms(keymap, key, group, level); if (num_syms == 0) goto err; - *syms_out = XkbKeySymEntry(xkb, key, group, level); + *syms_out = XkbKeySymEntry(keymap, key, group, level); return num_syms; err: @@ -324,11 +327,11 @@ _X_EXPORT unsigned int xkb_key_get_syms(struct xkb_state *state, xkb_keycode_t key, const xkb_keysym_t **syms_out) { - struct xkb_keymap *xkb = state->xkb; + struct xkb_keymap *keymap = state->keymap; int group; int level; - if (!state || key < xkb->min_key_code || key > xkb->max_key_code) + if (!state || key < keymap->min_key_code || key > keymap->max_key_code) return -1; group = xkb_key_get_group(state, key); @@ -338,7 +341,7 @@ xkb_key_get_syms(struct xkb_state *state, xkb_keycode_t key, if (level == -1) goto err; - return xkb_key_get_syms_by_level(xkb, key, group, level, syms_out); + return xkb_key_get_syms_by_level(keymap, key, group, level, syms_out); err: *syms_out = NULL; diff --git a/src/misc.c b/src/misc.c index b3053d0..77e9387 100644 --- a/src/misc.c +++ b/src/misc.c @@ -78,20 +78,21 @@ static struct xkb_key_type canonicalTypes[XkbNumRequiredTypes] = { }; int -XkbcInitCanonicalKeyTypes(struct xkb_keymap * xkb, unsigned which, int keypadVMod) +XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which, + int keypadVMod) { struct xkb_client_map * map; struct xkb_key_type *from, *to; int rtrn; - if (!xkb) + if (!keymap) return BadMatch; - rtrn= XkbcAllocClientMap(xkb, XkbKeyTypesMask, XkbNumRequiredTypes); + rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes); if (rtrn != Success) return rtrn; - map= xkb->map; + map = keymap->map; if ((which & XkbAllRequiredTypes) == 0) return Success; diff --git a/src/state.c b/src/state.c index 5d731db..5f78a87 100644 --- a/src/state.c +++ b/src/state.c @@ -79,8 +79,8 @@ xkb_key_get_action(struct xkb_state *state, xkb_keycode_t key) { int group, level; - if (!XkbKeyHasActions(state->xkb, key) || - !XkbKeycodeInRange(state->xkb, key)) { + if (!XkbKeyHasActions(state->keymap, key) || + !XkbKeycodeInRange(state->keymap, key)) { static union xkb_action fake; memset(&fake, 0, sizeof(fake)); fake.type = XkbSA_NoAction; @@ -90,7 +90,7 @@ xkb_key_get_action(struct xkb_state *state, xkb_keycode_t key) group = xkb_key_get_group(state, key); level = xkb_key_get_level(state, key, group); - return XkbKeyActionEntry(state->xkb, key, level, group); + return XkbKeyActionEntry(state->keymap, key, level, group); } static struct xkb_filter * @@ -456,11 +456,11 @@ xkb_filter_apply_all(struct xkb_state *state, xkb_keycode_t key, } _X_EXPORT struct xkb_state * -xkb_state_new(struct xkb_keymap *xkb) +xkb_state_new(struct xkb_keymap *keymap) { struct xkb_state *ret; - if (!xkb) + if (!keymap) return NULL; ret = calloc(sizeof(*ret), 1); @@ -468,7 +468,7 @@ xkb_state_new(struct xkb_keymap *xkb) return NULL; ret->refcnt = 1; - ret->xkb = xkb_map_ref(xkb); + ret->keymap = xkb_map_ref(keymap); return ret; } @@ -488,7 +488,7 @@ xkb_state_unref(struct xkb_state *state) if (state->refcnt > 0) return; - xkb_map_unref(state->xkb); + xkb_map_unref(state->keymap); free(state->filters); free(state); } @@ -496,7 +496,7 @@ xkb_state_unref(struct xkb_state *state) _X_EXPORT struct xkb_keymap * xkb_state_get_map(struct xkb_state *state) { - return state->xkb; + return state->keymap; } /** @@ -510,7 +510,7 @@ xkb_state_led_update_all(struct xkb_state *state) state->leds = 0; for (led = 0; led < XkbNumIndicators; led++) { - struct xkb_indicator_map *map = &state->xkb->indicators->maps[led]; + struct xkb_indicator_map *map = &state->keymap->indicators->maps[led]; uint32_t mod_mask = 0; uint32_t group_mask = 0; @@ -542,7 +542,7 @@ xkb_state_led_update_all(struct xkb_state *state) state->leds |= (1 << led); } else if (map->ctrls) { - if ((map->ctrls & state->xkb->ctrls->enabled_ctrls)) + if ((map->ctrls & state->keymap->ctrls->enabled_ctrls)) state->leds |= (1 << led); } } @@ -597,7 +597,7 @@ xkb_state_update_mask(struct xkb_state *state, state->base_mods = 0; state->latched_mods = 0; state->locked_mods = 0; - for (mod = 0; mod < xkb_map_num_mods(state->xkb); mod++) { + for (mod = 0; mod < xkb_map_num_mods(state->keymap); mod++) { xkb_mod_mask_t idx = (1 << mod); if (base_mods & idx) state->base_mods |= idx; @@ -671,7 +671,7 @@ xkb_state_mod_index_is_active(struct xkb_state *state, { int ret = 0; - if (idx >= xkb_map_num_mods(state->xkb)) + if (idx >= xkb_map_num_mods(state->keymap)) return -1; if (type & XKB_STATE_DEPRESSED) @@ -723,7 +723,8 @@ xkb_state_mod_indices_are_active(struct xkb_state *state, va_start(ap, match); while (1) { idx = va_arg(ap, xkb_mod_index_t); - if (idx == XKB_MOD_INVALID || idx >= xkb_map_num_mods(state->xkb)) { + if (idx == XKB_MOD_INVALID || + idx >= xkb_map_num_mods(state->keymap)) { ret = -1; break; } @@ -745,7 +746,7 @@ _X_EXPORT int xkb_state_mod_name_is_active(struct xkb_state *state, const char *name, enum xkb_state_component type) { - xkb_mod_index_t idx = xkb_map_mod_get_index(state->xkb, name); + xkb_mod_index_t idx = xkb_map_mod_get_index(state->keymap, name); if (idx == XKB_MOD_INVALID) return -1; @@ -774,7 +775,7 @@ xkb_state_mod_names_are_active(struct xkb_state *state, str = va_arg(ap, const char *); if (str == NULL) break; - idx = xkb_map_mod_get_index(state->xkb, str); + idx = xkb_map_mod_get_index(state->keymap, str); if (idx == XKB_MOD_INVALID) { ret = -1; break; @@ -800,7 +801,7 @@ xkb_state_group_index_is_active(struct xkb_state *state, { int ret = 0; - if (idx >= xkb_map_num_groups(state->xkb)) + if (idx >= xkb_map_num_groups(state->keymap)) return -1; if (type & XKB_STATE_DEPRESSED) @@ -821,7 +822,7 @@ _X_EXPORT int xkb_state_group_name_is_active(struct xkb_state *state, const char *name, enum xkb_state_component type) { - xkb_group_index_t idx = xkb_map_group_get_index(state->xkb, name); + xkb_group_index_t idx = xkb_map_group_get_index(state->keymap, name); if (idx == XKB_GROUP_INVALID) return -1; @@ -835,7 +836,7 @@ xkb_state_group_name_is_active(struct xkb_state *state, const char *name, _X_EXPORT int xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx) { - if (idx >= xkb_map_num_leds(state->xkb)) + if (idx >= xkb_map_num_leds(state->keymap)) return -1; return !!(state->leds & (1 << idx)); @@ -847,7 +848,7 @@ xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx) _X_EXPORT int xkb_state_led_name_is_active(struct xkb_state *state, const char *name) { - xkb_led_index_t idx = xkb_map_led_get_index(state->xkb, name); + xkb_led_index_t idx = xkb_map_led_get_index(state->keymap, name); if (idx == XKB_LED_INVALID) return -1; diff --git a/src/text.c b/src/text.c index d9aede4..7603a6a 100644 --- a/src/text.c +++ b/src/text.c @@ -48,7 +48,7 @@ tbGetBuffer(unsigned int size) } static const char * -XkbcVModIndexText(struct xkb_keymap * xkb, unsigned ndx) +XkbcVModIndexText(struct xkb_keymap *keymap, unsigned ndx) { int len; char *rtrn; @@ -57,8 +57,8 @@ XkbcVModIndexText(struct xkb_keymap * xkb, unsigned ndx) if (ndx >= XkbNumVirtualMods) tmp = "illegal"; - else if (xkb && xkb->names) - tmp = xkb->names->vmods[ndx]; + else if (keymap && keymap->names) + tmp = keymap->names->vmods[ndx]; if (!tmp) { snprintf(buf, sizeof(buf) - 1, "%d", ndx); @@ -76,7 +76,7 @@ XkbcVModIndexText(struct xkb_keymap * xkb, unsigned ndx) } const char * -XkbcVModMaskText(struct xkb_keymap * xkb, unsigned modMask, unsigned mask) +XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask) { int i, bit, len, rem; const char *mm = NULL; @@ -101,7 +101,7 @@ XkbcVModMaskText(struct xkb_keymap * xkb, unsigned modMask, unsigned mask) len = snprintf(str, rem, "%s%s", (str != buf) ? "+" : "", - XkbcVModIndexText(xkb, i)); + XkbcVModIndexText(keymap, i)); rem -= len; str += len; } diff --git a/src/text.h b/src/text.h index 92fe910..ddf9b6f 100644 --- a/src/text.h +++ b/src/text.h @@ -30,7 +30,7 @@ authorization from the authors. #include "xkb-priv.h" extern const char * -XkbcVModMaskText(struct xkb_keymap * xkb, unsigned modMask, unsigned mask); +XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask); extern const char * XkbcModIndexText(unsigned ndx); diff --git a/src/xkb-priv.h b/src/xkb-priv.h index 1cd07b7..83af402 100644 --- a/src/xkb-priv.h +++ b/src/xkb-priv.h @@ -423,7 +423,7 @@ struct xkb_state { int refcnt; void *filters; int num_filters; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; }; extern unsigned int @@ -434,15 +434,15 @@ xkb_key_get_level(struct xkb_state *state, xkb_keycode_t key, unsigned int group); extern unsigned int -xkb_key_get_syms_by_level(struct xkb_keymap *xkb, xkb_keycode_t key, +xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t key, unsigned int group, unsigned int level, const xkb_keysym_t **syms_out); extern bool -XkbcComputeEffectiveMap(struct xkb_keymap * xkb, struct xkb_key_type * type, +XkbcComputeEffectiveMap(struct xkb_keymap *keymap, struct xkb_key_type *type, unsigned char *map_rtrn); extern int -XkbcInitCanonicalKeyTypes(struct xkb_keymap * xkb, unsigned which, +XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which, int keypadVMod); extern unsigned diff --git a/src/xkb.c b/src/xkb.c index 92d74d2..0de2037 100644 --- a/src/xkb.c +++ b/src/xkb.c @@ -78,7 +78,7 @@ XkbcCanonicaliseComponent(char *name, const char *old) _X_EXPORT void xkb_canonicalise_components(struct xkb_component_names * names, - const struct xkb_component_names * old) + const struct xkb_component_names * old) { names->keycodes = XkbcCanonicaliseComponent(names->keycodes, old ? old->keycodes : NULL); @@ -91,24 +91,24 @@ xkb_canonicalise_components(struct xkb_component_names * names, } static bool -VirtualModsToReal(struct xkb_keymap *xkb, unsigned virtual_mask, +VirtualModsToReal(struct xkb_keymap *keymap, unsigned virtual_mask, unsigned *mask_rtrn) { int i, bit; unsigned mask; - if (!xkb) + if (!keymap) return false; if (virtual_mask == 0) { *mask_rtrn = 0; return true; } - if (!xkb->server) + if (!keymap->server) return false; for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) { if (virtual_mask & bit) - mask |= xkb->server->vmods[i]; + mask |= keymap->server->vmods[i]; } *mask_rtrn = mask; @@ -116,18 +116,18 @@ VirtualModsToReal(struct xkb_keymap *xkb, unsigned virtual_mask, } bool -XkbcComputeEffectiveMap(struct xkb_keymap * xkb, struct xkb_key_type * type, +XkbcComputeEffectiveMap(struct xkb_keymap *keymap, struct xkb_key_type *type, unsigned char *map_rtrn) { int i; unsigned tmp; struct xkb_kt_map_entry * entry = NULL; - if (!xkb || !type || !xkb->server) + if (!keymap || !type || !keymap->server) return false; if (type->mods.vmods != 0) { - if (!VirtualModsToReal(xkb, type->mods.vmods, &tmp)) + if (!VirtualModsToReal(keymap, type->mods.vmods, &tmp)) return false; type->mods.mask = tmp | type->mods.real_mods; @@ -135,7 +135,7 @@ XkbcComputeEffectiveMap(struct xkb_keymap * xkb, struct xkb_key_type * type, for (i = 0; i < type->map_count; i++, entry++) { tmp = 0; if (entry->mods.vmods != 0) { - if (!VirtualModsToReal(xkb, entry->mods.vmods, &tmp)) + if (!VirtualModsToReal(keymap, entry->mods.vmods, &tmp)) return false; if (tmp == 0) { entry->active = false; diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c index f42cf1d..624f766 100644 --- a/src/xkbcomp/action.c +++ b/src/xkbcomp/action.c @@ -203,9 +203,8 @@ ReportNotFound(unsigned action, unsigned field, const char *what, } static bool -HandleNoAction(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleNoAction(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { return ReportIllegal(action->type, field); } @@ -233,9 +232,7 @@ CheckLatchLockFlags(unsigned action, } static bool -CheckModifierField(struct xkb_keymap * xkb, - unsigned action, - ExprDef * value, +CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value, unsigned *flags_inout, unsigned *mods_rtrn) { ExprResult rtrn; @@ -253,7 +250,7 @@ CheckModifierField(struct xkb_keymap * xkb, return true; } } - if (!ExprResolveVModMask(value, &rtrn, xkb)) + if (!ExprResolveVModMask(value, &rtrn, keymap)) return ReportMismatch(action, F_Modifiers, "modifier mask"); *mods_rtrn = rtrn.uval; *flags_inout &= ~XkbSA_UseModMapMods; @@ -261,9 +258,8 @@ CheckModifierField(struct xkb_keymap * xkb, } static bool -HandleSetLatchMods(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleSetLatchMods(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { struct xkb_mod_action *act; unsigned rtrn; @@ -293,7 +289,7 @@ HandleSetLatchMods(struct xkb_keymap * xkb, return false; case F_Modifiers: t1 = act->flags; - if (CheckModifierField(xkb, action->type, value, &t1, &t2)) + if (CheckModifierField(keymap, action->type, value, &t1, &t2)) { act->flags = t1; act->real_mods = act->mask = (t2 & 0xff); @@ -306,9 +302,8 @@ HandleSetLatchMods(struct xkb_keymap * xkb, } static bool -HandleLockMods(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleLockMods(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { struct xkb_mod_action *act; unsigned t1, t2; @@ -320,7 +315,7 @@ HandleLockMods(struct xkb_keymap * xkb, { case F_Modifiers: t1 = act->flags; - if (CheckModifierField(xkb, action->type, value, &t1, &t2)) + if (CheckModifierField(keymap, action->type, value, &t1, &t2)) { act->flags = t1; act->real_mods = act->mask = (t2 & 0xff); @@ -362,9 +357,8 @@ CheckGroupField(unsigned action, } static bool -HandleSetLatchGroup(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { struct xkb_group_action *act; unsigned rtrn; @@ -407,9 +401,8 @@ HandleSetLatchGroup(struct xkb_keymap * xkb, } static bool -HandleLockGroup(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleLockGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { struct xkb_group_action *act; unsigned t1; @@ -433,9 +426,8 @@ HandleLockGroup(struct xkb_keymap * xkb, } static bool -HandleMovePtr(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_pointer_action *act; @@ -488,9 +480,8 @@ static const LookupEntry lockWhich[] = { }; static bool -HandlePtrBtn(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_pointer_button_action *act; @@ -548,9 +539,8 @@ static const LookupEntry ptrDflts[] = { }; static bool -HandleSetPtrDflt(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_pointer_default_action *act; @@ -620,9 +610,8 @@ static const LookupEntry isoNames[] = { }; static bool -HandleISOLock(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_iso_action *act; @@ -636,7 +625,7 @@ HandleISOLock(struct xkb_keymap * xkb, if (array_ndx != NULL) return ReportActionNotArray(action->type, field); flags = act->flags; - if (CheckModifierField(xkb, action->type, value, &flags, &mods)) + if (CheckModifierField(keymap, action->type, value, &flags, &mods)) { act->flags = flags & (~XkbSA_ISODfltIsGroup); act->real_mods = mods & 0xff; @@ -667,9 +656,8 @@ HandleISOLock(struct xkb_keymap * xkb, } static bool -HandleSwitchScreen(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_switch_screen_action *act; @@ -742,9 +730,8 @@ const LookupEntry ctrlNames[] = { }; static bool -HandleSetLockControls(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleSetLockControls(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_controls_action *act; @@ -773,9 +760,8 @@ static const LookupEntry evNames[] = { }; static bool -HandleActionMessage(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_message_action *act; @@ -851,9 +837,8 @@ HandleActionMessage(struct xkb_keymap * xkb, } static bool -HandleRedirectKey(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_redirect_key_action *act; @@ -871,7 +856,7 @@ HandleRedirectKey(struct xkb_keymap * xkb, if (!ExprResolveKeyName(value, &rtrn)) return ReportMismatch(action->type, field, "key name"); tmp = KeyNameToLong(rtrn.keyName.name); - if (!FindNamedKey(xkb, tmp, &kc, true, CreateKeyNames(xkb), 0)) + if (!FindNamedKey(keymap, tmp, &kc, true, CreateKeyNames(keymap), 0)) { return ReportNotFound(action->type, field, "Key", XkbcKeyNameText(rtrn.keyName.name)); @@ -881,7 +866,7 @@ HandleRedirectKey(struct xkb_keymap * xkb, case F_ModsToClear: case F_Modifiers: t1 = 0; - if (CheckModifierField(xkb, action->type, value, &t1, &t2)) + if (CheckModifierField(keymap, action->type, value, &t1, &t2)) { act->mods_mask |= (t2 & 0xff); if (field == F_Modifiers) @@ -903,9 +888,8 @@ HandleRedirectKey(struct xkb_keymap * xkb, } static bool -HandleDeviceBtn(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; struct xkb_device_button_action *act; @@ -972,9 +956,8 @@ HandleDeviceBtn(struct xkb_keymap * xkb, } static bool -HandleDeviceValuator(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandleDeviceValuator(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { #if 0 ExprResult rtrn; @@ -987,9 +970,8 @@ HandleDeviceValuator(struct xkb_keymap * xkb, } static bool -HandlePrivate(struct xkb_keymap * xkb, - struct xkb_any_action * action, - unsigned field, ExprDef * array_ndx, ExprDef * value) +HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, + unsigned field, ExprDef *array_ndx, ExprDef *value) { ExprResult rtrn; @@ -1056,7 +1038,7 @@ HandlePrivate(struct xkb_keymap * xkb, return ReportIllegal(PrivateAction, field); } -typedef bool (*actionHandler) (struct xkb_keymap *xkb, +typedef bool (*actionHandler) (struct xkb_keymap *keymap, struct xkb_any_action *action, unsigned field, ExprDef *array_ndx, ExprDef *value); @@ -1107,8 +1089,8 @@ ActionsInit(void); int HandleActionDef(ExprDef * def, - struct xkb_keymap * xkb, - struct xkb_any_action * action, ActionInfo * info) + struct xkb_keymap *keymap, + struct xkb_any_action *action, ActionInfo *info) { ExprDef *arg; const char *str; @@ -1143,7 +1125,7 @@ HandleActionDef(ExprDef * def, if ((info->action == XkbSA_NoAction) || (info->action == hndlrType)) { - if (!(*handleAction[hndlrType]) (xkb, action, + if (!(*handleAction[hndlrType]) (keymap, action, info->field, info->array_ndx, info->value)) @@ -1202,11 +1184,9 @@ HandleActionDef(ExprDef * def, } free(elemRtrn.str); free(fieldRtrn.str); - if (!(*handleAction[hndlrType]) - (xkb, action, fieldNdx, arrayRtrn, value)) - { + if (!(*handleAction[hndlrType])(keymap, action, fieldNdx, arrayRtrn, + value)) return false; - } } return true; } @@ -1214,7 +1194,7 @@ HandleActionDef(ExprDef * def, /***====================================================================***/ int -SetActionField(struct xkb_keymap * xkb, +SetActionField(struct xkb_keymap *keymap, char *elem, char *field, ExprDef * array_ndx, ExprDef * value, ActionInfo ** info_rtrn) diff --git a/src/xkbcomp/action.h b/src/xkbcomp/action.h index bb0b44b..73cccff 100644 --- a/src/xkbcomp/action.h +++ b/src/xkbcomp/action.h @@ -68,11 +68,11 @@ typedef struct _ActionInfo } ActionInfo; extern int -HandleActionDef(ExprDef *def, struct xkb_keymap *xkb, +HandleActionDef(ExprDef *def, struct xkb_keymap *keymap, struct xkb_any_action *action, ActionInfo *info); extern int -SetActionField(struct xkb_keymap *xkb, char *elem, char *field, +SetActionField(struct xkb_keymap *keymap, char *elem, char *field, ExprDef *index, ExprDef *value, ActionInfo **info_rtrn); extern const LookupEntry ctrlNames[]; diff --git a/src/xkbcomp/alias.c b/src/xkbcomp/alias.c index 412f643..a6728db 100644 --- a/src/xkbcomp/alias.c +++ b/src/xkbcomp/alias.c @@ -147,7 +147,7 @@ MergeAliases(AliasInfo ** into, AliasInfo ** merge, unsigned how_merge) } int -ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in) +ApplyAliases(struct xkb_keymap *keymap, AliasInfo ** info_in) { int i; struct xkb_key_alias *old, *a; @@ -157,8 +157,8 @@ ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in) if (*info_in == NULL) return true; - nOld = (xkb->names ? xkb->names->num_key_aliases : 0); - old = (xkb->names ? xkb->names->key_aliases : NULL); + nOld = (keymap->names ? keymap->names->num_key_aliases : 0); + old = (keymap->names ? keymap->names->key_aliases : NULL); for (nNew = 0, info = *info_in; info != NULL; info = (AliasInfo *) info->def.next) { @@ -166,7 +166,7 @@ ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in) xkb_keycode_t kc; lname = KeyNameToLong(info->real); - if (!FindNamedKey(xkb, lname, &kc, false, CreateKeyNames(xkb), 0)) + if (!FindNamedKey(keymap, lname, &kc, false, CreateKeyNames(keymap), 0)) { if (warningLevel > 4) { @@ -178,7 +178,7 @@ ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in) continue; } lname = KeyNameToLong(info->alias); - if (FindNamedKey(xkb, lname, &kc, false, false, 0)) + if (FindNamedKey(keymap, lname, &kc, false, false, 0)) { if (warningLevel > 4) { @@ -214,15 +214,15 @@ ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in) *info_in = NULL; return true; } - status = XkbcAllocNames(xkb, XkbKeyAliasesMask, nOld + nNew); - if (xkb->names) - old = xkb->names->key_aliases; + status = XkbcAllocNames(keymap, XkbKeyAliasesMask, nOld + nNew); + if (keymap->names) + old = keymap->names->key_aliases; if (status != Success) { WSGO("Allocation failure in ApplyAliases\n"); return false; } - a = xkb->names ? &xkb->names->key_aliases[nOld] : NULL; + a = keymap->names ? &keymap->names->key_aliases[nOld] : NULL; for (info = *info_in; info != NULL; info = (AliasInfo *) info->def.next) { if (info->alias[0] != '\0') diff --git a/src/xkbcomp/alias.h b/src/xkbcomp/alias.h index b7bdf10..17a815e 100644 --- a/src/xkbcomp/alias.h +++ b/src/xkbcomp/alias.h @@ -47,6 +47,6 @@ extern bool MergeAliases(AliasInfo **into, AliasInfo **merge, unsigned how_merge); extern int -ApplyAliases(struct xkb_keymap *xkb, AliasInfo **info); +ApplyAliases(struct xkb_keymap *keymap, AliasInfo **info); #endif /* ALIAS_H */ diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c index 84ca19f..b0b4707 100644 --- a/src/xkbcomp/compat.c +++ b/src/xkbcomp/compat.c @@ -64,7 +64,7 @@ typedef struct _CompatInfo LEDInfo *leds; VModInfo vmods; ActionInfo *act; - struct xkb_keymap * xkb; + struct xkb_keymap *keymap; } CompatInfo; /***====================================================================***/ @@ -96,11 +96,11 @@ siText(SymInterpInfo * si, CompatInfo * info) } static void -InitCompatInfo(CompatInfo * info, struct xkb_keymap * xkb) +InitCompatInfo(CompatInfo *info, struct xkb_keymap *keymap) { unsigned int i; - info->xkb = xkb; + info->keymap = keymap; info->name = NULL; info->fileID = 0; info->errorCount = 0; @@ -122,11 +122,11 @@ InitCompatInfo(CompatInfo * info, struct xkb_keymap * xkb) memset(&info->groupCompat[0], 0, XkbNumKbdGroups * sizeof(GroupCompatInfo)); info->leds = NULL; - InitVModInfo(&info->vmods, xkb); + InitVModInfo(&info->vmods, keymap); } static void -ClearCompatInfo(CompatInfo * info, struct xkb_keymap * xkb) +ClearCompatInfo(CompatInfo *info, struct xkb_keymap *keymap) { unsigned int i; ActionInfo *next; @@ -151,7 +151,7 @@ ClearCompatInfo(CompatInfo * info, struct xkb_keymap * xkb) free(info->act); info->act = next; } - ClearVModInfo(&info->vmods, xkb); + ClearVModInfo(&info->vmods, keymap); } static SymInterpInfo * @@ -384,12 +384,12 @@ MergeIncludedCompatMaps(CompatInfo * into, CompatInfo * from, unsigned merge) } } -typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *xkb, +typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap, unsigned merge, CompatInfo *info); static bool -HandleIncludeCompatMap(IncludeStmt * stmt, - struct xkb_keymap * xkb, CompatInfo * info, FileHandler hndlr) +HandleIncludeCompatMap(IncludeStmt *stmt, struct xkb_keymap *keymap, + CompatInfo *info, FileHandler hndlr) { unsigned newMerge; XkbFile *rtrn; @@ -403,10 +403,10 @@ HandleIncludeCompatMap(IncludeStmt * stmt, included = *info; memset(info, 0, sizeof(CompatInfo)); } - else if (ProcessIncludeFile(xkb->context, stmt, XkmCompatMapIndex, &rtrn, - &newMerge)) + else if (ProcessIncludeFile(keymap->context, stmt, XkmCompatMapIndex, + &rtrn, &newMerge)) { - InitCompatInfo(&included, xkb); + InitCompatInfo(&included, keymap); included.fileID = rtrn->id; included.dflt = info->dflt; included.dflt.defs.fileID = rtrn->id; @@ -414,7 +414,7 @@ HandleIncludeCompatMap(IncludeStmt * stmt, included.ledDflt.defs.fileID = rtrn->id; included.ledDflt.defs.merge = newMerge; included.act = info->act; - (*hndlr) (rtrn, xkb, MergeOverride, &included); + (*hndlr) (rtrn, keymap, MergeOverride, &included); if (stmt->stmt != NULL) { free(included.name); @@ -442,12 +442,12 @@ HandleIncludeCompatMap(IncludeStmt * stmt, { haveSelf = true; MergeIncludedCompatMaps(&included, info, next->merge); - ClearCompatInfo(info, xkb); + ClearCompatInfo(info, keymap); } - else if (ProcessIncludeFile(xkb->context, next, XkmCompatMapIndex, - &rtrn, &op)) + else if (ProcessIncludeFile(keymap->context, next, + XkmCompatMapIndex, &rtrn, &op)) { - InitCompatInfo(&next_incl, xkb); + InitCompatInfo(&next_incl, keymap); next_incl.fileID = rtrn->id; next_incl.dflt = info->dflt; next_incl.dflt.defs.fileID = rtrn->id; @@ -455,11 +455,11 @@ HandleIncludeCompatMap(IncludeStmt * stmt, next_incl.ledDflt.defs.fileID = rtrn->id; next_incl.ledDflt.defs.merge = op; next_incl.act = info->act; - (*hndlr) (rtrn, xkb, MergeOverride, &next_incl); + (*hndlr) (rtrn, keymap, MergeOverride, &next_incl); MergeIncludedCompatMaps(&included, &next_incl, op); if (info->act != NULL) next_incl.act = NULL; - ClearCompatInfo(&next_incl, xkb); + ClearCompatInfo(&next_incl, keymap); FreeXKBFile(rtrn); } else @@ -474,7 +474,7 @@ HandleIncludeCompatMap(IncludeStmt * stmt, else { MergeIncludedCompatMaps(info, &included, newMerge); - ClearCompatInfo(&included, xkb); + ClearCompatInfo(&included, keymap); } return (info->errorCount == 0); } @@ -488,10 +488,8 @@ static const LookupEntry useModMapValues[] = { }; static int -SetInterpField(SymInterpInfo * si, - struct xkb_keymap * xkb, - char *field, - ExprDef * arrayNdx, ExprDef * value, CompatInfo * info) +SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, + ExprDef *arrayNdx, ExprDef *value, CompatInfo *info) { int ok = 1; ExprResult tmp; @@ -500,7 +498,7 @@ SetInterpField(SymInterpInfo * si, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = HandleActionDef(value, xkb, &si->interp.act.any, info->act); + ok = HandleActionDef(value, keymap, &si->interp.act.any, info->act); if (ok) si->defs.defined |= _SI_Action; } @@ -509,7 +507,7 @@ SetInterpField(SymInterpInfo * si, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ResolveVirtualModifier(value, xkb, &tmp, &info->vmods); + ok = ResolveVirtualModifier(value, keymap, &tmp, &info->vmods); if (ok) { si->interp.virtual_mod = tmp.uval; @@ -575,7 +573,7 @@ SetInterpField(SymInterpInfo * si, } static int -HandleInterpVar(VarDef * stmt, struct xkb_keymap * xkb, CompatInfo * info) +HandleInterpVar(VarDef * stmt, struct xkb_keymap *keymap, CompatInfo * info) { ExprResult elem, field; ExprDef *ndx; @@ -584,13 +582,13 @@ HandleInterpVar(VarDef * stmt, struct xkb_keymap * xkb, CompatInfo * info) if (ExprResolveLhs(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, xkb, field.str, ndx, stmt->value, + ret = SetInterpField(&info->dflt, keymap, field.str, ndx, stmt->value, info); else if (elem.str && (strcasecmp(elem.str, "indicator") == 0)) - ret = SetIndicatorMapField(&info->ledDflt, xkb, field.str, ndx, + ret = SetIndicatorMapField(&info->ledDflt, keymap, field.str, ndx, stmt->value); else - ret = SetActionField(xkb, elem.str, field.str, ndx, stmt->value, + ret = SetActionField(keymap, elem.str, field.str, ndx, stmt->value, &info->act); free(elem.str); free(field.str); @@ -598,8 +596,8 @@ HandleInterpVar(VarDef * stmt, struct xkb_keymap * xkb, CompatInfo * info) } static int -HandleInterpBody(VarDef * def, struct xkb_keymap * xkb, SymInterpInfo * si, - CompatInfo * info) +HandleInterpBody(VarDef *def, struct xkb_keymap *keymap, SymInterpInfo *si, + CompatInfo *info) { int ok = 1; ExprResult tmp, field; @@ -609,12 +607,12 @@ HandleInterpBody(VarDef * def, struct xkb_keymap * xkb, SymInterpInfo * si, { if ((def->name) && (def->name->type == ExprFieldRef)) { - ok = HandleInterpVar(def, xkb, info); + ok = HandleInterpVar(def, keymap, info); continue; } ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx); if (ok) { - ok = SetInterpField(si, xkb, field.str, arrayNdx, def->value, + ok = SetInterpField(si, keymap, field.str, arrayNdx, def->value, info); free(field.str); } @@ -623,8 +621,8 @@ HandleInterpBody(VarDef * def, struct xkb_keymap * xkb, SymInterpInfo * si, } static int -HandleInterpDef(InterpDef * def, struct xkb_keymap * xkb, unsigned merge, - CompatInfo * info) +HandleInterpDef(InterpDef *def, struct xkb_keymap *keymap, unsigned merge, + CompatInfo *info) { unsigned pred, mods; SymInterpInfo si; @@ -648,7 +646,7 @@ HandleInterpDef(InterpDef * def, struct xkb_keymap * xkb, unsigned merge, } si.interp.match = pred & XkbSI_OpMask; si.interp.mods = mods; - if (!HandleInterpBody(def->def, xkb, &si, info)) + if (!HandleInterpBody(def->def, keymap, &si, info)) { info->errorCount++; return false; @@ -663,8 +661,8 @@ HandleInterpDef(InterpDef * def, struct xkb_keymap * xkb, unsigned merge, } static int -HandleGroupCompatDef(GroupCompatDef * def, - struct xkb_keymap * xkb, unsigned merge, CompatInfo * info) +HandleGroupCompatDef(GroupCompatDef *def, struct xkb_keymap *keymap, + unsigned merge, CompatInfo *info) { ExprResult val; GroupCompatInfo tmp; @@ -681,7 +679,7 @@ HandleGroupCompatDef(GroupCompatDef * def, } tmp.fileID = info->fileID; tmp.merge = merge; - if (!ExprResolveVModMask(def->def, &val, xkb)) + if (!ExprResolveVModMask(def->def, &val, keymap)) { ERROR("Expected a modifier mask in group compatibility definition\n"); ACTION("Ignoring illegal compatibility map for group %d\n", @@ -695,8 +693,8 @@ HandleGroupCompatDef(GroupCompatDef * def, } static void -HandleCompatMapFile(XkbFile * file, - struct xkb_keymap * xkb, unsigned merge, CompatInfo * info) +HandleCompatMapFile(XkbFile *file, struct xkb_keymap *keymap, unsigned merge, + CompatInfo *info) { ParseCommon *stmt; @@ -710,23 +708,23 @@ HandleCompatMapFile(XkbFile * file, switch (stmt->stmtType) { case StmtInclude: - if (!HandleIncludeCompatMap((IncludeStmt *) stmt, xkb, info, + if (!HandleIncludeCompatMap((IncludeStmt *) stmt, keymap, info, HandleCompatMapFile)) info->errorCount++; break; case StmtInterpDef: - if (!HandleInterpDef((InterpDef *) stmt, xkb, merge, info)) + if (!HandleInterpDef((InterpDef *) stmt, keymap, merge, info)) info->errorCount++; break; case StmtGroupCompatDef: if (!HandleGroupCompatDef - ((GroupCompatDef *) stmt, xkb, merge, info)) + ((GroupCompatDef *) stmt, keymap, merge, info)) info->errorCount++; break; case StmtIndicatorMapDef: { LEDInfo *rtrn; - rtrn = HandleIndicatorMapDef((IndicatorMapDef *) stmt, xkb, + rtrn = HandleIndicatorMapDef((IndicatorMapDef *) stmt, keymap, &info->ledDflt, info->leds, merge); if (rtrn != NULL) info->leds = rtrn; @@ -735,11 +733,11 @@ HandleCompatMapFile(XkbFile * file, } break; case StmtVarDef: - if (!HandleInterpVar((VarDef *) stmt, xkb, info)) + if (!HandleInterpVar((VarDef *) stmt, keymap, info)) info->errorCount++; break; case StmtVModDef: - if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods)) + if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods)) info->errorCount++; break; case StmtKeycodeDef: @@ -787,62 +785,62 @@ CopyInterps(CompatInfo * info, } bool -CompileCompatMap(XkbFile *file, struct xkb_keymap *xkb, unsigned merge, +CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap, unsigned merge, LEDInfoPtr *unboundLEDs) { int i; CompatInfo info; GroupCompatInfo *gcm; - InitCompatInfo(&info, xkb); + InitCompatInfo(&info, keymap); info.dflt.defs.merge = merge; info.ledDflt.defs.merge = merge; - HandleCompatMapFile(file, xkb, merge, &info); + HandleCompatMapFile(file, keymap, merge, &info); if (info.errorCount != 0) goto err_info; - if (XkbcAllocCompatMap(xkb, info.nInterps) != Success) { + if (XkbcAllocCompatMap(keymap, info.nInterps) != Success) { WSGO("Couldn't allocate compatibility map\n"); goto err_info; } if (info.nInterps > 0) { - CopyInterps(&info, xkb->compat, true, XkbSI_Exactly); - CopyInterps(&info, xkb->compat, true, XkbSI_AllOf | XkbSI_NoneOf); - CopyInterps(&info, xkb->compat, true, XkbSI_AnyOf); - CopyInterps(&info, xkb->compat, true, XkbSI_AnyOfOrNone); - CopyInterps(&info, xkb->compat, false, XkbSI_Exactly); - CopyInterps(&info, xkb->compat, false, XkbSI_AllOf | XkbSI_NoneOf); - CopyInterps(&info, xkb->compat, false, XkbSI_AnyOf); - CopyInterps(&info, xkb->compat, false, XkbSI_AnyOfOrNone); + CopyInterps(&info, keymap->compat, true, XkbSI_Exactly); + CopyInterps(&info, keymap->compat, true, XkbSI_AllOf | XkbSI_NoneOf); + CopyInterps(&info, keymap->compat, true, XkbSI_AnyOf); + CopyInterps(&info, keymap->compat, true, XkbSI_AnyOfOrNone); + CopyInterps(&info, keymap->compat, false, XkbSI_Exactly); + CopyInterps(&info, keymap->compat, false, XkbSI_AllOf | XkbSI_NoneOf); + CopyInterps(&info, keymap->compat, false, XkbSI_AnyOf); + CopyInterps(&info, keymap->compat, false, XkbSI_AnyOfOrNone); } for (i = 0, gcm = &info.groupCompat[0]; i < XkbNumKbdGroups; i++, gcm++) { if ((gcm->fileID != 0) || (gcm->real_mods != 0) || (gcm->vmods != 0)) { - xkb->compat->groups[i].mask = gcm->real_mods; - xkb->compat->groups[i].real_mods = gcm->real_mods; - xkb->compat->groups[i].vmods = gcm->vmods; + keymap->compat->groups[i].mask = gcm->real_mods; + keymap->compat->groups[i].real_mods = gcm->real_mods; + keymap->compat->groups[i].vmods = gcm->vmods; } } if (info.leds != NULL) { - if (!CopyIndicatorMapDefs(xkb, info.leds, unboundLEDs)) + if (!CopyIndicatorMapDefs(keymap, info.leds, unboundLEDs)) info.errorCount++; info.leds = NULL; } - ClearCompatInfo(&info, xkb); + ClearCompatInfo(&info, keymap); return true; err_info: - ClearCompatInfo(&info, xkb); + ClearCompatInfo(&info, keymap); return false; } static uint32_t -VModsToReal(struct xkb_keymap *xkb, uint32_t vmodmask) +VModsToReal(struct xkb_keymap *keymap, uint32_t vmodmask) { uint32_t ret = 0; int i; @@ -853,14 +851,15 @@ VModsToReal(struct xkb_keymap *xkb, uint32_t vmodmask) for (i = 0; i < XkbNumVirtualMods; i++) { if (!(vmodmask & (1 << i))) continue; - ret |= xkb->server->vmods[i]; + ret |= keymap->server->vmods[i]; } return ret; } static void -UpdateActionMods(struct xkb_keymap *xkb, union xkb_action *act, uint32_t rmodmask) +UpdateActionMods(struct xkb_keymap *keymap, union xkb_action *act, + uint32_t rmodmask) { switch (act->type) { case XkbSA_SetMods: @@ -869,13 +868,13 @@ UpdateActionMods(struct xkb_keymap *xkb, union xkb_action *act, uint32_t rmodmas if (act->mods.flags & XkbSA_UseModMapMods) act->mods.real_mods = rmodmask; act->mods.mask = act->mods.real_mods; - act->mods.mask |= VModsToReal(xkb, act->mods.vmods); + act->mods.mask |= VModsToReal(keymap, act->mods.vmods); break; case XkbSA_ISOLock: if (act->iso.flags & XkbSA_UseModMapMods) act->iso.real_mods = rmodmask; act->iso.mask = act->iso.real_mods; - act->iso.mask |= VModsToReal(xkb, act->iso.vmods); + act->iso.mask |= VModsToReal(keymap, act->iso.vmods); break; default: break; @@ -888,19 +887,20 @@ UpdateActionMods(struct xkb_keymap *xkb, union xkb_action *act, uint32_t rmodmas * generic XKB_KEYSYM_NO_SYMBOL match. */ static struct xkb_sym_interpret * -FindInterpForKey(struct xkb_keymap *xkb, xkb_keycode_t key, uint32_t group, uint32_t level) +FindInterpForKey(struct xkb_keymap *keymap, xkb_keycode_t key, + uint32_t group, uint32_t level) { struct xkb_sym_interpret *ret = NULL; const xkb_keysym_t *syms; int num_syms; int i; - num_syms = xkb_key_get_syms_by_level(xkb, key, group, level, &syms); + num_syms = xkb_key_get_syms_by_level(keymap, key, group, level, &syms); if (num_syms == 0) return NULL; - for (i = 0; i < xkb->compat->num_si; i++) { - struct xkb_sym_interpret *interp = &xkb->compat->sym_interpret[i]; + for (i = 0; i < keymap->compat->num_si; i++) { + struct xkb_sym_interpret *interp = &keymap->compat->sym_interpret[i]; uint32_t mods; bool found; @@ -909,7 +909,7 @@ FindInterpForKey(struct xkb_keymap *xkb, xkb_keycode_t key, uint32_t group, uint continue; if (level == 0 || !(interp->match & XkbSI_LevelOneOnly)) - mods = xkb->map->modmap[key]; + mods = keymap->map->modmap[key]; else mods = 0; @@ -946,7 +946,7 @@ FindInterpForKey(struct xkb_keymap *xkb, xkb_keycode_t key, uint32_t group, uint /** */ static bool -ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key) +ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t key) { #define INTERP_SIZE (8 * 4) struct xkb_sym_interpret *interps[INTERP_SIZE]; @@ -954,37 +954,37 @@ ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key) uint32_t vmodmask = 0; int num_acts = 0; int group, level; - int width = XkbKeyGroupsWidth(xkb, key); + int width = XkbKeyGroupsWidth(keymap, key); int i; /* If we've been told not to bind interps to this key, then don't. */ - if (xkb->server->explicit[key] & XkbExplicitInterpretMask) + if (keymap->server->explicit[key] & XkbExplicitInterpretMask) return true; for (i = 0; i < INTERP_SIZE; i++) interps[i] = NULL; - for (group = 0; group < XkbKeyNumGroups(xkb, key); group++) { - for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++) { + for (group = 0; group < XkbKeyNumGroups(keymap, key); group++) { + for (level = 0; level < XkbKeyGroupWidth(keymap, key, group); level++) { i = (group * width) + level; if (i >= INTERP_SIZE) /* XXX FIXME */ return false; - interps[i] = FindInterpForKey(xkb, key, group, level); + interps[i] = FindInterpForKey(keymap, key, group, level); if (interps[i]) num_acts++; } } if (num_acts) - num_acts = XkbKeyNumGroups(xkb, key) * width; - acts = XkbcResizeKeyActions(xkb, key, num_acts); + num_acts = XkbKeyNumGroups(keymap, key) * width; + acts = XkbcResizeKeyActions(keymap, key, num_acts); if (!num_acts) return true; else if (!acts) return false; - for (group = 0; group < XkbKeyNumGroups(xkb, key); group++) { - for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++) { + for (group = 0; group < XkbKeyNumGroups(keymap, key); group++) { + for (level = 0; level < XkbKeyGroupWidth(keymap, key, group); level++) { struct xkb_sym_interpret *interp; i = (group * width) + level; @@ -992,12 +992,12 @@ ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key) /* Infer default key behaviours from the base level. */ if (group == 0 && level == 0) { - if (!(xkb->server->explicit[key] & XkbExplicitAutoRepeatMask) && + if (!(keymap->server->explicit[key] & XkbExplicitAutoRepeatMask) && (!interp || interp->flags & XkbSI_AutoRepeat)) - xkb->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8)); - if (!(xkb->server->explicit[key] & XkbExplicitBehaviorMask) && + keymap->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8)); + if (!(keymap->server->explicit[key] & XkbExplicitBehaviorMask) && interp && (interp->flags & XkbSI_LockingKey)) - xkb->server->behaviors[key].type = XkbKB_Lock; + keymap->server->behaviors[key].type = XkbKB_Lock; } if (!interp) @@ -1012,8 +1012,8 @@ ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key) } } - if (!(xkb->server->explicit[key] & XkbExplicitVModMapMask)) - xkb->server->vmodmap[key] = vmodmask; + if (!(keymap->server->explicit[key] & XkbExplicitVModMapMask)) + keymap->server->vmodmap[key] = vmodmask; return true; #undef INTERP_SIZE @@ -1026,68 +1026,68 @@ ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key) * other than Shift actually do something ... */ bool -UpdateModifiersFromCompat(struct xkb_keymap *xkb) +UpdateModifiersFromCompat(struct xkb_keymap *keymap) { xkb_keycode_t key; int i; /* Find all the interprets for the key and bind them to actions, * which will also update the vmodmap. */ - for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) - if (!ApplyInterpsToKey(xkb, key)) + for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) + if (!ApplyInterpsToKey(keymap, key)) return false; - /* Update xkb->server->vmods, the virtual -> real mod mapping. */ + /* Update keymap->server->vmods, the virtual -> real mod mapping. */ for (i = 0; i < XkbNumVirtualMods; i++) - xkb->server->vmods[i] = 0; - for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) { - if (!xkb->server->vmodmap[key]) + keymap->server->vmods[i] = 0; + for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) { + if (!keymap->server->vmodmap[key]) continue; for (i = 0; i < XkbNumVirtualMods; i++) { - if (!(xkb->server->vmodmap[key] & (1 << i))) + if (!(keymap->server->vmodmap[key] & (1 << i))) continue; - xkb->server->vmods[i] |= xkb->map->modmap[key]; + keymap->server->vmods[i] |= keymap->map->modmap[key]; } } /* Now update the level masks for all the types to reflect the vmods. */ - for (i = 0; i < xkb->map->num_types; i++) { - struct xkb_key_type *type = &xkb->map->types[i]; + for (i = 0; i < keymap->map->num_types; i++) { + struct xkb_key_type *type = &keymap->map->types[i]; uint32_t mask = 0; int j; type->mods.mask = type->mods.real_mods; - type->mods.mask |= VModsToReal(xkb, type->mods.vmods); + type->mods.mask |= VModsToReal(keymap, type->mods.vmods); for (j = 0; j < XkbNumVirtualMods; j++) { if (!(type->mods.vmods & (1 << j))) continue; - mask |= xkb->server->vmods[j]; + mask |= keymap->server->vmods[j]; } for (j = 0; j < type->map_count; j++) { struct xkb_mods *mods = &type->map[j].mods; - mods->mask = mods->real_mods | VModsToReal(xkb, mods->vmods); + mods->mask = mods->real_mods | VModsToReal(keymap, mods->vmods); } } /* Update action modifiers. */ - for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) { - union xkb_action *acts = XkbKeyActionsPtr(xkb, key); - for (i = 0; i < XkbKeyNumActions(xkb, key); i++) { + for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) { + union xkb_action *acts = XkbKeyActionsPtr(keymap, key); + for (i = 0; i < XkbKeyNumActions(keymap, key); i++) { if (acts[i].any.type == XkbSA_NoAction) continue; - UpdateActionMods(xkb, &acts[i], xkb->map->modmap[key]); + UpdateActionMods(keymap, &acts[i], keymap->map->modmap[key]); } } /* Update group modifiers. */ for (i = 0; i < XkbNumKbdGroups; i++) { - struct xkb_mods *group = &xkb->compat->groups[i]; - group->mask = group->real_mods | VModsToReal(xkb, group->vmods); + struct xkb_mods *group = &keymap->compat->groups[i]; + group->mask = group->real_mods | VModsToReal(keymap, group->vmods); } /* Update vmod -> indicator maps. */ for (i = 0; i < XkbNumIndicators; i++) { - struct xkb_mods *led = &xkb->indicators->maps[i].mods; - led->mask = led->real_mods | VModsToReal(xkb, led->vmods); + struct xkb_mods *led = &keymap->indicators->maps[i].mods; + led->mask = led->real_mods | VModsToReal(keymap, led->vmods); } return true; diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c index 2b82ce3..c1626d2 100644 --- a/src/xkbcomp/expr.c +++ b/src/xkbcomp/expr.c @@ -943,31 +943,27 @@ ExprResolveMaskLookup(ExprDef * expr, } int -ExprResolveMask(ExprDef * expr, - ExprResult * val_rtrn, +ExprResolveMask(ExprDef *expr, ExprResult *val_rtrn, const LookupEntry * values) { return ExprResolveMaskLookup(expr, val_rtrn, SimpleLookup, values); } int -ExprResolveModMask(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveModMask(ExprDef *expr, ExprResult *val_rtrn) { return ExprResolveMaskLookup(expr, val_rtrn, LookupModMask, NULL); } int -ExprResolveVModMask(ExprDef * expr, - ExprResult * val_rtrn, - struct xkb_keymap *xkb) +ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn, + struct xkb_keymap *keymap) { - return ExprResolveMaskLookup(expr, val_rtrn, LookupVModMask, xkb); + return ExprResolveMaskLookup(expr, val_rtrn, LookupVModMask, keymap); } int -ExprResolveKeySym(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn) { int ok = 0; xkb_keysym_t sym; diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h index 89162d1..1f77314 100644 --- a/src/xkbcomp/expr.h +++ b/src/xkbcomp/expr.h @@ -68,7 +68,7 @@ ExprResolveModMask(ExprDef *expr, ExprResult *val_rtrn); extern int ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn, - struct xkb_keymap *xkb); + struct xkb_keymap *keymap); extern int ExprResolveBoolean(ExprDef *expr, ExprResult *val_rtrn); diff --git a/src/xkbcomp/indicators.c b/src/xkbcomp/indicators.c index c4f861e..fc75a4d 100644 --- a/src/xkbcomp/indicators.c +++ b/src/xkbcomp/indicators.c @@ -191,9 +191,8 @@ static const LookupEntry groupNames[] = { }; int -SetIndicatorMapField(LEDInfo * led, - struct xkb_keymap * xkb, - char *field, ExprDef * arrayNdx, ExprDef * value) +SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, + char *field, ExprDef *arrayNdx, ExprDef *value) { ExprResult rtrn; bool ok; @@ -204,7 +203,7 @@ SetIndicatorMapField(LEDInfo * led, { if (arrayNdx != NULL) return ReportIndicatorNotArray(led, field); - if (!ExprResolveVModMask(value, &rtrn, xkb)) + if (!ExprResolveVModMask(value, &rtrn, keymap)) return ReportIndicatorBadType(led, field, "modifier mask"); led->real_mods = rtrn.uval & 0xff; led->vmods = (rtrn.uval >> 8) & 0xff; @@ -311,9 +310,8 @@ SetIndicatorMapField(LEDInfo * led, } LEDInfo * -HandleIndicatorMapDef(IndicatorMapDef * def, - struct xkb_keymap * xkb, - LEDInfo * dflt, LEDInfo * oldLEDs, unsigned merge) +HandleIndicatorMapDef(IndicatorMapDef *def, struct xkb_keymap *keymap, + LEDInfo *dflt, LEDInfo *oldLEDs, unsigned merge) { LEDInfo led, *rtrn; VarDef *var; @@ -346,7 +344,7 @@ HandleIndicatorMapDef(IndicatorMapDef * def, } else { - ok = SetIndicatorMapField(&led, xkb, field.str, arrayNdx, + ok = SetIndicatorMapField(&led, keymap, field.str, arrayNdx, var->value) && ok; } free(elem.str); @@ -361,17 +359,18 @@ HandleIndicatorMapDef(IndicatorMapDef * def, } bool -CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRtrn) +CopyIndicatorMapDefs(struct xkb_keymap *keymap, LEDInfo *leds, + LEDInfo **unboundRtrn) { LEDInfo *led, *next; LEDInfo *unbound, *last; - if (XkbcAllocNames(xkb, XkbIndicatorNamesMask, 0) != Success) + if (XkbcAllocNames(keymap, XkbIndicatorNamesMask, 0) != Success) { WSGO("Couldn't allocate names\n"); ACTION("Indicator names may be incorrect\n"); } - if (XkbcAllocIndicatorMaps(xkb) != Success) + if (XkbcAllocIndicatorMaps(keymap) != Success) { WSGO("Can't allocate indicator maps\n"); ACTION("Indicator map definitions may be lost\n"); @@ -389,7 +388,7 @@ CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRt led->which_groups = XkbIM_UseEffective; if ((led->which_mods == 0) && ((led->real_mods) || (led->vmods))) led->which_mods = XkbIM_UseEffective; - if ((led->indicator == _LED_NotBound) || (!xkb->indicators)) + if ((led->indicator == _LED_NotBound) || (!keymap->indicators)) { if (unboundRtrn != NULL) { @@ -406,7 +405,7 @@ CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRt else { struct xkb_indicator_map * im; - im = &xkb->indicators->maps[led->indicator - 1]; + im = &keymap->indicators->maps[led->indicator - 1]; im->flags = led->flags; im->which_groups = led->which_groups; im->groups = led->groups; @@ -415,10 +414,11 @@ CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRt im->mods.real_mods = led->real_mods; im->mods.vmods = led->vmods; im->ctrls = led->ctrls; - if (xkb->names != NULL) + if (keymap->names != NULL) { - free(UNCONSTIFY(xkb->names->indicators[led->indicator - 1])); - xkb->names->indicators[led->indicator-1] = XkbcAtomGetString(led->name); + free(UNCONSTIFY(keymap->names->indicators[led->indicator - 1])); + keymap->names->indicators[led->indicator-1] = + XkbcAtomGetString(led->name); } free(led); } @@ -431,13 +431,13 @@ CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRt } bool -BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound, +BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, LEDInfo **unboundRtrn) { int i; LEDInfo *led, *next, *last; - if (xkb->names != NULL) + if (keymap->names != NULL) { for (led = unbound; led != NULL; led = (LEDInfo *) led->defs.next) { @@ -445,8 +445,8 @@ BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound, { for (i = 0; i < XkbNumIndicators; i++) { - if (xkb->names->indicators[i] && - strcmp(xkb->names->indicators[i], + if (keymap->names->indicators[i] && + strcmp(keymap->names->indicators[i], XkbcAtomText(led->name)) == 0) { led->indicator = i + 1; @@ -463,9 +463,10 @@ BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound, { for (i = 0; i < XkbNumIndicators; i++) { - if (xkb->names->indicators[i] == NULL) + if (keymap->names->indicators[i] == NULL) { - xkb->names->indicators[i] = XkbcAtomGetString(led->name); + keymap->names->indicators[i] = + XkbcAtomGetString(led->name); led->indicator = i + 1; break; } @@ -503,11 +504,11 @@ BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound, } else { - if ((xkb->names != NULL) && - (strcmp(xkb->names->indicators[led->indicator - 1], + if ((keymap->names != NULL) && + (strcmp(keymap->names->indicators[led->indicator - 1], XkbcAtomText(led->name)) != 0)) { - const char *old = xkb->names->indicators[led->indicator - 1]; + const char *old = keymap->names->indicators[led->indicator - 1]; ERROR("Multiple names bound to indicator %d\n", (unsigned int) led->indicator); ACTION("Using %s, ignoring %s\n", old, XkbcAtomText(led->name)); @@ -529,7 +530,7 @@ BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound, else { struct xkb_indicator_map * map; - map = &xkb->indicators->maps[led->indicator - 1]; + map = &keymap->indicators->maps[led->indicator - 1]; map->flags = led->flags; map->which_groups = led->which_groups; map->groups = led->groups; diff --git a/src/xkbcomp/indicators.h b/src/xkbcomp/indicators.h index c88ae4b..829f5d2 100644 --- a/src/xkbcomp/indicators.h +++ b/src/xkbcomp/indicators.h @@ -61,19 +61,19 @@ extern LEDInfo * AddIndicatorMap(LEDInfo *oldLEDs, LEDInfo *newLED); extern int -SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *xkb, char *field, +SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, char *field, ExprDef *arrayNdx, ExprDef *value); extern LEDInfo * -HandleIndicatorMapDef(IndicatorMapDef *stmt, struct xkb_keymap *xkb, +HandleIndicatorMapDef(IndicatorMapDef *stmt, struct xkb_keymap *keymap, LEDInfo *dflt, LEDInfo *oldLEDs, unsigned mergeMode); extern bool -CopyIndicatorMapDefs(struct xkb_keymap *xkb, LEDInfo *leds, +CopyIndicatorMapDefs(struct xkb_keymap *keymap, LEDInfo *leds, LEDInfo **unboundRtrn); extern bool -BindIndicators(struct xkb_keymap *xkb, bool force, LEDInfo *unbound, +BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, LEDInfo **unboundRtrn); #endif /* INDICATORS_H */ diff --git a/src/xkbcomp/keycodes.c b/src/xkbcomp/keycodes.c index 5790cda..7fdd688 100644 --- a/src/xkbcomp/keycodes.c +++ b/src/xkbcomp/keycodes.c @@ -77,10 +77,8 @@ typedef struct _KeyNamesInfo AliasInfo *aliases; } KeyNamesInfo; -static void HandleKeycodesFile(XkbFile * file, - struct xkb_keymap * xkb, - unsigned merge, - KeyNamesInfo * info); +static void HandleKeycodesFile(XkbFile *file, struct xkb_keymap *keymap, + unsigned merge, KeyNamesInfo *info); static int ResizeKeyNameArrays(KeyNamesInfo *info, int newMax) @@ -537,11 +535,12 @@ MergeIncludedKeycodes(KeyNamesInfo * into, KeyNamesInfo * from, * Handle the given include statement (e.g. "include "evdev+aliases(qwerty)"). * * @param stmt The include statement from the keymap file. - * @param xkb Unused for all but the xkb->flags. + * @param keymap Unused for all but the keymap->flags. * @param info Struct to store the key info in. */ static bool -HandleIncludeKeycodes(IncludeStmt * stmt, struct xkb_keymap * xkb, KeyNamesInfo * info) +HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, + KeyNamesInfo *info) { unsigned newMerge; XkbFile *rtrn; @@ -559,16 +558,16 @@ HandleIncludeKeycodes(IncludeStmt * stmt, struct xkb_keymap * xkb, KeyNamesInfo } else if (stmt->file && strcmp(stmt->file, "computed") == 0) { - xkb->flags |= AutoKeyNames; + keymap->flags |= AutoKeyNames; info->explicitMin = 0; info->explicitMax = XKB_KEYCODE_MAX; return (info->errorCount == 0); } /* parse file, store returned info in the xkb struct */ - else if (ProcessIncludeFile(xkb->context, stmt, XkmKeyNamesIndex, &rtrn, - &newMerge)) + else if (ProcessIncludeFile(keymap->context, stmt, XkmKeyNamesIndex, + &rtrn, &newMerge)) { InitKeyNamesInfo(&included); - HandleKeycodesFile(rtrn, xkb, MergeOverride, &included); + HandleKeycodesFile(rtrn, keymap, MergeOverride, &included); if (stmt->stmt != NULL) { free(included.name); @@ -597,11 +596,11 @@ HandleIncludeKeycodes(IncludeStmt * stmt, struct xkb_keymap * xkb, KeyNamesInfo MergeIncludedKeycodes(&included, info, next->merge); ClearKeyNamesInfo(info); } - else if (ProcessIncludeFile(xkb->context, next, XkmKeyNamesIndex, - &rtrn, &op)) + else if (ProcessIncludeFile(keymap->context, next, + XkmKeyNamesIndex, &rtrn, &op)) { InitKeyNamesInfo(&next_incl); - HandleKeycodesFile(rtrn, xkb, MergeOverride, &next_incl); + HandleKeycodesFile(rtrn, keymap, MergeOverride, &next_incl); MergeIncludedKeycodes(&included, &next_incl, op); ClearKeyNamesInfo(&next_incl); FreeXKBFile(rtrn); @@ -629,7 +628,7 @@ HandleIncludeKeycodes(IncludeStmt * stmt, struct xkb_keymap * xkb, KeyNamesInfo * e.g. = 9 */ static int -HandleKeycodeDef(KeycodeDef * stmt, unsigned merge, KeyNamesInfo * info) +HandleKeycodeDef(KeycodeDef *stmt, unsigned merge, KeyNamesInfo *info) { if ((info->explicitMin != 0 && stmt->value < info->explicitMin) || (info->explicitMax != 0 && stmt->value > info->explicitMax)) @@ -661,7 +660,7 @@ HandleKeycodeDef(KeycodeDef * stmt, unsigned merge, KeyNamesInfo * info) * @return 1 on success, 0 otherwise. */ static int -HandleKeyNameVar(VarDef * stmt, KeyNamesInfo * info) +HandleKeyNameVar(VarDef *stmt, KeyNamesInfo *info) { ExprResult tmp, field; ExprDef *arrayNdx; @@ -798,8 +797,8 @@ HandleIndicatorNameDef(IndicatorNameDef *def, KeyNamesInfo *info) * @param info Struct to contain the fully parsed key information. */ static void -HandleKeycodesFile(XkbFile * file, - struct xkb_keymap * xkb, unsigned merge, KeyNamesInfo * info) +HandleKeycodesFile(XkbFile *file, struct xkb_keymap *keymap, + unsigned merge, KeyNamesInfo *info) { ParseCommon *stmt; @@ -811,7 +810,7 @@ HandleKeycodesFile(XkbFile * file, switch (stmt->stmtType) { case StmtInclude: /* e.g. include "evdev+aliases(qwerty)" */ - if (!HandleIncludeKeycodes((IncludeStmt *) stmt, xkb, info)) + if (!HandleIncludeKeycodes((IncludeStmt *) stmt, keymap, info)) info->errorCount++; break; case StmtKeycodeDef: /* e.g. = 9; */ @@ -819,8 +818,8 @@ HandleKeycodesFile(XkbFile * file, info->errorCount++; break; case StmtKeyAliasDef: /* e.g. alias = ; */ - if (!HandleAliasDef((KeyAliasDef *) stmt, - merge, info->fileID, &info->aliases)) + if (!HandleAliasDef((KeyAliasDef *) stmt, merge, info->fileID, + &info->aliases)) info->errorCount++; break; case StmtVarDef: /* e.g. minimum, maximum */ @@ -829,9 +828,7 @@ HandleKeycodesFile(XkbFile * file, break; case StmtIndicatorNameDef: /* e.g. indicator 1 = "Caps Lock"; */ if (!HandleIndicatorNameDef((IndicatorNameDef *) stmt, info)) - { info->errorCount++; - } break; case StmtInterpDef: case StmtVModDef: @@ -870,13 +867,13 @@ HandleKeycodesFile(XkbFile * file, * @return true on success, false otherwise. */ bool -CompileKeycodes(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) +CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) { KeyNamesInfo info; /* contains all the info after parsing */ InitKeyNamesInfo(&info); - HandleKeycodesFile(file, xkb, merge, &info); + HandleKeycodesFile(file, keymap, merge, &info); /* all the keys are now stored in info */ @@ -884,20 +881,20 @@ CompileKeycodes(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) goto err_info; if (info.explicitMin > 0) /* if "minimum" statement was present */ - xkb->min_key_code = info.explicitMin; + keymap->min_key_code = info.explicitMin; else - xkb->min_key_code = info.computedMin; + keymap->min_key_code = info.computedMin; if (info.explicitMax > 0) /* if "maximum" statement was present */ - xkb->max_key_code = info.explicitMax; + keymap->max_key_code = info.explicitMax; else - xkb->max_key_code = info.computedMax; + keymap->max_key_code = info.computedMax; - if (XkbcAllocNames(xkb, XkbKeyNamesMask | XkbIndicatorNamesMask, 0) + if (XkbcAllocNames(keymap, XkbKeyNamesMask | XkbIndicatorNamesMask, 0) == Success) { uint64_t i; for (i = info.computedMin; i <= info.computedMax; i++) - LongToKeyName(info.names[i], xkb->names->keys[i].name); + LongToKeyName(info.names[i], keymap->names->keys[i].name); } else { WSGO("Cannot create struct xkb_names in CompileKeycodes\n"); goto err_info; @@ -905,18 +902,18 @@ CompileKeycodes(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) if (info.leds) { IndicatorNameInfo *ii; - if (XkbcAllocIndicatorMaps(xkb) != Success) { + if (XkbcAllocIndicatorMaps(keymap) != Success) { WSGO("Couldn't allocate IndicatorRec in CompileKeycodes\n"); ACTION("Physical indicators not set\n"); } for (ii = info.leds; ii; ii = (IndicatorNameInfo *)ii->defs.next) { - free(UNCONSTIFY(xkb->names->indicators[ii->ndx - 1])); - xkb->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name); + free(UNCONSTIFY(keymap->names->indicators[ii->ndx - 1])); + keymap->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name); } } - ApplyAliases(xkb, &info.aliases); + ApplyAliases(keymap, &info.aliases); ClearKeyNamesInfo(&info); return true; diff --git a/src/xkbcomp/keymap.c b/src/xkbcomp/keymap.c index 2d40bb4..f6e77ea 100644 --- a/src/xkbcomp/keymap.c +++ b/src/xkbcomp/keymap.c @@ -41,7 +41,7 @@ CompileKeymap(struct xkb_context *context, XkbFile *file) unsigned mainType; const char *mainName; LEDInfo *unbound = NULL, *next; - struct xkb_keymap *xkb = XkbcAllocKeyboard(context); + struct xkb_keymap *keymap = XkbcAllocKeyboard(context); struct { XkbFile *keycodes; XkbFile *types; @@ -49,7 +49,7 @@ CompileKeymap(struct xkb_context *context, XkbFile *file) XkbFile *symbols; } sections; - if (!xkb) + if (!keymap) return NULL; memset(§ions, 0, sizeof(sections)); @@ -149,43 +149,43 @@ CompileKeymap(struct xkb_context *context, XkbFile *file) /* compile the sections we have in the file one-by-one, or fail. */ if (sections.keycodes == NULL || - !CompileKeycodes(sections.keycodes, xkb, MergeOverride)) + !CompileKeycodes(sections.keycodes, keymap, MergeOverride)) { ERROR("Failed to compile keycodes\n"); goto err; } if (sections.types == NULL || - !CompileKeyTypes(sections.types, xkb, MergeOverride)) + !CompileKeyTypes(sections.types, keymap, MergeOverride)) { ERROR("Failed to compile key types\n"); goto err; } if (sections.compat == NULL || - !CompileCompatMap(sections.compat, xkb, MergeOverride, &unbound)) + !CompileCompatMap(sections.compat, keymap, MergeOverride, &unbound)) { ERROR("Failed to compile compat map\n"); goto err; } if (sections.symbols == NULL || - !CompileSymbols(sections.symbols, xkb, MergeOverride)) + !CompileSymbols(sections.symbols, keymap, MergeOverride)) { ERROR("Failed to compile symbols\n"); goto err; } - ok = BindIndicators(xkb, true, unbound, NULL); + ok = BindIndicators(keymap, true, unbound, NULL); if (!ok) goto err; - ok = UpdateModifiersFromCompat(xkb); + ok = UpdateModifiersFromCompat(keymap); if (!ok) goto err; - return xkb; + return keymap; err: ACTION("Failed to compile keymap\n"); - xkb_map_unref(xkb); + xkb_map_unref(keymap); while (unbound) { next = (LEDInfo *) unbound->defs.next; free(unbound); diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c index 3344e22..f5d50dd 100644 --- a/src/xkbcomp/keytypes.c +++ b/src/xkbcomp/keytypes.c @@ -101,7 +101,8 @@ static xkb_atom_t tok_KEYPAD; /***====================================================================***/ static void -InitKeyTypesInfo(KeyTypesInfo * info, struct xkb_keymap * xkb, KeyTypesInfo * from) +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"); @@ -126,7 +127,7 @@ InitKeyTypesInfo(KeyTypesInfo * info, struct xkb_keymap * xkb, KeyTypesInfo * fr info->dflt.szNames = 0; info->dflt.lvlNames = NULL; info->dflt.preserve = NULL; - InitVModInfo(&info->vmods, xkb); + InitVModInfo(&info->vmods, keymap); if (from != NULL) { info->dflt = from->dflt; @@ -241,7 +242,7 @@ ReportTypeBadWidth(const char *type, int has, int needs) } static bool -AddKeyType(struct xkb_keymap * xkb, KeyTypesInfo * info, KeyTypeInfo * new) +AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new) { KeyTypeInfo *old; @@ -326,8 +327,8 @@ AddKeyType(struct xkb_keymap * xkb, KeyTypesInfo * info, KeyTypeInfo * new) /***====================================================================***/ static void -MergeIncludedKeyTypes(KeyTypesInfo * into, - KeyTypesInfo * from, unsigned merge, struct xkb_keymap * xkb) +MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from, + unsigned merge, struct xkb_keymap *keymap) { KeyTypeInfo *type; @@ -345,18 +346,18 @@ MergeIncludedKeyTypes(KeyTypesInfo * into, { if (merge != MergeDefault) type->defs.merge = merge; - if (!AddKeyType(xkb, into, type)) + if (!AddKeyType(keymap, into, type)) into->errorCount++; } into->stdPresent |= from->stdPresent; } -typedef void (*FileHandler) (XkbFile *file, struct xkb_keymap *xkb, +typedef void (*FileHandler) (XkbFile *file, struct xkb_keymap *keymap, unsigned merge, KeyTypesInfo *included); static bool -HandleIncludeKeyTypes(IncludeStmt * stmt, - struct xkb_keymap * xkb, KeyTypesInfo * info, FileHandler hndlr) +HandleIncludeKeyTypes(IncludeStmt *stmt, struct xkb_keymap *keymap, + KeyTypesInfo *info, FileHandler hndlr) { unsigned newMerge; XkbFile *rtrn; @@ -370,14 +371,14 @@ HandleIncludeKeyTypes(IncludeStmt * stmt, included = *info; memset(info, 0, sizeof(KeyTypesInfo)); } - else if (ProcessIncludeFile(xkb->context, stmt, XkmTypesIndex, &rtrn, + else if (ProcessIncludeFile(keymap->context, stmt, XkmTypesIndex, &rtrn, &newMerge)) { - InitKeyTypesInfo(&included, xkb, info); + InitKeyTypesInfo(&included, keymap, info); included.fileID = included.dflt.defs.fileID = rtrn->id; included.dflt.defs.merge = newMerge; - (*hndlr) (rtrn, xkb, newMerge, &included); + (*hndlr) (rtrn, keymap, newMerge, &included); if (stmt->stmt != NULL) { free(included.name); @@ -402,17 +403,17 @@ HandleIncludeKeyTypes(IncludeStmt * stmt, if ((next->file == NULL) && (next->map == NULL)) { haveSelf = true; - MergeIncludedKeyTypes(&included, info, next->merge, xkb); + MergeIncludedKeyTypes(&included, info, next->merge, keymap); FreeKeyTypesInfo(info); } - else if (ProcessIncludeFile(xkb->context, next, XkmTypesIndex, + else if (ProcessIncludeFile(keymap->context, next, XkmTypesIndex, &rtrn, &op)) { - InitKeyTypesInfo(&next_incl, xkb, &included); + InitKeyTypesInfo(&next_incl, keymap, &included); next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id; next_incl.dflt.defs.merge = op; - (*hndlr) (rtrn, xkb, op, &next_incl); - MergeIncludedKeyTypes(&included, &next_incl, op, xkb); + (*hndlr) (rtrn, keymap, op, &next_incl); + MergeIncludedKeyTypes(&included, &next_incl, op, keymap); FreeKeyTypesInfo(&next_incl); FreeXKBFile(rtrn); } @@ -428,7 +429,7 @@ HandleIncludeKeyTypes(IncludeStmt * stmt, *info = included; else { - MergeIncludedKeyTypes(info, &included, newMerge, xkb); + MergeIncludedKeyTypes(info, &included, newMerge, keymap); FreeKeyTypesInfo(&included); } return (info->errorCount == 0); @@ -504,8 +505,8 @@ NextMapEntry(KeyTypeInfo * type) } static bool -AddPreserve(struct xkb_keymap * xkb, - KeyTypeInfo * type, PreserveInfo * new, bool clobber, bool report) +AddPreserve(struct xkb_keymap *keymap, KeyTypeInfo *type, + PreserveInfo *new, bool clobber, bool report) { PreserveInfo *old; @@ -524,7 +525,7 @@ AddPreserve(struct xkb_keymap * xkb, if (warningLevel > 9) { WARN("Identical definitions for preserve[%s] in %s\n", - PreserveIndexTxt(xkb, old), TypeTxt(type)); + PreserveIndexTxt(keymap, old), TypeTxt(type)); ACTION("Ignored\n"); } return true; @@ -533,17 +534,17 @@ AddPreserve(struct xkb_keymap * xkb, { const char *str; WARN("Multiple definitions for preserve[%s] in %s\n", - PreserveIndexTxt(xkb, old), TypeTxt(type)); + PreserveIndexTxt(keymap, old), TypeTxt(type)); if (clobber) - str = PreserveTxt(xkb, new); + str = PreserveTxt(keymap, new); else - str = PreserveTxt(xkb, old); + str = PreserveTxt(keymap, old); ACTION("Using %s, ", str); if (clobber) - str = PreserveTxt(xkb, old); + str = PreserveTxt(keymap, old); else - str = PreserveTxt(xkb, new); + str = PreserveTxt(keymap, new); INFO("ignoring %s\n", str); } if (clobber) @@ -557,7 +558,7 @@ AddPreserve(struct xkb_keymap * xkb, if (!old) { WSGO("Couldn't allocate preserve in %s\n", TypeTxt(type)); - ACTION("Preserve[%s] lost\n", PreserveIndexTxt(xkb, new)); + ACTION("Preserve[%s] lost\n", PreserveIndexTxt(keymap, new)); return false; } *old = *new; @@ -576,9 +577,8 @@ AddPreserve(struct xkb_keymap * xkb, * @param report true if a warning is to be printed on. */ static bool -AddMapEntry(struct xkb_keymap * xkb, - KeyTypeInfo * type, - struct xkb_kt_map_entry * new, bool clobber, bool report) +AddMapEntry(struct xkb_keymap *keymap, KeyTypeInfo *type, + struct xkb_kt_map_entry *new, bool clobber, bool report) { struct xkb_kt_map_entry * old; @@ -599,13 +599,13 @@ AddMapEntry(struct xkb_keymap * xkb, ignore = new->level + 1; } WARN("Multiple map entries for %s in %s\n", - MapEntryTxt(xkb, new), TypeTxt(type)); + MapEntryTxt(keymap, new), TypeTxt(type)); ACTION("Using %d, ignoring %d\n", use, ignore); } else if (warningLevel > 9) { WARN("Multiple occurences of map[%s]= %d in %s\n", - MapEntryTxt(xkb, new), new->level + 1, TypeTxt(type)); + MapEntryTxt(keymap, new), new->level + 1, TypeTxt(type)); ACTION("Ignored\n"); return true; } @@ -629,15 +629,15 @@ AddMapEntry(struct xkb_keymap * xkb, } static bool -SetMapEntry(KeyTypeInfo * type, - struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value) +SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, + ExprDef *value) { ExprResult rtrn; struct xkb_kt_map_entry entry; if (arrayNdx == NULL) return ReportTypeShouldBeArray(type, "map entry"); - if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb)) + if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap)) return ReportTypeBadType(type, "map entry", "modifier mask"); entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */ entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */ @@ -648,10 +648,10 @@ SetMapEntry(KeyTypeInfo * type, { WARN("Map entry for unused modifiers in %s\n", TypeTxt(type)); ACTION("Using %s instead of ", - XkbcVModMaskText(xkb, + XkbcVModMaskText(keymap, entry.mods.real_mods & type->mask, entry.mods.vmods & type->vmask)); - INFO("%s\n", MapEntryTxt(xkb, &entry)); + INFO("%s\n", MapEntryTxt(keymap, &entry)); } entry.mods.real_mods &= type->mask; entry.mods.vmods &= type->vmask; @@ -663,19 +663,19 @@ SetMapEntry(KeyTypeInfo * type, return false; } entry.level = rtrn.ival - 1; - return AddMapEntry(xkb, type, &entry, true, true); + return AddMapEntry(keymap, type, &entry, true, true); } static bool -SetPreserve(KeyTypeInfo * type, - struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value) +SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, + ExprDef *arrayNdx, ExprDef *value) { ExprResult rtrn; PreserveInfo new; if (arrayNdx == NULL) return ReportTypeShouldBeArray(type, "preserve entry"); - if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb)) + if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap)) return ReportTypeBadType(type, "preserve entry", "modifier mask"); new.defs = type->defs; new.defs.next = NULL; @@ -687,18 +687,18 @@ SetPreserve(KeyTypeInfo * type, { WARN("Preserve for modifiers not used by the %s type\n", TypeTxt(type)); - ACTION("Index %s converted to ", PreserveIndexTxt(xkb, &new)); + ACTION("Index %s converted to ", PreserveIndexTxt(keymap, &new)); } new.indexMods &= type->mask; new.indexVMods &= type->vmask; if (warningLevel > 0) - INFO("%s\n", PreserveIndexTxt(xkb, &new)); + INFO("%s\n", PreserveIndexTxt(keymap, &new)); } - if (!ExprResolveVModMask(value, &rtrn, xkb)) + if (!ExprResolveVModMask(value, &rtrn, keymap)) { ERROR("Preserve value in a key type is not a modifier mask\n"); ACTION("Ignoring preserve[%s] in type %s\n", - PreserveIndexTxt(xkb, &new), TypeTxt(type)); + PreserveIndexTxt(keymap, &new), TypeTxt(type)); return false; } new.preMods = rtrn.uval & 0xff; @@ -709,24 +709,23 @@ SetPreserve(KeyTypeInfo * type, if (warningLevel > 0) { WARN("Illegal value for preserve[%s] in type %s\n", - PreserveTxt(xkb, &new), TypeTxt(type)); - ACTION("Converted %s to ", PreserveIndexTxt(xkb, &new)); + PreserveTxt(keymap, &new), TypeTxt(type)); + ACTION("Converted %s to ", PreserveIndexTxt(keymap, &new)); } new.preMods &= new.indexMods; new.preVMods &= new.indexVMods; if (warningLevel > 0) { - INFO("%s\n", PreserveIndexTxt(xkb, &new)); + INFO("%s\n", PreserveIndexTxt(keymap, &new)); } } - return AddPreserve(xkb, type, &new, true, true); + return AddPreserve(keymap, type, &new, true, true); } /***====================================================================***/ static bool -AddLevelName(KeyTypeInfo * type, - unsigned level, xkb_atom_t name, bool clobber) +AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber) { if ((type->lvlNames == NULL) || (type->szNames <= level)) { @@ -807,10 +806,9 @@ SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value) * @param field The field to parse (e.g. modifiers, map, level_name) */ static bool -SetKeyTypeField(KeyTypeInfo * type, - struct xkb_keymap * xkb, - char *field, - ExprDef * arrayNdx, ExprDef * value, KeyTypesInfo * info) +SetKeyTypeField(KeyTypeInfo *type, struct xkb_keymap *keymap, + char *field, ExprDef *arrayNdx, ExprDef *value, + KeyTypesInfo *info) { ExprResult tmp; @@ -823,7 +821,7 @@ SetKeyTypeField(KeyTypeInfo * type, ACTION("Illegal array subscript ignored\n"); } /* get modifier mask for current type */ - if (!ExprResolveVModMask(value, &tmp, xkb)) + if (!ExprResolveVModMask(value, &tmp, keymap)) { ERROR("Key type mask field must be a modifier mask\n"); ACTION("Key type definition ignored\n"); @@ -835,8 +833,8 @@ SetKeyTypeField(KeyTypeInfo * type, { WARN("Multiple modifier mask definitions for key type %s\n", XkbcAtomText(type->name)); - ACTION("Using %s, ", TypeMaskTxt(type, xkb)); - INFO("ignoring %s\n", XkbcVModMaskText(xkb, mods, vmods)); + ACTION("Using %s, ", TypeMaskTxt(type, keymap)); + INFO("ignoring %s\n", XkbcVModMaskText(keymap, mods, vmods)); return false; } type->mask = mods; @@ -847,12 +845,12 @@ SetKeyTypeField(KeyTypeInfo * type, else if (strcasecmp(field, "map") == 0) { type->defs.defined |= _KT_Map; - return SetMapEntry(type, xkb, arrayNdx, value); + return SetMapEntry(type, keymap, arrayNdx, value); } else if (strcasecmp(field, "preserve") == 0) { type->defs.defined |= _KT_Preserve; - return SetPreserve(type, xkb, arrayNdx, value); + return SetPreserve(type, keymap, arrayNdx, value); } else if ((strcasecmp(field, "levelname") == 0) || (strcasecmp(field, "level_name") == 0)) @@ -866,7 +864,7 @@ SetKeyTypeField(KeyTypeInfo * type, } static bool -HandleKeyTypeVar(VarDef * stmt, struct xkb_keymap * xkb, KeyTypesInfo * info) +HandleKeyTypeVar(VarDef *stmt, struct xkb_keymap *keymap, KeyTypesInfo *info) { ExprResult elem, field; ExprDef *arrayNdx; @@ -874,7 +872,7 @@ HandleKeyTypeVar(VarDef * stmt, struct xkb_keymap * xkb, KeyTypesInfo * info) if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx)) return false; /* internal error, already reported */ if (elem.str && (strcasecmp(elem.str, "type") == 0)) - return SetKeyTypeField(&info->dflt, xkb, field.str, arrayNdx, + return SetKeyTypeField(&info->dflt, keymap, field.str, arrayNdx, stmt->value, info); if (elem.str != NULL) { @@ -891,8 +889,8 @@ HandleKeyTypeVar(VarDef * stmt, struct xkb_keymap * xkb, KeyTypesInfo * info) } static int -HandleKeyTypeBody(VarDef * def, - struct xkb_keymap * xkb, KeyTypeInfo * type, KeyTypesInfo * info) +HandleKeyTypeBody(VarDef *def, struct xkb_keymap *keymap, + KeyTypeInfo *type, KeyTypesInfo *info) { int ok = 1; ExprResult tmp, field; @@ -902,13 +900,13 @@ HandleKeyTypeBody(VarDef * def, { if ((def->name) && (def->name->type == ExprFieldRef)) { - ok = HandleKeyTypeVar(def, xkb, info); + ok = HandleKeyTypeVar(def, keymap, info); continue; } ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx); if (ok) { - ok = SetKeyTypeField(type, xkb, field.str, arrayNdx, def->value, - info); + ok = SetKeyTypeField(type, keymap, field.str, arrayNdx, + def->value, info); free(field.str); } } @@ -920,8 +918,8 @@ HandleKeyTypeBody(VarDef * def, * */ static int -HandleKeyTypeDef(KeyTypeDef * def, - struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info) +HandleKeyTypeDef(KeyTypeDef *def, struct xkb_keymap *keymap, + unsigned merge, KeyTypesInfo *info) { unsigned int i; KeyTypeInfo type; @@ -945,7 +943,7 @@ HandleKeyTypeDef(KeyTypeDef * def, type.preserve = NULL; /* Parse the actual content. */ - if (!HandleKeyTypeBody(def->body, xkb, &type, info)) + if (!HandleKeyTypeBody(def->body, keymap, &type, info)) { info->errorCount++; return false; @@ -960,7 +958,7 @@ HandleKeyTypeDef(KeyTypeDef * def, if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) && ((dflt->mods.vmods & type.vmask) == dflt->mods.vmods)) { - AddMapEntry(xkb, &type, dflt, false, false); + AddMapEntry(keymap, &type, dflt, false, false); } } if (info->dflt.preserve) @@ -971,7 +969,7 @@ HandleKeyTypeDef(KeyTypeDef * def, if (((dflt->indexMods & type.mask) == dflt->indexMods) && ((dflt->indexVMods & type.vmask) == dflt->indexVMods)) { - AddPreserve(xkb, &type, dflt, false, false); + AddPreserve(keymap, &type, dflt, false, false); } dflt = (PreserveInfo *) dflt->defs.next; } @@ -984,7 +982,7 @@ HandleKeyTypeDef(KeyTypeDef * def, } } /* Now add the new keytype to the info struct */ - if (!AddKeyType(xkb, info, &type)) + if (!AddKeyType(keymap, info, &type)) { info->errorCount++; return false; @@ -1000,8 +998,8 @@ HandleKeyTypeDef(KeyTypeDef * def, * @param info Pointer to memory where the outcome will be stored. */ static void -HandleKeyTypesFile(XkbFile * file, - struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info) +HandleKeyTypesFile(XkbFile *file, struct xkb_keymap *keymap, + unsigned merge, KeyTypesInfo *info) { ParseCommon *stmt; @@ -1013,20 +1011,20 @@ HandleKeyTypesFile(XkbFile * file, switch (stmt->stmtType) { case StmtInclude: - if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, xkb, info, + if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, keymap, info, HandleKeyTypesFile)) info->errorCount++; break; case StmtKeyTypeDef: /* e.g. type "ONE_LEVEL" */ - if (!HandleKeyTypeDef((KeyTypeDef *) stmt, xkb, merge, info)) + if (!HandleKeyTypeDef((KeyTypeDef *) stmt, keymap, merge, info)) info->errorCount++; break; case StmtVarDef: - if (!HandleKeyTypeVar((VarDef *) stmt, xkb, info)) + if (!HandleKeyTypeVar((VarDef *) stmt, keymap, info)) info->errorCount++; break; case StmtVModDef: /* virtual_modifiers NumLock, ... */ - if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods)) + if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods)) info->errorCount++; break; case StmtKeyAliasDef: @@ -1062,7 +1060,8 @@ HandleKeyTypesFile(XkbFile * file, } static bool -CopyDefToKeyType(struct xkb_keymap * xkb, struct xkb_key_type * type, KeyTypeInfo * def) +CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type, + KeyTypeInfo *def) { unsigned int i; PreserveInfo *pre; @@ -1075,7 +1074,7 @@ CopyDefToKeyType(struct xkb_keymap * xkb, struct xkb_key_type * type, KeyTypeInf tmp.mods.real_mods = pre->indexMods; tmp.mods.vmods = pre->indexVMods; tmp.level = 0; - AddMapEntry(xkb, def, &tmp, false, false); + AddMapEntry(keymap, def, &tmp, false, false); match = FindMatchingMapEntry(def, pre->indexMods, pre->indexVMods); if (!match) { @@ -1131,21 +1130,21 @@ CopyDefToKeyType(struct xkb_keymap * xkb, struct xkb_key_type * type, KeyTypeInf def->nEntries = def->szEntries = 0; def->entries = NULL; - return XkbcComputeEffectiveMap(xkb, type, NULL); + return XkbcComputeEffectiveMap(keymap, type, NULL); } bool -CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge) +CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) { unsigned int i; struct xkb_key_type *type, *next; KeyTypesInfo info; KeyTypeInfo *def; - InitKeyTypesInfo(&info, xkb, NULL); + InitKeyTypesInfo(&info, keymap, NULL); info.fileID = file->id; - HandleKeyTypesFile(file, xkb, merge, &info); + HandleKeyTypesFile(file, keymap, merge, &info); if (info.errorCount != 0) goto err_info; @@ -1160,54 +1159,54 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge) if ((info.stdPresent & XkbAlphabeticMask) == 0) i++; - if (XkbcAllocClientMap(xkb, XkbKeyTypesMask, i) != Success) { + if (XkbcAllocClientMap(keymap, XkbKeyTypesMask, i) != Success) { WSGO("Couldn't allocate client map\n"); goto err_info; } - xkb->map->num_types = i; + keymap->map->num_types = i; if (XkbAllRequiredTypes & (~info.stdPresent)) { unsigned missing, keypadVMod; missing = XkbAllRequiredTypes & (~info.stdPresent); - keypadVMod = FindKeypadVMod(xkb); + keypadVMod = FindKeypadVMod(keymap); - if (XkbcInitCanonicalKeyTypes(xkb, missing, keypadVMod) != Success) { + if (XkbcInitCanonicalKeyTypes(keymap, missing, keypadVMod) != Success) { WSGO("Couldn't initialize canonical key types\n"); goto err_info; } if (missing & XkbOneLevelMask) - xkb->map->types[XkbOneLevelIndex].name = + keymap->map->types[XkbOneLevelIndex].name = XkbcAtomGetString(tok_ONE_LEVEL); if (missing & XkbTwoLevelMask) - xkb->map->types[XkbTwoLevelIndex].name = + keymap->map->types[XkbTwoLevelIndex].name = XkbcAtomGetString(tok_TWO_LEVEL); if (missing & XkbAlphabeticMask) - xkb->map->types[XkbAlphabeticIndex].name = + keymap->map->types[XkbAlphabeticIndex].name = XkbcAtomGetString(tok_ALPHABETIC); if (missing & XkbKeypadMask) - xkb->map->types[XkbKeypadIndex].name = + keymap->map->types[XkbKeypadIndex].name = XkbcAtomGetString(tok_KEYPAD); } - next = &xkb->map->types[XkbLastRequiredType + 1]; + next = &keymap->map->types[XkbLastRequiredType + 1]; for (i = 0, def = info.types; i < info.nTypes; i++) { if (def->name == tok_ONE_LEVEL) - type = &xkb->map->types[XkbOneLevelIndex]; + type = &keymap->map->types[XkbOneLevelIndex]; else if (def->name == tok_TWO_LEVEL) - type = &xkb->map->types[XkbTwoLevelIndex]; + type = &keymap->map->types[XkbTwoLevelIndex]; else if (def->name == tok_ALPHABETIC) - type = &xkb->map->types[XkbAlphabeticIndex]; + type = &keymap->map->types[XkbAlphabeticIndex]; else if (def->name == tok_KEYPAD) - type = &xkb->map->types[XkbKeypadIndex]; + type = &keymap->map->types[XkbKeypadIndex]; else type = next++; DeleteLevel1MapEntries(def); - if (!CopyDefToKeyType(xkb, type, def)) + if (!CopyDefToKeyType(keymap, type, def)) goto err_info; def = (KeyTypeInfo *)def->defs.next; diff --git a/src/xkbcomp/misc.c b/src/xkbcomp/misc.c index bdd7dc1..7e163fa 100644 --- a/src/xkbcomp/misc.c +++ b/src/xkbcomp/misc.c @@ -215,39 +215,39 @@ AddCommonInfo(CommonInfo * old, CommonInfo * new) /** * Find the key with the given name and return its keycode in kc_rtrn. * + * @param keymap The keymap to search in. * @param name The 4-letter name of the key as a long. * @param kc_rtrn Set to the keycode if the key was found, otherwise 0. * @param use_aliases true if the key aliases should be searched too. * @param create If true and the key is not found, it is added to the - * xkb->names at the first free keycode. + * keymap->names at the first free keycode. * @param start_from Keycode to start searching from. * * @return true if found, false otherwise. */ bool -FindNamedKey(struct xkb_keymap * xkb, - unsigned long name, - xkb_keycode_t *kc_rtrn, - bool use_aliases, bool create, xkb_keycode_t start_from) +FindNamedKey(struct xkb_keymap *keymap, unsigned long name, + xkb_keycode_t *kc_rtrn, bool use_aliases, bool create, + xkb_keycode_t start_from) { unsigned n; - if (start_from < xkb->min_key_code) + if (start_from < keymap->min_key_code) { - start_from = xkb->min_key_code; + start_from = keymap->min_key_code; } - else if (start_from > xkb->max_key_code) + else if (start_from > keymap->max_key_code) { return false; } *kc_rtrn = 0; /* some callers rely on this */ - if (xkb && xkb->names && xkb->names->keys) + if (keymap && keymap->names && keymap->names->keys) { - for (n = start_from; n <= xkb->max_key_code; n++) + for (n = start_from; n <= keymap->max_key_code; n++) { unsigned long tmp; - tmp = KeyNameToLong(xkb->names->keys[n].name); + tmp = KeyNameToLong(keymap->names->keys[n].name); if (tmp == name) { *kc_rtrn = n; @@ -257,15 +257,16 @@ FindNamedKey(struct xkb_keymap * xkb, if (use_aliases) { unsigned long new_name; - if (FindKeyNameForAlias(xkb, name, &new_name)) - return FindNamedKey(xkb, new_name, kc_rtrn, false, create, 0); + if (FindKeyNameForAlias(keymap, name, &new_name)) + return FindNamedKey(keymap, new_name, kc_rtrn, false, + create, 0); } } if (create) { - if ((!xkb->names) || (!xkb->names->keys)) + if ((!keymap->names) || (!keymap->names->keys)) { - if (XkbcAllocNames(xkb, XkbKeyNamesMask, 0) != Success) + if (XkbcAllocNames(keymap, XkbKeyNamesMask, 0) != Success) { if (warningLevel > 0) { @@ -277,13 +278,13 @@ FindNamedKey(struct xkb_keymap * xkb, } } /* Find first unused keycode and store our key here */ - for (n = xkb->min_key_code; n <= xkb->max_key_code; n++) + for (n = keymap->min_key_code; n <= keymap->max_key_code; n++) { - if (xkb->names->keys[n].name[0] == '\0') + if (keymap->names->keys[n].name[0] == '\0') { char buf[XkbKeyNameLength + 1]; LongToKeyName(name, buf); - memcpy(xkb->names->keys[n].name, buf, XkbKeyNameLength); + memcpy(keymap->names->keys[n].name, buf, XkbKeyNameLength); *kc_rtrn = n; return true; } @@ -293,19 +294,19 @@ FindNamedKey(struct xkb_keymap * xkb, } bool -FindKeyNameForAlias(struct xkb_keymap * xkb, unsigned long lname, +FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname, unsigned long *real_name) { unsigned int i; char name[XkbKeyNameLength + 1]; - if (xkb && xkb->names && xkb->names->key_aliases) + if (keymap && keymap->names && keymap->names->key_aliases) { struct xkb_key_alias * a; - a = xkb->names->key_aliases; + a = keymap->names->key_aliases; LongToKeyName(lname, name); name[XkbKeyNameLength] = '\0'; - for (i = 0; i < xkb->names->num_key_aliases; i++, a++) + for (i = 0; i < keymap->names->num_key_aliases; i++, a++) { if (strncmp(name, a->alias, XkbKeyNameLength) == 0) { diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c index 86a2cb0..51bdc36 100644 --- a/src/xkbcomp/symbols.c +++ b/src/xkbcomp/symbols.c @@ -284,7 +284,7 @@ typedef struct _SymbolsInfo } SymbolsInfo; static void -InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap * xkb) +InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap) { int i; @@ -301,7 +301,7 @@ InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap * xkb) for (i = 0; i < XkbNumKbdGroups; i++) info->groupNames[i] = XKB_ATOM_NONE; InitKeyInfo(&info->dflt); - InitVModInfo(&info->vmods, xkb); + InitVModInfo(&info->vmods, keymap); info->action = NULL; info->aliases = NULL; } @@ -708,7 +708,7 @@ MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from) } static bool -AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_keymap * xkb) +AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap) { unsigned int i; unsigned long real_name; @@ -718,7 +718,7 @@ AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_keymap * xkb) if (info->keys[i].name == key->name) return MergeKeys(info, &info->keys[i], key); } - if (FindKeyNameForAlias(xkb, key->name, &real_name)) + if (FindKeyNameForAlias(keymap, key->name, &real_name)) { for (i = 0; i < info->nKeys; i++) { @@ -819,8 +819,8 @@ AddModMapEntry(SymbolsInfo * info, ModMapEntry * new) /***====================================================================***/ static void -MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from, - unsigned merge, struct xkb_keymap * xkb) +MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from, + unsigned merge, struct xkb_keymap *keymap) { unsigned int i; KeyInfo *key; @@ -848,7 +848,7 @@ MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from, { if (merge != MergeDefault) key->defs.merge = merge; - if (!AddKeySymbols(into, key, xkb)) + if (!AddKeySymbols(into, key, keymap)) into->errorCount++; } if (from->modMap != NULL) @@ -869,12 +869,12 @@ MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from, into->errorCount++; } -typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *xkb, +typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap, unsigned merge, SymbolsInfo *included); static bool -HandleIncludeSymbols(IncludeStmt * stmt, - struct xkb_keymap * xkb, SymbolsInfo * info, FileHandler hndlr) +HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap, + SymbolsInfo *info, FileHandler hndlr) { unsigned newMerge; XkbFile *rtrn; @@ -888,10 +888,10 @@ HandleIncludeSymbols(IncludeStmt * stmt, included = *info; memset(info, 0, sizeof(SymbolsInfo)); } - else if (ProcessIncludeFile(xkb->context, stmt, XkmSymbolsIndex, &rtrn, - &newMerge)) + else if (ProcessIncludeFile(keymap->context, stmt, XkmSymbolsIndex, + &rtrn, &newMerge)) { - InitSymbolsInfo(&included, xkb); + InitSymbolsInfo(&included, keymap); included.fileID = included.dflt.defs.fileID = rtrn->id; included.merge = included.dflt.defs.merge = MergeOverride; if (stmt->modifier) @@ -902,7 +902,7 @@ HandleIncludeSymbols(IncludeStmt * stmt, { included.explicit_group = info->explicit_group; } - (*hndlr) (rtrn, xkb, MergeOverride, &included); + (*hndlr) (rtrn, keymap, MergeOverride, &included); if (stmt->stmt != NULL) { free(included.name); @@ -927,13 +927,13 @@ HandleIncludeSymbols(IncludeStmt * stmt, if ((next->file == NULL) && (next->map == NULL)) { haveSelf = true; - MergeIncludedSymbols(&included, info, next->merge, xkb); + MergeIncludedSymbols(&included, info, next->merge, keymap); FreeSymbolsInfo(info); } - else if (ProcessIncludeFile(xkb->context, next, XkmSymbolsIndex, - &rtrn, &op)) + else if (ProcessIncludeFile(keymap->context, next, + XkmSymbolsIndex, &rtrn, &op)) { - InitSymbolsInfo(&next_incl, xkb); + InitSymbolsInfo(&next_incl, keymap); next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id; next_incl.merge = next_incl.dflt.defs.merge = MergeOverride; if (next->modifier) @@ -944,8 +944,8 @@ HandleIncludeSymbols(IncludeStmt * stmt, { next_incl.explicit_group = info->explicit_group; } - (*hndlr) (rtrn, xkb, MergeOverride, &next_incl); - MergeIncludedSymbols(&included, &next_incl, op, xkb); + (*hndlr) (rtrn, keymap, MergeOverride, &next_incl); + MergeIncludedSymbols(&included, &next_incl, op, keymap); FreeSymbolsInfo(&next_incl); FreeXKBFile(rtrn); } @@ -965,7 +965,7 @@ HandleIncludeSymbols(IncludeStmt * stmt, *info = included; else { - MergeIncludedSymbols(info, &included, newMerge, xkb); + MergeIncludedSymbols(info, &included, newMerge, keymap); FreeSymbolsInfo(&included); } return (info->errorCount == 0); @@ -1020,9 +1020,8 @@ GetGroupIndex(KeyInfo * key, } static bool -AddSymbolsToKey(KeyInfo * key, - struct xkb_keymap * xkb, - ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info) +AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap, + ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info) { unsigned ndx, nSyms, nLevels; unsigned int i; @@ -1086,9 +1085,8 @@ AddSymbolsToKey(KeyInfo * key, } static bool -AddActionsToKey(KeyInfo * key, - struct xkb_keymap * xkb, - ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info) +AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx, + ExprDef *value, SymbolsInfo *info) { unsigned int i; unsigned ndx, nActs; @@ -1139,7 +1137,7 @@ AddActionsToKey(KeyInfo * key, act = value->value.child; for (i = 0; i < nActs; i++, toAct++) { - if (!HandleActionDef(act, xkb, toAct, info->action)) + if (!HandleActionDef(act, keymap, toAct, info->action)) { ERROR("Illegal action definition for %s\n", longText(key->name)); @@ -1173,10 +1171,8 @@ static const LookupEntry repeatEntries[] = { }; static bool -SetSymbolsField(KeyInfo * key, - struct xkb_keymap * xkb, - char *field, - ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info) +SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, + ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info) { bool ok = true; ExprResult tmp; @@ -1211,14 +1207,14 @@ SetSymbolsField(KeyInfo * key, free(tmp.str); } else if (strcasecmp(field, "symbols") == 0) - return AddSymbolsToKey(key, xkb, arrayNdx, value, info); + return AddSymbolsToKey(key, keymap, arrayNdx, value, info); else if (strcasecmp(field, "actions") == 0) - return AddActionsToKey(key, xkb, arrayNdx, value, info); + return AddActionsToKey(key, keymap, arrayNdx, value, info); else if ((strcasecmp(field, "vmods") == 0) || (strcasecmp(field, "virtualmods") == 0) || (strcasecmp(field, "virtualmodifiers") == 0)) { - ok = ExprResolveVModMask(value, &tmp, xkb); + ok = ExprResolveVModMask(value, &tmp, keymap); if (ok) { key->vmodmap = (tmp.uval >> 8); @@ -1358,7 +1354,7 @@ SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value) } static int -HandleSymbolsVar(VarDef * stmt, struct xkb_keymap * xkb, SymbolsInfo * info) +HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) { ExprResult elem, field, tmp; ExprDef *arrayNdx; @@ -1368,7 +1364,7 @@ HandleSymbolsVar(VarDef * stmt, struct xkb_keymap * xkb, SymbolsInfo * info) return 0; /* internal error, already reported */ if (elem.str && (strcasecmp(elem.str, "key") == 0)) { - ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx, + ret = SetSymbolsField(&info->dflt, keymap, field.str, arrayNdx, stmt->value, info); } else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) || @@ -1436,8 +1432,8 @@ HandleSymbolsVar(VarDef * stmt, struct xkb_keymap * xkb, SymbolsInfo * info) ret = false; } else { - ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value, - &info->action); + ret = SetActionField(keymap, elem.str, field.str, arrayNdx, + stmt->value, &info->action); } free(elem.str); @@ -1446,8 +1442,8 @@ HandleSymbolsVar(VarDef * stmt, struct xkb_keymap * xkb, SymbolsInfo * info) } static bool -HandleSymbolsBody(VarDef * def, - struct xkb_keymap * xkb, KeyInfo * key, SymbolsInfo * info) +HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key, + SymbolsInfo *info) { bool ok = true; ExprResult tmp, field; @@ -1457,7 +1453,7 @@ HandleSymbolsBody(VarDef * def, { if ((def->name) && (def->name->type == ExprFieldRef)) { - ok = HandleSymbolsVar(def, xkb, info); + ok = HandleSymbolsVar(def, keymap, info); continue; } else @@ -1476,7 +1472,7 @@ HandleSymbolsBody(VarDef * def, ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx); } if (ok) - ok = SetSymbolsField(key, xkb, field.str, arrayNdx, + ok = SetSymbolsField(key, keymap, field.str, arrayNdx, def->value, info); free(field.str); } @@ -1485,7 +1481,7 @@ HandleSymbolsBody(VarDef * def, } static bool -SetExplicitGroup(SymbolsInfo * info, KeyInfo * key) +SetExplicitGroup(SymbolsInfo *info, KeyInfo *key) { unsigned group = info->explicit_group; @@ -1529,8 +1525,8 @@ SetExplicitGroup(SymbolsInfo * info, KeyInfo * key) } static int -HandleSymbolsDef(SymbolsDef * stmt, - struct xkb_keymap *xkb, SymbolsInfo *info) +HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap, + SymbolsInfo *info) { KeyInfo key; @@ -1538,7 +1534,7 @@ HandleSymbolsDef(SymbolsDef * stmt, CopyKeyInfo(&info->dflt, &key, false); key.defs.merge = stmt->merge; key.name = KeyNameToLong(stmt->keyName); - if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info)) + if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info)) { info->errorCount++; return false; @@ -1550,7 +1546,7 @@ HandleSymbolsDef(SymbolsDef * stmt, return false; } - if (!AddKeySymbols(info, &key, xkb)) + if (!AddKeySymbols(info, &key, keymap)) { info->errorCount++; return false; @@ -1559,8 +1555,7 @@ HandleSymbolsDef(SymbolsDef * stmt, } static bool -HandleModMapDef(ModMapDef * def, - struct xkb_keymap * xkb, SymbolsInfo * info) +HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info) { ExprDef *key; ModMapEntry tmp; @@ -1602,8 +1597,8 @@ HandleModMapDef(ModMapDef * def, } static void -HandleSymbolsFile(XkbFile * file, - struct xkb_keymap * xkb, unsigned merge, SymbolsInfo * info) +HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap, + unsigned merge, SymbolsInfo *info) { ParseCommon *stmt; @@ -1615,20 +1610,20 @@ HandleSymbolsFile(XkbFile * file, switch (stmt->stmtType) { case StmtInclude: - if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info, + if (!HandleIncludeSymbols((IncludeStmt *) stmt, keymap, info, HandleSymbolsFile)) info->errorCount++; break; case StmtSymbolsDef: - if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, info)) + if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info)) info->errorCount++; break; case StmtVarDef: - if (!HandleSymbolsVar((VarDef *) stmt, xkb, info)) + if (!HandleSymbolsVar((VarDef *) stmt, keymap, info)) info->errorCount++; break; case StmtVModDef: - if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods)) + if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods)) info->errorCount++; break; case StmtInterpDef: @@ -1642,7 +1637,7 @@ HandleSymbolsFile(XkbFile * file, info->errorCount++; break; case StmtModMapDef: - if (!HandleModMapDef((ModMapDef *) stmt, xkb, info)) + if (!HandleModMapDef((ModMapDef *) stmt, keymap, info)) info->errorCount++; break; default: @@ -1663,19 +1658,21 @@ HandleSymbolsFile(XkbFile * file, } static bool -FindKeyForSymbol(struct xkb_keymap * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn) +FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym, + xkb_keycode_t *kc_rtrn) { xkb_keycode_t key; unsigned int group, level; - for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) + for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) { - for (group = 0; group < XkbKeyNumGroups(xkb, key); group++) + for (group = 0; group < XkbKeyNumGroups(keymap, key); group++) { - for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++) + for (level = 0; level < XkbKeyGroupWidth(keymap, key, group); + level++) { - if (XkbKeyNumSyms(xkb, key, group, level) != 1 || - (XkbKeySymEntry(xkb, key, group, level))[0] != sym) + if (XkbKeyNumSyms(keymap, key, group, level) != 1 || + (XkbKeySymEntry(keymap, key, group, level))[0] != sym) continue; *kc_rtrn = key; return true; @@ -1695,16 +1692,16 @@ FindKeyForSymbol(struct xkb_keymap * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rt * @return true if found, false otherwise. */ static bool -FindNamedType(struct xkb_keymap * xkb, xkb_atom_t atom, unsigned *type_rtrn) +FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn) { unsigned n; const char *name = XkbcAtomText(atom); - if (xkb && xkb->map && xkb->map->types) + if (keymap && keymap->map && keymap->map->types) { - for (n = 0; n < xkb->map->num_types; n++) + for (n = 0; n < keymap->map->num_types; n++) { - if (strcmp(xkb->map->types[n].name, name) == 0) + if (strcmp(keymap->map->types[n].name, name) == 0) { *type_rtrn = n; return true; @@ -1931,7 +1928,7 @@ PrepareKeyDef(KeyInfo * key) * This function recurses. */ static bool -CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) +CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) { unsigned int i; xkb_keycode_t kc; @@ -1946,8 +1943,8 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) useAlias = (start_from == 0); /* get the keycode for the key. */ - if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb), - start_from)) + if (!FindNamedKey(keymap, key->name, &kc, useAlias, + CreateKeyNames(keymap), start_from)) { if ((start_from == 0) && (warningLevel >= 5)) { @@ -1988,10 +1985,10 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) } } } - if (FindNamedType(xkb, key->types[i], &types[i])) + if (FindNamedType(keymap, key->types[i], &types[i])) { if (!autoType || key->numLevels[i] > 2) - xkb->server->explicit[kc] |= (1 << i); + keymap->server->explicit[kc] |= (1 << i); } else { @@ -2005,7 +2002,7 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) types[i] = XkbTwoLevelIndex; } /* if the type specifies fewer levels than the key has, shrink the key */ - type = &xkb->map->types[types[i]]; + type = &keymap->map->types[types[i]]; if (type->num_levels < key->numLevels[i]) { if (warningLevel > 0) @@ -2024,7 +2021,7 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) sizeSyms += key->sizeSyms[i]; } - if (!XkbcResizeKeySyms(xkb, kc, sizeSyms)) + if (!XkbcResizeKeySyms(keymap, kc, sizeSyms)) { WSGO("Could not enlarge symbols for %s (keycode %d)\n", longText(key->name), kc); @@ -2032,27 +2029,28 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) } if (haveActions) { - outActs = XkbcResizeKeyActions(xkb, kc, width * nGroups); + outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups); if (outActs == NULL) { WSGO("Could not enlarge actions for %s (key %d)\n", longText(key->name), kc); return false; } - xkb->server->explicit[kc] |= XkbExplicitInterpretMask; + keymap->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; - xkb->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width, int); - xkb->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width, - unsigned int); + i = keymap->map->key_sym_map[kc].group_info; + + keymap->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups); + keymap->map->key_sym_map[kc].width = width; + keymap->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width, + int); + keymap->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width, + unsigned int); for (i = 0; i < nGroups; i++) { /* assign kt_index[i] to the index of the type in map->types. @@ -2063,7 +2061,7 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) * FIXME: There should be a better fix for this. */ if (key->numLevels[i]) - xkb->map->key_sym_map[kc].kt_index[i] = types[i]; + keymap->map->key_sym_map[kc].kt_index[i] = types[i]; if (key->sizeSyms[i] != 0) { /* fill key to "width" symbols*/ @@ -2071,21 +2069,21 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) { if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp]) { - memcpy(&xkb->map->key_sym_map[kc].syms[symIndex], + memcpy(&keymap->map->key_sym_map[kc].syms[symIndex], &key->syms[i][key->symsMapIndex[i][tmp]], key->symsMapNumEntries[i][tmp] * sizeof(xkb_keysym_t)); - xkb->map->key_sym_map[kc].sym_index[(i * width) + tmp] = + keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] = symIndex; - xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp] = + keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] = key->symsMapNumEntries[i][tmp]; symIndex += - xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp]; + keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp]; } else { - xkb->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1; - xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0; + keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1; + keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0; } if ((outActs != NULL) && (key->acts[i] != NULL)) { @@ -2102,41 +2100,40 @@ CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from) case XkbKB_Default: break; default: - xkb->server->behaviors[kc] = key->behavior; - xkb->server->explicit[kc] |= XkbExplicitBehaviorMask; + keymap->server->behaviors[kc] = key->behavior; + keymap->server->explicit[kc] |= XkbExplicitBehaviorMask; break; } if (key->defs.defined & _Key_VModMap) { - xkb->server->vmodmap[kc] = key->vmodmap; - xkb->server->explicit[kc] |= XkbExplicitVModMapMask; + keymap->server->vmodmap[kc] = key->vmodmap; + keymap->server->explicit[kc] |= XkbExplicitVModMapMask; } if (key->repeat != RepeatUndefined) { if (key->repeat == RepeatYes) - xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8)); + keymap->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; + keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8)); + keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask; } - if (nGroups > xkb->ctrls->num_groups) - xkb->ctrls->num_groups = nGroups; + if (nGroups > keymap->ctrls->num_groups) + keymap->ctrls->num_groups = nGroups; /* do the same thing for the next key */ - CopySymbolsDef(xkb, key, kc + 1); + CopySymbolsDef(keymap, key, kc + 1); return true; } static bool -CopyModMapDef(struct xkb_keymap * xkb, ModMapEntry *entry) +CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry) { xkb_keycode_t kc; - if ((!entry->haveSymbol) - && - (!FindNamedKey - (xkb, entry->u.keyName, &kc, true, CreateKeyNames(xkb), 0))) + if (!entry->haveSymbol && + !FindNamedKey(keymap, entry->u.keyName, &kc, true, + CreateKeyNames(keymap), 0)) { if (warningLevel >= 5) { @@ -2147,8 +2144,8 @@ CopyModMapDef(struct xkb_keymap * xkb, ModMapEntry *entry) } return false; } - else if (entry->haveSymbol - && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc))) + else if (entry->haveSymbol && + !FindKeyForSymbol(keymap, entry->u.keySym, &kc)) { if (warningLevel > 5) { @@ -2159,7 +2156,7 @@ CopyModMapDef(struct xkb_keymap * xkb, ModMapEntry *entry) } return false; } - xkb->map->modmap[kc] |= (1 << entry->modifier); + keymap->map->modmap[kc] |= (1 << entry->modifier); return true; } @@ -2167,21 +2164,21 @@ CopyModMapDef(struct xkb_keymap * xkb, ModMapEntry *entry) * Handle the xkb_symbols section of an xkb file. * * @param file The parsed xkb_symbols section of the xkb file. - * @param xkb Handle to the keyboard description to store the symbols in. + * @param keymap Handle to the keyboard description to store the symbols in. * @param merge Merge strategy (e.g. MergeOverride). */ bool -CompileSymbols(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) +CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) { unsigned int i; SymbolsInfo info; KeyInfo *key; - InitSymbolsInfo(&info, xkb); + InitSymbolsInfo(&info, keymap); info.dflt.defs.fileID = file->id; info.dflt.defs.merge = merge; - HandleSymbolsFile(file, xkb, merge, &info); + HandleSymbolsFile(file, keymap, merge, &info); if (info.nKeys == 0) goto err_info; @@ -2190,38 +2187,38 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) goto err_info; /* alloc memory in the xkb struct */ - if (XkbcAllocNames(xkb, XkbGroupNamesMask, 0) != Success) { + if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) { WSGO("Can not allocate names in CompileSymbols\n"); ACTION("Symbols not added\n"); goto err_info; } - if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0) + if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0) != Success) { WSGO("Could not allocate client map in CompileSymbols\n"); ACTION("Symbols not added\n"); goto err_info; } - if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success) { + if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) { WSGO("Could not allocate server map in CompileSymbols\n"); ACTION("Symbols not added\n"); goto err_info; } - if (XkbcAllocControls(xkb) != Success) { + if (XkbcAllocControls(keymap) != Success) { WSGO("Could not allocate controls in CompileSymbols\n"); ACTION("Symbols not added\n"); goto err_info; } /* now copy info into xkb. */ - ApplyAliases(xkb, &info.aliases); + ApplyAliases(keymap, &info.aliases); for (i = 0; i < XkbNumKbdGroups; i++) { if (info.groupNames[i] != XKB_ATOM_NONE) { - free(UNCONSTIFY(xkb->names->groups[i])); - xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]); + free(UNCONSTIFY(keymap->names->groups[i])); + keymap->names->groups[i] = XkbcAtomGetString(info.groupNames[i]); } } @@ -2231,17 +2228,17 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) /* copy! */ for (key = info.keys, i = 0; i < info.nKeys; i++, key++) - if (!CopySymbolsDef(xkb, key, 0)) + if (!CopySymbolsDef(keymap, key, 0)) 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') + for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) { + if (keymap->names->keys[i].name[0] == '\0') continue; - if (XkbKeyNumGroups(xkb, i) < 1) { + if (XkbKeyNumGroups(keymap, i) < 1) { char buf[5]; - memcpy(buf, xkb->names->keys[i].name, 4); + memcpy(buf, keymap->names->keys[i].name, 4); buf[4] = '\0'; WARN("No symbols defined for <%s> (keycode %d)\n", buf, i); } @@ -2251,9 +2248,9 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *xkb, unsigned merge) if (info.modMap) { ModMapEntry *mm, *next; for (mm = info.modMap; mm != NULL; mm = next) { - if (!CopyModMapDef(xkb, mm)) + if (!CopyModMapDef(keymap, mm)) info.errorCount++; - next = (ModMapEntry *)mm->defs.next; + next = (ModMapEntry *) mm->defs.next; } } diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c index ec72f2b..83188b7 100644 --- a/src/xkbcomp/vmod.c +++ b/src/xkbcomp/vmod.c @@ -27,32 +27,32 @@ #include "vmod.h" void -InitVModInfo(VModInfo * info, struct xkb_keymap * xkb) +InitVModInfo(VModInfo *info, struct xkb_keymap *keymap) { - ClearVModInfo(info, xkb); + ClearVModInfo(info, keymap); info->errorCount = 0; } void -ClearVModInfo(VModInfo * info, struct xkb_keymap * xkb) +ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap) { int i; info->newlyDefined = info->defined = info->available = 0; - if (XkbcAllocNames(xkb, 0, 0) != Success) + if (XkbcAllocNames(keymap, 0, 0) != Success) return; - if (XkbcAllocServerMap(xkb, 0, 0) != Success) + if (XkbcAllocServerMap(keymap, 0, 0) != Success) return; - info->xkb = xkb; - if (xkb && xkb->names) + info->keymap = keymap; + if (keymap && keymap->names) { int bit; for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) { - if (xkb->names->vmods[i] != NULL) + if (keymap->names->vmods[i] != NULL) info->defined |= bit; } } @@ -69,16 +69,14 @@ ClearVModInfo(VModInfo * info, struct xkb_keymap * xkb) * @param mergeMode Merge strategy (e.g. MergeOverride) */ bool -HandleVModDef(VModDef * stmt, struct xkb_keymap *xkb, unsigned mergeMode, - VModInfo * info) +HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, + VModInfo *info) { int i, bit, nextFree; ExprResult mod; - struct xkb_server_map * srv; - struct xkb_names * names; + struct xkb_server_map *srv = keymap->server; + struct xkb_names *names = keymap->names; - srv = xkb->server; - names = xkb->names; for (i = 0, bit = 1, nextFree = -1; i < XkbNumVirtualMods; i++, bit <<= 1) { if (info->defined & bit) @@ -144,7 +142,7 @@ HandleVModDef(VModDef * stmt, struct xkb_keymap *xkb, unsigned mergeMode, /** * Returns the index of the given modifier in the xkb->names->vmods array. * - * @param priv Pointer to the xkb data structure. + * @param keymap Pointer to the xkb data structure. * @param field The Atom of the modifier's name (e.g. Atom for LAlt) * @param type Must be TypeInt, otherwise return false. * @param val_rtrn Set to the index of the modifier that matches. @@ -153,13 +151,13 @@ HandleVModDef(VModDef * stmt, struct xkb_keymap *xkb, unsigned mergeMode, * undefined. */ static int -LookupVModIndex(const struct xkb_keymap *xkb, xkb_atom_t field, unsigned type, - ExprResult * val_rtrn) +LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, + unsigned type, ExprResult * val_rtrn) { int i; const char *name = XkbcAtomText(field); - if ((xkb == NULL) || (xkb->names == NULL) || (type != TypeInt)) + if ((keymap == NULL) || (keymap->names == NULL) || (type != TypeInt)) { return false; } @@ -170,7 +168,8 @@ LookupVModIndex(const struct xkb_keymap *xkb, xkb_atom_t field, unsigned type, */ for (i = 0; i < XkbNumVirtualMods; i++) { - if (xkb->names->vmods[i] && strcmp(xkb->names->vmods[i], name) == 0) + if (keymap->names->vmods[i] && + strcmp(keymap->names->vmods[i], name) == 0) { val_rtrn->uval = i; return true; @@ -207,13 +206,13 @@ LookupVModMask(const void * priv, xkb_atom_t field, unsigned type, } int -FindKeypadVMod(struct xkb_keymap * xkb) +FindKeypadVMod(struct xkb_keymap *keymap) { xkb_atom_t name; ExprResult rtrn; name = xkb_intern_atom("NumLock"); - if ((xkb) && LookupVModIndex(xkb, name, TypeInt, &rtrn)) + if (keymap && LookupVModIndex(keymap, name, TypeInt, &rtrn)) { return rtrn.ival; } @@ -221,12 +220,11 @@ FindKeypadVMod(struct xkb_keymap * xkb) } bool -ResolveVirtualModifier(ExprDef * def, struct xkb_keymap *xkb, - ExprResult * val_rtrn, VModInfo * info) +ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, + ExprResult *val_rtrn, VModInfo *info) { - struct xkb_names * names; + struct xkb_names *names = keymap->names; - names = xkb->names; if (def->op == ExprIdent) { int i, bit; diff --git a/src/xkbcomp/vmod.h b/src/xkbcomp/vmod.h index 159a9fe..45fb2f4 100644 --- a/src/xkbcomp/vmod.h +++ b/src/xkbcomp/vmod.h @@ -32,7 +32,7 @@ typedef struct _VModInfo { - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; unsigned defined; unsigned available; unsigned newlyDefined; @@ -40,23 +40,23 @@ typedef struct _VModInfo } VModInfo; extern void -InitVModInfo(VModInfo *info, struct xkb_keymap *xkb); +InitVModInfo(VModInfo *info, struct xkb_keymap *keymap); extern void -ClearVModInfo(VModInfo *info, struct xkb_keymap *xkb); +ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap); extern bool -HandleVModDef(VModDef *stmt, struct xkb_keymap *xkb, unsigned mergeMode, +HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, VModInfo *info); extern bool -ApplyVModDefs(VModInfo *info, struct xkb_keymap *xkb); +ApplyVModDefs(VModInfo *info, struct xkb_keymap *keymap); extern int -FindKeypadVMod(struct xkb_keymap *xkb); +FindKeypadVMod(struct xkb_keymap *keymap); extern bool -ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *xkb, +ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, ExprResult *value_rtrn, VModInfo *info); #endif /* VMOD_H */ diff --git a/src/xkbcomp/xkbcomp-priv.h b/src/xkbcomp/xkbcomp-priv.h index 9aecd19..239ea61 100644 --- a/src/xkbcomp/xkbcomp-priv.h +++ b/src/xkbcomp/xkbcomp-priv.h @@ -69,15 +69,16 @@ ProcessIncludeFile(struct xkb_context *context, unsigned *merge_rtrn); extern bool -FindNamedKey(struct xkb_keymap *xkb, unsigned long name, xkb_keycode_t *kc_rtrn, - bool use_aliases, bool create, xkb_keycode_t start_from); +FindNamedKey(struct xkb_keymap *keymap, unsigned long name, + xkb_keycode_t *kc_rtrn, bool use_aliases, bool create, + xkb_keycode_t start_from); extern bool -FindKeyNameForAlias(struct xkb_keymap *xkb, unsigned long lname, +FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname, unsigned long *real_name); extern bool -UpdateModifiersFromCompat(struct xkb_keymap *xkb); +UpdateModifiersFromCompat(struct xkb_keymap *keymap); extern const char * XkbDirectoryForInclude(unsigned type); diff --git a/src/xkbcomp/xkbcomp.c b/src/xkbcomp/xkbcomp.c index e332697..1912dd5 100644 --- a/src/xkbcomp/xkbcomp.c +++ b/src/xkbcomp/xkbcomp.c @@ -121,7 +121,7 @@ xkb_map_new_from_names(struct xkb_context *context, { XkbRF_VarDefsRec defs; struct xkb_component_names *names; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; if (!rmlvo || ISEMPTY(rmlvo->rules) || ISEMPTY(rmlvo->layout)) { ERROR("rules and layout required to generate XKB keymap\n"); @@ -140,7 +140,7 @@ xkb_map_new_from_names(struct xkb_context *context, return NULL; } - xkb = xkb_map_new_from_kccgst(context, names, 0); + keymap = xkb_map_new_from_kccgst(context, names, 0); free(names->keymap); free(names->keycodes); @@ -149,7 +149,7 @@ xkb_map_new_from_names(struct xkb_context *context, free(names->symbols); free(names); - return xkb; + return keymap; } static XkbFile * @@ -190,7 +190,7 @@ static struct xkb_keymap * compile_keymap(struct xkb_context *context, XkbFile *file) { XkbFile *mapToUse; - struct xkb_keymap * xkb = NULL; + struct xkb_keymap *keymap = NULL; /* Find map to use */ mapToUse = XkbChooseMap(file, NULL); @@ -207,14 +207,14 @@ compile_keymap(struct xkb_context *context, XkbFile *file) goto err; } - xkb = CompileKeymap(context, mapToUse); - if (!xkb) + keymap = CompileKeymap(context, mapToUse); + if (!keymap) goto err; err: FreeXKBFile(file); XkbcFreeAllAtoms(); - return xkb; + return keymap; } _X_EXPORT struct xkb_keymap * @@ -317,17 +317,17 @@ xkb_map_new_from_fd(struct xkb_context *context, } _X_EXPORT struct xkb_keymap * -xkb_map_ref(struct xkb_keymap *xkb) +xkb_map_ref(struct xkb_keymap *keymap) { - xkb->refcnt++; - return xkb; + keymap->refcnt++; + return keymap; } _X_EXPORT void -xkb_map_unref(struct xkb_keymap *xkb) +xkb_map_unref(struct xkb_keymap *keymap) { - if (--xkb->refcnt > 0) + if (--keymap->refcnt > 0) return; - XkbcFreeKeyboard(xkb); + XkbcFreeKeyboard(keymap); } diff --git a/src/xkbcomp/xkbcomp.h b/src/xkbcomp/xkbcomp.h index c69c141..b4b2ed9 100644 --- a/src/xkbcomp/xkbcomp.h +++ b/src/xkbcomp/xkbcomp.h @@ -254,18 +254,18 @@ extern struct xkb_keymap * CompileKeymap(struct xkb_context *context, XkbFile *file); extern bool -CompileKeycodes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge); +CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge); extern bool -CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge); +CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge); typedef struct _LEDInfo *LEDInfoPtr; extern bool -CompileCompatMap(XkbFile *file, struct xkb_keymap * xkb, unsigned merge, +CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap, unsigned merge, LEDInfoPtr *unboundLEDs); extern bool -CompileSymbols(XkbFile *file, struct xkb_keymap * xkb, unsigned merge); +CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge); #endif /* XKBCOMP_H */ diff --git a/test/filecomp.c b/test/filecomp.c index d387044..4ee03b1 100644 --- a/test/filecomp.c +++ b/test/filecomp.c @@ -41,7 +41,7 @@ test_file(const char *path) { int fd; struct xkb_context *context; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; fd = open(path, O_RDONLY); assert(fd >= 0); @@ -51,16 +51,16 @@ test_file(const char *path) fprintf(stderr, "\nCompiling path: %s\n", path); - xkb = xkb_map_new_from_fd(context, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0); + keymap = xkb_map_new_from_fd(context, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0); close(fd); - if (!xkb) { + if (!keymap) { fprintf(stderr, "Failed to compile keymap\n"); xkb_context_unref(context); return 0; } - xkb_map_unref(xkb); + xkb_map_unref(keymap); xkb_context_unref(context); return 1; } @@ -79,20 +79,21 @@ static int test_string(const char *string) { struct xkb_context *context; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; context = xkb_context_new(0); assert(context); fprintf(stderr, "\nCompiling string\n"); - xkb = xkb_map_new_from_string(context, string, XKB_KEYMAP_FORMAT_TEXT_V1, 0); - if (!xkb) { + keymap = xkb_map_new_from_string(context, string, + XKB_KEYMAP_FORMAT_TEXT_V1, 0); + if (!keymap) { xkb_context_unref(context); return 0; } - xkb_map_unref(xkb); + xkb_map_unref(keymap); xkb_context_unref(context); return 1; } diff --git a/test/namescomp.c b/test/namescomp.c index 36c89f3..b68a33e 100644 --- a/test/namescomp.c +++ b/test/namescomp.c @@ -37,7 +37,7 @@ test_names(const char *keycodes, const char *types, { int ret = 1; struct xkb_context *context; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; struct xkb_component_names kccgst = { .keymap = NULL, .keycodes = strdup(keycodes), @@ -52,13 +52,13 @@ test_names(const char *keycodes, const char *types, fprintf(stderr, "\nCompiling %s %s %s %s\n", kccgst.keycodes, kccgst.types, kccgst.compat, kccgst.symbols); - xkb = xkb_map_new_from_kccgst(context, &kccgst, 0); - if (!xkb) { + keymap = xkb_map_new_from_kccgst(context, &kccgst, 0); + if (!keymap) { ret = 0; goto err_ctx; } - xkb_map_unref(xkb); + xkb_map_unref(keymap); err_ctx: xkb_context_unref(context); free(kccgst.keycodes); diff --git a/test/rulescomp.c b/test/rulescomp.c index 91b91b4..fbf335d 100644 --- a/test/rulescomp.c +++ b/test/rulescomp.c @@ -34,7 +34,7 @@ test_rmlvo(const char *rules, const char *model, const char *layout, const char *variant, const char *options) { struct xkb_context *context; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; struct xkb_rule_names rmlvo = { .rules = rules, .model = model, @@ -49,13 +49,13 @@ test_rmlvo(const char *rules, const char *model, const char *layout, fprintf(stderr, "\nCompiling %s %s %s %s %s\n", rmlvo.rules, rmlvo.model, rmlvo.layout, rmlvo.variant, rmlvo.options); - xkb = xkb_map_new_from_names(context, &rmlvo, 0); - if (!xkb) { + keymap = xkb_map_new_from_names(context, &rmlvo, 0); + if (!keymap) { xkb_context_unref(context); return 0; } - xkb_map_unref(xkb); + xkb_map_unref(keymap); xkb_context_unref(context); return 1; } diff --git a/test/state.c b/test/state.c index d43d25e..bbc7077 100644 --- a/test/state.c +++ b/test/state.c @@ -49,11 +49,11 @@ print_state(struct xkb_state *state) return; } - for (group = 0; group < xkb_map_num_groups(state->xkb); group++) { + for (group = 0; group < xkb_map_num_groups(state->keymap); group++) { if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE)) continue; fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n", - xkb_map_group_get_name(state->xkb, group), + xkb_map_group_get_name(state->keymap, group), group, xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) ? "effective " : "", @@ -65,11 +65,11 @@ print_state(struct xkb_state *state) "locked " : ""); } - for (mod = 0; mod < xkb_map_num_mods(state->xkb); mod++) { + for (mod = 0; mod < xkb_map_num_mods(state->keymap); mod++) { if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE)) continue; fprintf(stderr, "\tmod %s (%d): %s%s%s\n", - xkb_map_mod_get_name(state->xkb, mod), + xkb_map_mod_get_name(state->keymap, mod), mod, xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) ? "depressed " : "", @@ -79,19 +79,19 @@ print_state(struct xkb_state *state) "locked " : ""); } - for (led = 0; led < xkb_map_num_leds(state->xkb); led++) { + for (led = 0; led < xkb_map_num_leds(state->keymap); led++) { if (!xkb_state_led_index_is_active(state, led)) continue; fprintf(stderr, "\tled %s (%d): active\n", - xkb_map_led_get_name(state->xkb, led), + xkb_map_led_get_name(state->keymap, led), led); } } static void -test_update_key(struct xkb_keymap *xkb) +test_update_key(struct xkb_keymap *keymap) { - struct xkb_state *state = xkb_state_new(xkb); + struct xkb_state *state = xkb_state_new(keymap); const xkb_keysym_t *syms; int num_syms; @@ -170,9 +170,9 @@ test_update_key(struct xkb_keymap *xkb) } static void -test_serialisation(struct xkb_keymap *xkb) +test_serialisation(struct xkb_keymap *keymap) { - struct xkb_state *state = xkb_state_new(xkb); + struct xkb_state *state = xkb_state_new(keymap); xkb_mod_mask_t base_mods; xkb_mod_mask_t latched_mods; xkb_mod_mask_t locked_mods; @@ -184,11 +184,11 @@ test_serialisation(struct xkb_keymap *xkb) assert(state); - caps = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CAPS); + caps = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_CAPS); assert(caps != XKB_MOD_INVALID); - shift = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_SHIFT); + shift = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_SHIFT); assert(shift != XKB_MOD_INVALID); - ctrl = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CTRL); + ctrl = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_CTRL); assert(ctrl != XKB_MOD_INVALID); xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN); @@ -226,7 +226,7 @@ int main(void) { struct xkb_context *context; - struct xkb_keymap *xkb; + struct xkb_keymap *keymap; struct xkb_rule_names rmlvo = { .rules = "evdev", .model = "pc104", @@ -238,12 +238,12 @@ main(void) context = xkb_context_new(0); assert(context); - xkb = xkb_map_new_from_names(context, &rmlvo, 0); - assert(xkb); + keymap = xkb_map_new_from_names(context, &rmlvo, 0); + assert(keymap); - test_update_key(xkb); - test_serialisation(xkb); + test_update_key(keymap); + test_serialisation(keymap); - xkb_map_unref(xkb); + xkb_map_unref(keymap); xkb_context_unref(context); } -- 2.7.4