jolt 0.9.76__py3-none-any.whl → 0.9.429__py3-none-any.whl

jolt/plugins/ninja.py

@@ -1,6 +1,11 @@
+from collections import OrderedDict
+import contextlib
 import copy
-import ninja_syntax as ninja
+import functools
+from ninja import ninja_syntax as ninja
 import os
+import platform
+import re
 import sys
 
 from jolt.tasks import Task, attributes as task_attributes
@@ -8,16 +13,27 @@ from jolt import config
 from jolt.influence import attribute as influence_attribute
 from jolt.influence import DirectoryInfluence, FileInfluence
 from jolt.influence import HashInfluenceProvider, TaskAttributeInfluence
+from jolt.config import get_cachedir
 from jolt import log
 from jolt import utils
 from jolt import filesystem as fs
+from jolt.error import raise_task_error
 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):
-        super().__init__("Compilation failed")
+    def __init__(self, error):
+        if error:
+            super().__init__(f"{error.type}: {error.location}: {error.message}")
+        else:
+            super().__init__("Compilation failed")
 
 
 class attributes:
@@ -34,6 +50,7 @@ class attributes:
                 Keywords are expanded.
             prepend (boolean): Prepend the value of the alternative
                 attribute. Default: false (append).
+
         """
         return utils.concat_attributes("asflags", attrib, prepend)
 
@@ -50,9 +67,438 @@ class attributes:
                 Keywords are expanded.
             prepend (boolean): Prepend the value of the alternative
                 attribute. Default: false (append).
+
         """
         return utils.concat_attributes("cflags", attrib, prepend)
 
