From e7bb1e5fd99438b69bb7ce8c29de381d55c95b96 Mon Sep 17 00:00:00 2001 From: Ran Benita Date: Wed, 9 May 2012 15:03:11 +0300 Subject: [PATCH] Shorten context to ctx (This breaks the API.) "context" is really annoying to type all the time (and we're going to type it a lot more :). "ctx" is clear, concise and common in many other libraries. Use it! Signed-off-by: Ran Benita [daniels: Fix for xkb -> keymap change.] --- include/xkbcommon/xkbcommon.h | 38 ++++---- src/alloc.c | 6 +- src/alloc.h | 2 +- src/context.c | 116 +++++++++++------------ src/xkb-priv.h | 10 +- src/xkbcomp/action.c | 74 +++++++-------- src/xkbcomp/compat.c | 24 ++--- src/xkbcomp/expr.c | 172 +++++++++++++++++----------------- src/xkbcomp/expr.h | 32 +++---- src/xkbcomp/indicators.c | 44 ++++----- src/xkbcomp/indicators.h | 2 +- src/xkbcomp/keycodes.c | 22 ++--- src/xkbcomp/keymap.c | 4 +- src/xkbcomp/keytypes.c | 48 +++++----- src/xkbcomp/misc.c | 8 +- src/xkbcomp/parser.y | 28 +++--- src/xkbcomp/parseutils.c | 4 +- src/xkbcomp/parseutils.h | 10 +- src/xkbcomp/path.c | 12 +-- src/xkbcomp/scanner.l | 8 +- src/xkbcomp/symbols.c | 79 ++++++++-------- src/xkbcomp/vmod.c | 28 +++--- src/xkbcomp/xkbcomp-priv.h | 4 +- src/xkbcomp/xkbcomp.c | 50 +++++----- src/xkbcomp/xkbcomp.h | 2 +- test/context.c | 6 +- test/filecomp.c | 25 +++-- test/namescomp.c | 10 +- test/rulescomp.c | 12 +-- test/state.c | 10 +- 30 files changed, 444 insertions(+), 446 deletions(-) diff --git a/include/xkbcommon/xkbcommon.h b/include/xkbcommon/xkbcommon.h index c125562..9b6cce7 100644 --- a/include/xkbcommon/xkbcommon.h +++ b/include/xkbcommon/xkbcommon.h @@ -133,9 +133,9 @@ struct xkb_component_names { /** * Opaque context object; may only be created, accessed, manipulated and - * destroyed through the xkb_context_*() API. + * destroyed through the xkb_ctx_*() API. */ -struct xkb_context; +struct xkb_ctx; /** * Opaque keymap object; may only be created, accessed, manipulated and @@ -193,7 +193,7 @@ xkb_keysym_from_name(const char *s); * @{ */ -enum xkb_context_flags { +enum xkb_ctx_flags { /** Create this context with an empty include path. */ XKB_CONTEXT_NO_DEFAULT_INCLUDES = 1, }; @@ -201,10 +201,10 @@ enum xkb_context_flags { /** * Returns a new XKB context, or NULL on failure. If successful, the caller * holds a reference on the context, and must free it when finished with - * xkb_context_unref(). + * xkb_ctx_unref(). */ -struct xkb_context * -xkb_context_new(enum xkb_context_flags flags); +struct xkb_ctx * +xkb_ctx_new(enum xkb_ctx_flags flags); /** * Appends a new entry to the include path used for keymap compilation. @@ -212,7 +212,7 @@ xkb_context_new(enum xkb_context_flags flags); * inaccessible. */ int -xkb_context_include_path_append(struct xkb_context *context, const char *path); +xkb_ctx_include_path_append(struct xkb_ctx *ctx, const char *path); /** * Appends the default include paths to the context's current include path. @@ -220,7 +220,7 @@ xkb_context_include_path_append(struct xkb_context *context, const char *path); * added. */ int -xkb_context_include_path_append_default(struct xkb_context *context); +xkb_ctx_include_path_append_default(struct xkb_ctx *ctx); /** * Removes all entries from the context's include path, and inserts the @@ -228,37 +228,37 @@ xkb_context_include_path_append_default(struct xkb_context *context); * could not be added. */ int -xkb_context_include_path_reset_defaults(struct xkb_context *context); +xkb_ctx_include_path_reset_defaults(struct xkb_ctx *ctx); /** * Removes all entries from the context's include path. */ void -xkb_context_include_path_clear(struct xkb_context *context); +xkb_ctx_include_path_clear(struct xkb_ctx *ctx); /** * Returns the number of include paths currently active in the context. */ unsigned int -xkb_context_num_include_paths(struct xkb_context *context); +xkb_ctx_num_include_paths(struct xkb_ctx *ctx); /** * Returns the include path at the specified index within the context. */ const char * -xkb_context_include_path_get(struct xkb_context *context, unsigned int index); +xkb_ctx_include_path_get(struct xkb_ctx *ctx, unsigned int index); /** * Takes a new reference on an XKB context. */ -struct xkb_context * -xkb_context_ref(struct xkb_context *context); +struct xkb_ctx * +xkb_ctx_ref(struct xkb_ctx *ctx); /** * Releases a reference on an XKB context, and possibly frees it. */ void -xkb_context_unref(struct xkb_context *context); +xkb_ctx_unref(struct xkb_ctx *ctx); /** @} */ @@ -282,7 +282,7 @@ enum xkb_map_compile_flags { * keymaps. */ struct xkb_keymap * -xkb_map_new_from_names(struct xkb_context *context, +xkb_map_new_from_names(struct xkb_ctx *ctx, const struct xkb_rule_names *names, enum xkb_map_compile_flags flags); @@ -297,7 +297,7 @@ xkb_map_new_from_names(struct xkb_context *context, * Geometry will be ignored since xkbcommon does not support it in any way. */ struct xkb_keymap * -xkb_map_new_from_kccgst(struct xkb_context *context, +xkb_map_new_from_kccgst(struct xkb_ctx *ctx, const struct xkb_component_names *kccgst, enum xkb_map_compile_flags flags); @@ -311,7 +311,7 @@ enum xkb_keymap_format { * file descriptor. */ struct xkb_keymap * -xkb_map_new_from_fd(struct xkb_context *context, +xkb_map_new_from_fd(struct xkb_ctx *ctx, int fd, enum xkb_keymap_format format, enum xkb_map_compile_flags flags); @@ -320,7 +320,7 @@ xkb_map_new_from_fd(struct xkb_context *context, * enormous string. */ struct xkb_keymap * -xkb_map_new_from_string(struct xkb_context *context, +xkb_map_new_from_string(struct xkb_ctx *ctx, const char *string, enum xkb_keymap_format format, enum xkb_map_compile_flags flags); diff --git a/src/alloc.c b/src/alloc.c index 81a5b6c..09bba46 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -597,7 +597,7 @@ XkbcFreeIndicatorMaps(struct xkb_keymap *keymap) } struct xkb_keymap * -XkbcAllocKeyboard(struct xkb_context *context) +XkbcAllocKeyboard(struct xkb_ctx *ctx) { struct xkb_keymap *keymap; @@ -606,7 +606,7 @@ XkbcAllocKeyboard(struct xkb_context *context) return NULL; keymap->refcnt = 1; - keymap->context = xkb_context_ref(context); + keymap->ctx = xkb_ctx_ref(ctx); return keymap; } @@ -623,6 +623,6 @@ XkbcFreeKeyboard(struct xkb_keymap *keymap) XkbcFreeIndicatorMaps(keymap); XkbcFreeNames(keymap); XkbcFreeControls(keymap); - xkb_context_unref(keymap->context); + xkb_ctx_unref(keymap->ctx); free(keymap); } diff --git a/src/alloc.h b/src/alloc.h index d7c71d5..4a0bcca 100644 --- a/src/alloc.h +++ b/src/alloc.h @@ -43,7 +43,7 @@ extern int XkbcAllocIndicatorMaps(struct xkb_keymap *keymap); extern struct xkb_keymap * -XkbcAllocKeyboard(struct xkb_context *context); +XkbcAllocKeyboard(struct xkb_ctx *ctx); extern void XkbcFreeKeyboard(struct xkb_keymap *keymap); diff --git a/src/context.c b/src/context.c index bf3b07a..0d0e900 100644 --- a/src/context.c +++ b/src/context.c @@ -31,7 +31,7 @@ #include "xkb-priv.h" #include "atom.h" -struct xkb_context { +struct xkb_ctx { int refcnt; char **include_paths; @@ -48,23 +48,23 @@ struct xkb_context { * Append one directory to the context's include path. */ _X_EXPORT int -xkb_context_include_path_append(struct xkb_context *context, const char *path) +xkb_ctx_include_path_append(struct xkb_ctx *ctx, const char *path) { struct stat stat_buf; int err; - if (context->size_include_paths <= context->num_include_paths) { + if (ctx->size_include_paths <= ctx->num_include_paths) { int new_size; char **new_paths; - new_size = context->size_include_paths + 2; - new_paths = uTypedRecalloc(context->include_paths, - context->size_include_paths, + new_size = ctx->size_include_paths + 2; + new_paths = uTypedRecalloc(ctx->include_paths, + ctx->size_include_paths, new_size, char *); if (!new_paths) return 0; - context->include_paths = new_paths; - context->size_include_paths = new_size; + ctx->include_paths = new_paths; + ctx->size_include_paths = new_size; } err = stat(path, &stat_buf); @@ -75,10 +75,10 @@ xkb_context_include_path_append(struct xkb_context *context, const char *path) if (eaccess(path, R_OK | X_OK) != 0) return 0; - context->include_paths[context->num_include_paths] = strdup(path); - if (!context->include_paths[context->num_include_paths]) + ctx->include_paths[ctx->num_include_paths] = strdup(path); + if (!ctx->include_paths[ctx->num_include_paths]) return 0; - context->num_include_paths++; + ctx->num_include_paths++; return 1; } @@ -87,13 +87,13 @@ xkb_context_include_path_append(struct xkb_context *context, const char *path) * Append the default include directories to the context. */ _X_EXPORT int -xkb_context_include_path_append_default(struct xkb_context *context) +xkb_ctx_include_path_append_default(struct xkb_ctx *ctx) { const char *home = getenv("HOME"); char *user_path; int err; - (void) xkb_context_include_path_append(context, DFLT_XKB_CONFIG_ROOT); + (void) xkb_ctx_include_path_append(ctx, DFLT_XKB_CONFIG_ROOT); home = getenv("HOME"); if (!home) @@ -101,7 +101,7 @@ xkb_context_include_path_append_default(struct xkb_context *context) err = asprintf(&user_path, "%s/.xkb", home); if (err <= 0) return 1; - (void) xkb_context_include_path_append(context, user_path); + (void) xkb_ctx_include_path_append(ctx, user_path); free(user_path); return 1; @@ -111,36 +111,36 @@ xkb_context_include_path_append_default(struct xkb_context *context) * Remove all entries in the context's include path. */ _X_EXPORT void -xkb_context_include_path_clear(struct xkb_context *context) +xkb_ctx_include_path_clear(struct xkb_ctx *ctx) { int i; - for (i = 0; i < context->num_include_paths; i++) { - free(context->include_paths[i]); - context->include_paths[i] = NULL; + for (i = 0; i < ctx->num_include_paths; i++) { + free(ctx->include_paths[i]); + ctx->include_paths[i] = NULL; } - free(context->include_paths); - context->include_paths = NULL; - context->num_include_paths = 0; + free(ctx->include_paths); + ctx->include_paths = NULL; + ctx->num_include_paths = 0; } /** - * xkb_context_include_path_clear() + xkb_context_include_path_append_default() + * xkb_ctx_include_path_clear() + xkb_ctx_include_path_append_default() */ _X_EXPORT int -xkb_context_include_path_reset_defaults(struct xkb_context *context) +xkb_ctx_include_path_reset_defaults(struct xkb_ctx *ctx) { - xkb_context_include_path_clear(context); - return xkb_context_include_path_append_default(context); + xkb_ctx_include_path_clear(ctx); + return xkb_ctx_include_path_append_default(ctx); } /** * Returns the number of entries in the context's include path. */ _X_EXPORT unsigned int -xkb_context_num_include_paths(struct xkb_context *context) +xkb_ctx_num_include_paths(struct xkb_ctx *ctx) { - return context->num_include_paths; + return ctx->num_include_paths; } /** @@ -148,28 +148,28 @@ xkb_context_num_include_paths(struct xkb_context *context) * invalid index is passed. */ _X_EXPORT const char * -xkb_context_include_path_get(struct xkb_context *context, unsigned int idx) +xkb_ctx_include_path_get(struct xkb_ctx *ctx, unsigned int idx) { - if (idx >= xkb_context_num_include_paths(context)) + if (idx >= xkb_ctx_num_include_paths(ctx)) return NULL; - return context->include_paths[idx]; + return ctx->include_paths[idx]; } int -xkb_context_take_file_id(struct xkb_context *context) +xkb_ctx_take_file_id(struct xkb_ctx *ctx) { - return context->file_id++; + return ctx->file_id++; } /** * Take a new reference on the context. */ -_X_EXPORT struct xkb_context * -xkb_context_ref(struct xkb_context *context) +_X_EXPORT struct xkb_ctx * +xkb_ctx_ref(struct xkb_ctx *ctx) { - context->refcnt++; - return context; + ctx->refcnt++; + return ctx; } /** @@ -177,58 +177,58 @@ xkb_context_ref(struct xkb_context *context) * now 0. */ _X_EXPORT void -xkb_context_unref(struct xkb_context *context) +xkb_ctx_unref(struct xkb_ctx *ctx) { - if (--context->refcnt > 0) + if (--ctx->refcnt > 0) return; - xkb_context_include_path_clear(context); - atom_table_free(context->atom_table); - free(context); + xkb_ctx_include_path_clear(ctx); + atom_table_free(ctx->atom_table); + free(ctx); } /** * Create a new context. */ -_X_EXPORT struct xkb_context * -xkb_context_new(enum xkb_context_flags flags) +_X_EXPORT struct xkb_ctx * +xkb_ctx_new(enum xkb_ctx_flags flags) { - struct xkb_context *context = calloc(1, sizeof(*context)); + struct xkb_ctx *ctx = calloc(1, sizeof(*ctx)); - if (!context) + if (!ctx) return NULL; - context->refcnt = 1; + ctx->refcnt = 1; if (!(flags & XKB_CONTEXT_NO_DEFAULT_INCLUDES) && - !xkb_context_include_path_append_default(context)) { - xkb_context_unref(context); + !xkb_ctx_include_path_append_default(ctx)) { + xkb_ctx_unref(ctx); return NULL; } - context->atom_table = atom_table_new(); - if (!context->atom_table) { - xkb_context_unref(context); + ctx->atom_table = atom_table_new(); + if (!ctx->atom_table) { + xkb_ctx_unref(ctx); return NULL; } - return context; + return ctx; } xkb_atom_t -xkb_atom_intern(struct xkb_context *context, const char *string) +xkb_atom_intern(struct xkb_ctx *ctx, const char *string) { - return atom_intern(context->atom_table, string); + return atom_intern(ctx->atom_table, string); } char * -xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom) +xkb_atom_strdup(struct xkb_ctx *ctx, xkb_atom_t atom) { - return atom_strdup(context->atom_table, atom); + return atom_strdup(ctx->atom_table, atom); } const char * -xkb_atom_text(struct xkb_context *context, xkb_atom_t atom) +xkb_atom_text(struct xkb_ctx *ctx, xkb_atom_t atom) { - return atom_text(context->atom_table, atom); + return atom_text(ctx->atom_table, atom); } diff --git a/src/xkb-priv.h b/src/xkb-priv.h index 584447e..35f7f8a 100644 --- a/src/xkb-priv.h +++ b/src/xkb-priv.h @@ -358,7 +358,7 @@ struct xkb_controls { /* Common keyboard description structure */ struct xkb_keymap { - struct xkb_context *context; + struct xkb_ctx *ctx; unsigned int refcnt; unsigned short flags; @@ -431,13 +431,13 @@ typedef uint32_t xkb_atom_t; #define XKB_ATOM_NONE 0 xkb_atom_t -xkb_atom_intern(struct xkb_context *context, const char *string); +xkb_atom_intern(struct xkb_ctx *ctx, const char *string); char * -xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom); +xkb_atom_strdup(struct xkb_ctx *ctx, xkb_atom_t atom); const char * -xkb_atom_text(struct xkb_context *context, xkb_atom_t atom); +xkb_atom_text(struct xkb_ctx *ctx, xkb_atom_t atom); extern unsigned int xkb_key_get_group(struct xkb_state *state, xkb_keycode_t key); @@ -452,7 +452,7 @@ xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t key, const xkb_keysym_t **syms_out); extern int -xkb_context_take_file_id(struct xkb_context *context); +xkb_ctx_take_file_id(struct xkb_ctx *ctx); extern bool XkbcComputeEffectiveMap(struct xkb_keymap *keymap, struct xkb_key_type *type, diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c index 1c6eee1..1cd1815 100644 --- a/src/xkbcomp/action.c +++ b/src/xkbcomp/action.c @@ -222,7 +222,7 @@ CheckLatchLockFlags(struct xkb_keymap *keymap, unsigned action, tmp = XkbSA_LatchToLock; else return false; /* WSGO! */ - if (!ExprResolveBoolean(keymap->context, value, &result)) + if (!ExprResolveBoolean(keymap->ctx, value, &result)) return ReportMismatch(action, field, "boolean"); if (result.uval) *flags_inout |= tmp; @@ -240,7 +240,7 @@ CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value, if (value->op == ExprIdent) { const char *valStr; - valStr = xkb_atom_text(keymap->context, value->value.str); + valStr = xkb_atom_text(keymap->ctx, value->value.str); if (valStr && ((strcasecmp(valStr, "usemodmapmods") == 0) || (strcasecmp(valStr, "modmapmods") == 0))) { @@ -345,7 +345,7 @@ CheckGroupField(struct xkb_keymap *keymap, unsigned action, spec = value; } - if (!ExprResolveGroup(keymap->context, spec, &rtrn)) + if (!ExprResolveGroup(keymap->ctx, spec, &rtrn)) return ReportMismatch(action, F_Group, "integer (range 1..8)"); if (value->op == OpNegate) *grp_rtrn = -rtrn.ival; @@ -443,7 +443,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, absolute = false; else absolute = true; - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer"); if (field == F_X) { @@ -461,7 +461,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if (field == F_Accel) { - if (!ExprResolveBoolean(keymap->context, value, &rtrn)) + if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "boolean"); if (rtrn.uval) act->flags &= ~XkbSA_NoAcceleration; @@ -491,7 +491,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveButton(keymap->context, value, &rtrn)) + if (!ExprResolveButton(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer (range 1..5)"); if ((rtrn.ival < 0) || (rtrn.ival > 5)) @@ -507,7 +507,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveEnum(keymap->context, value, &rtrn, lockWhich)) + if (!ExprResolveEnum(keymap->ctx, value, &rtrn, lockWhich)) return ReportMismatch(action->type, field, "lock or unlock"); act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock); act->flags |= rtrn.ival; @@ -517,7 +517,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveButton(keymap->context, value, &rtrn)) + if (!ExprResolveButton(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -550,7 +550,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveEnum(keymap->context, value, &rtrn, ptrDflts)) + if (!ExprResolveEnum(keymap->ctx, value, &rtrn, ptrDflts)) return ReportMismatch(action->type, field, "pointer component"); act->affect = rtrn.uval; return true; @@ -571,7 +571,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, btn = value; } - if (!ExprResolveButton(keymap->context, btn, &rtrn)) + if (!ExprResolveButton(keymap->ctx, btn, &rtrn)) return ReportMismatch(action->type, field, "integer (range 1..5)"); if ((rtrn.ival < 0) || (rtrn.ival > 5)) @@ -647,7 +647,7 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Affect: if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, isoNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, isoNames)) return ReportMismatch(action->type, field, "keyboard component"); act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask; return true; @@ -679,7 +679,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, scrn = value; } - if (!ExprResolveInteger(keymap->context, scrn, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, scrn, &rtrn)) return ReportMismatch(action->type, field, "integer (0..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -697,7 +697,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveBoolean(keymap->context, value, &rtrn)) + if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "boolean"); if (rtrn.uval) act->flags &= ~XkbSA_SwitchApplication; @@ -741,7 +741,7 @@ HandleSetLockControls(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, ctrlNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, ctrlNames)) return ReportMismatch(action->type, field, "controls mask"); act->ctrls = rtrn.uval; return true; @@ -772,7 +772,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Report: if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, evNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, evNames)) return ReportMismatch(action->type, field, "key event mask"); act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease); act->flags = @@ -781,7 +781,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_GenKeyEvent: if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveBoolean(keymap->context, value, &rtrn)) + if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "boolean"); if (rtrn.uval) act->flags |= XkbSA_MessageGenKeyEvent; @@ -791,7 +791,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Data: if (array_ndx == NULL) { - if (!ExprResolveString(keymap->context, value, &rtrn)) + if (!ExprResolveString(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "string"); else { @@ -808,7 +808,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, else { unsigned ndx; - if (!ExprResolveInteger(keymap->context, array_ndx, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) { ERROR("Array subscript must be integer\n"); ACTION("Illegal subscript ignored\n"); @@ -821,7 +821,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, ACTION("Attempt to use data[%d] ignored\n", ndx); return false; } - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -853,7 +853,7 @@ HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action, switch (field) { case F_Keycode: - if (!ExprResolveKeyName(keymap->context, value, &rtrn)) + if (!ExprResolveKeyName(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "key name"); tmp = KeyNameToLong(rtrn.keyName.name); if (!FindNamedKey(keymap, tmp, &kc, true, CreateKeyNames(keymap), 0)) @@ -899,7 +899,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer (range 1..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) @@ -915,7 +915,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveEnum(keymap->context, value, &rtrn, lockWhich)) + if (!ExprResolveEnum(keymap->ctx, value, &rtrn, lockWhich)) return ReportMismatch(action->type, field, "lock or unlock"); act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock); act->flags |= rtrn.ival; @@ -925,7 +925,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveButton(keymap->context, value, &rtrn)) + if (!ExprResolveButton(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -940,7 +940,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { if (array_ndx != NULL) return ReportActionNotArray(action->type, field); - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer (range 1..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) @@ -978,7 +978,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, switch (field) { case F_Type: - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(PrivateAction, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -991,7 +991,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Data: if (array_ndx == NULL) { - if (!ExprResolveString(keymap->context, value, &rtrn)) + if (!ExprResolveString(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "string"); else { @@ -1010,7 +1010,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, else { unsigned ndx; - if (!ExprResolveInteger(keymap->context, array_ndx, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) { ERROR("Array subscript must be integer\n"); ACTION("Illegal subscript ignored\n"); @@ -1023,7 +1023,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, ACTION("Attempt to use data[%d] ignored\n", ndx); return false; } - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportMismatch(action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { @@ -1085,7 +1085,7 @@ ApplyActionFactoryDefaults(union xkb_action * action) } static void -ActionsInit(struct xkb_context *context); +ActionsInit(struct xkb_ctx *ctx); int HandleActionDef(ExprDef * def, @@ -1097,7 +1097,7 @@ HandleActionDef(ExprDef * def, unsigned tmp, hndlrType; if (!actionsInitialized) - ActionsInit(keymap->context); + ActionsInit(keymap->ctx); if (def->op != ExprActionDecl) { @@ -1105,7 +1105,7 @@ HandleActionDef(ExprDef * def, exprOpText(def->op)); return false; } - str = xkb_atom_text(keymap->context, def->value.action.name); + str = xkb_atom_text(keymap->ctx, def->value.action.name); if (!str) { WSGO("Missing name in action definition!!\n"); @@ -1153,13 +1153,13 @@ HandleActionDef(ExprDef * def, if ((arg->op == OpNot) || (arg->op == OpInvert)) { field = arg->value.child; - constFalse.value.str = xkb_atom_intern(keymap->context, "false"); + constFalse.value.str = xkb_atom_intern(keymap->ctx, "false"); value = &constFalse; } else { field = arg; - constTrue.value.str = xkb_atom_intern(keymap->context, "true"); + constTrue.value.str = xkb_atom_intern(keymap->ctx, "true"); value = &constTrue; } } @@ -1202,7 +1202,7 @@ SetActionField(struct xkb_keymap *keymap, ActionInfo *new, *old; if (!actionsInitialized) - ActionsInit(keymap->context); + ActionsInit(keymap->ctx); new = uTypedAlloc(ActionInfo); if (new == NULL) @@ -1249,7 +1249,7 @@ SetActionField(struct xkb_keymap *keymap, /***====================================================================***/ static void -ActionsInit(struct xkb_context *context) +ActionsInit(struct xkb_ctx *ctx) { if (!actionsInitialized) { @@ -1259,12 +1259,12 @@ ActionsInit(struct xkb_context *context) constTrue.common.next = NULL; constTrue.op = ExprIdent; constTrue.type = TypeBoolean; - constTrue.value.str = xkb_atom_intern(context, "true"); + constTrue.value.str = xkb_atom_intern(ctx, "true"); constFalse.common.stmtType = StmtExpr; constFalse.common.next = NULL; constFalse.op = ExprIdent; constFalse.type = TypeBoolean; - constFalse.value.str = xkb_atom_intern(context, "false"); + constFalse.value.str = xkb_atom_intern(ctx, "false"); actionsInitialized = 1; } } diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c index af5c600..e9b6c14 100644 --- a/src/xkbcomp/compat.c +++ b/src/xkbcomp/compat.c @@ -115,7 +115,7 @@ InitCompatInfo(CompatInfo *info, struct xkb_keymap *keymap) info->dflt.interp.act.type = XkbSA_NoAction; for (i = 0; i < sizeof(info->dflt.interp.act.any.data); i++) info->dflt.interp.act.any.data[i] = 0; - ClearIndicatorMapInfo(keymap->context, &info->ledDflt); + ClearIndicatorMapInfo(keymap->ctx, &info->ledDflt); info->ledDflt.defs.fileID = info->fileID; info->ledDflt.defs.defined = 0; info->ledDflt.defs.merge = MergeOverride; @@ -140,7 +140,7 @@ ClearCompatInfo(CompatInfo *info, struct xkb_keymap *keymap) info->dflt.interp.act.type = XkbSA_NoAction; for (i = 0; i < sizeof(info->dflt.interp.act.any.data); i++) info->dflt.interp.act.any.data[i] = 0; - ClearIndicatorMapInfo(keymap->context, &info->ledDflt); + ClearIndicatorMapInfo(keymap->ctx, &info->ledDflt); info->nInterps = 0; info->interps = (SymInterpInfo *) ClearCommonInfo(&info->interps->defs); memset(&info->groupCompat[0], 0, @@ -299,7 +299,7 @@ ResolveStateAndPredicate(ExprDef * expr, *pred_rtrn = XkbSI_Exactly; if (expr->op == ExprActionDecl) { - const char *pred_txt = xkb_atom_text(info->keymap->context, + const char *pred_txt = xkb_atom_text(info->keymap->ctx, expr->value.action.name); if (strcasecmp(pred_txt, "noneof") == 0) *pred_rtrn = XkbSI_NoneOf; @@ -321,7 +321,7 @@ ResolveStateAndPredicate(ExprDef * expr, } else if (expr->op == ExprIdent) { - const char *pred_txt = xkb_atom_text(info->keymap->context, + const char *pred_txt = xkb_atom_text(info->keymap->ctx, expr->value.str); if ((pred_txt) && (strcasecmp(pred_txt, "any") == 0)) { @@ -331,7 +331,7 @@ ResolveStateAndPredicate(ExprDef * expr, } } - if (ExprResolveModMask(info->keymap->context, expr, &result)) + if (ExprResolveModMask(info->keymap->ctx, expr, &result)) { *mods_rtrn = result.uval; return true; @@ -405,8 +405,8 @@ HandleIncludeCompatMap(IncludeStmt *stmt, struct xkb_keymap *keymap, included = *info; memset(info, 0, sizeof(CompatInfo)); } - else if (ProcessIncludeFile(keymap->context, stmt, XkmCompatMapIndex, - &rtrn, &newMerge)) + else if (ProcessIncludeFile(keymap->ctx, stmt, XkmCompatMapIndex, &rtrn, + &newMerge)) { InitCompatInfo(&included, keymap); included.fileID = rtrn->id; @@ -446,8 +446,8 @@ HandleIncludeCompatMap(IncludeStmt *stmt, struct xkb_keymap *keymap, MergeIncludedCompatMaps(&included, info, next->merge); ClearCompatInfo(info, keymap); } - else if (ProcessIncludeFile(keymap->context, next, - XkmCompatMapIndex, &rtrn, &op)) + else if (ProcessIncludeFile(keymap->ctx, next, XkmCompatMapIndex, + &rtrn, &op)) { InitCompatInfo(&next_incl, keymap); next_incl.fileID = rtrn->id; @@ -522,7 +522,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ExprResolveBoolean(keymap->context, value, &tmp); + ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (ok) { if (tmp.uval) @@ -538,7 +538,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ExprResolveBoolean(keymap->context, value, &tmp); + ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (ok) { if (tmp.uval) @@ -555,7 +555,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ExprResolveEnum(keymap->context, value, &tmp, useModMapValues); + ok = ExprResolveEnum(keymap->ctx, value, &tmp, useModMapValues); if (ok) { if (tmp.uval) diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c index 1353a28..1b4411c 100644 --- a/src/xkbcomp/expr.c +++ b/src/xkbcomp/expr.c @@ -28,7 +28,7 @@ /***====================================================================***/ -typedef bool (*IdentLookupFunc) (struct xkb_context *context, const void *priv, +typedef bool (*IdentLookupFunc) (struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn); @@ -137,21 +137,21 @@ ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr, { case ExprIdent: elem_rtrn->str = NULL; - field_rtrn->str = xkb_atom_strdup(keymap->context, + field_rtrn->str = xkb_atom_strdup(keymap->ctx, expr->value.str); *index_rtrn = NULL; return true; case ExprFieldRef: - elem_rtrn->str = xkb_atom_strdup(keymap->context, + elem_rtrn->str = xkb_atom_strdup(keymap->ctx, expr->value.field.element); - field_rtrn->str = xkb_atom_strdup(keymap->context, + field_rtrn->str = xkb_atom_strdup(keymap->ctx, expr->value.field.field); *index_rtrn = NULL; return true; case ExprArrayRef: - elem_rtrn->str = xkb_atom_strdup(keymap->context, + elem_rtrn->str = xkb_atom_strdup(keymap->ctx, expr->value.array.element); - field_rtrn->str = xkb_atom_strdup(keymap->context, + field_rtrn->str = xkb_atom_strdup(keymap->ctx, expr->value.array.field); *index_rtrn = expr->value.array.entry; return true; @@ -161,7 +161,7 @@ ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr, } static bool -SimpleLookup(struct xkb_context *context, const void *priv, +SimpleLookup(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn) { const LookupEntry *entry; @@ -171,7 +171,7 @@ SimpleLookup(struct xkb_context *context, const void *priv, { return false; } - str = xkb_atom_text(context, field); + str = xkb_atom_text(ctx, field); for (entry = priv; (entry != NULL) && (entry->name != NULL); entry++) { if (strcasecmp(str, entry->name) == 0) @@ -197,14 +197,14 @@ static const LookupEntry modIndexNames[] = { }; bool -LookupModIndex(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupModIndex(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn) { - return SimpleLookup(context, modIndexNames, field, type, val_rtrn); + return SimpleLookup(ctx, modIndexNames, field, type, val_rtrn); } bool -LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupModMask(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn) { const char *str; @@ -212,14 +212,14 @@ LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, if (type != TypeInt) return false; - str = xkb_atom_text(context, field); + str = xkb_atom_text(ctx, field); if (str == NULL) return false; if (strcasecmp(str, "all") == 0) val_rtrn->uval = 0xff; else if (strcasecmp(str, "none") == 0) val_rtrn->uval = 0; - else if (LookupModIndex(context, priv, field, type, val_rtrn)) + else if (LookupModIndex(ctx, priv, field, type, val_rtrn)) val_rtrn->uval = (1 << val_rtrn->uval); else ret = false; @@ -227,7 +227,7 @@ LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, } int -ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, +ExprResolveBoolean(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { int ok = 0; @@ -246,7 +246,7 @@ ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, val_rtrn->ival = expr->value.ival; return true; case ExprIdent: - bogus = xkb_atom_text(context, expr->value.str); + bogus = xkb_atom_text(ctx, expr->value.str); if (bogus) { if ((strcasecmp(bogus, "true") == 0) || @@ -265,16 +265,16 @@ ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, } } ERROR("Identifier \"%s\" of type int is unknown\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return false; case ExprFieldRef: ERROR("Default \"%s.%s\" of type boolean is unknown\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case OpInvert: case OpNot: - ok = ExprResolveBoolean(context, expr, val_rtrn); + ok = ExprResolveBoolean(ctx, expr, val_rtrn); if (ok) val_rtrn->uval = !val_rtrn->uval; return ok; @@ -309,7 +309,7 @@ ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, } int -ExprResolveFloat(struct xkb_context *context, ExprDef *expr, +ExprResolveFloat(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { int ok = 0; @@ -322,7 +322,7 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, if (expr->type == TypeString) { const char *str; - str = xkb_atom_text(context, expr->value.str); + str = xkb_atom_text(ctx, expr->value.str); if ((str != NULL) && (strlen(str) == 1)) { val_rtrn->uval = str[0] * XkbGeomPtsPerMM; @@ -341,12 +341,12 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, return true; case ExprIdent: ERROR("Numeric identifier \"%s\" unknown\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return ok; case ExprFieldRef: ERROR("Numeric default \"%s.%s\" unknown\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case OpAdd: case OpSubtract: @@ -354,8 +354,8 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, case OpDivide: left = expr->value.binary.left; right = expr->value.binary.right; - if (ExprResolveFloat(context, left, &leftRtrn) && - ExprResolveFloat(context, right, &rightRtrn)) + if (ExprResolveFloat(ctx, left, &leftRtrn) && + ExprResolveFloat(ctx, right, &rightRtrn)) { switch (expr->op) { @@ -384,7 +384,7 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, case OpInvert: case OpNegate: left = expr->value.child; - if (ExprResolveFloat(context, left, &leftRtrn)) + if (ExprResolveFloat(ctx, left, &leftRtrn)) { if (expr->op == OpNegate) val_rtrn->ival = -leftRtrn.ival; @@ -395,7 +395,7 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, return false; case OpUnaryPlus: left = expr->value.child; - return ExprResolveFloat(context, left, val_rtrn); + return ExprResolveFloat(ctx, left, val_rtrn); default: WSGO("Unknown operator %d in ResolveFloat\n", expr->op); break; @@ -404,7 +404,7 @@ ExprResolveFloat(struct xkb_context *context, ExprDef *expr, } int -ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, +ExprResolveKeyCode(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { ExprResult leftRtrn, rightRtrn; @@ -428,8 +428,8 @@ ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, case OpDivide: left = expr->value.binary.left; right = expr->value.binary.right; - if (ExprResolveKeyCode(context, left, &leftRtrn) && - ExprResolveKeyCode(context, right, &rightRtrn)) + if (ExprResolveKeyCode(ctx, left, &leftRtrn) && + ExprResolveKeyCode(ctx, right, &rightRtrn)) { switch (expr->op) { @@ -451,7 +451,7 @@ ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, return false; case OpNegate: left = expr->value.child; - if (ExprResolveKeyCode(context, left, &leftRtrn)) + if (ExprResolveKeyCode(ctx, left, &leftRtrn)) { val_rtrn->uval = ~leftRtrn.uval; return true; @@ -459,7 +459,7 @@ ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, return false; case OpUnaryPlus: left = expr->value.child; - return ExprResolveKeyCode(context, left, val_rtrn); + return ExprResolveKeyCode(ctx, left, val_rtrn); default: WSGO("Unknown operator %d in ResolveKeyCode\n", expr->op); break; @@ -470,9 +470,9 @@ ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, /** * This function returns ... something. It's a bit of a guess, really. * - * If a string is given in value context, its first character will be - * returned in uval. If an integer is given in value context, it will be - * returned in ival. If a float is given in value context, it will be + * If a string is given in value ctx, its first character will be + * returned in uval. If an integer is given in value ctx, it will be + * returned in ival. If a float is given in value ctx, it will be * returned as millimetres (rather than points) in ival. * * If an ident or field reference is given, the lookup function (if given) @@ -482,7 +482,7 @@ ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, * Cool. */ static int -ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, +ExprResolveIntegerLookup(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, IdentLookupFunc lookup, const void *lookupPriv) { @@ -496,7 +496,7 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, if (expr->type == TypeString) { const char *str; - str = xkb_atom_text(context, expr->value.str); + str = xkb_atom_text(ctx, expr->value.str); if (str != NULL) switch (strlen(str)) { @@ -521,16 +521,16 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, return true; case ExprIdent: if (lookup) - ok = lookup(context, lookupPriv, expr->value.str, + ok = lookup(ctx, lookupPriv, expr->value.str, TypeInt, val_rtrn); if (!ok) ERROR("Identifier \"%s\" of type int is unknown\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return ok; case ExprFieldRef: ERROR("Default \"%s.%s\" of type int is unknown\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case OpAdd: case OpSubtract: @@ -538,8 +538,8 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, case OpDivide: left = expr->value.binary.left; right = expr->value.binary.right; - if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup, lookupPriv) && - ExprResolveIntegerLookup(context, right, &rightRtrn, lookup, lookupPriv)) + if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, lookupPriv) && + ExprResolveIntegerLookup(ctx, right, &rightRtrn, lookup, lookupPriv)) { switch (expr->op) { @@ -568,7 +568,7 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, case OpInvert: case OpNegate: left = expr->value.child; - if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup, + if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, lookupPriv)) { if (expr->op == OpNegate) @@ -580,7 +580,7 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, return false; case OpUnaryPlus: left = expr->value.child; - return ExprResolveIntegerLookup(context, left, val_rtrn, lookup, + return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup, lookupPriv); default: WSGO("Unknown operator %d in ResolveInteger\n", expr->op); @@ -590,14 +590,14 @@ ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr, } int -ExprResolveInteger(struct xkb_context *context, ExprDef *expr, +ExprResolveInteger(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { - return ExprResolveIntegerLookup(context, expr, val_rtrn, NULL, NULL); + return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL); } int -ExprResolveGroup(struct xkb_context *context, ExprDef *expr, +ExprResolveGroup(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { int ret; @@ -613,7 +613,7 @@ ExprResolveGroup(struct xkb_context *context, ExprDef *expr, { NULL, 0 } }; - ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup, + ret = ExprResolveIntegerLookup(ctx, expr, val_rtrn, SimpleLookup, group_names); if (ret == false) return ret; @@ -628,7 +628,7 @@ ExprResolveGroup(struct xkb_context *context, ExprDef *expr, } int -ExprResolveLevel(struct xkb_context *context, ExprDef *expr, +ExprResolveLevel(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { int ret; @@ -644,7 +644,7 @@ ExprResolveLevel(struct xkb_context *context, ExprDef *expr, { NULL, 0 } }; - ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup, + ret = ExprResolveIntegerLookup(ctx, expr, val_rtrn, SimpleLookup, level_names); if (ret == false) return ret; @@ -659,7 +659,7 @@ ExprResolveLevel(struct xkb_context *context, ExprDef *expr, } int -ExprResolveButton(struct xkb_context *context, ExprDef *expr, +ExprResolveButton(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { static const LookupEntry button_names[] = { @@ -672,12 +672,12 @@ ExprResolveButton(struct xkb_context *context, ExprDef *expr, { NULL, 0 } }; - return ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup, + return ExprResolveIntegerLookup(ctx, expr, val_rtrn, SimpleLookup, button_names); } int -ExprResolveString(struct xkb_context *context, ExprDef *expr, +ExprResolveString(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { ExprResult leftRtrn, rightRtrn; @@ -694,24 +694,24 @@ ExprResolveString(struct xkb_context *context, ExprDef *expr, exprTypeText(expr->type)); return false; } - val_rtrn->str = xkb_atom_strdup(context, expr->value.str); + val_rtrn->str = xkb_atom_strdup(ctx, expr->value.str); if (val_rtrn->str == NULL) val_rtrn->str = strdup(""); return true; case ExprIdent: ERROR("Identifier \"%s\" of type string not found\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return false; case ExprFieldRef: ERROR("Default \"%s.%s\" of type string not found\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case OpAdd: left = expr->value.binary.left; right = expr->value.binary.right; - if (ExprResolveString(context, left, &leftRtrn) && - ExprResolveString(context, right, &rightRtrn)) + if (ExprResolveString(ctx, left, &leftRtrn) && + ExprResolveString(ctx, right, &rightRtrn)) { int len; char *new; @@ -762,7 +762,7 @@ ExprResolveString(struct xkb_context *context, ExprDef *expr, } int -ExprResolveKeyName(struct xkb_context *context, ExprDef *expr, +ExprResolveKeyName(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { const char *bogus = NULL; @@ -780,12 +780,12 @@ ExprResolveKeyName(struct xkb_context *context, ExprDef *expr, return true; case ExprIdent: ERROR("Identifier \"%s\" of type string not found\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return false; case ExprFieldRef: ERROR("Default \"%s.%s\" of type key name not found\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case OpAdd: if (bogus == NULL) @@ -826,7 +826,7 @@ ExprResolveKeyName(struct xkb_context *context, ExprDef *expr, /***====================================================================***/ int -ExprResolveEnum(struct xkb_context *context, ExprDef *expr, +ExprResolveEnum(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, const LookupEntry *values) { if (expr->op != ExprIdent) @@ -835,11 +835,11 @@ ExprResolveEnum(struct xkb_context *context, ExprDef *expr, exprOpText(expr->op)); return false; } - if (!SimpleLookup(context, values, expr->value.str, TypeInt, val_rtrn)) + if (!SimpleLookup(ctx, values, expr->value.str, TypeInt, val_rtrn)) { int nOut = 0; ERROR("Illegal identifier %s (expected one of: ", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); while (values && values->name) { if (nOut != 0) @@ -856,7 +856,7 @@ ExprResolveEnum(struct xkb_context *context, ExprDef *expr, } static int -ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, +ExprResolveMaskLookup(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, IdentLookupFunc lookup, const void *lookupPriv) { @@ -878,15 +878,15 @@ ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, val_rtrn->ival = expr->value.ival; return true; case ExprIdent: - ok = lookup(context, lookupPriv, expr->value.str, TypeInt, val_rtrn); + ok = lookup(ctx, lookupPriv, expr->value.str, TypeInt, val_rtrn); if (!ok) ERROR("Identifier \"%s\" of type int is unknown\n", - xkb_atom_text(context, expr->value.str)); + xkb_atom_text(ctx, expr->value.str)); return ok; case ExprFieldRef: ERROR("Default \"%s.%s\" of type int is unknown\n", - xkb_atom_text(context, expr->value.field.element), - xkb_atom_text(context, expr->value.field.field)); + xkb_atom_text(ctx, expr->value.field.element), + xkb_atom_text(ctx, expr->value.field.field)); return false; case ExprArrayRef: bogus = "array reference"; @@ -902,8 +902,8 @@ ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, case OpDivide: left = expr->value.binary.left; right = expr->value.binary.right; - if (ExprResolveMaskLookup(context, left, &leftRtrn, lookup, lookupPriv) && - ExprResolveMaskLookup(context, right, &rightRtrn, lookup, lookupPriv)) + if (ExprResolveMaskLookup(ctx, left, &leftRtrn, lookup, lookupPriv) && + ExprResolveMaskLookup(ctx, right, &rightRtrn, lookup, lookupPriv)) { switch (expr->op) { @@ -928,7 +928,7 @@ ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, break; case OpInvert: left = expr->value.child; - if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup, + if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, lookupPriv)) { val_rtrn->ival = ~leftRtrn.ival; @@ -939,7 +939,7 @@ ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, case OpNegate: case OpNot: left = expr->value.child; - if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup, + if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, lookupPriv)) { ERROR("The %s operator cannot be used with a mask\n", @@ -954,29 +954,29 @@ ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr, } int -ExprResolveMask(struct xkb_context *context, ExprDef *expr, +ExprResolveMask(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, const LookupEntry *values) { - return ExprResolveMaskLookup(context, expr, val_rtrn, SimpleLookup, values); + return ExprResolveMaskLookup(ctx, expr, val_rtrn, SimpleLookup, values); } int -ExprResolveModMask(struct xkb_context *context, ExprDef *expr, +ExprResolveModMask(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { - return ExprResolveMaskLookup(context, expr, val_rtrn, LookupModMask, NULL); + return ExprResolveMaskLookup(ctx, expr, val_rtrn, LookupModMask, NULL); } int ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn, struct xkb_keymap *keymap) { - return ExprResolveMaskLookup(keymap->context, expr, val_rtrn, - LookupVModMask, keymap); + return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask, + keymap); } int -ExprResolveKeySym(struct xkb_context *context, ExprDef *expr, +ExprResolveKeySym(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn) { int ok = 0; @@ -985,7 +985,7 @@ ExprResolveKeySym(struct xkb_context *context, ExprDef *expr, if (expr->op == ExprIdent) { const char *str; - str = xkb_atom_text(context, expr->value.str); + str = xkb_atom_text(ctx, expr->value.str); if (str) { sym = xkb_keysym_from_name(str); if (sym != XKB_KEYSYM_NO_SYMBOL) { @@ -994,7 +994,7 @@ ExprResolveKeySym(struct xkb_context *context, ExprDef *expr, } } } - ok = ExprResolveInteger(context, expr, val_rtrn); + ok = ExprResolveInteger(ctx, expr, val_rtrn); if ((ok) && (val_rtrn->uval < 10)) val_rtrn->uval += '0'; return ok; diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h index 9582234..29b46e5 100644 --- a/src/xkbcomp/expr.h +++ b/src/xkbcomp/expr.h @@ -53,19 +53,19 @@ extern const char * exprOpText(unsigned type); extern bool -LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupModMask(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn); extern bool -LookupVModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupVModMask(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn); extern bool -LookupModIndex(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupModIndex(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn); extern int -ExprResolveModMask(struct xkb_context *context, ExprDef *expr, +ExprResolveModMask(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int @@ -73,51 +73,51 @@ ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn, struct xkb_keymap *keymap); extern int -ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, +ExprResolveBoolean(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, +ExprResolveKeyCode(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveInteger(struct xkb_context *context, ExprDef *expr, +ExprResolveInteger(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveLevel(struct xkb_context *context, ExprDef *expr, +ExprResolveLevel(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveGroup(struct xkb_context *context, ExprDef *expr, +ExprResolveGroup(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveButton(struct xkb_context *context, ExprDef *expr, +ExprResolveButton(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveFloat(struct xkb_context *context, ExprDef *expr, +ExprResolveFloat(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveString(struct xkb_context *context, ExprDef *expr, +ExprResolveString(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveKeyName(struct xkb_context *context, ExprDef *expr, +ExprResolveKeyName(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); extern int -ExprResolveEnum(struct xkb_context *context, ExprDef *expr, +ExprResolveEnum(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, const LookupEntry *values); extern int -ExprResolveMask(struct xkb_context *context, ExprDef *expr, +ExprResolveMask(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn, const LookupEntry *values); extern int -ExprResolveKeySym(struct xkb_context *context, ExprDef *expr, +ExprResolveKeySym(struct xkb_ctx *ctx, ExprDef *expr, ExprResult *val_rtrn); #endif /* EXPR_H */ diff --git a/src/xkbcomp/indicators.c b/src/xkbcomp/indicators.c index 746a7ed..4d76a2b 100644 --- a/src/xkbcomp/indicators.c +++ b/src/xkbcomp/indicators.c @@ -32,17 +32,17 @@ #define ReportIndicatorBadType(keymap, l, f, w) \ ReportBadType("indicator map", (f), \ - xkb_atom_text((keymap)->context, (l)->name), (w)) + xkb_atom_text((keymap)->ctx, (l)->name), (w)) #define ReportIndicatorNotArray(keymap, l, f) \ ReportNotArray("indicator map", (f), \ - xkb_atom_text((keymap)->context, (l)->name)) + xkb_atom_text((keymap)->ctx, (l)->name)) /***====================================================================***/ void -ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo * info) +ClearIndicatorMapInfo(struct xkb_ctx *ctx, LEDInfo * info) { - info->name = xkb_atom_intern(context, "default"); + info->name = xkb_atom_intern(ctx, "default"); info->indicator = _LED_NotBound; info->flags = info->which_mods = info->real_mods = 0; info->vmods = 0; @@ -78,7 +78,7 @@ AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *new) && (warningLevel > 0)) || (warningLevel > 9)) { WARN("Map for indicator %s redefined\n", - xkb_atom_text(keymap->context, old->name)); + xkb_atom_text(keymap->ctx, old->name)); ACTION("Earlier definition ignored\n"); } *old = *new; @@ -130,7 +130,7 @@ AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *new) if (collide) { WARN("Map for indicator %s redefined\n", - xkb_atom_text(keymap->context, old->name)); + xkb_atom_text(keymap->ctx, old->name)); ACTION("Using %s definition for duplicate fields\n", (new->defs.merge == MergeAugment ? "first" : "last")); } @@ -145,7 +145,7 @@ AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *new) { WSGO("Couldn't allocate indicator map\n"); ACTION("Map for indicator %s not compiled\n", - xkb_atom_text(keymap->context, new->name)); + xkb_atom_text(keymap->ctx, new->name)); return NULL; } *old = *new; @@ -215,7 +215,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, groupNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, groupNames)) return ReportIndicatorBadType(keymap, led, field, "group mask"); led->groups = rtrn.uval; led->defs.defined |= _LED_Groups; @@ -225,7 +225,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, ctrlNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, ctrlNames)) return ReportIndicatorBadType(keymap, led, field, "controls mask"); led->ctrls = rtrn.uval; @@ -235,7 +235,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveBoolean(keymap->context, value, &rtrn)) + if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) return ReportIndicatorBadType(keymap, led, field, "boolean"); if (rtrn.uval) led->flags &= ~XkbIM_NoExplicit; @@ -248,7 +248,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, modComponentNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, modComponentNames)) { return ReportIndicatorBadType(keymap, led, field, "mask of modifier state components"); @@ -259,7 +259,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveMask(keymap->context, value, &rtrn, groupComponentNames)) + if (!ExprResolveMask(keymap->ctx, value, &rtrn, groupComponentNames)) { return ReportIndicatorBadType(keymap, led, field, "mask of group state components"); @@ -275,7 +275,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveBoolean(keymap->context, value, &rtrn)) + if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) return ReportIndicatorBadType(keymap, led, field, "boolean"); if (rtrn.uval) led->flags |= XkbIM_LEDDrivesKB; @@ -287,7 +287,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, { if (arrayNdx != NULL) return ReportIndicatorNotArray(keymap, led, field); - if (!ExprResolveInteger(keymap->context, value, &rtrn)) + if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) return ReportIndicatorBadType(keymap, led, field, "indicator index"); if ((rtrn.uval < 1) || (rtrn.uval > 32)) @@ -295,7 +295,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, ERROR("Illegal indicator index %d (range 1..%d)\n", rtrn.uval, XkbNumIndicators); ACTION("Index definition for %s indicator ignored\n", - xkb_atom_text(keymap->context, led->name)); + xkb_atom_text(keymap->ctx, led->name)); return false; } led->indicator = rtrn.uval; @@ -304,7 +304,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, else { ERROR("Unknown field %s in map for %s indicator\n", field, - xkb_atom_text(keymap->context, led->name)); + xkb_atom_text(keymap->ctx, led->name)); ACTION("Definition ignored\n"); ok = false; } @@ -420,7 +420,7 @@ CopyIndicatorMapDefs(struct xkb_keymap *keymap, LEDInfo *leds, { free(UNCONSTIFY(keymap->names->indicators[led->indicator - 1])); keymap->names->indicators[led->indicator-1] = - xkb_atom_strdup(keymap->context, led->name); + xkb_atom_strdup(keymap->ctx, led->name); } free(led); } @@ -449,7 +449,7 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, { if (keymap->names->indicators[i] && strcmp(keymap->names->indicators[i], - xkb_atom_text(keymap->context, led->name)) == 0) + xkb_atom_text(keymap->ctx, led->name)) == 0) { led->indicator = i + 1; break; @@ -468,7 +468,7 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, if (keymap->names->indicators[i] == NULL) { keymap->names->indicators[i] = - xkb_atom_strdup(keymap->context, led->name); + xkb_atom_strdup(keymap->ctx, led->name); led->indicator = i + 1; break; } @@ -478,7 +478,7 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, ERROR("No unnamed indicators found\n"); ACTION ("Virtual indicator map \"%s\" not bound\n", - xkb_atom_text(keymap->context, led->name)); + xkb_atom_text(keymap->ctx, led->name)); continue; } } @@ -508,13 +508,13 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, { if ((keymap->names != NULL) && (strcmp(keymap->names->indicators[led->indicator - 1], - xkb_atom_text(keymap->context, led->name)) != 0)) + xkb_atom_text(keymap->ctx, led->name)) != 0)) { 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, - xkb_atom_text(keymap->context, led->name)); + xkb_atom_text(keymap->ctx, led->name)); led->indicator = _LED_NotBound; if (force) { diff --git a/src/xkbcomp/indicators.h b/src/xkbcomp/indicators.h index d2c8899..b0ed415 100644 --- a/src/xkbcomp/indicators.h +++ b/src/xkbcomp/indicators.h @@ -54,7 +54,7 @@ typedef struct _LEDInfo } LEDInfo; extern void -ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo *info); +ClearIndicatorMapInfo(struct xkb_ctx *ctx, LEDInfo *info); extern LEDInfo * diff --git a/src/xkbcomp/keycodes.c b/src/xkbcomp/keycodes.c index 6bdf7fd..cca2688 100644 --- a/src/xkbcomp/keycodes.c +++ b/src/xkbcomp/keycodes.c @@ -208,7 +208,7 @@ AddIndicatorName(KeyNamesInfo *info, struct xkb_keymap *keymap, || (warningLevel > 9)) { WARN("Multiple indicators named %s\n", - xkb_atom_text(keymap->context, new->name)); + xkb_atom_text(keymap->ctx, new->name)); if (old->ndx == new->ndx) { if (old->virtual != new->virtual) @@ -286,8 +286,8 @@ AddIndicatorName(KeyNamesInfo *info, struct xkb_keymap *keymap, ignoring = new->name; } ACTION("Using %s %s, ignoring %s %s\n", - oldType, xkb_atom_text(keymap->context, using), - newType, xkb_atom_text(keymap->context, ignoring)); + oldType, xkb_atom_text(keymap->ctx, using), + newType, xkb_atom_text(keymap->ctx, ignoring)); } } if (replace) @@ -565,8 +565,8 @@ HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, info->explicitMax = XKB_KEYCODE_MAX; return (info->errorCount == 0); } /* parse file, store returned info in the xkb struct */ - else if (ProcessIncludeFile(keymap->context, stmt, XkmKeyNamesIndex, - &rtrn, &newMerge)) + else if (ProcessIncludeFile(keymap->ctx, stmt, XkmKeyNamesIndex, &rtrn, + &newMerge)) { InitKeyNamesInfo(&included); HandleKeycodesFile(rtrn, keymap, MergeOverride, &included); @@ -598,8 +598,8 @@ HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, MergeIncludedKeycodes(&included, keymap, info, next->merge); ClearKeyNamesInfo(info); } - else if (ProcessIncludeFile(keymap->context, next, - XkmKeyNamesIndex, &rtrn, &op)) + else if (ProcessIncludeFile(keymap->ctx, next, XkmKeyNamesIndex, + &rtrn, &op)) { InitKeyNamesInfo(&next_incl); HandleKeycodesFile(rtrn, keymap, MergeOverride, &next_incl); @@ -694,7 +694,7 @@ HandleKeyNameVar(VarDef *stmt, struct xkb_keymap *keymap, KeyNamesInfo *info) goto err_out; } - if (ExprResolveKeyCode(keymap->context, stmt->value, &tmp) == 0) + if (ExprResolveKeyCode(keymap->ctx, stmt->value, &tmp) == 0) { ACTION("Assignment to field %s ignored\n", field.str); goto err_out; @@ -771,14 +771,14 @@ HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *keymap, } InitIndicatorNameInfo(&ii, info); ii.ndx = def->ndx; - if (!ExprResolveString(keymap->context, def->name, &tmp)) + if (!ExprResolveString(keymap->ctx, def->name, &tmp)) { char buf[20]; snprintf(buf, sizeof(buf), "%d", def->ndx); info->errorCount++; return ReportBadType("indicator", "name", buf, "string"); } - ii.name = xkb_atom_intern(keymap->context, tmp.str); + ii.name = xkb_atom_intern(keymap->ctx, tmp.str); free(tmp.str); ii.virtual = def->virtual; if (!AddIndicatorName(info, keymap, &ii)) @@ -913,7 +913,7 @@ CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) for (ii = info.leds; ii; ii = (IndicatorNameInfo *)ii->defs.next) { free(UNCONSTIFY(keymap->names->indicators[ii->ndx - 1])); keymap->names->indicators[ii->ndx - 1] = - xkb_atom_strdup(keymap->context, ii->name); + xkb_atom_strdup(keymap->ctx, ii->name); } } diff --git a/src/xkbcomp/keymap.c b/src/xkbcomp/keymap.c index f6e77ea..58141e0 100644 --- a/src/xkbcomp/keymap.c +++ b/src/xkbcomp/keymap.c @@ -33,7 +33,7 @@ * XkmKeyNamesIdx, etc.) */ struct xkb_keymap * -CompileKeymap(struct xkb_context *context, XkbFile *file) +CompileKeymap(struct xkb_ctx *ctx, XkbFile *file) { unsigned have; bool ok; @@ -41,7 +41,7 @@ CompileKeymap(struct xkb_context *context, XkbFile *file) unsigned mainType; const char *mainName; LEDInfo *unbound = NULL, *next; - struct xkb_keymap *keymap = XkbcAllocKeyboard(context); + struct xkb_keymap *keymap = XkbcAllocKeyboard(ctx); struct { XkbFile *keycodes; XkbFile *types; diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c index f94a45c..4e4ac04 100644 --- a/src/xkbcomp/keytypes.c +++ b/src/xkbcomp/keytypes.c @@ -94,7 +94,7 @@ static xkb_atom_t tok_KEYPAD; #define PreserveTxt(x, p) \ XkbcVModMaskText((x), (p)->preMods, (p)->preVMods) #define TypeTxt(keymap, t) \ - xkb_atom_text((keymap)->context, (t)->name) + xkb_atom_text((keymap)->ctx, (t)->name) #define TypeMaskTxt(t, x) \ XkbcVModMaskText((x), (t)->mask, (t)->vmask) @@ -104,10 +104,10 @@ static void InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap, KeyTypesInfo *from) { - tok_ONE_LEVEL = xkb_atom_intern(keymap->context, "ONE_LEVEL"); - tok_TWO_LEVEL = xkb_atom_intern(keymap->context, "TWO_LEVEL"); - tok_ALPHABETIC = xkb_atom_intern(keymap->context, "ALPHABETIC"); - tok_KEYPAD = xkb_atom_intern(keymap->context, "KEYPAD"); + tok_ONE_LEVEL = xkb_atom_intern(keymap->ctx, "ONE_LEVEL"); + tok_TWO_LEVEL = xkb_atom_intern(keymap->ctx, "TWO_LEVEL"); + tok_ALPHABETIC = xkb_atom_intern(keymap->ctx, "ALPHABETIC"); + tok_KEYPAD = xkb_atom_intern(keymap->ctx, "KEYPAD"); info->name = strdup("default"); info->errorCount = 0; info->stdPresent = 0; @@ -289,7 +289,7 @@ AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new) && (warningLevel > 0)) || (warningLevel > 9)) { WARN("Multiple definitions of the %s key type\n", - xkb_atom_text(keymap->context, new->name)); + xkb_atom_text(keymap->ctx, new->name)); ACTION("Earlier definition ignored\n"); } FreeKeyTypeInfo(old); @@ -305,7 +305,7 @@ AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new) if (report) { WARN("Multiple definitions of the %s key type\n", - xkb_atom_text(keymap->context, new->name)); + xkb_atom_text(keymap->ctx, new->name)); ACTION("Later definition ignored\n"); } FreeKeyTypeInfo(new); @@ -371,7 +371,7 @@ HandleIncludeKeyTypes(IncludeStmt *stmt, struct xkb_keymap *keymap, included = *info; memset(info, 0, sizeof(KeyTypesInfo)); } - else if (ProcessIncludeFile(keymap->context, stmt, XkmTypesIndex, &rtrn, + else if (ProcessIncludeFile(keymap->ctx, stmt, XkmTypesIndex, &rtrn, &newMerge)) { InitKeyTypesInfo(&included, keymap, info); @@ -406,7 +406,7 @@ HandleIncludeKeyTypes(IncludeStmt *stmt, struct xkb_keymap *keymap, MergeIncludedKeyTypes(&included, info, next->merge, keymap); FreeKeyTypesInfo(info); } - else if (ProcessIncludeFile(keymap->context, next, XkmTypesIndex, + else if (ProcessIncludeFile(keymap->ctx, next, XkmTypesIndex, &rtrn, &op)) { InitKeyTypesInfo(&next_incl, keymap, &included); @@ -659,7 +659,7 @@ SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, entry.mods.real_mods &= type->mask; entry.mods.vmods &= type->vmask; } - if (!ExprResolveLevel(keymap->context, value, &rtrn)) + if (!ExprResolveLevel(keymap->ctx, value, &rtrn)) { ERROR("Level specifications in a key type must be integer\n"); ACTION("Ignoring malformed level specification\n"); @@ -761,8 +761,8 @@ AddLevelName(struct xkb_keymap *keymap, KeyTypeInfo *type, if (warningLevel > 0) { const char *old, *new; - old = xkb_atom_text(keymap->context, type->lvlNames[level]); - new = xkb_atom_text(keymap->context, name); + old = xkb_atom_text(keymap->ctx, type->lvlNames[level]); + new = xkb_atom_text(keymap->ctx, name); WARN("Multiple names for level %d of key type %s\n", level + 1, TypeTxt(keymap, type)); if (clobber) @@ -789,17 +789,17 @@ SetLevelName(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, if (arrayNdx == NULL) return ReportTypeShouldBeArray(keymap, type, "level name"); - if (!ExprResolveLevel(keymap->context, arrayNdx, &rtrn)) + if (!ExprResolveLevel(keymap->ctx, arrayNdx, &rtrn)) return ReportTypeBadType(keymap, type, "level name", "integer"); level = rtrn.ival - 1; - if (!ExprResolveString(keymap->context, value, &rtrn)) + if (!ExprResolveString(keymap->ctx, value, &rtrn)) { ERROR("Non-string name for level %d in key type %s\n", level + 1, - xkb_atom_text(keymap->context, type->name)); + xkb_atom_text(keymap->ctx, type->name)); ACTION("Ignoring illegal level name definition\n"); return false; } - level_name = xkb_atom_intern(keymap->context, rtrn.str); + level_name = xkb_atom_intern(keymap->ctx, rtrn.str); free(rtrn.str); return AddLevelName(keymap, type, level, level_name, true); } @@ -838,7 +838,7 @@ SetKeyTypeField(KeyTypeInfo *type, struct xkb_keymap *keymap, if (type->defs.defined & _KT_Mask) { WARN("Multiple modifier mask definitions for key type %s\n", - xkb_atom_text(keymap->context, type->name)); + xkb_atom_text(keymap->ctx, type->name)); ACTION("Using %s, ", TypeMaskTxt(type, keymap)); INFO("ignoring %s\n", XkbcVModMaskText(keymap, mods, vmods)); return false; @@ -1102,7 +1102,7 @@ CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type, { WARN("Couldn't allocate preserve array in CopyDefToKeyType\n"); ACTION("Preserve setting for type %s lost\n", - xkb_atom_text(keymap->context, def->name)); + xkb_atom_text(keymap->ctx, def->name)); } else { @@ -1118,7 +1118,7 @@ CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type, } else type->preserve = NULL; - type->name = xkb_atom_strdup(keymap->context, def->name); + type->name = xkb_atom_strdup(keymap->ctx, def->name); if (def->szNames > 0) { type->level_names = uTypedCalloc(def->numLevels, const char *); @@ -1126,7 +1126,7 @@ CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type, /* assert def->szNames<=def->numLevels */ for (i = 0; i < def->szNames; i++) { - type->level_names[i] = xkb_atom_strdup(keymap->context, + type->level_names[i] = xkb_atom_strdup(keymap->ctx, def->lvlNames[i]); } } @@ -1186,16 +1186,16 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) if (missing & XkbOneLevelMask) keymap->map->types[XkbOneLevelIndex].name = - xkb_atom_strdup(keymap->context, tok_ONE_LEVEL); + xkb_atom_strdup(keymap->ctx, tok_ONE_LEVEL); if (missing & XkbTwoLevelMask) keymap->map->types[XkbTwoLevelIndex].name = - xkb_atom_strdup(keymap->context, tok_TWO_LEVEL); + xkb_atom_strdup(keymap->ctx, tok_TWO_LEVEL); if (missing & XkbAlphabeticMask) keymap->map->types[XkbAlphabeticIndex].name = - xkb_atom_strdup(keymap->context, tok_ALPHABETIC); + xkb_atom_strdup(keymap->ctx, tok_ALPHABETIC); if (missing & XkbKeypadMask) keymap->map->types[XkbKeypadIndex].name = - xkb_atom_strdup(keymap->context, tok_KEYPAD); + xkb_atom_strdup(keymap->ctx, tok_KEYPAD); } next = &keymap->map->types[XkbLastRequiredType + 1]; diff --git a/src/xkbcomp/misc.c b/src/xkbcomp/misc.c index 7072adc..8802283 100644 --- a/src/xkbcomp/misc.c +++ b/src/xkbcomp/misc.c @@ -35,7 +35,7 @@ * If the statement defines a specific map to use, this map is returned in * file_rtrn. Otherwise, the default map is returned. * - * @param context The context containing include paths + * @param ctx The ctx containing include paths * @param stmt The include statement, specifying the file name to look for. * @param file_type Type of file (XkmKeyNamesIdx, etc.) * @param file_rtrn Returns the key map to be used. @@ -44,7 +44,7 @@ * @return true on success or false otherwise. */ bool -ProcessIncludeFile(struct xkb_context *context, +ProcessIncludeFile(struct xkb_ctx *ctx, IncludeStmt * stmt, unsigned file_type, XkbFile ** file_rtrn, unsigned *merge_rtrn) @@ -52,7 +52,7 @@ ProcessIncludeFile(struct xkb_context *context, FILE *file; XkbFile *rtrn, *mapToUse, *next; - file = XkbFindFileInPath(context, stmt->file, file_type, &stmt->path); + file = XkbFindFileInPath(ctx, stmt->file, file_type, &stmt->path); if (file == NULL) { ERROR("Can't find file \"%s\" for %s include\n", stmt->file, @@ -61,7 +61,7 @@ ProcessIncludeFile(struct xkb_context *context, } - if (!XKBParseFile(context, file, stmt->file, &rtrn)) + if (!XKBParseFile(ctx, file, stmt->file, &rtrn)) { ERROR("Error interpreting include file \"%s\"\n", stmt->file); fclose(file); diff --git a/src/xkbcomp/parser.y b/src/xkbcomp/parser.y index df9232c..2810a13 100644 --- a/src/xkbcomp/parser.y +++ b/src/xkbcomp/parser.y @@ -176,7 +176,7 @@ XkbCompositeMap : OptFlags XkbCompositeType OptMapName OBRACE XkbMapConfigList CBRACE SEMI { - $$ = CreateXKBFile(param->context, $2, $3, + $$ = CreateXKBFile(param->ctx, $2, $3, &$5->common, $1); } ; @@ -209,7 +209,7 @@ XkbMapConfig : OptFlags FileType OptMapName OBRACE } else { - $$ = CreateXKBFile(param->context, $2, $3, $5, $1); + $$ = CreateXKBFile(param->ctx, $2, $3, $5, $1); } } ; @@ -224,7 +224,7 @@ XkbConfig : OptFlags FileType OptMapName DeclList } else { - $$ = CreateXKBFile(param->context, $2, $3, $4, $1); + $$ = CreateXKBFile(param->ctx, $2, $3, $4, $1); } } ; @@ -563,21 +563,21 @@ FieldSpec : Ident { $$= $1; } ; Element : ACTION_TOK - { $$= xkb_atom_intern(param->context, "action"); } + { $$= xkb_atom_intern(param->ctx, "action"); } | INTERPRET - { $$= xkb_atom_intern(param->context, "interpret"); } + { $$= xkb_atom_intern(param->ctx, "interpret"); } | TYPE - { $$= xkb_atom_intern(param->context, "type"); } + { $$= xkb_atom_intern(param->ctx, "type"); } | KEY - { $$= xkb_atom_intern(param->context, "key"); } + { $$= xkb_atom_intern(param->ctx, "key"); } | GROUP - { $$= xkb_atom_intern(param->context, "group"); } + { $$= xkb_atom_intern(param->ctx, "group"); } | MODIFIER_MAP - {$$= xkb_atom_intern(param->context, "modifier_map");} + {$$= xkb_atom_intern(param->ctx, "modifier_map");} | INDICATOR - { $$= xkb_atom_intern(param->context, "indicator"); } + { $$= xkb_atom_intern(param->ctx, "indicator"); } | SHAPE - { $$= xkb_atom_intern(param->context, "shape"); } + { $$= xkb_atom_intern(param->ctx, "shape"); } | ROW { $$= XKB_ATOM_NONE; } | SECTION @@ -769,18 +769,18 @@ KeyName : KEYNAME { $$= $1; } Ident : IDENT { - $$ = xkb_atom_intern(param->context, $1); + $$ = xkb_atom_intern(param->ctx, $1); free($1); } | DEFAULT { - $$ = xkb_atom_intern(param->context, "default"); + $$ = xkb_atom_intern(param->ctx, "default"); } ; String : STRING { - $$ = xkb_atom_intern(param->context, $1); + $$ = xkb_atom_intern(param->ctx, $1); free($1); } ; diff --git a/src/xkbcomp/parseutils.c b/src/xkbcomp/parseutils.c index b22a3d5..8be29cb 100644 --- a/src/xkbcomp/parseutils.c +++ b/src/xkbcomp/parseutils.c @@ -684,7 +684,7 @@ EnsureSafeMapName(char *name) } XkbFile * -CreateXKBFile(struct xkb_context *context, int type, char *name, +CreateXKBFile(struct xkb_ctx *ctx, int type, char *name, ParseCommon *defs, unsigned flags) { XkbFile *file; @@ -698,7 +698,7 @@ CreateXKBFile(struct xkb_context *context, int type, char *name, file->topName = uDupString(name); file->name = name; file->defs = defs; - file->id = xkb_context_take_file_id(context); + file->id = xkb_ctx_take_file_id(ctx); file->flags = flags; } return file; diff --git a/src/xkbcomp/parseutils.h b/src/xkbcomp/parseutils.h index ed706c5..eed6da4 100644 --- a/src/xkbcomp/parseutils.h +++ b/src/xkbcomp/parseutils.h @@ -33,7 +33,7 @@ #include "parser.h" struct parser_param { - struct xkb_context *context; + struct xkb_ctx *ctx; void *scanner; XkbFile *rtrn; }; @@ -120,16 +120,16 @@ extern void CheckDefaultMap(XkbFile *maps, const char *fileName); extern XkbFile * -CreateXKBFile(struct xkb_context *context, int type, char *name, +CreateXKBFile(struct xkb_ctx *ctx, int type, char *name, ParseCommon *defs, unsigned flags); extern bool -XKBParseFile(struct xkb_context *context, FILE *file, +XKBParseFile(struct xkb_ctx *ctx, FILE *file, const char *file_name, XkbFile **out); extern bool -XKBParseString(struct xkb_context *context, const char *string, - const char *file_name, XkbFile **out); +XKBParseString(struct xkb_ctx *context, const char *string, + const char *file_name, XkbFile **out); extern void FreeXKBFile(XkbFile *file); diff --git a/src/xkbcomp/path.c b/src/xkbcomp/path.c index 326e497..e10d3cf 100644 --- a/src/xkbcomp/path.c +++ b/src/xkbcomp/path.c @@ -174,7 +174,7 @@ XkbDirectoryForInclude(unsigned type) /** * Search for the given file name in the include directories. * - * @param context the XKB context containing the include paths + * @param ctx the XKB ctx containing the include paths * @param type one of XkbTypesIndex, XkbCompatMapIndex, ..., or * XkbSemanticsFile, XkmKeymapFile, ... * @param pathReturn is set to the full path of the file if found. @@ -183,7 +183,7 @@ XkbDirectoryForInclude(unsigned type) * pathRtrn is undefined. */ FILE * -XkbFindFileInPath(struct xkb_context *context, +XkbFindFileInPath(struct xkb_ctx *ctx, const char *name, unsigned type, char **pathRtrn) { size_t i; @@ -193,21 +193,21 @@ XkbFindFileInPath(struct xkb_context *context, const char *typeDir; typeDir = XkbDirectoryForInclude(type); - for (i = 0; i < xkb_context_num_include_paths(context); i++) + for (i = 0; i < xkb_ctx_num_include_paths(ctx); i++) { ret = snprintf(buf, sizeof(buf), "%s/%s/%s", - xkb_context_include_path_get(context, i), typeDir, name); + xkb_ctx_include_path_get(ctx, i), typeDir, name); if (ret >= (ssize_t)sizeof(buf)) { ERROR("File name (%s/%s/%s) too long\n", - xkb_context_include_path_get(context, i), typeDir, name); + xkb_ctx_include_path_get(ctx, i), typeDir, name); ACTION("Ignored\n"); continue; } file = fopen(buf, "r"); if (file == NULL) { ERROR("Couldn't open file (%s/%s/%s): %s\n", - xkb_context_include_path_get(context, i), typeDir, name, + xkb_ctx_include_path_get(ctx, i), typeDir, name, strerror(-errno)); ACTION("Ignored\n"); continue; diff --git a/src/xkbcomp/scanner.l b/src/xkbcomp/scanner.l index 7711d82..f105c0e 100644 --- a/src/xkbcomp/scanner.l +++ b/src/xkbcomp/scanner.l @@ -205,7 +205,7 @@ yyerror(struct YYLTYPE *loc, void *scanner, const char *msg) } bool -XKBParseString(struct xkb_context *context, const char *string, +XKBParseString(struct xkb_ctx *ctx, const char *string, const char *file_name, XkbFile **out) { int ret; @@ -216,7 +216,7 @@ XKBParseString(struct xkb_context *context, const char *string, if (string == NULL) return false; - param.context = context; + param.ctx = ctx; memset(&extra, 0, sizeof(extra)); ret = yylex_init_extra(&extra, ¶m.scanner); @@ -241,7 +241,7 @@ XKBParseString(struct xkb_context *context, const char *string, } bool -XKBParseFile(struct xkb_context *context, FILE *file, +XKBParseFile(struct xkb_ctx *ctx, FILE *file, const char *file_name, XkbFile **out) { int ret; @@ -251,7 +251,7 @@ XKBParseFile(struct xkb_context *context, FILE *file, if (!file) return false; - param.context = context; + param.ctx = ctx; memset(&extra, 0, sizeof(extra)); ret = yylex_init_extra(&extra, ¶m.scanner); diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c index b56e012..23e65ab 100644 --- a/src/xkbcomp/symbols.c +++ b/src/xkbcomp/symbols.c @@ -663,8 +663,8 @@ MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap, ("Multiple definitions for group %d type of key %s\n", i, longText(into->name)); ACTION("Using %s, ignoring %s\n", - xkb_atom_text(keymap->context, use), - xkb_atom_text(keymap->context, ignore)); + xkb_atom_text(keymap->ctx, use), + xkb_atom_text(keymap->ctx, ignore)); } if ((from->defs.merge != MergeAugment) || (into->types[i] == XKB_ATOM_NONE)) @@ -889,8 +889,8 @@ HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap, included = *info; memset(info, 0, sizeof(SymbolsInfo)); } - else if (ProcessIncludeFile(keymap->context, stmt, XkmSymbolsIndex, - &rtrn, &newMerge)) + else if (ProcessIncludeFile(keymap->ctx, stmt, XkmSymbolsIndex, &rtrn, + &newMerge)) { InitSymbolsInfo(&included, keymap); included.fileID = included.dflt.defs.fileID = rtrn->id; @@ -931,8 +931,8 @@ HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap, MergeIncludedSymbols(&included, info, next->merge, keymap); FreeSymbolsInfo(info); } - else if (ProcessIncludeFile(keymap->context, next, - XkmSymbolsIndex, &rtrn, &op)) + else if (ProcessIncludeFile(keymap->ctx, next, XkmSymbolsIndex, + &rtrn, &op)) { InitSymbolsInfo(&next_incl, keymap); next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id; @@ -1009,7 +1009,7 @@ GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap, ACTION("Ignoring %s defined for extra groups\n", name); return false; } - if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp)) + if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp)) { ERROR("Illegal group index for %s of key %s\n", name, longText(key->name)); @@ -1070,7 +1070,7 @@ AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap, &key->syms[ndx][key->symsMapIndex[ndx][i] + j])) { WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n", value->value.list.syms[i], longText(key->name), ndx + 1, - xkb_atom_text(keymap->context, info->groupNames[ndx]), nSyms); + xkb_atom_text(keymap->ctx, info->groupNames[ndx]), nSyms); while (--j >= 0) key->syms[ndx][key->symsMapIndex[ndx][i] + j] = NoSymbol; key->symsMapIndex[ndx][i] = -1; @@ -1181,7 +1181,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, if (strcasecmp(field, "type") == 0) { ExprResult ndx; - if ((!ExprResolveString(keymap->context, value, &tmp)) + if ((!ExprResolveString(keymap->ctx, value, &tmp)) && (warningLevel > 0)) { WARN("The type field of a key symbol map must be a string\n"); @@ -1189,10 +1189,10 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, } if (arrayNdx == NULL) { - key->dfltType = xkb_atom_intern(keymap->context, tmp.str); + key->dfltType = xkb_atom_intern(keymap->ctx, tmp.str); key->defs.defined |= _Key_Type_Dflt; } - else if (!ExprResolveGroup(keymap->context, arrayNdx, &ndx)) + else if (!ExprResolveGroup(keymap->ctx, arrayNdx, &ndx)) { ERROR("Illegal group index for type of key %s\n", longText(key->name)); @@ -1202,8 +1202,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, } else { - key->types[ndx.uval - 1] = xkb_atom_intern(keymap->context, - tmp.str); + key->types[ndx.uval - 1] = xkb_atom_intern(keymap->ctx, tmp.str); key->typesDefined |= (1 << (ndx.uval - 1)); } free(tmp.str); @@ -1234,7 +1233,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, (strcasecmp(field, "lock") == 0) || (strcasecmp(field, "locks") == 0)) { - ok = ExprResolveEnum(keymap->context, value, &tmp, lockingEntries); + ok = ExprResolveEnum(keymap->ctx, value, &tmp, lockingEntries); if (ok) key->behavior.type = tmp.uval; key->defs.defined |= _Key_Behavior; @@ -1257,7 +1256,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, (strcasecmp(field, "repeats") == 0) || (strcasecmp(field, "repeat") == 0)) { - ok = ExprResolveEnum(keymap->context, value, &tmp, repeatEntries); + ok = ExprResolveEnum(keymap->ctx, value, &tmp, repeatEntries); if (!ok) { ERROR("Illegal repeat setting for %s\n", @@ -1271,7 +1270,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, else if ((strcasecmp(field, "groupswrap") == 0) || (strcasecmp(field, "wrapgroups") == 0)) { - ok = ExprResolveBoolean(keymap->context, value, &tmp); + ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (!ok) { ERROR("Illegal groupsWrap setting for %s\n", @@ -1288,7 +1287,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, else if ((strcasecmp(field, "groupsclamp") == 0) || (strcasecmp(field, "clampgroups") == 0)) { - ok = ExprResolveBoolean(keymap->context, value, &tmp); + ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (!ok) { ERROR("Illegal groupsClamp setting for %s\n", @@ -1305,7 +1304,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, else if ((strcasecmp(field, "groupsredirect") == 0) || (strcasecmp(field, "redirectgroups") == 0)) { - if (!ExprResolveGroup(keymap->context, value, &tmp)) + if (!ExprResolveGroup(keymap->ctx, value, &tmp)) { ERROR("Illegal group index for redirect of key %s\n", longText(key->name)); @@ -1337,20 +1336,20 @@ SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx, ACTION("Group name definition without array subscript ignored\n"); return false; } - if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp)) + if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp)) { ERROR("Illegal index in group name definition\n"); ACTION("Definition with non-integer array index ignored\n"); return false; } - if (!ExprResolveString(keymap->context, value, &name)) + if (!ExprResolveString(keymap->ctx, value, &name)) { ERROR("Group name must be a string\n"); ACTION("Illegal name for group %d ignored\n", tmp.uval); return false; } info->groupNames[tmp.uval - 1 + info->explicit_group] = - xkb_atom_intern(keymap->context, name.str); + xkb_atom_intern(keymap->ctx, name.str); free(name.str); return true; @@ -1380,7 +1379,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((strcasecmp(field.str, "groupswrap") == 0) || (strcasecmp(field.str, "wrapgroups") == 0))) { - if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp)) + if (!ExprResolveBoolean(keymap->ctx, stmt->value, &tmp)) { ERROR("Illegal setting for global groupsWrap\n"); ACTION("Non-boolean value ignored\n"); @@ -1398,7 +1397,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((strcasecmp(field.str, "groupsclamp") == 0) || (strcasecmp(field.str, "clampgroups") == 0))) { - if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp)) + if (!ExprResolveBoolean(keymap->ctx, stmt->value, &tmp)) { ERROR("Illegal setting for global groupsClamp\n"); ACTION("Non-boolean value ignored\n"); @@ -1416,7 +1415,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((strcasecmp(field.str, "groupsredirect") == 0) || (strcasecmp(field.str, "redirectgroups") == 0))) { - if (!ExprResolveGroup(keymap->context, stmt->value, &tmp)) + if (!ExprResolveGroup(keymap->ctx, stmt->value, &tmp)) { ERROR("Illegal group index for global groupsRedirect\n"); ACTION("Definition with non-integer group ignored\n"); @@ -1566,11 +1565,11 @@ HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info) ExprResult rtrn; bool ok; - if (!LookupModIndex(keymap->context, NULL, def->modifier, TypeInt, &rtrn)) + if (!LookupModIndex(keymap->ctx, NULL, def->modifier, TypeInt, &rtrn)) { ERROR("Illegal modifier map definition\n"); ACTION("Ignoring map for non-modifier \"%s\"\n", - xkb_atom_text(keymap->context, def->modifier)); + xkb_atom_text(keymap->ctx, def->modifier)); return false; } ok = true; @@ -1582,7 +1581,7 @@ HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info) tmp.haveSymbol = false; tmp.u.keyName = KeyNameToLong(key->value.keyName); } - else if (ExprResolveKeySym(keymap->context, key, &rtrn)) + else if (ExprResolveKeySym(keymap->ctx, key, &rtrn)) { tmp.haveSymbol = true; tmp.u.keySym = rtrn.uval; @@ -1699,7 +1698,7 @@ static bool FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn) { unsigned n; - const char *name = xkb_atom_text(keymap->context, atom); + const char *name = xkb_atom_text(keymap->ctx, atom); if (keymap && keymap->map && keymap->map->types) { @@ -1738,23 +1737,23 @@ FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms, *autoType = false; if ((width == 1) || (width == 0)) { - *typeNameRtrn = xkb_atom_intern(keymap->context, "ONE_LEVEL"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ONE_LEVEL"); *autoType = true; } else if (width == 2) { if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1])) { - *typeNameRtrn = xkb_atom_intern(keymap->context, "ALPHABETIC"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "ALPHABETIC"); } else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))) { - *typeNameRtrn = xkb_atom_intern(keymap->context, "KEYPAD"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "KEYPAD"); *autoType = true; } else { - *typeNameRtrn = xkb_atom_intern(keymap->context, "TWO_LEVEL"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "TWO_LEVEL"); *autoType = true; } } @@ -1763,15 +1762,15 @@ FindAutomaticType(struct xkb_keymap *keymap, int width, xkb_keysym_t *syms, if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1])) if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3])) *typeNameRtrn = - xkb_atom_intern(keymap->context, "FOUR_LEVEL_ALPHABETIC"); + xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_ALPHABETIC"); else - *typeNameRtrn = xkb_atom_intern(keymap->context, + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_SEMIALPHABETIC"); else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1]))) - *typeNameRtrn = xkb_atom_intern(keymap->context, "FOUR_LEVEL_KEYPAD"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL_KEYPAD"); else - *typeNameRtrn = xkb_atom_intern(keymap->context, "FOUR_LEVEL"); + *typeNameRtrn = xkb_atom_intern(keymap->ctx, "FOUR_LEVEL"); /* XXX: why not set autoType here? */ } return ((width >= 0) && (width <= 4)); @@ -1985,7 +1984,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) WARN("No automatic type for %d symbols\n", (unsigned int) key->numLevels[i]); ACTION("Using %s for the %s key (keycode %d)\n", - xkb_atom_text(keymap->context, key->types[i]), + xkb_atom_text(keymap->ctx, key->types[i]), longText(key->name), kc); } } @@ -2000,7 +1999,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) if (warningLevel >= 3) { WARN("Type \"%s\" is not defined\n", - xkb_atom_text(keymap->context, key->types[i])); + xkb_atom_text(keymap->ctx, key->types[i])); ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n", longText(key->name), kc); } @@ -2014,7 +2013,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) { WARN("Type \"%s\" has %d levels, but %s has %d symbols\n", type->name, type->num_levels, - xkb_atom_text(keymap->context, key->name), key->numLevels[i]); + xkb_atom_text(keymap->ctx, key->name), key->numLevels[i]); ACTION("Ignoring extra symbols\n"); } key->numLevels[i] = type->num_levels; @@ -2223,7 +2222,7 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge) for (i = 0; i < XkbNumKbdGroups; i++) { if (info.groupNames[i] != XKB_ATOM_NONE) { free(UNCONSTIFY(keymap->names->groups[i])); - keymap->names->groups[i] = xkb_atom_strdup(keymap->context, + keymap->names->groups[i] = xkb_atom_strdup(keymap->ctx, info.groupNames[i]); } } diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c index 42fd8e3..39ba5f9 100644 --- a/src/xkbcomp/vmod.c +++ b/src/xkbcomp/vmod.c @@ -83,7 +83,7 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, { if (names->vmods[i] && strcmp(names->vmods[i], - xkb_atom_text(keymap->context, stmt->name)) == 0) + xkb_atom_text(keymap->ctx, stmt->name)) == 0) { /* already defined */ info->available |= bit; if (stmt->value == NULL) @@ -92,16 +92,16 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, { const char *str1; const char *str2 = ""; - if (!ExprResolveModMask(keymap->context, stmt->value, &mod)) + if (!ExprResolveModMask(keymap->ctx, stmt->value, &mod)) { - str1 = xkb_atom_text(keymap->context, stmt->name); + str1 = xkb_atom_text(keymap->ctx, stmt->name); ACTION("Declaration of %s ignored\n", str1); return false; } if (mod.uval == srv->vmods[i]) return true; - str1 = xkb_atom_text(keymap->context, stmt->name); + str1 = xkb_atom_text(keymap->ctx, stmt->name); WARN("Virtual modifier %s multiply defined\n", str1); str1 = XkbcModMaskText(srv->vmods[i], true); if (mergeMode == MergeOverride) @@ -128,15 +128,15 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, info->defined |= (1 << nextFree); info->newlyDefined |= (1 << nextFree); info->available |= (1 << nextFree); - names->vmods[nextFree] = xkb_atom_strdup(keymap->context, stmt->name); + names->vmods[nextFree] = xkb_atom_strdup(keymap->ctx, stmt->name); if (stmt->value == NULL) return true; - if (ExprResolveModMask(keymap->context, stmt->value, &mod)) + if (ExprResolveModMask(keymap->ctx, stmt->value, &mod)) { srv->vmods[nextFree] = mod.uval; return true; } - ACTION("Declaration of %s ignored\n", xkb_atom_text(keymap->context, stmt->name)); + ACTION("Declaration of %s ignored\n", xkb_atom_text(keymap->ctx, stmt->name)); return false; } @@ -156,7 +156,7 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, unsigned type, ExprResult * val_rtrn) { int i; - const char *name = xkb_atom_text(keymap->context, field); + const char *name = xkb_atom_text(keymap->ctx, field); if ((keymap == NULL) || (keymap->names == NULL) || (type != TypeInt)) { @@ -190,10 +190,10 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, * undefined. */ bool -LookupVModMask(struct xkb_context *context, const void *priv, xkb_atom_t field, +LookupVModMask(struct xkb_ctx *ctx, const void *priv, xkb_atom_t field, unsigned type, ExprResult *val_rtrn) { - if (LookupModMask(context, NULL, field, type, val_rtrn)) + if (LookupModMask(ctx, NULL, field, type, val_rtrn)) { return true; } @@ -212,8 +212,8 @@ FindKeypadVMod(struct xkb_keymap *keymap) xkb_atom_t name; ExprResult rtrn; - name = xkb_atom_intern(keymap->context, "NumLock"); - if (keymap && LookupVModIndex(keymap, name, TypeInt, &rtrn)) + name = xkb_atom_intern(keymap->ctx, "NumLock"); + if ((keymap) && LookupVModIndex(keymap, name, TypeInt, &rtrn)) { return rtrn.ival; } @@ -229,7 +229,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, if (def->op == ExprIdent) { int i, bit; - const char *name = xkb_atom_text(keymap->context, def->value.str); + const char *name = xkb_atom_text(keymap->ctx, def->value.str); for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) { if ((info->available & bit) && names->vmods[i] && @@ -240,7 +240,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, } } } - if (ExprResolveInteger(keymap->context, def, val_rtrn)) + if (ExprResolveInteger(keymap->ctx, def, val_rtrn)) { if (val_rtrn->uval < XkbNumVirtualMods) return true; diff --git a/src/xkbcomp/xkbcomp-priv.h b/src/xkbcomp/xkbcomp-priv.h index 239ea61..bffab47 100644 --- a/src/xkbcomp/xkbcomp-priv.h +++ b/src/xkbcomp/xkbcomp-priv.h @@ -64,7 +64,7 @@ extern int ReportBadField(const char *type, const char *field, const char *name); extern bool -ProcessIncludeFile(struct xkb_context *context, +ProcessIncludeFile(struct xkb_ctx *ctx, IncludeStmt *stmt, unsigned file_type, XkbFile **file_rtrn, unsigned *merge_rtrn); @@ -84,7 +84,7 @@ extern const char * XkbDirectoryForInclude(unsigned type); extern FILE * -XkbFindFileInPath(struct xkb_context *context, const char *name, +XkbFindFileInPath(struct xkb_ctx *ctx, const char *name, unsigned type, char **pathRtrn); extern bool diff --git a/src/xkbcomp/xkbcomp.c b/src/xkbcomp/xkbcomp.c index d408c29..bf08b01 100644 --- a/src/xkbcomp/xkbcomp.c +++ b/src/xkbcomp/xkbcomp.c @@ -34,38 +34,38 @@ unsigned int warningLevel = 0; #define ISEMPTY(str) (!(str) || (strlen(str) == 0)) static XkbFile * -XkbKeymapFileFromComponents(struct xkb_context *context, +XkbKeymapFileFromComponents(struct xkb_ctx *ctx, const struct xkb_component_names *ktcsg) { XkbFile *keycodes, *types, *compat, *symbols; IncludeStmt *inc; inc = IncludeCreate(ktcsg->keycodes, MergeDefault); - keycodes = CreateXKBFile(context, XkmKeyNamesIndex, NULL, + keycodes = CreateXKBFile(ctx, XkmKeyNamesIndex, NULL, (ParseCommon *)inc, 0); inc = IncludeCreate(ktcsg->types, MergeDefault); - types = CreateXKBFile(context, XkmTypesIndex, NULL, + types = CreateXKBFile(ctx, XkmTypesIndex, NULL, (ParseCommon *)inc, 0); AppendStmt(&keycodes->common, &types->common); inc = IncludeCreate(ktcsg->compat, MergeDefault); - compat = CreateXKBFile(context, XkmCompatMapIndex, NULL, + compat = CreateXKBFile(ctx, XkmCompatMapIndex, NULL, (ParseCommon *)inc, 0); AppendStmt(&keycodes->common, &compat->common); inc = IncludeCreate(ktcsg->symbols, MergeDefault); - symbols = CreateXKBFile(context, XkmSymbolsIndex, NULL, + symbols = CreateXKBFile(ctx, XkmSymbolsIndex, NULL, (ParseCommon *)inc, 0); AppendStmt(&keycodes->common, &symbols->common); - return CreateXKBFile(context, XkmKeymapFile, + return CreateXKBFile(ctx, XkmKeymapFile, ktcsg->keymap ? ktcsg->keymap : strdup(""), &keycodes->common, 0); } static struct xkb_component_names * -XkbComponentsFromRules(struct xkb_context *context, +XkbComponentsFromRules(struct xkb_ctx *ctx, const char *rules, const XkbRF_VarDefsPtr defs) { @@ -75,13 +75,13 @@ XkbComponentsFromRules(struct xkb_context *context, struct xkb_component_names * names = NULL; int i; - rulesFile = XkbFindFileInPath(context, rules, XkmRulesFile, &rulesPath); + rulesFile = XkbFindFileInPath(ctx, rules, XkmRulesFile, &rulesPath); if (!rulesFile) { ERROR("could not find \"%s\" rules in XKB path\n", rules); ERROR("%d include paths searched:\n", - xkb_context_num_include_paths(context)); - for (i = 0; i < xkb_context_num_include_paths(context); i++) - ERROR("\t%s\n", xkb_context_include_path_get(context, i)); + xkb_ctx_num_include_paths(ctx)); + for (i = 0; i < xkb_ctx_num_include_paths(ctx); i++) + ERROR("\t%s\n", xkb_ctx_include_path_get(ctx, i)); return NULL; } @@ -120,7 +120,7 @@ unwind_file: } _X_EXPORT struct xkb_keymap * -xkb_map_new_from_names(struct xkb_context *context, +xkb_map_new_from_names(struct xkb_ctx *ctx, const struct xkb_rule_names *rmlvo, enum xkb_map_compile_flags flags) { @@ -138,14 +138,14 @@ xkb_map_new_from_names(struct xkb_context *context, defs.variant = rmlvo->variant; defs.options = rmlvo->options; - names = XkbComponentsFromRules(context, rmlvo->rules, &defs); + names = XkbComponentsFromRules(ctx, rmlvo->rules, &defs); if (!names) { ERROR("failed to generate XKB components from rules \"%s\"\n", rmlvo->rules); return NULL; } - keymap = xkb_map_new_from_kccgst(context, names, 0); + keymap = xkb_map_new_from_kccgst(ctx, names, 0); free(names->keymap); free(names->keycodes); @@ -192,7 +192,7 @@ XkbChooseMap(XkbFile *file, const char *name) } static struct xkb_keymap * -compile_keymap(struct xkb_context *context, XkbFile *file) +compile_keymap(struct xkb_ctx *ctx, XkbFile *file) { XkbFile *mapToUse; struct xkb_keymap *keymap = NULL; @@ -212,7 +212,7 @@ compile_keymap(struct xkb_context *context, XkbFile *file) goto err; } - keymap = CompileKeymap(context, mapToUse); + keymap = CompileKeymap(ctx, mapToUse); if (!keymap) goto err; @@ -222,7 +222,7 @@ err: } _X_EXPORT struct xkb_keymap * -xkb_map_new_from_kccgst(struct xkb_context *context, +xkb_map_new_from_kccgst(struct xkb_ctx *ctx, const struct xkb_component_names *kccgst, enum xkb_map_compile_flags flags) { @@ -253,16 +253,16 @@ xkb_map_new_from_kccgst(struct xkb_context *context, return NULL; } - if (!(file = XkbKeymapFileFromComponents(context, kccgst))) { + if (!(file = XkbKeymapFileFromComponents(ctx, kccgst))) { ERROR("failed to generate parsed XKB file from components\n"); return NULL; } - return compile_keymap(context, file); + return compile_keymap(ctx, file); } _X_EXPORT struct xkb_keymap * -xkb_map_new_from_string(struct xkb_context *context, +xkb_map_new_from_string(struct xkb_ctx *ctx, const char *string, enum xkb_keymap_format format, enum xkb_map_compile_flags flags) @@ -279,16 +279,16 @@ xkb_map_new_from_string(struct xkb_context *context, return NULL; } - if (!XKBParseString(context, string, "input", &file)) { + if (!XKBParseString(ctx, string, "input", &file)) { ERROR("failed to parse input xkb file\n"); return NULL; } - return compile_keymap(context, file); + return compile_keymap(ctx, file); } _X_EXPORT struct xkb_keymap * -xkb_map_new_from_fd(struct xkb_context *context, +xkb_map_new_from_fd(struct xkb_ctx *ctx, int fd, enum xkb_keymap_format format, enum xkb_map_compile_flags flags) @@ -312,12 +312,12 @@ xkb_map_new_from_fd(struct xkb_context *context, return NULL; } - if (!XKBParseFile(context, fptr, "(unknown file)", &file)) { + if (!XKBParseFile(ctx, fptr, "(unknown file)", &file)) { ERROR("failed to parse input xkb file\n"); return NULL; } - return compile_keymap(context, file); + return compile_keymap(ctx, file); } _X_EXPORT struct xkb_keymap * diff --git a/src/xkbcomp/xkbcomp.h b/src/xkbcomp/xkbcomp.h index 5c0dc96..a4078a3 100644 --- a/src/xkbcomp/xkbcomp.h +++ b/src/xkbcomp/xkbcomp.h @@ -250,7 +250,7 @@ typedef struct _XkbFile } XkbFile; extern struct xkb_keymap * -CompileKeymap(struct xkb_context *context, XkbFile *file); +CompileKeymap(struct xkb_ctx *ctx, XkbFile *file); extern bool CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge); diff --git a/test/context.c b/test/context.c index 016c5ea..77060ad 100644 --- a/test/context.c +++ b/test/context.c @@ -30,13 +30,13 @@ int main(void) { - struct xkb_context *context = xkb_context_new(0); + struct xkb_ctx *ctx = xkb_ctx_new(0); - assert(context); + assert(ctx); /* FIXME: Test include path stuff. */ - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 0; } diff --git a/test/filecomp.c b/test/filecomp.c index 4ee03b1..e595ed5 100644 --- a/test/filecomp.c +++ b/test/filecomp.c @@ -40,28 +40,28 @@ static int test_file(const char *path) { int fd; - struct xkb_context *context; + struct xkb_ctx *ctx; struct xkb_keymap *keymap; fd = open(path, O_RDONLY); assert(fd >= 0); - context = xkb_context_new(0); - assert(context); + ctx = xkb_ctx_new(0); + assert(ctx); fprintf(stderr, "\nCompiling path: %s\n", path); - keymap = xkb_map_new_from_fd(context, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0); + keymap = xkb_map_new_from_fd(ctx, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0); close(fd); if (!keymap) { fprintf(stderr, "Failed to compile keymap\n"); - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 0; } xkb_map_unref(keymap); - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 1; } @@ -78,23 +78,22 @@ test_file_name(const char *file_name) static int test_string(const char *string) { - struct xkb_context *context; + struct xkb_ctx *ctx; struct xkb_keymap *keymap; - context = xkb_context_new(0); - assert(context); + ctx = xkb_ctx_new(0); + assert(ctx); fprintf(stderr, "\nCompiling string\n"); - keymap = xkb_map_new_from_string(context, string, - XKB_KEYMAP_FORMAT_TEXT_V1, 0); + keymap = xkb_map_new_from_string(ctx, string, XKB_KEYMAP_FORMAT_TEXT_V1, 0); if (!keymap) { - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 0; } xkb_map_unref(keymap); - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 1; } diff --git a/test/namescomp.c b/test/namescomp.c index b68a33e..d73018c 100644 --- a/test/namescomp.c +++ b/test/namescomp.c @@ -36,7 +36,7 @@ test_names(const char *keycodes, const char *types, const char *compat, const char *symbols) { int ret = 1; - struct xkb_context *context; + struct xkb_ctx *ctx; struct xkb_keymap *keymap; struct xkb_component_names kccgst = { .keymap = NULL, @@ -46,13 +46,13 @@ test_names(const char *keycodes, const char *types, .symbols = strdup(symbols), }; - context = xkb_context_new(0); - assert(context); + ctx = xkb_ctx_new(0); + assert(ctx); fprintf(stderr, "\nCompiling %s %s %s %s\n", kccgst.keycodes, kccgst.types, kccgst.compat, kccgst.symbols); - keymap = xkb_map_new_from_kccgst(context, &kccgst, 0); + keymap = xkb_map_new_from_kccgst(ctx, &kccgst, 0); if (!keymap) { ret = 0; goto err_ctx; @@ -60,7 +60,7 @@ test_names(const char *keycodes, const char *types, xkb_map_unref(keymap); err_ctx: - xkb_context_unref(context); + xkb_ctx_unref(ctx); free(kccgst.keycodes); free(kccgst.types); free(kccgst.compat); diff --git a/test/rulescomp.c b/test/rulescomp.c index fbf335d..403ff65 100644 --- a/test/rulescomp.c +++ b/test/rulescomp.c @@ -33,7 +33,7 @@ static int test_rmlvo(const char *rules, const char *model, const char *layout, const char *variant, const char *options) { - struct xkb_context *context; + struct xkb_ctx *ctx; struct xkb_keymap *keymap; struct xkb_rule_names rmlvo = { .rules = rules, @@ -43,20 +43,20 @@ test_rmlvo(const char *rules, const char *model, const char *layout, .options = options }; - context = xkb_context_new(0); - assert(context); + ctx = xkb_ctx_new(0); + assert(ctx); fprintf(stderr, "\nCompiling %s %s %s %s %s\n", rmlvo.rules, rmlvo.model, rmlvo.layout, rmlvo.variant, rmlvo.options); - keymap = xkb_map_new_from_names(context, &rmlvo, 0); + keymap = xkb_map_new_from_names(ctx, &rmlvo, 0); if (!keymap) { - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 0; } xkb_map_unref(keymap); - xkb_context_unref(context); + xkb_ctx_unref(ctx); return 1; } diff --git a/test/state.c b/test/state.c index bbc7077..0104f11 100644 --- a/test/state.c +++ b/test/state.c @@ -225,7 +225,7 @@ test_serialisation(struct xkb_keymap *keymap) int main(void) { - struct xkb_context *context; + struct xkb_ctx *ctx; struct xkb_keymap *keymap; struct xkb_rule_names rmlvo = { .rules = "evdev", @@ -235,15 +235,15 @@ main(void) .options = NULL, }; - context = xkb_context_new(0); - assert(context); + ctx = xkb_ctx_new(0); + assert(ctx); - keymap = xkb_map_new_from_names(context, &rmlvo, 0); + keymap = xkb_map_new_from_names(ctx, &rmlvo, 0); assert(keymap); test_update_key(keymap); test_serialisation(keymap); xkb_map_unref(keymap); - xkb_context_unref(context); + xkb_ctx_unref(ctx); }