StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Messages: merge macros with and without message code 

Previously we had two types of macros for logging: with and without
message code. They were intended to be merged afterwards.

The idea is to use a special code – `XKB_LOG_MESSAGE_NO_ID = 0` – that
should *not* be displayed. But we would like to avoid checking this
special code at run time. This is achieved using macro tricks; they
are detailed in the code (see: `PREPEND_MESSAGE_ID`).

Now it is also easier to spot the remaining undocumented log entries:
just search `XKB_LOG_MESSAGE_NO_ID`.
master
Pierre Le Marre 2023-09-21 20:06:27 +02:00 committed by Wismill
parent a83d745b62
commit c0065c95a4
23 changed files with 280 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/compose/parser.c
View File

@ -727,7 +727,9 @@ parse_file(struct xkb_compose_table *table, FILE *file, const char *file_name)
ok = map_file(file, &string, &size); ok = map_file(file, &string, &size);
if (!ok) { if (!ok) {
log_err(table->ctx, "Couldn't read Compose file %s: %s\n", log_err(table->ctx,
XKB_LOG_MESSAGE_NO_ID,
"Couldn't read Compose file %s: %s\n",
file_name, strerror(errno)); file_name, strerror(errno));
return false; return false;
} }

6
src/compose/table.c
View File

@ -206,7 +206,8 @@ xkb_compose_table_new_from_locale(struct xkb_context *ctx,
} }
free(path); free(path);
log_err(ctx, "couldn't find a Compose file for locale \"%s\" (mapped to \"%s\")\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"couldn't find a Compose file for locale \"%s\" (mapped to \"%s\")\n",
locale, table->locale); locale, table->locale);
xkb_compose_table_unref(table); xkb_compose_table_unref(table);
return NULL; return NULL;
@ -220,7 +221,8 @@ found_path:
return NULL; return NULL;
} }
log_dbg(ctx, "created compose table from locale %s with path %s\n", log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID,
"created compose table from locale %s with path %s\n",
table->locale, path); table->locale, path);
free(path); free(path);

1
src/context-priv.c
View File

