jolt 0.9.123__py3-none-any.whl → 0.9.435__py3-none-any.whl

jolt/plugins/ninja.py

@@ -1,8 +1,11 @@
+from collections import OrderedDict
 import contextlib
 import copy
 import functools
-import ninja_syntax as ninja
+from ninja import ninja_syntax as ninja
 import os
+import platform
+import re
 import sys
 
 from jolt.tasks import Task, attributes as task_attributes
@@ -10,7 +13,6 @@ 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.loader import get_workspacedir
 from jolt.config import get_cachedir
 from jolt import log
 from jolt import utils
@@ -20,9 +22,18 @@ from jolt.error import raise_task_error_if
 from jolt.error import JoltError, JoltCommandError
 
 
+c_standard_default = None
+cxx_standard_default = None
+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:
@@ -96,13 +107,13 @@ class attributes:
                     self.info("Collecting coverage data into {covdatadir}")
 
                     for _, artifact in deps.items():
-                        if str(artifact.paths.coverage_data):
-                            tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                        if artifact.paths.coverage_data:
+                            tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
                     with tools.environ(GCOV_PREFIX=self.covdatadir):
                         yield
 
-                @functools.cache
+                @utils.cached.instance
                 def publish_coverage_data(self, artifact, tools):
                     if not publish:
                         return
@@ -149,9 +160,9 @@ class attributes:
         The following class attributes may be set to control the behavior
         of lcov:
 
-          - ``gcov_branches`` - Enable branch coverage.
+        - ``gcov_branches`` - Enable branch coverage.
           Passed as ``-b`` on the command line. Default: ``True``
-          - ``gcov_demangle`` - Display demangled function names in output.
+        - ``gcov_demangle`` - Display demangled function names in output.
           Passed as ``-m`` on the command line. Default: ``True``
 
         The task artifact is annotated with
@@ -192,34 +203,33 @@ class attributes:
                     if not hasattr(self, "covdatadir"):
                         self.covdatadir = tools.builddir("coverage-data")
                         for _, artifact in deps.items():
-                            if str(artifact.paths.coverage_data):
-                                tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                            if artifact.paths.coverage_data:
+                                tools.copy(str(artifact.paths.coverage_data), self.covdatadir)
 
                     with tools.cwd(self.covdatadir):
                         datafiles = tools.glob("**/*.gcda")
 
-                    with tools.cwd(tools.builddir("coverage-report-gcov")):
+                    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 ""
-                            tools.run("{} {}{}-p -s {covdatadir} {}",
-                                      gcov, branchflag, demangleflag, infile, output_on_error=True)
-
-                        wsdir = get_workspacedir()
-
-                        for file in tools.glob("^#^#*.gcov"):
-                            # Patch paths in gcov files.
-                            tools.replace_in_file(file, "Source:../../", "Source:")
-                            tools.replace_in_file(file, self.covdatadir, "")
-
-                            # Demangle and rename files into a tree directory structure.
-                            newfile = file.replace("^", "..").replace("#", os.sep)
-                            newfile = tools.expand_relpath(newfile, wsdir)
-                            tools.mkdirname(newfile)
-                            tools.move(file, newfile)
-
-                @functools.cache
+                            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
@@ -324,6 +334,19 @@ class attributes:
 
         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):
@@ -343,13 +366,12 @@ class attributes:
                     if not hasattr(self, "covdatadir"):
                         self.covdatadir = tools.builddir("coverage-data")
                         for _, artifact in deps.items():
-                            if str(artifact.paths.coverage_data):
-                                tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                            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()
-                    wsdir = get_workspacedir()
 
                     lcov_configs = list(getattr(self, "lcov_configs", []))
                     lcov_excludes = list(getattr(self, "lcov_excludes", []))
@@ -357,7 +379,7 @@ class attributes:
                     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", wsdir]
+                    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}")
@@ -370,7 +392,7 @@ class attributes:
                         lcov_configs.append("no_exception_branch=1")
 
                     if lcov_excludes:
-                        lcov_excludes = ["--exclude " + exclude for exclude in lcov_excludes]
+                        lcov_excludes = ["--exclude " + f"'{exclude}'" for exclude in lcov_excludes]
                         lcov_info_flags.extend(lcov_excludes)
 
                     if lcov_filters:
@@ -392,13 +414,22 @@ class attributes:
                         lcov_html_flags.extend(lcov_substitutes)
 
                     self.info("Generating LCOV code coverage report")
-                    tools.run("{} -c -d {covdatadir} -o {}/coverage.info --gcov-tool={} {}",
-                              lcov, reportdir, gcov, " ".join(lcov_info_flags), output_on_error=True)
+                    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 str(artifact.paths.coverage_report_lcov):
+                        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")
@@ -406,13 +437,14 @@ class attributes:
                                   lcov, " ".join(reports), reportdir, gcov, " ".join(lcov_info_flags), output_on_error=True)
 
                     with tools.cwd(reportdir):