+    @staticmethod
+    def coverage_data(publish=True):
+        """Task decorator collecting coverage data files (.gcda) from instrumented executables.
+
+        The decorator sets the ``GCOV_PREFIX`` environment variable
+        during execution of the task.  Data files generated by
+        instrumented executable are then collected into a dedicated
+        build directory and published upon completion of the task.
+
+        The decorator also republishes coverage note files found in
+        dependency artifacts.
+
+        The task artifact is annotated with
+        ``artifact.paths.coverage_data`` which points out the path to
+        the data files within the artifact.
+
+        Args:
+          publish (boolean): Publish coverage data with artifact.
+              Default: True.
+
+        Example:
+
+          .. literalinclude:: ../examples/code_coverage/coverage.jolt
+            :language: python
+            :caption: examples/code_coverage/coverage.jolt
+
+        """
+
+        def decorate(cls):
+            class CoverageDataMixin(object):
+                @contextlib.contextmanager
+                def run_coverage_data(self, deps, tools):
+                    self.covdatadir = tools.builddir("coverage-data")
+                    self.info("Collecting coverage data into {covdatadir}")
+
+                    for _, artifact in deps.items():
+                        if artifact.paths.coverage_data:
+                            tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
+
+                    with tools.environ(GCOV_PREFIX=self.covdatadir):
+                        yield
+
+                @utils.cached.instance
+                def publish_coverage_data(self, artifact, tools):
+                    if not publish:
+                        return
+
+                    self.verbose("Publishing coverage data from {covdatadir}")
+                    with tools.cwd(self.covdatadir):
+                        if artifact.collect("**/*.gc*", "cov/"):
+                            artifact.paths.coverage_data = "cov"
+
+            class CoverageData(cls, CoverageDataMixin):
+                @functools.wraps(cls.run)
+                def run(self, deps, tools):
+                    with self.run_coverage_data(deps, tools):
+                        super().run(deps, tools)
+
+                def publish_coverage_data(self, artifact, tools):
+                    CoverageDataMixin.publish_coverage_data(self, artifact, tools)
+
+                @functools.wraps(cls.publish)
+                def publish(self, artifact, tools):
+                    super().publish(artifact, tools)
+                    if publish:
+                        self.publish_coverage_data(artifact, tools)
+
+            CoverageData.__doc__ = cls.__doc__
+            CoverageData.__name__ = cls.__name__
+            return CoverageData
+
+        return decorate
+
+    @staticmethod
+    def coverage_report_gcov(branches=True, demangle=True, coverage_data=False):
+        """Decorator generating gcov reports from collected coverage data.
+
+        A gcov report file is generated for each instrumented source
+        file in the executable. The reports consists of plain-text
+        source code annotated with code coverage details.
+
+        The decorator can be used standalone or in combination with
+        :func:`coverage_data`. In either case, coverage data is
+        collected from dependency artifacts and processed together
+        with any data generated by the task itself.
+
+        The following class attributes may be set to control the behavior
+        of lcov:
+
+        - ``gcov_branches`` - Enable branch coverage.
+          Passed as ``-b`` on the command line. Default: ``True``
+        - ``gcov_demangle`` - Display demangled function names in output.
+          Passed as ``-m`` on the command line. Default: ``True``
+
+        The task artifact is annotated with
+        ``artifact.paths.coverage_report_gcov`` which points out the
+        path to the gcov reports within the artifact.
+
+        A gcov executable must exist in PATH. Set the ``GCOV`` environment
+        variable to override its default name.
+
+        Args:
+            branches (boolean): Enable branch coverage. Default: True.
+                Overridden by class attribute ``gcov_branches``, if set.
+            demangle (boolean): Display demangled function names in output. Default: True.
+                Overridden by class attribute ``gcov_demangle``, if set.
+            coverage_data (boolean): Republish coverage data found in
+                dependency artifacts. Default: ``False``
+                Overridden by class attribute ``gcov_coverage_data``, if set.
+
+        Example:
+
+          .. literalinclude:: ../examples/code_coverage/coverage.jolt
+            :language: python
+            :caption: examples/code_coverage/coverage.jolt
+
+        """
+
+        def decorate(cls):
+            class CoverageReportGcovMixin(object):
+                def run_coverage_report_gcov(self, deps, tools):
+                    self.info("Generating GCOV code coverage report")
+
+                    gcov = tools.getenv("GCOV", tools.getenv("CROSS_COMPILE", "") + "gcov")
+                    if not tools.which(gcov):
+                        raise_task_error(self, "gcov not found in PATH, cannot generate coverage report.")
+
+                    # Assume data is already copied by coverage_data() if the covdatadir exists,
+                    # otherwise copy it from dependency artifacts.
+                    if not hasattr(self, "covdatadir"):
+                        self.covdatadir = tools.builddir("coverage-data")
+                        for _, artifact in deps.items():
+                            if artifact.paths.coverage_data:
+                                tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
+
+                    with tools.cwd(self.covdatadir):
+                        datafiles = tools.glob("**/*.gcda")
+
+                    reportdir = tools.builddir("coverage-report-gcov")
+
+                    with tools.cwd(tools.wsroot):
+                        for file in datafiles:
+                            infile = os.path.join(self.covdatadir, file)
+                            branchflag = "-b " if bool(getattr(self, "gcov_branches", branches)) else ""
+                            demangleflag = "-m " if bool(getattr(self, "gcov_demangle", demangle)) else ""
+                            output = tools.run(
+                                "{} {}{}-t -p -s {covdatadir} {}",
+                                gcov, branchflag, demangleflag, infile, output_on_error=True)
+                            output = output.replace(self.covdatadir, "")
+                            source = re.search(r"0:Source:(.*)", output)
+                            if not source:
+                                self.warning(f"No source file found in gcov output for {file}")
+                                continue
+                            report = source.group(1) + ".gcov"
+                            report_path = os.path.join(reportdir, report)
+                            tools.mkdirname(report_path)
+                            tools.write_file(report_path, output, expand=False)
+
+                @utils.cached.instance
+                def publish_coverage_data(self, artifact, tools):
+                    if not bool(getattr(self, "gcov_coverage_data", coverage_data)):
+                        return
+
+                    self.verbose("Publishing coverage data from {covdatadir}")
+                    with tools.cwd(self.covdatadir):
+                        if artifact.collect("**/*.gc*", "cov/"):
+                            artifact.paths.coverage_data = "cov"
+
+                def publish_coverage_report_gcov(self, artifact, tools):
+                    with tools.cwd(tools.builddir("coverage-report-gcov")):
+                        artifact.collect("*", "report/gcov/")
+                        artifact.paths.coverage_report_gcov = "report/gcov"
+
+            class CoverageReportGcov(cls, CoverageReportGcovMixin):
+                @functools.wraps(cls.run)
+                def run(self, deps, tools):
+                    super().run(deps, tools)
+                    self.run_coverage_report_gcov(deps, tools)
+
+                def publish_coverage_data(self, artifact, tools):
+                    CoverageReportGcovMixin.publish_coverage_data(self, artifact, tools)
+
+                @functools.wraps(cls.publish)
+                def publish(self, artifact, tools):
+                    super().publish(artifact, tools)
+                    self.publish_coverage_report_gcov(artifact, tools)
+                    if bool(getattr(self, "gcov_coverage_data", coverage_data)):
+                        self.publish_coverage_data(artifact, tools)
+
+            CoverageReportGcov.__doc__ = cls.__doc__
+            CoverageReportGcov.__name__ = cls.__name__
+            return CoverageReportGcov
+
+        return decorate
+
+    @staticmethod
+    def coverage_report_lcov(branches=True, demangle=True, html=True, coverage_data=False):
+        """Decorator generating HTML reports from collected coverage data.
+
+        A single lcov coverage information file is always generated
+        and published. The corresponding HTML report is optional but
+        enabled by default. Disabling can save time if the coverage
+        information have to be merged with info from other tasks in
+        order for an HTML report to be useful.
+
+        The decorator can be used standalone or in combination with
+        :func:`coverage_data`. In either case, gcov coverage data as
+        well as lcov coverage data is collected from dependency
+        artifacts and processed together with data generated by the
+        task itself.
+
+        The following class attributes may be set to control the behavior
+        of lcov:
+
+          - ``lcov_branches`` - Enable branch coverage. Sets lcov configs
+            ``branch_coverage=1`` and ``no_exception_branch=1``. Default: ``True``
+          - ``lcov_configs`` - List of lcov configs to set. Passed as ``--rc <config>``
+            on the command line. Default: ``[]``
+          - ``lcov_demangle`` - Display demangled function names in output.
+            Passed as ``--demangle-cpp`` on the command line. Default: ``True``
+          - ``lcov_exclude`` - List of files to exclude from the report.
+            Wildcards may be used. Passed as ``--exclude`` on the command line.
+            Default: ``[]``
+          - ``lcov_filters`` - List of filters. Passed as ``--filter`` on
+            the command line. Default: ``[brace, branch, range]``
+          - ``lcov_html`` - Enable/disable HTML report generation. Default: ``True``
+          - ``lcov_ignore_errors`` - List of errors to ignore.
+            Sets lcov config ``ignore_errors``. Default: ``[empty, mismatch, source, unused]``
+          - ``lcov_coverage_data`` - Republish raw gcov coverage data. Default: ``False``
+
+        The task artifact is annotated with:
+
+         - ``artifact.paths.coverage_report_lcov`` which points out the
+           path to the resulting coverage.info file in the artifact.
+         - ``artifact.paths.coverage_report_html`` which points out the
+           path to the resulting HTML files in the artifact.
+
+
+        A gcov and an lcov executable must exist in PATH. Set the ``GCOV``
+        and/or the ``LCOV`` environment variables to override their default names.
+
+        Args:
+            branches (boolean): Enable branch coverage. Default: ``True``.
+                Overridden by class attribute ``lcov_branches``, if set.
+            demangle (boolean): Display demangled function names in output.
+                Default: ``True``. Overridden by class attribute ``lcov_demangle``,
+                if set.
+            html (boolean): Generate an HTML report. Default: ``True``.
+                Overridden by class attribute ``lcov_html``, if set.
+            coverage_data (boolean): Republish coverage data found in
+                dependency artifacts. Default: ``False``
+                Overridden by class attribute ``lcov_coverage_data``, if set.
+
+        Example:
+
+          .. literalinclude:: ../examples/code_coverage/coverage.jolt
+            :language: python
+            :caption: examples/code_coverage/coverage.jolt
+
+        """
+
+        def decorate(cls):
+            class CoverageReportLcovMixin(object):
+                def _cov_report_has_trace_data(self, report):
+                    """
+                    Check if a coverage report has trace data.
+
+                    LCOV argument ``--ignore-errors=empty`` is not working correctly.
+
+                    """
+                    with open(report, "r") as f:
+                        for line in f:
+                            if line.startswith("DA:") or line.startswith("BRDA:"):
+                                return True
+                    return False
+
+                def run_coverage_report_lcov(self, deps, tools):
+                    lcov = tools.getenv("LCOV", "lcov")
+                    if not tools.which(lcov):
+                        raise_task_error(self, "lcov not found in PATH, cannot generate coverage report.")
+
+                    gcov = tools.getenv("GCOV", tools.getenv("CROSS_COMPILE", "") + "gcov")
+                    if not tools.which(gcov):
+                        raise_task_error(self, "gcov not found in PATH, cannot generate coverage report.")
+
+                    if bool(getattr(self, "lcov_demangle", demangle)):
+                        cxxfilt = tools.getenv("CXXFILT", tools.getenv("CROSS_COMPILE", "") + "c++filt")
+                        if not tools.which(cxxfilt):
+                            raise_task_error(self, "c++filt not found in PATH, cannot generate coverage report.")
+
+                    # Assume data is already copied by coverage_data() if the covdatadir exists,
+                    # otherwise copy it from dependency artifacts.
+                    if not hasattr(self, "covdatadir"):
+                        self.covdatadir = tools.builddir("coverage-data")
+                        for _, artifact in deps.items():
+                            if artifact.paths.coverage_data:
+                                tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
+
+                    reportdir = tools.builddir("coverage-report-lcov")
+                    htmldir = tools.builddir("coverage-report-lcov-html")
+                    cachedir = get_cachedir()
+
+                    lcov_configs = list(getattr(self, "lcov_configs", []))
+                    lcov_excludes = list(getattr(self, "lcov_excludes", []))
+                    lcov_filters = list(getattr(self, "lcov_filters", ["brace", "branch", "range"]))
+                    lcov_ignore_errors = list(getattr(self, "lcov_ignore_errors", ["empty", "mismatch", "source", "source", "unused"]))
+                    lcov_substitutes = list(getattr(self, "lcov_substitutes", []))
+
+                    lcov_html_flags = ["-p", tools.wsroot]
+                    if bool(getattr(self, "lcov_demangle", demangle)):
+                        lcov_html_flags.append("--demangle-cpp")
+                        lcov_html_flags.append(f"--rc demangle_cpp={cxxfilt}")
+
+                    lcov_html_flags.extend(getattr(self, "lcov_html_flags", []))
+                    lcov_info_flags = getattr(self, "lcov_info_flags", [])
+
+                    if bool(getattr(self, "lcov_branches", branches)):
+                        lcov_configs.append("branch_coverage=1")
+                        lcov_configs.append("no_exception_branch=1")
+
+                    if lcov_excludes:
+                        lcov_excludes = ["--exclude " + f"'{exclude}'" for exclude in lcov_excludes]
+                        lcov_info_flags.extend(lcov_excludes)
+
+                    if lcov_filters:
+                        lcov_info_flags.append("--rc filter=" + ",".join(lcov_filters))
+                        lcov_html_flags.append("--rc filter=" + ",".join(lcov_filters))
+
+                    if lcov_ignore_errors:
+                        lcov_html_flags.append("--rc ignore_errors=" + ",".join(lcov_ignore_errors))
+                        lcov_info_flags.append("--rc ignore_errors=" + ",".join(lcov_ignore_errors))
+
+                    if lcov_configs:
+                        lcov_configs = ["--rc " + option for option in lcov_configs]
+                        lcov_html_flags.extend(lcov_configs)
+                        lcov_info_flags.extend(lcov_configs)
+
+                    if lcov_substitutes:
+                        lcov_substitutes = [f"--substitute '{sub}'" for sub in lcov_substitutes]
+                        lcov_substitutes = tools.expand(lcov_substitutes)
+                        lcov_html_flags.extend(lcov_substitutes)
+
+                    self.info("Generating LCOV code coverage report")
+                    tools.run("{} -b {} -c -d {covdatadir} -o {}/coverage.info --gcov-tool={} {}",
+                              lcov, tools.wsroot, reportdir, gcov, " ".join(lcov_info_flags), output_on_error=True)
+
+                    reports = []
+                    for _, artifact in deps.items():
+                        if artifact.paths.coverage_report_lcov:
+                            reports.append(str(artifact.paths.coverage_report_lcov))
+                    if reports:
+                        filtered_reports = []
+                        for report in reports:
+                            if not self._cov_report_has_trace_data(report):
+                                self.warning(f"Coverage report {report} has no data records, excluding from merge")
+                            else:
+                                filtered_reports.append(report)
+                        reports = filtered_reports
+
+                    if reports:
+                        reports = ["-a " + report for report in reports]
+                        self.info("Merging LCOV code coverage reports")
+                        tools.run("{} {} -o {}/coverage.info --gcov-tool={} {}",
+                                  lcov, " ".join(reports), reportdir, gcov, " ".join(lcov_info_flags), output_on_error=True)
+
+                    with tools.cwd(reportdir):
+                        tools.replace_in_file("coverage.info", f"{tools.wsroot}/", "")
+                        tools.replace_in_file("coverage.info", f"{cachedir}/", "{{cachedir}}/")
+                        tools.copy("coverage.info", "coverage.info.abs")
+                        tools.replace_in_file("coverage.info.abs", "SF:", f"SF:{tools.wsroot}/")
+                        tools.replace_in_file("coverage.info.abs", f"SF:{tools.wsroot}/" + "{{cachedir}}/", f"SF:{cachedir}/")
+
+                        if tools.file_size("coverage.info") <= 0 or not self._cov_report_has_trace_data(tools.expand_path("coverage.info")):
+                            tools.unlink("coverage.info")
+                            self.warning("No coverage data records available, skipping HTML report generation")
+                            return
+
+                    if bool(getattr(self, "lcov_html", html)):
+                        self.info("Generating HTML code coverage report")
+                        tools.run("genhtml {}/coverage.info.abs --output-directory {} --title '{short_qualified_name}' {}",
+                                  reportdir, htmldir, " ".join(lcov_html_flags), output_on_error=True)
+
+                @utils.cached.instance
+                def publish_coverage_data(self, artifact, tools):
+                    if not bool(getattr(self, "lcov_coverage_data", coverage_data)):
+                        return
+
+                    self.verbose("Publishing coverage data from {covdatadir}")
+                    with tools.cwd(self.covdatadir):
+                        if artifact.collect("**/*.gc*", "cov/"):
+                            artifact.paths.coverage_data = "cov"
+
+                def publish_coverage_report_lcov_info(self, artifact, tools):
+                    reportdir = tools.builddir("coverage-report-lcov")
+                    with tools.cwd(reportdir):
+                        if artifact.collect("coverage.info", "report/lcov/"):
+                            artifact.paths.coverage_report_lcov = "report/lcov/coverage.info"
+
+                def publish_coverage_report_lcov_html(self, artifact, tools):
+                    htmldir = tools.builddir("coverage-report-lcov-html")
+                    with tools.cwd(htmldir):
+                        if artifact.collect("*", "report/html/"):
+                            artifact.paths.coverage_report_html = "report/html"
+
+            class CoverageReportLcov(cls, CoverageReportLcovMixin):
+                @functools.wraps(cls.run)
+                def run(self, deps, tools):
+                    super().run(deps, tools)
+                    self.run_coverage_report_lcov(deps, tools)
+
+                def publish_coverage_data(self, artifact, tools):
+                    CoverageReportLcovMixin.publish_coverage_data(self, artifact, tools)
+
+                @functools.wraps(cls.publish)
+                def publish(self, artifact, tools):
+                    super().publish(artifact, tools)
+                    self.publish_coverage_report_lcov_info(artifact, tools)
+                    if bool(getattr(self, "lcov_html", html)):
+                        self.publish_coverage_report_lcov_html(artifact, tools)
+                    if bool(getattr(self, "lcov_coverage_data", coverage_data)):
+                        self.publish_coverage_data(artifact, tools)
+
+            CoverageReportLcov.__doc__ = cls.__doc__
+            CoverageReportLcov.__name__ = cls.__name__
+            return CoverageReportLcov
+
+        return decorate
+
     @staticmethod
     def cxxflags(attrib, prepend=False):
         """
@@ -69,6 +515,22 @@ class attributes:
         """
         return utils.concat_attributes("cxxflags", attrib, prepend)
 
