From e037f518624cdd4c694b2b696ae314382b03ac0b Mon Sep 17 00:00:00 2001 From: Ran Benita Date: Sat, 21 Jul 2012 14:53:49 +0300 Subject: [PATCH] action: use new log functions Signed-off-by: Ran Benita --- src/utils.h | 1 - src/xkbcomp/action.c | 295 ++++++++++++++++++++++++++++----------------------- 2 files changed, 164 insertions(+), 132 deletions(-) diff --git a/src/utils.h b/src/utils.h index 7d4e612..5e4000a 100644 --- a/src/utils.h +++ b/src/utils.h @@ -37,7 +37,6 @@ #define UNCONSTIFY(const_ptr) ((void *) (uintptr_t) (const_ptr)) #define uDupString(s) ((s) ? strdup(s) : NULL) -#define uStringText(s) ((s) == NULL ? "" : (s)) #define uStrCasePrefix(s1, s2) (strncasecmp((s1), (s2), strlen(s1)) == 0) /* Compiler Attributes */ diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c index badd05a..d648384 100644 --- a/src/xkbcomp/action.c +++ b/src/xkbcomp/action.c @@ -166,46 +166,54 @@ fieldText(unsigned field) /***====================================================================***/ static inline bool -ReportMismatch(unsigned action, unsigned field, const char *type) +ReportMismatch(struct xkb_keymap *keymap, unsigned action, unsigned field, + const char *type) { - ERROR("Value of %s field must be of type %s\n", fieldText(field), type); - ACTION("Action %s definition ignored\n", XkbcActionTypeText(action)); + log_err(keymap->ctx, + "Value of %s field must be of type %s; " + "Action %s definition ignored\n", + fieldText(field), type, XkbcActionTypeText(action)); return false; } static inline bool -ReportIllegal(unsigned action, unsigned field) +ReportIllegal(struct xkb_keymap *keymap, unsigned action, unsigned field) { - ERROR("Field %s is not defined for an action of type %s\n", - fieldText(field), XkbcActionTypeText(action)); - ACTION("Action definition ignored\n"); + log_err(keymap->ctx, + "Field %s is not defined for an action of type %s; " + "Action definition ignored\n", + fieldText(field), XkbcActionTypeText(action)); return false; } static inline bool -ReportActionNotArray(unsigned action, unsigned field) +ReportActionNotArray(struct xkb_keymap *keymap, unsigned action, + unsigned field) { - ERROR("The %s field in the %s action is not an array\n", - fieldText(field), XkbcActionTypeText(action)); - ACTION("Action definition ignored\n"); + log_err(keymap->ctx, + "The %s field in the %s action is not an array; " + "Action definition ignored\n", + fieldText(field), XkbcActionTypeText(action)); return false; } static inline bool -ReportNotFound(unsigned action, unsigned field, const char *what, - const char *bad) +ReportNotFound(struct xkb_keymap *keymap, unsigned action, unsigned field, + const char *what, const char *bad) { - ERROR("%s named %s not found\n", what, bad); - ACTION("Ignoring the %s field of an %s action\n", fieldText(field), - XkbcActionTypeText(action)); + log_err(keymap->ctx, + "%s named %s not found; " + "Ignoring the %s field of an %s action\n", + what, bad, fieldText(field), XkbcActionTypeText(action)); return false; } static bool HandleNoAction(struct xkb_keymap *keymap, struct xkb_any_action *action, unsigned field, ExprDef *array_ndx, ExprDef *value) + { - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -222,7 +230,7 @@ CheckLatchLockFlags(struct xkb_keymap *keymap, unsigned action, else return false; /* WSGO! */ if (!ExprResolveBoolean(keymap->ctx, value, &result)) - return ReportMismatch(action, field, "boolean"); + return ReportMismatch(keymap, action, field, "boolean"); if (result.uval) *flags_inout |= tmp; else @@ -248,7 +256,7 @@ CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value, } } if (!ExprResolveVModMask(value, &rtrn, keymap)) - return ReportMismatch(action, F_Modifiers, "modifier mask"); + return ReportMismatch(keymap, action, F_Modifiers, "modifier mask"); *mods_rtrn = rtrn.uval; *flags_inout &= ~XkbSA_UseModMapMods; return true; @@ -268,7 +276,7 @@ HandleSetLatchMods(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_ClearLocks: case F_LatchToLock: case F_Modifiers: - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); } } switch (field) { @@ -291,7 +299,7 @@ HandleSetLatchMods(struct xkb_keymap *keymap, struct xkb_any_action *action, } return false; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -303,7 +311,7 @@ HandleLockMods(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_mod_action *) action; if ((array_ndx != NULL) && (field == F_Modifiers)) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); switch (field) { case F_Modifiers: t1 = act->flags; @@ -315,7 +323,7 @@ HandleLockMods(struct xkb_keymap *keymap, struct xkb_any_action *action, } return false; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -336,7 +344,8 @@ CheckGroupField(struct xkb_keymap *keymap, unsigned action, } if (!ExprResolveGroup(keymap->ctx, spec, &rtrn)) - return ReportMismatch(action, F_Group, "integer (range 1..8)"); + return ReportMismatch(keymap, action, F_Group, + "integer (range 1..8)"); if (value->op == OpNegate) *grp_rtrn = -rtrn.ival; else if (value->op == OpUnaryPlus) @@ -361,7 +370,7 @@ HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_ClearLocks: case F_LatchToLock: case F_Group: - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); } } switch (field) { @@ -383,7 +392,7 @@ HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, } return false; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -396,7 +405,7 @@ HandleLockGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_group_action *) action; if ((array_ndx != NULL) && (field == F_Group)) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (field == F_Group) { t1 = act->flags; if (CheckGroupField(keymap, action->type, value, &t1, &t2)) { @@ -406,7 +415,7 @@ HandleLockGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, } return false; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -419,7 +428,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_pointer_action *) action; if ((array_ndx != NULL) && ((field == F_X) || (field == F_Y))) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if ((field == F_X) || (field == F_Y)) { if ((value->op == OpNegate) || (value->op == OpUnaryPlus)) @@ -427,7 +436,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, else absolute = true; if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "integer"); + return ReportMismatch(keymap, action->type, field, "integer"); if (field == F_X) { if (absolute) act->flags |= XkbSA_MoveAbsoluteX; @@ -442,13 +451,13 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if (field == F_Accel) { if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "boolean"); + return ReportMismatch(keymap, action->type, field, "boolean"); if (rtrn.uval) act->flags &= ~XkbSA_NoAcceleration; else act->flags |= XkbSA_NoAcceleration; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static const LookupEntry lockWhich[] = { @@ -469,13 +478,14 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_pointer_button_action *) action; if (field == F_Button) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveButton(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, + return ReportMismatch(keymap, action->type, field, "integer (range 1..5)"); if ((rtrn.ival < 0) || (rtrn.ival > 5)) { - ERROR("Button must specify default or be in the range 1..5\n"); - ACTION("Illegal button value %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Button must specify default or be in the range 1..5; " + "Illegal button value %d ignored\n", rtrn.ival); return false; } act->button = rtrn.ival; @@ -483,27 +493,29 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if ((action->type == XkbSA_LockPtrBtn) && (field == F_Affect)) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveEnum(keymap->ctx, value, &rtrn, lockWhich)) - return ReportMismatch(action->type, field, "lock or unlock"); + return ReportMismatch(keymap, action->type, field, + "lock or unlock"); act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock); act->flags |= rtrn.ival; return true; } else if (field == F_Count) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveButton(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "integer"); + return ReportMismatch(keymap, action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("The count field must have a value in the range 0..255\n"); - ACTION("Illegal count %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "The count field must have a value in the range 0..255; " + "Illegal count %d ignored\n", rtrn.ival); return false; } act->count = rtrn.ival; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static const LookupEntry ptrDflts[] = { @@ -523,16 +535,17 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_pointer_default_action *) action; if (field == F_Affect) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveEnum(keymap->ctx, value, &rtrn, ptrDflts)) - return ReportMismatch(action->type, field, "pointer component"); + return ReportMismatch(keymap, action->type, field, + "pointer component"); act->affect = rtrn.uval; return true; } else if ((field == F_Button) || (field == F_Value)) { ExprDef *btn; if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if ((value->op == OpNegate) || (value->op == OpUnaryPlus)) { act->flags &= ~XkbSA_DfltBtnAbsolute; btn = value->value.child; @@ -543,16 +556,18 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, } if (!ExprResolveButton(keymap->ctx, btn, &rtrn)) - return ReportMismatch(action->type, field, + return ReportMismatch(keymap, action->type, field, "integer (range 1..5)"); if ((rtrn.ival < 0) || (rtrn.ival > 5)) { - ERROR("New default button value must be in the range 1..5\n"); - ACTION("Illegal default button value %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "New default button value must be in the range 1..5; " + "Illegal default button value %d ignored\n", rtrn.ival); return false; } if (rtrn.ival == 0) { - ERROR("Cannot set default pointer button to \"default\"\n"); - ACTION("Illegal default button setting ignored\n"); + log_err(keymap->ctx, + "Cannot set default pointer button to \"default\"; " + "Illegal default button setting ignored\n"); return false; } if (value->op == OpNegate) @@ -561,7 +576,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, act->value = rtrn.ival; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static const LookupEntry isoNames[] = { @@ -591,7 +606,7 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, switch (field) { case F_Modifiers: if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); flags = act->flags; if (CheckModifierField(keymap, action->type, value, &flags, &mods)) { act->flags = flags & (~XkbSA_ISODfltIsGroup); @@ -603,7 +618,7 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Group: if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); flags = act->flags; if (CheckGroupField(keymap, action->type, value, &flags, &group)) { act->flags = flags | XkbSA_ISODfltIsGroup; @@ -614,13 +629,14 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Affect: if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveMask(keymap->ctx, value, &rtrn, isoNames)) - return ReportMismatch(action->type, field, "keyboard component"); + return ReportMismatch(keymap, action->type, field, + "keyboard component"); act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -634,7 +650,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, if (field == F_Screen) { ExprDef *scrn; if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if ((value->op == OpNegate) || (value->op == OpUnaryPlus)) { act->flags &= ~XkbSA_SwitchAbsolute; scrn = value->value.child; @@ -645,10 +661,12 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, } if (!ExprResolveInteger(keymap->ctx, scrn, &rtrn)) - return ReportMismatch(action->type, field, "integer (0..255)"); + return ReportMismatch(keymap, action->type, field, + "integer (0..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("Screen index must be in the range 1..255\n"); - ACTION("Illegal screen value %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Screen index must be in the range 1..255; " + "Illegal screen value %d ignored\n", rtrn.ival); return false; } if (value->op == OpNegate) @@ -659,16 +677,16 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if (field == F_Same) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "boolean"); + return ReportMismatch(keymap, action->type, field, "boolean"); if (rtrn.uval) act->flags &= ~XkbSA_SwitchApplication; else act->flags |= XkbSA_SwitchApplication; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } const LookupEntry ctrlNames[] = { @@ -704,13 +722,14 @@ HandleSetLockControls(struct xkb_keymap *keymap, act = (struct xkb_controls_action *) action; if (field == F_Controls) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveMask(keymap->ctx, value, &rtrn, ctrlNames)) - return ReportMismatch(action->type, field, "controls mask"); + return ReportMismatch(keymap, action->type, field, + "controls mask"); act->ctrls = rtrn.uval; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static const LookupEntry evNames[] = { @@ -734,9 +753,10 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, switch (field) { case F_Report: if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveMask(keymap->ctx, value, &rtrn, evNames)) - return ReportMismatch(action->type, field, "key event mask"); + return ReportMismatch(keymap, action->type, field, + "key event mask"); act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease); act->flags = rtrn.uval & (XkbSA_MessageOnPress | XkbSA_MessageOnRelease); @@ -744,9 +764,9 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_GenKeyEvent: if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveBoolean(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "boolean"); + return ReportMismatch(keymap, action->type, field, "boolean"); if (rtrn.uval) act->flags |= XkbSA_MessageGenKeyEvent; else @@ -756,12 +776,13 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Data: if (array_ndx == NULL) { if (!ExprResolveString(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "string"); + return ReportMismatch(keymap, action->type, field, "string"); else { int len = strlen(rtrn.str); if ((len < 1) || (len > 6)) { - WARN("An action message can hold only 6 bytes\n"); - ACTION("Extra %d bytes ignored\n", len - 6); + log_warn(keymap->ctx, + "An action message can hold only 6 bytes; " + "Extra %d bytes ignored\n", len - 6); } strncpy((char *) act->message, rtrn.str, 6); } @@ -770,28 +791,31 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, else { unsigned ndx; if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) { - ERROR("Array subscript must be integer\n"); - ACTION("Illegal subscript ignored\n"); + log_err(keymap->ctx, + "Array subscript must be integer; " + "Illegal subscript ignored\n"); return false; } ndx = rtrn.uval; if (ndx > 5) { - ERROR("An action message is at most 6 bytes long\n"); - ACTION("Attempt to use data[%d] ignored\n", ndx); + log_err(keymap->ctx, + "An action message is at most 6 bytes long; " + "Attempt to use data[%d] ignored\n", ndx); return false; } if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "integer"); + return ReportMismatch(keymap, action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("Message data must be in the range 0..255\n"); - ACTION("Illegal datum %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Message data must be in the range 0..255; " + "Illegal datum %d ignored\n", rtrn.ival); return false; } act->message[ndx] = rtrn.uval; } return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -805,18 +829,18 @@ HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action, unsigned long tmp; if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); act = (struct xkb_redirect_key_action *) action; switch (field) { case F_Keycode: if (!ExprResolveKeyName(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "key name"); + return ReportMismatch(keymap, action->type, field, "key name"); tmp = KeyNameToLong(rtrn.name); key = FindNamedKey(keymap, tmp, true, CreateKeyNames(keymap), 0); if (!key) - return ReportNotFound(action->type, field, "Key", + return ReportNotFound(keymap, action->type, field, "Key", XkbcKeyNameText(rtrn.name)); act->new_kc = XkbKeyGetKeycode(keymap, key); return true; @@ -841,7 +865,7 @@ HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action, } return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -854,13 +878,14 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, act = (struct xkb_device_button_action *) action; if (field == F_Button) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, + return ReportMismatch(keymap, action->type, field, "integer (range 1..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("Button must specify default or be in the range 1..255\n"); - ACTION("Illegal button value %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Button must specify default or be in the range 1..255; " + "Illegal button value %d ignored\n", rtrn.ival); return false; } act->button = rtrn.ival; @@ -868,21 +893,23 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if ((action->type == XkbSA_LockDeviceBtn) && (field == F_Affect)) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveEnum(keymap->ctx, value, &rtrn, lockWhich)) - return ReportMismatch(action->type, field, "lock or unlock"); + return ReportMismatch(keymap, action->type, field, + "lock or unlock"); act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock); act->flags |= rtrn.ival; return true; } else if (field == F_Count) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveButton(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "integer"); + return ReportMismatch(keymap, action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("The count field must have a value in the range 0..255\n"); - ACTION("Illegal count %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "The count field must have a value in the range 0..255; " + "Illegal count %d ignored\n", rtrn.ival); return false; } act->count = rtrn.ival; @@ -890,19 +917,20 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, } else if (field == F_Device) { if (array_ndx != NULL) - return ReportActionNotArray(action->type, field); + return ReportActionNotArray(keymap, action->type, field); if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, + return ReportMismatch(keymap, action->type, field, "integer (range 1..255)"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("Device must specify default or be in the range 1..255\n"); - ACTION("Illegal device value %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Device must specify default or be in the range 1..255; " + "Illegal device value %d ignored\n", rtrn.ival); return false; } act->device = rtrn.ival; return true; } - return ReportIllegal(action->type, field); + return ReportIllegal(keymap, action->type, field); } static bool @@ -928,10 +956,11 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, switch (field) { case F_Type: if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(PrivateAction, field, "integer"); + return ReportMismatch(keymap, PrivateAction, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("Private action type must be in the range 0..255\n"); - ACTION("Illegal type %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "Private action type must be in the range 0..255; " + "Illegal type %d ignored\n", rtrn.ival); return false; } action->type = rtrn.uval; @@ -940,12 +969,13 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, case F_Data: if (array_ndx == NULL) { if (!ExprResolveString(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "string"); + return ReportMismatch(keymap, action->type, field, "string"); else { int len = strlen(rtrn.str); if ((len < 1) || (len > 7)) { - WARN("A private action has 7 data bytes\n"); - ACTION("Extra %d bytes ignored\n", len - 6); + log_warn(keymap->ctx, + "A private action has 7 data bytes; " + "Extra %d bytes ignored\n", len - 6); return false; } strncpy((char *) action->data, rtrn.str, sizeof action->data); @@ -956,28 +986,31 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, else { unsigned ndx; if (!ExprResolveInteger(keymap->ctx, array_ndx, &rtrn)) { - ERROR("Array subscript must be integer\n"); - ACTION("Illegal subscript ignored\n"); + log_err(keymap->ctx, + "Array subscript must be integer; " + "Illegal subscript ignored\n"); return false; } ndx = rtrn.uval; if (ndx >= sizeof action->data) { - ERROR("The data for a private action is 18 bytes long\n"); - ACTION("Attempt to use data[%d] ignored\n", ndx); + log_err(keymap->ctx, + "The data for a private action is 18 bytes long; " + "Attempt to use data[%d] ignored\n", ndx); return false; } if (!ExprResolveInteger(keymap->ctx, value, &rtrn)) - return ReportMismatch(action->type, field, "integer"); + return ReportMismatch(keymap, action->type, field, "integer"); if ((rtrn.ival < 0) || (rtrn.ival > 255)) { - ERROR("All data for a private action must be 0..255\n"); - ACTION("Illegal datum %d ignored\n", rtrn.ival); + log_err(keymap->ctx, + "All data for a private action must be 0..255; " + "Illegal datum %d ignored\n", rtrn.ival); return false; } action->data[ndx] = rtrn.uval; return true; } } - return ReportIllegal(PrivateAction, field); + return ReportIllegal(keymap, PrivateAction, field); } typedef bool (*actionHandler)(struct xkb_keymap *keymap, @@ -1040,17 +1073,17 @@ HandleActionDef(ExprDef * def, ActionsInit(keymap->ctx); if (def->op != ExprActionDecl) { - ERROR("Expected an action definition, found %s\n", - exprOpText(def->op)); + log_err(keymap->ctx, "Expected an action definition, found %s\n", + exprOpText(def->op)); return false; } str = xkb_atom_text(keymap->ctx, def->value.action.name); if (!str) { - WSGO("Missing name in action definition!!\n"); + log_wsgo(keymap->ctx, "Missing name in action definition!!\n"); return false; } if (!stringToAction(str, &tmp)) { - ERROR("Unknown action %s\n", str); + log_err(keymap->ctx, "Unknown action %s\n", str); return false; } action->type = hndlrType = tmp; @@ -1096,15 +1129,16 @@ HandleActionDef(ExprDef * def, return false; /* internal error -- already reported */ if (elemRtrn.str != NULL) { - ERROR("Cannot change defaults in an action definition\n"); - ACTION("Ignoring attempt to change %s.%s\n", elemRtrn.str, - fieldRtrn.str); + log_err(keymap->ctx, + "Cannot change defaults in an action definition; " + "Ignoring attempt to change %s.%s\n", + elemRtrn.str, fieldRtrn.str); free(elemRtrn.str); free(fieldRtrn.str); return false; } if (!stringToField(fieldRtrn.str, &fieldNdx)) { - ERROR("Unknown field name %s\n", uStringText(fieldRtrn.str)); + log_err(keymap->ctx, "Unknown field name %s\n", fieldRtrn.str); free(elemRtrn.str); free(fieldRtrn.str); return false; @@ -1121,10 +1155,8 @@ HandleActionDef(ExprDef * def, /***====================================================================***/ int -SetActionField(struct xkb_keymap *keymap, - char *elem, - char *field, - ExprDef * array_ndx, ExprDef * value, ActionInfo ** info_rtrn) +SetActionField(struct xkb_keymap *keymap, char *elem, char *field, + ExprDef *array_ndx, ExprDef *value, ActionInfo **info_rtrn) { ActionInfo *new, *old; @@ -1133,7 +1165,7 @@ SetActionField(struct xkb_keymap *keymap, new = malloc(sizeof(*new)); if (!new) { - WSGO("Couldn't allocate space for action default\n"); + log_wsgo(keymap->ctx, "Couldn't allocate space for action default\n"); return false; } @@ -1145,14 +1177,15 @@ SetActionField(struct xkb_keymap *keymap, return false; } if (new->action == XkbSA_NoAction) { - ERROR("\"%s\" is not a valid field in a NoAction action\n", - field); + log_err(keymap->ctx, + "\"%s\" is not a valid field in a NoAction action\n", + field); free(new); return false; } } if (!stringToField(field, &new->field)) { - ERROR("\"%s\" is not a legal field name\n", field); + log_err(keymap->ctx, "\"%s\" is not a legal field name\n", field); free(new); return false; } -- 2.7.4