Don't use xkbcommon-compat names in internal code

Signed-off-by: Ran Benita <ran234@gmail.com>

diff --git a/src/keymap-dump.c b/src/keymap-dump.c
index b0ec338..42b125b 100644 (file)
--- a/src/keymap-dump.c
+++ b/src/keymap-dump.c
@@ -557,7 +557,7 @@ write_compat(struct xkb_keymap *keymap, struct buf *buf)
 
 static bool
 write_keysyms(struct xkb_keymap *keymap, struct buf *buf,
-              struct xkb_key *key, xkb_group_index_t group)
+              struct xkb_key *key, xkb_layout_index_t group)
 {
     const xkb_keysym_t *syms;
     int num_syms;
@@ -598,7 +598,7 @@ static bool
 write_symbols(struct xkb_keymap *keymap, struct buf *buf)
 {
     struct xkb_key *key;
-    xkb_group_index_t group, tmp;
+    xkb_layout_index_t group, tmp;
     bool showActions;
 
     if (keymap->symbols_section_name)
@@ -746,7 +746,7 @@ write_symbols(struct xkb_keymap *keymap, struct buf *buf)
 }
 
 XKB_EXPORT char *
-xkb_map_get_as_string(struct xkb_keymap *keymap)
+xkb_keymap_get_as_string(struct xkb_keymap *keymap)
 {
     bool ok;
     struct buf buf = { NULL, 0, 0 };

diff --git a/src/map.c b/src/map.c
index 1ffcb0d..9c91749 100644 (file)
--- a/src/map.c
+++ b/src/map.c
@@ -131,7 +131,7 @@ xkb_keymap_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx)
 {
     const char *name;
 
-    if (idx >= xkb_map_num_mods(keymap))
+    if (idx >= xkb_keymap_num_mods(keymap))
         return NULL;
 
     /* First try to find a legacy modifier name.  If that fails, try to
@@ -203,13 +203,13 @@ xkb_keymap_layout_get_index(struct xkb_keymap *keymap, const char *name)
     xkb_layout_index_t i;
 
     if (atom == XKB_ATOM_NONE)
-        return XKB_GROUP_INVALID;
+        return XKB_LAYOUT_INVALID;
 
     for (i = 0; i < num_groups; i++)
         if (keymap->group_names[i] == atom)
             return i;
 
-    return XKB_GROUP_INVALID;
+    return XKB_LAYOUT_INVALID;
 }
 
 /**
@@ -263,7 +263,7 @@ xkb_keymap_num_leds(struct xkb_keymap *keymap)
 XKB_EXPORT const char *
 xkb_keymap_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx)
 {
-    if (idx >= xkb_map_num_leds(keymap))
+    if (idx >= xkb_keymap_num_leds(keymap))
         return NULL;
 
     return xkb_atom_text(keymap->ctx, keymap->indicators[idx].name);
@@ -272,10 +272,10 @@ xkb_keymap_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx)
 /**
  * Returns the index for a named group.
  */
-XKB_EXPORT xkb_group_index_t
+XKB_EXPORT xkb_layout_index_t
 xkb_keymap_led_get_index(struct xkb_keymap *keymap, const char *name)
 {
-    xkb_led_index_t num_leds = xkb_map_num_leds(keymap);
+    xkb_led_index_t num_leds = xkb_keymap_num_leds(keymap);
     xkb_atom_t atom = xkb_atom_lookup(keymap->ctx, name);
     xkb_led_index_t i;
 
@@ -291,13 +291,13 @@ xkb_keymap_led_get_index(struct xkb_keymap *keymap, const char *name)
 
 static struct xkb_kt_map_entry *
 get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
-                        xkb_group_index_t group)
+                        xkb_layout_index_t group)
 {
     struct xkb_key_type *type;
     xkb_mod_mask_t active_mods;
     unsigned int i;
 
-    type = XkbKeyType(xkb_state_get_map(state), key, group);
+    type = XkbKeyType(xkb_state_get_keymap(state), key, group);
     active_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
     active_mods &= type->mods.mask;
 
@@ -404,7 +404,7 @@ XKB_EXPORT int
 xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t kc,
                        const xkb_keysym_t **syms_out)
 {
-    struct xkb_keymap *keymap = xkb_state_get_map(state);
+    struct xkb_keymap *keymap = xkb_state_get_keymap(state);
     xkb_layout_index_t layout;
     xkb_level_index_t level;
     const struct xkb_key *key = XkbKey(keymap, kc);
@@ -444,10 +444,10 @@ static xkb_mod_mask_t
 key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
 {
     struct xkb_kt_map_entry *entry;
-    xkb_group_index_t group;
+    xkb_layout_index_t group;
 
     group = xkb_state_key_get_layout(state, key->keycode);
-    if (group == XKB_GROUP_INVALID)
+    if (group == XKB_LAYOUT_INVALID)
         return 0;
 
     entry = get_entry_for_key_state(state, key, group);
@@ -473,7 +473,7 @@ XKB_EXPORT int
 xkb_state_mod_index_is_consumed(struct xkb_state *state, xkb_keycode_t kc,
                                 xkb_mod_index_t idx)
 {
-    const struct xkb_key *key = XkbKey(xkb_state_get_map(state), kc);
+    const struct xkb_key *key = XkbKey(xkb_state_get_keymap(state), kc);
     if (!key)
         return 0;
 
@@ -492,7 +492,7 @@ XKB_EXPORT xkb_mod_mask_t
 xkb_state_mod_mask_remove_consumed(struct xkb_state *state, xkb_keycode_t kc,
                                    xkb_mod_mask_t mask)
 {
-    const struct xkb_key *key = XkbKey(xkb_state_get_map(state), kc);
+    const struct xkb_key *key = XkbKey(xkb_state_get_keymap(state), kc);
     if (!key)
         return 0;
 

diff --git a/src/map.h b/src/map.h
index 7c2be1b..6360165 100644 (file)
--- a/src/map.h
+++ b/src/map.h
@@ -81,7 +81,10 @@
 #ifndef MAP_H
 #define MAP_H
 
+ /* Don't use compat names in internal code. */
+#define _XKBCOMMON_COMPAT_H
 #include "xkbcommon/xkbcommon.h"
+
 #include "utils.h"
 #include "context.h"
 

diff --git a/src/state.c b/src/state.c
index 8529f4e..69993b0 100644 (file)
--- a/src/state.c
+++ b/src/state.c
@@ -73,10 +73,10 @@ struct xkb_filter {
 };
 
 struct xkb_state {
-    xkb_group_index_t base_group; /**< depressed */
-    xkb_group_index_t latched_group;
-    xkb_group_index_t locked_group;
-    xkb_group_index_t group; /**< effective */
+    xkb_layout_index_t base_group; /**< depressed */
+    xkb_layout_index_t latched_group;
+    xkb_layout_index_t locked_group;
+    xkb_layout_index_t group; /**< effective */
 
     xkb_mod_mask_t base_mods; /**< depressed */
     xkb_mod_mask_t latched_mods;
@@ -459,7 +459,7 @@ xkb_state_new(struct xkb_keymap *keymap)
         return NULL;
 
     ret->refcnt = 1;
-    ret->keymap = xkb_map_ref(keymap);
+    ret->keymap = xkb_keymap_ref(keymap);
 
     return ret;
 }
@@ -477,13 +477,13 @@ xkb_state_unref(struct xkb_state *state)
     if (--state->refcnt > 0)
         return;
 
-    xkb_map_unref(state->keymap);
+    xkb_keymap_unref(state->keymap);
     darray_free(state->filters);
     free(state);
 }
 
 XKB_EXPORT struct xkb_keymap *
-xkb_state_get_map(struct xkb_state *state)
+xkb_state_get_keymap(struct xkb_state *state)
 {
     return state->keymap;
 }
@@ -598,9 +598,9 @@ xkb_state_update_mask(struct xkb_state *state,
                       xkb_mod_mask_t base_mods,
                       xkb_mod_mask_t latched_mods,
                       xkb_mod_mask_t locked_mods,
-                      xkb_group_index_t base_group,
-                      xkb_group_index_t latched_group,
-                      xkb_group_index_t locked_group)
+                      xkb_layout_index_t base_group,
+                      xkb_layout_index_t latched_group,
+                      xkb_layout_index_t locked_group)
 {
     xkb_mod_index_t num_mods;
     xkb_mod_index_t idx;
@@ -608,7 +608,7 @@ xkb_state_update_mask(struct xkb_state *state,
     state->base_mods = 0;
     state->latched_mods = 0;
     state->locked_mods = 0;
-    num_mods = xkb_map_num_mods(state->keymap);
+    num_mods = xkb_keymap_num_mods(state->keymap);
 
     for (idx = 0; idx < num_mods; idx++) {
         xkb_mod_mask_t mod = (1 << idx);
@@ -654,11 +654,11 @@ xkb_state_serialize_mods(struct xkb_state *state,
  * Serialises the requested group state, with all the same disclaimers as
  * in xkb_state_update_mask.
  */
-XKB_EXPORT xkb_group_index_t
-xkb_state_serialize_group(struct xkb_state *state,
-                          enum xkb_state_component type)
+XKB_EXPORT xkb_layout_index_t
+xkb_state_serialize_layout(struct xkb_state *state,
+                           enum xkb_state_component type)
 {
-    xkb_group_index_t ret = 0;
+    xkb_layout_index_t ret = 0;
 
     if (type == XKB_STATE_EFFECTIVE)
         return state->group;
@@ -684,7 +684,7 @@ xkb_state_mod_index_is_active(struct xkb_state *state,
 {
     int ret = 0;
 
-    if (idx >= xkb_map_num_mods(state->keymap))
+    if (idx >= xkb_keymap_num_mods(state->keymap))
         return -1;
 
     if (type & XKB_STATE_DEPRESSED)
@@ -732,7 +732,7 @@ xkb_state_mod_indices_are_active(struct xkb_state *state,
     xkb_mod_index_t idx = 0;
     uint32_t wanted = 0;
     int ret = 0;
-    xkb_mod_index_t num_mods = xkb_map_num_mods(state->keymap);
+    xkb_mod_index_t num_mods = xkb_keymap_num_mods(state->keymap);
 
     va_start(ap, match);
     while (1) {
@@ -761,7 +761,7 @@ XKB_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->keymap, name);
+    xkb_mod_index_t idx = xkb_keymap_mod_get_index(state->keymap, name);
 
     if (idx == XKB_MOD_INVALID)
         return -1;
@@ -790,7 +790,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->keymap, str);
+        idx = xkb_keymap_mod_get_index(state->keymap, str);
         if (idx == XKB_MOD_INVALID) {
             ret = -1;
             break;
@@ -810,13 +810,13 @@ xkb_state_mod_names_are_active(struct xkb_state *state,
  * not, or -1 if the group is invalid.
  */
 XKB_EXPORT int
-xkb_state_group_index_is_active(struct xkb_state *state,
-                                xkb_group_index_t idx,
+xkb_state_layout_index_is_active(struct xkb_state *state,
+                                xkb_layout_index_t idx,
                                 enum xkb_state_component type)
 {
     int ret = 0;
 
-    if (idx >= xkb_map_num_groups(state->keymap))
+    if (idx >= xkb_keymap_num_layouts(state->keymap))
         return -1;
 
     if (type & XKB_STATE_DEPRESSED)
@@ -834,15 +834,15 @@ xkb_state_group_index_is_active(struct xkb_state *state,
  * not, or -1 if the modifier is invalid.
  */
 XKB_EXPORT int
-xkb_state_group_name_is_active(struct xkb_state *state, const char *name,
-                               enum xkb_state_component type)
+xkb_state_layout_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->keymap, name);
+    xkb_layout_index_t idx = xkb_keymap_layout_get_index(state->keymap, name);
 
-    if (idx == XKB_GROUP_INVALID)
+    if (idx == XKB_LAYOUT_INVALID)
         return -1;
 
-    return xkb_state_group_index_is_active(state, idx, type);
+    return xkb_state_layout_index_is_active(state, idx, type);
 }
 
 /**
@@ -851,7 +851,7 @@ xkb_state_group_name_is_active(struct xkb_state *state, const char *name,
 XKB_EXPORT int
 xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
 {
-    if (idx >= xkb_map_num_leds(state->keymap))
+    if (idx >= xkb_keymap_num_leds(state->keymap))
         return -1;
 
     return !!(state->leds & (1 << idx));
@@ -863,7 +863,7 @@ xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
 XKB_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->keymap, name);
+    xkb_led_index_t idx = xkb_keymap_led_get_index(state->keymap, name);
 
     if (idx == XKB_LED_INVALID)
         return -1;

diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c
index 81a5eaa..47d273c 100644 (file)
--- a/src/xkbcomp/action.c
+++ b/src/xkbcomp/action.c
@@ -364,7 +364,7 @@ HandleLockMods(struct xkb_keymap *keymap, union xkb_action *action,
 static bool
 CheckGroupField(struct xkb_keymap *keymap, unsigned action,
                 const ExprDef *value, enum xkb_action_flags *flags_inout,
-                xkb_group_index_t *grp_rtrn)
+                xkb_layout_index_t *grp_rtrn)
 {
     const ExprDef *spec;
 
@@ -396,7 +396,7 @@ HandleSetLatchGroup(struct xkb_keymap *keymap, union xkb_action *action,
 {
     struct xkb_group_action *act = &action->group;
     enum xkb_action_flags rtrn, t1;
-    xkb_group_index_t t2;
+    xkb_layout_index_t t2;
 
     if (array_ndx != NULL) {
         switch (field) {
@@ -443,7 +443,7 @@ HandleLockGroup(struct xkb_keymap *keymap, union xkb_action *action,
 {
     struct xkb_group_action *act = &action->group;
     enum xkb_action_flags t1;
-    xkb_group_index_t t2;
+    xkb_layout_index_t t2;
 
     if ((array_ndx != NULL) && (field == ACTION_FIELD_GROUP))
         return ReportActionNotArray(keymap, action->type, field);

diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c
index e30d7e2..a7c91b8 100644 (file)
--- a/src/xkbcomp/expr.c
+++ b/src/xkbcomp/expr.c
@@ -386,7 +386,7 @@ ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
 
 bool
 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
-                 xkb_group_index_t *group_rtrn)
+                 xkb_layout_index_t *group_rtrn)
 {
     bool ok;
     int result;
@@ -402,7 +402,7 @@ ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
         return false;
     }
 
-    *group_rtrn = (xkb_group_index_t) result;
+    *group_rtrn = (xkb_layout_index_t) result;
     return true;
 }
 

diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h
index 450b6c8..21d9c5d 100644 (file)
--- a/src/xkbcomp/expr.h
+++ b/src/xkbcomp/expr.h
@@ -70,7 +70,7 @@ ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
 
 bool
 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
-                 xkb_group_index_t *group_rtrn);
+                 xkb_layout_index_t *group_rtrn);
 
 bool
 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr,

diff --git a/src/xkbcomp/keymap.c b/src/xkbcomp/keymap.c
index a10d834..6ca91d1 100644 (file)
--- a/src/xkbcomp/keymap.c
+++ b/src/xkbcomp/keymap.c
@@ -69,7 +69,7 @@ UpdateActionMods(struct xkb_keymap *keymap, union xkb_action *act,
  */
 static struct xkb_sym_interpret *
 FindInterpForKey(struct xkb_keymap *keymap, struct xkb_key *key,
-                 xkb_group_index_t group, xkb_level_index_t level)
+                 xkb_layout_index_t group, xkb_level_index_t level)
 {
     struct xkb_sym_interpret *interp;
     const xkb_keysym_t *syms;
@@ -131,7 +131,7 @@ static bool
 ApplyInterpsToKey(struct xkb_keymap *keymap, struct xkb_key *key)
 {
     xkb_mod_mask_t vmodmask = 0;
-    xkb_group_index_t group;
+    xkb_layout_index_t group;
     xkb_level_index_t width, level;
 
     /* If we've been told not to bind interps to this key, then don't. */

diff --git a/src/xkbcomp/rules.c b/src/xkbcomp/rules.c
index badbbf2..0fe2b9b 100644 (file)
--- a/src/xkbcomp/rules.c
+++ b/src/xkbcomp/rules.c
@@ -400,7 +400,7 @@ struct mapping {
     int mlvo_at_pos[_MLVO_NUM_ENTRIES];
     unsigned int num_mlvo;
     unsigned int defined_mlvo_mask;
-    xkb_group_index_t layout_idx, variant_idx;
+    xkb_layout_index_t layout_idx, variant_idx;
     int kccgst_at_pos[_KCCGST_NUM_ENTRIES];
     unsigned int num_kccgst;
     unsigned int defined_kccgst_mask;
@@ -544,7 +544,7 @@ matcher_mapping_start_new(struct matcher *m)
         m->mapping.mlvo_at_pos[i] = -1;
     for (i = 0; i < _KCCGST_NUM_ENTRIES; i++)
         m->mapping.kccgst_at_pos[i] = -1;
-    m->mapping.layout_idx = m->mapping.variant_idx = XKB_GROUP_INVALID;
+    m->mapping.layout_idx = m->mapping.variant_idx = XKB_LAYOUT_INVALID;
     m->mapping.num_mlvo = m->mapping.num_kccgst = 0;
     m->mapping.defined_mlvo_mask = 0;
     m->mapping.defined_kccgst_mask = 0;
@@ -552,7 +552,7 @@ matcher_mapping_start_new(struct matcher *m)
 }
 
 static int
-extract_group_index(const char *s, size_t max_len, xkb_group_index_t *out)
+extract_layout_index(const char *s, size_t max_len, xkb_layout_index_t *out)
 {
     /* This function is pretty stupid, but works for now. */
     if (max_len < 3)
@@ -571,7 +571,7 @@ matcher_mapping_set_mlvo(struct matcher *m, struct sval ident)
 {
     enum rules_mlvo mlvo;
     struct sval mlvo_sval;
-    xkb_group_index_t idx;
+    xkb_layout_index_t idx;
     int consumed;
 
     for (mlvo = 0; mlvo < _MLVO_NUM_ENTRIES; mlvo++) {
@@ -602,7 +602,7 @@ matcher_mapping_set_mlvo(struct matcher *m, struct sval ident)
 
     /* If there are leftovers still, it must be an index. */
     if (mlvo_sval.len < ident.len) {
-        consumed = extract_group_index(ident.start + mlvo_sval.len,
+        consumed = extract_layout_index(ident.start + mlvo_sval.len,
                                        ident.len - mlvo_sval.len, &idx);
         if ((int) (ident.len - mlvo_sval.len) != consumed) {
             matcher_error(m,
@@ -694,7 +694,7 @@ matcher_mapping_verify(struct matcher *m)
      */
 
     if (m->mapping.defined_mlvo_mask & (1 << MLVO_LAYOUT)) {
-        if (m->mapping.layout_idx == XKB_GROUP_INVALID) {
+        if (m->mapping.layout_idx == XKB_LAYOUT_INVALID) {
             if (darray_size(m->rmlvo.layouts) > 1)
                 goto skip;
         }
@@ -706,7 +706,7 @@ matcher_mapping_verify(struct matcher *m)
     }
 
     if (m->mapping.defined_mlvo_mask & (1 << MLVO_VARIANT)) {
-        if (m->mapping.variant_idx == XKB_GROUP_INVALID) {
+        if (m->mapping.variant_idx == XKB_LAYOUT_INVALID) {
             if (darray_size(m->rmlvo.variants) > 1)
                 goto skip;
         }
@@ -831,7 +831,7 @@ append_expanded_kccgst_value(struct matcher *m, darray_char *to,
     unsigned int i;
     size_t original_size = darray_size(*to);
     const char *s = value.start;
-    xkb_group_index_t idx;
+    xkb_layout_index_t idx;
     int consumed;
     enum rules_mlvo mlv;
     struct sval expanded;
@@ -890,12 +890,12 @@ append_expanded_kccgst_value(struct matcher *m, darray_char *to,
                     goto error;
                 }
 
-                consumed = extract_group_index(s + i, value.len - i, &idx);
+                consumed = extract_layout_index(s + i, value.len - i, &idx);
                 if (consumed == -1) goto error;
                 i += consumed;
             }
             else {
-                idx = XKB_GROUP_INVALID;
+                idx = XKB_LAYOUT_INVALID;
             }
         }
 
@@ -909,20 +909,20 @@ append_expanded_kccgst_value(struct matcher *m, darray_char *to,
         expanded.len = 0;
 
         if (mlv == MLVO_LAYOUT) {
-            if (idx != XKB_GROUP_INVALID &&
+            if (idx != XKB_LAYOUT_INVALID &&
                 idx < darray_size(m->rmlvo.layouts) &&
                 darray_size(m->rmlvo.layouts) > 1)
                 expanded = darray_item(m->rmlvo.layouts, idx);
-            else if (idx == XKB_GROUP_INVALID &&
+            else if (idx == XKB_LAYOUT_INVALID &&
                      darray_size(m->rmlvo.layouts) == 1)
                 expanded = darray_item(m->rmlvo.layouts, 0);
         }
         else if (mlv == MLVO_VARIANT) {
-            if (idx != XKB_GROUP_INVALID &&
+            if (idx != XKB_LAYOUT_INVALID &&
                 idx < darray_size(m->rmlvo.variants) &&
                 darray_size(m->rmlvo.variants) > 1)
                 expanded = darray_item(m->rmlvo.variants, idx);
-            else if (idx == XKB_GROUP_INVALID &&
+            else if (idx == XKB_LAYOUT_INVALID &&
                      darray_size(m->rmlvo.variants) == 1)
                 expanded = darray_item(m->rmlvo.variants, 0);
         }
@@ -970,7 +970,7 @@ matcher_rule_apply_if_matches(struct matcher *m)
     struct sval value, *option;
     enum mlvo_match_type match_type;
     bool matched = false;
-    xkb_group_index_t idx;
+    xkb_layout_index_t idx;
 
     for (i = 0; i < m->mapping.num_mlvo; i++) {
         mlvo = m->mapping.mlvo_at_pos[i];
@@ -982,14 +982,14 @@ matcher_rule_apply_if_matches(struct matcher *m)
         }
         else if (mlvo == MLVO_LAYOUT) {
             idx = m->mapping.layout_idx;
-            idx = (idx == XKB_GROUP_INVALID ? 0 : idx);
+            idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
             matched = match_value(m, value,
                                   darray_item(m->rmlvo.layouts, idx),
                                   match_type);
         }
         else if (mlvo == MLVO_VARIANT) {
             idx = m->mapping.layout_idx;
-            idx = (idx == XKB_GROUP_INVALID ? 0 : idx);
+            idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
             matched = match_value(m, value,
                                   darray_item(m->rmlvo.variants, idx),
                                   match_type);

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index 278732c..4233a76 100644 (file)
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -108,7 +108,7 @@ typedef struct _KeyInfo {
     xkb_atom_t dfltType;
 
     enum xkb_range_exceed_type out_of_range_group_action;
-    xkb_group_index_t out_of_range_group_number;
+    xkb_layout_index_t out_of_range_group_number;
 } KeyInfo;
 
 static void
@@ -139,7 +139,7 @@ InitKeyInfo(KeyInfo *keyi, unsigned file_id)
 static void
 ClearKeyInfo(KeyInfo *keyi)
 {
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
     for (i = 0; i < XKB_NUM_GROUPS; i++)
         ClearGroupInfo(&keyi->groups[i]);
 }
@@ -161,7 +161,7 @@ typedef struct _SymbolsInfo {
     int errorCount;
     unsigned file_id;
     enum merge_mode merge;
-    xkb_group_index_t explicit_group;
+    xkb_layout_index_t explicit_group;
     darray(KeyInfo) keys;
     KeyInfo dflt;
     VModInfo vmods;
@@ -198,7 +198,7 @@ ClearSymbolsInfo(SymbolsInfo * info)
 
 static bool
 MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
-            bool report, xkb_group_index_t group, unsigned long key_name)
+            bool report, xkb_layout_index_t group, unsigned long key_name)
 {
     xkb_level_index_t i, numLevels;
     enum { INTO = (1 << 0), FROM = (1 << 1) } using;
@@ -393,7 +393,7 @@ UseNewKeyField(enum key_field field, enum key_field old, enum key_field new,
 static bool
 MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
 {
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
     enum key_field collide = 0;
     bool clobber, report;
     int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
@@ -626,12 +626,12 @@ HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *stmt)
 
 static bool
 GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
-              unsigned what, xkb_group_index_t *ndx_rtrn)
+              unsigned what, xkb_layout_index_t *ndx_rtrn)
 {
     const char *name = (what == SYMBOLS ? "symbols" : "actions");
 
     if (arrayNdx == NULL) {
-        xkb_group_index_t i;
+        xkb_layout_index_t i;
         enum group_field field = (what == SYMBOLS ?
                                   GROUP_FIELD_SYMS : GROUP_FIELD_ACTS);
 
@@ -689,7 +689,7 @@ static bool
 AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
                 ExprDef *value)
 {
-    xkb_group_index_t ndx;
+    xkb_layout_index_t ndx;
     GroupInfo *groupi;
     unsigned int nSyms;
     xkb_level_index_t nLevels;
@@ -779,7 +779,7 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
                 ExprDef *value)
 {
     unsigned int i;
-    xkb_group_index_t ndx;
+    xkb_layout_index_t ndx;
     GroupInfo *groupi;
     unsigned int nActs;
     ExprDef *act;
@@ -854,7 +854,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
     struct xkb_context *ctx = info->keymap->ctx;
 
     if (istreq(field, "type")) {
-        xkb_group_index_t ndx;
+        xkb_layout_index_t ndx;
         xkb_atom_t val;
 
         if (!ExprResolveString(ctx, value, &val))
@@ -980,7 +980,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
     }
     else if (istreq(field, "groupsredirect") ||
              istreq(field, "redirectgroups")) {
-        xkb_group_index_t grp;
+        xkb_layout_index_t grp;
 
         if (!ExprResolveGroup(ctx, value, &grp)) {
             log_err(info->keymap->ctx,
@@ -1008,7 +1008,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
 static int
 SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
 {
-    xkb_group_index_t grp;
+    xkb_layout_index_t grp;
     xkb_atom_t name;
 
     if (!arrayNdx) {
@@ -1121,7 +1121,7 @@ HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
 static bool
 SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
 {
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
 
     if (info->explicit_group == 0)
         return true;
@@ -1149,7 +1149,7 @@ static int
 HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
 {
     KeyInfo keyi;
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
 
     keyi = info->dflt;
     for (i = 0; i < XKB_NUM_GROUPS; i++) {
@@ -1282,7 +1282,7 @@ static struct xkb_key *
 FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym)
 {
     struct xkb_key *key, *ret = NULL;
-    xkb_group_index_t group, min_group = UINT32_MAX;
+    xkb_layout_index_t group, min_group = UINT32_MAX;
     xkb_level_index_t level, min_level = UINT16_MAX;
 
     xkb_foreach_key(key, keymap) {
@@ -1403,7 +1403,7 @@ FindAutomaticType(struct xkb_context *ctx, xkb_level_index_t width,
 static void
 PrepareKeyDef(KeyInfo *keyi)
 {
-    xkb_group_index_t i, lastGroup;
+    xkb_layout_index_t i, lastGroup;
     const GroupInfo *group0;
     bool identical;
 
@@ -1474,7 +1474,7 @@ CopySymbolsDef(SymbolsInfo *info, KeyInfo *keyi)
 {
     struct xkb_keymap *keymap = info->keymap;
     struct xkb_key *key;
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
     bool haveActions;
     unsigned int sizeSyms;
     unsigned int symIndex;
@@ -1676,7 +1676,7 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
 {
     KeyInfo *keyi;
     ModMapEntry *mm;
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
     struct xkb_key *key;
 
     keymap->symbols_section_name = strdup_safe(info->name);

diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c
index b09e3ef..17a16cf 100644 (file)
--- a/src/xkbcomp/vmod.c
+++ b/src/xkbcomp/vmod.c
@@ -32,7 +32,7 @@
 void
 InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
 {
-    xkb_group_index_t i;
+    xkb_layout_index_t i;
 
     memset(info, 0, sizeof(*info));
     for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++)

diff --git a/src/xkbcomp/xkbcomp.c b/src/xkbcomp/xkbcomp.c
index fd997d5..7da20d6 100644 (file)
--- a/src/xkbcomp/xkbcomp.c
+++ b/src/xkbcomp/xkbcomp.c
@@ -53,14 +53,14 @@ compile_keymap_file(struct xkb_context *ctx, XkbFile *file)
     return keymap;
 
 err:
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
     return NULL;
 }
 
 XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_names(struct xkb_context *ctx,
-                       const struct xkb_rule_names *rmlvo_in,
-                       enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_names(struct xkb_context *ctx,
+                          const struct xkb_rule_names *rmlvo_in,
+                          enum xkb_keymap_compile_flags flags)
 {
     bool ok;
     struct xkb_component_names kccgst;
@@ -117,10 +117,10 @@ xkb_map_new_from_names(struct xkb_context *ctx,
 }
 
 XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_string(struct xkb_context *ctx,
-                        const char *string,
-                        enum xkb_keymap_format format,
-                        enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_string(struct xkb_context *ctx,
+                           const char *string,
+                           enum xkb_keymap_format format,
+                           enum xkb_keymap_compile_flags flags)
 {
     bool ok;
     XkbFile *file;
@@ -148,10 +148,10 @@ xkb_map_new_from_string(struct xkb_context *ctx,
 }
 
 XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_file(struct xkb_context *ctx,
-                      FILE *file,
-                      enum xkb_keymap_format format,
-                      enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_file(struct xkb_context *ctx,
+                         FILE *file,
+                         enum xkb_keymap_format format,
+                         enum xkb_keymap_compile_flags flags)
 {
     bool ok;
     XkbFile *xkb_file;

diff --git a/test/common.c b/test/common.c
index 372c642..f960501 100644 (file)
--- a/test/common.c
+++ b/test/common.c
@@ -117,8 +117,8 @@ test_compile_file(struct xkb_context *context, const char *path_rel)
     }
     assert(file != NULL);
 
-    keymap = xkb_map_new_from_file(context, file,
-                                   XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+    keymap = xkb_keymap_new_from_file(context, file,
+                                      XKB_KEYMAP_FORMAT_TEXT_V1, 0);
     fclose(file);
 
     if (!keymap) {
@@ -136,8 +136,8 @@ test_compile_string(struct xkb_context *context, const char *string)
 {
     struct xkb_keymap *keymap;
 
-    keymap = xkb_map_new_from_string(context, string,
-                                     XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+    keymap = xkb_keymap_new_from_string(context, string,
+                                        XKB_KEYMAP_FORMAT_TEXT_V1, 0);
     if (!keymap) {
         fprintf(stderr, "Failed to compile string\n");
         return NULL;
@@ -160,7 +160,7 @@ test_compile_rules(struct xkb_context *context, const char *rules,
         .options = options
     };
 
-    keymap = xkb_map_new_from_names(context, &rmlvo, 0);
+    keymap = xkb_keymap_new_from_names(context, &rmlvo, 0);
     if (!keymap) {
         fprintf(stderr,
                 "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",

diff --git a/test/filecomp.c b/test/filecomp.c
index dca4fe5..1d7a127 100644 (file)
--- a/test/filecomp.c
+++ b/test/filecomp.c
@@ -31,7 +31,7 @@ test_file(struct xkb_context *ctx, const char *path_rel)
     if (!keymap)
         return 0;
 
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
     return 1;
 }
 

diff --git a/test/interactive.c b/test/interactive.c
index 332f57c..3d91dc6 100644 (file)
--- a/test/interactive.c
+++ b/test/interactive.c
@@ -221,14 +221,14 @@ print_keycode(struct keyboard *kbd, xkb_keycode_t keycode)
     unsigned int nsyms;
     char s[16];
     uint32_t unicode;
-    xkb_group_index_t group;
+    xkb_layout_index_t group;
     xkb_mod_index_t mod;
     xkb_led_index_t led;
 
     state = kbd->state;
-    keymap = xkb_state_get_map(state);
+    keymap = xkb_state_get_keymap(state);
 
-    nsyms = xkb_key_get_syms(state, keycode, &syms);
+    nsyms = xkb_state_key_get_syms(state, keycode, &syms);
 
     if (nsyms <= 0)
         return;
@@ -254,29 +254,29 @@ print_keycode(struct keyboard *kbd, xkb_keycode_t keycode)
 #endif
 
     printf("groups [ ");
-    for (group = 0; group < xkb_map_num_groups(keymap); group++) {
-        if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE))
+    for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
+        if (!xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE))
             continue;
-        printf("%s (%d) ", xkb_map_group_get_name(keymap, group), group);
+        printf("%s (%d) ", xkb_keymap_layout_get_name(keymap, group), group);
     }
     printf("] ");
 
     printf("mods [ ");
-    for (mod = 0; mod < xkb_map_num_mods(keymap); mod++) {
+    for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
         if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
             continue;
-        if (xkb_key_mod_index_is_consumed(state, keycode, mod))
-            printf("-%s ", xkb_map_mod_get_name(keymap, mod));
+        if (xkb_state_mod_index_is_consumed(state, keycode, mod))
+            printf("-%s ", xkb_keymap_mod_get_name(keymap, mod));
         else
-            printf("%s ", xkb_map_mod_get_name(keymap, mod));
+            printf("%s ", xkb_keymap_mod_get_name(keymap, mod));
     }
     printf("] ");
 
     printf("leds [ ");
-    for (led = 0; led < xkb_map_num_leds(keymap); led++) {
+    for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
         if (!xkb_state_led_index_is_active(state, led))
             continue;
-        printf("%s ", xkb_map_led_get_name(keymap, led));
+        printf("%s ", xkb_keymap_led_get_name(keymap, led));
     }
     printf("] ");
 
@@ -302,9 +302,9 @@ process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
         return;
 
     keycode = EVDEV_OFFSET + code;
-    keymap = xkb_state_get_map(kbd->state);
+    keymap = xkb_state_get_keymap(kbd->state);
 
-    if (value == KEY_STATE_REPEAT && !xkb_key_repeats(keymap, keycode))
+    if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
         return;
 
     if (value != KEY_STATE_RELEASE)
@@ -492,7 +492,7 @@ err_stty:
     system("stty echo");
     free_keyboards(kbds);
 err_xkb:
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
 err_ctx:
     xkb_context_unref(ctx);
 err_out:

diff --git a/test/keyseq.c b/test/keyseq.c
index 2e827fc..4508ab1 100644 (file)
--- a/test/keyseq.c
+++ b/test/keyseq.c
@@ -75,7 +75,7 @@ test_key_seq(struct xkb_keymap *keymap, ...)
         kc = va_arg(ap, int) + EVDEV_OFFSET;
         op = va_arg(ap, int);
 
-        nsyms = xkb_key_get_syms(state, kc, &syms);
+        nsyms = xkb_state_key_get_syms(state, kc, &syms);
         fprintf(stderr, "got %d syms for key 0x%x: [", nsyms, kc);
 
         if (op == DOWN || op == BOTH)
@@ -378,7 +378,7 @@ main(void)
 
                         KEY_V,           BOTH,  XKB_KEY_p,               FINISH));
 
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
     xkb_context_unref(ctx);
     return 0;
 }

diff --git a/test/print-compiled-keymap.c b/test/print-compiled-keymap.c
index 34be4d4..95bd85a 100644 (file)
--- a/test/print-compiled-keymap.c
+++ b/test/print-compiled-keymap.c
@@ -87,7 +87,7 @@ main(int argc, char *argv[])
         goto err_ctx;
     }
 
-    dump = xkb_map_get_as_string(keymap);
+    dump = xkb_keymap_get_as_string(keymap);
     if (!dump) {
         fprintf(stderr, "Couldn't get the keymap string\n");
         goto err_map;
@@ -98,7 +98,7 @@ main(int argc, char *argv[])
     ret = EXIT_SUCCESS;
     free(dump);
 err_map:
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
 err_ctx:
     xkb_context_unref(ctx);
 err_out:

diff --git a/test/rulescomp.c b/test/rulescomp.c
index 3fb8a30..1c16dc8 100644 (file)
--- a/test/rulescomp.c
+++ b/test/rulescomp.c
@@ -40,7 +40,7 @@ test_rmlvo(struct xkb_context *context, const char *rules,
         fprintf(stderr, "Compiled '%s' '%s' '%s' '%s' '%s'\n",
                 strnull(rules), strnull(model), strnull(layout),
                 strnull(variant), strnull(options));
-        xkb_map_unref(keymap);
+        xkb_keymap_unref(keymap);
     }
 
     return keymap != NULL;
@@ -56,7 +56,7 @@ test_rmlvo_silent(struct xkb_context *context, const char *rules,
     keymap = test_compile_rules(context, rules, model, layout, variant,
                                 options);
     if (keymap)
-        xkb_map_unref(keymap);
+        xkb_keymap_unref(keymap);
 
     return keymap != NULL;
 }

diff --git a/test/state.c b/test/state.c
index 367c686..cdb7583 100644 (file)
--- a/test/state.c
+++ b/test/state.c
@@ -28,7 +28,6 @@
 #include <stdlib.h>
 #include <linux/input.h>
 
-#include "xkbcommon/xkbcommon.h"
 #include "test.h"
 
 /* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
@@ -39,11 +38,11 @@ static void
 print_state(struct xkb_state *state)
 {
     struct xkb_keymap *keymap;
-    xkb_group_index_t group;
+    xkb_layout_index_t group;
     xkb_mod_index_t mod;
     xkb_led_index_t led;
 
-    group = xkb_state_serialize_group(state, XKB_STATE_EFFECTIVE);
+    group = xkb_state_serialize_layout(state, XKB_STATE_EFFECTIVE);
     mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
     /* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
     if (!group && !mod /* && !led */) {
@@ -51,29 +50,29 @@ print_state(struct xkb_state *state)
         return;
     }
 
-    keymap = xkb_state_get_map(state);
+    keymap = xkb_state_get_keymap(state);
 
-    for (group = 0; group < xkb_map_num_groups(keymap); group++) {
-        if (xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
+    for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
+        if (xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
             continue;
         fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
-                xkb_map_group_get_name(keymap, group),
+                xkb_keymap_layout_get_name(keymap, group),
                 group,
-                xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
+                xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
                     "effective " : "",
-                xkb_state_group_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
+                xkb_state_layout_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
                     "depressed " : "",
-                xkb_state_group_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
+                xkb_state_layout_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
                     "latched " : "",
-                xkb_state_group_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
+                xkb_state_layout_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
                     "locked " : "");
     }
 
-    for (mod = 0; mod < xkb_map_num_mods(keymap); mod++) {
+    for (mod = 0; mod < xkb_keymap_num_mods(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(keymap, mod),
+                xkb_keymap_mod_get_name(keymap, mod),
                 mod,
                 xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) > 0 ?
                     "depressed " : "",
@@ -83,11 +82,11 @@ print_state(struct xkb_state *state)
                     "locked " : "");
     }
 
-    for (led = 0; led < xkb_map_num_leds(keymap); led++) {
+    for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
         if (!xkb_state_led_index_is_active(state, led))
             continue;
         fprintf(stderr, "\tled %s (%d): active\n",
-                xkb_map_led_get_name(keymap, led),
+                xkb_keymap_led_get_name(keymap, led),
                 led);
     }
 }
@@ -123,8 +122,8 @@ test_update_key(struct xkb_keymap *keymap)
                                           NULL) > 0);
     assert(xkb_state_mod_indices_are_active(state, XKB_STATE_DEPRESSED,
                                           XKB_STATE_MATCH_ALL,
-                                          xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
-                                          xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT),
+                                          xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
+                                          xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT),
                                           XKB_MOD_INVALID) > 0);
     assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
                                            XKB_STATE_MATCH_ALL,
@@ -163,7 +162,7 @@ test_update_key(struct xkb_keymap *keymap)
     assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
                                         XKB_STATE_LOCKED) > 0);
     assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
-    num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
+    num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
     assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
 
     /* Caps unlocked */
@@ -172,7 +171,7 @@ test_update_key(struct xkb_keymap *keymap)
     assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
                                          XKB_STATE_EFFECTIVE) > 0);
     assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
-    num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
+    num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
     assert(num_syms == 1 && syms[0] == XKB_KEY_q);
 
     xkb_state_unref(state);
@@ -187,17 +186,17 @@ test_serialisation(struct xkb_keymap *keymap)
     xkb_mod_mask_t locked_mods;
     xkb_mod_mask_t effective_mods;
     xkb_mod_index_t caps, shift, ctrl;
-    xkb_group_index_t base_group = 0;
-    xkb_group_index_t latched_group = 0;
-    xkb_group_index_t locked_group = 0;
+    xkb_layout_index_t base_group = 0;
+    xkb_layout_index_t latched_group = 0;
+    xkb_layout_index_t locked_group = 0;
 
     assert(state);
 
-    caps = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+    caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
     assert(caps != XKB_MOD_INVALID);
-    shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+    shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
     assert(shift != XKB_MOD_INVALID);
-    ctrl = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
+    ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
     assert(ctrl != XKB_MOD_INVALID);
 
     xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
@@ -234,11 +233,11 @@ test_serialisation(struct xkb_keymap *keymap)
 static void
 test_repeat(struct xkb_keymap *keymap)
 {
-    assert(!xkb_key_repeats(keymap, KEY_LEFTSHIFT + 8));
-    assert(xkb_key_repeats(keymap, KEY_A + 8));
-    assert(xkb_key_repeats(keymap, KEY_8 + 8));
-    assert(xkb_key_repeats(keymap, KEY_DOWN + 8));
-    assert(xkb_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
+    assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + 8));
+    assert(xkb_keymap_key_repeats(keymap, KEY_A + 8));
+    assert(xkb_keymap_key_repeats(keymap, KEY_8 + 8));
+    assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + 8));
+    assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
 }
 
 static void
@@ -250,9 +249,9 @@ test_consume(struct xkb_keymap *keymap)
 
     assert(state);
 
-    alt = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT);
+    alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
     assert(alt != XKB_MOD_INVALID);
-    shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+    shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
     assert(shift != XKB_MOD_INVALID);
 
     xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
@@ -264,8 +263,8 @@ test_consume(struct xkb_keymap *keymap)
 
     mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
     assert(mask == ((1 << alt) | (1 << shift)));
-    mask = xkb_key_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
-                                            mask);
+    mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
+                                              mask);
     assert(mask == (1 << alt));
 
     xkb_state_unref(state);
@@ -287,6 +286,6 @@ main(void)
     test_repeat(keymap);
     test_consume(keymap);
 
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
     xkb_context_unref(context);
 }

diff --git a/test/stringcomp.c b/test/stringcomp.c
index 402b9a6..e00e92f 100644 (file)
--- a/test/stringcomp.c
+++ b/test/stringcomp.c
@@ -25,7 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "xkbcommon/xkbcommon.h"
 #include "test.h"
 
 #define DATA_PATH "keymaps/stringcomp.data"
@@ -48,7 +47,7 @@ main(int argc, char *argv[])
     keymap = test_compile_string(ctx, original);
     assert(keymap);
 
-    dump = xkb_map_get_as_string(keymap);
+    dump = xkb_keymap_get_as_string(keymap);
     assert(dump);
 
     if (!streq(original, dump)) {
@@ -66,7 +65,7 @@ main(int argc, char *argv[])
 
     free(original);
     free(dump);
-    xkb_map_unref(keymap);
+    xkb_keymap_unref(keymap);
 
     /* Make sure we can't (falsely claim to) compile an empty string. */
     keymap = test_compile_string(ctx, "");

diff --git a/test/test.h b/test/test.h
index 2a9b0fa..046b64e 100644 (file)
--- a/test/test.h
+++ b/test/test.h
@@ -25,6 +25,8 @@
 
 #include <assert.h>
 
+ /* Don't use compat names in internal code. */
+#define _XKBCOMMON_COMPAT_H
 #include "xkbcommon/xkbcommon.h"
 #include "utils.h"