+    @staticmethod
+    def headers(attrib, prepend=False):
+        """
+        Decorates a task with an alternative ``headers`` attribute.
+
+        The new attribute will be concatenated with the regular
+        ``headers`` attribute.
+
+        Args:
+            attrib (str): Name of alternative attribute.
+                Keywords are expanded.
+            prepend (boolean): Prepend the value of the alternative
+                attribute. Default: false (append).
+        """
+        return utils.concat_attributes("headers", attrib, prepend)
+
     @staticmethod
     def incpaths(attrib, prepend=False):
         """
@@ -186,7 +648,7 @@ class Variable(HashInfluenceProvider):
 
     @staticmethod
     def __get_variables__(obj):
-        variables = {}
+        variables = OrderedDict()
         for mro in reversed(obj.__class__.__mro__):
             for key, variable in getattr(mro, "__variable_list", {}).items():
                 attr = getattr(obj.__class__, key)
@@ -197,7 +659,7 @@ class Variable(HashInfluenceProvider):
     def __set_name__(self, owner, name):
         self.name = name
         if "__variable_list" not in owner.__dict__:
-            setattr(owner, "__variable_list", {})
+            setattr(owner, "__variable_list", OrderedDict())
         getattr(owner, "__variable_list")[name] = self
 
     def create(self, project, writer, deps, tools):
@@ -287,7 +749,7 @@ class ProjectVariable(Variable):
 
     def create(self, project, writer, deps, tools):
         value = getattr(project, self._attrib or self.name, "")
-        if type(value) == list:
+        if type(value) is list:
             value = " ".join(value)
         writer.variable(self.name, str(value))
 
@@ -296,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
@@ -325,11 +835,11 @@ class GNUPCHVariables(Variable):
             "multiple precompiled headers found, only one is allowed")
 
         if len(pch) <= 0:
-            writer.variable("pch_out", "$binary.dir/")
+            writer.variable("pch_out", tools.expand_relpath("{outdir}/{binary}.dir/", tools.wsroot))
             return
 
         project._pch = fs.path.basename(pch[0])
-        project._pch_out = "$binary.dir/" + project._pch + self.gch_ext
+        project._pch_out = tools.expand_relpath("{outdir}/{binary}.dir/{_pch}" + self.gch_ext, tools.wsroot)
 
         writer.variable("pch", project._pch)
         writer.variable("pch_flags", "")
@@ -340,6 +850,14 @@ class GNUPCHVariables(Variable):
         return "PCHV"
 
 
+class GNUCoverageVariable(Variable):
+    def create(self, project, writer, deps, tools):
+        if bool(getattr(project, "coverage", False)):
+            writer.variable("covflags", "--coverage")
+        else:
+            writer.variable("covflags", "")
+
+
 class Rule(HashInfluenceProvider):
     """ A source transformation rule.
 
