-->
This page lists the warnings and errors generated by xkbcommon.
-There are currently 21 entries.
+There are currently 52 entries.
@todo The documentation of the log messages is a work in progress.
| Code | Identifier | Description | Type |
| --------- | ---------------------------- | ----------- | ---- |
| [XKB-034] | `malformed-number-literal` | Warn on malformed number literals | Error |
+| [XKB-043] | `conflicting-key-type-preserve-entries` | Conflicting “preserve” entries in a key type | Warning |
| [XKB-060] | `unsupported-modifier-mask` | Warn on unsupported modifier mask | Error |
+| [XKB-077] | `expected-array-entry` | Expected an array entry, but the index is missing | Error |
+| [XKB-101] | `illegal-keycode-alias` | Illegal keycode alias with the name of a real key | Warning |
| [XKB-107] | `unrecognized-keysym` | Warn on unrecognized keysyms | Warning |
+| [XKB-123] | `undeclared-virtual-modifier` | A virtual modifier is used before being declared | Error |
+| [XKB-150] | `wrong-statement-type` | The type of the statement is not allowed in the context | Error |
+| [XKB-172] | `unsupported-geometry-section` | Geometry sections are not supported | Warning |
| [XKB-183] | `cannot-infer-key-type` | Warn if no key type can be inferred | Warning |
+| [XKB-195] | `illegal-key-type-preserve-result` | The result of a key type “preserve” entry must be a subset of its input modifiers. | Warning |
+| [XKB-203] | `invalid-include-statement` | Syntax error in the include statement | Error |
+| [XKB-206] | `invalid-modmap-entry` | A modmap entry is invalid | Error |
| [XKB-237] | `unsupported-group-index` | Warn when a group index is not supported | Error |
+| [XKB-239] | `conflicting-key-type-level-names` | The name of a key type level is defined multiple times. | Warning |
+| [XKB-254] | `invalid-set-default-statement` | Invalid statement setting default values | Error |
+| [XKB-266] | `conflicting-key-type-map-entry` | Conflicting “map” entries in type definition | Warning |
| [XKB-286] | `undefined-key-type` | Warn if using an undefined key type | Warning |
| [XKB-305] | `non-base-group-name` | Warn if a group name was defined for group other than the first one | Warning |
| [XKB-312] | `unsupported-shift-level` | Warn when a shift level is not supported | Error |
+| [XKB-338] | `included-file-not-found` | Could not find a file used in an include statement | Error |
+| [XKB-345] | `unknown-operator` | Use of an operator that is unknown and thus unsupported | Error |
+| [XKB-378] | `duplicate-entry` | An entry is duplicated and will be ignored | Warning |
+| [XKB-407] | `conflicting-key-type-definitions` | Conflicting definitions of a key type | Warning |
+| [XKB-428] | `wrong-scope` | A statement is in a wrong scope and should be moved | Error |
+| [XKB-433] | `missing-default-section` | Missing default section in included file | Warning |
| [XKB-461] | `conflicting-key-symbol` | Warn if there are conflicting keysyms while merging keys | Warning |
+| [XKB-478] | `invalid-operation` | The operation is invalid in the context | Error |
| [XKB-489] | `numeric-keysym` | Warn on numeric keysym (other than 0-9) | Warning |
| [XKB-516] | `extra-symbols-ignored` | <span class="todo">TODO:</span> add description | Warning |
+| [XKB-523] | `conflicting-key-name` | Conflicting definitions of a key name or alias | Warning |
+| [XKB-550] | `allocation-error` | Cannot allocate memory | Error |
| [XKB-578] | `wrong-field-type` | Warn when a field has not the expected type | Error |
+| [XKB-623] | `invalid-real-modifier` | Invalid _real_ modifier | Error |
| [XKB-645] | `unknown-char-escape-sequence` | Warn on unknown escape sequence in string literal | Warning |
+| [XKB-661] | `invalid-included-file` | The target file of an include statement could not be processed | Error |
| [XKB-700] | `multiple-groups-at-once` | Warn if a key defines multiple groups at once | Warning |
+| [XKB-711] | `unsupported-symbols-field` | A legacy X11 symbol field is not supported | Warning |
| [XKB-769] | `invalid-syntax` | The syntax is invalid and the file cannot be parsed | Error |
-| [XKB-770] | `undefined-keycode` | <span class="todo">TODO:</span> add description | Warning |
+| [XKB-770] | `undefined-keycode` | Reference to an undefined keycode | Warning |
+| [XKB-784] | `invalid-expression-type` | An expression has not the expected type | Error |
+| [XKB-796] | `invalid-value` | A value is invalid and will be ignored | Error |
| [XKB-800] | `conflicting-modmap` | Warn if there are conflicting modmap definitions | Warning |
+| [XKB-812] | `unknown-field` | A field is unknown and will be ignored | Error |
| [XKB-883] | `conflicting-key-action` | Warn if there are conflicting actions while merging keys | Warning |
-| [XKB-893] | `conflicting-key-type` | Warn if there are conflicting key types while merging groups | Warning |
+| [XKB-893] | `conflicting-key-type-merging-groups` | Warn if there are conflicting key types while merging groups | Warning |
+| [XKB-901] | `conflicting-key-symbols-entry` | Conflicting symbols entry for a key | Error |
+| [XKB-903] | `missing-symbols-group-name-index` | Missing group index in a group name entry | Warning |
| [XKB-935] | `conflicting-key-fields` | Warn if there are conflicting fields while merging keys | Warning |
+| [XKB-949] | `invalid-identifier` | An identifier is used but is not built-in | Error |
| [XKB-965] | `unresolved-keymap-symbol` | Warn if using a symbol not defined in the keymap | Warning |
+| [XKB-971] | `undeclared-modifiers-in-key-type` | Some modifiers used in a key type “map” or “preserve” entry are not declared | Warning |
## Details
- *hexadecimal integer:* prefixed with “0x”: 0x123, 0xff, 0xAB, etc.
+### XKB-043 – Conflicting key type preserve entries {#XKB-043}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Conflicting “preserve” entries in a key type</dd>
+</dl>
+
### XKB-060 – Unsupported modifier mask {#XKB-060}
<dl>
<dt>Summary</dt><dd>Warn on unsupported modifier mask</dd>
</dl>
+### XKB-077 – Expected array entry {#XKB-077}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Expected an array entry, but the index is missing</dd>
+</dl>
+
+### XKB-101 – Illegal keycode alias {#XKB-101}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Illegal keycode alias with the name of a real key</dd>
+</dl>
+
### XKB-107 – Unrecognized keysym {#XKB-107}
<dl>
</div>
</details>
+### XKB-123 – Undeclared virtual modifier {#XKB-123}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>A virtual modifier is used before being declared</dd>
+</dl>
+
+### XKB-150 – Wrong statement type {#XKB-150}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>The type of the statement is not allowed in the context</dd>
+</dl>
+
+### XKB-172 – Unsupported geometry section {#XKB-172}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Geometry sections are not supported</dd>
+</dl>
+
### XKB-183 – Cannot infer key type {#XKB-183}
<dl>
<dt>Summary</dt><dd>Warn if no key type can be inferred</dd>
</dl>
+### XKB-195 – Illegal key type preserve result {#XKB-195}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>The result of a key type “preserve” entry must be a subset of its input modifiers.</dd>
+</dl>
+
+### XKB-203 – Invalid include statement {#XKB-203}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Syntax error in the include statement</dd>
+</dl>
+
+### XKB-206 – Invalid modmap entry {#XKB-206}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>A modmap entry is invalid</dd>
+</dl>
+
### XKB-237 – Unsupported group index {#XKB-237}
<dl>
xkbcommon supports group index in the range (1..4).
+### XKB-239 – Conflicting key type level names {#XKB-239}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>The name of a key type level is defined multiple times.</dd>
+</dl>
+
+### XKB-254 – Invalid set default statement {#XKB-254}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Invalid statement setting default values</dd>
+</dl>
+
+### XKB-266 – Conflicting key type map entry {#XKB-266}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Conflicting “map” entries in type definition</dd>
+</dl>
+
### XKB-286 – Undefined key type {#XKB-286}
<dl>
as numbers and as identifiers `LevelN`, where `N` is in the range (1..8).
+### XKB-338 – Included file not found {#XKB-338}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Could not find a file used in an include statement</dd>
+</dl>
+
+### XKB-345 – Unknown operator {#XKB-345}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Use of an operator that is unknown and thus unsupported</dd>
+</dl>
+
+### XKB-378 – Duplicate entry {#XKB-378}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>An entry is duplicated and will be ignored</dd>
+</dl>
+
+### XKB-407 – Conflicting key type definitions {#XKB-407}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Conflicting definitions of a key type</dd>
+</dl>
+
+The given key type is defined multiple times, but only one definition is kept.
+
+
+### XKB-428 – Wrong scope {#XKB-428}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>A statement is in a wrong scope and should be moved</dd>
+</dl>
+
+### XKB-433 – Missing default section {#XKB-433}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Missing default section in included file</dd>
+</dl>
+
+When using an include statement, the included file may contains multiple sections.
+The include statement may specify the name of the section to include, or leave it
+unspecified. In the latter case, the included file must then define a *default* section.
+The present warning is shown when no default section is defined.
+
+To solve this, either fix the include statement by specifying the exact section to
+include, or declare a default section in the included file.
+
+
### XKB-461 – Conflicting key symbol {#XKB-461}
<dl>
<dt>Summary</dt><dd>Warn if there are conflicting keysyms while merging keys</dd>
</dl>
+### XKB-478 – Invalid operation {#XKB-478}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>The operation is invalid in the context</dd>
+</dl>
+
### XKB-489 – Numeric keysym {#XKB-489}
<dl>
<dt>Summary</dt><dd><span class="todo">TODO:</span> add description</dd>
</dl>
+### XKB-523 – Conflicting key name {#XKB-523}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Conflicting definitions of a key name or alias</dd>
+</dl>
+
+### XKB-550 – Allocation error {#XKB-550}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Cannot allocate memory</dd>
+</dl>
+
### XKB-578 – Wrong field type {#XKB-578}
<dl>
<dt>Summary</dt><dd>Warn when a field has not the expected type</dd>
</dl>
+### XKB-623 – Invalid real modifier {#XKB-623}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Invalid _real_ modifier</dd>
+</dl>
+
### XKB-645 – Unknown char escape sequence {#XKB-645}
<dl>
| `\NNN` | _Octal_ escape, from `\0` to `\777` |
+### XKB-661 – Invalid included file {#XKB-661}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>The target file of an include statement could not be processed</dd>
+</dl>
+
### XKB-700 – Multiple groups at once {#XKB-700}
<dl>
<dt>Summary</dt><dd>Warn if a key defines multiple groups at once</dd>
</dl>
+### XKB-711 – Unsupported symbols field {#XKB-711}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>A legacy X11 symbol field is not supported</dd>
+</dl>
+
### XKB-769 – Invalid syntax {#XKB-769}
<dl>
<dl>
<dt>Since</dt><dd>1.0.0</dd>
<dt>Type</dt><dd>Warning</dd>
- <dt>Summary</dt><dd><span class="todo">TODO:</span> add description</dd>
+ <dt>Summary</dt><dd>Reference to an undefined keycode</dd>
+</dl>
+
+### XKB-784 – Invalid expression type {#XKB-784}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>An expression has not the expected type</dd>
+</dl>
+
+### XKB-796 – Invalid value {#XKB-796}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>A value is invalid and will be ignored</dd>
</dl>
### XKB-800 – Conflicting modmap {#XKB-800}
@todo detailed explanation and examples
+### XKB-812 – Unknown field {#XKB-812}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>A field is unknown and will be ignored</dd>
+</dl>
+
### XKB-883 – Conflicting key action {#XKB-883}
<dl>
<dt>Summary</dt><dd>Warn if there are conflicting actions while merging keys</dd>
</dl>
-### XKB-893 – Conflicting key type {#XKB-893}
+### XKB-893 – Conflicting key type merging groups {#XKB-893}
<dl>
<dt>Since</dt><dd>1.0.0</dd>
<dt>Summary</dt><dd>Warn if there are conflicting key types while merging groups</dd>
</dl>
+### XKB-901 – Conflicting key symbols entry {#XKB-901}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>Conflicting symbols entry for a key</dd>
+</dl>
+
+### XKB-903 – Missing symbols group name index {#XKB-903}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Missing group index in a group name entry</dd>
+</dl>
+
### XKB-935 – Conflicting key fields {#XKB-935}
<dl>
<dt>Summary</dt><dd>Warn if there are conflicting fields while merging keys</dd>
</dl>
+### XKB-949 – Invalid identifier {#XKB-949}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Error</dd>
+ <dt>Summary</dt><dd>An identifier is used but is not built-in</dd>
+</dl>
+
### XKB-965 – Unresolved keymap symbol {#XKB-965}
<dl>
<dt>Summary</dt><dd>Warn if using a symbol not defined in the keymap</dd>
</dl>
+### XKB-971 – Undeclared modifiers in key type {#XKB-971}
+
+<dl>
+ <dt>Since</dt><dd>1.0.0</dd>
+ <dt>Type</dt><dd>Warning</dd>
+ <dt>Summary</dt><dd>Some modifiers used in a key type “map” or “preserve” entry are not declared</dd>
+</dl>
+
+The modifiers used in `map` or `preserve` entries should be declared using the entry
+`modifiers` in the key type.
+
+
[XKB-034]: @ref XKB-034
+[XKB-043]: @ref XKB-043
[XKB-060]: @ref XKB-060
+[XKB-077]: @ref XKB-077
+[XKB-101]: @ref XKB-101
[XKB-107]: @ref XKB-107
+[XKB-123]: @ref XKB-123
+[XKB-150]: @ref XKB-150
+[XKB-172]: @ref XKB-172
[XKB-183]: @ref XKB-183
+[XKB-195]: @ref XKB-195
+[XKB-203]: @ref XKB-203
+[XKB-206]: @ref XKB-206
[XKB-237]: @ref XKB-237
+[XKB-239]: @ref XKB-239
+[XKB-254]: @ref XKB-254
+[XKB-266]: @ref XKB-266
[XKB-286]: @ref XKB-286
[XKB-305]: @ref XKB-305
[XKB-312]: @ref XKB-312
+[XKB-338]: @ref XKB-338
+[XKB-345]: @ref XKB-345
+[XKB-378]: @ref XKB-378
+[XKB-407]: @ref XKB-407
+[XKB-428]: @ref XKB-428
+[XKB-433]: @ref XKB-433
[XKB-461]: @ref XKB-461
+[XKB-478]: @ref XKB-478
[XKB-489]: @ref XKB-489
[XKB-516]: @ref XKB-516
+[XKB-523]: @ref XKB-523
+[XKB-550]: @ref XKB-550
[XKB-578]: @ref XKB-578
+[XKB-623]: @ref XKB-623
[XKB-645]: @ref XKB-645
+[XKB-661]: @ref XKB-661
[XKB-700]: @ref XKB-700
+[XKB-711]: @ref XKB-711
[XKB-769]: @ref XKB-769
[XKB-770]: @ref XKB-770
+[XKB-784]: @ref XKB-784
+[XKB-796]: @ref XKB-796
[XKB-800]: @ref XKB-800
+[XKB-812]: @ref XKB-812
[XKB-883]: @ref XKB-883
[XKB-893]: @ref XKB-893
+[XKB-901]: @ref XKB-901
+[XKB-903]: @ref XKB-903
[XKB-935]: @ref XKB-935
+[XKB-949]: @ref XKB-949
[XKB-965]: @ref XKB-965
+[XKB-971]: @ref XKB-971
- *decimal integer:* 1, 123, etc.
- *decimal floating-point number:* 1.23, etc.
- *hexadecimal integer:* prefixed with “0x”: 0x123, 0xff, 0xAB, etc.
+- id: "conflicting-key-type-preserve-entries"
+ code: 43
+ added: ALWAYS
+ type: warning
+ description: "Conflicting “preserve” entries in a key type"
- id: "unsupported-modifier-mask"
code: 60
added: ALWAYS
type: error
description: "Warn on unsupported modifier mask"
+- id: "expected-array-entry"
+ code: 77
+ added: ALWAYS
+ type: error
+ description: "Expected an array entry, but the index is missing"
+- id: "illegal-keycode-alias"
+ code: 101
+ added: ALWAYS
+ type: warning
+ description: "Illegal keycode alias with the name of a real key"
- id: "unrecognized-keysym"
code: 107
added: ALWAYS
```c
key <AB08> {[ comma, semicolon, periodcentered, multiply ]};
```
+- id: "undeclared-virtual-modifier"
+ code: 123
+ added: ALWAYS
+ type: error
+ description: "A virtual modifier is used before being declared"
+- id: "wrong-statement-type"
+ code: 150
+ added: ALWAYS
+ type: error
+ description: "The type of the statement is not allowed in the context"
+- id: "unsupported-geometry-section"
+ code: 172
+ added: ALWAYS
+ type: warning
+ description: "Geometry sections are not supported"
- id: "cannot-infer-key-type"
code: 183
added: ALWAYS
type: warning
description: "Warn if no key type can be inferred"
+- id: "illegal-key-type-preserve-result"
+ code: 195
+ added: ALWAYS
+ type: warning
+ description: "The result of a key type “preserve” entry must be a subset of its input modifiers."
+- id: "invalid-include-statement"
+ code: 203
+ added: ALWAYS
+ type: error
+ description: "Syntax error in the include statement"
+- id: "invalid-modmap-entry"
+ code: 206
+ added: ALWAYS
+ type: error
+ description: "A modmap entry is invalid"
- id: "unsupported-group-index"
code: 237
added: ALWAYS
description: "Warn when a group index is not supported"
details: |
xkbcommon supports group index in the range (1..{{XKB_MAX_GROUPS}}).
+- id: "conflicting-key-type-level-names"
+ code: 239
+ added: ALWAYS
+ type: warning
+ description: "The name of a key type level is defined multiple times."
+- id: "invalid-set-default-statement"
+ code: 254
+ added: ALWAYS
+ type: error
+ description: "Invalid statement setting default values"
+- id: "conflicting-key-type-map-entry"
+ code: 266
+ added: ALWAYS
+ type: warning
+ description: "Conflicting “map” entries in type definition"
- id: "undefined-key-type"
code: 286
added: ALWAYS
details: |
Shift levels are _one_-indexed. xkbcommon supports two formats of shift levels:
as numbers and as identifiers `LevelN`, where `N` is in the range (1..8).
+- id: "included-file-not-found"
+ code: 338
+ added: ALWAYS
+ type: error
+ description: "Could not find a file used in an include statement"
+- id: "unknown-operator"
+ code: 345
+ added: ALWAYS
+ type: error
+ description: "Use of an operator that is unknown and thus unsupported"
+- id: "duplicate-entry"
+ code: 378
+ added: ALWAYS
+ type: warning
+ description: "An entry is duplicated and will be ignored"
+- id: "conflicting-key-type-definitions"
+ code: 407
+ added: ALWAYS
+ type: warning
+ description: "Conflicting definitions of a key type"
+ details: |
+ The given key type is defined multiple times, but only one definition is kept.
+- id: "wrong-scope"
+ code: 428
+ added: ALWAYS
+ type: error
+ description: "A statement is in a wrong scope and should be moved"
+- id: "missing-default-section"
+ code: 433
+ added: ALWAYS
+ type: warning
+ description: "Missing default section in included file"
+ details: |
+ When using an include statement, the included file may contains multiple sections.
+ The include statement may specify the name of the section to include, or leave it
+ unspecified. In the latter case, the included file must then define a *default* section.
+ The present warning is shown when no default section is defined.
+
+ To solve this, either fix the include statement by specifying the exact section to
+ include, or declare a default section in the included file.
- id: "conflicting-key-symbol"
code: 461
added: ALWAYS
type: warning
description: "Warn if there are conflicting keysyms while merging keys"
+- id: "invalid-operation"
+ code: 478
+ added: ALWAYS
+ type: error
+ description: "The operation is invalid in the context"
- id: "numeric-keysym"
code: 489
added: 1.6.0
added: ALWAYS
type: warning
description: "TODO: add description"
+- id: "conflicting-key-name"
+ code: 523
+ added: ALWAYS
+ type: warning
+ description: "Conflicting definitions of a key name or alias"
+- id: "allocation-error"
+ code: 550
+ added: ALWAYS
+ type: error
+ description: "Cannot allocate memory"
- id: "wrong-field-type"
code: 578
added: ALWAYS
type: error
description: "Warn when a field has not the expected type"
+- id: "invalid-real-modifier"
+ code: 623
+ added: ALWAYS
+ type: error
+ description: "Invalid _real_ modifier"
- id: "unknown-char-escape-sequence"
code: 645
added: ALWAYS
| `\e` | `U+001B` Escape |
| `\\` | `U+005C` Backslash |
| `\NNN` | _Octal_ escape, from `\0` to `\777` |
+- id: "invalid-included-file"
+ code: 661
+ added: ALWAYS
+ type: error
+ description: "The target file of an include statement could not be processed"
- id: "multiple-groups-at-once"
code: 700
added: ALWAYS
type: warning
description: "Warn if a key defines multiple groups at once"
+- id: "unsupported-symbols-field"
+ code: 711
+ added: ALWAYS
+ type: warning
+ description: "A legacy X11 symbol field is not supported"
- id: "invalid-syntax"
code: 769
added: ALWAYS
code: 770
added: ALWAYS
type: warning
- description: "TODO: add description"
+ description: "Reference to an undefined keycode"
+- id: "invalid-expression-type"
+ code: 784
+ added: ALWAYS
+ type: error
+ description: "An expression has not the expected type"
+- id: "invalid-value"
+ code: 796
+ added: ALWAYS
+ type: error
+ description: "A value is invalid and will be ignored"
- id: "conflicting-modmap"
code: 800
added: ALWAYS
description: "Warn if there are conflicting modmap definitions"
details: |
@todo detailed explanation and examples
+- id: "unknown-field"
+ code: 812
+ added: ALWAYS
+ type: error
+ description: "A field is unknown and will be ignored"
- id: "conflicting-key-action"
code: 883
added: ALWAYS
type: warning
description: "Warn if there are conflicting actions while merging keys"
-- id: "conflicting-key-type"
+- id: "conflicting-key-type-merging-groups"
code: 893
added: ALWAYS
type: warning
description: "Warn if there are conflicting key types while merging groups"
+- id: "conflicting-key-symbols-entry"
+ code: 901
+ added: ALWAYS
+ type: error
+ description: "Conflicting symbols entry for a key"
+- id: "missing-symbols-group-name-index"
+ code: 903
+ added: ALWAYS
+ type: warning
+ description: "Missing group index in a group name entry"
- id: "conflicting-key-fields"
code: 935
added: ALWAYS
type: warning
description: "Warn if there are conflicting fields while merging keys"
+- id: "invalid-identifier"
+ code: 949
+ added: ALWAYS
+ type: error
+ description: "An identifier is used but is not built-in"
- id: "unresolved-keymap-symbol"
code: 965
added: ALWAYS
type: warning
description: "Warn if using a symbol not defined in the keymap"
+- id: "undeclared-modifiers-in-key-type"
+ code: 971
+ added: ALWAYS
+ type: warning
+ description: "Some modifiers used in a key type “map” or “preserve” entry are not declared"
+ details: |
+ The modifiers used in `map` or `preserve` entries should be declared using the entry
+ `modifiers` in the key type.
# TODO: deprecated keysym
# TODO: unicode keysym when named and recommended keysym exists
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_with_code(ctx, vrb, id, ...) \
+#define log_vrb(ctx, vrb, id, ...) \
xkb_log_with_code((ctx), XKB_LOG_LEVEL_WARNING, (vrb), (id), __VA_ARGS__)
-#define log_vrb(ctx, vrb, ...) \
- xkb_log((ctx), XKB_LOG_LEVEL_WARNING, (vrb), __VA_ARGS__)
/*
* Variants which are prefixed by the name of the function they're
#include <stdint.h>
/**
+ * Special case when no message identifier is defined.
+ *
+ * @added 1.6.0
+ *
+ */
+#define XKB_LOG_MESSAGE_NO_ID 0
+
+/**
* @name Codes of the log messages
*
* @added 1.6.0
_XKB_LOG_MESSAGE_MIN_CODE = 34,
/** Warn on malformed number literals */
XKB_ERROR_MALFORMED_NUMBER_LITERAL = 34,
+ /** Conflicting “preserve” entries in a key type */
+ XKB_WARNING_CONFLICTING_KEY_TYPE_PRESERVE_ENTRIES = 43,
/** Warn on unsupported modifier mask */
XKB_ERROR_UNSUPPORTED_MODIFIER_MASK = 60,
+ /** Expected an array entry, but the index is missing */
+ XKB_ERROR_EXPECTED_ARRAY_ENTRY = 77,
+ /** Illegal keycode alias with the name of a real key */
+ XKB_WARNING_ILLEGAL_KEYCODE_ALIAS = 101,
/** Warn on unrecognized keysyms */
XKB_WARNING_UNRECOGNIZED_KEYSYM = 107,
+ /** A virtual modifier is used before being declared */
+ XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER = 123,
+ /** The type of the statement is not allowed in the context */
+ XKB_ERROR_WRONG_STATEMENT_TYPE = 150,
+ /** Geometry sections are not supported */
+ XKB_WARNING_UNSUPPORTED_GEOMETRY_SECTION = 172,
/** Warn if no key type can be inferred */
XKB_WARNING_CANNOT_INFER_KEY_TYPE = 183,
+ /** The result of a key type “preserve” entry must be a subset of its input modifiers. */
+ XKB_WARNING_ILLEGAL_KEY_TYPE_PRESERVE_RESULT = 195,
+ /** Syntax error in the include statement */
+ XKB_ERROR_INVALID_INCLUDE_STATEMENT = 203,
+ /** A modmap entry is invalid */
+ XKB_ERROR_INVALID_MODMAP_ENTRY = 206,
/** Warn when a group index is not supported */
XKB_ERROR_UNSUPPORTED_GROUP_INDEX = 237,
+ /** The name of a key type level is defined multiple times. */
+ XKB_WARNING_CONFLICTING_KEY_TYPE_LEVEL_NAMES = 239,
+ /** Invalid statement setting default values */
+ XKB_ERROR_INVALID_SET_DEFAULT_STATEMENT = 254,
+ /** Conflicting “map” entries in type definition */
+ XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY = 266,
/** Warn if using an undefined key type */
XKB_WARNING_UNDEFINED_KEY_TYPE = 286,
/** Warn if a group name was defined for group other than the first one */
XKB_WARNING_NON_BASE_GROUP_NAME = 305,
/** Warn when a shift level is not supported */
XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL = 312,
+ /** Could not find a file used in an include statement */
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND = 338,
+ /** Use of an operator that is unknown and thus unsupported */
+ XKB_ERROR_UNKNOWN_OPERATOR = 345,
+ /** An entry is duplicated and will be ignored */
+ XKB_WARNING_DUPLICATE_ENTRY = 378,
+ /** Conflicting definitions of a key type */
+ XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS = 407,
+ /** A statement is in a wrong scope and should be moved */
+ XKB_ERROR_WRONG_SCOPE = 428,
+ /** Missing default section in included file */
+ XKB_WARNING_MISSING_DEFAULT_SECTION = 433,
/** Warn if there are conflicting keysyms while merging keys */
XKB_WARNING_CONFLICTING_KEY_SYMBOL = 461,
+ /** The operation is invalid in the context */
+ XKB_ERROR_INVALID_OPERATION = 478,
/** Warn on numeric keysym (other than 0-9) */
XKB_WARNING_NUMERIC_KEYSYM = 489,
/** TODO: add description */
XKB_WARNING_EXTRA_SYMBOLS_IGNORED = 516,
+ /** Conflicting definitions of a key name or alias */
+ XKB_WARNING_CONFLICTING_KEY_NAME = 523,
+ /** Cannot allocate memory */
+ XKB_ERROR_ALLOCATION_ERROR = 550,
/** Warn when a field has not the expected type */
XKB_ERROR_WRONG_FIELD_TYPE = 578,
+ /** Invalid _real_ modifier */
+ XKB_ERROR_INVALID_REAL_MODIFIER = 623,
/** Warn on unknown escape sequence in string literal */
XKB_WARNING_UNKNOWN_CHAR_ESCAPE_SEQUENCE = 645,
+ /** The target file of an include statement could not be processed */
+ XKB_ERROR_INVALID_INCLUDED_FILE = 661,
/** Warn if a key defines multiple groups at once */
XKB_WARNING_MULTIPLE_GROUPS_AT_ONCE = 700,
+ /** A legacy X11 symbol field is not supported */
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD = 711,
/** The syntax is invalid and the file cannot be parsed */
XKB_ERROR_INVALID_SYNTAX = 769,
- /** TODO: add description */
+ /** Reference to an undefined keycode */
XKB_WARNING_UNDEFINED_KEYCODE = 770,
+ /** An expression has not the expected type */
+ XKB_ERROR_INVALID_EXPRESSION_TYPE = 784,
+ /** A value is invalid and will be ignored */
+ XKB_ERROR_INVALID_VALUE = 796,
/** Warn if there are conflicting modmap definitions */
XKB_WARNING_CONFLICTING_MODMAP = 800,
+ /** A field is unknown and will be ignored */
+ XKB_ERROR_UNKNOWN_FIELD = 812,
/** Warn if there are conflicting actions while merging keys */
XKB_WARNING_CONFLICTING_KEY_ACTION = 883,
/** Warn if there are conflicting key types while merging groups */
- XKB_WARNING_CONFLICTING_KEY_TYPE = 893,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS = 893,
+ /** Conflicting symbols entry for a key */
+ XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY = 901,
+ /** Missing group index in a group name entry */
+ XKB_WARNING_MISSING_SYMBOLS_GROUP_NAME_INDEX = 903,
/** Warn if there are conflicting fields while merging keys */
XKB_WARNING_CONFLICTING_KEY_FIELDS = 935,
+ /** An identifier is used but is not built-in */
+ XKB_ERROR_INVALID_IDENTIFIER = 949,
/** Warn if using a symbol not defined in the keymap */
XKB_WARNING_UNRESOLVED_KEYMAP_SYMBOL = 965,
- _XKB_LOG_MESSAGE_MAX_CODE = 965
+ /** Some modifiers used in a key type “map” or “preserve” entry are not declared */
+ XKB_WARNING_UNDECLARED_MODIFIERS_IN_KEY_TYPE = 971,
+ _XKB_LOG_MESSAGE_MAX_CODE = 971
};
typedef uint32_t xkb_message_code_t;
#include <stdint.h>
/**
+ * Special case when no message identifier is defined.
+ *
+ * @added 1.6.0
+ *
+ */
+#define XKB_LOG_MESSAGE_NO_ID 0
+
+/**
* @name Codes of the log messages
*
* @added 1.6.0
return first;
err:
- log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt);
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_INCLUDE_STATEMENT,
+ "Illegal include statement \"%s\"; Ignored\n", stmt);
FreeInclude(first);
free(stmt);
return NULL;
default:
break;
}
- log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_INVALID_SYNTAX,
+ "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
return false;
}
switch (expr->expr.op) {
case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where boolean was expected\n",
expr_value_type_to_string(expr->expr.value_type));
return false;
return true;
}
}
- log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_IDENTIFIER,
+ "Identifier \"%s\" of type boolean is unknown\n", ident);
return false;
case EXPR_FIELD_REF:
- log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_EXPRESSION_TYPE,
+ "Default \"%s.%s\" of type boolean is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element),
xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ACTION_DECL:
case EXPR_ACTION_LIST:
case EXPR_KEYSYM_LIST:
- log_err(ctx, "%s of boolean values not permitted\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "%s of boolean values not permitted\n",
expr_op_type_to_string(expr->expr.op));
break;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_UNKNOWN_OPERATOR,
+ "Unknown operator %d in ResolveBoolean\n",
expr->expr.op);
break;
}
switch (expr->expr.op) {
case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where an int was expected\n",
expr_value_type_to_string(expr->expr.value_type));
return false;
break;
case EXPR_DIVIDE:
if (rightRtrn == 0) {
- log_err(ctx, "Cannot divide by zero: %d / %d\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "Cannot divide by zero: %d / %d\n",
leftRtrn, rightRtrn);
return false;
}
return ExprResolveKeyCode(ctx, expr->unary.child, kc);
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
- expr->expr.op);
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_INVALID_SYNTAX,
+ "Unknown operator %d in ResolveKeyCode\n", expr->expr.op);
break;
}
switch (expr->expr.op) {
case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where an int was expected\n",
expr_value_type_to_string(expr->expr.value_type));
return false;
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
if (!ok)
- log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_IDENTIFIER,
+ "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->ident.ident));
else
*val_rtrn = (int) u;
return ok;
case EXPR_FIELD_REF:
- log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_EXPRESSION_TYPE,
+ "Default \"%s.%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element),
xkb_atom_text(ctx, expr->field_ref.field));
return false;
break;
case EXPR_DIVIDE:
if (r == 0) {
- log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "Cannot divide by zero: %d / %d\n", l, r);
return false;
}
*val_rtrn = l / r;
break;
default:
- log_err(ctx, "%s of integers not permitted\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "%s of integers not permitted\n",
expr_op_type_to_string(expr->expr.op));
return false;
}
return true;
case EXPR_ASSIGN:
- log_wsgo(ctx, "Assignment operator not implemented yet\n");
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "Assignment operator not implemented yet\n");
break;
case EXPR_NOT:
- log_err(ctx, "The ! operator cannot be applied to an integer\n");
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "The ! operator cannot be applied to an integer\n");
return false;
case EXPR_INVERT:
lookupPriv);
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_UNKNOWN_OPERATOR,
+ "Unknown operator %d in ResolveInteger\n",
expr->expr.op);
break;
}
switch (expr->expr.op) {
case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_STRING) {
- log_err(ctx, "Found constant of type %s, expected a string\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
+ "Found constant of type %s, expected a string\n",
expr_value_type_to_string(expr->expr.value_type));
return false;
}
return true;
case EXPR_IDENT:
- log_err(ctx, "Identifier \"%s\" of type string not found\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_IDENTIFIER,
+ "Identifier \"%s\" of type string not found\n",
xkb_atom_text(ctx, expr->ident.ident));
return false;
case EXPR_FIELD_REF:
- log_err(ctx, "Default \"%s.%s\" of type string not found\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_EXPRESSION_TYPE,
+ "Default \"%s.%s\" of type string not found\n",
xkb_atom_text(ctx, expr->field_ref.element),
xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ACTION_DECL:
case EXPR_ACTION_LIST:
case EXPR_KEYSYM_LIST:
- log_err(ctx, "%s of strings not permitted\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_SYNTAX,
+ "%s of strings not permitted\n",
expr_op_type_to_string(expr->expr.op));
return false;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_UNKNOWN_OPERATOR,
+ "Unknown operator %d in ResolveString\n",
expr->expr.op);
break;
}
unsigned int *val_rtrn, const LookupEntry *values)
{
if (expr->expr.op != EXPR_IDENT) {
- log_err(ctx, "Found a %s where an enumerated value was expected\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
+ "Found a %s where an enumerated value was expected\n",
expr_op_type_to_string(expr->expr.op));
return false;
}
if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn)) {
- log_err(ctx, "Illegal identifier %s; expected one of:\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_IDENTIFIER,
+ "Illegal identifier %s; expected one of:\n",
xkb_atom_text(ctx, expr->ident.ident));
while (values && values->name)
{
- log_err(ctx, "\t%s\n", values->name);
+ log_err_with_code(ctx, XKB_ERROR_INVALID_IDENTIFIER, "\t%s\n", values->name);
values++;
}
return false;
switch (expr->expr.op) {
case EXPR_VALUE:
if (expr->expr.value_type != EXPR_TYPE_INT) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Found constant of type %s where a mask was expected\n",
expr_value_type_to_string(expr->expr.value_type));
return false;
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn);
if (!ok)
- log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_IDENTIFIER,
+ "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->ident.ident));
return ok;
case EXPR_FIELD_REF:
- log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_EXPRESSION_TYPE,
+ "Default \"%s.%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->field_ref.element),
xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ACTION_DECL:
if (bogus == NULL)
bogus = "function use";
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Unexpected %s in mask expression; Expression Ignored\n",
bogus);
return false;
break;
case EXPR_MULTIPLY:
case EXPR_DIVIDE:
- log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "Cannot %s masks; Illegal operation ignored\n",
(expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
return false;
default:
return true;
case EXPR_ASSIGN:
- log_wsgo(ctx, "Assignment operator not implemented yet\n");
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "Assignment operator not implemented yet\n");
break;
case EXPR_INVERT:
case EXPR_NOT:
left = expr->unary.child;
if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
- log_err(ctx, "The %s operator cannot be used with a mask\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_OPERATION,
+ "The %s operator cannot be used with a mask\n",
(expr->expr.op == EXPR_NEGATE ? "-" : "!"));
return false;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
+ log_wsgo_with_code(ctx,
+ XKB_ERROR_UNKNOWN_OPERATOR,
+ "Unknown operator %d in ResolveMask\n",
expr->expr.op);
break;
}
xkb_atom_t name;
if (def->expr.op != EXPR_IDENT) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Cannot resolve virtual modifier: "
"found %s where a virtual modifier name was expected\n",
expr_op_type_to_string(def->expr.op));
name = def->ident.ident;
ndx = XkbModNameToIndex(mods, name, mod_type);
if (ndx == XKB_MOD_INVALID) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER,
"Cannot resolve virtual modifier: "
"\"%s\" was not previously declared\n",
xkb_atom_text(ctx, name));
unsigned int i;
if (xkb_context_num_include_paths(ctx) > 0) {
- log_err(ctx, "%d include paths searched:\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "%d include paths searched:\n",
xkb_context_num_include_paths(ctx));
for (i = 0; i < xkb_context_num_include_paths(ctx); i++)
- log_err(ctx, "\t%s\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "\t%s\n",
xkb_context_include_path_get(ctx, i));
}
else {
- log_err(ctx, "There are no include paths to search\n");
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "There are no include paths to search\n");
}
if (xkb_context_num_failed_include_paths(ctx) > 0) {
- log_err(ctx, "%d include paths could not be added:\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "%d include paths could not be added:\n",
xkb_context_num_failed_include_paths(ctx));
for (i = 0; i < xkb_context_num_failed_include_paths(ctx); i++)
- log_err(ctx, "\t%s\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "\t%s\n",
xkb_context_failed_include_path_get(ctx, i));
}
}
buf = asprintf_safe("%s/%s/%s", xkb_context_include_path_get(ctx, i),
typeDir, name);
if (!buf) {
- log_err(ctx, "Failed to alloc buffer for (%s/%s/%s)\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_ALLOCATION_ERROR,
+ "Failed to alloc buffer for (%s/%s/%s)\n",
xkb_context_include_path_get(ctx, i), typeDir, name);
continue;
}
/* We only print warnings if we can't find the file on the first lookup */
if (*offset == 0) {
- log_err(ctx, "Couldn't find file \"%s/%s\" in include paths\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INCLUDED_FILE_NOT_FOUND,
+ "Couldn't find file \"%s/%s\" in include paths\n",
typeDir, name);
LogIncludePaths(ctx);
}
if (xkb_file) {
if (xkb_file->file_type != file_type) {
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_INCLUDED_FILE,
"Include file of wrong type (expected %s, got %s); "
"Include file \"%s\" ignored\n",
xkb_file_type_to_string(file_type),
if (!xkb_file) {
if (stmt->map)
- log_err(ctx, "Couldn't process include statement for '%s(%s)'\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_INCLUDED_FILE,
+ "Couldn't process include statement for '%s(%s)'\n",
stmt->file, stmt->map);
else
- log_err(ctx, "Couldn't process include statement for '%s'\n",
+ log_err_with_code(ctx,
+ XKB_ERROR_INVALID_INCLUDED_FILE,
+ "Couldn't process include statement for '%s'\n",
stmt->file);
}
if (merge == MERGE_OVERRIDE) {
darray_item(info->key_names, old_kc) = XKB_ATOM_NONE;
if (report)
- log_warn(info->ctx,
+ log_warn_with_code(info->ctx,
+ XKB_WARNING_CONFLICTING_KEY_NAME,
"Key name %s assigned to multiple keys; "
"Using %d, ignoring %d\n", kname, kc, old_kc);
}
else {
if (report)
log_vrb(info->ctx, 3,
+ XKB_WARNING_CONFLICTING_KEY_NAME,
"Key name %s assigned to multiple keys; "
"Using %d, ignoring %d\n", kname, old_kc, kc);
return true;
if (old->alias == def->alias) {
if (def->real == old->real) {
log_vrb(info->ctx, 1,
+ XKB_WARNING_CONFLICTING_KEY_NAME,
"Alias of %s for %s declared more than once; "
"First definition ignored\n",
KeyNameText(info->ctx, def->alias),
use = (merge == MERGE_AUGMENT ? old->real : def->real);
ignore = (merge == MERGE_AUGMENT ? def->real : old->real);
- log_warn(info->ctx,
+ log_warn_with_code(info->ctx,
+ XKB_WARNING_CONFLICTING_KEY_NAME,
"Multiple definitions for alias %s; "
"Using %s, ignoring %s\n",
KeyNameText(info->ctx, old->alias),
/* Check that ->real is a key. */
if (!XkbKeyByName(keymap, alias->real, false)) {
log_vrb(info->ctx, 5,
+ XKB_WARNING_UNDEFINED_KEYCODE,
"Attempt to alias %s to non-existent key %s; Ignored\n",
KeyNameText(info->ctx, alias->alias),
KeyNameText(info->ctx, alias->real));
/* Check that ->alias is not a key. */
if (XkbKeyByName(keymap, alias->alias, false)) {
log_vrb(info->ctx, 5,
+ XKB_WARNING_ILLEGAL_KEYCODE_ALIAS,
"Attempt to create alias with the name of a real key; "
"Alias \"%s = %s\" ignored\n",
KeyNameText(info->ctx, alias->alias),
file->file_type > LAST_KEYMAP_FILE_TYPE) {
if (file->file_type == FILE_TYPE_GEOMETRY) {
log_vrb(ctx, 1,
+ XKB_WARNING_UNSUPPORTED_GEOMETRY_SECTION,
"Geometry sections are not supported; ignoring\n");
} else {
log_err(ctx, "Cannot define %s in a keymap file\n",
if (first)
log_vrb(ctx, 5,
+ XKB_WARNING_MISSING_DEFAULT_SECTION,
"No map in include statement, but \"%s\" contains several; "
"Using first defined map, \"%s\"\n",
scanner->file_name, first->name);
#include "keysym.h"
-// TODO: convert log_err to log_err_with_code
-// TODO: convert log_vrb to log_vrb_with_code
-
enum key_repeat {
KEY_REPEAT_UNDEFINED = 0,
KEY_REPEAT_YES = 1,
if (report) {
log_warn_with_code(info->ctx,
- XKB_WARNING_CONFLICTING_KEY_TYPE,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS,
"Multiple definitions for group %d type of key %s; "
"Using %s, ignoring %s\n",
group + 1, KeyNameText(info->ctx, key_name),
if (stmt->modifier) {
next_incl.explicit_group = atoi(stmt->modifier) - 1;
if (next_incl.explicit_group >= XKB_MAX_GROUPS) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Cannot set explicit group to %d - must be between 1..%d; "
"Ignoring group number\n",
next_incl.explicit_group + 1, XKB_MAX_GROUPS);
}
if (i >= XKB_MAX_GROUPS) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
"Too many groups of %s for key %s (max %u); "
"Ignoring %s defined for extra groups\n",
name, KeyInfoText(info, keyi), XKB_MAX_GROUPS, name);
}
if (value->expr.op != EXPR_KEYSYM_LIST) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Expected a list of symbols, found %s; "
"Ignoring symbols for group %u of %s\n",
expr_op_type_to_string(value->expr.op), ndx + 1,
}
if (groupi->defined & GROUP_FIELD_SYMS) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY,
"Symbols for key %s, group %u already defined; "
"Ignoring duplicate definition\n",
KeyInfoText(info, keyi), ndx + 1);
union xkb_action *toAct = &darray_item(groupi->levels, i).action;
if (!HandleActionDef(info->ctx, info->actions, &info->mods, act, toAct))
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_VALUE,
"Illegal action definition for %s; "
"Action for group %u/level %u ignored\n",
KeyInfoText(info, keyi), ndx + 1, i + 1);
xkb_atom_t val;
if (!ExprResolveString(info->ctx, value, &val)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"The type field of a key symbol map must be a string; "
"Ignoring illegal type definition\n");
return false;
if (!ExprResolveModMask(info->ctx, value, MOD_VIRT, &info->mods,
&mask)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Expected a virtual modifier mask, found %s; "
"Ignoring virtual modifiers definition for key %s\n",
expr_op_type_to_string(value->expr.op),
istreq(field, "lock") ||
istreq(field, "locks")) {
log_vrb(info->ctx, 1,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Key behaviors not supported; "
"Ignoring locking specification for key %s\n",
KeyInfoText(info, keyi));
istreq(field, "permanentradiogroup") ||
istreq(field, "allownone")) {
log_vrb(info->ctx, 1,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Radio groups not supported; "
"Ignoring radio group specification for key %s\n",
KeyInfoText(info, keyi));
else if (istreq_prefix("overlay", field) ||
istreq_prefix("permanentoverlay", field)) {
log_vrb(info->ctx, 1,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Overlays not supported; "
"Ignoring overlay specification for key %s\n",
KeyInfoText(info, keyi));
unsigned int val;
if (!ExprResolveEnum(info->ctx, value, &val, repeatEntries)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_VALUE,
"Illegal repeat setting for %s; "
"Non-boolean repeat setting ignored\n",
KeyInfoText(info, keyi));
bool set;
if (!ExprResolveBoolean(info->ctx, value, &set)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_VALUE,
"Illegal groupsWrap setting for %s; "
"Non-boolean value ignored\n",
KeyInfoText(info, keyi));
bool set;
if (!ExprResolveBoolean(info->ctx, value, &set)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_VALUE,
"Illegal groupsClamp setting for %s; "
"Non-boolean value ignored\n",
KeyInfoText(info, keyi));
keyi->defined |= KEY_FIELD_GROUPINFO;
}
else {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNKNOWN_FIELD,
"Unknown field %s in a symbol interpretation; "
"Definition ignored\n",
field);
if (!arrayNdx) {
log_vrb(info->ctx, 1,
+ XKB_WARNING_MISSING_SYMBOLS_GROUP_NAME_INDEX,
"You must specify an index when specifying a group name; "
"Group name definition without array subscript ignored\n");
return false;
}
if (!ExprResolveString(info->ctx, value, &name)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Group name must be a string; "
"Illegal name for group %d ignored\n", group);
return false;
}
else if (!elem && (istreq(field, "groupswrap") ||
istreq(field, "wrapgroups"))) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupswrap\" not supported; Ignored\n");
ret = true;
}
else if (!elem && (istreq(field, "groupsclamp") ||
istreq(field, "clampgroups"))) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupsclamp\" not supported; Ignored\n");
ret = true;
}
else if (!elem && (istreq(field, "groupsredirect") ||
istreq(field, "redirectgroups"))) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Global \"groupsredirect\" not supported; Ignored\n");
ret = true;
}
else if (!elem && istreq(field, "allownone")) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD,
"Radio groups not supported; "
"Ignoring \"allownone\" specification\n");
ret = true;
for (; def; def = (VarDef *) def->common.next) {
if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_SCOPE,
"Cannot set a global default value from within a key statement; "
"Move statements to the global file scope\n");
continue;
// Handle normal entry
ndx = XkbModNameToIndex(&info->mods, def->modifier, MOD_REAL);
if (ndx == XKB_MOD_INVALID) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_REAL_MODIFIER,
"Illegal modifier map definition; "
"Ignoring map for non-modifier \"%s\"\n",
xkb_atom_text(ctx, def->modifier));
tmp.u.keySym = sym;
}
else {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_MODMAP_ENTRY,
"Modmap entries may contain only key names or keysyms; "
"Illegal definition for %s modifier ignored\n",
ModIndexText(info->ctx, &info->mods, tmp.modifier));
ok = HandleModMapDef(info, (ModMapDef *) stmt);
break;
default:
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_STATEMENT_TYPE,
"Symbols files may not include other types; "
"Ignoring %s\n", stmt_type_to_string(stmt->type));
ok = false;
info->errorCount++;
if (info->errorCount > 10) {
- log_err(info->ctx, "Abandoning symbols file \"%s\"\n",
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_SYNTAX,
+ "Abandoning symbols file \"%s\"\n",
file->name);
break;
}
*/
key = XkbKeyByName(keymap, keyi->name, false);
if (!key) {
- log_vrb_with_code(info->ctx, 5,
+ log_vrb(info->ctx, 5,
XKB_WARNING_UNDEFINED_KEYCODE,
"Key %s not found in keycodes; Symbols ignored\n",
KeyInfoText(info, keyi));
if (type->num_levels < darray_size(groupi->levels)) {
struct xkb_level *leveli;
- log_vrb_with_code(info->ctx, 1,
+ log_vrb(info->ctx, 1,
XKB_WARNING_EXTRA_SYMBOLS_IGNORED,
"Type \"%s\" has %d levels, but %s has %d levels; "
"Ignoring extra symbols\n",
if (!entry->haveSymbol) {
key = XkbKeyByName(keymap, entry->u.keyName, true);
if (!key) {
- log_vrb_with_code(info->ctx, 5,
+ log_vrb(info->ctx, 5,
XKB_WARNING_UNDEFINED_KEYCODE,
"Key %s not found in keycodes; "
"Modifier map entry for %s not updated\n",
else {
key = FindKeyForSymbol(keymap, entry->u.keySym);
if (!key) {
- log_vrb_with_code(info->ctx, 5,
+ log_vrb(info->ctx, 5,
XKB_WARNING_UNRESOLVED_KEYMAP_SYMBOL,
"Key \"%s\" not found in symbol map; "
"Modifier map entry for %s not updated\n",
if (old) {
if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) {
if ((same_file && verbosity > 0) || verbosity > 9) {
- log_warn(info->ctx,
+ log_warn_with_code(info->ctx,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS,
"Multiple definitions of the %s key type; "
"Earlier definition ignored\n",
xkb_atom_text(info->ctx, new->name));
if (same_file)
log_vrb(info->ctx, 4,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS,
"Multiple definitions of the %s key type; "
"Later definition ignored\n",
xkb_atom_text(info->ctx, new->name));
"Illegal array subscript ignored\n");
if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, &mods)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
return false;
old = FindMatchingMapEntry(type, new->mods.mods);
if (old) {
if (report && old->level != new->level) {
- log_warn(info->ctx,
+ log_warn_with_code(info->ctx,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY,
"Multiple map entries for %s in %s; "
"Using %d, ignoring %d\n",
MapEntryTxt(info, new), TypeTxt(info, type),
}
else {
log_vrb(info->ctx, 10,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY,
"Multiple occurrences of map[%s]= %d in %s; Ignored\n",
MapEntryTxt(info, new), new->level + 1,
TypeTxt(info, type));
if (entry.mods.mods & (~type->mods)) {
log_vrb(info->ctx, 1,
- "Map entry for unused modifiers in %s; "
+ XKB_WARNING_UNDECLARED_MODIFIERS_IN_KEY_TYPE,
+ "Map entry for modifiers not used by type %s; "
"Using %s instead of %s\n",
TypeTxt(info, type),
ModMaskText(info->ctx, &info->mods,
/* Map exists with same preserve; do nothing. */
if (entry->preserve.mods == preserve_mods) {
log_vrb(info->ctx, 10,
+ XKB_WARNING_DUPLICATE_ENTRY,
"Identical definitions for preserve[%s] in %s; "
"Ignored\n",
ModMaskText(info->ctx, &info->mods, mods),
/* Map exists with different preserve; latter wins. */
log_vrb(info->ctx, 1,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_PRESERVE_ENTRIES,
"Multiple definitions for preserve[%s] in %s; "
"Using %s, ignoring %s\n",
ModMaskText(info->ctx, &info->mods, mods),
after = ModMaskText(info->ctx, &info->mods, mods);
log_vrb(info->ctx, 1,
- "Preserve for modifiers not used by the %s type; "
+ XKB_WARNING_UNDECLARED_MODIFIERS_IN_KEY_TYPE,
+ "Preserve entry for modifiers not used by the %s type; "
"Index %s converted to %s\n",
TypeTxt(info, type), before, after);
}
if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods,
&preserve_mods)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNSUPPORTED_MODIFIER_MASK,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
ModMaskText(info->ctx, &info->mods, mods),
after = ModMaskText(info->ctx, &info->mods, preserve_mods);
log_vrb(info->ctx, 1,
+ XKB_WARNING_ILLEGAL_KEY_TYPE_PRESERVE_RESULT,
"Illegal value for preserve[%s] in type %s; "
"Converted %s to %s\n",
ModMaskText(info->ctx, &info->mods, mods),
/* Same level, same name. */
if (darray_item(type->level_names, level) == name) {
log_vrb(info->ctx, 10,
+ XKB_WARNING_DUPLICATE_ENTRY,
"Duplicate names for level %d of key type %s; Ignored\n",
level + 1, TypeTxt(info, type));
return true;
darray_item(type->level_names, level));
new = xkb_atom_text(info->ctx, name);
log_vrb(info->ctx, 1,
+ XKB_WARNING_CONFLICTING_KEY_TYPE_LEVEL_NAMES,
"Multiple names for level %d of key type %s; "
"Using %s, ignoring %s\n",
level + 1, TypeTxt(info, type),
type, "level name", "integer");
if (!ExprResolveString(info->ctx, value, &level_name)) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"Non-string name for level %d in key type %s; "
"Ignoring illegal level name definition\n",
level + 1, xkb_atom_text(info->ctx, type->name));
type_field = TYPE_FIELD_LEVEL_NAME;
ok = SetLevelName(info, type, arrayNdx, value);
} else {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_UNKNOWN_FIELD,
"Unknown field %s in key type %s; Definition ignored\n",
field, TypeTxt(info, type));
}
continue;
if (elem && istreq(elem, "type")) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_SET_DEFAULT_STATEMENT,
"Support for changing the default type has been removed; "
"Statement ignored\n");
continue;
ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge);
break;
case STMT_VAR:
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_STATEMENT_TYPE,
"Support for changing the default type has been removed; "
"Statement ignored\n");
ok = true;
ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge);
break;
default:
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_WRONG_STATEMENT_TYPE,
"Key type files may not include other declarations; "
"Ignoring %s\n", stmt_type_to_string(stmt->type));
ok = false;
info->errorCount++;
if (info->errorCount > 10) {
- log_err(info->ctx,
+ log_err_with_code(info->ctx,
+ XKB_ERROR_INVALID_SYNTAX,
"Abandoning keytypes file \"%s\"\n", file->name);
break;
}
ReportNotArray(struct xkb_context *ctx, const char *type, const char *field,
const char *name)
{
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_WRONG_FIELD_TYPE,
"The %s %s field is not an array; "
"Ignoring illegal assignment in %s\n",
type, field, name);
ReportShouldBeArray(struct xkb_context *ctx, const char *type,
const char *field, const char *name)
{
- log_err(ctx,
+ log_err_with_code(ctx,
+ XKB_ERROR_EXPECTED_ARRAY_ENTRY,
"Missing subscript for %s %s; "
"Ignoring illegal assignment in %s\n",
type, field, name);
#include "test.h"
#include "context.h"
+#include "messages-codes.h"
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wmissing-format-attribute"
log_info(ctx, "first info\n");
log_dbg(ctx, "first debug: %s\n", "hello");
log_err(ctx, "first error: %lu\n", 115415UL);
- log_vrb(ctx, 5, "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);
log_warn(ctx, "second warning: %d\n", 87);
log_dbg(ctx, "second debug: %s %s\n", "hello", "world");
log_info(ctx, "second info\n");
log_err(ctx, "second error: %lu\n", 115415UL);
- log_vrb(ctx, 6, "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_level(ctx, XKB_LOG_LEVEL_CRITICAL);
log_dbg(ctx, "third debug: %s %s\n", "hello", "world");
log_info(ctx, "third info\n");
log_err(ctx, "third error: %lu\n", 115415UL);
- log_vrb(ctx, 0, "third verbose 0\n");
+ log_vrb(ctx, 0, XKB_LOG_MESSAGE_NO_ID, "third verbose 0\n");
printf("%s", log_string.item);
assert(streq(log_string.item,
"warning: first warning: 87\n"
"error: first error: 115415\n"
- "warning: first verbose 5\n"
+ "warning: [XKB-000] first verbose 5\n"
"warning: second warning: 87\n"
"debug: second debug: hello world\n"
"info: second info\n"
static const struct xkb_message_entry xkb_messages[] = {
{XKB_ERROR_MALFORMED_NUMBER_LITERAL, "Malformed number literal"},
+ {XKB_WARNING_CONFLICTING_KEY_TYPE_PRESERVE_ENTRIES, "Conflicting key type preserve entries"},
{XKB_ERROR_UNSUPPORTED_MODIFIER_MASK, "Unsupported modifier mask"},
+ {XKB_ERROR_EXPECTED_ARRAY_ENTRY, "Expected array entry"},
+ {XKB_WARNING_ILLEGAL_KEYCODE_ALIAS, "Illegal keycode alias"},
{XKB_WARNING_UNRECOGNIZED_KEYSYM, "Unrecognized keysym"},
+ {XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER, "Undeclared virtual modifier"},
+ {XKB_ERROR_WRONG_STATEMENT_TYPE, "Wrong statement type"},
+ {XKB_WARNING_UNSUPPORTED_GEOMETRY_SECTION, "Unsupported geometry section"},
{XKB_WARNING_CANNOT_INFER_KEY_TYPE, "Cannot infer key type"},
+ {XKB_WARNING_ILLEGAL_KEY_TYPE_PRESERVE_RESULT, "Illegal key type preserve result"},
+ {XKB_ERROR_INVALID_INCLUDE_STATEMENT, "Invalid include statement"},
+ {XKB_ERROR_INVALID_MODMAP_ENTRY, "Invalid modmap entry"},
{XKB_ERROR_UNSUPPORTED_GROUP_INDEX, "Unsupported group index"},
+ {XKB_WARNING_CONFLICTING_KEY_TYPE_LEVEL_NAMES, "Conflicting key type level names"},
+ {XKB_ERROR_INVALID_SET_DEFAULT_STATEMENT, "Invalid set default statement"},
+ {XKB_WARNING_CONFLICTING_KEY_TYPE_MAP_ENTRY, "Conflicting key type map entry"},
{XKB_WARNING_UNDEFINED_KEY_TYPE, "Undefined key type"},
{XKB_WARNING_NON_BASE_GROUP_NAME, "Non base group name"},
{XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL, "Unsupported shift level"},
+ {XKB_ERROR_INCLUDED_FILE_NOT_FOUND, "Included file not found"},
+ {XKB_ERROR_UNKNOWN_OPERATOR, "Unknown operator"},
+ {XKB_WARNING_DUPLICATE_ENTRY, "Duplicate entry"},
+ {XKB_WARNING_CONFLICTING_KEY_TYPE_DEFINITIONS, "Conflicting key type definitions"},
+ {XKB_ERROR_WRONG_SCOPE, "Wrong scope"},
+ {XKB_WARNING_MISSING_DEFAULT_SECTION, "Missing default section"},
{XKB_WARNING_CONFLICTING_KEY_SYMBOL, "Conflicting key symbol"},
+ {XKB_ERROR_INVALID_OPERATION, "Invalid operation"},
{XKB_WARNING_NUMERIC_KEYSYM, "Numeric keysym"},
{XKB_WARNING_EXTRA_SYMBOLS_IGNORED, "Extra symbols ignored"},
+ {XKB_WARNING_CONFLICTING_KEY_NAME, "Conflicting key name"},
+ {XKB_ERROR_ALLOCATION_ERROR, "Allocation error"},
{XKB_ERROR_WRONG_FIELD_TYPE, "Wrong field type"},
+ {XKB_ERROR_INVALID_REAL_MODIFIER, "Invalid real modifier"},
{XKB_WARNING_UNKNOWN_CHAR_ESCAPE_SEQUENCE, "Unknown char escape sequence"},
+ {XKB_ERROR_INVALID_INCLUDED_FILE, "Invalid included file"},
{XKB_WARNING_MULTIPLE_GROUPS_AT_ONCE, "Multiple groups at once"},
+ {XKB_WARNING_UNSUPPORTED_SYMBOLS_FIELD, "Unsupported symbols field"},
{XKB_ERROR_INVALID_SYNTAX, "Invalid syntax"},
{XKB_WARNING_UNDEFINED_KEYCODE, "Undefined keycode"},
+ {XKB_ERROR_INVALID_EXPRESSION_TYPE, "Invalid expression type"},
+ {XKB_ERROR_INVALID_VALUE, "Invalid value"},
{XKB_WARNING_CONFLICTING_MODMAP, "Conflicting modmap"},
+ {XKB_ERROR_UNKNOWN_FIELD, "Unknown field"},
{XKB_WARNING_CONFLICTING_KEY_ACTION, "Conflicting key action"},
- {XKB_WARNING_CONFLICTING_KEY_TYPE, "Conflicting key type"},
+ {XKB_WARNING_CONFLICTING_KEY_TYPE_MERGING_GROUPS, "Conflicting key type merging groups"},
+ {XKB_ERROR_CONFLICTING_KEY_SYMBOLS_ENTRY, "Conflicting key symbols entry"},
+ {XKB_WARNING_MISSING_SYMBOLS_GROUP_NAME_INDEX, "Missing symbols group name index"},
{XKB_WARNING_CONFLICTING_KEY_FIELDS, "Conflicting key fields"},
- {XKB_WARNING_UNRESOLVED_KEYMAP_SYMBOL, "Unresolved keymap symbol"}
+ {XKB_ERROR_INVALID_IDENTIFIER, "Invalid identifier"},
+ {XKB_WARNING_UNRESOLVED_KEYMAP_SYMBOL, "Unresolved keymap symbol"},
+ {XKB_WARNING_UNDECLARED_MODIFIERS_IN_KEY_TYPE, "Undeclared modifiers in key type"}
};
int
projects / platform / upstream / libxkbcommon.git / commitdiff