@ -182,6 +182,7 @@ xkb_context_sanitize_rule_names(struct xkb_context *ctx,
if (!isempty(rmlvo->variant)) { if (!isempty(rmlvo->variant)) {
const char *variant = xkb_context_get_default_variant(ctx); const char *variant = xkb_context_get_default_variant(ctx);
log_warn(ctx, log_warn(ctx,
XKB_LOG_MESSAGE_NO_ID,
"Layout not provided, but variant set to \"%s\": " "Layout not provided, but variant set to \"%s\": "
"ignoring variant and using defaults for both: " "ignoring variant and using defaults for both: "
"layout=\"%s\", variant=\"%s\".\n", "layout=\"%s\", variant=\"%s\".\n",

8
src/context.c
View File

@ -65,13 +65,14 @@ xkb_context_include_path_append(struct xkb_context *ctx, const char *path)
} }
darray_append(ctx->includes, tmp); darray_append(ctx->includes, tmp);
log_dbg(ctx, "Include path added: %s\n", tmp); log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID, "Include path added: %s\n", tmp);
return 1; return 1;
err: err:
darray_append(ctx->failed_includes, tmp); darray_append(ctx->failed_includes, tmp);
log_dbg(ctx, "Include path failed: %s (%s)\n", tmp, strerror(err)); log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID,
"Include path failed: %s (%s)\n", tmp, strerror(err));
return 0; return 0;
} }
@ -304,7 +305,8 @@ xkb_context_new(enum xkb_context_flags flags)
if (!(flags & XKB_CONTEXT_NO_DEFAULT_INCLUDES) && if (!(flags & XKB_CONTEXT_NO_DEFAULT_INCLUDES) &&
!xkb_context_include_path_append_default(ctx)) { !xkb_context_include_path_append_default(ctx)) {
log_err(ctx, "failed to add default include path %s\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"failed to add default include path %s\n",
DFLT_XKB_CONFIG_ROOT); DFLT_XKB_CONFIG_ROOT);
xkb_context_unref(ctx); xkb_context_unref(ctx);
return NULL; return NULL;

68
src/context.h
View File

@ -109,6 +109,35 @@ void
xkb_context_sanitize_rule_names(struct xkb_context *ctx, xkb_context_sanitize_rule_names(struct xkb_context *ctx,
struct xkb_rule_names *rmlvo); struct xkb_rule_names *rmlvo);
/*
* Macro sorcery: PREPEND_MESSAGE_ID enables the log functions to format messages
* with the message ID only if the ID is not 0 (XKB_LOG_MESSAGE_NO_ID).
* This avoid checking the ID value at run time.
*
* The trick resides in CHECK_ID:
* • CHECK_ID(0) expands to:
* ‣ SECOND(MATCH0, WITH_ID, unused)
* ‣ SECOND(unused,WITHOUT_ID, WITH_ID, unused)
* ‣ WITHOUT_ID
* • CHECK_ID(123) expands to:
* ‣ SECOND(MATCH123, WITH_ID, unused)
* ‣ WITH_ID
*/
#define EXPAND(...) __VA_ARGS__ /* needed for MSVC compatibility */
#define JOIN_EXPAND(a, b) a##b
#define JOIN(a, b) JOIN_EXPAND(a, b)
#define SECOND_EXPAND(a, b, ...) b
#define SECOND(...) EXPAND(SECOND_EXPAND(__VA_ARGS__))
#define MATCH0 unused,WITHOUT_ID
#define CHECK_ID(value) SECOND(JOIN(MATCH, value), WITH_ID, unused)
#define FORMAT_MESSAGE_WITHOUT_ID(id, fmt) fmt
#define FORMAT_MESSAGE_WITH_ID(id, fmt) "[XKB-%03d] " fmt, id
#define PREPEND_MESSAGE_ID(id, fmt) JOIN(FORMAT_MESSAGE_, CHECK_ID(id))(id, fmt)
/* /*
* The format is not part of the argument list in order to avoid the * The format is not part of the argument list in order to avoid the
* "ISO C99 requires rest arguments to be used" warning when only the * "ISO C99 requires rest arguments to be used" warning when only the
@ -116,30 +145,19 @@ xkb_context_sanitize_rule_names(struct xkb_context *ctx,
* result in an error, though. * result in an error, though.
*/ */
#define xkb_log_with_code(ctx, level, verbosity, msg_id, fmt, ...) \ #define xkb_log_with_code(ctx, level, verbosity, msg_id, fmt, ...) \
xkb_log(ctx, level, verbosity, "[XKB-%03d] " fmt, \ xkb_log(ctx, level, verbosity, PREPEND_MESSAGE_ID(msg_id, fmt), ##__VA_ARGS__)
msg_id, ##__VA_ARGS__) #define log_dbg(ctx, id, ...) \
#define log_dbg_with_code(ctx, id, ...) \ xkb_log_with_code((ctx), XKB_LOG_LEVEL_DEBUG, 0, id, __VA_ARGS__)
xkb_log_with_code((ctx), XKB_LOG_LEVEL_DEBUG, 0, (id), __VA_ARGS__) #define log_info(ctx, id, ...) \
#define log_dbg(ctx, ...) \ xkb_log_with_code((ctx), XKB_LOG_LEVEL_INFO, 0, id, __VA_ARGS__)
xkb_log((ctx), XKB_LOG_LEVEL_DEBUG, 0, __VA_ARGS__) #define log_warn(ctx, id, ...) \
#define log_info_with_code(ctx, id, ...) \ xkb_log_with_code((ctx), XKB_LOG_LEVEL_WARNING, 0, id, __VA_ARGS__)
xkb_log_with_code((ctx), XKB_LOG_LEVEL_INFO, 0, (id), __VA_ARGS__) #define log_err(ctx, id, ...) \
#define log_info(ctx, ...) \ xkb_log_with_code((ctx), XKB_LOG_LEVEL_ERROR, 0, id, __VA_ARGS__)
xkb_log((ctx), XKB_LOG_LEVEL_INFO, 0, __VA_ARGS__) #define log_wsgo(ctx, id, ...) \
#define log_warn_with_code(ctx, id, ...) \ xkb_log_with_code((ctx), XKB_LOG_LEVEL_CRITICAL, 0, id, __VA_ARGS__)
xkb_log_with_code((ctx), XKB_LOG_LEVEL_WARNING, 0, (id), __VA_ARGS__)
#define log_warn(ctx, ...) \
xkb_log((ctx), XKB_LOG_LEVEL_WARNING, 0, __VA_ARGS__)
#define log_err_with_code(ctx, id, ...) \
xkb_log_with_code((ctx), XKB_LOG_LEVEL_ERROR, 0, (id), __VA_ARGS__)
#define log_err(ctx, ...) \
xkb_log((ctx), XKB_LOG_LEVEL_ERROR, 0, __VA_ARGS__)
#define log_wsgo_with_code(ctx, id, ...) \
xkb_log_with_code((ctx), XKB_LOG_LEVEL_CRITICAL, 0, (id), __VA_ARGS__)
#define log_wsgo(ctx, ...) \
xkb_log((ctx), XKB_LOG_LEVEL_CRITICAL, 0, __VA_ARGS__)
#define log_vrb(ctx, vrb, id, ...) \ #define log_vrb(ctx, vrb, id, ...) \
xkb_log_with_code((ctx), XKB_LOG_LEVEL_WARNING, (vrb), (id), __VA_ARGS__) xkb_log_with_code((ctx), XKB_LOG_LEVEL_WARNING, (vrb), id, __VA_ARGS__)
/* /*
* Variants which are prefixed by the name of the function they're * Variants which are prefixed by the name of the function they're
@ -147,8 +165,8 @@ xkb_context_sanitize_rule_names(struct xkb_context *ctx,
* Here we must have the silly 1 variant. * Here we must have the silly 1 variant.
*/ */
#define log_err_func(ctx, fmt, ...) \ #define log_err_func(ctx, fmt, ...) \
log_err(ctx, "%s: " fmt, __func__, __VA_ARGS__) log_err(ctx, XKB_LOG_MESSAGE_NO_ID, "%s: " fmt, __func__, __VA_ARGS__)
#define log_err_func1(ctx, fmt) \ #define log_err_func1(ctx, fmt) \
log_err(ctx, "%s: " fmt, __func__) log_err(ctx, XKB_LOG_MESSAGE_NO_ID, "%s: " fmt, __func__)
#endif #endif

6
src/messages-codes.h
View File

@ -8,17 +8,11 @@
/** /**
* Special case when no message identifier is defined. * Special case when no message identifier is defined.
*
* @added 1.6.0
*
*/ */
#define XKB_LOG_MESSAGE_NO_ID 0 #define XKB_LOG_MESSAGE_NO_ID 0
/** /**
* @name Codes of the log messages * @name Codes of the log messages
*
* @added 1.6.0
*
*/ */
enum xkb_message_code { enum xkb_message_code {
_XKB_LOG_MESSAGE_MIN_CODE = 34, _XKB_LOG_MESSAGE_MIN_CODE = 34,

6
src/messages-codes.h.jinja
View File

@ -8,17 +8,11 @@
/** /**
* Special case when no message identifier is defined. * Special case when no message identifier is defined.
*
* @added 1.6.0
*
*/ */
#define XKB_LOG_MESSAGE_NO_ID 0 #define XKB_LOG_MESSAGE_NO_ID 0
/** /**
* @name Codes of the log messages * @name Codes of the log messages
*
* @added 1.6.0
*
*/ */
enum xkb_message_code { enum xkb_message_code {
_XKB_LOG_MESSAGE_MIN_CODE = {{ entries[0].code }}, _XKB_LOG_MESSAGE_MIN_CODE = {{ entries[0].code }},

4
src/x11/keymap.c
View File

@ -63,7 +63,7 @@
*/ */
#define FAIL_UNLESS(expr) do { \ #define FAIL_UNLESS(expr) do { \
if (!(expr)) { \ if (!(expr)) { \
log_err(keymap->ctx, \ log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID, \
"x11: failed to get keymap from X server: unmet condition in %s(): %s\n", \ "x11: failed to get keymap from X server: unmet condition in %s(): %s\n", \
__func__, STRINGIFY(expr)); \ __func__, STRINGIFY(expr)); \
goto fail; \ goto fail; \
@ -72,7 +72,7 @@
#define FAIL_IF_BAD_REPLY(reply, request_name) do { \ #define FAIL_IF_BAD_REPLY(reply, request_name) do { \
if (!reply) { \ if (!reply) { \
log_err(keymap->ctx, \ log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID, \
"x11: failed to get keymap from X server: %s request failed\n", \ "x11: failed to get keymap from X server: %s request failed\n", \
(request_name)); \ (request_name)); \
goto fail; \ goto fail; \

43
src/xkbcomp/action.c
View File

@ -194,7 +194,7 @@ ReportMismatch(struct xkb_context *ctx, xkb_message_code_t code,
enum xkb_action_type action, enum action_field field, enum xkb_action_type action, enum action_field field,
const char *type) const char *type)
{ {
log_err_with_code(ctx, code, log_err(ctx, code,
"Value of %s field must be of type %s; " "Value of %s field must be of type %s; "
"Action %s definition ignored\n", "Action %s definition ignored\n",
fieldText(field), type, ActionTypeText(action)); fieldText(field), type, ActionTypeText(action));
@ -205,7 +205,7 @@ static inline bool
ReportIllegal(struct xkb_context *ctx, enum xkb_action_type action, ReportIllegal(struct xkb_context *ctx, enum xkb_action_type action,
enum action_field field) enum action_field field)
{ {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Field %s is not defined for an action of type %s; " "Field %s is not defined for an action of type %s; "
"Action definition ignored\n", "Action definition ignored\n",
fieldText(field), ActionTypeText(action)); fieldText(field), ActionTypeText(action));
@ -216,7 +216,7 @@ static inline bool
ReportActionNotArray(struct xkb_context *ctx, enum xkb_action_type action, ReportActionNotArray(struct xkb_context *ctx, enum xkb_action_type action,
enum action_field field) enum action_field field)
{ {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"The %s field in the %s action is not an array; " "The %s field in the %s action is not an array; "
"Action definition ignored\n", "Action definition ignored\n",
fieldText(field), ActionTypeText(action)); fieldText(field), ActionTypeText(action));
@ -423,7 +423,7 @@ HandleMovePtr(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer"); field, "integer");
if (val < INT16_MIN || val > INT16_MAX) { if (val < INT16_MIN || val > INT16_MAX) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"The %s field in the %s action must be in range %d..%d; " "The %s field in the %s action must be in range %d..%d; "
"Action definition ignored\n", "Action definition ignored\n",
fieldText(field), ActionTypeText(action->type), fieldText(field), ActionTypeText(action->type),
@ -470,7 +470,7 @@ HandlePtrBtn(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer (range 1..5)"); field, "integer (range 1..5)");
if (btn < 0 || btn > 5) { if (btn < 0 || btn > 5) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Button must specify default or be in the range 1..5; " "Button must specify default or be in the range 1..5; "
"Illegal button value %d ignored\n", btn); "Illegal button value %d ignored\n", btn);
return false; return false;
@ -495,7 +495,7 @@ HandlePtrBtn(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer"); field, "integer");
if (val < 0 || val > 255) { if (val < 0 || val > 255) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"The count field must have a value in the range 0..255; " "The count field must have a value in the range 0..255; "
"Illegal count %d ignored\n", val); "Illegal count %d ignored\n", val);
return false; return false;
@ -555,13 +555,13 @@ HandleSetPtrDflt(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer (range 1..5)"); field, "integer (range 1..5)");
if (btn < 0 || btn > 5) { if (btn < 0 || btn > 5) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"New default button value must be in the range 1..5; " "New default button value must be in the range 1..5; "
"Illegal default button value %d ignored\n", btn); "Illegal default button value %d ignored\n", btn);
return false; return false;
} }
if (btn == 0) { if (btn == 0) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot set default pointer button to \"default\"; " "Cannot set default pointer button to \"default\"; "
"Illegal default button setting ignored\n"); "Illegal default button setting ignored\n");
return false; return false;
@ -603,7 +603,7 @@ HandleSwitchScreen(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer (0..255)"); field, "integer (0..255)");
if (val < 0 || val > 255) { if (val < 0 || val > 255) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Screen index must be in the range 1..255; " "Screen index must be in the range 1..255; "
"Illegal screen value %d ignored\n", val); "Illegal screen value %d ignored\n", val);
return false; return false;
@ -667,7 +667,7 @@ HandlePrivate(struct xkb_context *ctx, const struct xkb_mod_set *mods,
ACTION_TYPE_PRIVATE, field, "integer"); ACTION_TYPE_PRIVATE, field, "integer");
if (type < 0 || type > 255) { if (type < 0 || type > 255) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Private action type must be in the range 0..255; " "Private action type must be in the range 0..255; "
"Illegal type %d ignored\n", type); "Illegal type %d ignored\n", type);
return false; return false;
@ -684,7 +684,7 @@ HandlePrivate(struct xkb_context *ctx, const struct xkb_mod_set *mods,
* make actions like these no-ops for now. * make actions like these no-ops for now.
*/ */
if (type < ACTION_TYPE_PRIVATE) { if (type < ACTION_TYPE_PRIVATE) {
log_info(ctx, log_info(ctx, XKB_LOG_MESSAGE_NO_ID,
"Private actions of type %s are not supported; Ignored\n", "Private actions of type %s are not supported; Ignored\n",
ActionTypeText(type)); ActionTypeText(type));
act->type = ACTION_TYPE_NONE; act->type = ACTION_TYPE_NONE;
@ -708,7 +708,7 @@ HandlePrivate(struct xkb_context *ctx, const struct xkb_mod_set *mods,
str = xkb_atom_text(ctx, val); str = xkb_atom_text(ctx, val);
len = strlen(str); len = strlen(str);
if (len < 1 || len > sizeof(act->data)) { if (len < 1 || len > sizeof(act->data)) {
log_warn(ctx, log_warn(ctx, XKB_LOG_MESSAGE_NO_ID,
"A private action has %ld data bytes; " "A private action has %ld data bytes; "
"Illegal data ignored\n", sizeof(act->data)); "Illegal data ignored\n", sizeof(act->data));
return false; return false;
@ -723,14 +723,14 @@ HandlePrivate(struct xkb_context *ctx, const struct xkb_mod_set *mods,
int ndx, datum; int ndx, datum;
if (!ExprResolveInteger(ctx, array_ndx, &ndx)) { if (!ExprResolveInteger(ctx, array_ndx, &ndx)) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Array subscript must be integer; " "Array subscript must be integer; "
"Illegal subscript ignored\n"); "Illegal subscript ignored\n");
return false; return false;
} }
if (ndx < 0 || (size_t) ndx >= sizeof(act->data)) { if (ndx < 0 || (size_t) ndx >= sizeof(act->data)) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"The data for a private action is %lu bytes long; " "The data for a private action is %lu bytes long; "
"Attempt to use data[%d] ignored\n", "Attempt to use data[%d] ignored\n",
(unsigned long) sizeof(act->data), ndx); (unsigned long) sizeof(act->data), ndx);
@ -742,7 +742,7 @@ HandlePrivate(struct xkb_context *ctx, const struct xkb_mod_set *mods,
field, "integer"); field, "integer");
if (datum < 0 || datum > 255) { if (datum < 0 || datum > 255) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"All data for a private action must be 0..255; " "All data for a private action must be 0..255; "
"Illegal datum %d ignored\n", datum); "Illegal datum %d ignored\n", datum);
return false; return false;
@ -794,14 +794,15 @@ HandleActionDef(struct xkb_context *ctx, ActionsInfo *info,
enum xkb_action_type handler_type; enum xkb_action_type handler_type;
if (def->expr.op != EXPR_ACTION_DECL) { if (def->expr.op != EXPR_ACTION_DECL) {
log_err(ctx, "Expected an action definition, found %s\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Expected an action definition, found %s\n",
expr_op_type_to_string(def->expr.op)); expr_op_type_to_string(def->expr.op));
return false; return false;
} }
str = xkb_atom_text(ctx, def->action.name); str = xkb_atom_text(ctx, def->action.name);
if (!stringToAction(str, &handler_type)) { if (!stringToAction(str, &handler_type)) {
log_err(ctx, "Unknown action %s\n", str); log_err(ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown action %s\n", str);
return false; return false;
} }
@ -841,7 +842,7 @@ HandleActionDef(struct xkb_context *ctx, ActionsInfo *info,
return false; return false;
if (elemRtrn) { if (elemRtrn) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot change defaults in an action definition; " "Cannot change defaults in an action definition; "
"Ignoring attempt to change %s.%s\n", "Ignoring attempt to change %s.%s\n",
elemRtrn, fieldRtrn); elemRtrn, fieldRtrn);
@ -849,7 +850,8 @@ HandleActionDef(struct xkb_context *ctx, ActionsInfo *info,
} }
if (!stringToField(fieldRtrn, &fieldNdx)) { if (!stringToField(fieldRtrn, &fieldNdx)) {
log_err(ctx, "Unknown field name %s\n", fieldRtrn); log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Unknown field name %s\n", fieldRtrn);
return false; return false;
} }
@ -873,7 +875,8 @@ SetActionField(struct xkb_context *ctx, ActionsInfo *info,
return false; return false;
if (!stringToField(field, &action_field)) { if (!stringToField(field, &action_field)) {
log_err(ctx, "\"%s\" is not a legal field name\n", field); log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"\"%s\" is not a legal field name\n", field);
return false; return false;
} }

2
src/xkbcomp/ast-build.c
View File

@ -525,7 +525,7 @@ IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge)
return first; return first;
err: err:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_INCLUDE_STATEMENT, XKB_ERROR_INVALID_INCLUDE_STATEMENT,
"Illegal include statement \"%s\"; Ignored\n", stmt); "Illegal include statement \"%s\"; Ignored\n", stmt);
FreeInclude(first); FreeInclude(first);

38
src/xkbcomp/compat.c
View File

@ -209,7 +209,7 @@ AddInterp(CompatInfo *info, SymInterpInfo *new, bool same_file)
if (new->merge == MERGE_REPLACE) { if (new->merge == MERGE_REPLACE) {
if (report) if (report)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple definitions for \"%s\"; " "Multiple definitions for \"%s\"; "
"Earlier interpretation ignored\n", "Earlier interpretation ignored\n",
siText(new, info)); siText(new, info));
@ -239,7 +239,7 @@ AddInterp(CompatInfo *info, SymInterpInfo *new, bool same_file)
} }
if (collide) { if (collide) {
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple interpretations of \"%s\"; " "Multiple interpretations of \"%s\"; "
"Using %s definition for duplicate fields\n", "Using %s definition for duplicate fields\n",
siText(new, info), siText(new, info),
@ -270,7 +270,7 @@ ResolveStateAndPredicate(ExprDef *expr, enum xkb_match_operation *pred_rtrn,
const char *pred_txt = xkb_atom_text(info->ctx, expr->action.name); const char *pred_txt = xkb_atom_text(info->ctx, expr->action.name);
if (!LookupString(symInterpretMatchMaskNames, pred_txt, pred_rtrn) || if (!LookupString(symInterpretMatchMaskNames, pred_txt, pred_rtrn) ||
!expr->action.args || expr->action.args->common.next) { !expr->action.args || expr->action.args->common.next) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Illegal modifier predicate \"%s\"; Ignored\n", pred_txt); "Illegal modifier predicate \"%s\"; Ignored\n", pred_txt);
return false; return false;
} }
@ -333,7 +333,7 @@ AddLedMap(CompatInfo *info, LedInfo *new, bool same_file)
if (new->merge == MERGE_REPLACE) { if (new->merge == MERGE_REPLACE) {
if (report) if (report)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Map for indicator %s redefined; " "Map for indicator %s redefined; "
"Earlier definition ignored\n", "Earlier definition ignored\n",
xkb_atom_text(info->ctx, old->led.name)); xkb_atom_text(info->ctx, old->led.name));
@ -358,7 +358,7 @@ AddLedMap(CompatInfo *info, LedInfo *new, bool same_file)
} }
if (collide) { if (collide) {
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Map for indicator %s redefined; " "Map for indicator %s redefined; "
"Using %s definition for duplicate fields\n", "Using %s definition for duplicate fields\n",
xkb_atom_text(info->ctx, old->led.name), xkb_atom_text(info->ctx, old->led.name),
@ -369,7 +369,7 @@ AddLedMap(CompatInfo *info, LedInfo *new, bool same_file)
} }
if (info->num_leds >= XKB_MAX_LEDS) { if (info->num_leds >= XKB_MAX_LEDS) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Too many LEDs defined (maximum %d)\n", "Too many LEDs defined (maximum %d)\n",
XKB_MAX_LEDS); XKB_MAX_LEDS);
return false; return false;
@ -506,7 +506,7 @@ SetInterpField(CompatInfo *info, SymInterpInfo *si, const char *field,
si->defined |= SI_FIELD_AUTO_REPEAT; si->defined |= SI_FIELD_AUTO_REPEAT;
} }
else if (istreq(field, "locking")) { else if (istreq(field, "locking")) {
log_dbg(info->ctx, log_dbg(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The \"locking\" field in symbol interpretation is unsupported; " "The \"locking\" field in symbol interpretation is unsupported; "
"Ignored\n"); "Ignored\n");
} }
@ -572,7 +572,7 @@ SetLedMapField(CompatInfo *info, LedInfo *ledi, const char *field,
ledi->defined |= LED_FIELD_CTRLS; ledi->defined |= LED_FIELD_CTRLS;
} }
else if (istreq(field, "allowexplicit")) { else if (istreq(field, "allowexplicit")) {
log_dbg(info->ctx, log_dbg(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The \"allowExplicit\" field in indicator statements is unsupported; " "The \"allowExplicit\" field in indicator statements is unsupported; "
"Ignored\n"); "Ignored\n");
} }
@ -609,18 +609,18 @@ SetLedMapField(CompatInfo *info, LedInfo *ledi, const char *field,
istreq(field, "leddriveskeyboard") || istreq(field, "leddriveskeyboard") ||
istreq(field, "indicatordriveskbd") || istreq(field, "indicatordriveskbd") ||
istreq(field, "indicatordriveskeyboard")) { istreq(field, "indicatordriveskeyboard")) {
log_dbg(info->ctx, log_dbg(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The \"%s\" field in indicator statements is unsupported; " "The \"%s\" field in indicator statements is unsupported; "
"Ignored\n", field); "Ignored\n", field);
} }
else if (istreq(field, "index")) { else if (istreq(field, "index")) {
/* Users should see this, it might cause unexpected behavior. */ /* Users should see this, it might cause unexpected behavior. */
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The \"index\" field in indicator statements is unsupported; " "The \"index\" field in indicator statements is unsupported; "
"Ignored\n"); "Ignored\n");
} }
else { else {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Unknown field %s in map for %s indicator; " "Unknown field %s in map for %s indicator; "
"Definition ignored\n", "Definition ignored\n",
field, xkb_atom_text(info->ctx, ledi->led.name)); field, xkb_atom_text(info->ctx, ledi->led.name));
@ -660,7 +660,7 @@ HandleInterpBody(CompatInfo *info, VarDef *def, SymInterpInfo *si)
for (; def; def = (VarDef *) def->common.next) { for (; def; def = (VarDef *) def->common.next) {
if (def->name && def->name->expr.op == EXPR_FIELD_REF) { if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot set a global default value from within an interpret statement; " "Cannot set a global default value from within an interpret statement; "
"Move statements to the global file scope\n"); "Move statements to the global file scope\n");
ok = false; ok = false;
@ -685,7 +685,7 @@ HandleInterpDef(CompatInfo *info, InterpDef *def, enum merge_mode merge)
SymInterpInfo si; SymInterpInfo si;
if (!ResolveStateAndPredicate(def->match, &pred, &mods, info)) { if (!ResolveStateAndPredicate(def->match, &pred, &mods, info)) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Couldn't determine matching modifiers; " "Couldn't determine matching modifiers; "
"Symbol interpretation ignored\n"); "Symbol interpretation ignored\n");
return false; return false;
@ -734,7 +734,7 @@ HandleLedMapDef(CompatInfo *info, LedMapDef *def, enum merge_mode merge)
} }
if (elem) { if (elem) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot set defaults for \"%s\" element in indicator map; " "Cannot set defaults for \"%s\" element in indicator map; "
"Assignment to %s.%s ignored\n", elem, elem, field); "Assignment to %s.%s ignored\n", elem, elem, field);
ok = false; ok = false;
@ -769,7 +769,7 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleInterpDef(info, (InterpDef *) stmt, merge); ok = HandleInterpDef(info, (InterpDef *) stmt, merge);
break; break;
case STMT_GROUP_COMPAT: case STMT_GROUP_COMPAT:
log_dbg(info->ctx, log_dbg(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The \"group\" statement in compat is unsupported; " "The \"group\" statement in compat is unsupported; "
"Ignored\n"); "Ignored\n");
ok = true; ok = true;
@ -784,7 +784,7 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge); ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge);
break; break;
default: default:
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Compat files may not include other types; " "Compat files may not include other types; "
"Ignoring %s\n", stmt_type_to_string(stmt->type)); "Ignoring %s\n", stmt_type_to_string(stmt->type));
ok = false; ok = false;
@ -795,7 +795,7 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
info->errorCount++; info->errorCount++;
if (info->errorCount > 10) { if (info->errorCount > 10) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Abandoning compatibility map \"%s\"\n", file->name); "Abandoning compatibility map \"%s\"\n", file->name);
break; break;
} }
@ -837,7 +837,7 @@ CopyLedMapDefsToKeymap(struct xkb_keymap *keymap, CompatInfo *info)
/* Not previously declared; create it with next free index. */ /* Not previously declared; create it with next free index. */
if (i >= keymap->num_leds) { if (i >= keymap->num_leds) {
log_dbg(keymap->ctx, log_dbg(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Indicator name \"%s\" was not declared in the keycodes section; " "Indicator name \"%s\" was not declared in the keycodes section; "
"Adding new indicator\n", "Adding new indicator\n",
xkb_atom_text(keymap->ctx, ledi->led.name)); xkb_atom_text(keymap->ctx, ledi->led.name));
@ -849,7 +849,7 @@ CopyLedMapDefsToKeymap(struct xkb_keymap *keymap, CompatInfo *info)
if (i >= keymap->num_leds) { if (i >= keymap->num_leds) {
/* Not place to put it; ignore. */ /* Not place to put it; ignore. */
if (i >= XKB_MAX_LEDS) { if (i >= XKB_MAX_LEDS) {
log_err(keymap->ctx, log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Too many indicators (maximum is %d); " "Too many indicators (maximum is %d); "
"Indicator name \"%s\" ignored\n", "Indicator name \"%s\" ignored\n",
XKB_MAX_LEDS, XKB_MAX_LEDS,

80
src/xkbcomp/expr.c
View File

@ -63,7 +63,7 @@ ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
default: default:
break; break;
} }
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_INVALID_SYNTAX, XKB_ERROR_INVALID_SYNTAX,
"Unexpected operator %d in ResolveLhs\n", expr->expr.op); "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
return false; return false;
@ -141,7 +141,7 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
switch (expr->expr.op) { switch (expr->expr.op) {
case EXPR_VALUE: case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) { if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where boolean was expected\n", "Found constant of type %s where boolean was expected\n",
expr_value_type_to_string(expr->expr.value_type)); expr_value_type_to_string(expr->expr.value_type));
@ -166,13 +166,13 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
return true; return true;
} }
} }
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_IDENTIFIER, XKB_ERROR_INVALID_IDENTIFIER,
"Identifier \"%s\" of type boolean is unknown\n", ident); "Identifier \"%s\" of type boolean is unknown\n", ident);
return false; return false;
case EXPR_FIELD_REF: case EXPR_FIELD_REF:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_EXPRESSION_TYPE, XKB_ERROR_INVALID_EXPRESSION_TYPE,
"Default \"%s.%s\" of type boolean is unknown\n", "Default \"%s.%s\" of type boolean is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element), xkb_atom_text(ctx, expr->field_ref.element),
@ -195,14 +195,14 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
case EXPR_ACTION_DECL: case EXPR_ACTION_DECL:
case EXPR_ACTION_LIST: case EXPR_ACTION_LIST:
case EXPR_KEYSYM_LIST: case EXPR_KEYSYM_LIST:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"%s of boolean values not permitted\n", "%s of boolean values not permitted\n",
expr_op_type_to_string(expr->expr.op)); expr_op_type_to_string(expr->expr.op));
break; break;
default: default:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_UNKNOWN_OPERATOR, XKB_ERROR_UNKNOWN_OPERATOR,
"Unknown operator %d in ResolveBoolean\n", "Unknown operator %d in ResolveBoolean\n",
expr->expr.op); expr->expr.op);
@ -221,7 +221,7 @@ ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
switch (expr->expr.op) { switch (expr->expr.op) {
case EXPR_VALUE: case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) { if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where an int was expected\n", "Found constant of type %s where an int was expected\n",
expr_value_type_to_string(expr->expr.value_type)); expr_value_type_to_string(expr->expr.value_type));
@ -251,7 +251,7 @@ ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
break; break;
case EXPR_DIVIDE: case EXPR_DIVIDE:
if (rightRtrn == 0) { if (rightRtrn == 0) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"Cannot divide by zero: %d / %d\n", "Cannot divide by zero: %d / %d\n",
leftRtrn, rightRtrn); leftRtrn, rightRtrn);
@ -277,7 +277,7 @@ ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
return ExprResolveKeyCode(ctx, expr->unary.child, kc); return ExprResolveKeyCode(ctx, expr->unary.child, kc);
default: default:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_INVALID_SYNTAX, XKB_ERROR_INVALID_SYNTAX,
"Unknown operator %d in ResolveKeyCode\n", expr->expr.op); "Unknown operator %d in ResolveKeyCode\n", expr->expr.op);
break; break;
@ -309,7 +309,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
switch (expr->expr.op) { switch (expr->expr.op) {
case EXPR_VALUE: case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) { if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where an int was expected\n", "Found constant of type %s where an int was expected\n",
expr_value_type_to_string(expr->expr.value_type)); expr_value_type_to_string(expr->expr.value_type));
@ -324,7 +324,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u); ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
if (!ok) if (!ok)
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_IDENTIFIER, XKB_ERROR_INVALID_IDENTIFIER,
"Identifier \"%s\" of type int is unknown\n", "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->ident.ident)); xkb_atom_text(ctx, expr->ident.ident));
@ -334,7 +334,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
return ok; return ok;
case EXPR_FIELD_REF: case EXPR_FIELD_REF:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_EXPRESSION_TYPE, XKB_ERROR_INVALID_EXPRESSION_TYPE,
"Default \"%s.%s\" of type int is unknown\n", "Default \"%s.%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element), xkb_atom_text(ctx, expr->field_ref.element),
@ -363,7 +363,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
break; break;
case EXPR_DIVIDE: case EXPR_DIVIDE:
if (r == 0) { if (r == 0) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"Cannot divide by zero: %d / %d\n", l, r); "Cannot divide by zero: %d / %d\n", l, r);
return false; return false;
@ -371,7 +371,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
*val_rtrn = l / r; *val_rtrn = l / r;
break; break;
default: default:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"%s of integers not permitted\n", "%s of integers not permitted\n",
expr_op_type_to_string(expr->expr.op)); expr_op_type_to_string(expr->expr.op));
@ -381,13 +381,13 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
return true; return true;
case EXPR_ASSIGN: case EXPR_ASSIGN:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"Assignment operator not implemented yet\n"); "Assignment operator not implemented yet\n");
break; break;
case EXPR_NOT: case EXPR_NOT:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"The ! operator cannot be applied to an integer\n"); "The ! operator cannot be applied to an integer\n");
return false; return false;
@ -407,7 +407,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
lookupPriv); lookupPriv);
default: default:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_UNKNOWN_OPERATOR, XKB_ERROR_UNKNOWN_OPERATOR,
"Unknown operator %d in ResolveInteger\n", "Unknown operator %d in ResolveInteger\n",
expr->expr.op); expr->expr.op);
@ -437,7 +437,7 @@ ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
return false; return false;
if (result <= 0 || result > XKB_MAX_GROUPS) { if (result <= 0 || result > XKB_MAX_GROUPS) {
log_err_with_code(ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX, log_err(ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Group index %u is out of range (1..%d)\n", "Group index %u is out of range (1..%d)\n",
result, XKB_MAX_GROUPS); result, XKB_MAX_GROUPS);
return false; return false;
@ -460,7 +460,7 @@ ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
return false; return false;
if (result < 1) { if (result < 1) {
log_err_with_code(ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL, log_err(ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL,
"Shift level %d is out of range\n", result); "Shift level %d is out of range\n", result);
return false; return false;
} }
@ -484,7 +484,7 @@ ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
switch (expr->expr.op) { switch (expr->expr.op) {
case EXPR_VALUE: case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_STRING) { if (expr->expr.value_type != EXPR_TYPE_STRING) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s, expected a string\n", "Found constant of type %s, expected a string\n",
expr_value_type_to_string(expr->expr.value_type)); expr_value_type_to_string(expr->expr.value_type));
@ -495,14 +495,14 @@ ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
return true; return true;
case EXPR_IDENT: case EXPR_IDENT:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_IDENTIFIER, XKB_ERROR_INVALID_IDENTIFIER,
"Identifier \"%s\" of type string not found\n", "Identifier \"%s\" of type string not found\n",
xkb_atom_text(ctx, expr->ident.ident)); xkb_atom_text(ctx, expr->ident.ident));
return false; return false;
case EXPR_FIELD_REF: case EXPR_FIELD_REF:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_EXPRESSION_TYPE, XKB_ERROR_INVALID_EXPRESSION_TYPE,
"Default \"%s.%s\" of type string not found\n", "Default \"%s.%s\" of type string not found\n",
xkb_atom_text(ctx, expr->field_ref.element), xkb_atom_text(ctx, expr->field_ref.element),
@ -521,14 +521,14 @@ ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
case EXPR_ACTION_DECL: case EXPR_ACTION_DECL:
case EXPR_ACTION_LIST: case EXPR_ACTION_LIST:
case EXPR_KEYSYM_LIST: case EXPR_KEYSYM_LIST:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_SYNTAX, XKB_ERROR_INVALID_SYNTAX,
"%s of strings not permitted\n", "%s of strings not permitted\n",
expr_op_type_to_string(expr->expr.op)); expr_op_type_to_string(expr->expr.op));
return false; return false;
default: default:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_UNKNOWN_OPERATOR, XKB_ERROR_UNKNOWN_OPERATOR,
"Unknown operator %d in ResolveString\n", "Unknown operator %d in ResolveString\n",
expr->expr.op); expr->expr.op);
@ -542,7 +542,7 @@ ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
unsigned int *val_rtrn, const LookupEntry *values) unsigned int *val_rtrn, const LookupEntry *values)
{ {
if (expr->expr.op != EXPR_IDENT) { if (expr->expr.op != EXPR_IDENT) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found a %s where an enumerated value was expected\n", "Found a %s where an enumerated value was expected\n",
expr_op_type_to_string(expr->expr.op)); expr_op_type_to_string(expr->expr.op));
@ -551,13 +551,13 @@ ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT, if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn)) { val_rtrn)) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_IDENTIFIER, XKB_ERROR_INVALID_IDENTIFIER,
"Illegal identifier %s; expected one of:\n", "Illegal identifier %s; expected one of:\n",
xkb_atom_text(ctx, expr->ident.ident)); xkb_atom_text(ctx, expr->ident.ident));
while (values && values->name) while (values && values->name)
{ {
log_err_with_code(ctx, XKB_ERROR_INVALID_IDENTIFIER, "\t%s\n", values->name); log_err(ctx, XKB_ERROR_INVALID_IDENTIFIER, "\t%s\n", values->name);
values++; values++;
} }
return false; return false;
@ -580,7 +580,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
switch (expr->expr.op) { switch (expr->expr.op) {
case EXPR_VALUE: case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) { if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where a mask was expected\n", "Found constant of type %s where a mask was expected\n",
expr_value_type_to_string(expr->expr.value_type)); expr_value_type_to_string(expr->expr.value_type));
@ -593,14 +593,14 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn); val_rtrn);
if (!ok) if (!ok)
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_IDENTIFIER, XKB_ERROR_INVALID_IDENTIFIER,
"Identifier \"%s\" of type int is unknown\n", "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->ident.ident)); xkb_atom_text(ctx, expr->ident.ident));
return ok; return ok;
case EXPR_FIELD_REF: case EXPR_FIELD_REF:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_EXPRESSION_TYPE, XKB_ERROR_INVALID_EXPRESSION_TYPE,
"Default \"%s.%s\" of type int is unknown\n", "Default \"%s.%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element), xkb_atom_text(ctx, expr->field_ref.element),
@ -613,7 +613,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
case EXPR_ACTION_DECL: case EXPR_ACTION_DECL:
if (bogus == NULL) if (bogus == NULL)
bogus = "function use"; bogus = "function use";
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Unexpected %s in mask expression; Expression Ignored\n", "Unexpected %s in mask expression; Expression Ignored\n",
bogus); bogus);
@ -638,7 +638,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
break; break;
case EXPR_MULTIPLY: case EXPR_MULTIPLY:
case EXPR_DIVIDE: case EXPR_DIVIDE:
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"Cannot %s masks; Illegal operation ignored\n", "Cannot %s masks; Illegal operation ignored\n",
(expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply")); (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
@ -650,7 +650,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
return true; return true;
case EXPR_ASSIGN: case EXPR_ASSIGN:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"Assignment operator not implemented yet\n"); "Assignment operator not implemented yet\n");
break; break;
@ -668,14 +668,14 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
case EXPR_NOT: case EXPR_NOT:
left = expr->unary.child; left = expr->unary.child;
if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv)) if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_OPERATION, XKB_ERROR_INVALID_OPERATION,
"The %s operator cannot be used with a mask\n", "The %s operator cannot be used with a mask\n",
(expr->expr.op == EXPR_NEGATE ? "-" : "!")); (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
return false; return false;
default: default:
log_wsgo_with_code(ctx, log_wsgo(ctx,
XKB_ERROR_UNKNOWN_OPERATOR, XKB_ERROR_UNKNOWN_OPERATOR,
"Unknown operator %d in ResolveMask\n", "Unknown operator %d in ResolveMask\n",
expr->expr.op); expr->expr.op);
@ -718,7 +718,7 @@ ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
return false; return false;
if (val < XKB_KEYSYM_MIN) { if (val < XKB_KEYSYM_MIN) {
log_warn_with_code(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM, log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
"unrecognized keysym \"-0x%x\" (%d)\n", "unrecognized keysym \"-0x%x\" (%d)\n",
(unsigned int) -val, val); (unsigned int) -val, val);
return false; return false;
@ -731,14 +731,14 @@ ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
} }
if (val <= XKB_KEYSYM_MAX) { if (val <= XKB_KEYSYM_MAX) {
log_warn_with_code(ctx, XKB_WARNING_NUMERIC_KEYSYM, log_warn(ctx, XKB_WARNING_NUMERIC_KEYSYM,
"numeric keysym \"0x%x\" (%d)", "numeric keysym \"0x%x\" (%d)",
(unsigned int) val, val); (unsigned int) val, val);
*sym_rtrn = (xkb_keysym_t) val; *sym_rtrn = (xkb_keysym_t) val;
return true; return true;
} }
log_warn_with_code(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM, log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
"unrecognized keysym \"0x%x\" (%d)\n", "unrecognized keysym \"0x%x\" (%d)\n",
(unsigned int) val, val); (unsigned int) val, val);
return false; return false;
@ -754,7 +754,7 @@ ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
xkb_atom_t name; xkb_atom_t name;
if (def->expr.op != EXPR_IDENT) { if (def->expr.op != EXPR_IDENT) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Cannot resolve virtual modifier: " "Cannot resolve virtual modifier: "
"found %s where a virtual modifier name was expected\n", "found %s where a virtual modifier name was expected\n",
@ -765,7 +765,7 @@ ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
name = def->ident.ident; name = def->ident.ident;
ndx = XkbModNameToIndex(mods, name, mod_type); ndx = XkbModNameToIndex(mods, name, mod_type);
if (ndx == XKB_MOD_INVALID) { if (ndx == XKB_MOD_INVALID) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER, XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER,
"Cannot resolve virtual modifier: " "Cannot resolve virtual modifier: "
"\"%s\" was not previously declared\n", "\"%s\" was not previously declared\n",

20
src/xkbcomp/include.c
View File

@ -201,29 +201,29 @@ LogIncludePaths(struct xkb_context *ctx)
unsigned int i; unsigned int i;
if (xkb_context_num_include_paths(ctx) > 0) { if (xkb_context_num_include_paths(ctx) > 0) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"%d include paths searched:\n", "%d include paths searched:\n",
xkb_context_num_include_paths(ctx)); xkb_context_num_include_paths(ctx));
for (i = 0; i < xkb_context_num_include_paths(ctx); i++) for (i = 0; i < xkb_context_num_include_paths(ctx); i++)
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"\t%s\n", "\t%s\n",
xkb_context_include_path_get(ctx, i)); xkb_context_include_path_get(ctx, i));
} }
else { else {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"There are no include paths to search\n"); "There are no include paths to search\n");
} }
if (xkb_context_num_failed_include_paths(ctx) > 0) { if (xkb_context_num_failed_include_paths(ctx) > 0) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"%d include paths could not be added:\n", "%d include paths could not be added:\n",
xkb_context_num_failed_include_paths(ctx)); xkb_context_num_failed_include_paths(ctx));
for (i = 0; i < xkb_context_num_failed_include_paths(ctx); i++) for (i = 0; i < xkb_context_num_failed_include_paths(ctx); i++)
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"\t%s\n", "\t%s\n",
xkb_context_failed_include_path_get(ctx, i)); xkb_context_failed_include_path_get(ctx, i));
@ -256,7 +256,7 @@ FindFileInXkbPath(struct xkb_context *ctx, const char *name,
buf = asprintf_safe("%s/%s/%s", xkb_context_include_path_get(ctx, i), buf = asprintf_safe("%s/%s/%s", xkb_context_include_path_get(ctx, i),
typeDir, name); typeDir, name);
if (!buf) { if (!buf) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_ALLOCATION_ERROR, XKB_ERROR_ALLOCATION_ERROR,
"Failed to alloc buffer for (%s/%s/%s)\n", "Failed to alloc buffer for (%s/%s/%s)\n",
xkb_context_include_path_get(ctx, i), typeDir, name); xkb_context_include_path_get(ctx, i), typeDir, name);
@ -276,7 +276,7 @@ FindFileInXkbPath(struct xkb_context *ctx, const char *name,
/* We only print warnings if we can't find the file on the first lookup */ /* We only print warnings if we can't find the file on the first lookup */
if (*offset == 0) { if (*offset == 0) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INCLUDED_FILE_NOT_FOUND, XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
"Couldn't find file \"%s/%s\" in include paths\n", "Couldn't find file \"%s/%s\" in include paths\n",
typeDir, name); typeDir, name);
@ -306,7 +306,7 @@ ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
if (xkb_file) { if (xkb_file) {
if (xkb_file->file_type != file_type) { if (xkb_file->file_type != file_type) {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_INCLUDED_FILE, XKB_ERROR_INVALID_INCLUDED_FILE,
"Include file of wrong type (expected %s, got %s); " "Include file of wrong type (expected %s, got %s); "
"Include file \"%s\" ignored\n", "Include file \"%s\" ignored\n",
@ -325,12 +325,12 @@ ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
if (!xkb_file) { if (!xkb_file) {
if (stmt->map) if (stmt->map)
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_INCLUDED_FILE, XKB_ERROR_INVALID_INCLUDED_FILE,
"Couldn't process include statement for '%s(%s)'\n", "Couldn't process include statement for '%s(%s)'\n",
stmt->file, stmt->map); stmt->file, stmt->map);
else else
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_INVALID_INCLUDED_FILE, XKB_ERROR_INVALID_INCLUDED_FILE,
"Couldn't process include statement for '%s'\n", "Couldn't process include statement for '%s'\n",
stmt->file); stmt->file);

30
src/xkbcomp/keycodes.c
View File

@ -99,7 +99,7 @@ AddLedName(KeyNamesInfo *info, enum merge_mode merge, bool same_file,
old = FindLedByName(info, new->name, &old_idx); old = FindLedByName(info, new->name, &old_idx);
if (old) { if (old) {
if (old_idx == new_idx) { if (old_idx == new_idx) {
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple indicators named \"%s\"; " "Multiple indicators named \"%s\"; "
"Identical definitions ignored\n", "Identical definitions ignored\n",
xkb_atom_text(info->ctx, new->name)); xkb_atom_text(info->ctx, new->name));
@ -109,7 +109,7 @@ AddLedName(KeyNamesInfo *info, enum merge_mode merge, bool same_file,
if (report) { if (report) {
xkb_led_index_t use = (replace ? new_idx + 1 : old_idx + 1); xkb_led_index_t use = (replace ? new_idx + 1 : old_idx + 1);
xkb_led_index_t ignore = (replace ? old_idx + 1 : new_idx + 1); xkb_led_index_t ignore = (replace ? old_idx + 1 : new_idx + 1);
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple indicators named %s; Using %d, ignoring %d\n", "Multiple indicators named %s; Using %d, ignoring %d\n",
xkb_atom_text(info->ctx, new->name), use, ignore); xkb_atom_text(info->ctx, new->name), use, ignore);
} }
@ -129,7 +129,8 @@ AddLedName(KeyNamesInfo *info, enum merge_mode merge, bool same_file,
if (report) { if (report) {
const xkb_atom_t use = (replace ? new->name : old->name); const xkb_atom_t use = (replace ? new->name : old->name);
const xkb_atom_t ignore = (replace ? old->name : new->name); const xkb_atom_t ignore = (replace ? old->name : new->name);
log_warn(info->ctx, "Multiple names for indicator %d; " log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple names for indicator %d; "
"Using %s, ignoring %s\n", new_idx + 1, "Using %s, ignoring %s\n", new_idx + 1,
xkb_atom_text(info->ctx, use), xkb_atom_text(info->ctx, use),
xkb_atom_text(info->ctx, ignore)); xkb_atom_text(info->ctx, ignore));
@ -200,7 +201,7 @@ AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
if (old_name == name) { if (old_name == name) {
if (report) if (report)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple identical key name definitions; " "Multiple identical key name definitions; "
"Later occurrences of \"%s = %d\" ignored\n", "Later occurrences of \"%s = %d\" ignored\n",
lname, kc); lname, kc);
@ -208,14 +209,14 @@ AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
} }
else if (merge == MERGE_AUGMENT) { else if (merge == MERGE_AUGMENT) {
if (report) if (report)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple names for keycode %d; " "Multiple names for keycode %d; "
"Using %s, ignoring %s\n", kc, lname, kname); "Using %s, ignoring %s\n", kc, lname, kname);
return true; return true;
} }
else { else {
if (report) if (report)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple names for keycode %d; " "Multiple names for keycode %d; "
"Using %s, ignoring %s\n", kc, kname, lname); "Using %s, ignoring %s\n", kc, kname, lname);
darray_item(info->key_names, kc) = XKB_ATOM_NONE; darray_item(info->key_names, kc) = XKB_ATOM_NONE;
@ -230,7 +231,7 @@ AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
if (merge == MERGE_OVERRIDE) { if (merge == MERGE_OVERRIDE) {
darray_item(info->key_names, old_kc) = XKB_ATOM_NONE; darray_item(info->key_names, old_kc) = XKB_ATOM_NONE;
if (report) if (report)
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_NAME, XKB_WARNING_CONFLICTING_KEY_NAME,
"Key name %s assigned to multiple keys; " "Key name %s assigned to multiple keys; "
"Using %d, ignoring %d\n", kname, kc, old_kc); "Using %d, ignoring %d\n", kname, kc, old_kc);
@ -380,7 +381,7 @@ HandleKeycodeDef(KeyNamesInfo *info, KeycodeDef *stmt, enum merge_mode merge)
} }
if (stmt->value < 0 || stmt->value > XKB_KEYCODE_MAX) { if (stmt->value < 0 || stmt->value > XKB_KEYCODE_MAX) {
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Illegal keycode %lld: must be between 0..%u; " "Illegal keycode %lld: must be between 0..%u; "
"Key ignored\n", (long long) stmt->value, XKB_KEYCODE_MAX); "Key ignored\n", (long long) stmt->value, XKB_KEYCODE_MAX);
return false; return false;
@ -411,7 +412,7 @@ HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge)
use = (merge == MERGE_AUGMENT ? old->real : def->real); use = (merge == MERGE_AUGMENT ? old->real : def->real);
ignore = (merge == MERGE_AUGMENT ? def->real : old->real); ignore = (merge == MERGE_AUGMENT ? def->real : old->real);
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_NAME, XKB_WARNING_CONFLICTING_KEY_NAME,
"Multiple definitions for alias %s; " "Multiple definitions for alias %s; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -442,13 +443,13 @@ HandleKeyNameVar(KeyNamesInfo *info, VarDef *stmt)
return false; return false;
if (elem) { if (elem) {
log_err(info->ctx, "Unknown element %s encountered; " log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown element %s encountered; "
"Default for field %s ignored\n", elem, field); "Default for field %s ignored\n", elem, field);
return false; return false;
} }
if (!istreq(field, "minimum") && !istreq(field, "maximum")) { if (!istreq(field, "minimum") && !istreq(field, "maximum")) {
log_err(info->ctx, "Unknown field encountered; " log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown field encountered; "
"Assignment to field %s ignored\n", field); "Assignment to field %s ignored\n", field);
return false; return false;
} }
@ -466,7 +467,7 @@ HandleLedNameDef(KeyNamesInfo *info, LedNameDef *def,
if (def->ndx < 1 || def->ndx > XKB_MAX_LEDS) { if (def->ndx < 1 || def->ndx > XKB_MAX_LEDS) {
info->errorCount++; info->errorCount++;
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Illegal indicator index (%d) specified; must be between 1 .. %d; " "Illegal indicator index (%d) specified; must be between 1 .. %d; "
"Ignored\n", def->ndx, XKB_MAX_LEDS); "Ignored\n", def->ndx, XKB_MAX_LEDS);
return false; return false;
@ -511,7 +512,7 @@ HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleLedNameDef(info, (LedNameDef *) stmt, merge); ok = HandleLedNameDef(info, (LedNameDef *) stmt, merge);
break; break;
default: default:
log_err(info->ctx, log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Keycode files may define key and indicator names only; " "Keycode files may define key and indicator names only; "
"Ignoring %s\n", stmt_type_to_string(stmt->type)); "Ignoring %s\n", stmt_type_to_string(stmt->type));
ok = false; ok = false;
@ -522,7 +523,8 @@ HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
info->errorCount++; info->errorCount++;
if (info->errorCount > 10) { if (info->errorCount > 10) {
log_err(info->ctx, "Abandoning keycodes file \"%s\"\n", log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Abandoning keycodes file \"%s\"\n",
file->name); file->name);
break; break;
} }

