Product configuration in Starlark support files.
Bug: 170637441
Test: rbcrun build/make/tests/run.rbc
Change-Id: Ie8f0c3dea66a287f2b0a3b588c446bfbb2c9a978
diff --git a/core/build_id.rbc b/core/build_id.rbc
new file mode 100644
index 0000000..4f33833
--- /dev/null
+++ b/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"
\ No newline at end of file
diff --git a/core/envsetup.rbc b/core/envsetup.rbc
new file mode 100644
index 0000000..2924ee1
--- /dev/null
+++ b/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"
diff --git a/core/product_config.rbc b/core/product_config.rbc
new file mode 100644
index 0000000..6e96822
--- /dev/null
+++ b/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,
+ )
+
diff --git a/tests/device.rbc b/tests/device.rbc
new file mode 100644
index 0000000..5d4e70c
--- /dev/null
+++ b/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"])
diff --git a/tests/include1.rbc b/tests/include1.rbc
new file mode 100644
index 0000000..c0c9b3b
--- /dev/null
+++ b/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"]
diff --git a/tests/part1.rbc b/tests/part1.rbc
new file mode 100644
index 0000000..3e50751
--- /dev/null
+++ b/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"]
diff --git a/tests/run.rbc b/tests/run.rbc
new file mode 100644
index 0000000..b13f835
--- /dev/null
+++ b/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()) }
+)