@@ -372,7 +890,7 @@ class Rule(HashInfluenceProvider):
 
     """
 
-    def __init__(self, command=None, infiles=None, outfiles=None, depfile=None, deps=None, variables=None, implicit=None, order_only=None, aggregate=False, phony=None):
+    def __init__(self, command=None, infiles=None, outfiles=None, depfile=None, deps=None, variables=None, implicit=None, implicit_outputs=None, order_only=None, aggregate=False, phony=None):
         """
         Creates a new rule.
 
@@ -443,12 +961,13 @@ class Rule(HashInfluenceProvider):
                  before any C++ file is compiled.
         """
         self.command = command
-        self.variables = variables or {}
+        self.variables = OrderedDict([(key, value) for key, value in (variables or {}).items()])
         self.depfile = depfile
         self.deps = deps
         self.infiles = infiles or []
         self.outfiles = utils.as_list(outfiles or [])
         self.implicit = implicit or []
+        self.implicit_outputs = implicit_outputs or []
         self.order_only = order_only or []
         self.aggregate = aggregate
         self.phony = phony
@@ -471,17 +990,17 @@ class Rule(HashInfluenceProvider):
             setattr(owner, "__rule_list", {})
         getattr(owner, "__rule_list")[name] = self
 
-    def _out(self, project, infile):
+    def _out(self, project, infile, outfiles=None):
         in_dirname_outdir = None
         in_dirname, in_basename = fs.path.split(infile)
         in_base, in_ext = fs.path.splitext(in_basename)
 
         if in_dirname and fs.path.isabs(in_dirname):
-            in_dirname_outdir = fs.path.relpath(in_dirname, project.outdir)
-            in_dirname = fs.path.relpath(in_dirname, project.joltdir)
+            in_dirname_outdir = fs.path.relpath(in_dirname, project.tools.wsroot)
+            in_dirname = fs.path.relpath(in_dirname, project.tools.wsroot)
 
         result_files = []
-        for outfile in self.outfiles:
+        for outfile in outfiles or self.outfiles:
             outfile = project.tools.expand(
                 outfile,
                 in_path=in_dirname,
@@ -495,7 +1014,7 @@ class Rule(HashInfluenceProvider):
 
             result_files.append(outfile.replace("..", "__"))
 
-        result_vars = {}
+        result_vars = OrderedDict()
         for key, val in self.variables.items():
             result_vars[key] = project.tools.expand(
                 val,
@@ -518,23 +1037,34 @@ class Rule(HashInfluenceProvider):
         outfiles, _ = self._out(project, utils.as_list(infiles)[0])
         return outfiles
 
-    def build(self, project, writer, infiles, implicit=None, order_only=None):
+    def build(self, project, writer, infiles, implicit=None, implicit_outputs=None, order_only=None):
         result = []
         infiles = utils.as_list(infiles)
-        infiles_rel = [fs.path.relpath(infile, project.outdir) for infile in infiles]
+        infiles_rel = [fs.path.relpath(infile, project.tools.wsroot) for infile in infiles]
         implicit = (self.implicit or []) + (implicit or [])
+        implicit_outputs = (self.implicit_outputs or []) + (implicit_outputs or [])
         order_only = (self.order_only or []) + (order_only or [])
 
         if self.aggregate:
             outfiles, variables = self._out(project, infiles[0])
-            outfiles_rel = [fs.path.relpath(outfile, project.outdir) for outfile in outfiles]
-            writer.build(outfiles_rel, self.name, infiles_rel, variables=variables, implicit=implicit, order_only=self.order_only + order_only)
+            outfiles_rel = [fs.path.relpath(outfile, project.tools.wsroot) for outfile in outfiles]
+            if implicit_outputs:
+                implicit_outfiles, _ = self._out(project, infiles[0], implicit_outputs)
+                implicit_outfiles_rel = [fs.path.relpath(outfile, project.tools.wsroot) for outfile in implicit_outfiles]
+            else:
+                implicit_outfiles_rel = []
+            writer.build(outfiles_rel, self.name, infiles_rel, variables=variables, implicit=implicit, implicit_outputs=implicit_outfiles_rel, order_only=self.order_only + order_only)
             result.extend(outfiles)
         else:
             for infile, infile_rel in zip(infiles, infiles_rel):
                 outfiles, variables = self._out(project, infile)
-                outfiles_rel = [fs.path.relpath(outfile, project.outdir) for outfile in outfiles]
-                writer.build(outfiles_rel, self.name, infile_rel, variables=variables, implicit=implicit, order_only=order_only)
+                outfiles_rel = [fs.path.relpath(outfile, project.tools.wsroot) for outfile in outfiles]
+                if implicit_outputs:
+                    implicit_outfiles, _ = self._out(project, infile, implicit_outputs)
+                    implicit_outfiles_rel = [fs.path.relpath(outfile, project.tools.wsroot) for outfile in implicit_outfiles]
+                else:
+                    implicit_outfiles_rel = []
+                writer.build(outfiles_rel, self.name, infile_rel, variables=variables, implicit=implicit, implicit_outputs=implicit_outfiles_rel, order_only=order_only)
                 result.extend(outfiles)
         if self.phony:
             writer.build(self.phony, "phony", outfiles_rel)
@@ -564,12 +1094,12 @@ class ProtobufCompiler(Rule):
             phony=True,
             variables=None,
             **kwargs):
-        variables_final = {
-            "desc": "[PROTOC] {in_base}{in_ext}",
-            "out_depfile": "{binary}.dir/{in_base}.pb.d",
-            "outdir_proto": os.path.dirname(outfiles[0]),
-            "in_path_outdir": "{in_path_outdir}",
-        }
+        variables_final = OrderedDict([
+            ("desc", "[PROTOC] {in_base}{in_ext}"),
+            ("out_depfile", "{outdir_rel}/{binary}.dir/{in_base}.pb.d"),
+            ("outdir_proto", "{outdir_rel}/{binary}.dir"),
+            ("in_path_outdir", "{in_path_outdir}"),
+        ])
         variables_final.update(variables or {})
         super().__init__(
             command=command,
@@ -583,8 +1113,8 @@ class ProtobufCompiler(Rule):
             **kwargs)
         self.generator = generator
 
-    def _out(self, project, infile):
-        outfiles, variables = super()._out(project, infile)
+    def _out(self, project, infile, outfiles=None):
+        outfiles, variables = super()._out(project, infile, outfiles)
         variables["generator"] = project.tools.expand(self.generator)
         return outfiles, variables
 
@@ -610,8 +1140,8 @@ class GRPCProtobufCompiler(ProtobufCompiler):
             variables=None,
             **kwargs):
         variables_final = {
-            "out_depfile": "{binary}.dir/{in_base}.pb.d",
-            "out_depfile_grpc": "{binary}.dir/{in_base}.grpc.pb.d",
+            "out_depfile": "{outdir_rel}/{binary}.dir/{in_base}.pb.d",
+            "out_depfile_grpc": "{outdir_rel}/{binary}.dir/{in_base}.grpc.pb.d",
         }
         variables_final.update(variables or {})
         super().__init__(command=command, depfile=depfile, outfiles=outfiles, variables=variables_final, **kwargs)
@@ -650,8 +1180,8 @@ class FlatbufferCompiler(Rule):
             **kwargs)
         self.generator = generator
 
-    def _out(self, project, infile):
-        outfiles, variables = super()._out(project, infile)
+    def _out(self, project, infile, outfiles=None):
+        outfiles, variables = super()._out(project, infile, outfiles)
         variables["generator"] = project.tools.expand(self.generator)
         return outfiles, variables
 
@@ -678,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):
@@ -700,16 +1231,23 @@ class MakeDirectory(Rule):
 
 class GNUCompiler(Rule):
     def __init__(self, *args, **kwargs):
+        self.covfiles = kwargs.pop("covfiles", [])
         super(GNUCompiler, self).__init__(*args, **kwargs)
 
     def create(self, project, writer, deps, tools):
         super().create(project, writer, deps, tools)
 
-    def build(self, project, writer, infiles, implicit=None, order_only=None):
+    def build(self, project, writer, infiles, implicit=None, implicit_outputs=None, order_only=None):
         implicit = implicit or []
+        implicit_outputs = implicit_outputs or []
+
+        if getattr(project, "coverage", False) and self.covfiles:
+            implicit_outputs.extend(self.covfiles)
+
         if GNUPCHVariables.pch_ext not in self.infiles and project._pch_out is not None:
             implicit.append(project._pch_out)
-        return super().build(project, writer, infiles, implicit, order_only)
+
+        return super().build(project, writer, infiles, implicit=implicit, implicit_outputs=implicit_outputs, order_only=order_only)
 
     @utils.cached.instance
     def get_influence(self, task):
@@ -746,7 +1284,9 @@ class FileListWriter(Rule):
     def build(self, project, writer, infiles, implicit=None, order_only=None):
         infiles = [fs.as_posix(infile) for infile in infiles] if self.posix else infiles
         file_list_path = fs.path.join(project.outdir, "{0}.list".format(self.name))
+        file_list_path = project.tools.expand_path(file_list_path)
         file_list_hash_path = fs.path.join(project.outdir, "{0}.hash".format(self.name))
+        file_list_hash_path = project.tools.expand_path(file_list_hash_path)
         data, digest = self._data(project, infiles)
         if not self._identical(file_list_path, file_list_hash_path, data, digest):
             self._write(file_list_path, file_list_hash_path, data, digest)
@@ -829,11 +1369,12 @@ class GNUDepImporter(Rule):
         for name, artifact in deps.items():
             if artifact.cxxinfo.libpaths.items():
                 sandbox = project.tools.sandbox(artifact, project.incremental)
+                sandbox = project.tools.expand_relpath(sandbox, project.tools.wsroot)
             for lib in artifact.cxxinfo.libraries.items():
                 name = "{0}{1}{2}".format(self.prefix, lib, self.suffix)
                 for path in artifact.cxxinfo.libpaths.items():
                     archive = fs.path.join(sandbox, path, name)
-                    if fs.path.exists(archive):
+                    if fs.path.exists(os.path.join(project.tools.wsroot, archive)):
                         archives.append(archive)
         return archives
 
@@ -844,7 +1385,9 @@ class GNUDepImporter(Rule):
         if isinstance(project, CXXLibrary):
             imports += self._build_archives(project, writer, deps)
             if not project.shared and project.selfsustained:
-                writer.sources.extend(imports)
+                sources = [os.path.join(project.tools.wsroot, source) for source in imports]
+                sources = [os.path.relpath(source, project.joltdir) for source in sources]
+                writer.sources.extend(sources)
         return imports
 
     def get_influence(self, task):
@@ -857,7 +1400,7 @@ class Toolchain(object):
 
     @staticmethod
     def build_rules_and_vars(obj):
-        rule_map = {}
+        rule_map = OrderedDict()
         rules, vars = Toolchain.all_rules_and_vars(obj)
         for name, rule in rules.items():
             rule.name = name
@@ -929,18 +1472,18 @@ class IncludePaths(Variable):
                 return tools.expand(path)
             if path[0] in ['-']:
                 path = tools.expand_path(path[1:])
-            return tools.expand_relpath(path, project.outdir)
+            return tools.expand_relpath(path, project.tools.wsroot)
 
         def expand_artifact(sandbox, path):
             if path[0] in ['=', fs.sep]:
                 return path
             if path[0] in ['-']:
                 path = fs.path.join(project.joltdir, path[1:])
-            return tools.expand_relpath(fs.path.join(sandbox, path), project.outdir)
+            return tools.expand_relpath(fs.path.join(sandbox, path), project.tools.wsroot)
 
         incpaths = []
         if self.outdir:
-            incpaths += ["$binary.dir"]
+            incpaths += [tools.expand_relpath("{outdir}/{binary}.dir", project.tools.wsroot)]
         if self.attrib:
             incpaths += [expand(path) for path in getattr(project, self.attrib)]
         if self.imported:
@@ -969,12 +1512,13 @@ class LibraryPaths(Variable):
             return
         libpaths = []
         if self.attrib:
-            libpaths = [tools.expand_relpath(path, project.outdir) for path in getattr(project, self.attrib)]
+            libpaths = [tools.expand_relpath(path, project.tools.wsroot) for path in getattr(project, self.attrib)]
         if self.imported:
             for _, artifact in deps.items():
                 libs = artifact.cxxinfo.libpaths.items()
                 if libs:
                     sandbox = tools.sandbox(artifact, project.incremental)
+                    sandbox = tools.expand_relpath(sandbox, project.tools.wsroot)
                     libpaths += [fs.path.join(sandbox, path) for path in libs]
         libpaths = ["{0}{1}".format(self.prefix, path) for path in libpaths]
         writer.variable(self.name, " ".join(libpaths))
@@ -1036,7 +1580,9 @@ class GNUToolchain(Toolchain):
     bin = Skip(infiles=[".dll", ".elf", ".exe", ".out", ".so"])
 
     joltdir = ProjectVariable()
+    builddir = ProjectVariable(attrib="outdir")
     outdir = ProjectVariable()
+    outdir_rel = ProjectVariable()
     binary = ProjectVariable()
 
     ar = ToolEnvironmentVariable(default="ar", abspath=True)
@@ -1049,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="")
@@ -1065,6 +1621,8 @@ class GNUToolchain(Toolchain):
     extra_cxxflags = ProjectVariable(attrib="cxxflags")
     extra_ldflags = ProjectVariable(attrib="ldflags")
 
+    covflags = GNUCoverageVariable()
+
     task_fbflags = ProjectVariable(attrib="fbflags")
     task_protoflags = ProjectVariable(attrib="protoflags")
 
@@ -1075,31 +1633,34 @@ class GNUToolchain(Toolchain):
     libpaths = LibraryPaths(prefix="-L")
     libraries = Libraries(prefix="-l")
 
-    mkdir_debug = MakeDirectory(name=".debug")
+    mkdir_debug = MakeDirectory(name="$outdir_rel/.debug")
 
     compile_pch = GNUCompiler(
-        command="$cxxwrap $cxx -x c++-header $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $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],
         outfiles=["{outdir}/{binary}.dir/{in_base}{in_ext}" + GNUPCHVariables.gch_ext],
+        covfiles=["{outdir}/{binary}.dir/{in_base}{in_ext}.gcno"],
         variables={"desc": "[PCH] {in_base}{in_ext}"})
 
     compile_c = GNUCompiler(
-        command="$ccwrap $cc -x c $pch_flags $cflags $shared_flags $imported_cflags $extra_cflags $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"],
         outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.o"],
+        covfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.gcno"],
         variables={"desc": "[C] {in_base}{in_ext}"},
         implicit=["$cc_path"])
 
     compile_cxx = GNUCompiler(
-        command="$cxxwrap $cxx -x c++ $pch_flags $cxxflags $shared_flags $imported_cxxflags $extra_cxxflags $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"],
         outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.o"],
+        covfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.gcno"],
         variables={"desc": "[CXX] {in_base}{in_ext}"},
         implicit=["$cxx_path"])
 
@@ -1109,6 +1670,7 @@ class GNUToolchain(Toolchain):
         depfile="$out.d",
         infiles=[".s", ".asm"],
         outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.o"],
+        covfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.gcno"],
         variables={"desc": "[ASM] {in_base}{in_ext}"},
         implicit=["$cc_path"])
 
@@ -1118,6 +1680,7 @@ class GNUToolchain(Toolchain):
         depfile="$out.d",
         infiles=[".S"],
         outfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.o"],
+        covfiles=["{outdir}/{binary}.dir/{in_path}/{in_base}{in_ext}.gcno"],
         variables={"desc": "[ASM] {in_base}{in_ext}"},
         implicit=["$cc_path"])
 
@@ -1127,51 +1690,100 @@ class GNUToolchain(Toolchain):
 
     linker = GNULinker(
         command=" && ".join([
-            "$ld $ldflags $imported_ldflags $extra_ldflags $libpaths -Wl,--start-group @objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
-            "$objcopy_path --only-keep-debug $out .debug/$binary",
+            "$ld $ldflags $imported_ldflags $extra_ldflags $covflags $libpaths -Wl,--start-group @$outdir_rel/objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
+            "$objcopy_path --only-keep-debug $out $outdir_rel/.debug/$binary",
             "$objcopy_path --strip-all $out",
-            "$objcopy_path --add-gnu-debuglink=.debug/$binary $out"
+            "$objcopy_path --add-gnu-debuglink=$outdir_rel/.debug/$binary $out"
         ]),
         infiles=[".o", ".obj", ".a"],
         outfiles=["{outdir}/{binary}"],
         variables={"desc": "[LINK] {binary}"},
-        implicit=["$ld_path", "$objcopy_path", ".debug"])
+        implicit=["$ld_path", "$objcopy_path", "$outdir_rel/.debug"])
 
     dynlinker = GNULinker(
         command=" && ".join([
-            "$ld $ldflags -shared $imported_ldflags $extra_ldflags $libpaths -Wl,--start-group @objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
-            "$objcopy_path --only-keep-debug $out .debug/lib$binary.so",
+            "$ld $ldflags -shared $imported_ldflags $extra_ldflags $covflags $libpaths -Wl,--start-group @$outdir_rel/objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
+            "$objcopy_path --only-keep-debug $out $outdir_rel/.debug/lib$binary.so",
             "$objcopy_path --strip-all $out",
-            "$objcopy_path --add-gnu-debuglink=.debug/lib$binary.so $out"
+            "$objcopy_path --add-gnu-debuglink=$outdir_rel/.debug/lib$binary.so $out"
         ]),
         infiles=[".o", ".obj", ".a"],
         outfiles=["{outdir}/lib{binary}.so"],
         variables={"desc": "[LINK] {binary}"},
-        implicit=["$ld_path", "$objcopy_path", ".debug"])
+        implicit=["$ld_path", "$objcopy_path", "$outdir_rel/.debug"])
 
     archiver = GNUArchiver(
-        command="$ar -M < objects.list && $ranlib $out",
+        command="$ar -M < $outdir_rel/objects.list && $ranlib $out",
         infiles=[".o", ".obj", ".a"],
         outfiles=["{outdir}/lib{binary}.a"],
         variables={"desc": "[AR] lib{binary}.a"},
-        implicit=["$ld_path", "$ar_path"])
+        implicit=["$ld_path", "$ar_path", "$ranlib_path"])
 
     depimport = GNUDepImporter(
         prefix="lib",
         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([
-            "$ld $ldflags $imported_ldflags $extra_ldflags $libpaths -Wl,--start-group @objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
-            "$objcopy --only-keep-debug $out .debug/$binary.exe",
+            "$ld $ldflags $imported_ldflags $extra_ldflags $libpaths -Wl,--start-group @$outdir_rel/objects.list -Wl,--end-group -o $out -Wl,--start-group $libraries -Wl,--end-group",
+            "$objcopy --only-keep-debug $out $outdir_rel/.debug/$binary.exe",
             "$objcopy --strip-all $out",
-            "$objcopy --add-gnu-debuglink=.debug/$binary.exe $out"
+            "$objcopy --add-gnu-debuglink=$outdir_rel/.debug/$binary.exe $out"
         ]),
         outfiles=["{outdir}/{binary}.exe"],
         variables={"desc": "[LINK] {binary}"},
-        implicit=["$ld_path", "$objcopy_path", ".debug"])
+        implicit=["$ld_path", "$objcopy_path", "$outdir_rel/.debug"])
 
 
 class MSVCArchiver(Rule):
@@ -1189,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
@@ -1199,7 +1867,9 @@ class MSVCToolchain(Toolchain):
     bin = Skip(infiles=[".dll", ".exe"])
 
     joltdir = ProjectVariable()
+    builddir = ProjectVariable(attrib="outdir")
     outdir = ProjectVariable()
+    outdir_rel = ProjectVariable()
     binary = ProjectVariable()
 
     cl = ToolEnvironmentVariable(default="cl", envname="cl_exe", abspath=True)
@@ -1208,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")
@@ -1229,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"])
 
@@ -1256,14 +1938,14 @@ class MSVCToolchain(Toolchain):
     compile_proto = ProtobufCompiler(generator="cpp")
 
     linker = MSVCLinker(
-        command="$link /nologo $ldflags $extra_ldflags $libpaths @objects.list $libraries /out:$out",
+        command="$link /nologo $ldflags $extra_ldflags $libpaths @$outdir_rel/objects.list $libraries /out:$out",
         infiles=[".o", ".obj", ".lib"],
         outfiles=["{outdir}/{binary}.exe"],
         variables={"desc": "[LINK] {binary}"},
         implicit=["$link_path"])
 
     archiver = MSVCArchiver(
-        command="$lib /nologo /out:$out @objects.list",
+        command="$lib /nologo /out:$out @$outdir_rel/objects.list",
         infiles=[".o", ".obj", ".lib"],
         outfiles=["{outdir}/{binary}.lib"],
         variables={"desc": "[LIB] {binary}"},
@@ -1276,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]
 
@@ -1320,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 """
 