14
src/xkbcomp/keymap.c
View File

@ -248,14 +248,15 @@ CompileKeymap(XkbFile *file, struct xkb_keymap *keymap, enum merge_mode merge)
XKB_WARNING_UNSUPPORTED_GEOMETRY_SECTION, XKB_WARNING_UNSUPPORTED_GEOMETRY_SECTION,
"Geometry sections are not supported; ignoring\n"); "Geometry sections are not supported; ignoring\n");
} else { } else {
log_err(ctx, "Cannot define %s in a keymap file\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot define %s in a keymap file\n",
xkb_file_type_to_string(file->file_type)); xkb_file_type_to_string(file->file_type));
} }
continue; continue;
} }
if (files[file->file_type]) { if (files[file->file_type]) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"More than one %s section in keymap file; " "More than one %s section in keymap file; "
"All sections after the first ignored\n", "All sections after the first ignored\n",
xkb_file_type_to_string(file->file_type)); xkb_file_type_to_string(file->file_type));
@ -274,7 +275,8 @@ CompileKeymap(XkbFile *file, struct xkb_keymap *keymap, enum merge_mode merge)
type <= LAST_KEYMAP_FILE_TYPE; type <= LAST_KEYMAP_FILE_TYPE;
type++) { type++) {
if (files[type] == NULL) { if (files[type] == NULL) {
log_err(ctx, "Required section %s missing from keymap\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Required section %s missing from keymap\n",
xkb_file_type_to_string(type)); xkb_file_type_to_string(type));
ok = false; ok = false;
} }
@ -286,12 +288,14 @@ CompileKeymap(XkbFile *file, struct xkb_keymap *keymap, enum merge_mode merge)
for (type = FIRST_KEYMAP_FILE_TYPE; for (type = FIRST_KEYMAP_FILE_TYPE;
type <= LAST_KEYMAP_FILE_TYPE; type <= LAST_KEYMAP_FILE_TYPE;
type++) { type++) {
log_dbg(ctx, "Compiling %s \"%s\"\n", log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID,
"Compiling %s \"%s\"\n",
xkb_file_type_to_string(type), files[type]->name); xkb_file_type_to_string(type), files[type]->name);
ok = compile_file_fns[type](files[type], keymap, merge); ok = compile_file_fns[type](files[type], keymap, merge);
if (!ok) { if (!ok) {
log_err(ctx, "Failed to compile %s\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to compile %s\n",
xkb_file_type_to_string(type)); xkb_file_type_to_string(type));
return false; return false;
} }