-                        tools.replace_in_file("coverage.info", f"{wsdir}/", "")
+                        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:{wsdir}/")
-                        tools.replace_in_file("coverage.info.abs", f"SF:{wsdir}/" + "{{cachedir}}/", f"SF:{cachedir}/")
+                        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:
+                        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
 
@@ -421,7 +453,7 @@ class attributes:
                         tools.run("genhtml {}/coverage.info.abs --output-directory {} --title '{short_qualified_name}' {}",
                                   reportdir, htmldir, " ".join(lcov_html_flags), output_on_error=True)
 
-                @functools.cache
+                @utils.cached.instance
                 def publish_coverage_data(self, artifact, tools):
                     if not bool(getattr(self, "lcov_coverage_data", coverage_data)):
                         return
@@ -434,8 +466,8 @@ class attributes:
                 def publish_coverage_report_lcov_info(self, artifact, tools):
                     reportdir = tools.builddir("coverage-report-lcov")
                     with tools.cwd(reportdir):
-                        artifact.collect("coverage.info", "report/lcov/")
-                        artifact.paths.coverage_report_lcov = "report/lcov/coverage.info"
+                        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")
@@ -483,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):
         """
@@ -600,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)
@@ -611,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):
@@ -710,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
@@ -739,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", "")
@@ -865,7 +961,7 @@ 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 []
@@ -900,8 +996,8 @@ class Rule(HashInfluenceProvider):
         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 outfiles or self.outfiles:
@@ -918,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,
@@ -944,17 +1040,17 @@ class Rule(HashInfluenceProvider):
     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]
+            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.outdir) for outfile in implicit_outfiles]
+                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)
@@ -962,10 +1058,10 @@ class Rule(HashInfluenceProvider):
         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]
+                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.outdir) for outfile in implicit_outfiles]
+                    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)
@@ -998,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,
@@ -1044,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)
@@ -1112,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):
@@ -1187,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)
@@ -1270,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
 
@@ -1285,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):
@@ -1298,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
@@ -1370,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:
@@ -1410,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))
@@ -1477,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)
@@ -1490,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="")
@@ -1518,10 +1633,10 @@ 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 $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],
@@ -1530,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"],
@@ -1540,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"],
@@ -1575,51 +1690,100 @@ class GNUToolchain(Toolchain):
 
     linker = GNULinker(
         command=" && ".join([
-            "$ld $ldflags $imported_ldflags $extra_ldflags $covflags $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 $covflags $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):
@@ -1637,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, "msvcrt"):
+            crt = self._combine(project, crt, self._select_flag([str(dep.cxxinfo.msvcrt)]))
+        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, "msvcrt", 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 "MSVC-CRT"
+
+
 MSVCCompiler = GNUCompiler
 MSVCLinker = GNULinker
 MSVCDepImporter = GNUDepImporter
@@ -1647,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)
@@ -1656,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")
@@ -1677,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"])
 
@@ -1704,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}"},
@@ -1724,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]
 
@@ -1768,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: Compiler default
+
+    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: Compiler default
+
+    If the chosen standard is not supported, the nearest supported standard is selected.
+    """
+
     depimports = []
     """ List of implicit dependencies """
 
@@ -1789,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.
 
@@ -1823,8 +2087,7 @@ class CXXProject(Task):
     """ Name of the target binary (defaults to canonical task name) """
 
     coverage = False
-    """
-    Enable code coverage instrumentation.
+    """Enable code coverage instrumentation.
 
     Only implemented for GCC/Clang toolchains.
 
@@ -1834,11 +2097,12 @@ class CXXProject(Task):
     task artifact. Upon running the executable, coverage data files are
     generated.
 
-    Use the :func:`coverage_data` decorator to automatically collect and
-    publish data files in tasks that run instrumented binaries. The
-    :func:`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:`coverage_report_lcov` decorator that will
+    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:
@@ -1903,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 = []
 
@@ -1941,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):
@@ -1990,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)
@@ -2024,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:]:
@@ -2034,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()
@@ -2043,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):
@@ -2088,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)
@@ -2185,25 +2455,39 @@ 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._writer = self._write_ninja_file(self.outdir, 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(self.outdir):
+            with tools.cwd(tools.wsroot):
                 for obj in getattr(self._writer, "_objects", []):
                     obj, ext = os.path.splitext(obj)
                     obj = obj + ".gcno"
@@ -2213,19 +2497,20 @@ if __name__ == "__main__":
                         pass
             if self.selfsustained:
                 for _, artifact in deps.items():
-                    if str(artifact.paths.coverage_data):
-                        tools.copy(artifact.paths.coverage_data, self.covdatadir)
+                    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.
 
@@ -2242,41 +2527,58 @@ if __name__ == "__main__":
         self._expand_headers()
         self._expand_sources(deps, tools)
         self.outdir = tools.builddir("ninja", self.incremental)
+        self.outdir_rel = self.tools.expand_relpath(self.outdir, tools.wsroot)
         writer = self._write_ninja_file(self.outdir, 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:"))
-
-        # 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): (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):