@@ -1341,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.
 
@@ -1374,6 +2086,33 @@ class CXXProject(Task):
     binary = None
     """ Name of the target binary (defaults to canonical task name) """
 
+    coverage = False
+    """Enable code coverage instrumentation.
+
+    Only implemented for GCC/Clang toolchains.
+
+    When set, the --coverage flag is passed to the compiler. The compiler
+    instruments the generated machine code and outputs coverage note files
+    (.gcno), one for each translation unit, which are collected into the
+    task artifact. Upon running the executable, coverage data files are
+    generated.
+
+    Use the :func:`attributes.coverage_data` decorator to
+    automatically collect and publish data files in tasks that run
+    instrumented binaries. The :func:`attributes.coverage_report_gcov`
+    decorator can then be used to process the notes and data files
+    into human readable coverage information.  There is also a
+    :func:`attributes.coverage_report_lcov` decorator that will
+    generate and publish an HTML coverage report.
+
+    Example:
+
+      .. literalinclude:: ../examples/code_coverage/coverage.jolt
+         :language: python
+         :caption: examples/code_coverage/coverage.jolt
+
+    """
+
     incremental = True
     """ Compile incrementally.
 
@@ -1428,7 +2167,7 @@ class CXXProject(Task):
         self._init_rules_and_vars()
 
     def _init_rules_and_vars(self):
-        self._rules_by_ext = {}
+        self._rules_by_ext = OrderedDict()
         self._rules = []
         self._variables = []
 
@@ -1466,22 +2205,26 @@ class CXXProject(Task):
     def _verify_influence(self, deps, artifact, tools):
         # Verify that listed sources and their dependencies are influencing
         sources = set(self.sources + getattr(self, "headers", []))
-        with tools.cwd(self.outdir):
+        with tools.cwd(tools.wsroot):
             depfiles = [obj + ".d" for obj in getattr(self._writer, "_objects", [])]
             for depfile in depfiles:
                 try:
                     data = tools.read_file(depfile)
                 except Exception:
                     continue
-                data = data.split(":", 1)
-                if len(data) <= 1:
-                    continue
 
-                depsrcs = data[1]
-                depsrcs = depsrcs.split()
-                depsrcs = [f.rstrip("\\").strip() for f in depsrcs]
-                depsrcs = [tools.expand_relpath(dep, self.joltdir) for dep in filter(lambda n: n, depsrcs)]
-                sources = sources.union(depsrcs)
+                data = data.replace("\\\n", "")
+                for depline in data.splitlines():
+                    depline = depline.strip()
+                    depline = depline.split(":", 1)
+                    if len(depline) <= 1:
+                        continue
+
+                    inputs = depline[1]
+                    inputs = inputs.replace("\\ ", "\x00")
+                    inputs = [dep.strip().replace("\x00", " ") for dep in inputs.split()]
+                    inputs = [tools.expand_relpath(input, self.joltdir) for input in filter(lambda n: n, inputs)]
+                    sources = sources.union(inputs)
         super()._verify_influence(deps, artifact, tools, sources)
 
     def _expand_headers(self):
@@ -1515,10 +2258,11 @@ class CXXProject(Task):
         self.sources = sources
 
     def _write_ninja_file(self, basedir, deps, tools, filename="build.ninja"):
-        with open(fs.path.join(basedir, filename), "w") as fobj:
+        with open(tools.expand_path(fs.path.join(basedir, filename)), "w") as fobj:
             writer = ninja.Writer(fobj)
-            writer.depimports = [tools.expand_relpath(dep, self.outdir)
-                                 for dep in self.depimports]
+            writer.depimports = [
+                tools.expand_relpath(dep, tools.wsroot)
+                for dep in self.depimports]
             writer.objects = []
             writer.sources = copy.copy(self.sources)
             self._populate_rules_and_variables(writer, deps, tools)
@@ -1526,12 +2270,6 @@ class CXXProject(Task):
             writer.close()
             return writer
 
-    def _prepare_ninja_cache(self, deps, tools):
-        """ Hooked from ninja-cache plugin """
-
-    def _write_ninja_cache(self, deps, tools):
-        """ Hooked from ninja-cache plugin """
-
     def _write_shell_file(self, basedir, deps, tools, writer):
         filepath = fs.path.join(basedir, "compile")
         with open(filepath, "w") as fobj:
@@ -1555,7 +2293,7 @@ def main():
         for object in objects:
             print(object)
     elif [arg for arg in sys.argv[1:] if arg == "-a"]:
-        subprocess.call(["ninja", "-v"])
+        subprocess.call(["ninja", "-f", "{outdir}/build.ninja", "-v"])
     else:
         targets = []
         for arg in sys.argv[1:]:
@@ -1565,7 +2303,7 @@ def main():
             targets.extend(matches)
         if not targets:
             return
-        subprocess.call(["ninja", "-v"] + targets)
+        subprocess.call(["ninja", "-f", "{outdir}/build.ninja",  "-v"] + targets)
 
 if __name__ == "__main__":
     main()
@@ -1574,7 +2312,8 @@ if __name__ == "__main__":
             fobj.write(
                 data.format(
                     executable=sys.executable,
-                    objects=[fs.path.relpath(o, self.outdir) for o in writer.objects]))
+                    objects=[fs.path.relpath(o, tools.wsroot) for o in writer.objects],
+                    outdir=self.outdir))
         tools.chmod(filepath, 0o777)
 
     def find_rule(self, ext):
@@ -1619,7 +2358,7 @@ if __name__ == "__main__":
         sources = [(tools.expand_path(source), origin) for source, origin in sources]
 
         # Aggregated list of sources for each rule
-        rule_source_list = {}
+        rule_source_list = OrderedDict()
         while sources:
             source, origin = sources.pop()
             _, ext = fs.path.splitext(source)
@@ -1716,25 +2455,62 @@ if __name__ == "__main__":
         incrementally. The behavior can be changed with the ``incremental``
         class attribute.
         """
