jolt 0.9.419__py3-none-any.whl → 0.9.430__py3-none-any.whl

jolt/plugins/ninja.py

@@ -4,6 +4,7 @@ import copy
 import functools
 from ninja import ninja_syntax as ninja
 import os
+import platform
 import re
 import sys
 
@@ -21,6 +22,12 @@ from jolt.error import raise_task_error_if
 from jolt.error import JoltError, JoltCommandError
 
 
+c_standard_default = 17
+cxx_standard_default = 17
+c_standards_list = [90, 99, 11, 17, 23]
+cxx_standards_list = [98, 11, 14, 17, 20, 23, 26]
+
+
 class CompileError(JoltError):
     def __init__(self, error):
         if error:
@@ -751,6 +758,54 @@ class ProjectVariable(Variable):
         return "PV: default={},attrib={}".format(self._default, self._attrib)
 
 
+class StdVariable(Variable):
+    def __init__(self, lang, flagfmt, values, supported=None, default=None):
+        self._lang = lang
+        self._flagfmt = flagfmt
+        self._values = values
+        self._supported = supported or values
+        self._default = default
+
+    def create(self, project, writer, deps, tools):
+        value = getattr(project, self.name, self._default) or self._default
+        if not value:
+            return
+        raise_task_error_if(
+            type(value) is not int,
+            project,
+            f"Illegal {self._lang} language standard: '{value}'. Expected integer."
+        )
+        raise_task_error_if(
+            value not in self._values,
+            project,
+            f"Illegal {self._lang} language standard: '{value}'. Expected one of: {', '.join([str(v) for v in self._values])}"
+        )
+
+        if value not in self._supported:
+            new_value = min(self._supported, key=lambda n: abs(n - value))
+            project.warning(f"{self._lang}{value} is not supported. Using {self._lang}{new_value} instead.")
+            value = new_value
+
+        writer.variable(self.name, self._flagfmt.format(value))
+
+
+class OptimizationVariable(Variable):
+    def __init__(self, default, values, name=None):
+        self.name = name
+        self._default = default
+        self._values = values
+        assert type(values) is dict, "Optimization values must be dict with compiler flag mapping"
+
+    def create(self, project, writer, deps, tools):
+        value = str(getattr(project, "optimize", self._default))
+        raise_task_error_if(
+            value not in self._values,
+            project,
+            f"Illegal value assigned to 'optimize' ({value}). Expected: 'none', 'debug', 'size', or 'release'."
+        )
+        writer.variable(self.name, self._values[value])
+
+
 class SharedLibraryVariable(Variable):
     def __init__(self, name=None, default=None):
         self.name = name
@@ -1153,7 +1208,8 @@ class Skip(Rule):
 
 @task_attributes.system
 class MakeDirectory(Rule):
-    command_linux = "mkdir -p $out"
+    command_darwin = "mkdir -p $out"
+    command_linux = command_darwin
     command_windows = "if not exist $out mkdir $out"
 
     def __init__(self, name):
@@ -1539,7 +1595,17 @@ class GNUToolchain(Toolchain):
     cxxwrap = EnvironmentVariable(default="")
     flatc = ToolEnvironmentVariable(default="flatc", envname="FLATC", abspath=True)
     protoc = ToolEnvironmentVariable(default="protoc", envname="PROTOC", abspath=True)
-
+    strip = ToolEnvironmentVariable(default="strip", envname="STRIP", abspath=True)
+
+    cstd = StdVariable("C", "-std=c{}", values=c_standards_list, default=c_standard_default)
+    cxxstd = StdVariable("C++", "-std=c++{}", values=cxx_standards_list, default=cxx_standard_default)
+    optflag = OptimizationVariable(default="release", values={
+        "none": "-O0",
+        "debug": "-Og",
+        "size": "-Os",
+        "release": "-O2",
+        None: "-O0",
+    })
     asflags = EnvironmentVariable(default="")
     cflags = EnvironmentVariable(default="")
     cxxflags = EnvironmentVariable(default="")
