Skip heading UTF-8 encoded BOM

src/compose/parser.c

@@ -534,6 +534,10 @@ parse(struct xkb_compose_table *table, struct scanner *s,
     production.mods = 0;
     production.modmask = 0;
 
+    /* Skip UTF-8 encoded BOM (U+FEFF) */
+    /* See: https://www.unicode.org/faq/utf_bom.html#bom5 */
+    scanner_str(s, "\xef\xbb\xbf", 3);
+
     /* fallthrough */
 
 initial_eol:

src/xkbcomp/rules.c

@@ -1099,6 +1099,10 @@ read_rules_file(struct xkb_context *ctx,
 
     scanner_init(&scanner, matcher->ctx, string, size, path, NULL);
 
+    /* Skip UTF-8 encoded BOM (U+FEFF) */
+    /* See: https://www.unicode.org/faq/utf_bom.html#bom5 */
+    scanner_str(&scanner, "\xef\xbb\xbf", 3);
+
     ret = matcher_match(matcher, &scanner, include_depth, string, size, path);
 
     unmap_file(string, size);

src/xkbcomp/scanner.c

@@ -199,6 +199,11 @@ XkbParseString(struct xkb_context *ctx, const char *string, size_t len,
 {
     struct scanner scanner;
     scanner_init(&scanner, ctx, string, len, file_name, NULL);
+
+    /* Skip UTF-8 encoded BOM (U+FEFF) */
+    /* See: https://www.unicode.org/faq/utf_bom.html#bom5 */
+    scanner_str(&scanner, "\xef\xbb\xbf", 3);
+
     return parse(ctx, &scanner, map);
 }
 

test/buffercomp.c

@@ -78,6 +78,18 @@ main(int argc, char *argv[])
     keymap = test_compile_buffer(ctx, "", 0);
     assert(!keymap);
 
+    /* Accept UTF-8 encoded BOM (U+FEFF) */
+    const char *bom =
+        "\xef\xbb\xbfxkb_keymap {"
+        "  xkb_keycodes { include \"evdev\" };"
+        "  xkb_types { include \"complete\" };"
+        "  xkb_compat { include \"complete\" };"
+        "  xkb_symbols { include \"pc\" };"
+        "};";
+    keymap = test_compile_buffer(ctx, bom, strlen(bom));
+    assert(keymap);
+    xkb_keymap_unref(keymap);
+
     /* Make sure we can recompile our output for a normal keymap from rules. */
     keymap = test_compile_rules(ctx, NULL, NULL,
                                 "ru,ca,de,us", ",multix,neo,intl", NULL);

test/compose.c

@@ -172,6 +172,16 @@ test_compose_seq_buffer(struct xkb_context *ctx, const char *buffer, ...)
     return ok;
 }
 
+static void
+test_compose_utf8_bom(struct xkb_context *ctx)
+{
+    const char *buffer = "\xef\xbb\xbf<A> : X";
+    assert(test_compose_seq_buffer(ctx, buffer,
+        XKB_KEY_A, XKB_COMPOSE_FEED_ACCEPTED, XKB_COMPOSE_COMPOSED, "X", XKB_KEY_X,
+        XKB_KEY_NoSymbol));
+}
+
+
 static void
 test_seqs(struct xkb_context *ctx)
 {
@@ -723,6 +733,7 @@ main(int argc, char *argv[])
     unsetenv("XLOCALEDIR");
 #endif
 
+    test_compose_utf8_bom(ctx);
     test_seqs(ctx);
     test_conflicting(ctx);
     test_XCOMPOSEFILE(ctx);

test/data/rules/utf-8_with_bom

@@ -0,0 +1,22 @@
+// NOTE: this file is encoded in UTF-8 with a leading BOM (U+FEFF)
+! model         = keycodes
+  my_model      = my_keycodes
+  *             = default_keycodes
+
+! layout        variant    = symbols
+  my_layout     my_variant = my_symbols+extra_variant
+
+! layout        = symbols
+  my_layout     = my_symbols
+  *             = default_symbols
+
+! model         = types
+  my_model      = my_types
+  *             = default_types
+
+! model         = compat
+  my_model      = my_compat
+  *             = default_compat
+
+! option        = compat
+  my_option     = |some:compat

test/rules-file.c

@@ -94,6 +94,18 @@ main(int argc, char *argv[])
     ctx = test_get_context(0);
     assert(ctx);
 
+    struct test_data test_utf_8_with_bom = {
+        .rules = "utf-8_with_bom",
+
+        .model = "my_model", .layout = "my_layout", .variant = "my_variant",
+        .options = "my_option",
+
+        .keycodes = "my_keycodes", .types = "my_types",
+        .compat = "my_compat|some:compat",
+        .symbols = "my_symbols+extra_variant",
+    };
+    assert(test_rules(ctx, &test_utf_8_with_bom));
+
     struct test_data test1 = {
         .rules = "simple",