-
         self.outdir = tools.builddir("ninja", self.incremental)
+        self.outdir_rel = self.tools.expand_relpath(self.outdir, tools.wsroot)
         self._expand_headers()
         self._expand_sources(deps, tools)
-        self._prepare_ninja_cache(deps, tools)
         self._writer = self._write_ninja_file(self.outdir, deps, tools)
-        self._write_ninja_cache(deps, tools)
         verbose = " -v" if log.is_verbose() else ""
         threads = config.get("jolt", "threads", tools.getenv("JOLT_THREADS", None))
         threads = " -j" + threads if threads else ""
+        keep_going = " -k 0" if config.get_keep_going() else ""
         depsfile = self._get_keepdepfile(tools)
         try:
-            tools.run("ninja{3}{2} -C {0} {1}", self.outdir, verbose, threads, depsfile)
+            self.buildlog = tools.run(
+                "ninja{3}{2}{5} -C {0} -f {4} {1}",
+                tools.wsroot,
+                verbose,
+                threads,
+                depsfile,
+                fs.path.join(self.outdir, "build.ninja"),
+                keep_going,
+                output=True,
+            )
+            self._report_errors(self.buildlog)
         except JoltCommandError as e:
-            with utils.ignore_exception(), self.report() as report:
-                self._report_errors(report, "\n".join(e.stdout))
-            raise CompileError()
+            self.buildlog = "\n".join(e.stdout)
+            report = self._report_errors(self.buildlog)
+            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")
+            with tools.cwd(tools.wsroot):
+                for obj in getattr(self._writer, "_objects", []):
+                    obj, ext = os.path.splitext(obj)
+                    obj = obj + ".gcno"
+                    try:
+                        tools.copy(obj, os.path.join(self.covdatadir, tools.expand_relpath(obj, "/")))
+                    except FileNotFoundError:
+                        pass
+            if self.selfsustained:
+                for _, artifact in deps.items():
+                    if artifact.paths.coverage_data:
+                        tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
+
+    def publish(self, artifact, tools):
+        if bool(getattr(self, "coverage", False)):
+            self.publish_coverage_data(artifact, tools)
+
+    def publish_coverage_data(self, artifact, tools):
+        """ Publishes code coverage data files. """
+        with tools.cwd(self.covdatadir):
+            if artifact.collect("**/*.gcno", "cov/"):
+                artifact.paths.coverage_data = "cov"
 
