X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fcontext.c;h=b8b214bcda86d75d1c72b1b1c38d5da44e9b2261;hb=b900faf77b5d07805f10a1160cd1c6842cc46b11;hp=6c52d37b3126a9507007f3762829facb65dc6343;hpb=3d305bd0cb6bc9f8959e41c161446ab3b691368a;p=platform%2Fupstream%2Flibxkbcommon.git diff --git a/src/context.c b/src/context.c index 6c52d37..b8b214b 100644 --- a/src/context.c +++ b/src/context.c @@ -1,5 +1,6 @@ /* * Copyright © 2012 Intel Corporation + * Copyright © 2012 Ran Benita * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -23,16 +24,16 @@ * Author: Daniel Stone */ +#include "config.h" + #include #include -#include #include -#include -#include -#include -#include "xkb-priv.h" -#include "atom.h" +#include "xkbcommon/xkbcommon.h" +#include "utils.h" +#include "context.h" + /** * Append one directory to the context's include path. @@ -41,7 +42,7 @@ XKB_EXPORT int xkb_context_include_path_append(struct xkb_context *ctx, const char *path) { struct stat stat_buf; - int err; + int err = ENOMEM; char *tmp; tmp = strdup(path); @@ -49,48 +50,85 @@ xkb_context_include_path_append(struct xkb_context *ctx, const char *path) goto err; err = stat(path, &stat_buf); - if (err != 0) + if (err != 0) { + err = errno; goto err; - if (!S_ISDIR(stat_buf.st_mode)) + } + if (!S_ISDIR(stat_buf.st_mode)) { + err = ENOTDIR; goto err; + } -#if defined(HAVE_EACCESS) - if (eaccess(path, R_OK | X_OK) != 0) - goto err; -#elif defined(HAVE_EUIDACCESS) - if (euidaccess(path, R_OK | X_OK) != 0) + if (!check_eaccess(path, R_OK | X_OK)) { + err = EACCES; goto err; -#endif + } darray_append(ctx->includes, tmp); + log_dbg(ctx, "Include path added: %s\n", tmp); + return 1; err: darray_append(ctx->failed_includes, tmp); + log_dbg(ctx, "Include path failed: %s (%s)\n", tmp, strerror(err)); return 0; } +const char * +xkb_context_include_path_get_extra_path(struct xkb_context *ctx) +{ + const char *extra = xkb_context_getenv(ctx, "XKB_CONFIG_EXTRA_PATH"); + return extra ? extra : DFLT_XKB_CONFIG_EXTRA_PATH; +} + +const char * +xkb_context_include_path_get_system_path(struct xkb_context *ctx) +{ + const char *root = xkb_context_getenv(ctx, "XKB_CONFIG_ROOT"); + return root ? root : DFLT_XKB_CONFIG_ROOT; +} + /** * Append the default include directories to the context. */ XKB_EXPORT int xkb_context_include_path_append_default(struct xkb_context *ctx) { - const char *home; + const char *home, *xdg, *root, *extra; char *user_path; - int err; int ret = 0; - ret |= xkb_context_include_path_append(ctx, DFLT_XKB_CONFIG_ROOT); + home = xkb_context_getenv(ctx, "HOME"); + + xdg = xkb_context_getenv(ctx, "XDG_CONFIG_HOME"); + if (xdg != NULL) { + user_path = asprintf_safe("%s/xkb", xdg); + if (user_path) { + ret |= xkb_context_include_path_append(ctx, user_path); + free(user_path); + } + } else if (home != NULL) { + /* XDG_CONFIG_HOME fallback is $HOME/.config/ */ + user_path = asprintf_safe("%s/.config/xkb", home); + if (user_path) { + ret |= xkb_context_include_path_append(ctx, user_path); + free(user_path); + } + } + + if (home != NULL) { + user_path = asprintf_safe("%s/.xkb", home); + if (user_path) { + ret |= xkb_context_include_path_append(ctx, user_path); + free(user_path); + } + } - home = getenv("HOME"); - if (!home) - return ret; - err = asprintf(&user_path, "%s/.xkb", home); - if (err <= 0) - return ret; - ret |= xkb_context_include_path_append(ctx, user_path); - free(user_path); + extra = xkb_context_include_path_get_extra_path(ctx); + ret |= xkb_context_include_path_append(ctx, extra); + root = xkb_context_include_path_get_system_path(ctx); + ret |= xkb_context_include_path_append(ctx, root); return ret; } @@ -144,12 +182,6 @@ xkb_context_include_path_get(struct xkb_context *ctx, unsigned int idx) return darray_item(ctx->includes, idx); } -unsigned -xkb_context_take_file_id(struct xkb_context *ctx) -{ - return ctx->file_id++; -} - /** * Take a new reference on the context. */ @@ -167,60 +199,63 @@ xkb_context_ref(struct xkb_context *ctx) XKB_EXPORT void xkb_context_unref(struct xkb_context *ctx) { - if (--ctx->refcnt > 0) + if (!ctx || --ctx->refcnt > 0) return; + free(ctx->x11_atom_cache); xkb_context_include_path_clear(ctx); atom_table_free(ctx->atom_table); free(ctx); } static const char * -priority_to_prefix(int priority) +log_level_to_prefix(enum xkb_log_level level) { - switch (priority) { + switch (level) { case XKB_LOG_LEVEL_DEBUG: - return "Debug:"; + return "xkbcommon: DEBUG: "; case XKB_LOG_LEVEL_INFO: - return "Info:"; + return "xkbcommon: INFO: "; case XKB_LOG_LEVEL_WARNING: - return "Warning:"; + return "xkbcommon: WARNING: "; case XKB_LOG_LEVEL_ERROR: - return "Error:"; + return "xkbcommon: ERROR: "; case XKB_LOG_LEVEL_CRITICAL: - return "Internal error (critical):"; + return "xkbcommon: CRITICAL: "; default: return NULL; } } ATTR_PRINTF(3, 0) static void -default_log_fn(struct xkb_context *ctx, int priority, +default_log_fn(struct xkb_context *ctx, enum xkb_log_level level, const char *fmt, va_list args) { - const char *prefix = priority_to_prefix(priority); + const char *prefix = log_level_to_prefix(level); if (prefix) - fprintf(stderr, "%-10s", prefix); + fprintf(stderr, "%s", prefix); vfprintf(stderr, fmt, args); } -static int -log_priority(const char *priority) { +static enum xkb_log_level +log_level(const char *level) { char *endptr; - int prio; + enum xkb_log_level lvl; errno = 0; - prio = strtol(priority, &endptr, 10); - if (errno == 0 && (endptr[0] == '\0' || isspace(endptr[0]))) - return prio; - if (strncasecmp(priority, "err", 3) == 0) + lvl = strtol(level, &endptr, 10); + if (errno == 0 && (endptr[0] == '\0' || is_space(endptr[0]))) + return lvl; + if (istreq_prefix("crit", level)) + return XKB_LOG_LEVEL_CRITICAL; + if (istreq_prefix("err", level)) return XKB_LOG_LEVEL_ERROR; - if (strncasecmp(priority, "warn", 4) == 0) + if (istreq_prefix("warn", level)) return XKB_LOG_LEVEL_WARNING; - if (strncasecmp(priority, "info", 4) == 0) + if (istreq_prefix("info", level)) return XKB_LOG_LEVEL_INFO; - if (strncasecmp(priority, "debug", 5) == 0) + if (istreq_prefix("debug", level) || istreq_prefix("dbg", level)) return XKB_LOG_LEVEL_DEBUG; return XKB_LOG_LEVEL_ERROR; @@ -253,17 +288,19 @@ xkb_context_new(enum xkb_context_flags flags) ctx->refcnt = 1; ctx->log_fn = default_log_fn; - ctx->log_priority = XKB_LOG_LEVEL_ERROR; + ctx->log_level = XKB_LOG_LEVEL_ERROR; ctx->log_verbosity = 0; + ctx->use_environment_names = !(flags & XKB_CONTEXT_NO_ENVIRONMENT_NAMES); + ctx->use_secure_getenv = !(flags & XKB_CONTEXT_NO_SECURE_GETENV); /* Environment overwrites defaults. */ - env = getenv("XKB_LOG"); + env = xkb_context_getenv(ctx, "XKB_LOG_LEVEL"); if (env) - xkb_set_log_priority(ctx, log_priority(env)); + xkb_context_set_log_level(ctx, log_level(env)); - env = getenv("XKB_VERBOSITY"); + env = xkb_context_getenv(ctx, "XKB_LOG_VERBOSITY"); if (env) - xkb_set_log_verbosity(ctx, log_verbosity(env)); + xkb_context_set_log_verbosity(ctx, log_verbosity(env)); if (!(flags & XKB_CONTEXT_NO_DEFAULT_INCLUDES) && !xkb_context_include_path_append_default(ctx)) { @@ -279,77 +316,46 @@ xkb_context_new(enum xkb_context_flags flags) return NULL; } - return ctx; -} - -xkb_atom_t -xkb_atom_intern(struct xkb_context *ctx, const char *string) -{ - return atom_intern(ctx->atom_table, string, false); -} - -xkb_atom_t -xkb_atom_steal(struct xkb_context *ctx, char *string) -{ - return atom_intern(ctx->atom_table, string, true); -} - -char * -xkb_atom_strdup(struct xkb_context *ctx, xkb_atom_t atom) -{ - return atom_strdup(ctx->atom_table, atom); -} - -const char * -xkb_atom_text(struct xkb_context *ctx, xkb_atom_t atom) -{ - return atom_text(ctx->atom_table, atom); -} - -void -xkb_log(struct xkb_context *ctx, int priority, const char *fmt, ...) -{ - va_list args; + ctx->x11_atom_cache = NULL; - va_start(args, fmt); - ctx->log_fn(ctx, priority, fmt, args); - va_end(args); + return ctx; } XKB_EXPORT void -xkb_set_log_fn(struct xkb_context *ctx, - void (*log_fn)(struct xkb_context *ctx, int priority, - const char *fmt, va_list args)) +xkb_context_set_log_fn(struct xkb_context *ctx, + void (*log_fn)(struct xkb_context *ctx, + enum xkb_log_level level, + const char *fmt, va_list args)) { ctx->log_fn = (log_fn ? log_fn : default_log_fn); } XKB_EXPORT enum xkb_log_level -xkb_get_log_priority(struct xkb_context *ctx) +xkb_context_get_log_level(struct xkb_context *ctx) { - return ctx->log_priority; + return ctx->log_level; } XKB_EXPORT void -xkb_set_log_priority(struct xkb_context *ctx, enum xkb_log_level priority) +xkb_context_set_log_level(struct xkb_context *ctx, enum xkb_log_level level) { - ctx->log_priority = priority; + ctx->log_level = level; } XKB_EXPORT int -xkb_get_log_verbosity(struct xkb_context *ctx) +xkb_context_get_log_verbosity(struct xkb_context *ctx) { return ctx->log_verbosity; } XKB_EXPORT void -xkb_set_log_verbosity(struct xkb_context *ctx, int verbosity) +xkb_context_set_log_verbosity(struct xkb_context *ctx, int verbosity) { ctx->log_verbosity = verbosity; } XKB_EXPORT void * -xkb_get_user_data(struct xkb_context *ctx) +xkb_context_get_user_data(struct xkb_context *ctx) { if (ctx) return ctx->user_data; @@ -357,7 +363,7 @@ xkb_get_user_data(struct xkb_context *ctx) } XKB_EXPORT void -xkb_set_user_data(struct xkb_context *ctx, void *user_data) +xkb_context_set_user_data(struct xkb_context *ctx, void *user_data) { ctx->user_data = user_data; }