kc3-lang/libxkbcommon

diff --git a/meson.build b/meson.build
index b884c90..ad268d0 100644
--- a/meson.build
+++ b/meson.build
@@ -285,6 +285,11 @@ test_env.set('XKB_LOG_LEVEL', 'debug')
 test_env.set('XKB_LOG_VERBOSITY', '10')
 test_env.set('top_srcdir', meson.source_root())
 test_env.set('top_builddir', meson.build_root())
+
+test_configh_data = configuration_data()
+test_configh_data.set_quoted('TEST_XKB_CONFIG_ROOT', join_paths(meson.source_root(), 'test', 'data'))
+configure_file(output: 'test-config.h', configuration: test_configh_data)
+
 # Some tests need to use unexported symbols, so we link them against
 # an internal copy of libxkbcommon with all symbols exposed.
 libxkbcommon_test_internal = static_library(
@@ -335,6 +340,11 @@ test(
     env: test_env,
 )
 test(
+    'rules-file-includes',
+    executable('test-rules-file-includes', 'test/rules-file-includes.c', dependencies: test_dep),
+    env: test_env,
+)
+test(
     'stringcomp',
     executable('test-stringcomp', 'test/stringcomp.c', dependencies: test_dep),
     env: test_env,
diff --git a/src/xkbcomp/rules.c b/src/xkbcomp/rules.c
index 15b6012..a08e3c5 100644
--- a/src/xkbcomp/rules.c
+++ b/src/xkbcomp/rules.c
@@ -52,6 +52,8 @@
 #include "include.h"
 #include "scanner-utils.h"
 
+#define MAX_INCLUDE_DEPTH 5
+
 /* Scanner / Lexer */
 
 /* Values returned with some tokens, like yylval. */
@@ -67,6 +69,7 @@ enum rules_token {
     TOK_BANG,
     TOK_EQUALS,
     TOK_STAR,
+    TOK_INCLUDE,
     TOK_ERROR
 };
 
@@ -131,6 +134,10 @@ skip_more_whitespace_and_comments:
         return TOK_GROUP_NAME;
     }
 
+    /* Include statement. */
+    if (lit(s, "include"))
+        return TOK_INCLUDE;
+
     /* Identifier. */
     if (is_ident(peek(s))) {
         val->string.start = s->s + s->pos;
@@ -338,6 +345,74 @@ matcher_group_add_element(struct matcher *m, struct scanner *s,
                   element);
 }
 
+static bool
+read_rules_file(struct xkb_context *ctx,
+                struct matcher *matcher,
+                unsigned include_depth,
+                const char *path);
+
+static void
+matcher_include(struct matcher *m, struct scanner *parent_scanner,
+                unsigned include_depth,
+                struct sval inc)
+{
+    bool ret;
+    struct scanner s; /* parses the !include value */
+
+    scanner_init(&s, m->ctx, inc.start, inc.len,
+                 parent_scanner->file_name, NULL);
+    s.token_line = parent_scanner->token_line;
+    s.token_column = parent_scanner->token_column;
+    s.buf_pos = 0;
+
+    if (include_depth >= MAX_INCLUDE_DEPTH) {
+        scanner_err(&s, "maximum include depth (%d) exceeded; maybe there is an include loop?",
+                    MAX_INCLUDE_DEPTH);
+        return;
+    }
+
+    while (!eof(&s) && !eol(&s)) {
+        if (chr(&s, '%')) {
+            if (chr(&s, '%')) {
+                buf_append(&s, '%');
+            }
+            else if (chr(&s, 'H')) {
+                const char *home = secure_getenv("HOME");
+                if (!home) {
+                    scanner_err(&s, "%%H was used in an include statement, but the HOME environment variable is not set");
+                    return;
+                }
+                if (!buf_appends(&s, home)) {
+                    scanner_err(&s, "include path after expanding %%H is too long");
+                    return;
+                }
+            }
+            else if (chr(&s, 'S')) {
+                const char *default_root = xkb_context_include_path_get_system_path(m->ctx);
+                if (!buf_appends(&s, default_root) || !buf_appends(&s, "/rules")) {
+                    scanner_err(&s, "include path after expanding %%S is too long");
+                    return;
+                }
+            }
+            else {
+                scanner_err(&s, "unknown %% format (%c) in include statement", peek(&s));
+                return;
+            }
+        }
+        else {
+            buf_append(&s, next(&s));
+        }
+    }
+    if (!buf_append(&s, '\0')) {
+        scanner_err(&s, "include path is too long");
+        return;
+    }
+
+    ret = read_rules_file(m->ctx, m, include_depth + 1, s.buf);
+    if (!ret)
+        log_err(m->ctx, "No components returned from included XKB rules \"%s\"\n", s.buf);
+}
+
 static void
 matcher_mapping_start_new(struct matcher *m)
 {
@@ -822,6 +897,7 @@ gettok(struct matcher *m, struct scanner *s)
 
 static bool
 matcher_match(struct matcher *m, struct scanner *s,
+              unsigned include_depth,
               const char *string, size_t len,
               const char *file_name)
 {
@@ -847,6 +923,8 @@ bang:
     case TOK_GROUP_NAME:
         matcher_group_start_new(m, m->val.string);
         goto group_name;
+    case TOK_INCLUDE:
+        goto include_statement;
     case TOK_IDENTIFIER:
         matcher_mapping_start_new(m);
         matcher_mapping_set_mlvo(m, s, m->val.string);
@@ -874,6 +952,15 @@ group_element:
         goto unexpected;
     }
 
+include_statement:
+    switch (tok = gettok(m, s)) {
+    case TOK_IDENTIFIER:
+        matcher_include(m, s, include_depth, m->val.string);
+        goto initial;
+    default:
+        goto unexpected;
+    }
+
 mapping_mlvo:
     switch (tok = gettok(m, s)) {
     case TOK_IDENTIFIER:
@@ -971,6 +1058,7 @@ error:
 static bool
 read_rules_file(struct xkb_context *ctx,
                 struct matcher *matcher,
+                unsigned include_depth,
                 const char *path)
 {
     bool ret = false;
@@ -992,7 +1080,7 @@ read_rules_file(struct xkb_context *ctx,
 
     scanner_init(&scanner, matcher->ctx, string, size, path, NULL);
 
-    ret = matcher_match(matcher, &scanner, string, size, path);
+    ret = matcher_match(matcher, &scanner, include_depth, string, size, path);
 
     unmap_file(string, size);
 out:
@@ -1021,7 +1109,7 @@ xkb_components_from_rules(struct xkb_context *ctx,
 
     matcher = matcher_new(ctx, rmlvo);
 
-    ret = read_rules_file(ctx, matcher, path);
+    ret = read_rules_file(ctx, matcher, 0, path);
     if (!ret ||
         darray_empty(matcher->kccgst[KCCGST_KEYCODES]) ||
         darray_empty(matcher->kccgst[KCCGST_TYPES]) ||
diff --git a/test/data/rules/inc-dst-loop-twice b/test/data/rules/inc-dst-loop-twice
new file mode 100644
index 0000000..abb11b0
--- /dev/null
+++ b/test/data/rules/inc-dst-loop-twice
@@ -0,0 +1,20 @@
+! model         = keycodes
+  *             = default_keycodes
+
+! layout        variant    = symbols
+  my_layout     my_variant = my_symbols+extra_variant
+
+! layout        = symbols
+  my_layout     = my_symbols
+  *             = default_symbols
+
+! model         = types
+  *             = default_types
+
+! model         = compat
+  *             = default_compat
+
+! option        = compat
+  my_option     = |some:compat
+
+! include %S/inc-src-loop-twice
diff --git a/test/data/rules/inc-dst-simple b/test/data/rules/inc-dst-simple
new file mode 100644
index 0000000..a8d0605
--- /dev/null
+++ b/test/data/rules/inc-dst-simple
@@ -0,0 +1,18 @@
+! model         = keycodes
+  my_model      = my_keycodes
+  *             = default_keycodes
+
+! layout        variant    = symbols
+  my_layout     my_variant = my_symbols+extra_variant
+
+! layout        = symbols
+  *             = default_symbols
+
+! model         = types
+  *             = default_types
+
+! model         = compat
+  *             = default_compat
+
+! option        = compat
+  my_option     = |some:compat
diff --git a/test/data/rules/inc-src-before-after b/test/data/rules/inc-src-before-after
new file mode 100644
index 0000000..6ea34f0
--- /dev/null
+++ b/test/data/rules/inc-src-before-after
@@ -0,0 +1,7 @@
+! model         = keycodes
+  before_model  = my_keycodes
+
+! include %S/inc-dst-simple
+
+! layout        = symbols
+  after_layout  = my_symbols
diff --git a/test/data/rules/inc-src-loop-twice b/test/data/rules/inc-src-loop-twice
new file mode 100644
index 0000000..67e66c1
--- /dev/null
+++ b/test/data/rules/inc-src-loop-twice
@@ -0,0 +1,4 @@
+! model         = keycodes
+  my_model      = my_keycodes
+
+! include %S/inc-dst-loop-twice
diff --git a/test/data/rules/inc-src-looped b/test/data/rules/inc-src-looped
new file mode 100644
index 0000000..652abdd
--- /dev/null
+++ b/test/data/rules/inc-src-looped
@@ -0,0 +1 @@
+! include %S/inc-src-looped
diff --git a/test/data/rules/inc-src-nested b/test/data/rules/inc-src-nested
new file mode 100644
index 0000000..7f23207
--- /dev/null
+++ b/test/data/rules/inc-src-nested
@@ -0,0 +1 @@
+! include %S/inc-src-simple
diff --git a/test/data/rules/inc-src-options b/test/data/rules/inc-src-options
new file mode 100644
index 0000000..6fa13ec
--- /dev/null
+++ b/test/data/rules/inc-src-options
@@ -0,0 +1,10 @@
+! option        = compat
+  option111     = +substring
+  option1       = +some:compat
+  option11      = +group(bla)
+
+! include %S/inc-dst-simple
+
+! option        = symbols
+  option3       = +compose(foo)+keypad(bar)
+  colon:opt     = +altwin(menu)
diff --git a/test/data/rules/inc-src-simple b/test/data/rules/inc-src-simple
new file mode 100644
index 0000000..afe4742
--- /dev/null
+++ b/test/data/rules/inc-src-simple
@@ -0,0 +1,4 @@
+! layout        = symbols
+  my_layout     = my_symbols
+
+! include %S/inc-dst-simple
diff --git a/test/rules-file-includes.c b/test/rules-file-includes.c
new file mode 100644
index 0000000..bdeb03a
--- /dev/null
+++ b/test/rules-file-includes.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2012 Ran Benita <ran234@gmail.com>
+ * Copyright © 2019 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "test-config.h"
+
+#include "test.h"
+#include "xkbcomp/xkbcomp-priv.h"
+#include "xkbcomp/rules.h"
+
+struct test_data {
+    /* Rules file */
+    const char *rules;
+
+    /* Input */
+    const char *model;
+    const char *layout;
+    const char *variant;
+    const char *options;
+
+    /* Expected output */
+    const char *keycodes;
+    const char *types;
+    const char *compat;
+    const char *symbols;
+
+    /* Or set this if xkb_components_from_rules() should fail. */
+    bool should_fail;
+};
+
+static bool
+test_rules(struct xkb_context *ctx, struct test_data *data)
+{
+    bool passed;
+    const struct xkb_rule_names rmlvo = {
+        data->rules, data->model, data->layout, data->variant, data->options
+    };
+    struct xkb_component_names kccgst;
+
+    fprintf(stderr, "\n\nChecking : %s\t%s\t%s\t%s\t%s\n", data->rules,
+            data->model, data->layout, data->variant, data->options);
+
+    if (data->should_fail)
+        fprintf(stderr, "Expecting: FAILURE\n");
+    else
+        fprintf(stderr, "Expecting: %s\t%s\t%s\t%s\n",
+                data->keycodes, data->types, data->compat, data->symbols);
+
+    if (!xkb_components_from_rules(ctx, &rmlvo, &kccgst)) {
+        fprintf(stderr, "Received : FAILURE\n");
+        return data->should_fail;
+    }
+
+    fprintf(stderr, "Received : %s\t%s\t%s\t%s\n",
+            kccgst.keycodes, kccgst.types, kccgst.compat, kccgst.symbols);
+
+    passed = streq(kccgst.keycodes, data->keycodes) &&
+             streq(kccgst.types, data->types) &&
+             streq(kccgst.compat, data->compat) &&
+             streq(kccgst.symbols, data->symbols);
+
+    free(kccgst.keycodes);
+    free(kccgst.types);
+    free(kccgst.compat);
+    free(kccgst.symbols);
+
+    return passed;
+}
+
+int
+main(int argc, char *argv[])
+{
+    struct xkb_context *ctx;
+
+    setenv("XKB_CONFIG_ROOT", TEST_XKB_CONFIG_ROOT, 1);
+
+    ctx = test_get_context(0);
+    assert(ctx);
+
+    struct test_data test1 = {
+        .rules = "inc-src-simple",
+
+        .model = "my_model", .layout = "my_layout", .variant = "", .options = "",
+
+        .keycodes = "my_keycodes", .types = "default_types",
+        .compat = "default_compat", .symbols = "my_symbols",
+    };
+    assert(test_rules(ctx, &test1));
+
+    struct test_data test2 = {
+        .rules = "inc-src-nested",
+
+        .model = "my_model", .layout = "my_layout", .variant = "", .options = "",
+
+        .keycodes = "my_keycodes", .types = "default_types",
+        .compat = "default_compat", .symbols = "my_symbols",
+    };
+    assert(test_rules(ctx, &test2));
+
+    struct test_data test3 = {
+        .rules = "inc-src-looped",
+
+        .model = "my_model", .layout = "my_layout", .variant = "", .options = "",
+
+        .should_fail = true,
+    };
+    assert(test_rules(ctx, &test3));
+
+    struct test_data test4 = {
+        .rules = "inc-src-before-after",
+
+        .model = "before_model", .layout = "my_layout", .variant = "", .options = "",
+
+        .keycodes = "my_keycodes", .types = "default_types",
+        .compat = "default_compat", .symbols = "default_symbols",
+    };
+    assert(test_rules(ctx, &test4));
+
+    struct test_data test5 = {
+        .rules = "inc-src-options",
+
+        .model = "my_model", .layout = "my_layout", .variant = "my_variant",
+        .options = "option11,my_option,colon:opt,option111",
+
+        .keycodes = "my_keycodes", .types = "default_types",
+        .compat = "default_compat+substring+group(bla)|some:compat",
+        .symbols = "my_symbols+extra_variant+altwin(menu)",
+    };
+    assert(test_rules(ctx, &test5));
+
+    struct test_data test6 = {
+        .rules = "inc-src-loop-twice",
+
+        .model = "my_model", .layout = "my_layout", .variant = "", .options = "",
+
+        .keycodes = "my_keycodes", .types = "default_types",
+        .compat = "default_compat", .symbols = "my_symbols",
+    };
+    assert(test_rules(ctx, &test6));
+
+    xkb_context_unref(ctx);
+    return 0;
+}