@@ -1570,7 +1636,7 @@ class GNUToolchain(Toolchain):
     mkdir_debug = MakeDirectory(name="$outdir_rel/.debug")
 
     compile_pch = GNUCompiler(
-        command="$cxxwrap $cxx -x c++-header $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$cxxwrap $cxx -x c++-header $cxxstd $optflag $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[GNUPCHVariables.pch_ext],
@@ -1579,7 +1645,7 @@ class GNUToolchain(Toolchain):
         variables={"desc": "[PCH] {in_base}{in_ext}"})
 
     compile_c = GNUCompiler(
-        command="$ccwrap $cc -x c $pch_flags $cflags $shared_flags $imported_cflags $extra_cflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$ccwrap $cc -x c $cstd $pch_flags $optflag $cflags $shared_flags $imported_cflags $extra_cflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[".c"],
@@ -1589,7 +1655,7 @@ class GNUToolchain(Toolchain):
         implicit=["$cc_path"])
 
     compile_cxx = GNUCompiler(
-        command="$cxxwrap $cxx -x c++ $pch_flags $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
+        command="$cxxwrap $cxx -x c++ $cxxstd $pch_flags $optflag $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $covflags $macros $incpaths -MMD -MF $out.d -c $in -o $out",
         deps="gcc",
         depfile="$out.d",
         infiles=[".cc", ".cpp", ".cxx"],
@@ -1658,6 +1724,55 @@ class GNUToolchain(Toolchain):
         suffix=".a")
 
 
