@surgeapi/node 0.30.0 → 0.31.0

package/oidc/node_modules/npm/node_modules/node-gyp/gyp/pylib/gyp/generator/ninja.py

@@ -1,2957 +0,0 @@
-# Copyright (c) 2013 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-
-import collections
-import copy
-import ctypes
-import hashlib
-import json
-import multiprocessing
-import os.path
-import re
-import shutil
-import signal
-import subprocess
-import sys
-from io import StringIO
-
-import gyp
-import gyp.common
-import gyp.msvs_emulation
-import gyp.xcode_emulation
-from gyp import MSVSUtil, ninja_syntax
-from gyp.common import GetEnvironFallback
-
-generator_default_variables = {
-    "EXECUTABLE_PREFIX": "",
-    "EXECUTABLE_SUFFIX": "",
-    "STATIC_LIB_PREFIX": "lib",
-    "STATIC_LIB_SUFFIX": ".a",
-    "SHARED_LIB_PREFIX": "lib",
-    # Gyp expects the following variables to be expandable by the build
-    # system to the appropriate locations.  Ninja prefers paths to be
-    # known at gyp time.  To resolve this, introduce special
-    # variables starting with $! and $| (which begin with a $ so gyp knows it
-    # should be treated specially, but is otherwise an invalid
-    # ninja/shell variable) that are passed to gyp here but expanded
-    # before writing out into the target .ninja files; see
-    # ExpandSpecial.
-    # $! is used for variables that represent a path and that can only appear at
-    # the start of a string, while $| is used for variables that can appear
-    # anywhere in a string.
-    "INTERMEDIATE_DIR": "$!INTERMEDIATE_DIR",
-    "SHARED_INTERMEDIATE_DIR": "$!PRODUCT_DIR/gen",
-    "PRODUCT_DIR": "$!PRODUCT_DIR",
-    "CONFIGURATION_NAME": "$|CONFIGURATION_NAME",
-    # Special variables that may be used by gyp 'rule' targets.
-    # We generate definitions for these variables on the fly when processing a
-    # rule.
-    "RULE_INPUT_ROOT": "${root}",
-    "RULE_INPUT_DIRNAME": "${dirname}",
-    "RULE_INPUT_PATH": "${source}",
-    "RULE_INPUT_EXT": "${ext}",
-    "RULE_INPUT_NAME": "${name}",
-}
-
-# Placates pylint.
-generator_additional_non_configuration_keys = []
-generator_additional_path_sections = []
-generator_extra_sources_for_rules = []
-generator_filelist_paths = None
-
-generator_supports_multiple_toolsets = gyp.common.CrossCompileRequested()
-
-
-def StripPrefix(arg, prefix):
-    if arg.startswith(prefix):
-        return arg[len(prefix) :]
-    return arg
-
-
-def QuoteShellArgument(arg, flavor):
-    """Quote a string such that it will be interpreted as a single argument
-    by the shell."""
-    # Rather than attempting to enumerate the bad shell characters, just
-    # allow common OK ones and quote anything else.
-    if re.match(r"^[a-zA-Z0-9_=.\\/-]+$", arg):
-        return arg  # No quoting necessary.
-    if flavor == "win":
-        return gyp.msvs_emulation.QuoteForRspFile(arg)
-    return "'" + arg.replace("'", "'" + '"\'"' + "'") + "'"
-
-
-def Define(d, flavor):
-    """Takes a preprocessor define and returns a -D parameter that's ninja- and
-    shell-escaped."""
-    if flavor == "win":
-        # cl.exe replaces literal # characters with = in preprocessor definitions for
-        # some reason. Octal-encode to work around that.
-        d = d.replace("#", "\\%03o" % ord("#"))
-    return QuoteShellArgument(ninja_syntax.escape("-D" + d), flavor)
-
-
-def AddArch(output, arch):
-    """Adds an arch string to an output path."""
-    output, extension = os.path.splitext(output)
-    return f"{output}.{arch}{extension}"
-
-
-class Target:
-    """Target represents the paths used within a single gyp target.
-
-    Conceptually, building a single target A is a series of steps:
-
-    1) actions/rules/copies  generates source/resources/etc.
-    2) compiles              generates .o files
-    3) link                  generates a binary (library/executable)
-    4) bundle                merges the above in a mac bundle
-
-    (Any of these steps can be optional.)
-
-    From a build ordering perspective, a dependent target B could just
-    depend on the last output of this series of steps.
-
-    But some dependent commands sometimes need to reach inside the box.
-    For example, when linking B it needs to get the path to the static
-    library generated by A.
-
-    This object stores those paths.  To keep things simple, member
-    variables only store concrete paths to single files, while methods
-    compute derived values like "the last output of the target".
-    """
-
-    def __init__(self, type):
-        # Gyp type ("static_library", etc.) of this target.
-        self.type = type
-        # File representing whether any input dependencies necessary for
-        # dependent actions have completed.
-        self.preaction_stamp = None
-        # File representing whether any input dependencies necessary for
-        # dependent compiles have completed.
-        self.precompile_stamp = None
-        # File representing the completion of actions/rules/copies, if any.
-        self.actions_stamp = None
-        # Path to the output of the link step, if any.
-        self.binary = None
-        # Path to the file representing the completion of building the bundle,
-        # if any.
-        self.bundle = None
-        # On Windows, incremental linking requires linking against all the .objs
-        # that compose a .lib (rather than the .lib itself). That list is stored
-        # here. In this case, we also need to save the compile_deps for the target,
-        # so that the target that directly depends on the .objs can also depend
-        # on those.
-        self.component_objs = None
-        self.compile_deps = None
-        # Windows only. The import .lib is the output of a build step, but
-        # because dependents only link against the lib (not both the lib and the
-        # dll) we keep track of the import library here.
-        self.import_lib = None
-        # Track if this target contains any C++ files, to decide if gcc or g++
-        # should be used for linking.
-        self.uses_cpp = False
-
-    def Linkable(self):
-        """Return true if this is a target that can be linked against."""
-        return self.type in ("static_library", "shared_library")
-
-    def UsesToc(self, flavor):
-        """Return true if the target should produce a restat rule based on a TOC
-        file."""
-        # For bundles, the .TOC should be produced for the binary, not for
-        # FinalOutput(). But the naive approach would put the TOC file into the
-        # bundle, so don't do this for bundles for now.
-        if flavor == "win" or self.bundle:
-            return False
-        return self.type in ("shared_library", "loadable_module")
-
-    def PreActionInput(self, flavor):
-        """Return the path, if any, that should be used as a dependency of
-        any dependent action step."""
-        if self.UsesToc(flavor):
-            return self.FinalOutput() + ".TOC"
-        return self.FinalOutput() or self.preaction_stamp
-
-    def PreCompileInput(self):
-        """Return the path, if any, that should be used as a dependency of
-        any dependent compile step."""
-        return self.actions_stamp or self.precompile_stamp
-
-    def FinalOutput(self):
-        """Return the last output of the target, which depends on all prior
-        steps."""
-        return self.bundle or self.binary or self.actions_stamp
-
-
-# A small discourse on paths as used within the Ninja build:
-# All files we produce (both at gyp and at build time) appear in the
-# build directory (e.g. out/Debug).
-#
-# Paths within a given .gyp file are always relative to the directory
-# containing the .gyp file.  Call these "gyp paths".  This includes
-# sources as well as the starting directory a given gyp rule/action
-# expects to be run from.  We call the path from the source root to
-# the gyp file the "base directory" within the per-.gyp-file
-# NinjaWriter code.
-#
-# All paths as written into the .ninja files are relative to the build
-# directory.  Call these paths "ninja paths".
-#
-# We translate between these two notions of paths with two helper
-# functions:
-#
-# - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
-#   into the equivalent ninja path.
-#
-# - GypPathToUniqueOutput translates a gyp path into a ninja path to write
-#   an output file; the result can be namespaced such that it is unique
-#   to the input file name as well as the output target name.
-
-
-class NinjaWriter:
-    def __init__(
-        self,
-        hash_for_rules,
-        target_outputs,
-        base_dir,
-        build_dir,
-        output_file,
-        toplevel_build,
-        output_file_name,
-        flavor,
-        toplevel_dir=None,
-    ):
-        """
-        base_dir: path from source root to directory containing this gyp file,
-                  by gyp semantics, all input paths are relative to this
-        build_dir: path from source root to build output
-        toplevel_dir: path to the toplevel directory
-        """
-
-        self.hash_for_rules = hash_for_rules
-        self.target_outputs = target_outputs
-        self.base_dir = base_dir
-        self.build_dir = build_dir
-        self.ninja = ninja_syntax.Writer(output_file)
-        self.toplevel_build = toplevel_build
-        self.output_file_name = output_file_name
-
-        self.flavor = flavor
-        self.abs_build_dir = None
-        if toplevel_dir is not None:
-            self.abs_build_dir = os.path.abspath(os.path.join(toplevel_dir, build_dir))
-        self.obj_ext = ".obj" if flavor == "win" else ".o"
-        if flavor == "win":
-            # See docstring of msvs_emulation.GenerateEnvironmentFiles().
-            self.win_env = {}
-            for arch in ("x86", "x64"):
-                self.win_env[arch] = "environment." + arch
-
-        # Relative path from build output dir to base dir.
-        build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
-        self.build_to_base = os.path.join(build_to_top, base_dir)
-        # Relative path from base dir to build dir.
-        base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
-        self.base_to_build = os.path.join(base_to_top, build_dir)
-
-    def ExpandSpecial(self, path, product_dir=None):
-        """Expand specials like $!PRODUCT_DIR in |path|.
-
-        If |product_dir| is None, assumes the cwd is already the product
-        dir.  Otherwise, |product_dir| is the relative path to the product
-        dir.
-        """
-
-        if (PRODUCT_DIR := "$!PRODUCT_DIR") in path:
-            if product_dir:
-                path = path.replace(PRODUCT_DIR, product_dir)
-            else:
-                path = path.replace(PRODUCT_DIR + "/", "")
-                path = path.replace(PRODUCT_DIR + "\\", "")
-                path = path.replace(PRODUCT_DIR, ".")
-
-        if (INTERMEDIATE_DIR := "$!INTERMEDIATE_DIR") in path:
-            int_dir = self.GypPathToUniqueOutput("gen")
-            # GypPathToUniqueOutput generates a path relative to the product dir,
-            # so insert product_dir in front if it is provided.
-            path = path.replace(
-                INTERMEDIATE_DIR, os.path.join(product_dir or "", int_dir)
-            )
-
-        CONFIGURATION_NAME = "$|CONFIGURATION_NAME"
-        path = path.replace(CONFIGURATION_NAME, self.config_name)
-
-        return path
-
-    def ExpandRuleVariables(self, path, root, dirname, source, ext, name):
-        if self.flavor == "win":
-            path = self.msvs_settings.ConvertVSMacros(path, config=self.config_name)
-        path = path.replace(generator_default_variables["RULE_INPUT_ROOT"], root)
-        path = path.replace(generator_default_variables["RULE_INPUT_DIRNAME"], dirname)
-        path = path.replace(generator_default_variables["RULE_INPUT_PATH"], source)
-        path = path.replace(generator_default_variables["RULE_INPUT_EXT"], ext)
-        path = path.replace(generator_default_variables["RULE_INPUT_NAME"], name)
-        return path
-
-    def GypPathToNinja(self, path, env=None):
-        """Translate a gyp path to a ninja path, optionally expanding environment
-        variable references in |path| with |env|.
-
-        See the above discourse on path conversions."""
-        if env:
-            if self.flavor == "mac":
-                path = gyp.xcode_emulation.ExpandEnvVars(path, env)
-            elif self.flavor == "win":
-                path = gyp.msvs_emulation.ExpandMacros(path, env)
-        if path.startswith("$!"):
-            expanded = self.ExpandSpecial(path)
-            if self.flavor == "win":
-                expanded = os.path.normpath(expanded)
-            return expanded
-        if "$|" in path:
-            path = self.ExpandSpecial(path)
-        assert "$" not in path, path
-        return os.path.normpath(os.path.join(self.build_to_base, path))
-
-    def GypPathToUniqueOutput(self, path, qualified=True):
-        """Translate a gyp path to a ninja path for writing output.
-
-        If qualified is True, qualify the resulting filename with the name
-        of the target.  This is necessary when e.g. compiling the same
-        path twice for two separate output targets.
-
-        See the above discourse on path conversions."""
-
-        path = self.ExpandSpecial(path)
-        assert not path.startswith("$"), path
-
-        # Translate the path following this scheme:
-        #   Input: foo/bar.gyp, target targ, references baz/out.o
-        #   Output: obj/foo/baz/targ.out.o (if qualified)
-        #           obj/foo/baz/out.o (otherwise)
-        #     (and obj.host instead of obj for cross-compiles)
-        #
-        # Why this scheme and not some other one?
-        # 1) for a given input, you can compute all derived outputs by matching
-        #    its path, even if the input is brought via a gyp file with '..'.
-        # 2) simple files like libraries and stamps have a simple filename.
-
-        obj = "obj"
-        if self.toolset != "target":
-            obj += "." + self.toolset
-
-        path_dir, path_basename = os.path.split(path)
-        assert not os.path.isabs(path_dir), (
-            "'%s' can not be absolute path (see crbug.com/462153)." % path_dir
-        )
-
-        if qualified:
-            path_basename = self.name + "." + path_basename
-        return os.path.normpath(
-            os.path.join(obj, self.base_dir, path_dir, path_basename)
-        )
-
-    def WriteCollapsedDependencies(self, name, targets, order_only=None):
-        """Given a list of targets, return a path for a single file
-        representing the result of building all the targets or None.
-
-        Uses a stamp file if necessary."""
-
-        assert targets == [item for item in targets if item], targets
-        if len(targets) == 0:
-            assert not order_only
-            return None
-        if len(targets) > 1 or order_only:
-            stamp = self.GypPathToUniqueOutput(name + ".stamp")
-            targets = self.ninja.build(stamp, "stamp", targets, order_only=order_only)
-            self.ninja.newline()
-        return targets[0]
-
-    def _SubninjaNameForArch(self, arch):
-        output_file_base = os.path.splitext(self.output_file_name)[0]
-        return f"{output_file_base}.{arch}.ninja"
-
-    def WriteSpec(self, spec, config_name, generator_flags):
-        """The main entry point for NinjaWriter: write the build rules for a spec.
-
-        Returns a Target object, which represents the output paths for this spec.
-        Returns None if there are no outputs (e.g. a settings-only 'none' type
-        target)."""
-
-        self.config_name = config_name
-        self.name = spec["target_name"]
-        self.toolset = spec["toolset"]
-        config = spec["configurations"][config_name]
-        self.target = Target(spec["type"])
-        self.is_standalone_static_library = bool(
-            spec.get("standalone_static_library", 0)
-        )
-
-        self.target_rpath = generator_flags.get("target_rpath", r"\$$ORIGIN/lib/")
-
-        self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
-        self.xcode_settings = self.msvs_settings = None
-        if self.flavor == "mac":
-            self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
-            mac_toolchain_dir = generator_flags.get("mac_toolchain_dir", None)
-            if mac_toolchain_dir:
-                self.xcode_settings.mac_toolchain_dir = mac_toolchain_dir
-
-        if self.flavor == "win":
-            self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec, generator_flags)
-            arch = self.msvs_settings.GetArch(config_name)
-            self.ninja.variable("arch", self.win_env[arch])
-            self.ninja.variable("cc", "$cl_" + arch)
-            self.ninja.variable("cxx", "$cl_" + arch)
-            self.ninja.variable("cc_host", "$cl_" + arch)
-            self.ninja.variable("cxx_host", "$cl_" + arch)
-            self.ninja.variable("asm", "$ml_" + arch)
-
-        if self.flavor == "mac":
-            self.archs = self.xcode_settings.GetActiveArchs(config_name)
-            if len(self.archs) > 1:
-                self.arch_subninjas = {
-                    arch: ninja_syntax.Writer(
-                        OpenOutput(
-                            os.path.join(
-                                self.toplevel_build, self._SubninjaNameForArch(arch)
-                            ),
-                            "w",
-                        )
-                    )
-                    for arch in self.archs
-                }
-
-        # Compute predepends for all rules.
-        # actions_depends is the dependencies this target depends on before running
-        # any of its action/rule/copy steps.
-        # compile_depends is the dependencies this target depends on before running
-        # any of its compile steps.
-        actions_depends = []
-        compile_depends = []
-        # TODO(evan): it is rather confusing which things are lists and which
-        # are strings.  Fix these.
-        if "dependencies" in spec:
-            for dep in spec["dependencies"]:
-                if dep in self.target_outputs:
-                    target = self.target_outputs[dep]
-                    actions_depends.append(target.PreActionInput(self.flavor))
-                    compile_depends.append(target.PreCompileInput())
-                    if target.uses_cpp:
-                        self.target.uses_cpp = True
-            actions_depends = [item for item in actions_depends if item]
-            compile_depends = [item for item in compile_depends if item]
-            actions_depends = self.WriteCollapsedDependencies(
-                "actions_depends", actions_depends
-            )
-            compile_depends = self.WriteCollapsedDependencies(
-                "compile_depends", compile_depends
-            )
-            self.target.preaction_stamp = actions_depends
-            self.target.precompile_stamp = compile_depends
-
-        # Write out actions, rules, and copies.  These must happen before we
-        # compile any sources, so compute a list of predependencies for sources
-        # while we do it.
-        extra_sources = []
-        mac_bundle_depends = []
-        self.target.actions_stamp = self.WriteActionsRulesCopies(
-            spec, extra_sources, actions_depends, mac_bundle_depends
-        )
-
-        # If we have actions/rules/copies, we depend directly on those, but
-        # otherwise we depend on dependent target's actions/rules/copies etc.
-        # We never need to explicitly depend on previous target's link steps,
-        # because no compile ever depends on them.
-        compile_depends_stamp = self.target.actions_stamp or compile_depends
-
-        # Write out the compilation steps, if any.
-        link_deps = []
-        try:
-            sources = extra_sources + spec.get("sources", [])
-        except TypeError:
-            print("extra_sources: ", str(extra_sources))
-            print('spec.get("sources"): ', str(spec.get("sources")))
-            raise
-        if sources:
-            if self.flavor == "mac" and len(self.archs) > 1:
-                # Write subninja file containing compile and link commands scoped to
-                # a single arch if a fat binary is being built.
-                for arch in self.archs:
-                    self.ninja.subninja(self._SubninjaNameForArch(arch))
-
-            pch = None
-            if self.flavor == "win":
-                gyp.msvs_emulation.VerifyMissingSources(
-                    sources, self.abs_build_dir, generator_flags, self.GypPathToNinja
-                )
-                pch = gyp.msvs_emulation.PrecompiledHeader(
-                    self.msvs_settings,
-                    config_name,
-                    self.GypPathToNinja,
-                    self.GypPathToUniqueOutput,
-                    self.obj_ext,
-                )
-            else:
-                pch = gyp.xcode_emulation.MacPrefixHeader(
-                    self.xcode_settings,
-                    self.GypPathToNinja,
-                    lambda path, lang: self.GypPathToUniqueOutput(path + "-" + lang),
-                )
-            link_deps = self.WriteSources(
-                self.ninja,
-                config_name,
-                config,
-                sources,
-                compile_depends_stamp,
-                pch,
-                spec,
-            )
-            # Some actions/rules output 'sources' that are already object files.
-            obj_outputs = [f for f in sources if f.endswith(self.obj_ext)]
-            if obj_outputs:
-                if self.flavor != "mac" or len(self.archs) == 1:
-                    link_deps += [self.GypPathToNinja(o) for o in obj_outputs]
-                else:
-                    print(
-                        "Warning: Actions/rules writing object files don't work with "
-                        "multiarch targets, dropping. (target %s)" % spec["target_name"]
-                    )
-        elif self.flavor == "mac" and len(self.archs) > 1:
-            link_deps = collections.defaultdict(list)
-
-        compile_deps = self.target.actions_stamp or actions_depends
-        if self.flavor == "win" and self.target.type == "static_library":
-            self.target.component_objs = link_deps
-            self.target.compile_deps = compile_deps
-
-        # Write out a link step, if needed.
-        output = None
-        is_empty_bundle = not link_deps and not mac_bundle_depends
-        if link_deps or self.target.actions_stamp or actions_depends:
-            output = self.WriteTarget(
-                spec, config_name, config, link_deps, compile_deps
-            )
-            if self.is_mac_bundle:
-                mac_bundle_depends.append(output)
-
-        # Bundle all of the above together, if needed.
-        if self.is_mac_bundle:
-            output = self.WriteMacBundle(spec, mac_bundle_depends, is_empty_bundle)
-
-        if not output:
-            return None
-
-        assert self.target.FinalOutput(), output
-        return self.target
-
-    def _WinIdlRule(self, source, prebuild, outputs):
-        """Handle the implicit VS .idl rule for one source file. Fills |outputs|
-        with files that are generated."""
-        outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
-            source, self.config_name
-        )
-        outdir = self.GypPathToNinja(outdir)
-
-        def fix_path(path, rel=None):
-            path = os.path.join(outdir, path)
-            dirname, basename = os.path.split(source)
-            root, ext = os.path.splitext(basename)
-            path = self.ExpandRuleVariables(path, root, dirname, source, ext, basename)
-            if rel:
-                path = os.path.relpath(path, rel)
-            return path
-
-        vars = [(name, fix_path(value, outdir)) for name, value in vars]
-        output = [fix_path(p) for p in output]
-        vars.append(("outdir", outdir))
-        vars.append(("idlflags", flags))
-        input = self.GypPathToNinja(source)
-        self.ninja.build(output, "idl", input, variables=vars, order_only=prebuild)
-        outputs.extend(output)
-
-    def WriteWinIdlFiles(self, spec, prebuild):
-        """Writes rules to match MSVS's implicit idl handling."""
-        assert self.flavor == "win"
-        if self.msvs_settings.HasExplicitIdlRulesOrActions(spec):
-            return []
-        outputs = []
-        for source in filter(lambda x: x.endswith(".idl"), spec["sources"]):
-            self._WinIdlRule(source, prebuild, outputs)
-        return outputs
-
-    def WriteActionsRulesCopies(
-        self, spec, extra_sources, prebuild, mac_bundle_depends
-    ):
-        """Write out the Actions, Rules, and Copies steps.  Return a path
-        representing the outputs of these steps."""
-        outputs = []
-        if self.is_mac_bundle:
-            mac_bundle_resources = spec.get("mac_bundle_resources", [])[:]
-        else:
-            mac_bundle_resources = []
-        extra_mac_bundle_resources = []
-
-        if "actions" in spec:
-            outputs += self.WriteActions(
-                spec["actions"], extra_sources, prebuild, extra_mac_bundle_resources
-            )
-        if "rules" in spec:
-            outputs += self.WriteRules(
-                spec["rules"],
-                extra_sources,
-                prebuild,
-                mac_bundle_resources,
-                extra_mac_bundle_resources,
-            )
-        if "copies" in spec:
-            outputs += self.WriteCopies(spec["copies"], prebuild, mac_bundle_depends)
-
-        if "sources" in spec and self.flavor == "win":
-            outputs += self.WriteWinIdlFiles(spec, prebuild)
-
-        if self.xcode_settings and self.xcode_settings.IsIosFramework():
-            self.WriteiOSFrameworkHeaders(spec, outputs, prebuild)
-
-        stamp = self.WriteCollapsedDependencies("actions_rules_copies", outputs)
-
-        if self.is_mac_bundle:
-            xcassets = self.WriteMacBundleResources(
-                extra_mac_bundle_resources + mac_bundle_resources, mac_bundle_depends
-            )
-            partial_info_plist = self.WriteMacXCassets(xcassets, mac_bundle_depends)
-            self.WriteMacInfoPlist(partial_info_plist, mac_bundle_depends)
-
-        return stamp
-
-    def GenerateDescription(self, verb, message, fallback):
-        """Generate and return a description of a build step.
-
-        |verb| is the short summary, e.g. ACTION or RULE.
-        |message| is a hand-written description, or None if not available.
-        |fallback| is the gyp-level name of the step, usable as a fallback.
-        """
-        if self.toolset != "target":
-            verb += "(%s)" % self.toolset
-        if message:
-            return f"{verb} {self.ExpandSpecial(message)}"
-        else:
-            return f"{verb} {self.name}: {fallback}"
-
-    def WriteActions(
-        self, actions, extra_sources, prebuild, extra_mac_bundle_resources
-    ):
-        # Actions cd into the base directory.
-        env = self.GetToolchainEnv()
-        all_outputs = []
-        for action in actions:
-            # First write out a rule for the action.
-            name = "{}_{}".format(action["action_name"], self.hash_for_rules)
-            description = self.GenerateDescription(
-                "ACTION", action.get("message", None), name
-            )
-            win_shell_flags = (
-                self.msvs_settings.GetRuleShellFlags(action)
-                if self.flavor == "win"
-                else None
-            )
-            args = action["action"]
-            depfile = action.get("depfile", None)
-            if depfile:
-                depfile = self.ExpandSpecial(depfile, self.base_to_build)
-            pool = "console" if int(action.get("ninja_use_console", 0)) else None
-            rule_name, _ = self.WriteNewNinjaRule(
-                name, args, description, win_shell_flags, env, pool, depfile=depfile
-            )
-
-            inputs = [self.GypPathToNinja(i, env) for i in action["inputs"]]
-            if int(action.get("process_outputs_as_sources", False)):
-                extra_sources += action["outputs"]
-            if int(action.get("process_outputs_as_mac_bundle_resources", False)):
-                extra_mac_bundle_resources += action["outputs"]
-            outputs = [self.GypPathToNinja(o, env) for o in action["outputs"]]
-
-            # Then write out an edge using the rule.
-            self.ninja.build(outputs, rule_name, inputs, order_only=prebuild)
-            all_outputs += outputs
-
-            self.ninja.newline()
-
-        return all_outputs
-
-    def WriteRules(
-        self,
-        rules,
-        extra_sources,
-        prebuild,
-        mac_bundle_resources,
-        extra_mac_bundle_resources,
-    ):
-        env = self.GetToolchainEnv()
-        all_outputs = []
-        for rule in rules:
-            # Skip a rule with no action and no inputs.
-            if "action" not in rule and not rule.get("rule_sources", []):
-                continue
-
-            # First write out a rule for the rule action.
-            name = "{}_{}".format(rule["rule_name"], self.hash_for_rules)
-
-            args = rule["action"]
-            description = self.GenerateDescription(
-                "RULE",
-                rule.get("message", None),
-                ("%s " + generator_default_variables["RULE_INPUT_PATH"]) % name,
-            )
-            win_shell_flags = (
-                self.msvs_settings.GetRuleShellFlags(rule)
-                if self.flavor == "win"
-                else None
-            )
-            pool = "console" if int(rule.get("ninja_use_console", 0)) else None
-            rule_name, args = self.WriteNewNinjaRule(
-                name, args, description, win_shell_flags, env, pool
-            )
-
-            # TODO: if the command references the outputs directly, we should
-            # simplify it to just use $out.
-
-            # Rules can potentially make use of some special variables which
-            # must vary per source file.
-            # Compute the list of variables we'll need to provide.
-            special_locals = ("source", "root", "dirname", "ext", "name")
-            needed_variables = {"source"}
-            for argument in args:
-                for var in special_locals:
-                    if "${%s}" % var in argument:
-                        needed_variables.add(var)
-            needed_variables = sorted(needed_variables)
-
-            def cygwin_munge(path):
-                # pylint: disable=cell-var-from-loop
-                if win_shell_flags and win_shell_flags.cygwin:
-                    return path.replace("\\", "/")
-                return path
-
-            inputs = [self.GypPathToNinja(i, env) for i in rule.get("inputs", [])]
-
-            # If there are n source files matching the rule, and m additional rule
-            # inputs, then adding 'inputs' to each build edge written below will
-            # write m * n inputs. Collapsing reduces this to m + n.
-            sources = rule.get("rule_sources", [])
-            num_inputs = len(inputs)
-            if prebuild:
-                num_inputs += 1
-            if num_inputs > 2 and len(sources) > 2:
-                inputs = [
-                    self.WriteCollapsedDependencies(
-                        rule["rule_name"], inputs, order_only=prebuild
-                    )
-                ]
-                prebuild = []
-
-            # For each source file, write an edge that generates all the outputs.
-            for source in sources:
-                source = os.path.normpath(source)
-                dirname, basename = os.path.split(source)
-                root, ext = os.path.splitext(basename)
-
-                # Gather the list of inputs and outputs, expanding $vars if possible.
-                outputs = [
-                    self.ExpandRuleVariables(o, root, dirname, source, ext, basename)
-                    for o in rule["outputs"]
-                ]
-
-                if int(rule.get("process_outputs_as_sources", False)):
-                    extra_sources += outputs
-
-                was_mac_bundle_resource = source in mac_bundle_resources
-                if was_mac_bundle_resource or int(
-                    rule.get("process_outputs_as_mac_bundle_resources", False)
-                ):
-                    extra_mac_bundle_resources += outputs
-                    # Note: This is n_resources * n_outputs_in_rule.
-                    # Put to-be-removed items in a set and
-                    # remove them all in a single pass
-                    # if this becomes a performance issue.
-                    if was_mac_bundle_resource:
-                        mac_bundle_resources.remove(source)
-
-                extra_bindings = []
-                for var in needed_variables:
-                    if var == "root":
-                        extra_bindings.append(("root", cygwin_munge(root)))
-                    elif var == "dirname":
-                        # '$dirname' is a parameter to the rule action, which means
-                        # it shouldn't be converted to a Ninja path.  But we don't
-                        # want $!PRODUCT_DIR in there either.
-                        dirname_expanded = self.ExpandSpecial(
-                            dirname, self.base_to_build
-                        )
-                        extra_bindings.append(
-                            ("dirname", cygwin_munge(dirname_expanded))
-                        )
-                    elif var == "source":
-                        # '$source' is a parameter to the rule action, which means
-                        # it shouldn't be converted to a Ninja path.  But we don't
-                        # want $!PRODUCT_DIR in there either.
-                        source_expanded = self.ExpandSpecial(source, self.base_to_build)
-                        extra_bindings.append(("source", cygwin_munge(source_expanded)))
-                    elif var == "ext":
-                        extra_bindings.append(("ext", ext))
-                    elif var == "name":
-                        extra_bindings.append(("name", cygwin_munge(basename)))
-                    else:
-                        assert var is None, repr(var)
-
-                outputs = [self.GypPathToNinja(o, env) for o in outputs]
-                if self.flavor == "win":
-                    # WriteNewNinjaRule uses unique_name to create a rsp file on win.
-                    extra_bindings.append(
-                        ("unique_name", hashlib.md5(outputs[0]).hexdigest())
-                    )
-
-                self.ninja.build(
-                    outputs,
-                    rule_name,
-                    self.GypPathToNinja(source),
-                    implicit=inputs,
-                    order_only=prebuild,
-                    variables=extra_bindings,
-                )
-
-                all_outputs.extend(outputs)
-
-        return all_outputs
-
-    def WriteCopies(self, copies, prebuild, mac_bundle_depends):
-        outputs = []
-        if self.xcode_settings:
-            extra_env = self.xcode_settings.GetPerTargetSettings()
-            env = self.GetToolchainEnv(additional_settings=extra_env)
-        else:
-            env = self.GetToolchainEnv()
-        for to_copy in copies:
-            for path in to_copy["files"]:
-                # Normalize the path so trailing slashes don't confuse us.
-                path = os.path.normpath(path)
-                basename = os.path.split(path)[1]
-                src = self.GypPathToNinja(path, env)
-                dst = self.GypPathToNinja(
-                    os.path.join(to_copy["destination"], basename), env
-                )
-                outputs += self.ninja.build(dst, "copy", src, order_only=prebuild)
-                if self.is_mac_bundle:
-                    # gyp has mac_bundle_resources to copy things into a bundle's
-                    # Resources folder, but there's no built-in way to copy files
-                    # to other places in the bundle.
-                    # Hence, some targets use copies for this.
-                    # Check if this file is copied into the current bundle,
-                    # and if so add it to the bundle depends so
-                    # that dependent targets get rebuilt if the copy input changes.
-                    if dst.startswith(
-                        self.xcode_settings.GetBundleContentsFolderPath()
-                    ):
-                        mac_bundle_depends.append(dst)
-
-        return outputs
-
-    def WriteiOSFrameworkHeaders(self, spec, outputs, prebuild):
-        """Prebuild steps to generate hmap files and copy headers to destination."""
-        framework = self.ComputeMacBundleOutput()
-        all_sources = spec["sources"]
-        copy_headers = spec["mac_framework_headers"]
-        output = self.GypPathToUniqueOutput("headers.hmap")
-        self.xcode_settings.header_map_path = output
-        all_headers = map(
-            self.GypPathToNinja, filter(lambda x: x.endswith(".h"), all_sources)
-        )
-        variables = [
-            ("framework", framework),
-            ("copy_headers", map(self.GypPathToNinja, copy_headers)),
-        ]
-        outputs.extend(
-            self.ninja.build(
-                output,
-                "compile_ios_framework_headers",
-                all_headers,
-                variables=variables,
-                order_only=prebuild,
-            )
-        )
-
-    def WriteMacBundleResources(self, resources, bundle_depends):
-        """Writes ninja edges for 'mac_bundle_resources'."""
-        xcassets = []
-
-        extra_env = self.xcode_settings.GetPerTargetSettings()
-        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-        env = self.ComputeExportEnvString(env)
-        isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
-
-        for output, res in gyp.xcode_emulation.GetMacBundleResources(
-            generator_default_variables["PRODUCT_DIR"],
-            self.xcode_settings,
-            map(self.GypPathToNinja, resources),
-        ):
-            output = self.ExpandSpecial(output)
-            if os.path.splitext(output)[-1] != ".xcassets":
-                self.ninja.build(
-                    output,
-                    "mac_tool",
-                    res,
-                    variables=[
-                        ("mactool_cmd", "copy-bundle-resource"),
-                        ("env", env),
-                        ("binary", isBinary),
-                    ],
-                )
-                bundle_depends.append(output)
-            else:
-                xcassets.append(res)
-        return xcassets
-
-    def WriteMacXCassets(self, xcassets, bundle_depends):
-        """Writes ninja edges for 'mac_bundle_resources' .xcassets files.
-
-        This add an invocation of 'actool' via the 'mac_tool.py' helper script.
-        It assumes that the assets catalogs define at least one imageset and
-        thus an Assets.car file will be generated in the application resources
-        directory. If this is not the case, then the build will probably be done
-        at each invocation of ninja."""
-        if not xcassets:
-            return
-
-        extra_arguments = {}
-        settings_to_arg = {
-            "XCASSETS_APP_ICON": "app-icon",
-            "XCASSETS_LAUNCH_IMAGE": "launch-image",
-        }
-        settings = self.xcode_settings.xcode_settings[self.config_name]
-        for settings_key, arg_name in settings_to_arg.items():
-            value = settings.get(settings_key)
-            if value:
-                extra_arguments[arg_name] = value
-
-        partial_info_plist = None
-        if extra_arguments:
-            partial_info_plist = self.GypPathToUniqueOutput(
-                "assetcatalog_generated_info.plist"
-            )
-            extra_arguments["output-partial-info-plist"] = partial_info_plist
-
-        outputs = []
-        outputs.append(
-            os.path.join(self.xcode_settings.GetBundleResourceFolder(), "Assets.car")
-        )
-        if partial_info_plist:
-            outputs.append(partial_info_plist)
-
-        keys = QuoteShellArgument(json.dumps(extra_arguments), self.flavor)
-        extra_env = self.xcode_settings.GetPerTargetSettings()
-        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-        env = self.ComputeExportEnvString(env)
-
-        bundle_depends.extend(
-            self.ninja.build(
-                outputs,
-                "compile_xcassets",
-                xcassets,
-                variables=[("env", env), ("keys", keys)],
-            )
-        )
-        return partial_info_plist
-
-    def WriteMacInfoPlist(self, partial_info_plist, bundle_depends):
-        """Write build rules for bundle Info.plist files."""
-        info_plist, out, defines, extra_env = gyp.xcode_emulation.GetMacInfoPlist(
-            generator_default_variables["PRODUCT_DIR"],
-            self.xcode_settings,
-            self.GypPathToNinja,
-        )
-        if not info_plist:
-            return
-        out = self.ExpandSpecial(out)
-        if defines:
-            # Create an intermediate file to store preprocessed results.
-            intermediate_plist = self.GypPathToUniqueOutput(
-                os.path.basename(info_plist)
-            )
-            defines = " ".join([Define(d, self.flavor) for d in defines])
-            info_plist = self.ninja.build(
-                intermediate_plist,
-                "preprocess_infoplist",
-                info_plist,
-                variables=[("defines", defines)],
-            )
-
-        env = self.GetSortedXcodeEnv(additional_settings=extra_env)
-        env = self.ComputeExportEnvString(env)
-
-        if partial_info_plist:
-            intermediate_plist = self.GypPathToUniqueOutput("merged_info.plist")
-            info_plist = self.ninja.build(
-                intermediate_plist, "merge_infoplist", [partial_info_plist, info_plist]
-            )
-
-        keys = self.xcode_settings.GetExtraPlistItems(self.config_name)
-        keys = QuoteShellArgument(json.dumps(keys), self.flavor)
-        isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
-        self.ninja.build(
-            out,
-            "copy_infoplist",
-            info_plist,
-            variables=[("env", env), ("keys", keys), ("binary", isBinary)],
-        )
-        bundle_depends.append(out)
-
-    def WriteSources(
-        self,
-        ninja_file,
-        config_name,
-        config,
-        sources,
-        predepends,
-        precompiled_header,
-        spec,
-    ):
-        """Write build rules to compile all of |sources|."""
-        if self.toolset == "host":
-            self.ninja.variable("ar", "$ar_host")
-            self.ninja.variable("cc", "$cc_host")
-            self.ninja.variable("cxx", "$cxx_host")
-            self.ninja.variable("ld", "$ld_host")
-            self.ninja.variable("ldxx", "$ldxx_host")
-            self.ninja.variable("nm", "$nm_host")
-            self.ninja.variable("readelf", "$readelf_host")
-
-        if self.flavor != "mac" or len(self.archs) == 1:
-            return self.WriteSourcesForArch(
-                self.ninja,
-                config_name,
-                config,
-                sources,
-                predepends,
-                precompiled_header,
-                spec,
-            )
-        else:
-            return {
-                arch: self.WriteSourcesForArch(
-                    self.arch_subninjas[arch],
-                    config_name,
-                    config,
-                    sources,
-                    predepends,
-                    precompiled_header,
-                    spec,
-                    arch=arch,
-                )
-                for arch in self.archs
-            }
-
-    def WriteSourcesForArch(
-        self,
-        ninja_file,
-        config_name,
-        config,
-        sources,
-        predepends,
-        precompiled_header,
-        spec,
-        arch=None,
-    ):
-        """Write build rules to compile all of |sources|."""
-
-        extra_defines = []
-        if self.flavor == "mac":
-            cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
-            cflags_c = self.xcode_settings.GetCflagsC(config_name)
-            cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
-            cflags_objc = ["$cflags_c"] + self.xcode_settings.GetCflagsObjC(config_name)
-            cflags_objcc = ["$cflags_cc"] + self.xcode_settings.GetCflagsObjCC(
-                config_name
-            )
-        elif self.flavor == "win":
-            asmflags = self.msvs_settings.GetAsmflags(config_name)
-            cflags = self.msvs_settings.GetCflags(config_name)
-            cflags_c = self.msvs_settings.GetCflagsC(config_name)
-            cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
-            extra_defines = self.msvs_settings.GetComputedDefines(config_name)
-            # See comment at cc_command for why there's two .pdb files.
-            pdbpath_c = pdbpath_cc = self.msvs_settings.GetCompilerPdbName(
-                config_name, self.ExpandSpecial
-            )
-            if not pdbpath_c:
-                obj = "obj"
-                if self.toolset != "target":
-                    obj += "." + self.toolset
-                pdbpath = os.path.normpath(os.path.join(obj, self.base_dir, self.name))
-                pdbpath_c = pdbpath + ".c.pdb"
-                pdbpath_cc = pdbpath + ".cc.pdb"
-            self.WriteVariableList(ninja_file, "pdbname_c", [pdbpath_c])
-            self.WriteVariableList(ninja_file, "pdbname_cc", [pdbpath_cc])
-            self.WriteVariableList(ninja_file, "pchprefix", [self.name])
-        else:
-            cflags = config.get("cflags", [])
-            cflags_c = config.get("cflags_c", [])
-            cflags_cc = config.get("cflags_cc", [])
-
-        # Respect environment variables related to build, but target-specific
-        # flags can still override them.
-        if self.toolset == "target":
-            cflags_c = (
-                os.environ.get("CPPFLAGS", "").split()
-                + os.environ.get("CFLAGS", "").split()
-                + cflags_c
-            )
-            cflags_cc = (
-                os.environ.get("CPPFLAGS", "").split()
-                + os.environ.get("CXXFLAGS", "").split()
-                + cflags_cc
-            )
-        elif self.toolset == "host":
-            cflags_c = (
-                os.environ.get("CPPFLAGS_host", "").split()
-                + os.environ.get("CFLAGS_host", "").split()
-                + cflags_c
-            )
-            cflags_cc = (
-                os.environ.get("CPPFLAGS_host", "").split()
-                + os.environ.get("CXXFLAGS_host", "").split()
-                + cflags_cc
-            )
-
-        defines = config.get("defines", []) + extra_defines
-        self.WriteVariableList(
-            ninja_file, "defines", [Define(d, self.flavor) for d in defines]
-        )
-        if self.flavor == "win":
-            self.WriteVariableList(
-                ninja_file, "asmflags", map(self.ExpandSpecial, asmflags)
-            )
-            self.WriteVariableList(
-                ninja_file,
-                "rcflags",
-                [
-                    QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
-                    for f in self.msvs_settings.GetRcflags(
-                        config_name, self.GypPathToNinja
-                    )
-                ],
-            )
-
-        include_dirs = config.get("include_dirs", [])
-
-        env = self.GetToolchainEnv()
-        if self.flavor == "win":
-            include_dirs = self.msvs_settings.AdjustIncludeDirs(
-                include_dirs, config_name
-            )
-        self.WriteVariableList(
-            ninja_file,
-            "includes",
-            [
-                QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
-                for i in include_dirs
-            ],
-        )
-
-        if self.flavor == "win":
-            midl_include_dirs = config.get("midl_include_dirs", [])
-            midl_include_dirs = self.msvs_settings.AdjustMidlIncludeDirs(
-                midl_include_dirs, config_name
-            )
-            self.WriteVariableList(
-                ninja_file,
-                "midl_includes",
-                [
-                    QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
-                    for i in midl_include_dirs
-                ],
-            )
-
-        pch_commands = precompiled_header.GetPchBuildCommands(arch)
-        if self.flavor == "mac":
-            # Most targets use no precompiled headers, so only write these if needed.
-            for ext, var in [
-                ("c", "cflags_pch_c"),
-                ("cc", "cflags_pch_cc"),
-                ("m", "cflags_pch_objc"),
-                ("mm", "cflags_pch_objcc"),
-            ]:
-                include = precompiled_header.GetInclude(ext, arch)
-                if include:
-                    ninja_file.variable(var, include)
-
-        arflags = config.get("arflags", [])
-
-        self.WriteVariableList(ninja_file, "cflags", map(self.ExpandSpecial, cflags))
-        self.WriteVariableList(
-            ninja_file, "cflags_c", map(self.ExpandSpecial, cflags_c)
-        )
-        self.WriteVariableList(
-            ninja_file, "cflags_cc", map(self.ExpandSpecial, cflags_cc)
-        )
-        if self.flavor == "mac":
-            self.WriteVariableList(
-                ninja_file, "cflags_objc", map(self.ExpandSpecial, cflags_objc)
-            )
-            self.WriteVariableList(
-                ninja_file, "cflags_objcc", map(self.ExpandSpecial, cflags_objcc)
-            )
-        self.WriteVariableList(ninja_file, "arflags", map(self.ExpandSpecial, arflags))
-        ninja_file.newline()
-        outputs = []
-        has_rc_source = False
-        for source in sources:
-            filename, ext = os.path.splitext(source)
-            ext = ext[1:]
-            obj_ext = self.obj_ext
-            if ext in ("cc", "cpp", "cxx"):
-                command = "cxx"
-                self.target.uses_cpp = True
-            elif ext == "c" or (ext == "S" and self.flavor != "win"):
-                command = "cc"
-            elif ext == "s" and self.flavor != "win":  # Doesn't generate .o.d files.
-                command = "cc_s"
-            elif (
-                self.flavor == "win"
-                and ext in ("asm", "S")
-                and not self.msvs_settings.HasExplicitAsmRules(spec)
-            ):
-                command = "asm"
-                # Add the _asm suffix as msvs is capable of handling .cc and
-                # .asm files of the same name without collision.
-                obj_ext = "_asm.obj"
-            elif self.flavor == "mac" and ext == "m":
-                command = "objc"
-            elif self.flavor == "mac" and ext == "mm":
-                command = "objcxx"
-                self.target.uses_cpp = True
-            elif self.flavor == "win" and ext == "rc":
-                command = "rc"
-                obj_ext = ".res"
-                has_rc_source = True
-            else:
-                # Ignore unhandled extensions.
-                continue
-            input = self.GypPathToNinja(source)
-            output = self.GypPathToUniqueOutput(filename + obj_ext)
-            if arch is not None:
-                output = AddArch(output, arch)
-            implicit = precompiled_header.GetObjDependencies([input], [output], arch)
-            variables = []
-            if self.flavor == "win":
-                variables, output, implicit = precompiled_header.GetFlagsModifications(
-                    input,
-                    output,
-                    implicit,
-                    command,
-                    cflags_c,
-                    cflags_cc,
-                    self.ExpandSpecial,
-                )
-            ninja_file.build(
-                output,
-                command,
-                input,
-                implicit=[gch for _, _, gch in implicit],
-                order_only=predepends,
-                variables=variables,
-            )
-            outputs.append(output)
-
-        if has_rc_source:
-            resource_include_dirs = config.get("resource_include_dirs", include_dirs)
-            self.WriteVariableList(
-                ninja_file,
-                "resource_includes",
-                [
-                    QuoteShellArgument("-I" + self.GypPathToNinja(i, env), self.flavor)
-                    for i in resource_include_dirs
-                ],
-            )
-
-        self.WritePchTargets(ninja_file, pch_commands)
-
-        ninja_file.newline()
-        return outputs
-
-    def WritePchTargets(self, ninja_file, pch_commands):
-        """Writes ninja rules to compile prefix headers."""
-        if not pch_commands:
-            return
-
-        for gch, lang_flag, lang, input in pch_commands:
-            var_name = {
-                "c": "cflags_pch_c",
-                "cc": "cflags_pch_cc",
-                "m": "cflags_pch_objc",
-                "mm": "cflags_pch_objcc",
-            }[lang]
-
-            map = {
-                "c": "cc",
-                "cc": "cxx",
-                "m": "objc",
-                "mm": "objcxx",
-            }
-            cmd = map.get(lang)
-            ninja_file.build(gch, cmd, input, variables=[(var_name, lang_flag)])
-
-    def WriteLink(self, spec, config_name, config, link_deps, compile_deps):
-        """Write out a link step. Fills out target.binary."""
-        if self.flavor != "mac" or len(self.archs) == 1:
-            return self.WriteLinkForArch(
-                self.ninja, spec, config_name, config, link_deps, compile_deps
-            )
-        else:
-            output = self.ComputeOutput(spec)
-            inputs = [
-                self.WriteLinkForArch(
-                    self.arch_subninjas[arch],
-                    spec,
-                    config_name,
-                    config,
-                    link_deps[arch],
-                    compile_deps,
-                    arch=arch,
-                )
-                for arch in self.archs
-            ]
-            extra_bindings = []
-            build_output = output
-            if not self.is_mac_bundle:
-                self.AppendPostbuildVariable(extra_bindings, spec, output, output)
-
-            # TODO(yyanagisawa): more work needed to fix:
-            # https://code.google.com/p/gyp/issues/detail?id=411
-            if (
-                spec["type"] in ("shared_library", "loadable_module")
-                and not self.is_mac_bundle
-            ):
-                extra_bindings.append(("lib", output))
-                self.ninja.build(
-                    [output, output + ".TOC"],
-                    "solipo",
-                    inputs,
-                    variables=extra_bindings,
-                )
-            else:
-                self.ninja.build(build_output, "lipo", inputs, variables=extra_bindings)
-            return output
-
-    def WriteLinkForArch(
-        self, ninja_file, spec, config_name, config, link_deps, compile_deps, arch=None
-    ):
-        """Write out a link step. Fills out target.binary."""
-        command = {
-            "executable": "link",
-            "loadable_module": "solink_module",
-            "shared_library": "solink",
-        }[spec["type"]]
-        command_suffix = ""
-
-        implicit_deps = set()
-        solibs = set()
-        order_deps = set()
-
-        if compile_deps:
-            # Normally, the compiles of the target already depend on compile_deps,
-            # but a shared_library target might have no sources and only link together
-            # a few static_library deps, so the link step also needs to depend
-            # on compile_deps to make sure actions in the shared_library target
-            # get run before the link.
-            order_deps.add(compile_deps)
-
-        if "dependencies" in spec:
-            # Two kinds of dependencies:
-            # - Linkable dependencies (like a .a or a .so): add them to the link line.
-            # - Non-linkable dependencies (like a rule that generates a file
-            #   and writes a stamp file): add them to implicit_deps
-            extra_link_deps = set()
-            for dep in spec["dependencies"]:
-                target = self.target_outputs.get(dep)
-                if not target:
-                    continue
-                linkable = target.Linkable()
-                if linkable:
-                    new_deps = []
-                    if (
-                        self.flavor == "win"
-                        and target.component_objs
-                        and self.msvs_settings.IsUseLibraryDependencyInputs(config_name)
-                    ):
-                        new_deps = target.component_objs
-                        if target.compile_deps:
-                            order_deps.add(target.compile_deps)
-                    elif self.flavor == "win" and target.import_lib:
-                        new_deps = [target.import_lib]
-                    elif target.UsesToc(self.flavor):
-                        solibs.add(target.binary)
-                        implicit_deps.add(target.binary + ".TOC")
-                    else:
-                        new_deps = [target.binary]
-                    for new_dep in new_deps:
-                        if new_dep not in extra_link_deps:
-                            extra_link_deps.add(new_dep)
-                            link_deps.append(new_dep)
-
-                final_output = target.FinalOutput()
-                if not linkable or final_output != target.binary:
-                    implicit_deps.add(final_output)
-
-        extra_bindings = []
-        if self.target.uses_cpp and self.flavor != "win":
-            extra_bindings.append(("ld", "$ldxx"))
-
-        output = self.ComputeOutput(spec, arch)
-        if arch is None and not self.is_mac_bundle:
-            self.AppendPostbuildVariable(extra_bindings, spec, output, output)
-
-        is_executable = spec["type"] == "executable"
-        # The ldflags config key is not used on mac or win. On those platforms
-        # linker flags are set via xcode_settings and msvs_settings, respectively.
-        if self.toolset == "target":
-            env_ldflags = os.environ.get("LDFLAGS", "").split()
-        elif self.toolset == "host":
-            env_ldflags = os.environ.get("LDFLAGS_host", "").split()
-
-        if self.flavor == "mac":
-            ldflags = self.xcode_settings.GetLdflags(
-                config_name,
-                self.ExpandSpecial(generator_default_variables["PRODUCT_DIR"]),
-                self.GypPathToNinja,
-                arch,
-            )
-            ldflags = env_ldflags + ldflags
-        elif self.flavor == "win":
-            manifest_base_name = self.GypPathToUniqueOutput(
-                self.ComputeOutputFileName(spec)
-            )
-            (
-                ldflags,
-                intermediate_manifest,
-                manifest_files,
-            ) = self.msvs_settings.GetLdflags(
-                config_name,
-                self.GypPathToNinja,
-                self.ExpandSpecial,
-                manifest_base_name,
-                output,
-                is_executable,
-                self.toplevel_build,
-            )
-            ldflags = env_ldflags + ldflags
-            self.WriteVariableList(ninja_file, "manifests", manifest_files)
-            implicit_deps = implicit_deps.union(manifest_files)
-            if intermediate_manifest:
-                self.WriteVariableList(
-                    ninja_file, "intermediatemanifest", [intermediate_manifest]
-                )
-            command_suffix = _GetWinLinkRuleNameSuffix(
-                self.msvs_settings.IsEmbedManifest(config_name)
-            )
-            def_file = self.msvs_settings.GetDefFile(self.GypPathToNinja)
-            if def_file:
-                implicit_deps.add(def_file)
-        else:
-            # Respect environment variables related to build, but target-specific
-            # flags can still override them.
-            ldflags = env_ldflags + config.get("ldflags", [])
-            if is_executable and solibs:
-                rpath = "lib/"
-                if self.toolset != "target":
-                    rpath += self.toolset
-                    ldflags.append(r"-Wl,-rpath=\$$ORIGIN/%s" % rpath)
-                else:
-                    ldflags.append("-Wl,-rpath=%s" % self.target_rpath)
-                ldflags.append("-Wl,-rpath-link=%s" % rpath)
-        self.WriteVariableList(ninja_file, "ldflags", map(self.ExpandSpecial, ldflags))
-
-        library_dirs = config.get("library_dirs", [])
-        if self.flavor == "win":
-            library_dirs = [
-                self.msvs_settings.ConvertVSMacros(library_dir, config_name)
-                for library_dir in library_dirs
-            ]
-            library_dirs = [
-                "/LIBPATH:"
-                + QuoteShellArgument(self.GypPathToNinja(library_dir), self.flavor)
-                for library_dir in library_dirs
-            ]
-        else:
-            library_dirs = [
-                QuoteShellArgument("-L" + self.GypPathToNinja(library_dir), self.flavor)
-                for library_dir in library_dirs
-            ]
-
-        libraries = gyp.common.uniquer(
-            map(self.ExpandSpecial, spec.get("libraries", []))
-        )
-        if self.flavor == "mac":
-            libraries = self.xcode_settings.AdjustLibraries(libraries, config_name)
-        elif self.flavor == "win":
-            libraries = self.msvs_settings.AdjustLibraries(libraries)
-
-        self.WriteVariableList(ninja_file, "libs", library_dirs + libraries)
-
-        linked_binary = output
-
-        if command in ("solink", "solink_module"):
-            extra_bindings.append(("soname", os.path.split(output)[1]))
-            extra_bindings.append(("lib", gyp.common.EncodePOSIXShellArgument(output)))
-            if self.flavor != "win":
-                link_file_list = output
-                if self.is_mac_bundle:
-                    # 'Dependency Framework.framework/Versions/A/Dependency Framework'
-                    # -> 'Dependency Framework.framework.rsp'
-                    link_file_list = self.xcode_settings.GetWrapperName()
-                if arch:
-                    link_file_list += "." + arch
-                link_file_list += ".rsp"
-                # If an rspfile contains spaces, ninja surrounds the filename with
-                # quotes around it and then passes it to open(), creating a file with
-                # quotes in its name (and when looking for the rsp file, the name
-                # makes it through bash which strips the quotes) :-/
-                link_file_list = link_file_list.replace(" ", "_")
-                extra_bindings.append(
-                    (
-                        "link_file_list",
-                        gyp.common.EncodePOSIXShellArgument(link_file_list),
-                    )
-                )
-            if self.flavor == "win":
-                extra_bindings.append(("binary", output))
-                if (
-                    "/NOENTRY" not in ldflags
-                    and not self.msvs_settings.GetNoImportLibrary(config_name)
-                ):
-                    self.target.import_lib = output + ".lib"
-                    extra_bindings.append(
-                        ("implibflag", "/IMPLIB:%s" % self.target.import_lib)
-                    )
-                    pdbname = self.msvs_settings.GetPDBName(
-                        config_name, self.ExpandSpecial, output + ".pdb"
-                    )
-                    output = [output, self.target.import_lib]
-                    if pdbname:
-                        output.append(pdbname)
-            elif not self.is_mac_bundle:
-                output = [output, output + ".TOC"]
-            else:
-                command = command + "_notoc"
-        elif self.flavor == "win":
-            extra_bindings.append(("binary", output))
-            pdbname = self.msvs_settings.GetPDBName(
-                config_name, self.ExpandSpecial, output + ".pdb"
-            )
-            if pdbname:
-                output = [output, pdbname]
-
-        if solibs:
-            extra_bindings.append(
-                ("solibs", gyp.common.EncodePOSIXShellList(sorted(solibs)))
-            )
-
-        ninja_file.build(
-            output,
-            command + command_suffix,
-            link_deps,
-            implicit=sorted(implicit_deps),
-            order_only=list(order_deps),
-            variables=extra_bindings,
-        )
-        return linked_binary
-
-    def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
-        extra_link_deps = any(
-            self.target_outputs.get(dep).Linkable()
-            for dep in spec.get("dependencies", [])
-            if dep in self.target_outputs
-        )
-        if spec["type"] == "none" or (not link_deps and not extra_link_deps):
-            # TODO(evan): don't call this function for 'none' target types, as
-            # it doesn't do anything, and we fake out a 'binary' with a stamp file.
-            self.target.binary = compile_deps
-            self.target.type = "none"
-        elif spec["type"] == "static_library":
-            self.target.binary = self.ComputeOutput(spec)
-            if (
-                self.flavor not in ("ios", "mac", "netbsd", "openbsd", "win")
-                and not self.is_standalone_static_library
-            ):
-                self.ninja.build(
-                    self.target.binary, "alink_thin", link_deps, order_only=compile_deps
-                )
-            else:
-                variables = []
-                if self.xcode_settings:
-                    libtool_flags = self.xcode_settings.GetLibtoolflags(config_name)
-                    if libtool_flags:
-                        variables.append(("libtool_flags", libtool_flags))
-                if self.msvs_settings:
-                    libflags = self.msvs_settings.GetLibFlags(
-                        config_name, self.GypPathToNinja
-                    )
-                    variables.append(("libflags", libflags))
-
-                if self.flavor != "mac" or len(self.archs) == 1:
-                    self.AppendPostbuildVariable(
-                        variables, spec, self.target.binary, self.target.binary
-                    )
-                    self.ninja.build(
-                        self.target.binary,
-                        "alink",
-                        link_deps,
-                        order_only=compile_deps,
-                        variables=variables,
-                    )
-                else:
-                    inputs = []
-                    for arch in self.archs:
-                        output = self.ComputeOutput(spec, arch)
-                        self.arch_subninjas[arch].build(
-                            output,
-                            "alink",
-                            link_deps[arch],
-                            order_only=compile_deps,
-                            variables=variables,
-                        )
-                        inputs.append(output)
-                    # TODO: It's not clear if
-                    # libtool_flags should be passed to the alink
-                    # call that combines single-arch .a files into a fat .a file.
-                    self.AppendPostbuildVariable(
-                        variables, spec, self.target.binary, self.target.binary
-                    )
-                    self.ninja.build(
-                        self.target.binary,
-                        "alink",
-                        inputs,
-                        # FIXME: test proving order_only=compile_deps isn't
-                        # needed.
-                        variables=variables,
-                    )
-        else:
-            self.target.binary = self.WriteLink(
-                spec, config_name, config, link_deps, compile_deps
-            )
-        return self.target.binary
-
-    def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
-        assert self.is_mac_bundle
-        package_framework = spec["type"] in ("shared_library", "loadable_module")
-        output = self.ComputeMacBundleOutput()
-        if is_empty:
-            output += ".stamp"
-        variables = []
-        self.AppendPostbuildVariable(
-            variables,
-            spec,
-            output,
-            self.target.binary,
-            is_command_start=not package_framework,
-        )
-        if package_framework and not is_empty:
-            if spec["type"] == "shared_library" and self.xcode_settings.isIOS:
-                self.ninja.build(
-                    output,
-                    "package_ios_framework",
-                    mac_bundle_depends,
-                    variables=variables,
-                )
-            else:
-                variables.append(("version", self.xcode_settings.GetFrameworkVersion()))
-                self.ninja.build(
-                    output, "package_framework", mac_bundle_depends, variables=variables
-                )
-        else:
-            self.ninja.build(output, "stamp", mac_bundle_depends, variables=variables)
-        self.target.bundle = output
-        return output
-
-    def GetToolchainEnv(self, additional_settings=None):
-        """Returns the variables toolchain would set for build steps."""
-        env = self.GetSortedXcodeEnv(additional_settings=additional_settings)
-        if self.flavor == "win":
-            env = self.GetMsvsToolchainEnv(additional_settings=additional_settings)
-        return env
-
-    def GetMsvsToolchainEnv(self, additional_settings=None):
-        """Returns the variables Visual Studio would set for build steps."""
-        return self.msvs_settings.GetVSMacroEnv(
-            "$!PRODUCT_DIR", config=self.config_name
-        )
-
-    def GetSortedXcodeEnv(self, additional_settings=None):
-        """Returns the variables Xcode would set for build steps."""
-        assert self.abs_build_dir
-        abs_build_dir = self.abs_build_dir
-        return gyp.xcode_emulation.GetSortedXcodeEnv(
-            self.xcode_settings,
-            abs_build_dir,
-            os.path.join(abs_build_dir, self.build_to_base),
-            self.config_name,
-            additional_settings,
-        )
-
-    def GetSortedXcodePostbuildEnv(self):
-        """Returns the variables Xcode would set for postbuild steps."""
-        postbuild_settings = {}
-        # CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.
-        # TODO(thakis): It would be nice to have some general mechanism instead.
-        strip_save_file = self.xcode_settings.GetPerTargetSetting(
-            "CHROMIUM_STRIP_SAVE_FILE"
-        )
-        if strip_save_file:
-            postbuild_settings["CHROMIUM_STRIP_SAVE_FILE"] = strip_save_file
-        return self.GetSortedXcodeEnv(additional_settings=postbuild_settings)
-
-    def AppendPostbuildVariable(
-        self, variables, spec, output, binary, is_command_start=False
-    ):
-        """Adds a 'postbuild' variable if there is a postbuild for |output|."""
-        postbuild = self.GetPostbuildCommand(spec, output, binary, is_command_start)
-        if postbuild:
-            variables.append(("postbuilds", postbuild))
-
-    def GetPostbuildCommand(self, spec, output, output_binary, is_command_start):
-        """Returns a shell command that runs all the postbuilds, and removes
-        |output| if any of them fails. If |is_command_start| is False, then the
-        returned string will start with ' && '."""
-        if not self.xcode_settings or spec["type"] == "none" or not output:
-            return ""
-        output = QuoteShellArgument(output, self.flavor)
-        postbuilds = gyp.xcode_emulation.GetSpecPostbuildCommands(spec, quiet=True)
-        if output_binary is not None:
-            postbuilds = self.xcode_settings.AddImplicitPostbuilds(
-                self.config_name,
-                os.path.normpath(os.path.join(self.base_to_build, output)),
-                QuoteShellArgument(
-                    os.path.normpath(os.path.join(self.base_to_build, output_binary)),
-                    self.flavor,
-                ),
-                postbuilds,
-                quiet=True,
-            )
-
-        if not postbuilds:
-            return ""
-        # Postbuilds expect to be run in the gyp file's directory, so insert an
-        # implicit postbuild to cd to there.
-        postbuilds.insert(
-            0, gyp.common.EncodePOSIXShellList(["cd", self.build_to_base])
-        )
-        env = self.ComputeExportEnvString(self.GetSortedXcodePostbuildEnv())
-        # G will be non-null if any postbuild fails. Run all postbuilds in a
-        # subshell.
-        commands = (
-            env
-            + " ("
-            + " && ".join([ninja_syntax.escape(command) for command in postbuilds])
-        )
-        command_string = (
-            commands + "); G=$$?; "
-            # Remove the final output if any postbuild failed.
-            "((exit $$G) || rm -rf %s) " % output + "&& exit $$G)"
-        )
-        if is_command_start:
-            return "(" + command_string + " && "
-        else:
-            return "$ && (" + command_string
-
-    def ComputeExportEnvString(self, env):
-        """Given an environment, returns a string looking like
-            'export FOO=foo; export BAR="${FOO} bar;'
-        that exports |env| to the shell."""
-        export_str = []
-        for k, v in env:
-            export_str.append(
-                "export %s=%s;"
-                % (k, ninja_syntax.escape(gyp.common.EncodePOSIXShellArgument(v)))
-            )
-        return " ".join(export_str)
-
-    def ComputeMacBundleOutput(self):
-        """Return the 'output' (full output path) to a bundle output directory."""
-        assert self.is_mac_bundle
-        path = generator_default_variables["PRODUCT_DIR"]
-        return self.ExpandSpecial(
-            os.path.join(path, self.xcode_settings.GetWrapperName())
-        )
-
-    def ComputeOutputFileName(self, spec, type=None):
-        """Compute the filename of the final output for the current target."""
-        if not type:
-            type = spec["type"]
-
-        default_variables = copy.copy(generator_default_variables)
-        CalculateVariables(default_variables, {"flavor": self.flavor})
-
-        # Compute filename prefix: the product prefix, or a default for
-        # the product type.
-        DEFAULT_PREFIX = {
-            "loadable_module": default_variables["SHARED_LIB_PREFIX"],
-            "shared_library": default_variables["SHARED_LIB_PREFIX"],
-            "static_library": default_variables["STATIC_LIB_PREFIX"],
-            "executable": default_variables["EXECUTABLE_PREFIX"],
-        }
-        prefix = spec.get("product_prefix", DEFAULT_PREFIX.get(type, ""))
-
-        # Compute filename extension: the product extension, or a default
-        # for the product type.
-        DEFAULT_EXTENSION = {
-            "loadable_module": default_variables["SHARED_LIB_SUFFIX"],
-            "shared_library": default_variables["SHARED_LIB_SUFFIX"],
-            "static_library": default_variables["STATIC_LIB_SUFFIX"],
-            "executable": default_variables["EXECUTABLE_SUFFIX"],
-        }
-        extension = spec.get("product_extension")
-        extension = "." + extension if extension else DEFAULT_EXTENSION.get(type, "")
-
-        if "product_name" in spec:
-            # If we were given an explicit name, use that.
-            target = spec["product_name"]
-        else:
-            # Otherwise, derive a name from the target name.
-            target = spec["target_name"]
-            if prefix == "lib":
-                # Snip out an extra 'lib' from libs if appropriate.
-                target = StripPrefix(target, "lib")
-
-        if type in (
-            "static_library",
-            "loadable_module",
-            "shared_library",
-            "executable",
-        ):
-            return f"{prefix}{target}{extension}"
-        elif type == "none":
-            return "%s.stamp" % target
-        else:
-            raise Exception("Unhandled output type %s" % type)
-
-    def ComputeOutput(self, spec, arch=None):
-        """Compute the path for the final output of the spec."""
-        type = spec["type"]
-
-        if self.flavor == "win":
-            override = self.msvs_settings.GetOutputName(
-                self.config_name, self.ExpandSpecial
-            )
-            if override:
-                return override
-
-        if (
-            arch is None
-            and self.flavor == "mac"
-            and type
-            in ("static_library", "executable", "shared_library", "loadable_module")
-        ):
-            filename = self.xcode_settings.GetExecutablePath()
-        else:
-            filename = self.ComputeOutputFileName(spec, type)
-
-        if arch is None and "product_dir" in spec:
-            path = os.path.join(spec["product_dir"], filename)
-            return self.ExpandSpecial(path)
-
-        # Some products go into the output root, libraries go into shared library
-        # dir, and everything else goes into the normal place.
-        type_in_output_root = ["executable", "loadable_module"]
-        if self.flavor == "mac" and self.toolset == "target":
-            type_in_output_root += ["shared_library", "static_library"]
-        elif self.flavor == "win" and self.toolset == "target":
-            type_in_output_root += ["shared_library"]
-
-        if arch is not None:
-            # Make sure partial executables don't end up in a bundle or the regular
-            # output directory.
-            archdir = "arch"
-            if self.toolset != "target":
-                archdir = os.path.join("arch", "%s" % self.toolset)
-            return os.path.join(archdir, AddArch(filename, arch))
-        elif type in type_in_output_root or self.is_standalone_static_library:
-            return filename
-        elif type == "shared_library":
-            libdir = "lib"
-            if self.toolset != "target":
-                libdir = os.path.join("lib", "%s" % self.toolset)
-            return os.path.join(libdir, filename)
-        else:
-            return self.GypPathToUniqueOutput(filename, qualified=False)
-
-    def WriteVariableList(self, ninja_file, var, values):
-        assert not isinstance(values, str)
-        if values is None:
-            values = []
-        ninja_file.variable(var, " ".join(values))
-
-    def WriteNewNinjaRule(
-        self, name, args, description, win_shell_flags, env, pool, depfile=None
-    ):
-        """Write out a new ninja "rule" statement for a given command.
-
-        Returns the name of the new rule, and a copy of |args| with variables
-        expanded."""
-
-        if self.flavor == "win":
-            args = [
-                self.msvs_settings.ConvertVSMacros(
-                    arg, self.base_to_build, config=self.config_name
-                )
-                for arg in args
-            ]
-            description = self.msvs_settings.ConvertVSMacros(
-                description, config=self.config_name
-            )
-        elif self.flavor == "mac":
-            # |env| is an empty list on non-mac.
-            args = [gyp.xcode_emulation.ExpandEnvVars(arg, env) for arg in args]
-            description = gyp.xcode_emulation.ExpandEnvVars(description, env)
-
-        # TODO: we shouldn't need to qualify names; we do it because
-        # currently the ninja rule namespace is global, but it really
-        # should be scoped to the subninja.
-        rule_name = self.name
-        if self.toolset == "target":
-            rule_name += "." + self.toolset
-        rule_name += "." + name
-        rule_name = re.sub("[^a-zA-Z0-9_]", "_", rule_name)
-
-        # Remove variable references, but not if they refer to the magic rule
-        # variables.  This is not quite right, as it also protects these for
-        # actions, not just for rules where they are valid. Good enough.
-        protect = ["${root}", "${dirname}", "${source}", "${ext}", "${name}"]
-        protect = "(?!" + "|".join(map(re.escape, protect)) + ")"
-        description = re.sub(protect + r"\$", "_", description)
-
-        # gyp dictates that commands are run from the base directory.
-        # cd into the directory before running, and adjust paths in
-        # the arguments to point to the proper locations.
-        rspfile = None
-        rspfile_content = None
-        args = [self.ExpandSpecial(arg, self.base_to_build) for arg in args]
-        if self.flavor == "win":
-            rspfile = rule_name + ".$unique_name.rsp"
-            # The cygwin case handles this inside the bash sub-shell.
-            run_in = "" if win_shell_flags.cygwin else " " + self.build_to_base
-            if win_shell_flags.cygwin:
-                rspfile_content = self.msvs_settings.BuildCygwinBashCommandLine(
-                    args, self.build_to_base
-                )
-            else:
-                rspfile_content = gyp.msvs_emulation.EncodeRspFileList(
-                    args, win_shell_flags.quote
-                )
-            command = (
-                "%s gyp-win-tool action-wrapper $arch " % sys.executable
-                + rspfile
-                + run_in
-            )
-        else:
-            env = self.ComputeExportEnvString(env)
-            command = gyp.common.EncodePOSIXShellList(args)
-            command = "cd %s; " % self.build_to_base + env + command
-
-        # GYP rules/actions express being no-ops by not touching their outputs.
-        # Avoid executing downstream dependencies in this case by specifying
-        # restat=1 to ninja.
-        self.ninja.rule(
-            rule_name,
-            command,
-            description,
-            depfile=depfile,
-            restat=True,
-            pool=pool,
-            rspfile=rspfile,
-            rspfile_content=rspfile_content,
-        )
-        self.ninja.newline()
-
-        return rule_name, args
-
-
-def CalculateVariables(default_variables, params):
-    """Calculate additional variables for use in the build (called by gyp)."""
-    global generator_additional_non_configuration_keys
-    global generator_additional_path_sections
-    flavor = gyp.common.GetFlavor(params)
-    if flavor == "mac":
-        default_variables.setdefault("OS", "mac")
-        default_variables.setdefault("SHARED_LIB_SUFFIX", ".dylib")
-        default_variables.setdefault(
-            "SHARED_LIB_DIR", generator_default_variables["PRODUCT_DIR"]
-        )
-        default_variables.setdefault(
-            "LIB_DIR", generator_default_variables["PRODUCT_DIR"]
-        )
-
-        # Copy additional generator configuration data from Xcode, which is shared
-        # by the Mac Ninja generator.
-        import gyp.generator.xcode as xcode_generator  # noqa: PLC0415
-
-        generator_additional_non_configuration_keys = getattr(
-            xcode_generator, "generator_additional_non_configuration_keys", []
-        )
-        generator_additional_path_sections = getattr(
-            xcode_generator, "generator_additional_path_sections", []
-        )
-        global generator_extra_sources_for_rules
-        generator_extra_sources_for_rules = getattr(
-            xcode_generator, "generator_extra_sources_for_rules", []
-        )
-    elif flavor == "win":
-        exts = gyp.MSVSUtil.TARGET_TYPE_EXT
-        default_variables.setdefault("OS", "win")
-        default_variables["EXECUTABLE_SUFFIX"] = "." + exts["executable"]
-        default_variables["STATIC_LIB_PREFIX"] = ""
-        default_variables["STATIC_LIB_SUFFIX"] = "." + exts["static_library"]
-        default_variables["SHARED_LIB_PREFIX"] = ""
-        default_variables["SHARED_LIB_SUFFIX"] = "." + exts["shared_library"]
-
-        # Copy additional generator configuration data from VS, which is shared
-        # by the Windows Ninja generator.
-        import gyp.generator.msvs as msvs_generator  # noqa: PLC0415
-
-        generator_additional_non_configuration_keys = getattr(
-            msvs_generator, "generator_additional_non_configuration_keys", []
-        )
-        generator_additional_path_sections = getattr(
-            msvs_generator, "generator_additional_path_sections", []
-        )
-
-        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-    else:
-        operating_system = flavor
-        if flavor == "android":
-            operating_system = "linux"  # Keep this legacy behavior for now.
-        default_variables.setdefault("OS", operating_system)
-        default_variables.setdefault("SHARED_LIB_SUFFIX", ".so")
-        default_variables.setdefault(
-            "SHARED_LIB_DIR", os.path.join("$!PRODUCT_DIR", "lib")
-        )
-        default_variables.setdefault("LIB_DIR", os.path.join("$!PRODUCT_DIR", "obj"))
-
-
-def ComputeOutputDir(params):
-    """Returns the path from the toplevel_dir to the build output directory."""
-    # generator_dir: relative path from pwd to where make puts build files.
-    # Makes migrating from make to ninja easier, ninja doesn't put anything here.
-    generator_dir = os.path.relpath(params["options"].generator_output or ".")
-
-    # output_dir: relative path from generator_dir to the build directory.
-    output_dir = params.get("generator_flags", {}).get("output_dir", "out")
-
-    # Relative path from source root to our output files.  e.g. "out"
-    return os.path.normpath(os.path.join(generator_dir, output_dir))
-
-
-def CalculateGeneratorInputInfo(params):
-    """Called by __init__ to initialize generator values based on params."""
-    # E.g. "out/gypfiles"
-    toplevel = params["options"].toplevel_dir
-    qualified_out_dir = os.path.normpath(
-        os.path.join(toplevel, ComputeOutputDir(params), "gypfiles")
-    )
-
-    global generator_filelist_paths
-    generator_filelist_paths = {
-        "toplevel": toplevel,
-        "qualified_out_dir": qualified_out_dir,
-    }
-
-
-def OpenOutput(path, mode="w"):
-    """Open |path| for writing, creating directories if necessary."""
-    gyp.common.EnsureDirExists(path)
-    return open(path, mode)
-
-
-def CommandWithWrapper(cmd, wrappers, prog):
-    if wrapper := wrappers.get(cmd, ""):
-        return wrapper + " " + prog
-    return prog
-
-
-def GetDefaultConcurrentLinks():
-    """Returns a best-guess for a number of concurrent links."""
-    if pool_size := int(os.environ.get("GYP_LINK_CONCURRENCY") or 0):
-        return pool_size
-
-    if sys.platform in ("win32", "cygwin"):
-
-        class MEMORYSTATUSEX(ctypes.Structure):
-            _fields_ = [
-                ("dwLength", ctypes.c_ulong),
-                ("dwMemoryLoad", ctypes.c_ulong),
-                ("ullTotalPhys", ctypes.c_ulonglong),
-                ("ullAvailPhys", ctypes.c_ulonglong),
-                ("ullTotalPageFile", ctypes.c_ulonglong),
-                ("ullAvailPageFile", ctypes.c_ulonglong),
-                ("ullTotalVirtual", ctypes.c_ulonglong),
-                ("ullAvailVirtual", ctypes.c_ulonglong),
-                ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
-            ]
-
-        stat = MEMORYSTATUSEX()
-        stat.dwLength = ctypes.sizeof(stat)
-        ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
-
-        # VS 2015 uses 20% more working set than VS 2013 and can consume all RAM
-        # on a 64 GiB machine.
-        mem_limit = max(1, stat.ullTotalPhys // (5 * (2**30)))  # total / 5GiB
-        hard_cap = max(1, int(os.environ.get("GYP_LINK_CONCURRENCY_MAX") or 2**32))
-        return min(mem_limit, hard_cap)
-    elif sys.platform.startswith("linux"):
-        if os.path.exists("/proc/meminfo"):
-            with open("/proc/meminfo") as meminfo:
-                memtotal_re = re.compile(r"^MemTotal:\s*(\d*)\s*kB")
-                for line in meminfo:
-                    match = memtotal_re.match(line)
-                    if not match:
-                        continue
-                    # Allow 8Gb per link on Linux because Gold is quite memory hungry
-                    return max(1, int(match.group(1)) // (8 * (2**20)))
-        return 1
-    elif sys.platform == "darwin":
-        try:
-            avail_bytes = int(subprocess.check_output(["sysctl", "-n", "hw.memsize"]))
-            # A static library debug build of Chromium's unit_tests takes ~2.7GB, so
-            # 4GB per ld process allows for some more bloat.
-            return max(1, avail_bytes // (4 * (2**30)))  # total / 4GB
-        except subprocess.CalledProcessError:
-            return 1
-    else:
-        # TODO(scottmg): Implement this for other platforms.
-        return 1
-
-
-def _GetWinLinkRuleNameSuffix(embed_manifest):
-    """Returns the suffix used to select an appropriate linking rule depending on
-    whether the manifest embedding is enabled."""
-    return "_embed" if embed_manifest else ""
-
-
-def _AddWinLinkRules(master_ninja, embed_manifest):
-    """Adds link rules for Windows platform to |master_ninja|."""
-
-    def FullLinkCommand(ldcmd, out, binary_type):
-        resource_name = {"exe": "1", "dll": "2"}[binary_type]
-        return (
-            "%(python)s gyp-win-tool link-with-manifests $arch %(embed)s "
-            '%(out)s "%(ldcmd)s" %(resname)s $mt $rc "$intermediatemanifest" '
-            "$manifests"
-            % {
-                "python": sys.executable,
-                "out": out,
-                "ldcmd": ldcmd,
-                "resname": resource_name,
-                "embed": embed_manifest,
-            }
-        )
-
-    rule_name_suffix = _GetWinLinkRuleNameSuffix(embed_manifest)
-    use_separate_mspdbsrv = int(os.environ.get("GYP_USE_SEPARATE_MSPDBSRV", "0")) != 0
-    dlldesc = "LINK%s(DLL) $binary" % rule_name_suffix.upper()
-    dllcmd = (
-        "%s gyp-win-tool link-wrapper $arch %s "
-        "$ld /nologo $implibflag /DLL /OUT:$binary "
-        "@$binary.rsp" % (sys.executable, use_separate_mspdbsrv)
-    )
-    dllcmd = FullLinkCommand(dllcmd, "$binary", "dll")
-    master_ninja.rule(
-        "solink" + rule_name_suffix,
-        description=dlldesc,
-        command=dllcmd,
-        rspfile="$binary.rsp",
-        rspfile_content="$libs $in_newline $ldflags",
-        restat=True,
-        pool="link_pool",
-    )
-    master_ninja.rule(
-        "solink_module" + rule_name_suffix,
-        description=dlldesc,
-        command=dllcmd,
-        rspfile="$binary.rsp",
-        rspfile_content="$libs $in_newline $ldflags",
-        restat=True,
-        pool="link_pool",
-    )
-    # Note that ldflags goes at the end so that it has the option of
-    # overriding default settings earlier in the command line.
-    exe_cmd = (
-        "%s gyp-win-tool link-wrapper $arch %s "
-        "$ld /nologo /OUT:$binary @$binary.rsp"
-        % (sys.executable, use_separate_mspdbsrv)
-    )
-    exe_cmd = FullLinkCommand(exe_cmd, "$binary", "exe")
-    master_ninja.rule(
-        "link" + rule_name_suffix,
-        description="LINK%s $binary" % rule_name_suffix.upper(),
-        command=exe_cmd,
-        rspfile="$binary.rsp",
-        rspfile_content="$in_newline $libs $ldflags",
-        pool="link_pool",
-    )
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name):
-    options = params["options"]
-    flavor = gyp.common.GetFlavor(params)
-    generator_flags = params.get("generator_flags", {})
-    generate_compile_commands = generator_flags.get("compile_commands", False)
-
-    # build_dir: relative path from source root to our output files.
-    # e.g. "out/Debug"
-    build_dir = os.path.normpath(os.path.join(ComputeOutputDir(params), config_name))
-
-    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-
-    master_ninja_file = OpenOutput(os.path.join(toplevel_build, "build.ninja"))
-    master_ninja = ninja_syntax.Writer(master_ninja_file, width=120)
-
-    # Put build-time support tools in out/{config_name}.
-    gyp.common.CopyTool(flavor, toplevel_build, generator_flags)
-
-    # Grab make settings for CC/CXX.
-    # The rules are
-    # - The priority from low to high is gcc/g++, the 'make_global_settings' in
-    #   gyp, the environment variable.
-    # - If there is no 'make_global_settings' for CC.host/CXX.host or
-    #   'CC_host'/'CXX_host' environment variable, cc_host/cxx_host should be set
-    #   to cc/cxx.
-    if flavor == "win":
-        ar = "lib.exe"
-        # cc and cxx must be set to the correct architecture by overriding with one
-        # of cl_x86 or cl_x64 below.
-        cc = "UNSET"
-        cxx = "UNSET"
-        ld = "link.exe"
-        ld_host = "$ld"
-    else:
-        ar = "ar"
-        cc = "cc"
-        cxx = "c++"
-        ld = "$cc"
-        ldxx = "$cxx"
-        ld_host = "$cc_host"
-        ldxx_host = "$cxx_host"
-
-    ar_host = ar
-    cc_host = None
-    cxx_host = None
-    cc_host_global_setting = None
-    cxx_host_global_setting = None
-    clang_cl = None
-    nm = "nm"
-    nm_host = "nm"
-    readelf = "readelf"
-    readelf_host = "readelf"
-
-    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
-    make_global_settings = data[build_file].get("make_global_settings", [])
-    build_to_root = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
-    wrappers = {}
-    for key, value in make_global_settings:
-        if key == "AR":
-            ar = os.path.join(build_to_root, value)
-        if key == "AR.host":
-            ar_host = os.path.join(build_to_root, value)
-        if key == "CC":
-            cc = os.path.join(build_to_root, value)
-            if cc.endswith("clang-cl"):
-                clang_cl = cc
-        if key == "CXX":
-            cxx = os.path.join(build_to_root, value)
-        if key == "CC.host":
-            cc_host = os.path.join(build_to_root, value)
-            cc_host_global_setting = value
-        if key == "CXX.host":
-            cxx_host = os.path.join(build_to_root, value)
-            cxx_host_global_setting = value
-        if key == "LD":
-            ld = os.path.join(build_to_root, value)
-        if key == "LD.host":
-            ld_host = os.path.join(build_to_root, value)
-        if key == "LDXX":
-            ldxx = os.path.join(build_to_root, value)
-        if key == "LDXX.host":
-            ldxx_host = os.path.join(build_to_root, value)
-        if key == "NM":
-            nm = os.path.join(build_to_root, value)
-        if key == "NM.host":
-            nm_host = os.path.join(build_to_root, value)
-        if key == "READELF":
-            readelf = os.path.join(build_to_root, value)
-        if key == "READELF.host":
-            readelf_host = os.path.join(build_to_root, value)
-        if key.endswith("_wrapper"):
-            wrappers[key[: -len("_wrapper")]] = os.path.join(build_to_root, value)
-
-    # Support wrappers from environment variables too.
-    for key, value in os.environ.items():
-        if key.lower().endswith("_wrapper"):
-            key_prefix = key[: -len("_wrapper")]
-            key_prefix = re.sub(r"\.HOST$", ".host", key_prefix)
-            wrappers[key_prefix] = os.path.join(build_to_root, value)
-
-    if mac_toolchain_dir := generator_flags.get("mac_toolchain_dir", None):
-        wrappers["LINK"] = "export DEVELOPER_DIR='%s' &&" % mac_toolchain_dir
-
-    if flavor == "win":
-        configs = [
-            target_dicts[qualified_target]["configurations"][config_name]
-            for qualified_target in target_list
-        ]
-        shared_system_includes = None
-        if not generator_flags.get("ninja_use_custom_environment_files", 0):
-            shared_system_includes = gyp.msvs_emulation.ExtractSharedMSVSSystemIncludes(
-                configs, generator_flags
-            )
-        cl_paths = gyp.msvs_emulation.GenerateEnvironmentFiles(
-            toplevel_build, generator_flags, shared_system_includes, OpenOutput
-        )
-        for arch, path in sorted(cl_paths.items()):
-            if clang_cl:
-                # If we have selected clang-cl, use that instead.
-                path = clang_cl
-            command = CommandWithWrapper(
-                "CC", wrappers, QuoteShellArgument(path, "win")
-            )
-            if clang_cl:
-                # Use clang-cl to cross-compile for x86 or x86_64.
-                command += " -m32" if arch == "x86" else " -m64"
-            master_ninja.variable("cl_" + arch, command)
-
-    cc = GetEnvironFallback(["CC_target", "CC"], cc)
-    master_ninja.variable("cc", CommandWithWrapper("CC", wrappers, cc))
-    cxx = GetEnvironFallback(["CXX_target", "CXX"], cxx)
-    master_ninja.variable("cxx", CommandWithWrapper("CXX", wrappers, cxx))
-
-    if flavor == "win":
-        master_ninja.variable("ld", ld)
-        master_ninja.variable("idl", "midl.exe")
-        master_ninja.variable("ar", ar)
-        master_ninja.variable("rc", "rc.exe")
-        master_ninja.variable("ml_x86", "ml.exe")
-        master_ninja.variable("ml_x64", "ml64.exe")
-        master_ninja.variable("mt", "mt.exe")
-    else:
-        master_ninja.variable("ld", CommandWithWrapper("LINK", wrappers, ld))
-        master_ninja.variable("ldxx", CommandWithWrapper("LINK", wrappers, ldxx))
-        master_ninja.variable("ar", GetEnvironFallback(["AR_target", "AR"], ar))
-        if flavor != "mac":
-            # Mac does not use readelf/nm for .TOC generation, so avoiding polluting
-            # the master ninja with extra unused variables.
-            master_ninja.variable("nm", GetEnvironFallback(["NM_target", "NM"], nm))
-            master_ninja.variable(
-                "readelf", GetEnvironFallback(["READELF_target", "READELF"], readelf)
-            )
-
-    if generator_supports_multiple_toolsets:
-        if not cc_host:
-            cc_host = cc
-        if not cxx_host:
-            cxx_host = cxx
-
-        master_ninja.variable("ar_host", GetEnvironFallback(["AR_host"], ar_host))
-        master_ninja.variable("nm_host", GetEnvironFallback(["NM_host"], nm_host))
-        master_ninja.variable(
-            "readelf_host", GetEnvironFallback(["READELF_host"], readelf_host)
-        )
-        cc_host = GetEnvironFallback(["CC_host"], cc_host)
-        cxx_host = GetEnvironFallback(["CXX_host"], cxx_host)
-
-        # The environment variable could be used in 'make_global_settings', like
-        # ['CC.host', '$(CC)'] or ['CXX.host', '$(CXX)'], transform them here.
-        if "$(CC)" in cc_host and cc_host_global_setting:
-            cc_host = cc_host_global_setting.replace("$(CC)", cc)
-        if "$(CXX)" in cxx_host and cxx_host_global_setting:
-            cxx_host = cxx_host_global_setting.replace("$(CXX)", cxx)
-        master_ninja.variable(
-            "cc_host", CommandWithWrapper("CC.host", wrappers, cc_host)
-        )
-        master_ninja.variable(
-            "cxx_host", CommandWithWrapper("CXX.host", wrappers, cxx_host)
-        )
-        if flavor == "win":
-            master_ninja.variable("ld_host", ld_host)
-        else:
-            master_ninja.variable(
-                "ld_host", CommandWithWrapper("LINK", wrappers, ld_host)
-            )
-            master_ninja.variable(
-                "ldxx_host", CommandWithWrapper("LINK", wrappers, ldxx_host)
-            )
-
-    master_ninja.newline()
-
-    master_ninja.pool("link_pool", depth=GetDefaultConcurrentLinks())
-    master_ninja.newline()
-
-    deps = "msvc" if flavor == "win" else "gcc"
-
-    if flavor != "win":
-        master_ninja.rule(
-            "cc",
-            description="CC $out",
-            command=(
-                "$cc -MMD -MF $out.d $defines $includes $cflags $cflags_c "
-                "$cflags_pch_c -c $in -o $out"
-            ),
-            depfile="$out.d",
-            deps=deps,
-        )
-        master_ninja.rule(
-            "cc_s",
-            description="CC $out",
-            command=(
-                "$cc $defines $includes $cflags $cflags_c $cflags_pch_c -c $in -o $out"
-            ),
-        )
-        master_ninja.rule(
-            "cxx",
-            description="CXX $out",
-            command=(
-                "$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc "
-                "$cflags_pch_cc -c $in -o $out"
-            ),
-            depfile="$out.d",
-            deps=deps,
-        )
-    else:
-        # TODO(scottmg) Separate pdb names is a test to see if it works around
-        # http://crbug.com/142362. It seems there's a race between the creation of
-        # the .pdb by the precompiled header step for .cc and the compilation of
-        # .c files. This should be handled by mspdbsrv, but rarely errors out with
-        #   c1xx : fatal error C1033: cannot open program database
-        # By making the rules target separate pdb files this might be avoided.
-        cc_command = (
-            "ninja -t msvc -e $arch " + "-- "
-            "$cc /nologo /showIncludes /FC "
-            "@$out.rsp /c $in /Fo$out /Fd$pdbname_c "
-        )
-        cxx_command = (
-            "ninja -t msvc -e $arch " + "-- "
-            "$cxx /nologo /showIncludes /FC "
-            "@$out.rsp /c $in /Fo$out /Fd$pdbname_cc "
-        )
-        master_ninja.rule(
-            "cc",
-            description="CC $out",
-            command=cc_command,
-            rspfile="$out.rsp",
-            rspfile_content="$defines $includes $cflags $cflags_c",
-            deps=deps,
-        )
-        master_ninja.rule(
-            "cxx",
-            description="CXX $out",
-            command=cxx_command,
-            rspfile="$out.rsp",
-            rspfile_content="$defines $includes $cflags $cflags_cc",
-            deps=deps,
-        )
-        master_ninja.rule(
-            "idl",
-            description="IDL $in",
-            command=(
-                "%s gyp-win-tool midl-wrapper $arch $outdir "
-                "$tlb $h $dlldata $iid $proxy $in "
-                "$midl_includes $idlflags" % sys.executable
-            ),
-        )
-        master_ninja.rule(
-            "rc",
-            description="RC $in",
-            # Note: $in must be last otherwise rc.exe complains.
-            command=(
-                "%s gyp-win-tool rc-wrapper "
-                "$arch $rc $defines $resource_includes $rcflags /fo$out $in"
-                % sys.executable
-            ),
-        )
-        master_ninja.rule(
-            "asm",
-            description="ASM $out",
-            command=(
-                "%s gyp-win-tool asm-wrapper "
-                "$arch $asm $defines $includes $asmflags /c /Fo $out $in"
-                % sys.executable
-            ),
-        )
-
-    if flavor not in ("ios", "mac", "win"):
-        master_ninja.rule(
-            "alink",
-            description="AR $out",
-            command="rm -f $out && $ar rcs $arflags $out $in",
-        )
-        master_ninja.rule(
-            "alink_thin",
-            description="AR $out",
-            command="rm -f $out && $ar rcsT $arflags $out $in",
-        )
-
-        # This allows targets that only need to depend on $lib's API to declare an
-        # order-only dependency on $lib.TOC and avoid relinking such downstream
-        # dependencies when $lib changes only in non-public ways.
-        # The resulting string leaves an uninterpolated %{suffix} which
-        # is used in the final substitution below.
-        mtime_preserving_solink_base = (
-            "if [ ! -e $lib -o ! -e $lib.TOC ]; then "
-            "%(solink)s && %(extract_toc)s > $lib.TOC; else "
-            "%(solink)s && %(extract_toc)s > $lib.tmp && "
-            "if ! cmp -s $lib.tmp $lib.TOC; then mv $lib.tmp $lib.TOC ; "
-            "fi; fi"
-            % {
-                "solink": "$ld -shared $ldflags -o $lib -Wl,-soname=$soname %(suffix)s",
-                "extract_toc": (
-                    "{ $readelf -d $lib | grep SONAME ; "
-                    "$nm -gD -f p $lib | cut -f1-2 -d' '; }"
-                ),
-            }
-        )
-
-        master_ninja.rule(
-            "solink",
-            description="SOLINK $lib",
-            restat=True,
-            command=mtime_preserving_solink_base % {"suffix": "@$link_file_list"},
-            rspfile="$link_file_list",
-            rspfile_content=(
-                "-Wl,--whole-archive $in $solibs -Wl,--no-whole-archive $libs"
-            ),
-            pool="link_pool",
-        )
-        master_ninja.rule(
-            "solink_module",
-            description="SOLINK(module) $lib",
-            restat=True,
-            command=mtime_preserving_solink_base % {"suffix": "@$link_file_list"},
-            rspfile="$link_file_list",
-            rspfile_content="-Wl,--start-group $in $solibs $libs -Wl,--end-group",
-            pool="link_pool",
-        )
-        master_ninja.rule(
-            "link",
-            description="LINK $out",
-            command=(
-                "$ld $ldflags -o $out "
-                "-Wl,--start-group $in $solibs $libs -Wl,--end-group"
-            ),
-            pool="link_pool",
-        )
-    elif flavor == "win":
-        master_ninja.rule(
-            "alink",
-            description="LIB $out",
-            command=(
-                "%s gyp-win-tool link-wrapper $arch False "
-                "$ar /nologo /ignore:4221 /OUT:$out @$out.rsp" % sys.executable
-            ),
-            rspfile="$out.rsp",
-            rspfile_content="$in_newline $libflags",
-        )
-        _AddWinLinkRules(master_ninja, embed_manifest=True)
-        _AddWinLinkRules(master_ninja, embed_manifest=False)
-    else:
-        master_ninja.rule(
-            "objc",
-            description="OBJC $out",
-            command=(
-                "$cc -MMD -MF $out.d $defines $includes $cflags $cflags_objc "
-                "$cflags_pch_objc -c $in -o $out"
-            ),
-            depfile="$out.d",
-            deps=deps,
-        )
-        master_ninja.rule(
-            "objcxx",
-            description="OBJCXX $out",
-            command=(
-                "$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc "
-                "$cflags_pch_objcc -c $in -o $out"
-            ),
-            depfile="$out.d",
-            deps=deps,
-        )
-        master_ninja.rule(
-            "alink",
-            description="LIBTOOL-STATIC $out, POSTBUILDS",
-            command="rm -f $out && "
-            "%s gyp-mac-tool filter-libtool libtool $libtool_flags "
-            "-static -o $out $in"
-            "$postbuilds" % sys.executable,
-        )
-        master_ninja.rule(
-            "lipo",
-            description="LIPO $out, POSTBUILDS",
-            command="rm -f $out && lipo -create $in -output $out$postbuilds",
-        )
-        master_ninja.rule(
-            "solipo",
-            description="SOLIPO $out, POSTBUILDS",
-            command=(
-                "rm -f $lib $lib.TOC && lipo -create $in -output $lib$postbuilds &&"
-                "%(extract_toc)s > $lib.TOC"
-                % {
-                    "extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
-                    "nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }"
-                }
-            ),
-        )
-
-        # Record the public interface of $lib in $lib.TOC. See the corresponding
-        # comment in the posix section above for details.
-        solink_base = "$ld %(type)s $ldflags -o $lib %(suffix)s"
-        mtime_preserving_solink_base = (
-            "if [ ! -e $lib -o ! -e $lib.TOC ] || "
-            # Always force dependent targets to relink if this library
-            # reexports something. Handling this correctly would require
-            # recursive TOC dumping but this is rare in practice, so punt.
-            "otool -l $lib | grep -q LC_REEXPORT_DYLIB ; then "
-            "%(solink)s && %(extract_toc)s > $lib.TOC; "
-            "else "
-            "%(solink)s && %(extract_toc)s > $lib.tmp && "
-            "if ! cmp -s $lib.tmp $lib.TOC; then "
-            "mv $lib.tmp $lib.TOC ; "
-            "fi; "
-            "fi"
-            % {
-                "solink": solink_base,
-                "extract_toc": "{ otool -l $lib | grep LC_ID_DYLIB -A 5; "
-                "nm -gP $lib | cut -f1-2 -d' ' | grep -v U$$; true; }",
-            }
-        )
-
-        solink_suffix = "@$link_file_list$postbuilds"
-        master_ninja.rule(
-            "solink",
-            description="SOLINK $lib, POSTBUILDS",
-            restat=True,
-            command=mtime_preserving_solink_base
-            % {"suffix": solink_suffix, "type": "-shared"},
-            rspfile="$link_file_list",
-            rspfile_content="$in $solibs $libs",
-            pool="link_pool",
-        )
-        master_ninja.rule(
-            "solink_notoc",
-            description="SOLINK $lib, POSTBUILDS",
-            restat=True,
-            command=solink_base % {"suffix": solink_suffix, "type": "-shared"},
-            rspfile="$link_file_list",
-            rspfile_content="$in $solibs $libs",
-            pool="link_pool",
-        )
-
-        master_ninja.rule(
-            "solink_module",
-            description="SOLINK(module) $lib, POSTBUILDS",
-            restat=True,
-            command=mtime_preserving_solink_base
-            % {"suffix": solink_suffix, "type": "-bundle"},
-            rspfile="$link_file_list",
-            rspfile_content="$in $solibs $libs",
-            pool="link_pool",
-        )
-        master_ninja.rule(
-            "solink_module_notoc",
-            description="SOLINK(module) $lib, POSTBUILDS",
-            restat=True,
-            command=solink_base % {"suffix": solink_suffix, "type": "-bundle"},
-            rspfile="$link_file_list",
-            rspfile_content="$in $solibs $libs",
-            pool="link_pool",
-        )
-
-        master_ninja.rule(
-            "link",
-            description="LINK $out, POSTBUILDS",
-            command=("$ld $ldflags -o $out $in $solibs $libs$postbuilds"),
-            pool="link_pool",
-        )
-        master_ninja.rule(
-            "preprocess_infoplist",
-            description="PREPROCESS INFOPLIST $out",
-            command=(
-                "$cc -E -P -Wno-trigraphs -x c $defines $in -o $out && "
-                "plutil -convert xml1 $out $out"
-            ),
-        )
-        master_ninja.rule(
-            "copy_infoplist",
-            description="COPY INFOPLIST $in",
-            command="$env %s gyp-mac-tool copy-info-plist $in $out $binary $keys"
-            % sys.executable,
-        )
-        master_ninja.rule(
-            "merge_infoplist",
-            description="MERGE INFOPLISTS $in",
-            command="$env %s gyp-mac-tool merge-info-plist $out $in" % sys.executable,
-        )
-        master_ninja.rule(
-            "compile_xcassets",
-            description="COMPILE XCASSETS $in",
-            command="$env %s gyp-mac-tool compile-xcassets $keys $in" % sys.executable,
-        )
-        master_ninja.rule(
-            "compile_ios_framework_headers",
-            description="COMPILE HEADER MAPS AND COPY FRAMEWORK HEADERS $in",
-            command="$env %(python)s gyp-mac-tool compile-ios-framework-header-map "
-            "$out $framework $in && $env %(python)s gyp-mac-tool "
-            "copy-ios-framework-headers $framework $copy_headers"
-            % {"python": sys.executable},
-        )
-        master_ninja.rule(
-            "mac_tool",
-            description="MACTOOL $mactool_cmd $in",
-            command="$env %s gyp-mac-tool $mactool_cmd $in $out $binary"
-            % sys.executable,
-        )
-        master_ninja.rule(
-            "package_framework",
-            description="PACKAGE FRAMEWORK $out, POSTBUILDS",
-            command="%s gyp-mac-tool package-framework $out $version$postbuilds "
-            "&& touch $out" % sys.executable,
-        )
-        master_ninja.rule(
-            "package_ios_framework",
-            description="PACKAGE IOS FRAMEWORK $out, POSTBUILDS",
-            command="%s gyp-mac-tool package-ios-framework $out $postbuilds "
-            "&& touch $out" % sys.executable,
-        )
-    if flavor == "win":
-        master_ninja.rule(
-            "stamp",
-            description="STAMP $out",
-            command="%s gyp-win-tool stamp $out" % sys.executable,
-        )
-    else:
-        master_ninja.rule(
-            "stamp", description="STAMP $out", command="${postbuilds}touch $out"
-        )
-    if flavor == "win":
-        master_ninja.rule(
-            "copy",
-            description="COPY $in $out",
-            command="%s gyp-win-tool recursive-mirror $in $out" % sys.executable,
-        )
-    elif flavor == "zos":
-        master_ninja.rule(
-            "copy",
-            description="COPY $in $out",
-            command="rm -rf $out && cp -fRP $in $out",
-        )
-    else:
-        master_ninja.rule(
-            "copy",
-            description="COPY $in $out",
-            command="ln -f $in $out 2>/dev/null || (rm -rf $out && cp -af $in $out)",
-        )
-    master_ninja.newline()
-
-    all_targets = set()
-    for build_file in params["build_files"]:
-        for target in gyp.common.AllTargets(
-            target_list, target_dicts, os.path.normpath(build_file)
-        ):
-            all_targets.add(target)
-    all_outputs = set()
-
-    # target_outputs is a map from qualified target name to a Target object.
-    target_outputs = {}
-    # target_short_names is a map from target short name to a list of Target
-    # objects.
-    target_short_names = {}
-
-    # short name of targets that were skipped because they didn't contain anything
-    # interesting.
-    # NOTE: there may be overlap between this an non_empty_target_names.
-    empty_target_names = set()
-
-    # Set of non-empty short target names.
-    # NOTE: there may be overlap between this an empty_target_names.
-    non_empty_target_names = set()
-
-    for qualified_target in target_list:
-        # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
-        build_file, name, toolset = gyp.common.ParseQualifiedTarget(qualified_target)
-
-        this_make_global_settings = data[build_file].get("make_global_settings", [])
-        assert make_global_settings == this_make_global_settings, (
-            "make_global_settings needs to be the same for all targets. "
-            f"{this_make_global_settings} vs. {make_global_settings}"
-        )
-
-        spec = target_dicts[qualified_target]
-        if flavor == "mac":
-            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
-
-        # If build_file is a symlink, we must not follow it because there's a chance
-        # it could point to a path above toplevel_dir, and we cannot correctly deal
-        # with that case at the moment.
-        build_file = gyp.common.RelativePath(build_file, options.toplevel_dir, False)
-
-        qualified_target_for_hash = gyp.common.QualifiedTarget(
-            build_file, name, toolset
-        )
-        qualified_target_for_hash = qualified_target_for_hash.encode("utf-8")
-        hash_for_rules = hashlib.md5(qualified_target_for_hash).hexdigest()
-
-        base_path = os.path.dirname(build_file)
-        obj = "obj"
-        if toolset != "target":
-            obj += "." + toolset
-        output_file = os.path.join(obj, base_path, name + ".ninja")
-
-        ninja_output = StringIO()
-        writer = NinjaWriter(
-            hash_for_rules,
-            target_outputs,
-            base_path,
-            build_dir,
-            ninja_output,
-            toplevel_build,
-            output_file,
-            flavor,
-            toplevel_dir=options.toplevel_dir,
-        )
-
-        target = writer.WriteSpec(spec, config_name, generator_flags)
-
-        if ninja_output.tell() > 0:
-            # Only create files for ninja files that actually have contents.
-            with OpenOutput(os.path.join(toplevel_build, output_file)) as ninja_file:
-                ninja_file.write(ninja_output.getvalue())
-            ninja_output.close()
-            master_ninja.subninja(output_file)
-
-        if target:
-            if name != target.FinalOutput() and spec["toolset"] == "target":
-                target_short_names.setdefault(name, []).append(target)
-            target_outputs[qualified_target] = target
-            if qualified_target in all_targets:
-                all_outputs.add(target.FinalOutput())
-            non_empty_target_names.add(name)
-        else:
-            empty_target_names.add(name)
-
-    if target_short_names:
-        # Write a short name to build this target.  This benefits both the
-        # "build chrome" case as well as the gyp tests, which expect to be
-        # able to run actions and build libraries by their short name.
-        master_ninja.newline()
-        master_ninja.comment("Short names for targets.")
-        for short_name in sorted(target_short_names):
-            master_ninja.build(
-                short_name,
-                "phony",
-                [x.FinalOutput() for x in target_short_names[short_name]],
-            )
-
-    # Write phony targets for any empty targets that weren't written yet. As
-    # short names are  not necessarily unique only do this for short names that
-    # haven't already been output for another target.
-    empty_target_names = empty_target_names - non_empty_target_names
-    if empty_target_names:
-        master_ninja.newline()
-        master_ninja.comment("Empty targets (output for completeness).")
-        for name in sorted(empty_target_names):
-            master_ninja.build(name, "phony")
-
-    if all_outputs:
-        master_ninja.newline()
-        master_ninja.build("all", "phony", sorted(all_outputs))
-        master_ninja.default(generator_flags.get("default_target", "all"))
-
-    master_ninja_file.close()
-
-    if generate_compile_commands:
-        compile_db = GenerateCompileDBWithNinja(toplevel_build)
-        compile_db_file = OpenOutput(
-            os.path.join(toplevel_build, "compile_commands.json")
-        )
-        compile_db_file.write(json.dumps(compile_db, indent=2))
-        compile_db_file.close()
-
-
-def GenerateCompileDBWithNinja(path, targets=["all"]):
-    """Generates a compile database using ninja.
-
-    Args:
-        path: The build directory to generate a compile database for.
-        targets: Additional targets to pass to ninja.
-
-    Returns:
-        List of the contents of the compile database.
-    """
-    ninja_path = shutil.which("ninja")
-    if ninja_path is None:
-        raise Exception("ninja not found in PATH")
-    json_compile_db = subprocess.check_output(
-        [ninja_path, "-C", path]
-        + targets
-        + ["-t", "compdb", "cc", "cxx", "objc", "objcxx"]
-    )
-    return json.loads(json_compile_db)
-
-
-def PerformBuild(data, configurations, params):
-    options = params["options"]
-    for config in configurations:
-        builddir = os.path.join(options.toplevel_dir, "out", config)
-        arguments = ["ninja", "-C", builddir]
-        print(f"Building [{config}]: {arguments}")
-        subprocess.check_call(arguments)
-
-
-def CallGenerateOutputForConfig(arglist):
-    # Ignore the interrupt signal so that the parent process catches it and
-    # kills all multiprocessing children.
-    signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-    (target_list, target_dicts, data, params, config_name) = arglist
-    GenerateOutputForConfig(target_list, target_dicts, data, params, config_name)
-
-
-def GenerateOutput(target_list, target_dicts, data, params):
-    # Update target_dicts for iOS device builds.
-    target_dicts = gyp.xcode_emulation.CloneConfigurationForDeviceAndEmulator(
-        target_dicts
-    )
-
-    user_config = params.get("generator_flags", {}).get("config", None)
-    if gyp.common.GetFlavor(params) == "win":
-        target_list, target_dicts = MSVSUtil.ShardTargets(target_list, target_dicts)
-        target_list, target_dicts = MSVSUtil.InsertLargePdbShims(
-            target_list, target_dicts, generator_default_variables
-        )
-
-    if user_config:
-        GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
-    else:
-        config_names = target_dicts[target_list[0]]["configurations"]
-        if params["parallel"]:
-            try:
-                pool = multiprocessing.Pool(len(config_names))
-                arglists = []
-                for config_name in config_names:
-                    arglists.append(
-                        (target_list, target_dicts, data, params, config_name)
-                    )
-                pool.map(CallGenerateOutputForConfig, arglists)
-            except KeyboardInterrupt as e:
-                pool.terminate()
-                raise e
-        else:
-            for config_name in config_names:
-                GenerateOutputForConfig(
-                    target_list, target_dicts, data, params, config_name
-                )