-    def shell(self, deps, tools):
+    def debugshell(self, deps, tools):
         """
         Invoked to start a debug shell.
 
@@ -1751,41 +2527,58 @@ if __name__ == "__main__":
         self._expand_headers()
         self._expand_sources(deps, tools)
         self.outdir = tools.builddir("ninja", self.incremental)
-        self._prepare_ninja_cache(deps, tools)
+        self.outdir_rel = self.tools.expand_relpath(self.outdir, tools.wsroot)
         writer = self._write_ninja_file(self.outdir, deps, tools)
-        self._write_ninja_cache(deps, tools)
         self._write_shell_file(self.outdir, deps, tools, writer)
         pathenv = self.outdir + os.pathsep + tools.getenv("PATH")
-        with tools.cwd(self.outdir), tools.environ(PATH=pathenv):
+        with tools.cwd(tools.wsroot), tools.environ(PATH=pathenv):
             print()
             print("Use the 'compile' command to build individual compilation targets")
-            super(CXXProject, self).shell(deps, tools)
-
-    def _report_errors(self, report, logbuffer):
-        # GCC style errors
-        report.add_regex_errors_with_file(
-            "Compiler Error",
-            r"(?P<location>(?P<file>.*?):(?P<line>[0-9]+):(?P<col>[0-9]+)): (?P<message>.*)",
-            logbuffer,
-            self.outdir,
-            lambda err: not err["message"].startswith("note:"))
-
-        # other compiler errors
-        report.add_regex_errors_with_file(
-            "Compiler Error",
-            r"(?P<location>(?P<file>.*?)\((?P<line>[0-9]+)\)): (?P<message>error: .*)",
-            logbuffer,
-            self.outdir)
-
-        # Linker errors
-        report.add_regex_errors(
-            "Linker Error",
-            r"(?P<location>(?P<file>.*?):(.*?)): (?P<message>(undefined reference|multiple definition).*)",
-            logbuffer)
-        report.add_regex_errors(
-            "Linker Error",
-            r"(?P<location>ld): (error|warning): (?P<message>.*)",
-            logbuffer)
+            super().debugshell(deps, tools)
+
+    def _report_errors(self, logbuffer):
+        """ Parses the build log and reports errors. """
+        with self.report() as report, utils.ignore_exception():
+            # GCC style errors
+            report.add_regex_errors_with_file(
+                "Compiler Error",
+                r"^(?P<location>(?P<file>.*?):(?P<line>[0-9]+):(?P<col>[0-9]+)): (?P<message>([^ ]*? )?(error:|[A-Z][0-9]*) .*)\n(?P<details>( ( |[0-9])*\| .*\n)+)?",
+                logbuffer,
+                self.outdir)
+
+            report.add_regex_errors_with_file(
+                "Compiler Warning",
+                r"^(?P<location>(?P<file>.*?):(?P<line>[0-9]+):(?P<col>[0-9]+)): (?P<message>([^ ]*? )?warning: .*)\n(?P<details>( ( |[0-9])*\| .*\n)+)?",
+                logbuffer,
+                self.outdir)
+
+            # MSVC compiler errors
+            report.add_regex_errors_with_file(
+                "Compiler Error",
+                r"^(?P<location>(?P<file>.*?)\((?P<line>[0-9]+)\)): (?P<message>(fatal )?error( C[0-9]*?): .*)",
+                logbuffer,
+                self.outdir)
+
+            # Binutils/MSVC linker errors
+            report.add_regex_errors(
+                "Linker Error",
+                r"^(?P<location>(?P<file>.*?)(:.*?)?)( )?: (?P<message>(( fatal)?error LNK|warning LNK|undefined reference|multiple definition).*)",
+                logbuffer)
+
+            # LLVM linker errors
+            report.add_regex_errors(
+                "Linker Error",
+                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
 
 
 class CXXLibrary(CXXProject):
@@ -1860,6 +2653,7 @@ class CXXLibrary(CXXProject):
         Include path metadata for this directory is automatically exported.
 
         """
+        super().publish(artifact, tools)
 
         with tools.cwd(self.outdir):
             if not self.shared:
@@ -1945,6 +2739,7 @@ class CXXExecutable(CXXProject):
         the executable to allow consumers to run it easily.
 
         """
+        super().publish(artifact, tools)
 
         with tools.cwd(self.outdir):
             if os.name == "nt":