26
src/xkbcomp/rules.c
View File

@ -424,10 +424,14 @@ matcher_include(struct matcher *m, struct scanner *parent_scanner,
if (file) { if (file) {
bool ret = read_rules_file(m->ctx, m, include_depth + 1, file, s.buf); bool ret = read_rules_file(m->ctx, m, include_depth + 1, file, s.buf);
if (!ret) if (!ret)
log_err(m->ctx, "No components returned from included XKB rules \"%s\"\n", s.buf); log_err(m->ctx, XKB_LOG_MESSAGE_NO_ID,
"No components returned from included XKB rules \"%s\"\n",
s.buf);
fclose(file); fclose(file);
} else { } else {
log_err(m->ctx, "Failed to open included XKB rules \"%s\"\n", s.buf); log_err(m->ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to open included XKB rules \"%s\"\n",
s.buf);
} }
} }
@ -1087,7 +1091,8 @@ read_rules_file(struct xkb_context *ctx,
ret = map_file(file, &string, &size); ret = map_file(file, &string, &size);
if (!ret) { if (!ret) {
log_err(ctx, "Couldn't read rules file \"%s\": %s\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Couldn't read rules file \"%s\": %s\n",
path, strerror(errno)); path, strerror(errno));
goto out; goto out;
} }
@ -1126,7 +1131,8 @@ xkb_components_from_rules(struct xkb_context *ctx,
darray_empty(matcher->kccgst[KCCGST_COMPAT]) || darray_empty(matcher->kccgst[KCCGST_COMPAT]) ||
/* darray_empty(matcher->kccgst[KCCGST_GEOMETRY]) || */ /* darray_empty(matcher->kccgst[KCCGST_GEOMETRY]) || */
darray_empty(matcher->kccgst[KCCGST_SYMBOLS])) { darray_empty(matcher->kccgst[KCCGST_SYMBOLS])) {
log_err(ctx, "No components returned from XKB rules \"%s\"\n", path); log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"No components returned from XKB rules \"%s\"\n", path);
ret = false; ret = false;
goto err_out; goto err_out;
} }
@ -1139,19 +1145,23 @@ xkb_components_from_rules(struct xkb_context *ctx,
mval = &matcher->rmlvo.model; mval = &matcher->rmlvo.model;
if (!mval->matched && mval->sval.len > 0) if (!mval->matched && mval->sval.len > 0)
log_err(matcher->ctx, "Unrecognized RMLVO model \"%.*s\" was ignored\n", log_err(matcher->ctx, XKB_LOG_MESSAGE_NO_ID,
"Unrecognized RMLVO model \"%.*s\" was ignored\n",
mval->sval.len, mval->sval.start); mval->sval.len, mval->sval.start);
darray_foreach(mval, matcher->rmlvo.layouts) darray_foreach(mval, matcher->rmlvo.layouts)
if (!mval->matched && mval->sval.len > 0) if (!mval->matched && mval->sval.len > 0)
log_err(matcher->ctx, "Unrecognized RMLVO layout \"%.*s\" was ignored\n", log_err(matcher->ctx, XKB_LOG_MESSAGE_NO_ID,
"Unrecognized RMLVO layout \"%.*s\" was ignored\n",
mval->sval.len, mval->sval.start); mval->sval.len, mval->sval.start);
darray_foreach(mval, matcher->rmlvo.variants) darray_foreach(mval, matcher->rmlvo.variants)
if (!mval->matched && mval->sval.len > 0) if (!mval->matched && mval->sval.len > 0)
log_err(matcher->ctx, "Unrecognized RMLVO variant \"%.*s\" was ignored\n", log_err(matcher->ctx, XKB_LOG_MESSAGE_NO_ID,
"Unrecognized RMLVO variant \"%.*s\" was ignored\n",
mval->sval.len, mval->sval.start); mval->sval.len, mval->sval.start);
darray_foreach(mval, matcher->rmlvo.options) darray_foreach(mval, matcher->rmlvo.options)
if (!mval->matched && mval->sval.len > 0) if (!mval->matched && mval->sval.len > 0)
log_err(matcher->ctx, "Unrecognized RMLVO option \"%.*s\" was ignored\n", log_err(matcher->ctx, XKB_LOG_MESSAGE_NO_ID,
"Unrecognized RMLVO option \"%.*s\" was ignored\n",
mval->sval.len, mval->sval.start); mval->sval.len, mval->sval.start);
err_out: err_out:

3
src/xkbcomp/scanner.c
View File

@ -205,7 +205,8 @@ XkbParseFile(struct xkb_context *ctx, FILE *file,
ok = map_file(file, &string, &size); ok = map_file(file, &string, &size);
if (!ok) { if (!ok) {
log_err(ctx, "Couldn't read XKB file %s: %s\n", log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Couldn't read XKB file %s: %s\n",
file_name, strerror(errno)); file_name, strerror(errno));
return NULL; return NULL;
} }

76
src/xkbcomp/symbols.c
View File

@ -242,7 +242,7 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
xkb_atom_t ignore = (clobber ? into->type : from->type); xkb_atom_t ignore = (clobber ? into->type : from->type);
if (report) { if (report) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS, XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS,
"Multiple definitions for group %d type of key %s; " "Multiple definitions for group %d type of key %s; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -288,7 +288,7 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
ignore = (clobber ? &intoLevel->action : &fromLevel->action); ignore = (clobber ? &intoLevel->action : &fromLevel->action);
if (report) { if (report) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_ACTION, XKB_WARNING_CONFLICTING_KEY_ACTION,
"Multiple actions for level %d/group %u on key %s; " "Multiple actions for level %d/group %u on key %s; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -313,7 +313,7 @@ MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
} }
else if (!XkbLevelsSameSyms(fromLevel, intoLevel)) { else if (!XkbLevelsSameSyms(fromLevel, intoLevel)) {
if (report) { if (report) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_SYMBOL, XKB_WARNING_CONFLICTING_KEY_SYMBOL,
"Multiple symbols for level %d/group %u on key %s; " "Multiple symbols for level %d/group %u on key %s; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -414,7 +414,7 @@ MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from, bool same_file)
} }
if (collide) { if (collide) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_FIELDS, XKB_WARNING_CONFLICTING_KEY_FIELDS,
"Symbol map for key %s redefined; " "Symbol map for key %s redefined; "
"Using %s definition for conflicting fields\n", "Using %s definition for conflicting fields\n",
@ -474,7 +474,7 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
ignore = (clobber ? old->modifier : new->modifier); ignore = (clobber ? old->modifier : new->modifier);
if (new->haveSymbol) { if (new->haveSymbol) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_MODMAP, XKB_WARNING_CONFLICTING_MODMAP,
"Symbol \"%s\" added to modifier map for multiple modifiers; " "Symbol \"%s\" added to modifier map for multiple modifiers; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -482,7 +482,7 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
ModIndexText(info->ctx, &info->mods, use), ModIndexText(info->ctx, &info->mods, use),
ModIndexText(info->ctx, &info->mods, ignore)); ModIndexText(info->ctx, &info->mods, ignore));
} else { } else {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_MODMAP, XKB_WARNING_CONFLICTING_MODMAP,
"Key \"%s\" added to modifier map for multiple modifiers; " "Key \"%s\" added to modifier map for multiple modifiers; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
@ -589,7 +589,7 @@ HandleIncludeSymbols(SymbolsInfo *info, IncludeStmt *include)
if (stmt->modifier) { if (stmt->modifier) {
next_incl.explicit_group = atoi(stmt->modifier) - 1; next_incl.explicit_group = atoi(stmt->modifier) - 1;
if (next_incl.explicit_group >= XKB_MAX_GROUPS) { if (next_incl.explicit_group >= XKB_MAX_GROUPS) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNSUPPORTED_GROUP_INDEX, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Cannot set explicit group to %d - must be between 1..%d; " "Cannot set explicit group to %d - must be between 1..%d; "
"Ignoring group number\n", "Ignoring group number\n",
@ -638,7 +638,7 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (i >= XKB_MAX_GROUPS) { if (i >= XKB_MAX_GROUPS) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNSUPPORTED_GROUP_INDEX, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Too many groups of %s for key %s (max %u); " "Too many groups of %s for key %s (max %u); "
"Ignoring %s defined for extra groups\n", "Ignoring %s defined for extra groups\n",
@ -652,7 +652,7 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (!ExprResolveGroup(info->ctx, arrayNdx, ndx_rtrn)) { if (!ExprResolveGroup(info->ctx, arrayNdx, ndx_rtrn)) {
log_err_with_code(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX, log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Illegal group index for %s of key %s\n" "Illegal group index for %s of key %s\n"
"Definition with non-integer array index ignored\n", "Definition with non-integer array index ignored\n",
name, KeyInfoText(info, keyi)); name, KeyInfoText(info, keyi));
@ -685,7 +685,7 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (value->expr.op != EXPR_KEYSYM_LIST) { if (value->expr.op != EXPR_KEYSYM_LIST) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Expected a list of symbols, found %s; " "Expected a list of symbols, found %s; "
"Ignoring symbols for group %u of %s\n", "Ignoring symbols for group %u of %s\n",
@ -695,7 +695,7 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (groupi->defined & GROUP_FIELD_SYMS) { if (groupi->defined & GROUP_FIELD_SYMS) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY, XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY,
"Symbols for key %s, group %u already defined; " "Symbols for key %s, group %u already defined; "
"Ignoring duplicate definition\n", "Ignoring duplicate definition\n",
@ -757,7 +757,7 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (value->expr.op != EXPR_ACTION_LIST) { if (value->expr.op != EXPR_ACTION_LIST) {
log_wsgo(info->ctx, log_wsgo(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Bad expression type (%d) for action list value; " "Bad expression type (%d) for action list value; "
"Ignoring actions for group %u of %s\n", "Ignoring actions for group %u of %s\n",
value->expr.op, ndx, KeyInfoText(info, keyi)); value->expr.op, ndx, KeyInfoText(info, keyi));
@ -765,7 +765,7 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
} }
if (groupi->defined & GROUP_FIELD_ACTS) { if (groupi->defined & GROUP_FIELD_ACTS) {
log_wsgo(info->ctx, log_wsgo(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Actions for key %s, group %u already defined\n", "Actions for key %s, group %u already defined\n",
KeyInfoText(info, keyi), ndx); KeyInfoText(info, keyi), ndx);
return false; return false;
@ -785,7 +785,7 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
union xkb_action *toAct = &darray_item(groupi->levels, i).action; union xkb_action *toAct = &darray_item(groupi->levels, i).action;
if (!HandleActionDef(info->ctx, info->actions, &info->mods, act, toAct)) if (!HandleActionDef(info->ctx, info->actions, &info->mods, act, toAct))
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_VALUE, XKB_ERROR_INVALID_VALUE,
"Illegal action definition for %s; " "Illegal action definition for %s; "
"Action for group %u/level %u ignored\n", "Action for group %u/level %u ignored\n",
@ -817,7 +817,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
xkb_atom_t val; xkb_atom_t val;
if (!ExprResolveString(info->ctx, value, &val)) { if (!ExprResolveString(info->ctx, value, &val)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"The type field of a key symbol map must be a string; " "The type field of a key symbol map must be a string; "
"Ignoring illegal type definition\n"); "Ignoring illegal type definition\n");
@ -829,7 +829,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
keyi->defined |= KEY_FIELD_DEFAULT_TYPE; keyi->defined |= KEY_FIELD_DEFAULT_TYPE;
} }
else if (!ExprResolveGroup(info->ctx, arrayNdx, &ndx)) { else if (!ExprResolveGroup(info->ctx, arrayNdx, &ndx)) {
log_err_with_code(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX, log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Illegal group index for type of key %s; " "Illegal group index for type of key %s; "
"Definition with non-integer array index ignored\n", "Definition with non-integer array index ignored\n",
KeyInfoText(info, keyi)); KeyInfoText(info, keyi));
@ -856,7 +856,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
if (!ExprResolveModMask(info->ctx, value, MOD_VIRT, &info->mods, if (!ExprResolveModMask(info->ctx, value, MOD_VIRT, &info->mods,
&mask)) { &mask)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNSUPPORTED_MODIFIER_MASK, XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Expected a virtual modifier mask, found %s; " "Expected a virtual modifier mask, found %s; "
"Ignoring virtual modifiers definition for key %s\n", "Ignoring virtual modifiers definition for key %s\n",
@ -900,7 +900,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
unsigned int val; unsigned int val;
if (!ExprResolveEnum(info->ctx, value, &val, repeatEntries)) { if (!ExprResolveEnum(info->ctx, value, &val, repeatEntries)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_VALUE, XKB_ERROR_INVALID_VALUE,
"Illegal repeat setting for %s; " "Illegal repeat setting for %s; "
"Non-boolean repeat setting ignored\n", "Non-boolean repeat setting ignored\n",
@ -916,7 +916,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
bool set; bool set;
if (!ExprResolveBoolean(info->ctx, value, &set)) { if (!ExprResolveBoolean(info->ctx, value, &set)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_VALUE, XKB_ERROR_INVALID_VALUE,
"Illegal groupsWrap setting for %s; " "Illegal groupsWrap setting for %s; "
"Non-boolean value ignored\n", "Non-boolean value ignored\n",
@ -932,7 +932,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
bool set; bool set;
if (!ExprResolveBoolean(info->ctx, value, &set)) { if (!ExprResolveBoolean(info->ctx, value, &set)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_VALUE, XKB_ERROR_INVALID_VALUE,
"Illegal groupsClamp setting for %s; " "Illegal groupsClamp setting for %s; "
"Non-boolean value ignored\n", "Non-boolean value ignored\n",
@ -948,7 +948,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
xkb_layout_index_t grp; xkb_layout_index_t grp;
if (!ExprResolveGroup(info->ctx, value, &grp)) { if (!ExprResolveGroup(info->ctx, value, &grp)) {
log_err_with_code(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX, log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Illegal group index for redirect of key %s; " "Illegal group index for redirect of key %s; "
"Definition with non-integer group ignored\n", "Definition with non-integer group ignored\n",
KeyInfoText(info, keyi)); KeyInfoText(info, keyi));
@ -960,7 +960,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
keyi->defined |= KEY_FIELD_GROUPINFO; keyi->defined |= KEY_FIELD_GROUPINFO;
} }
else { else {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNKNOWN_FIELD, XKB_ERROR_UNKNOWN_FIELD,
"Unknown field %s in a symbol interpretation; " "Unknown field %s in a symbol interpretation; "
"Definition ignored\n", "Definition ignored\n",
@ -986,14 +986,14 @@ SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
} }
if (!ExprResolveGroup(info->ctx, arrayNdx, &group)) { if (!ExprResolveGroup(info->ctx, arrayNdx, &group)) {
log_err_with_code(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX, log_err(info->ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Illegal index in group name definition; " "Illegal index in group name definition; "
"Definition with non-integer array index ignored\n"); "Definition with non-integer array index ignored\n");
return false; return false;
} }
if (!ExprResolveString(info->ctx, value, &name)) { if (!ExprResolveString(info->ctx, value, &name)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Group name must be a string; " "Group name must be a string; "
"Illegal name for group %d ignored\n", group); "Illegal name for group %d ignored\n", group);
@ -1007,7 +1007,7 @@ SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
group_to_use = info->explicit_group; group_to_use = info->explicit_group;
} }
else { else {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_NON_BASE_GROUP_NAME, XKB_WARNING_NON_BASE_GROUP_NAME,
"An explicit group was specified for the '%s' map, " "An explicit group was specified for the '%s' map, "
"but it provides a name for a group other than Group1 (%d); " "but it provides a name for a group other than Group1 (%d); "
@ -1044,27 +1044,27 @@ HandleGlobalVar(SymbolsInfo *info, VarDef *stmt)
} }
else if (!elem && (istreq(field, "groupswrap") || else if (!elem && (istreq(field, "groupswrap") ||
istreq(field, "wrapgroups"))) { istreq(field, "wrapgroups"))) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD, XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupswrap\" not supported; Ignored\n"); "Global \"groupswrap\" not supported; Ignored\n");
ret = true; ret = true;
} }
else if (!elem && (istreq(field, "groupsclamp") || else if (!elem && (istreq(field, "groupsclamp") ||
istreq(field, "clampgroups"))) { istreq(field, "clampgroups"))) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD, XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupsclamp\" not supported; Ignored\n"); "Global \"groupsclamp\" not supported; Ignored\n");
ret = true; ret = true;
} }
else if (!elem && (istreq(field, "groupsredirect") || else if (!elem && (istreq(field, "groupsredirect") ||
istreq(field, "redirectgroups"))) { istreq(field, "redirectgroups"))) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD, XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupsredirect\" not supported; Ignored\n"); "Global \"groupsredirect\" not supported; Ignored\n");
ret = true; ret = true;
} }
else if (!elem && istreq(field, "allownone")) { else if (!elem && istreq(field, "allownone")) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD, XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Radio groups not supported; " "Radio groups not supported; "
"Ignoring \"allownone\" specification\n"); "Ignoring \"allownone\" specification\n");
@ -1087,7 +1087,7 @@ HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
for (; def; def = (VarDef *) def->common.next) { for (; def; def = (VarDef *) def->common.next) {
if (def->name && def->name->expr.op == EXPR_FIELD_REF) { if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_SCOPE, XKB_ERROR_WRONG_SCOPE,
"Cannot set a global default value from within a key statement; " "Cannot set a global default value from within a key statement; "
"Move statements to the global file scope\n"); "Move statements to the global file scope\n");
@ -1132,7 +1132,7 @@ SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
} }
if (warn) { if (warn) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_MULTIPLE_GROUPS_AT_ONCE, XKB_WARNING_MULTIPLE_GROUPS_AT_ONCE,
"For the map %s an explicit group specified, " "For the map %s an explicit group specified, "
"but key %s has more than one group defined; " "but key %s has more than one group defined; "
@ -1198,7 +1198,7 @@ HandleModMapDef(SymbolsInfo *info, ModMapDef *def)
// Handle normal entry // Handle normal entry
ndx = XkbModNameToIndex(&info->mods, def->modifier, MOD_REAL); ndx = XkbModNameToIndex(&info->mods, def->modifier, MOD_REAL);
if (ndx == XKB_MOD_INVALID) { if (ndx == XKB_MOD_INVALID) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_REAL_MODIFIER, XKB_ERROR_INVALID_REAL_MODIFIER,
"Illegal modifier map definition; " "Illegal modifier map definition; "
"Ignoring map for non-modifier \"%s\"\n", "Ignoring map for non-modifier \"%s\"\n",
@ -1224,7 +1224,7 @@ HandleModMapDef(SymbolsInfo *info, ModMapDef *def)
tmp.u.keySym = sym; tmp.u.keySym = sym;
} }
else { else {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_MODMAP_ENTRY, XKB_ERROR_INVALID_MODMAP_ENTRY,
"Modmap entries may contain only key names or keysyms; " "Modmap entries may contain only key names or keysyms; "
"Illegal definition for %s modifier ignored\n", "Illegal definition for %s modifier ignored\n",
@ -1263,7 +1263,7 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleModMapDef(info, (ModMapDef *) stmt); ok = HandleModMapDef(info, (ModMapDef *) stmt);
break; break;
default: default:
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_STATEMENT_TYPE, XKB_ERROR_WRONG_STATEMENT_TYPE,
"Symbols files may not include other types; " "Symbols files may not include other types; "
"Ignoring %s\n", stmt_type_to_string(stmt->type)); "Ignoring %s\n", stmt_type_to_string(stmt->type));
@ -1275,7 +1275,7 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
info->errorCount++; info->errorCount++;
if (info->errorCount > 10) { if (info->errorCount > 10) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_SYNTAX, XKB_ERROR_INVALID_SYNTAX,
"Abandoning symbols file \"%s\"\n", "Abandoning symbols file \"%s\"\n",
file->name); file->name);
@ -1411,7 +1411,7 @@ FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
} }
if (type_name == XKB_ATOM_NONE) { if (type_name == XKB_ATOM_NONE) {
log_warn_with_code(keymap->ctx, log_warn(keymap->ctx,
XKB_WARNING_CANNOT_INFER_KEY_TYPE, XKB_WARNING_CANNOT_INFER_KEY_TYPE,
"Couldn't find an automatic type for key '%s' group %d with %lu levels; " "Couldn't find an automatic type for key '%s' group %d with %lu levels; "
"Using the default type\n", "Using the default type\n",
@ -1425,7 +1425,7 @@ FindTypeForGroup(struct xkb_keymap *keymap, KeyInfo *keyi,
break; break;
if (i >= keymap->num_types) { if (i >= keymap->num_types) {
log_warn_with_code(keymap->ctx, log_warn(keymap->ctx,
XKB_WARNING_UNDEFINED_KEY_TYPE, XKB_WARNING_UNDEFINED_KEY_TYPE,
"The type \"%s\" for key '%s' group %d was not previously defined; " "The type \"%s\" for key '%s' group %d was not previously defined; "
"Using the default type\n", "Using the default type\n",
@ -1613,7 +1613,7 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
continue; continue;
if (key->num_groups < 1) if (key->num_groups < 1)
log_info(info->ctx, log_info(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"No symbols defined for %s\n", "No symbols defined for %s\n",
KeyNameText(info->ctx, key->name)); KeyNameText(info->ctx, key->name));
} }

26
src/xkbcomp/types.c
View File

@ -143,7 +143,7 @@ AddKeyType(KeyTypesInfo *info, KeyTypeInfo *new, bool same_file)
if (old) { if (old) {
if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) { if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) {
if ((same_file && verbosity > 0) || verbosity > 9) { if ((same_file && verbosity > 0) || verbosity > 9) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS, XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS,
"Multiple definitions of the %s key type; " "Multiple definitions of the %s key type; "
"Earlier definition ignored\n", "Earlier definition ignored\n",
@ -252,12 +252,12 @@ SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
xkb_mod_mask_t mods; xkb_mod_mask_t mods;
if (arrayNdx) if (arrayNdx)
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"The modifiers field of a key type is not an array; " "The modifiers field of a key type is not an array; "
"Illegal array subscript ignored\n"); "Illegal array subscript ignored\n");
if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, &mods)) { if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, &mods)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNSUPPORTED_MODIFIER_MASK, XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Key type mask field must be a modifier mask; " "Key type mask field must be a modifier mask; "
"Key type definition ignored\n"); "Key type definition ignored\n");
@ -265,7 +265,7 @@ SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
} }
if (type->defined & TYPE_FIELD_MASK) { if (type->defined & TYPE_FIELD_MASK) {
log_warn(info->ctx, log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
"Multiple modifier mask definitions for key type %s; " "Multiple modifier mask definitions for key type %s; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
xkb_atom_text(info->ctx, type->name), xkb_atom_text(info->ctx, type->name),
@ -301,7 +301,7 @@ AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
old = FindMatchingMapEntry(type, new->mods.mods); old = FindMatchingMapEntry(type, new->mods.mods);
if (old) { if (old) {
if (report && old->level != new->level) { if (report && old->level != new->level) {
log_warn_with_code(info->ctx, log_warn(info->ctx,
XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY, XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY,
"Multiple map entries for %s in %s; " "Multiple map entries for %s in %s; "
"Using %d, ignoring %d\n", "Using %d, ignoring %d\n",
@ -361,7 +361,7 @@ SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
} }
if (!ExprResolveLevel(info->ctx, value, &entry.level)) { if (!ExprResolveLevel(info->ctx, value, &entry.level)) {
log_err_with_code(info->ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL, log_err(info->ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL,
"Level specifications in a key type must be integer; " "Level specifications in a key type must be integer; "
"Ignoring malformed level specification\n"); "Ignoring malformed level specification\n");
return false; return false;
@ -457,7 +457,7 @@ SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods,
&preserve_mods)) { &preserve_mods)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNSUPPORTED_MODIFIER_MASK, XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Preserve value in a key type is not a modifier mask; " "Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n", "Ignoring preserve[%s] in type %s\n",
@ -544,7 +544,7 @@ SetLevelName(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
type, "level name", "integer"); type, "level name", "integer");
if (!ExprResolveString(info->ctx, value, &level_name)) { if (!ExprResolveString(info->ctx, value, &level_name)) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"Non-string name for level %d in key type %s; " "Non-string name for level %d in key type %s; "
"Ignoring illegal level name definition\n", "Ignoring illegal level name definition\n",
@ -580,7 +580,7 @@ SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
type_field = TYPE_FIELD_LEVEL_NAME; type_field = TYPE_FIELD_LEVEL_NAME;
ok = SetLevelName(info, type, arrayNdx, value); ok = SetLevelName(info, type, arrayNdx, value);
} else { } else {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_UNKNOWN_FIELD, XKB_ERROR_UNKNOWN_FIELD,
"Unknown field %s in key type %s; Definition ignored\n", "Unknown field %s in key type %s; Definition ignored\n",
field, TypeTxt(info, type)); field, TypeTxt(info, type));
@ -604,7 +604,7 @@ HandleKeyTypeBody(KeyTypesInfo *info, VarDef *def, KeyTypeInfo *type)
continue; continue;
if (elem && istreq(elem, "type")) { if (elem && istreq(elem, "type")) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_SET_DEFAULT_STATEMENT, XKB_ERROR_INVALID_SET_DEFAULT_STATEMENT,
"Support for changing the default type has been removed; " "Support for changing the default type has been removed; "
"Statement ignored\n"); "Statement ignored\n");
@ -660,7 +660,7 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge); ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge);
break; break;
case STMT_VAR: case STMT_VAR:
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_STATEMENT_TYPE, XKB_ERROR_WRONG_STATEMENT_TYPE,
"Support for changing the default type has been removed; " "Support for changing the default type has been removed; "
"Statement ignored\n"); "Statement ignored\n");
@ -670,7 +670,7 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge); ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge);
break; break;
default: default:
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_WRONG_STATEMENT_TYPE, XKB_ERROR_WRONG_STATEMENT_TYPE,
"Key type files may not include other declarations; " "Key type files may not include other declarations; "
"Ignoring %s\n", stmt_type_to_string(stmt->type)); "Ignoring %s\n", stmt_type_to_string(stmt->type));
@ -682,7 +682,7 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
info->errorCount++; info->errorCount++;
if (info->errorCount > 10) { if (info->errorCount > 10) {
log_err_with_code(info->ctx, log_err(info->ctx,
XKB_ERROR_INVALID_SYNTAX, XKB_ERROR_INVALID_SYNTAX,
"Abandoning keytypes file \"%s\"\n", file->name); "Abandoning keytypes file \"%s\"\n", file->name);
break; break;

8
src/xkbcomp/vmod.c
View File

@ -48,7 +48,7 @@ HandleVModDef(struct xkb_context *ctx, struct xkb_mod_set *mods,
* through modifier_map or some such. * through modifier_map or some such.
*/ */
if (!ExprResolveModMask(ctx, stmt->value, MOD_REAL, mods, &mapping)) { if (!ExprResolveModMask(ctx, stmt->value, MOD_REAL, mods, &mapping)) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Declaration of %s ignored\n", "Declaration of %s ignored\n",
xkb_atom_text(ctx, stmt->name)); xkb_atom_text(ctx, stmt->name));
return false; return false;
@ -61,7 +61,7 @@ HandleVModDef(struct xkb_context *ctx, struct xkb_mod_set *mods,
xkb_mods_enumerate(i, mod, mods) { xkb_mods_enumerate(i, mod, mods) {
if (mod->name == stmt->name) { if (mod->name == stmt->name) {
if (mod->type != MOD_VIRT) { if (mod->type != MOD_VIRT) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Can't add a virtual modifier named \"%s\"; " "Can't add a virtual modifier named \"%s\"; "
"there is already a non-virtual modifier with this name! Ignored\n", "there is already a non-virtual modifier with this name! Ignored\n",
xkb_atom_text(ctx, mod->name)); xkb_atom_text(ctx, mod->name));
@ -77,7 +77,7 @@ HandleVModDef(struct xkb_context *ctx, struct xkb_mod_set *mods,
use = (merge == MERGE_OVERRIDE ? mapping : mod->mapping); use = (merge == MERGE_OVERRIDE ? mapping : mod->mapping);
ignore = (merge == MERGE_OVERRIDE ? mod->mapping : mapping); ignore = (merge == MERGE_OVERRIDE ? mod->mapping : mapping);
log_warn(ctx, log_warn(ctx, XKB_LOG_MESSAGE_NO_ID,
"Virtual modifier %s defined multiple times; " "Virtual modifier %s defined multiple times; "
"Using %s, ignoring %s\n", "Using %s, ignoring %s\n",
xkb_atom_text(ctx, stmt->name), xkb_atom_text(ctx, stmt->name),
@ -93,7 +93,7 @@ HandleVModDef(struct xkb_context *ctx, struct xkb_mod_set *mods,
} }
if (mods->num_mods >= XKB_MAX_MODS) { if (mods->num_mods >= XKB_MAX_MODS) {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Too many modifiers defined (maximum %d)\n", "Too many modifiers defined (maximum %d)\n",
XKB_MAX_MODS); XKB_MAX_MODS);
return false; return false;

9
src/xkbcomp/xkbcomp-priv.h
View File

@ -82,7 +82,7 @@ static inline bool
ReportNotArray(struct xkb_context *ctx, const char *type, const char *field, ReportNotArray(struct xkb_context *ctx, const char *type, const char *field,
const char *name) const char *name)
{ {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_WRONG_FIELD_TYPE, XKB_ERROR_WRONG_FIELD_TYPE,
"The %s %s field is not an array; " "The %s %s field is not an array; "
"Ignoring illegal assignment in %s\n", "Ignoring illegal assignment in %s\n",
@ -94,7 +94,7 @@ static inline bool
ReportShouldBeArray(struct xkb_context *ctx, const char *type, ReportShouldBeArray(struct xkb_context *ctx, const char *type,
const char *field, const char *name) const char *field, const char *name)
{ {
log_err_with_code(ctx, log_err(ctx,
XKB_ERROR_EXPECTED_ARRAY_ENTRY, XKB_ERROR_EXPECTED_ARRAY_ENTRY,
"Missing subscript for %s %s; " "Missing subscript for %s %s; "
"Ignoring illegal assignment in %s\n", "Ignoring illegal assignment in %s\n",
@ -106,7 +106,8 @@ static inline bool
ReportBadType(struct xkb_context *ctx, xkb_message_code_t code, const char *type, ReportBadType(struct xkb_context *ctx, xkb_message_code_t code, const char *type,
const char *field, const char *name, const char *wanted) const char *field, const char *name, const char *wanted)
{ {
log_err_with_code(ctx, code, "The %s %s field must be a %s; " log_err(ctx, code,
"The %s %s field must be a %s; "
"Ignoring illegal assignment in %s\n", "Ignoring illegal assignment in %s\n",
type, field, wanted, name); type, field, wanted, name);
return false; return false;
@ -116,7 +117,7 @@ static inline bool
ReportBadField(struct xkb_context *ctx, const char *type, const char *field, ReportBadField(struct xkb_context *ctx, const char *type, const char *field,
const char *name) const char *name)
{ {
log_err(ctx, log_err(ctx, XKB_LOG_MESSAGE_NO_ID,
"Unknown %s field %s in %s; " "Unknown %s field %s in %s; "
"Ignoring assignment to unknown field in %s\n", "Ignoring assignment to unknown field in %s\n",
type, field, name, name); type, field, name, name);

18
src/xkbcomp/xkbcomp.c
View File

@ -36,14 +36,14 @@ static bool
compile_keymap_file(struct xkb_keymap *keymap, XkbFile *file) compile_keymap_file(struct xkb_keymap *keymap, XkbFile *file)
{ {
if (file->file_type != FILE_TYPE_KEYMAP) { if (file->file_type != FILE_TYPE_KEYMAP) {
log_err(keymap->ctx, log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Cannot compile a %s file alone into a keymap\n", "Cannot compile a %s file alone into a keymap\n",
xkb_file_type_to_string(file->file_type)); xkb_file_type_to_string(file->file_type));
return false; return false;
} }
if (!CompileKeymap(file, keymap, MERGE_OVERRIDE)) { if (!CompileKeymap(file, keymap, MERGE_OVERRIDE)) {
log_err(keymap->ctx, log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to compile keymap\n"); "Failed to compile keymap\n");
return false; return false;
} }
@ -59,7 +59,7 @@ text_v1_keymap_new_from_names(struct xkb_keymap *keymap,
struct xkb_component_names kccgst; struct xkb_component_names kccgst;
XkbFile *file; XkbFile *file;
log_dbg(keymap->ctx, log_dbg(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Compiling from RMLVO: rules '%s', model '%s', layout '%s', " "Compiling from RMLVO: rules '%s', model '%s', layout '%s', "
"variant '%s', options '%s'\n", "variant '%s', options '%s'\n",
rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant, rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant,
@ -67,7 +67,7 @@ text_v1_keymap_new_from_names(struct xkb_keymap *keymap,
ok = xkb_components_from_rules(keymap->ctx, rmlvo, &kccgst); ok = xkb_components_from_rules(keymap->ctx, rmlvo, &kccgst);
if (!ok) { if (!ok) {
log_err(keymap->ctx, log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Couldn't look up rules '%s', model '%s', layout '%s', " "Couldn't look up rules '%s', model '%s', layout '%s', "
"variant '%s', options '%s'\n", "variant '%s', options '%s'\n",
rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant, rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant,
@ -75,7 +75,7 @@ text_v1_keymap_new_from_names(struct xkb_keymap *keymap,
return false; return false;
} }
log_dbg(keymap->ctx, log_dbg(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Compiling from KcCGST: keycodes '%s', types '%s', " "Compiling from KcCGST: keycodes '%s', types '%s', "
"compat '%s', symbols '%s'\n", "compat '%s', symbols '%s'\n",
kccgst.keycodes, kccgst.types, kccgst.compat, kccgst.symbols); kccgst.keycodes, kccgst.types, kccgst.compat, kccgst.symbols);
@ -88,7 +88,7 @@ text_v1_keymap_new_from_names(struct xkb_keymap *keymap,
free(kccgst.symbols); free(kccgst.symbols);
if (!file) { if (!file) {
log_err(keymap->ctx, log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to generate parsed XKB file from components\n"); "Failed to generate parsed XKB file from components\n");
return false; return false;
} }
@ -107,7 +107,8 @@ text_v1_keymap_new_from_string(struct xkb_keymap *keymap,
xkb_file = XkbParseString(keymap->ctx, string, len, "(input string)", NULL); xkb_file = XkbParseString(keymap->ctx, string, len, "(input string)", NULL);
if (!xkb_file) { if (!xkb_file) {
log_err(keymap->ctx, "Failed to parse input xkb string\n"); log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to parse input xkb string\n");
return false; return false;
} }
@ -124,7 +125,8 @@ text_v1_keymap_new_from_file(struct xkb_keymap *keymap, FILE *file)
xkb_file = XkbParseFile(keymap->ctx, file, "(unknown file)", NULL); xkb_file = XkbParseFile(keymap->ctx, file, "(unknown file)", NULL);
if (!xkb_file) { if (!xkb_file) {
log_err(keymap->ctx, "Failed to parse input xkb file\n"); log_err(keymap->ctx, XKB_LOG_MESSAGE_NO_ID,
"Failed to parse input xkb file\n");
return false; return false;
} }

28
test/log.c
View File

@ -86,25 +86,25 @@ main(void)
xkb_context_set_user_data(ctx, &log_string); xkb_context_set_user_data(ctx, &log_string);
xkb_context_set_log_fn(ctx, log_fn); xkb_context_set_log_fn(ctx, log_fn);
log_warn(ctx, "first warning: %d\n", 87); log_warn(ctx, XKB_LOG_MESSAGE_NO_ID, "first warning: %d\n", 87);
log_info(ctx, "first info\n"); log_info(ctx, XKB_LOG_MESSAGE_NO_ID, "first info\n");
log_dbg(ctx, "first debug: %s\n", "hello"); log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID, "first debug: %s\n", "hello");
log_err(ctx, "first error: %lu\n", 115415UL); log_err(ctx, XKB_LOG_MESSAGE_NO_ID, "first error: %lu\n", 115415UL);
log_vrb(ctx, 5, XKB_LOG_MESSAGE_NO_ID, "first verbose 5\n"); log_vrb(ctx, 5, XKB_LOG_MESSAGE_NO_ID, "first verbose 5\n");
xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_DEBUG); xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_DEBUG);
log_warn(ctx, "second warning: %d\n", 87); log_warn(ctx, XKB_LOG_MESSAGE_NO_ID, "second warning: %d\n", 87);
log_dbg(ctx, "second debug: %s %s\n", "hello", "world"); log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID, "second debug: %s %s\n", "hello", "world");
log_info(ctx, "second info\n"); log_info(ctx, XKB_LOG_MESSAGE_NO_ID, "second info\n");
log_err(ctx, "second error: %lu\n", 115415UL); log_err(ctx, XKB_ERROR_MALFORMED_NUMBER_LITERAL, "second error: %lu\n", 115415UL);
log_vrb(ctx, 6, XKB_LOG_MESSAGE_NO_ID, "second verbose 6\n"); log_vrb(ctx, 6, XKB_LOG_MESSAGE_NO_ID, "second verbose 6\n");
xkb_context_set_log_verbosity(ctx, 0); xkb_context_set_log_verbosity(ctx, 0);
xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL); xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL);
log_warn(ctx, "third warning: %d\n", 87); log_warn(ctx, XKB_LOG_MESSAGE_NO_ID, "third warning: %d\n", 87);
log_dbg(ctx, "third debug: %s %s\n", "hello", "world"); log_dbg(ctx, XKB_LOG_MESSAGE_NO_ID, "third debug: %s %s\n", "hello", "world");
log_info(ctx, "third info\n"); log_info(ctx, XKB_LOG_MESSAGE_NO_ID, "third info\n");
log_err(ctx, "third error: %lu\n", 115415UL); log_err(ctx, XKB_LOG_MESSAGE_NO_ID, "third error: %lu\n", 115415UL);
log_vrb(ctx, 0, XKB_LOG_MESSAGE_NO_ID, "third verbose 0\n"); log_vrb(ctx, 0, XKB_LOG_MESSAGE_NO_ID, "third verbose 0\n");
printf("%s", log_string.item); printf("%s", log_string.item);
@ -112,11 +112,11 @@ main(void)
assert(streq(log_string.item, assert(streq(log_string.item,
"warning: first warning: 87\n" "warning: first warning: 87\n"
"error: first error: 115415\n" "error: first error: 115415\n"
"warning: [XKB-000] first verbose 5\n" "warning: first verbose 5\n"
"warning: second warning: 87\n" "warning: second warning: 87\n"
"debug: second debug: hello world\n" "debug: second debug: hello world\n"
"info: second info\n" "info: second info\n"
"error: second error: 115415\n")); "error: [XKB-034] second error: 115415\n"));
xkb_context_unref(ctx); xkb_context_unref(ctx);
darray_free(log_string); darray_free(log_string);