}
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:";
case XKB_LOG_LEVEL_INFO:
case XKB_LOG_LEVEL_ERROR:
return "Error:";
case XKB_LOG_LEVEL_CRITICAL:
- return "Internal error (critical):";
+ return "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);
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);
+ lvl = strtol(level, &endptr, 10);
if (errno == 0 && (endptr[0] == '\0' || isspace(endptr[0])))
- return prio;
- if (strncasecmp(priority, "err", 3) == 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;
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;
/* Environment overwrites defaults. */
env = getenv("XKB_LOG");
if (env)
- xkb_set_log_priority(ctx, log_priority(env));
+ xkb_set_log_level(ctx, log_level(env));
env = getenv("XKB_VERBOSITY");
if (env)
}
void
-xkb_log(struct xkb_context *ctx, int priority, const char *fmt, ...)
+xkb_log(struct xkb_context *ctx, enum xkb_log_level level,
+ const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
- ctx->log_fn(ctx, priority, fmt, args);
+ ctx->log_fn(ctx, level, fmt, args);
va_end(args);
}
XKB_EXPORT void
xkb_set_log_fn(struct xkb_context *ctx,
- void (*log_fn)(struct xkb_context *ctx, int priority,
+ 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_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_set_log_level(struct xkb_context *ctx, enum xkb_log_level level)
{
- ctx->log_priority = priority;
+ ctx->log_level = level;
}
XKB_EXPORT int
struct xkb_context {
int refcnt;
- ATTR_PRINTF(3, 0) void (*log_fn)(struct xkb_context *ctx, int priority,
+ ATTR_PRINTF(3, 0) void (*log_fn)(struct xkb_context *ctx,
+ enum xkb_log_level level,
const char *fmt, va_list args);
- enum xkb_log_level log_priority;
+ enum xkb_log_level log_level;
int log_verbosity;
void *user_data;
xkb_keysym_is_keypad(xkb_keysym_t keysym);
ATTR_PRINTF(3, 4) void
-xkb_log(struct xkb_context *ctx, int priority, const char *fmt, ...);
+xkb_log(struct xkb_context *ctx, enum xkb_log_level level,
+ const char *fmt, ...);
-#define xkb_log_cond(ctx, prio, ...) \
- do { \
- if (xkb_get_log_priority(ctx) >= (prio)) \
- xkb_log((ctx), (prio), __VA_ARGS__); \
- } while (0)
+#define xkb_log_cond_level(ctx, level, ...) do { \
+ if (xkb_get_log_level(ctx) >= (level)) \
+ xkb_log((ctx), (level), __VA_ARGS__); \
+} while (0)
-#define xkb_log_cond_lvl(ctx, prio, lvl, ...) \
- do { \
- if (xkb_get_log_verbosity(ctx) >= (lvl)) \
- xkb_log_cond((ctx), (prio), __VA_ARGS__); \
- } while (0)
+#define xkb_log_cond_verbosity(ctx, level, vrb, ...) do { \
+ if (xkb_get_log_verbosity(ctx) >= (vrb)) \
+ xkb_log_cond_level((ctx), (level), __VA_ARGS__); \
+} while (0)
/*
* The format is not part of the argument list in order to avoid the
* result in an error, though.
*/
#define log_dbg(ctx, ...) \
- xkb_log_cond((ctx), XKB_LOG_LEVEL_DEBUG, __VA_ARGS__)
+ xkb_log_cond_level((ctx), XKB_LOG_LEVEL_DEBUG, __VA_ARGS__)
#define log_info(ctx, ...) \
- xkb_log_cond((ctx), XKB_LOG_LEVEL_INFO, __VA_ARGS__)
+ xkb_log_cond_level((ctx), XKB_LOG_LEVEL_INFO, __VA_ARGS__)
#define log_warn(ctx, ...) \
- xkb_log_cond((ctx), XKB_LOG_LEVEL_WARNING, __VA_ARGS__)
+ xkb_log_cond_level((ctx), XKB_LOG_LEVEL_WARNING, __VA_ARGS__)
#define log_err(ctx, ...) \
- xkb_log_cond((ctx), XKB_LOG_LEVEL_ERROR, __VA_ARGS__)
+ xkb_log_cond_level((ctx), XKB_LOG_LEVEL_ERROR, __VA_ARGS__)
#define log_wsgo(ctx, ...) \
- xkb_log_cond((ctx), XKB_LOG_LEVEL_CRITICAL, __VA_ARGS__)
-#define log_lvl(ctx, lvl, ...) \
- xkb_log_cond_lvl((ctx), XKB_LOG_LEVEL_WARNING, (lvl), __VA_ARGS__)
+ xkb_log_cond_level((ctx), XKB_LOG_LEVEL_CRITICAL, __VA_ARGS__)
+#define log_vrb(ctx, vrb, ...) \
+ xkb_log_cond_verbosity((ctx), XKB_LOG_LEVEL_WARNING, (vrb), __VA_ARGS__)
#endif /* XKB_PRIV_H */
}
}
else if (rtrn->common.next) {
- log_lvl(ctx, 5,
+ log_vrb(ctx, 5,
"No map in include statement, but \"%s\" contains several; "
"Using first defined map, \"%s\"\n",
stmt->file, rtrn->name);
/* Check that ->real is a key. */
key = FindNamedKey(keymap, alias->real, false, 0);
if (!key) {
- log_lvl(info->ctx, 5,
+ log_vrb(info->ctx, 5,
"Attempt to alias %s to non-existent key %s; Ignored\n",
LongKeyNameText(alias->alias),
LongKeyNameText(alias->real));
/* Check that ->alias is not a key. */
key = FindNamedKey(keymap, alias->alias, false, 0);
if (key) {
- log_lvl(info->ctx, 5,
+ log_vrb(info->ctx, 5,
"Attempt to create alias with the name of a real key; "
"Alias \"%s = %s\" ignored\n",
LongKeyNameText(alias->alias),
continue;
}
- log_lvl(ctx, 3,
+ log_vrb(ctx, 3,
"Multiple default components in %s; "
"Using %s, ignoring %s\n",
(fileName ? fileName : "(unknown)"),
const char *str;
if (!ExprResolveString(ctx, value, &str))
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"The type field of a key symbol map must be a string; "
"Ignoring illegal type definition\n");
const char *name;
if (!arrayNdx) {
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"You must specify an index when specifying a group name; "
"Group name definition without array subscript ignored\n");
return false;
key = FindNamedKey(keymap, keyi->name, useAlias, start_from);
if (!key) {
if (start_from == 0)
- log_lvl(info->keymap->ctx, 5,
+ log_vrb(info->keymap->ctx, 5,
"Key %s not found in keycodes; Symbols ignored\n",
LongKeyNameText(keyi->name));
return false;
darray_mem(keyi->syms[i], 0),
&keyi->types[i], &autoType)) { }
else
- log_lvl(info->keymap->ctx, 5,
+ log_vrb(info->keymap->ctx, 5,
"No automatic type for %d symbols; "
"Using %s for the %s key (keycode %d)\n",
keyi->numLevels[i],
key->explicit |= (1 << i);
}
else {
- log_lvl(info->keymap->ctx, 3,
+ log_vrb(info->keymap->ctx, 3,
"Type \"%s\" is not defined; "
"Using default type for the %s key (keycode %d)\n",
xkb_atom_text(keymap->ctx, keyi->types[i]),
/* if the type specifies fewer levels than the key has, shrink the key */
type = &keymap->types[types[i]];
if (type->num_levels < keyi->numLevels[i]) {
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Type \"%s\" has %d levels, but %s has %d symbols; "
"Ignoring extra symbols\n",
xkb_atom_text(keymap->ctx, type->name),
if (!entry->haveSymbol) {
key = FindNamedKey(keymap, entry->u.keyName, true, 0);
if (!key) {
- log_lvl(info->keymap->ctx, 5,
+ log_vrb(info->keymap->ctx, 5,
"Key %s not found in keycodes; "
"Modifier map entry for %s not updated\n",
LongKeyNameText(entry->u.keyName),
else {
key = FindKeyForSymbol(keymap, entry->u.keySym);
if (!key) {
- log_lvl(info->keymap->ctx, 5,
+ log_vrb(info->keymap->ctx, 5,
"Key \"%s\" not found in symbol map; "
"Modifier map entry for %s not updated\n",
KeysymText(entry->u.keySym),
}
if (old->file_id == new->file_id)
- log_lvl(info->keymap->ctx, 4,
+ log_vrb(info->keymap->ctx, 4,
"Multiple definitions of the %s key type; "
"Later definition ignored\n",
xkb_atom_text(info->keymap->ctx, new->name));
(clobber ? old->level : new->level) + 1);
}
else {
- log_lvl(info->keymap->ctx, 10,
+ log_vrb(info->keymap->ctx, 10,
"Multiple occurences of map[%s]= %d in %s; Ignored\n",
MapEntryTxt(info, new), new->level + 1,
TypeTxt(info, type));
return ReportTypeBadType(info, type, "map entry", "modifier mask");
if (entry.mods.mods & (~type->mods)) {
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
TypeTxt(info, type),
/* Map exists with same preserve; do nothing. */
if (entry->preserve.mods == preserve_mods) {
- log_lvl(info->keymap->ctx, 10,
+ log_vrb(info->keymap->ctx, 10,
"Identical definitions for preserve[%s] in %s; "
"Ignored\n",
VModMaskText(info->keymap, mods),
}
/* Map exists with different preserve; latter wins. */
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Multiple definitions for preserve[%s] in %s; "
"Using %s, ignoring %s\n",
VModMaskText(info->keymap, mods),
mods &= type->mods;
after = VModMaskText(info->keymap, mods);
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Preserve for modifiers not used by the %s type; "
"Index %s converted to %s\n",
TypeTxt(info, type), before, after);
preserve_mods &= mods;
after = VModMaskText(info->keymap, preserve_mods);
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Illegal value for preserve[%s] in type %s; "
"Converted %s to %s\n",
VModMaskText(info->keymap, mods),
/* Same level, same name. */
if (darray_item(type->level_names, level) == name) {
- log_lvl(info->keymap->ctx, 10,
+ log_vrb(info->keymap->ctx, 10,
"Duplicate names for level %d of key type %s; Ignored\n",
level + 1, TypeTxt(info, type));
return true;
old = xkb_atom_text(info->keymap->ctx,
darray_item(type->level_names, level));
new = xkb_atom_text(info->keymap->ctx, name);
- log_lvl(info->keymap->ctx, 1,
+ log_vrb(info->keymap->ctx, 1,
"Multiple names for level %d of key type %s; "
"Using %s, ignoring %s\n",
level + 1, TypeTxt(info, type),
xkb_context_include_path_append(ctx, test_get_path(""));
- xkb_set_log_priority(ctx, XKB_LOG_LEVEL_DEBUG);
+ xkb_set_log_level(ctx, XKB_LOG_LEVEL_DEBUG);
xkb_set_log_verbosity(ctx, 101);
return ctx;
#pragma GCC diagnostic ignored "-Wmissing-format-attribute"
static const char *
-priority_to_string(int priority)
+log_level_to_string(enum xkb_log_level level)
{
- switch (priority) {
+ switch (level) {
+ case XKB_LOG_LEVEL_CRITICAL:
+ return "critical";
case XKB_LOG_LEVEL_ERROR:
return "error";
case XKB_LOG_LEVEL_WARNING:
}
ATTR_PRINTF(3, 0) static void
-log_fn(struct xkb_context *ctx, int priority, const char *fmt, va_list args)
+log_fn(struct xkb_context *ctx, enum xkb_log_level level,
+ const char *fmt, va_list args)
{
char *s;
int size;
size = vasprintf(&s, fmt, args);
assert(size != -1);
- darray_append_string(*ls, priority_to_string(priority));
+ darray_append_string(*ls, log_level_to_string(level));
darray_append_lit(*ls, ": ");
darray_append_string(*ls, s);
free(s);
int ret;
ret = setenv("XKB_LOG", "warn", 1);
+ assert(ret == 0);
ret = setenv("XKB_VERBOSITY", "5", 1);
assert(ret == 0);
ctx = xkb_context_new(0);
log_info(ctx, "first info\n");
log_dbg(ctx, "first debug: %s\n", "hello");
log_err(ctx, "first error: %lu\n", 115415UL);
- log_lvl(ctx, 5, "first verbose 5\n");
+ log_vrb(ctx, 5, "first verbose 5\n");
- xkb_set_log_priority(ctx, XKB_LOG_LEVEL_DEBUG);
+ xkb_set_log_level(ctx, XKB_LOG_LEVEL_DEBUG);
log_warn(ctx, "second warning: %d\n", 87);
log_dbg(ctx, "second debug: %s %s\n", "hello", "world");
log_info(ctx, "second info\n");
log_err(ctx, "second error: %lu\n", 115415UL);
- log_lvl(ctx, 6, "second verbose 6\n");
+ log_vrb(ctx, 6, "second verbose 6\n");
xkb_set_log_verbosity(ctx, 0);
- xkb_set_log_priority(ctx, XKB_LOG_LEVEL_CRITICAL);
+ xkb_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL);
log_warn(ctx, "third warning: %d\n", 87);
log_dbg(ctx, "third debug: %s %s\n", "hello", "world");
log_info(ctx, "third info\n");
log_err(ctx, "third error: %lu\n", 115415UL);
- log_lvl(ctx, 0, "third verbose 0\n");
+ log_vrb(ctx, 0, "third verbose 0\n");
printf("%s", log_string.item);
benchmark(struct xkb_context *context)
{
struct timespec start, stop, elapsed;
- enum xkb_log_level old_prio = xkb_get_log_priority(context);
+ enum xkb_log_level old_level = xkb_get_log_level(context);
int old_verb = xkb_get_log_verbosity(context);
int i;
- xkb_set_log_priority(context, XKB_LOG_LEVEL_CRITICAL);
+ xkb_set_log_level(context, XKB_LOG_LEVEL_CRITICAL);
xkb_set_log_verbosity(context, 0);
clock_gettime(CLOCK_MONOTONIC, &start);
assert(test_rmlvo_silent(context, "evdev", "evdev", "us", "", ""));
clock_gettime(CLOCK_MONOTONIC, &stop);
- xkb_set_log_priority(context, old_prio);
+ xkb_set_log_level(context, old_level);
xkb_set_log_verbosity(context, old_verb);
elapsed.tv_sec = stop.tv_sec - start.tv_sec;
enum xkb_log_level {
/** Log critical internal errors only */
- XKB_LOG_LEVEL_CRITICAL = 0,
+ XKB_LOG_LEVEL_CRITICAL = 10,
/** Log all errors */
- XKB_LOG_LEVEL_ERROR = 1,
+ XKB_LOG_LEVEL_ERROR = 20,
/** Log warnings and errors */
- XKB_LOG_LEVEL_WARNING = 2,
+ XKB_LOG_LEVEL_WARNING = 30,
/** Log information, warnings, and errors */
- XKB_LOG_LEVEL_INFO = 3,
+ XKB_LOG_LEVEL_INFO = 40,
/** Log all the things */
- XKB_LOG_LEVEL_DEBUG = 4,
+ XKB_LOG_LEVEL_DEBUG = 50,
};
/**
**/
void
xkb_set_log_fn(struct xkb_context *context,
- void (*log_fn)(struct xkb_context *context, int priority,
+ void (*log_fn)(struct xkb_context *context,
+ enum xkb_log_level level,
const char *format, va_list args));
/**
- * Sets the current logging priority. The value controls which messages
- * are logged. The default priority is LOG_ERR.
+ * Sets the current logging level. The value controls which messages
+ * are logged. The default level is XKB_LOG_LEVEL_ERROR.
*
* The environment variable XKB_LOG, if set, overrides the default value
- * and may be specified as a priority number or name.
+ * and may be specified as a level number or name.
*/
void
-xkb_set_log_priority(struct xkb_context *context, enum xkb_log_level priority);
+xkb_set_log_level(struct xkb_context *context, enum xkb_log_level level);
/**
- * Returns the current logging priority.
+ * Returns the current logging level.
*/
enum xkb_log_level
-xkb_get_log_priority(struct xkb_context *context);
+xkb_get_log_level(struct xkb_context *context);
/**
* Sets the current logging verbosity, a value from 0 to 10.
* The environment variable XKB_VERBOSITY, if set, overrdies the default
* value.
*
- * Note that most verbose messages are of priority XKB_LOG_LEVEL_WARNING
+ * Note that most verbose messages are of level XKB_LOG_LEVEL_WARNING
* or lower.
*/
void