+class BSDArchiver(Rule):
+    def __init__(self, *args, **kwargs):
+        super(BSDArchiver, self).__init__(*args, aggregate=True, **kwargs)
+
+    def build(self, project, writer, infiles, implicit=None, order_only=None):
+        writer._objects = infiles
+        project._binaries, _ = self._out(project, project.binary)
+        file_list = FileListWriter("objects", project._binaries)
+        file_list.build(project, writer, infiles)
+        super().build(project, writer, infiles, implicit=writer.depimports, order_only=order_only)
+
+    def get_influence(self, task):
+        return "BSDArchiver" + super().get_influence(task)
+
+
+class DarwinGNUToolchain(GNUToolchain):
+    libtool = ToolEnvironmentVariable(default="libtool", envname="LIBTOOL", abspath=True)
+    dsymutil = ToolEnvironmentVariable(default="dsymutil", envname="DSYMUTIL", abspath=True)
+
+    linker = GNULinker(
+        command=" && ".join([
+            "$ld $ldflags $imported_ldflags $extra_ldflags $covflags $libpaths @$outdir_rel/objects.list -o $out $libraries",
+            "$dsymutil $out -o $outdir_rel/.debug/$binary.dSYM",
+            "$strip $out",
+        ]),
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/{binary}"],
+        variables={"desc": "[LINK] {binary}"},
+        implicit=["$ld_path", "$dsymutil_path", "$strip_path", "$outdir_rel/.debug"])
+
+    dynlinker = GNULinker(
+        command=" && ".join([
+            "$ld $ldflags -shared $imported_ldflags $extra_ldflags $covflags $libpaths @$outdir_rel/objects.list -o $out $libraries",
+            "$dsymutil $out -o $outdir_rel/.debug/$binary.dSYM",
+            "$strip $out",
+        ]),
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/lib{binary}.so"],
+        variables={"desc": "[LINK] {binary}"},
+        implicit=["$ld_path", "$dsymutil_path", "$strip_path", "$outdir_rel/.debug"])
+
+    archiver = BSDArchiver(
+        command="$libtool -static -o $out @$outdir_rel/objects.list && $ranlib $out",
+        infiles=[".o", ".obj", ".a"],
+        outfiles=["{outdir}/lib{binary}.a"],
+        variables={"desc": "[AR] lib{binary}.a"},
+        implicit=["$libtool_path", "$ranlib_path"])
+
+
 class MinGWToolchain(GNUToolchain):
     linker = GNULinker(
         command=" && ".join([
@@ -1686,6 +1801,62 @@ class MSVCArchiver(Rule):
         return "MSVCArchiver" + super().get_influence(task)
 
 
+class MSVCCRT(Variable):
+    def __init__(self, default="/MD", flagsfn=None):
+        self.default = default
+        self.flagsfn = flagsfn
+
+    def _combine(self, project, crt1, crt2):
+        if crt1 is None:
+            return crt2
+        if crt2 is None:
+            return crt1
+        raise_task_error_if(crt1 != crt2, project, "Mismatching Windows CRT library types (/MT vs /MD)")
+        return crt1
+
+    def _select_flag(self, flags):
+        """ Look for /Mxx flag in the list of flags """
+        if flags is None:
+            return None
+        if "Static" in flags:
+            return "/MT"
+        if "StaticDebug" in flags:
+            return "/MTd"
+        if "Dynamic" in flags:
+            return "/MD"
+        if "DynamicDebug" in flags:
+            return "/MDd"
+        if "/MT" in flags:
+            return "/MT"
+        if "/MTd" in flags:
+            return "/MTd"
+        if "/MD" in flags:
+            return "/MD"
+        if "/MDd" in flags:
+            return "/MDd"
+        return None
+
+    def _select_dep_flags(self, project, dep):
+        crt = self._select_flag(dep.cxxinfo.asflags.items())
+        if hasattr(dep.cxxinfo, "crt"):
+            crt = self._combine(project, crt, self._select_flag([str(dep.cxxinfo.crt)]))
+        crt = self._combine(project, crt, self._select_flag(dep.cxxinfo.cflags.items()))
+        return self._combine(project, crt, self._select_flag(dep.cxxinfo.cxxflags.items()))
+
+    def create(self, project, writer, deps, tools):
+        crt = self._select_flag(getattr(project, "crt", None))
+        crt = self._combine(project, crt, self._select_flag(project._asflags()))
+        crt = self._combine(project, crt, self._select_flag(project._cflags()))
+        crt = self._combine(project, crt, self._select_flag(project._cxxflags()))
+        for _, artifact in deps.items():
+            crt = self._combine(project, crt, self._select_dep_flags(project, artifact))
+        writer.variable(self.name, crt or self.default)
+
+    @utils.cached.instance
+    def get_influence(self, task):
+        return "CRT"
+
+
 MSVCCompiler = GNUCompiler
 MSVCLinker = GNULinker
 MSVCDepImporter = GNUDepImporter
@@ -1695,9 +1866,10 @@ class MSVCToolchain(Toolchain):
     hh = Skip(infiles=[".h", ".hh", ".hpp", ".hxx"])
     bin = Skip(infiles=[".dll", ".exe"])
 
-    builddir = ProjectVariable(attrib="outdir")
     joltdir = ProjectVariable()
+    builddir = ProjectVariable(attrib="outdir")
     outdir = ProjectVariable()
+    outdir_rel = ProjectVariable()
     binary = ProjectVariable()
 
     cl = ToolEnvironmentVariable(default="cl", envname="cl_exe", abspath=True)
@@ -1706,13 +1878,25 @@ class MSVCToolchain(Toolchain):
     flatc = ToolEnvironmentVariable(default="flatc", envname="FLATC", abspath=True)
     protoc = ToolEnvironmentVariable(default="protoc", envname="PROTOC", abspath=True)
 
+    cstd = StdVariable("C", "/std:c{}", values=c_standards_list, supported=[11, 17], default=c_standard_default)
+    cxxstd = StdVariable("C++", "/std:c++{}", values=cxx_standards_list, supported=[14, 17, 20], default=cxx_standard_default)
+    optflag = OptimizationVariable(default="speed", values={
+        "none": "/Od",
+        "debug": "/Od /Zi",
+        "size": "/O1",
+        "release": "/O2 /DNDEBUG",
+        None: "/0d",
+    })
+    win32flags = Variable("/DWIN32 /D_WINDOWS /D_WIN32_WINNT=0x0601 /EHsc")
     asflags = EnvironmentVariable(default="")
-    cflags = EnvironmentVariable(default="/EHsc")
-    cxxflags = EnvironmentVariable(default="/EHsc")
+    cflags = EnvironmentVariable(default="")
+    cxxflags = EnvironmentVariable(default="")
     fbflags = EnvironmentVariable(default="")
     ldflags = EnvironmentVariable(default="")
     protoflags = EnvironmentVariable(default="")
 
+    crt = MSVCCRT()
+
     extra_asflags = ProjectVariable(attrib="asflags")
     extra_cflags = ProjectVariable(attrib="cflags")
     extra_cxxflags = ProjectVariable(attrib="cxxflags")
@@ -1727,26 +1911,26 @@ class MSVCToolchain(Toolchain):
     libraries = Libraries(suffix=".lib")
 
     compile_asm = MSVCCompiler(
-        command="$cl /nologo /showIncludes $asflags $extra_asflags $macros $incpaths /c /Tc$in /Fo$out",
+        command="$cl /nologo /showIncludes $crt $win32flags $asflags $extra_asflags $macros $incpaths /c /Tc$in /Fo$out",
         deps="msvc",
         infiles=[".asm", ".s", ".S"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[ASM] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
     compile_c = MSVCCompiler(
-        command="$cl /nologo /showIncludes $cxxflags $extra_cxxflags $macros $incpaths /c /Tc$in /Fo$out",
+        command="$cl /nologo /showIncludes $cstd $crt $win32flags $optflag $cflags $extra_cflags $macros $incpaths /c /Tc$in /Fo$out",
         deps="msvc",
         infiles=[".c"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[C] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
     compile_cxx = MSVCCompiler(
-        command="$cl /nologo /showIncludes $cxxflags $extra_cxxflags $macros $incpaths /c /Tp$in /Fo$out",
+        command="$cl /nologo /showIncludes $cxxstd $crt $win32flags $optflag $cxxflags $extra_cxxflags $macros $incpaths /c /Tp$in /Fo$out",
         deps="msvc",
         infiles=[".cc", ".cpp", ".cxx"],
-        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}.obj"],
+        outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.obj"],
         variables={"desc": "[CXX] {in_base}{in_ext}"},
         implicit=["$cl_path"])
 
@@ -1774,11 +1958,15 @@ class MSVCToolchain(Toolchain):
 
 _toolchains = {
     GNUToolchain: GNUToolchain(),
+    DarwinGNUToolchain: DarwinGNUToolchain(),
     MSVCToolchain: MSVCToolchain(),
 }
 
-if os.name == "nt":
+_system = platform.system()
+if _system == "Windows":
     toolchain = _toolchains[MSVCToolchain]
+elif _system == "Darwin":
+    toolchain = _toolchains[DarwinGNUToolchain]
 else:
     toolchain = _toolchains[GNUToolchain]
 
@@ -1818,9 +2006,23 @@ class CXXProject(Task):
     cflags = []
     """ A list of compiler flags used when compiling C files. """
 
+    cstd = None
+    """
+    C language standard to use (int). Default: 17
+
+    If the chosen standard is not supported, the nearest supported standard is selected.
+    """
+
     cxxflags = []
     """ A list of compiler flags used when compiling C++ files. """
 
+    cxxstd = None
+    """
+    C++ language standard to use (int). Default: 17
+
+    If the chosen standard is not supported, the nearest supported standard is selected.
+    """
+
     depimports = []
     """ List of implicit dependencies """
 
@@ -1839,6 +2041,18 @@ class CXXProject(Task):
     macros = []
     """ List of preprocessor macros to set """
 
+    optimize = "release"
+    """
+    Compiler optimization level.
+
+    Supported values are:
+
+        - "none" / None
+        - "debug"
+        - "size"
+        - "release"
+    """
+
     sources = []
     """ A list of sources to compile.
 
@@ -2266,7 +2480,10 @@ if __name__ == "__main__":
         except JoltCommandError as e:
             self.buildlog = "\n".join(e.stdout)
             report = self._report_errors(self.buildlog)
-            raise CompileError(self._first_reported_error(report))
+            error = self._first_reported_error(report)
+            if error:
+                raise CompileError(error)
+            raise e
 
         if bool(getattr(self, "coverage", False)):
             self.covdatadir = tools.builddir("coverage-data")
@@ -2351,13 +2568,15 @@ if __name__ == "__main__":
             # LLVM linker errors
             report.add_regex_errors(
                 "Linker Error",
-                r"^(?P<location>ld(\.lld)?): (error|warning): (?P<message>.*)",
+                r"^(?P<location>(.*?)ld(\.lld)?): (error|warning): (?P<message>.*)",
                 logbuffer)
 
             return report
 
     def _first_reported_error(self, report):
         """ Returns the first reported error or None if no errors were reported. """
+        if report is None:
+            return None
         for error in report.errors:
             return error
 

jolt/plugins/pkgconfig.py

@@ -0,0 +1,219 @@
+from jolt import attributes
+from jolt import filesystem as fs
+from jolt import log
+from jolt import utils
+from jolt.error import raise_error_if
+
+
+class PkgConfigHelper(object):
+
+    TEMPLATE_PKGCONFIG = """
+prefix={{ artifact.final_path }}
+
+Name: {{ pkgname }}
+Description: {{ pkgname }} package
+Version: {{ artifact.identity }}
+
+Cflags: {% for flag in cxxflags %}{{ flag }} {% endfor %}{% for inc in incpaths %}-I${prefix}/{{ inc }} {% endfor %}{% for macro in macros %}-D{{ macro }} {% endfor %}
+
+Libs: {% for flag in ldflags %}{{ flag }} {% endfor %}{% for libpath in libpaths %}-L${prefix}/{{ libpath }} {% endfor %}{% for library in libraries %}-l{{ library }} {% endfor %}
+
+"""
+
+    def __init__(self, artifact, tools):
+        self.artifact = artifact
+        self.tools = tools
+
+    def _mkpath(self, path):
+        if fs.path.commonpath([path, self.artifact.path]) != self.artifact.path:
+            return path
+        return fs.path.relpath(path, self.artifact.path)
+
+    def cflags(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --cflags-only-other {}", self.pkgconfig, package, output=False)
+                return output.strip().split()
+        except Exception as e:
+            log.debug("PkgConfig.cflags: {}", str(e))
+            return []
+
+    def incpaths(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --cflags-only-I {}", self.pkgconfig, package, output=False)
+                return [self._mkpath(inc[2:]) for inc in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.incpaths: {}", str(e))
+            return []
+
+    def linkflags(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-other {}", self.pkgconfig, package, output=False)
+                return output.strip().split()
+        except Exception as e:
+            log.debug("PkgConfig.linkflags: {}", str(e))
+            return []
+
+    def libpaths(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-L {}", self.pkgconfig, package, output=False)
+                return [self._mkpath(lib[2:]) for lib in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.libpaths: {}", str(e))
+            return []
+
+    def libraries(self, package):
+        package = " ".join(utils.as_list(package))
+        try:
+            with self.tools.environ(**self.environ):
+                output = self.tools.run("{} --maximum-traverse-depth=1 --libs-only-l {}", self.pkgconfig, package, output=False)
+                return [lib[2:] for lib in output.strip().split()]
+        except Exception as e:
+            log.debug("PkgConfig.libraries: {}", str(e))
+            return []
+
+    def write_pc(self, package):
+        with self.tools.tmpdir() as tmpdir, self.tools.cwd(tmpdir):
+            content = self.tools.render(
+                self.TEMPLATE_PKGCONFIG,
+                artifact=self.artifact,
+                pkgname=package,
+                macros=list(self.artifact.cxxinfo.macros),
+                incpaths=list(self.artifact.cxxinfo.incpaths),
+                libpaths=list(self.artifact.cxxinfo.libpaths),
+                libraries=list(self.artifact.cxxinfo.libraries),
+            )
+            print(content)
+            self.tools.write_file(f"{package}.pc", content, expand=False)
+            self.artifact.collect(f"{package}.pc", "lib/pkgconfig/")
+
+    @property
+    def pkgconfig(self):
+        pkgconf = self.tools.which(self.tools.getenv("PKG_CONFIG", "pkg-config"))
+        raise_error_if(not pkgconf, "No pkg-config tool found in PATH")
+        return pkgconf
+
+    @property
+    def environ(self):
+        path = self.artifact.environ.get("PKG_CONFIG_PATH")
+        if path is None:
+            self.tools._task.verbose("No PKG_CONFIG_PATH in artifact environment")
+
+        # Path from the artifact environment
+        path = str(path).split(fs.pathsep)
+        path = fs.pathsep.join(fs.path.join(self.artifact.path, p) for p in path)
+
+        # Append existing PKG_CONFIG_PATH from the tools environment
+        if self.tools.getenv("PKG_CONFIG_PATH"):
+            path = path + fs.pathsep + self.tools.getenv("PKG_CONFIG_PATH")
+
+        return {"PKG_CONFIG_PATH": path}
+
+
+def to_cxxinfo(
+    pkg: list | str,
+    cflags: bool = True,
+    cxxflags: bool = True,
+    incpaths: bool = True,
+    ldflags: bool = True,
+    libpaths: bool = True,
+    libraries: bool = True,
+):
+    """
+    Decorator to add pkg-config information to cxxinfo metadata of an artifact.
+
+    The decorator enables interoperability between libraries built with Jolt's
+    Ninja plugin and external packages that provide pkg-config files.
+
+    It uses the pkg-config tool to query for compiler and linker flags,
+    include paths, library paths, and libraries associated with a given package.
+    If the relevant flags are found, they are appended to the corresponding fields
+    in the artifact's cxxinfo metadata.
+
+    Args:
+        pkg (str): The name of the pkg-config package to be added to cxxinfo.
+        cflags (bool): Whether to add C compiler flags from pkg-config.
+        cxxflags (bool): Whether to add C++ compiler flags from pkg-config.
+        incpaths (bool): Whether to add include paths from pkg-config.
+        ldflags (bool): Whether to add linker flags from pkg-config.
+        libpaths (bool): Whether to add library paths from pkg-config.
+        libraries (bool): Whether to add libraries from pkg-config.
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            if not pc.environ:
+                self.verbose("Skipping pkg-config cxxinfo addition due to missing PKG_CONFIG_PATH.")
+                return
+
+            if cflags:
+                artifact.cxxinfo.cflags.extend(pc.cflags(pkg))
+            if cxxflags:
+                artifact.cxxinfo.cxxflags.extend(pc.cflags(pkg))
+            if incpaths:
+                artifact.cxxinfo.incpaths.extend(pc.incpaths(pkg))
+            if ldflags:
+                artifact.cxxinfo.ldflags.extend(pc.linkflags(pkg))
+            if libpaths:
+                artifact.cxxinfo.libpaths.extend(pc.libpaths(pkg))
+            if libraries:
+                artifact.cxxinfo.libraries.extend(pc.libraries(pkg))
+
+        cls.publish = publish
+        return cls
+
+    return decorate
+
+
+def from_cxxinfo(package):
+    """
+    Decorator to write a pkg-config file for the given package
+    based on the cxxinfo metadata of the artifact.
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+        original_unpack = cls.unpack
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            pc.write_pc(package)
+
+        def unpack(self, artifact, tools):
+            original_unpack(self, artifact, tools)
+
+            pc = PkgConfigHelper(artifact, tools)
+            pc.write_pc(package)
+
+        cls.publish = publish
+        cls.unpack = unpack
+        return cls
+
+    return decorate
+
+
+def requires():
+    """ Decorator to add pkg-config requirements to a task. """
+
+    import jolt.pkgs.pkgconfig
+
+    def decorate(cls):
+        cls = attributes.requires("requires_pkgconf")(cls)
+        cls.requires_pkgconf = ["pkgconf"]
+        return cls
+
+    return decorate