Product configuration in Starlark support files.

Bug: 170637441
Test: rbcrun build/make/tests/run.rbc
Change-Id: Ie8f0c3dea66a287f2b0a3b588c446bfbb2c9a978

core/build_id.rbc

@@ -0,0 +1,21 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This file has been manually converted from build_id.mk
+def init(g):
+
+    # BUILD_ID is usually used to specify the branch name (like "MAIN") or a branch name and a release candidate
+    # (like "CRB01").  It must be a single word, and is capitalized by convention.
+    g["BUILD_ID"]="AOSP.MASTER"

core/envsetup.rbc

@@ -0,0 +1,199 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load(":build_id.rbc|init", _build_id_init="init")
+
+def _all_versions():
+    """Returns all known versions."""
+    versions = ["OPR1", "OPD1", "OPD2","OPM1", "OPM2", "PPR1", "PPD1", "PPD2", "PPM1",  "PPM2", "QPR1" ]
+    for v in ("Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"):
+        for e in ("P1A", "P1B", "P2A", "P2B", "D1A", "D1B", "D2A", "D2B", "Q1A", "Q1B", "Q2A", "Q2B", "Q3A",  "Q3B"):
+            versions.append(v+e)
+    return versions
+
+def _allowed_versions(all_versions, min_version, max_version, default_version):
+    """Checks that version range and default versions is valid, returns all versions in range."""
+    for v in (min_version, max_version, default_version):
+        if v not in all_versions:
+            fail("% is invalid" % v)
+
+    min_i = all_versions.index(min_version)
+    max_i = all_versions.index(max_version)
+    def_i = all_versions.index(default_version)
+    if min_i > max_i:
+        fail("%s should come before %s in the version list" % (min_version, max_version))
+    if def_i < min_i or def_i > max_i:
+        fail("%s should come between % and %s" % (default_version, min_version, max_version))
+    return all_versions[min_i:max_i+1]
+
+# This function is a manual conversion of the version_defaults.mk
+def _versions_default(g, all_versions):
+    """Handle various build version information.
+
+    Guarantees that the following are defined:
+     PLATFORM_VERSION
+     PLATFORM_SDK_VERSION
+     PLATFORM_VERSION_CODENAME
+     DEFAULT_APP_TARGET_SDK
+     BUILD_ID
+     BUILD_NUMBER
+     PLATFORM_SECURITY_PATCH
+     PLATFORM_VNDK_VERSION
+     PLATFORM_SYSTEMSDK_VERSIONS
+    """
+
+    # If build_id.rbc exists, it may override some of the defaults.
+    # Note that build.prop target also wants INTERNAL_BUILD_ID_MAKEFILE to be set if the file exists.
+    if _build_id_init != None:
+        _build_id_init(g)
+        g["INTERNAL_BUILD_ID_MAKEFILE"] = "build/make/core/build_id"
+
+    allowed_versions = _allowed_versions(all_versions, v_min, v_max, v_default)
+    g.setdefault("TARGET_PLATFORM_VERSION", v_default)
+    if g["TARGET_PLATFORM_VERSION"] not in allowed_versions:
+        fail("% is not valid, must be one of %s" % (g["TARGET_PLATFORM_VERSION"], allowed_versions))
+
+    g["DEFAULT_PLATFORM_VERSION"] = v_default
+    g["PLATFORM_VERSION_LAST_STABLE"] = 11
+    g.setdefault("PLATFORM_VERSION_CODENAME", g["TARGET_PLATFORM_VERSION"])
+    # TODO(asmundak): set PLATFORM_VERSION_ALL_CODENAMES
+
+    g.setdefault("PLATFORM_VERSION",
+        g["PLATFORM_VERSION_LAST_STABLE"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
+    g.setdefault("PLATFORM_SDK_VERSION", 30)
+    if g["PLATFORM_VERSION_CODENAME"] == "REL":
+        g["PLATFORM_PREVIEW_SDK_VERSION"] = 0
+    else:
+        g.setdefault("PLATFORM_PREVIEW_SDK_VERSION", 1)
+
+    g.setdefault("DEFAULT_APP_TARGET_SDK",
+        g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
+    g.setdefault("PLATFORM_VNDK_VERSION",
+        g["PLATFORM_SDK_VERSION"] if g["PLATFORM_VERSION_CODENAME"] == "REL" else g["PLATFORM_VERSION_CODENAME"])
+    g.setdefault("PLATFORM_SYSTEMSDK_MIN_VERSION", 28)
+    versions = [str(i) for i in range(g["PLATFORM_SYSTEMSDK_MIN_VERSION"], g["PLATFORM_SDK_VERSION"] + 1)]
+    versions.append(g["PLATFORM_VERSION_CODENAME"])
+    g["PLATFORM_SYSTEMSDK_VERSIONS"] = sorted(versions)
+
+    #  Used to indicate the security patch that has been applied to the device.
+    #  It must signify that the build includes all security patches issued up through the designated Android Public Security Bulletin.
+    #  It must be of the form "YYYY-MM-DD" on production devices.
+    #  It must match one of the Android Security Patch Level strings of the Public Security Bulletins.
+    #  If there is no $PLATFORM_SECURITY_PATCH set, keep it empty.
+    g.setdefault("PLATFORM_SECURITY_PATCH", "2021-03-05")
+    dt = 'TZ="GMT" %s' % g["PLATFORM_SECURITY_PATCH"]
+    g.setdefault("PLATFORM_SECURITY_PATCH_TIMESTAMP", rblf_shell("date -d '%s' +%%s" % dt))
+
+    # Used to indicate the base os applied to the device. Can be an arbitrary string, but must be a single word.
+    # If there is no $PLATFORM_BASE_OS set, keep it empty.
+    g.setdefault("PLATFORM_BASE_OS", "")
+
+    # Used to signify special builds.  E.g., branches and/or releases, like "M5-RC7".  Can be an arbitrary string, but
+    # must be a single word and a valid file name. If there is no BUILD_ID set, make it obvious.
+    g.setdefault("BUILD_ID", "UNKNOWN")
+
+    # BUILD_NUMBER should be set to the source control value that represents the current state of the source code.
+    # E.g., a perforce changelist number or a git hash.  Can be an arbitrary string (to allow for source control that
+    # uses something other than numbers), but must be a single word and a valid file name.
+    #
+    # If no BUILD_NUMBER is set, create a useful "I am an engineering build from this date/time" value.  Make it start
+    # with a non-digit so that anyone trying to parse it as an integer will probably get "0".
+    g.setdefault("BUILD_NUMBER", "eng.%s.%s" % (g["USER"], "TIMESTAMP"))
+
+    # Used to set minimum supported target sdk version. Apps targeting SDK version lower than the set value will result
+    # in a warning being shown when any activity from the app is started.
+    g.setdefault("PLATFORM_MIN_SUPPORTED_TARGET_SDK_VERSION", 23)
+
+def init(g):
+    all_versions = _all_versions()
+    _versions_default(g, all_versions)
+    for v in all_versions:
+        g["IS_AT_LEAST" + v] = True
+        if v == g["TARGET_PLATFORM_VERSION"]:
+            break
+
+    # ---------------------------------------------------------------
+    # If you update the build system such that the environment setup or buildspec.mk need to be updated,
+    # increment this number, and people who haven't re-run those will have to do so before they can build.
+    # Make sure to also update the corresponding value in buildspec.mk.default and envsetup.sh.
+    g["CORRECT_BUILD_ENV_SEQUENCE_NUMBER"] = 13
+
+    g.setdefault("TARGET_PRODUCT", "aosp_arm")
+    g.setdefault("TARGET_BUILD_VARIANT", "eng")
+
+    g.setdefault("TARGET_BUILD_APPS", [])
+    g["TARGET_BUILD_UNBUNDLED"] = (g["TARGET_BUILD_APPS"] != []) or (getattr(g, "TARGET_BUILD_UNBUNDLED_IMAGE", "") != "")
+
+    # ---------------------------------------------------------------
+    # Set up configuration for host machine.  We don't do cross-compiles except for arm, so the HOST
+    # is whatever we are running on.
+    host = rblf_shell("uname -sm")
+    if host.find("Linux") >= 0:
+        g["HOST_OS"] = "linux"
+    elif host.find("Darwin") >= 0:
+        g["HOST_OS"] = "darwin"
+    else:
+        fail("Cannot run on %s OS" % host)
+
+    # TODO(asmundak): set g.HOST_OS_EXTRA
+
+    g["BUILD_OS"] = g["HOST_OS"]
+
+    # TODO(asmundak): check cross-OS build
+
+    if host.find("x86_64") >= 0:
+        g["HOST_ARCH"] = "x86_64"
+        g["HOST_2ND_ARCH"] = "x86"
+        g["HOST_IS_64_BIT"] = True
+    elif host.find("i686") >= 0 or host.find("x86") >= 0:
+        fail("Building on a 32-bit x86 host is not supported: %s" % host)
+    elif g["HOST_OS"] == "darwin":
+        g["HOST_2ND_ARCH"] = ""
+
+    g["HOST_2ND_ARCH_VAR_PREFIX"] = "2ND_"
+    g["HOST_2ND_ARCH_MODULE_SUFFIX"] = "_32"
+    g["HOST_CROSS_2ND_ARCH_VAR_PREFIX"] = "2ND_"
+    g["HOST_CROSS_2ND_ARCH_MODULE_SUFFIX"] = "_64"
+    g["TARGET_2ND_ARCH_VAR_PREFIX"] = "2ND_"
+
+    # TODO(asmundak): combo-related stuff
+
+    # on windows, the tools have .exe at the end, and we depend on the
+    # host config stuff being done first
+    g["BUILD_ARCH"] = g["HOST_ARCH"]
+    g["BUILD_2ND_ARCH"] = g["HOST_2ND_ARCH"]
+
+    # the host build defaults to release, and it must be release or debug
+    g.setdefault("HOST_BUILD_TYPE", "release")
+    if g["HOST_BUILD_TYPE"] != "release" and g["HOST_BUILD_TYPE"] != "debug":
+        fail("HOST_BUILD_TYPE must be either release or debug, not '%s'" % g["HOST_BUILD_TYPE"])
+
+    # TODO(asmundak): a lot more, but not needed for the product configuration
+
+    g["ART_APEX_JARS"] = [
+        "com.android.art:core-oj",
+        "com.android.art:core-libart",
+        "com.android.art:okhttp",
+        "com.android.art:bouncycastle",
+        "com.android.art:apache-xml"
+    ]
+
+    if g.get("TARGET_BUILD_TYPE", "") != "debug":
+        g["TARGET_BUILD_TYPE"] = "release"
+
+
+v_default = "SP1A"
+v_min = "SP1A"
+v_max = "SP1A"

core/product_config.rbc

@@ -0,0 +1,483 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load("//build/make/core:envsetup.rbc", _envsetup_init="init")
+"""Runtime functions."""
+
+def _global_init():
+    """Returns dict created from the runtime environment."""
+    globals = dict()
+
+    # Environment variables
+    for k in dir(rblf_env):
+        globals[k] = getattr(rblf_env, k)
+
+    # Variables set as var=value command line arguments
+    for k in dir(rblf_cli):
+        globals[k] = getattr(rblf_cli, k)
+
+    globals.setdefault("PRODUCT_SOONG_NAMESPACES", [])
+    _envsetup_init(globals)
+
+    # Variables that should be defined.
+    mandatory_vars = [
+        "PLATFORM_VERSION_CODENAME", "PLATFORM_VERSION",
+        "PRODUCT_SOONG_NAMESPACES",
+        # TODO(asmundak): do we need TARGET_ARCH? AOSP does not reference it
+        "TARGET_BUILD_TYPE", "TARGET_BUILD_VARIANT", "TARGET_PRODUCT",
+    ]
+    for bv in mandatory_vars:
+        if not bv in globals:
+            fail(bv, " is not defined")
+
+    return globals
+
+_globals_base = _global_init()
+
+def __print_attr(attr, value):
+    if not value:
+        return
+    if type(value) == "list":
+        if _options.rearrange:
+            value = __printvars_rearrange_list(value)
+        if _options.format == "pretty":
+            print(attr, "=", repr(value))
+        elif _options.format == "make":
+            print(attr, ":=", " ".join(value))
+    else:
+        if _options.format == "pretty":
+            print(attr, "=", repr(value))
+        elif _options.format == "make":
+            print(attr, ":=", value)
+        else:
+            fail("bad output format", _options.format)
+
+
+def _printvars(globals, cfg):
+    """Prints known configuration variables."""
+    for attr, val in sorted(cfg.items()):
+        __print_attr(attr, val)
+    if _options.print_globals:
+        for attr, val in sorted(globals.items()):
+            print()
+            if attr not in _globals_base:
+                __print_attr(attr, val)
+
+
+def __printvars_rearrange_list(l):
+    """Rearrange value list: return only distinct elements, maybe sorted."""
+    seen = { item: 0 for item in l}
+    return sorted(seen.keys()) if _options.rearrange == "sort" else seen.keys()
+
+def _product_configuration(top_pcm_name, top_pcm):
+    """Creates configuration."""
+
+    # Product configuration is created by traversing product's inheritance
+    # tree. It is traversed twice.
+    # First, beginning with top-level module we execute a module and find
+    # its ancestors, repeating this recursively. At the end of this phase
+    # we get the full inheritance tree.
+    # Second, we traverse the tree in the postfix order (i.e., visiting a
+    # node after its ancestors) to calculate the product configuration.
+    #
+    # PCM means "Product Configuration Module", i.e., a Starlark file
+    # whose body consists of a single init function.
+
+    globals = dict(**_globals_base)
+
+    config_postfix = []     # Configs in postfix order
+    # Each PCM is represented by a quadruple of function, config, children names
+    # and readyness (that is, the configurations from inherited PCMs have been
+    # substituted).
+    configs = { top_pcm_name: (top_pcm, None, [], False)}  # All known PCMs
+
+    stash = []              # Configs to push once their descendants are done
+
+    # Stack maintaining PCMs to be processed. An item in the stack
+    # is a pair of PCMs name and its height in the product inheritance tree.
+    pcm_stack = []
+    pcm_stack.append((top_pcm_name, 0))
+    pcm_count = 0
+    # Run it until pcm_stack is exhausted, but no more than N times
+    for n in range(1000):
+        if not pcm_stack:
+            break
+        (name, height) = pcm_stack.pop()
+        pcm, cfg, c, _ = configs[name]
+        # each PCM is executed once
+        if cfg != None:
+            continue
+        # Push ancestors until we reach this node's height
+        config_postfix.extend([stash.pop() for i in range(len(stash) - height)])
+
+        # Run this one, obtaining its configuration and child PCMs.
+        if _options.trace_modules:
+            print("%s:" % n[0])
+
+        # The handle passed to the PCM consists of config and inheritance state.dict of inherited modules
+        # and a list containing the current default value of a list variable.
+        handle = __h_new()
+        pcm(globals, handle)
+        children = __h_inherited_modules(handle)
+        if _options.trace_modules:
+            print("   ", "    ".join(children.keys()))
+        configs[name] = (pcm, __h_cfg(handle), children.keys(), False)
+        pcm_count = pcm_count+1
+
+        if len(children) == 0:
+            # Leaf PCM goes straight to the config_postfix
+            config_postfix.append(name)
+            continue
+
+        # Stash this PCM, process children in the sorted order
+        stash.append(name)
+        for child_name in sorted(children, reverse=True):
+            if child_name not in configs:
+                configs[child_name] = (children[child_name], None, [], False)
+            pcm_stack.append((child_name, len(stash)))
+
+    # Flush the stash
+    config_postfix.extend([stash.pop() for i in range(len(stash))])
+    if len(config_postfix) != pcm_count:
+        fail("Ran %d modules but postfix tree has only %d entries" % (pcm_count, len(config_postfix)))
+
+
+    if _options.trace_modules:
+        print("\n---Postfix---")
+        for x in config_postfix:
+            print("   ", x)
+
+    # Traverse the tree from the bottom, evaluating inherited values
+    for pcm_name in config_postfix:
+        pcm, cfg, children_names, ready = configs[pcm_name]
+        # Should run
+        if cfg == None:
+            fail("%s: has not been run" % pcm_name)
+        # Ready once
+        if ready:
+            continue
+        # Children should be ready
+        for child_name in children_names:
+            if not configs[child_name][3]:
+                fail("%s: child is not ready" % child_name)
+
+        # if _options.trace_modules:
+        #     print(">%s: %s" % (pcm_name, cfg))
+
+        _substitute_inherited(configs, pcm_name, cfg)
+        _percolate_inherited(configs, pcm_name, cfg, children_names)
+        configs[pcm_name] = pcm, cfg, children_names, True
+        # if _options.trace_modules:
+        #     print("<%s: %s" % (pcm_name, cfg))
+
+    return globals, configs[top_pcm_name][1]
+
+
+def _substitute_inherited(configs, pcm_name, cfg):
+    """Substitutes inherited values in all the configuration settings."""
+    for attr, val in cfg.items():
+        trace_it = attr in _options.trace_variables
+        if trace_it:
+            old_val = val
+
+        # TODO(asmundak): should we handle single vars?
+        if type(val) != "list":
+            continue
+
+        if trace_it:
+            new_val = _value_expand(configs, attr, val)
+            if new_val != old_val:
+                print("%s(i): %s=%s (was %s)" % (pcm_name, attr, new_val, old_val))
+            cfg[attr] = new_val
+            continue
+
+        cfg[attr] = _value_expand(configs, attr, val)
+
+
+
+def _value_expand(configs, attr, values_list):
+    """Expands references to inherited values in a given list."""
+    result = []
+    expanded={}
+    for item in values_list:
+        # Inherited values are 1-tuples
+        if type(item) != "tuple":
+            result.append(item)
+            continue
+        child_name = item[0]
+        if child_name in expanded:
+            continue
+        expanded[child_name] = True
+        child = configs[child_name]
+        if not child[3]:
+            fail("%s should be ready" % child_name)
+        __move_items(result, child[1], attr)
+
+    return result
+
+
+def _percolate_inherited(configs, cfg_name, cfg, children_names):
+    """Percolates the settings that are present only in children."""
+    percolated_attrs = {}
+    for child_name in children_names:
+        child_cfg = configs[child_name][1]
+        for attr, value in child_cfg.items():
+            if type(value) != "list":
+                if attr in percolated_attrs or not attr in cfg:
+                    cfg[attr] = value
+                    percolated_attrs[attr] = True
+                continue
+            if attr in percolated_attrs:
+                # We already are percolating this one, just add this list
+                __move_items(cfg[attr], child_cfg, attr)
+            elif not attr in cfg:
+                percolated_attrs[attr] = True
+                cfg[attr] = []
+                __move_items(cfg[attr], child_cfg, attr)
+
+    for attr in _options.trace_variables:
+        if attr in percolated_attrs:
+            print("%s: %s^=%s" % (cfg_name, attr, cfg[attr]))
+
+
+def __move_items(to_list, from_cfg, attr):
+    l = from_cfg.get(attr, [])
+    if l:
+        to_list.extend(l)
+        from_cfg[attr] = []
+
+
+def _indirect(pcm_name):
+    """Returns configuration item for the inherited module."""
+    return (pcm_name,)
+
+
+def _addprefix(prefix, string_or_list):
+    """Adds prefix and returns a list.
+
+    If string_or_list is a list, prepends prefix to each element.
+    Otherwise, string_or_list is considered to be a string which
+    is split into words and then prefix is prepended to each one.
+
+    Args:
+        prefix
+        string_or_list
+
+    """
+    return [ prefix + x for x in __words(string_or_list)]
+
+
+def _addsuffix(suffix, string_or_list):
+    """Adds suffix and returns a list.
+
+    If string_or_list is a list, appends suffix to each element.
+    Otherwise, string_or_list is considered to be a string which
+    is split into words and then suffix is appended to each one.
+
+    Args:
+      suffix
+      string_or_list
+    """
+    return [ x + suffix for x in __words(string_or_list)]
+
+
+def __words(string_or_list):
+    if type(string_or_list) == "list":
+        return string_or_list
+    return string_or_list.split()
+
+
+def __h_new():
+    """Constructs a handle which is passed to PCM."""
+    return (dict(), dict(), list())
+
+def __h_inherited_modules(handle):
+    return handle[1]
+
+
+def __h_cfg(handle):
+    return handle[0]
+
+
+def _setdefault(handle, attr):
+    """Sets given attribute's value if it has not been set."""
+    cfg = handle[0]
+    if cfg.get(attr) == None:
+        cfg[attr] = list(handle[2])
+    return cfg[attr]
+
+def _inherit(handle, pcm_name, pcm):
+    """Records inheritance."""
+    cfg, inherited, default_lv = handle
+    inherited[pcm_name]=pcm
+    default_lv.append(_indirect(pcm_name))
+    # Add inherited module reference to all configuration values
+    for attr, val in cfg.items():
+        if type(val) == "list":
+            val.append(_indirect(pcm_name))
+
+
+def _copy_if_exists(path_pair):
+    """If from file exists, returns [from:to] pair."""
+    l = path_pair.split(":", 2)
+    # Check that l[0] exists
+    return [":".join(l)] if rblf_file_exists(l[0]) else []
+
+def _enforce_product_packages_exist(pkg_string_or_list):
+    """Makes including non-existent modules in PRODUCT_PACKAGES an error."""
+    #TODO(asmundak)
+    pass
+
+
+def _file_wildcard_exists(file_pattern):
+    """Return True if there are files matching given bash pattern."""
+    return len(rblf_wildcard(file_pattern)) > 0
+
+
+def _find_and_copy(pattern, from_dir, to_dir):
+    """Return a copy list for the files matching the pattern."""
+    return ["%s/%s:%s/%s" % (from_dir, f, to_dir, f) for f in rblf_wildcard(pattern, from_dir)]
+
+
+def _filter_out(pattern, text):
+    """Return all the words from `text' that do not match any word in `pattern'.
+
+    Args:
+        pattern: string or list of words. '%' stands for wildcard (in regex terms, '.*')
+        text: string or list of words
+    Return:
+        list of words
+    """
+    rex = __mk2regex(__words(pattern))
+    res = []
+    for w in __words(text):
+        if not _regex_match(rex, w):
+            res.append(w)
+    return res
+
+
+def _filter(pattern, text):
+    """Return all the words in `text` that match `pattern`.
+
+    Args:
+        pattern: strings of words or a list. A word can contain '%',
+         which stands for any sequence of characters.
+        text: string or list of words.
+    """
+    rex = __mk2regex(__words(pattern))
+    res = []
+    for w in __words(text):
+        if _regex_match(rex, w):
+            res.append(w)
+    return res
+
+
+def __mk2regex(words):
+    """Returns regular expression equivalent to Make pattern."""
+
+    # TODO(asmundak): this will mishandle '\%'
+    return "^(" + "|".join([w.replace("%", ".*", 1) for w in words]) + ")"
+
+
+def _regex_match(regex, w):
+    return rblf_regex(regex, w)
+
+
+def _require_artifacts_in_path(paths, allowed_paths):
+    """TODO."""
+    #print("require_artifacts_in_path(", __words(paths), ",", __words(allowed_paths), ")")
+    pass
+
+
+def _require_artifacts_in_path_relaxed(paths, allowed_paths):
+    """TODO."""
+    pass
+
+
+def _expand_wildcard(pattern):
+    """Expands shell wildcard pattern."""
+    return rblf_wildcard(pattern)
+
+
+def _mkerror(file, message=""):
+    """Prints error and stops."""
+    fail("%s: %s. Stop" % (file, message))
+
+
+def _mkwarning(file, message=""):
+    """Prints warning."""
+    print("%s: warning: %s" % (file, message))
+
+
+def _mkinfo(file, message=""):
+    """Prints info."""
+    print(message)
+
+
+def __get_options():
+    """Returns struct containing runtime global settings."""
+    settings = dict(
+        format = "pretty",
+        print_globals = False,
+        rearrange = "",
+        trace_modules = False,
+        trace_variables = [],
+    )
+    for x in getattr(rblf_cli, "RBC_OUT", "").split(","):
+        if x == "sort" or x == "unique":
+            if settings["rearrange"]:
+                fail("RBC_OUT: either sort or unique is allowed (and sort implies unique)")
+            settings["rearrange"] = x
+        elif x == "pretty" or x == "make":
+            settings["format"] = x
+        elif x == "global":
+            settings["print_globals"] = True
+        elif x != "":
+            fail("RBC_OUT: got %s, should be one of: [pretty|make] [sort|unique]" % x)
+    for x in getattr(rblf_cli, "RBC_DEBUG", "").split(","):
+        if x == "!trace":
+            settings["trace_modules"] = True
+        elif x != "":
+            settings["trace_variables"].append(x)
+    return struct(**settings)
+
+# Settings used during debugging.
+_options = __get_options()
+rblf = struct(addprefix=_addprefix,
+              addsuffix=_addsuffix,
+              copy_if_exists=_copy_if_exists,
+              cfg=__h_cfg,
+              enforce_product_packages_exist=_enforce_product_packages_exist,
+              expand_wildcard=_expand_wildcard,
+              file_exists=rblf_file_exists,
+              file_wildcard_exists=_file_wildcard_exists,
+              filter=_filter,
+              filter_out=_filter_out,
+              find_and_copy=_find_and_copy,
+              global_init=_global_init,
+              inherit=_inherit,
+              indirect=_indirect,
+              mkinfo=_mkinfo,
+              mkerror=_mkerror,
+              mkwarning=_mkwarning,
+              printvars=_printvars,
+              product_configuration=_product_configuration,
+              require_artifacts_in_path=_require_artifacts_in_path,
+              require_artifacts_in_path_relaxed=_require_artifacts_in_path_relaxed,
+              setdefault=_setdefault,
+              shell=rblf_shell,
+              warning=_mkwarning,
+              )
+

tests/device.rbc

@@ -0,0 +1,42 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Top-level test configuration.
+# Converted from the following makefile
+### PRODUCT_PACKAGES += dev
+### PRODUCT_HOST_PACKAGES += host
+### $(call inherit-product, $(LOCAL_PATH)/part1.mk)
+### PRODUCT_COPY_FILES += device_from:device_to
+### include $(LOCAL_PATH)/include1.mk
+### PRODUCT_PACKAGES += dev_after
+### PRODUCT_COPY_FILES += $(call find-copy-subdir-files,audio_platform_info*.xml,device/google/redfin/audio,$(TARGET_COPY_OUT_VENDOR)/etc) xyz
+
+load("//build/make/core:product_config.rbc", "rblf")
+load(":part1.rbc", _part1_init = "init")
+load(":include1.rbc", _include1_init = "init")
+
+def init(g, handle):
+  cfg = rblf.cfg(handle)
+  rblf.setdefault(handle, "PRODUCT_PACKAGES")
+  cfg["PRODUCT_PACKAGES"] += ["dev"]
+  rblf.setdefault(handle, "PRODUCT_HOST_PACKAGES")
+  cfg["PRODUCT_HOST_PACKAGES"] += ["host"]
+  rblf.inherit(handle, "test/part1", _part1_init)
+  rblf.setdefault(handle, "PRODUCT_COPY_FILES")
+  cfg["PRODUCT_COPY_FILES"] += ["device_from:device_to"]
+  _include1_init(g, handle)
+  cfg["PRODUCT_PACKAGES"] += ["dev_after"]
+  cfg["PRODUCT_COPY_FILES"] += (rblf.find_and_copy("audio_platform_info*.xml", "device/google/redfin/audio", "||VENDOR-PATH-PH||/etc") +
+      ["xyz"])

tests/include1.rbc

@@ -0,0 +1,25 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Included file (not inherited)
+# Converted from makefile
+### PRODUCT_PACKAGES += inc
+
+load("//build/make/core:product_config.rbc", "rblf")
+
+def init(g, handle):
+  cfg = rblf.cfg(handle)
+  rblf.setdefault(handle, "PRODUCT_PACKAGES")
+  cfg["PRODUCT_PACKAGES"] += ["inc"]

tests/part1.rbc

@@ -0,0 +1,28 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Part configuration
+# Converted from
+### PRODUCT_COPY_FILES += part_from:part_to
+### PRODUCT_PRODUCT_PROPERTIES += part_properties
+
+load("//build/make/core:product_config.rbc", "rblf")
+
+def init(g, handle):
+  cfg = rblf.cfg(handle)
+  rblf.setdefault(handle, "PRODUCT_COPY_FILES")
+  cfg["PRODUCT_COPY_FILES"] += ["part_from:part_to"]
+  rblf.setdefault(handle, "PRODUCT_PRODUCT_PROPERTIES")
+  cfg["PRODUCT_PRODUCT_PROPERTIES"] += ["part_properties"]

tests/run.rbc

@@ -0,0 +1,50 @@
+
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# Run test configuration and verify its result.
+# The main configuration file is device.rbc.
+# It inherits part1.rbc and also includes include1.rbc
+# TODO(asmundak): more tests are needed to verify that:
+#  * multi-level inheritance works as expected
+#  * all runtime functions (wildcard, regex, etc.) work
+
+load("//build/make/core:product_config.rbc", "rblf")
+load(":device.rbc", "init")
+
+def assert_eq(expected, actual):
+    if expected != actual:
+        fail("Expected %s, got %s" % (expected, actual))
+
+
+globals, config = rblf.product_configuration("test/device", init)
+assert_eq(
+    {
+      "PRODUCT_COPY_FILES": [
+          "part_from:part_to",
+          "device_from:device_to",
+          "device/google/redfin/audio/audio_platform_info_noextcodec_snd.xml:||VENDOR-PATH-PH||/etc/audio_platform_info_noextcodec_snd.xml",
+          "xyz"
+      ],
+      "PRODUCT_HOST_PACKAGES": ["host"],
+      "PRODUCT_PACKAGES": [
+          "dev",
+          "inc",
+          "dev_after"
+      ],
+      "PRODUCT_PRODUCT_PROPERTIES": ["part_properties"]
+    },
+    { k:v for k, v in sorted(config.items()) }
+)