| # |
| # Copyright OpenEmbedded Contributors |
| # |
| # SPDX-License-Identifier: GPL-2.0-only |
| # |
| |
| import collections |
| import bb.filter |
| |
| @bb.filter.filter_proc() |
| def native_filter(val, pn, bpn, regex=False, selfref=True): |
| deps = val |
| if not deps: |
| return |
| deps = bb.utils.explode_deps(deps) |
| newdeps = [] |
| for dep in deps: |
| if regex and dep.startswith("^") and dep.endswith("$"): |
| if not dep.endswith("-native$"): |
| newdeps.append(dep[:-1].replace(pn, bpn) + "-native$") |
| else: |
| newdeps.append(dep) |
| elif dep == pn: |
| if not selfref: |
| continue |
| newdeps.append(dep) |
| elif "-cross-" in dep: |
| newdeps.append(dep.replace("-cross", "-native")) |
| elif not dep.endswith("-native"): |
| # Replace ${PN} with ${BPN} in the dependency to make sure |
| # dependencies on, e.g., ${PN}-foo become ${BPN}-foo-native |
| # rather than ${BPN}-native-foo-native. |
| newdeps.append(dep.replace(pn, bpn) + "-native") |
| else: |
| newdeps.append(dep) |
| return " ".join(newdeps) |
| |
| def add_suffix(val, extname, prefixes): |
| if val.startswith(extname + "-"): |
| return val |
| if val.endswith(("-native", "-native-runtime")) or ('nativesdk-' in val) or ('-cross-' in val) or ('-crosssdk-' in val): |
| return val |
| # If it starts with a known prefix (e.g. multilibs), just pass it through |
| for prefix in prefixes: |
| if val.startswith(prefix + "-"): |
| return val |
| if val.startswith("kernel-") or val == "virtual/kernel": |
| return val |
| if val.startswith("rtld"): |
| return val |
| if val.endswith("-crosssdk"): |
| return val |
| if val.endswith("-" + extname): |
| val = val.replace("-" + extname, "") |
| if val.startswith("virtual/"): |
| # Assume large numbers of dashes means a triplet is present and we don't need to convert |
| if val.count("-") >= 3 and val.endswith(("-go",)): |
| return val |
| subs = val.split("/", 1)[1] |
| if not subs.startswith(extname): |
| return "virtual/" + extname + "-" + subs |
| return val |
| if val.startswith("/") or (val.startswith("${") and val.endswith("}")): |
| return val |
| if not val.startswith(extname): |
| return extname + "-" + val |
| return val |
| |
| def get_package_mappings(packages, extname): |
| pkgs_mapping = [] |
| for pkg in packages.split(): |
| if pkg.startswith(extname): |
| pkgs_mapping.append([pkg.split(extname + "-")[1], pkg]) |
| continue |
| pkgs_mapping.append([pkg, add_suffix(pkg, extname, [])]) |
| return pkgs_mapping |
| |
| @bb.filter.filter_proc() |
| def package_suffix_filter(val, extname): |
| pkgs_mapping = get_package_mappings(val, extname) |
| return " ".join([row[1] for row in pkgs_mapping]) |
| |
| @bb.filter.filter_proc() |
| def suffix_filter(val, extname, prefixes): |
| newdeps = [] |
| for dep in val.split(): |
| newdeps.append(add_suffix(dep, extname, prefixes)) |
| return " ".join(newdeps) |
| |
| @bb.filter.filter_proc() |
| def suffix_filter_regex(val, extname, prefixes): |
| newvar = [] |
| for v in val.split(): |
| if v.startswith("^" + extname): |
| newvar.append(v) |
| elif v.startswith("^"): |
| newvar.append("^" + extname + "-" + v[1:]) |
| else: |
| newvar.append(add_suffix(v, extname, prefixes)) |
| return " ".join(newvar) |
| |
| @bb.filter.filter_proc() |
| def suffix_filter_deps(val, extname, prefixes): |
| deps = bb.utils.explode_dep_versions2(val) |
| newdeps = collections.OrderedDict() |
| for dep in deps: |
| newdeps[add_suffix(dep, extname, prefixes)] = deps[dep] |
| return bb.utils.join_deps(newdeps, False) |
| |
| class ClassExtender(object): |
| def __init__(self, extname, prefixes, d): |
| self.extname = extname |
| self.d = d |
| self.prefixes = prefixes |
| |
| def set_filter(self, var, deps): |
| if deps: |
| self.d.setVarFilter(var, "suffix_filter_deps(val, '" + self.extname + "', " + str(self.prefixes) + ")") |
| else: |
| self.d.setVarFilter(var, "suffix_filter(val, '" + self.extname + "', " + str(self.prefixes) + ")") |
| |
| def map_packagevars(self): |
| self.set_filter("RDEPENDS", deps=True) |
| self.set_filter("RRECOMMENDS", deps=True) |
| self.set_filter("RSUGGESTS", deps=True) |
| self.set_filter("RPROVIDES", deps=True) |
| self.set_filter("RREPLACES", deps=True) |
| self.set_filter("RCONFLICTS", deps=True) |
| self.set_filter("PKG", deps=True) |
| |
| def rename_package_variables(self, variables): |
| pkgs_mapping = get_package_mappings(self.d.getVar('PACKAGES'), self.extname) |
| self.d.setVarFilter('PACKAGES', "package_suffix_filter(val, '" + self.extname + "')") |
| self.d.setVarFilter('PACKAGES_DYNAMIC', "suffix_filter_regex(val, '" + self.extname + "', " + str(self.prefixes) + ")") |
| |
| for pkg_mapping in pkgs_mapping: |
| if pkg_mapping[0].startswith("${") and pkg_mapping[0].endswith("}"): |
| continue |
| for subs in variables: |
| self.d.renameVar("%s:%s" % (subs, pkg_mapping[0]), "%s:%s" % (subs, pkg_mapping[1])) |
