@geoinsight/react-components 1.0.6 → 1.0.7

package/.yarn/unplugged/node-gyp-npm-10.0.1-48708ce70b/node_modules/node-gyp/gyp/pylib/gyp/generator/cmake.py

@@ -1,1318 +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.
-
-"""cmake output module
-
-This module is under development and should be considered experimental.
-
-This module produces cmake (2.8.8+) input as its output. One CMakeLists.txt is
-created for each configuration.
-
-This module's original purpose was to support editing in IDEs like KDevelop
-which use CMake for project management. It is also possible to use CMake to
-generate projects for other IDEs such as eclipse cdt and code::blocks. QtCreator
-will convert the CMakeLists.txt to a code::blocks cbp for the editor to read,
-but build using CMake. As a result QtCreator editor is unaware of compiler
-defines. The generated CMakeLists.txt can also be used to build on Linux. There
-is currently no support for building on platforms other than Linux.
-
-The generated CMakeLists.txt should properly compile all projects. However,
-there is a mismatch between gyp and cmake with regard to linking. All attempts
-are made to work around this, but CMake sometimes sees -Wl,--start-group as a
-library and incorrectly repeats it. As a result the output of this generator
-should not be relied on for building.
-
-When using with kdevelop, use version 4.4+. Previous versions of kdevelop will
-not be able to find the header file directories described in the generated
-CMakeLists.txt file.
-"""
-
-
-import multiprocessing
-import os
-import signal
-import subprocess
-import gyp.common
-import gyp.xcode_emulation
-
-_maketrans = str.maketrans
-
-generator_default_variables = {
-    "EXECUTABLE_PREFIX": "",
-    "EXECUTABLE_SUFFIX": "",
-    "STATIC_LIB_PREFIX": "lib",
-    "STATIC_LIB_SUFFIX": ".a",
-    "SHARED_LIB_PREFIX": "lib",
-    "SHARED_LIB_SUFFIX": ".so",
-    "SHARED_LIB_DIR": "${builddir}/lib.${TOOLSET}",
-    "LIB_DIR": "${obj}.${TOOLSET}",
-    "INTERMEDIATE_DIR": "${obj}.${TOOLSET}/${TARGET}/geni",
-    "SHARED_INTERMEDIATE_DIR": "${obj}/gen",
-    "PRODUCT_DIR": "${builddir}",
-    "RULE_INPUT_PATH": "${RULE_INPUT_PATH}",
-    "RULE_INPUT_DIRNAME": "${RULE_INPUT_DIRNAME}",
-    "RULE_INPUT_NAME": "${RULE_INPUT_NAME}",
-    "RULE_INPUT_ROOT": "${RULE_INPUT_ROOT}",
-    "RULE_INPUT_EXT": "${RULE_INPUT_EXT}",
-    "CONFIGURATION_NAME": "${configuration}",
-}
-
-FULL_PATH_VARS = ("${CMAKE_CURRENT_LIST_DIR}", "${builddir}", "${obj}")
-
-generator_supports_multiple_toolsets = True
-generator_wants_static_library_dependencies_adjusted = True
-
-COMPILABLE_EXTENSIONS = {
-    ".c": "cc",
-    ".cc": "cxx",
-    ".cpp": "cxx",
-    ".cxx": "cxx",
-    ".s": "s",  # cc
-    ".S": "s",  # cc
-}
-
-
-def RemovePrefix(a, prefix):
-    """Returns 'a' without 'prefix' if it starts with 'prefix'."""
-    return a[len(prefix) :] if a.startswith(prefix) else a
-
-
-def CalculateVariables(default_variables, params):
-    """Calculate additional variables for use in the build (called by gyp)."""
-    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
-
-
-def Compilable(filename):
-    """Return true if the file is compilable (should be in OBJS)."""
-    return any(filename.endswith(e) for e in COMPILABLE_EXTENSIONS)
-
-
-def Linkable(filename):
-    """Return true if the file is linkable (should be on the link line)."""
-    return filename.endswith(".o")
-
-
-def NormjoinPathForceCMakeSource(base_path, rel_path):
-    """Resolves rel_path against base_path and returns the result.
-
-  If rel_path is an absolute path it is returned unchanged.
-  Otherwise it is resolved against base_path and normalized.
-  If the result is a relative path, it is forced to be relative to the
-  CMakeLists.txt.
-  """
-    if os.path.isabs(rel_path):
-        return rel_path
-    if any(rel_path.startswith(var) for var in FULL_PATH_VARS):
-        return rel_path
-    # TODO: do we need to check base_path for absolute variables as well?
-    return os.path.join(
-        "${CMAKE_CURRENT_LIST_DIR}", os.path.normpath(os.path.join(base_path, rel_path))
-    )
-
-
-def NormjoinPath(base_path, rel_path):
-    """Resolves rel_path against base_path and returns the result.
-  TODO: what is this really used for?
-  If rel_path begins with '$' it is returned unchanged.
-  Otherwise it is resolved against base_path if relative, then normalized.
-  """
-    if rel_path.startswith("$") and not rel_path.startswith("${configuration}"):
-        return rel_path
-    return os.path.normpath(os.path.join(base_path, rel_path))
-
-
-def CMakeStringEscape(a):
-    """Escapes the string 'a' for use inside a CMake string.
-
-  This means escaping
-  '\' otherwise it may be seen as modifying the next character
-  '"' otherwise it will end the string
-  ';' otherwise the string becomes a list
-
-  The following do not need to be escaped
-  '#' when the lexer is in string state, this does not start a comment
-
-  The following are yet unknown
-  '$' generator variables (like ${obj}) must not be escaped,
-      but text $ should be escaped
-      what is wanted is to know which $ come from generator variables
-  """
-    return a.replace("\\", "\\\\").replace(";", "\\;").replace('"', '\\"')
-
-
-def SetFileProperty(output, source_name, property_name, values, sep):
-    """Given a set of source file, sets the given property on them."""
-    output.write("set_source_files_properties(")
-    output.write(source_name)
-    output.write(" PROPERTIES ")
-    output.write(property_name)
-    output.write(' "')
-    for value in values:
-        output.write(CMakeStringEscape(value))
-        output.write(sep)
-    output.write('")\n')
-
-
-def SetFilesProperty(output, variable, property_name, values, sep):
-    """Given a set of source files, sets the given property on them."""
-    output.write("set_source_files_properties(")
-    WriteVariable(output, variable)
-    output.write(" PROPERTIES ")
-    output.write(property_name)
-    output.write(' "')
-    for value in values:
-        output.write(CMakeStringEscape(value))
-        output.write(sep)
-    output.write('")\n')
-
-
-def SetTargetProperty(output, target_name, property_name, values, sep=""):
-    """Given a target, sets the given property."""
-    output.write("set_target_properties(")
-    output.write(target_name)
-    output.write(" PROPERTIES ")
-    output.write(property_name)
-    output.write(' "')
-    for value in values:
-        output.write(CMakeStringEscape(value))
-        output.write(sep)
-    output.write('")\n')
-
-
-def SetVariable(output, variable_name, value):
-    """Sets a CMake variable."""
-    output.write("set(")
-    output.write(variable_name)
-    output.write(' "')
-    output.write(CMakeStringEscape(value))
-    output.write('")\n')
-
-
-def SetVariableList(output, variable_name, values):
-    """Sets a CMake variable to a list."""
-    if not values:
-        return SetVariable(output, variable_name, "")
-    if len(values) == 1:
-        return SetVariable(output, variable_name, values[0])
-    output.write("list(APPEND ")
-    output.write(variable_name)
-    output.write('\n  "')
-    output.write('"\n  "'.join([CMakeStringEscape(value) for value in values]))
-    output.write('")\n')
-
-
-def UnsetVariable(output, variable_name):
-    """Unsets a CMake variable."""
-    output.write("unset(")
-    output.write(variable_name)
-    output.write(")\n")
-
-
-def WriteVariable(output, variable_name, prepend=None):
-    if prepend:
-        output.write(prepend)
-    output.write("${")
-    output.write(variable_name)
-    output.write("}")
-
-
-class CMakeTargetType:
-    def __init__(self, command, modifier, property_modifier):
-        self.command = command
-        self.modifier = modifier
-        self.property_modifier = property_modifier
-
-
-cmake_target_type_from_gyp_target_type = {
-    "executable": CMakeTargetType("add_executable", None, "RUNTIME"),
-    "static_library": CMakeTargetType("add_library", "STATIC", "ARCHIVE"),
-    "shared_library": CMakeTargetType("add_library", "SHARED", "LIBRARY"),
-    "loadable_module": CMakeTargetType("add_library", "MODULE", "LIBRARY"),
-    "none": CMakeTargetType("add_custom_target", "SOURCES", None),
-}
-
-
-def StringToCMakeTargetName(a):
-    """Converts the given string 'a' to a valid CMake target name.
-
-  All invalid characters are replaced by '_'.
-  Invalid for cmake: ' ', '/', '(', ')', '"'
-  Invalid for make: ':'
-  Invalid for unknown reasons but cause failures: '.'
-  """
-    return a.translate(_maketrans(' /():."', "_______"))
-
-
-def WriteActions(target_name, actions, extra_sources, extra_deps, path_to_gyp, output):
-    """Write CMake for the 'actions' in the target.
-
-  Args:
-    target_name: the name of the CMake target being generated.
-    actions: the Gyp 'actions' dict for this target.
-    extra_sources: [(<cmake_src>, <src>)] to append with generated source files.
-    extra_deps: [<cmake_taget>] to append with generated targets.
-    path_to_gyp: relative path from CMakeLists.txt being generated to
-        the Gyp file in which the target being generated is defined.
-  """
-    for action in actions:
-        action_name = StringToCMakeTargetName(action["action_name"])
-        action_target_name = f"{target_name}__{action_name}"
-
-        inputs = action["inputs"]
-        inputs_name = action_target_name + "__input"
-        SetVariableList(
-            output,
-            inputs_name,
-            [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs],
-        )
-
-        outputs = action["outputs"]
-        cmake_outputs = [
-            NormjoinPathForceCMakeSource(path_to_gyp, out) for out in outputs
-        ]
-        outputs_name = action_target_name + "__output"
-        SetVariableList(output, outputs_name, cmake_outputs)
-
-        # Build up a list of outputs.
-        # Collect the output dirs we'll need.
-        dirs = {dir for dir in (os.path.dirname(o) for o in outputs) if dir}
-
-        if int(action.get("process_outputs_as_sources", False)):
-            extra_sources.extend(zip(cmake_outputs, outputs))
-
-        # add_custom_command
-        output.write("add_custom_command(OUTPUT ")
-        WriteVariable(output, outputs_name)
-        output.write("\n")
-
-        if len(dirs) > 0:
-            for directory in dirs:
-                output.write("  COMMAND ${CMAKE_COMMAND} -E make_directory ")
-                output.write(directory)
-                output.write("\n")
-
-        output.write("  COMMAND ")
-        output.write(gyp.common.EncodePOSIXShellList(action["action"]))
-        output.write("\n")
-
-        output.write("  DEPENDS ")
-        WriteVariable(output, inputs_name)
-        output.write("\n")
-
-        output.write("  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
-        output.write(path_to_gyp)
-        output.write("\n")
-
-        output.write("  COMMENT ")
-        if "message" in action:
-            output.write(action["message"])
-        else:
-            output.write(action_target_name)
-        output.write("\n")
-
-        output.write("  VERBATIM\n")
-        output.write(")\n")
-
-        # add_custom_target
-        output.write("add_custom_target(")
-        output.write(action_target_name)
-        output.write("\n  DEPENDS ")
-        WriteVariable(output, outputs_name)
-        output.write("\n  SOURCES ")
-        WriteVariable(output, inputs_name)
-        output.write("\n)\n")
-
-        extra_deps.append(action_target_name)
-
-
-def NormjoinRulePathForceCMakeSource(base_path, rel_path, rule_source):
-    if rel_path.startswith(("${RULE_INPUT_PATH}", "${RULE_INPUT_DIRNAME}")):
-        if any(rule_source.startswith(var) for var in FULL_PATH_VARS):
-            return rel_path
-    return NormjoinPathForceCMakeSource(base_path, rel_path)
-
-
-def WriteRules(target_name, rules, extra_sources, extra_deps, path_to_gyp, output):
-    """Write CMake for the 'rules' in the target.
-
-  Args:
-    target_name: the name of the CMake target being generated.
-    actions: the Gyp 'actions' dict for this target.
-    extra_sources: [(<cmake_src>, <src>)] to append with generated source files.
-    extra_deps: [<cmake_taget>] to append with generated targets.
-    path_to_gyp: relative path from CMakeLists.txt being generated to
-        the Gyp file in which the target being generated is defined.
-  """
-    for rule in rules:
-        rule_name = StringToCMakeTargetName(target_name + "__" + rule["rule_name"])
-
-        inputs = rule.get("inputs", [])
-        inputs_name = rule_name + "__input"
-        SetVariableList(
-            output,
-            inputs_name,
-            [NormjoinPathForceCMakeSource(path_to_gyp, dep) for dep in inputs],
-        )
-        outputs = rule["outputs"]
-        var_outputs = []
-
-        for count, rule_source in enumerate(rule.get("rule_sources", [])):
-            action_name = rule_name + "_" + str(count)
-
-            rule_source_dirname, rule_source_basename = os.path.split(rule_source)
-            rule_source_root, rule_source_ext = os.path.splitext(rule_source_basename)
-
-            SetVariable(output, "RULE_INPUT_PATH", rule_source)
-            SetVariable(output, "RULE_INPUT_DIRNAME", rule_source_dirname)
-            SetVariable(output, "RULE_INPUT_NAME", rule_source_basename)
-            SetVariable(output, "RULE_INPUT_ROOT", rule_source_root)
-            SetVariable(output, "RULE_INPUT_EXT", rule_source_ext)
-
-            # Build up a list of outputs.
-            # Collect the output dirs we'll need.
-            dirs = {dir for dir in (os.path.dirname(o) for o in outputs) if dir}
-
-            # Create variables for the output, as 'local' variable will be unset.
-            these_outputs = []
-            for output_index, out in enumerate(outputs):
-                output_name = action_name + "_" + str(output_index)
-                SetVariable(
-                    output,
-                    output_name,
-                    NormjoinRulePathForceCMakeSource(path_to_gyp, out, rule_source),
-                )
-                if int(rule.get("process_outputs_as_sources", False)):
-                    extra_sources.append(("${" + output_name + "}", out))
-                these_outputs.append("${" + output_name + "}")
-                var_outputs.append("${" + output_name + "}")
-
-            # add_custom_command
-            output.write("add_custom_command(OUTPUT\n")
-            for out in these_outputs:
-                output.write("  ")
-                output.write(out)
-                output.write("\n")
-
-            for directory in dirs:
-                output.write("  COMMAND ${CMAKE_COMMAND} -E make_directory ")
-                output.write(directory)
-                output.write("\n")
-
-            output.write("  COMMAND ")
-            output.write(gyp.common.EncodePOSIXShellList(rule["action"]))
-            output.write("\n")
-
-            output.write("  DEPENDS ")
-            WriteVariable(output, inputs_name)
-            output.write(" ")
-            output.write(NormjoinPath(path_to_gyp, rule_source))
-            output.write("\n")
-
-            # CMAKE_CURRENT_LIST_DIR is where the CMakeLists.txt lives.
-            # The cwd is the current build directory.
-            output.write("  WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
-            output.write(path_to_gyp)
-            output.write("\n")
-
-            output.write("  COMMENT ")
-            if "message" in rule:
-                output.write(rule["message"])
-            else:
-                output.write(action_name)
-            output.write("\n")
-
-            output.write("  VERBATIM\n")
-            output.write(")\n")
-
-            UnsetVariable(output, "RULE_INPUT_PATH")
-            UnsetVariable(output, "RULE_INPUT_DIRNAME")
-            UnsetVariable(output, "RULE_INPUT_NAME")
-            UnsetVariable(output, "RULE_INPUT_ROOT")
-            UnsetVariable(output, "RULE_INPUT_EXT")
-
-        # add_custom_target
-        output.write("add_custom_target(")
-        output.write(rule_name)
-        output.write(" DEPENDS\n")
-        for out in var_outputs:
-            output.write("  ")
-            output.write(out)
-            output.write("\n")
-        output.write("SOURCES ")
-        WriteVariable(output, inputs_name)
-        output.write("\n")
-        for rule_source in rule.get("rule_sources", []):
-            output.write("  ")
-            output.write(NormjoinPath(path_to_gyp, rule_source))
-            output.write("\n")
-        output.write(")\n")
-
-        extra_deps.append(rule_name)
-
-
-def WriteCopies(target_name, copies, extra_deps, path_to_gyp, output):
-    """Write CMake for the 'copies' in the target.
-
-  Args:
-    target_name: the name of the CMake target being generated.
-    actions: the Gyp 'actions' dict for this target.
-    extra_deps: [<cmake_taget>] to append with generated targets.
-    path_to_gyp: relative path from CMakeLists.txt being generated to
-        the Gyp file in which the target being generated is defined.
-  """
-    copy_name = target_name + "__copies"
-
-    # CMake gets upset with custom targets with OUTPUT which specify no output.
-    have_copies = any(copy["files"] for copy in copies)
-    if not have_copies:
-        output.write("add_custom_target(")
-        output.write(copy_name)
-        output.write(")\n")
-        extra_deps.append(copy_name)
-        return
-
-    class Copy:
-        def __init__(self, ext, command):
-            self.cmake_inputs = []
-            self.cmake_outputs = []
-            self.gyp_inputs = []
-            self.gyp_outputs = []
-            self.ext = ext
-            self.inputs_name = None
-            self.outputs_name = None
-            self.command = command
-
-    file_copy = Copy("", "copy")
-    dir_copy = Copy("_dirs", "copy_directory")
-
-    for copy in copies:
-        files = copy["files"]
-        destination = copy["destination"]
-        for src in files:
-            path = os.path.normpath(src)
-            basename = os.path.split(path)[1]
-            dst = os.path.join(destination, basename)
-
-            copy = file_copy if os.path.basename(src) else dir_copy
-
-            copy.cmake_inputs.append(NormjoinPathForceCMakeSource(path_to_gyp, src))
-            copy.cmake_outputs.append(NormjoinPathForceCMakeSource(path_to_gyp, dst))
-            copy.gyp_inputs.append(src)
-            copy.gyp_outputs.append(dst)
-
-    for copy in (file_copy, dir_copy):
-        if copy.cmake_inputs:
-            copy.inputs_name = copy_name + "__input" + copy.ext
-            SetVariableList(output, copy.inputs_name, copy.cmake_inputs)
-
-            copy.outputs_name = copy_name + "__output" + copy.ext
-            SetVariableList(output, copy.outputs_name, copy.cmake_outputs)
-
-    # add_custom_command
-    output.write("add_custom_command(\n")
-
-    output.write("OUTPUT")
-    for copy in (file_copy, dir_copy):
-        if copy.outputs_name:
-            WriteVariable(output, copy.outputs_name, " ")
-    output.write("\n")
-
-    for copy in (file_copy, dir_copy):
-        for src, dst in zip(copy.gyp_inputs, copy.gyp_outputs):
-            # 'cmake -E copy src dst' will create the 'dst' directory if needed.
-            output.write("COMMAND ${CMAKE_COMMAND} -E %s " % copy.command)
-            output.write(src)
-            output.write(" ")
-            output.write(dst)
-            output.write("\n")
-
-    output.write("DEPENDS")
-    for copy in (file_copy, dir_copy):
-        if copy.inputs_name:
-            WriteVariable(output, copy.inputs_name, " ")
-    output.write("\n")
-
-    output.write("WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/")
-    output.write(path_to_gyp)
-    output.write("\n")
-
-    output.write("COMMENT Copying for ")
-    output.write(target_name)
-    output.write("\n")
-
-    output.write("VERBATIM\n")
-    output.write(")\n")
-
-    # add_custom_target
-    output.write("add_custom_target(")
-    output.write(copy_name)
-    output.write("\n  DEPENDS")
-    for copy in (file_copy, dir_copy):
-        if copy.outputs_name:
-            WriteVariable(output, copy.outputs_name, " ")
-    output.write("\n  SOURCES")
-    if file_copy.inputs_name:
-        WriteVariable(output, file_copy.inputs_name, " ")
-    output.write("\n)\n")
-
-    extra_deps.append(copy_name)
-
-
-def CreateCMakeTargetBaseName(qualified_target):
-    """This is the name we would like the target to have."""
-    _, gyp_target_name, gyp_target_toolset = gyp.common.ParseQualifiedTarget(
-        qualified_target
-    )
-    cmake_target_base_name = gyp_target_name
-    if gyp_target_toolset and gyp_target_toolset != "target":
-        cmake_target_base_name += "_" + gyp_target_toolset
-    return StringToCMakeTargetName(cmake_target_base_name)
-
-
-def CreateCMakeTargetFullName(qualified_target):
-    """An unambiguous name for the target."""
-    gyp_file, gyp_target_name, gyp_target_toolset = gyp.common.ParseQualifiedTarget(
-        qualified_target
-    )
-    cmake_target_full_name = gyp_file + ":" + gyp_target_name
-    if gyp_target_toolset and gyp_target_toolset != "target":
-        cmake_target_full_name += "_" + gyp_target_toolset
-    return StringToCMakeTargetName(cmake_target_full_name)
-
-
-class CMakeNamer:
-    """Converts Gyp target names into CMake target names.
-
-  CMake requires that target names be globally unique. One way to ensure
-  this is to fully qualify the names of the targets. Unfortunately, this
-  ends up with all targets looking like "chrome_chrome_gyp_chrome" instead
-  of just "chrome". If this generator were only interested in building, it
-  would be possible to fully qualify all target names, then create
-  unqualified target names which depend on all qualified targets which
-  should have had that name. This is more or less what the 'make' generator
-  does with aliases. However, one goal of this generator is to create CMake
-  files for use with IDEs, and fully qualified names are not as user
-  friendly.
-
-  Since target name collision is rare, we do the above only when required.
-
-  Toolset variants are always qualified from the base, as this is required for
-  building. However, it also makes sense for an IDE, as it is possible for
-  defines to be different.
-  """
-
-    def __init__(self, target_list):
-        self.cmake_target_base_names_conficting = set()
-
-        cmake_target_base_names_seen = set()
-        for qualified_target in target_list:
-            cmake_target_base_name = CreateCMakeTargetBaseName(qualified_target)
-
-            if cmake_target_base_name not in cmake_target_base_names_seen:
-                cmake_target_base_names_seen.add(cmake_target_base_name)
-            else:
-                self.cmake_target_base_names_conficting.add(cmake_target_base_name)
-
-    def CreateCMakeTargetName(self, qualified_target):
-        base_name = CreateCMakeTargetBaseName(qualified_target)
-        if base_name in self.cmake_target_base_names_conficting:
-            return CreateCMakeTargetFullName(qualified_target)
-        return base_name
-
-
-def WriteTarget(
-    namer,
-    qualified_target,
-    target_dicts,
-    build_dir,
-    config_to_use,
-    options,
-    generator_flags,
-    all_qualified_targets,
-    flavor,
-    output,
-):
-    # The make generator does this always.
-    # TODO: It would be nice to be able to tell CMake all dependencies.
-    circular_libs = generator_flags.get("circular", True)
-
-    if not generator_flags.get("standalone", False):
-        output.write("\n#")
-        output.write(qualified_target)
-        output.write("\n")
-
-    gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
-    rel_gyp_file = gyp.common.RelativePath(gyp_file, options.toplevel_dir)
-    rel_gyp_dir = os.path.dirname(rel_gyp_file)
-
-    # Relative path from build dir to top dir.
-    build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
-    # Relative path from build dir to gyp dir.
-    build_to_gyp = os.path.join(build_to_top, rel_gyp_dir)
-
-    path_from_cmakelists_to_gyp = build_to_gyp
-
-    spec = target_dicts.get(qualified_target, {})
-    config = spec.get("configurations", {}).get(config_to_use, {})
-
-    xcode_settings = None
-    if flavor == "mac":
-        xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
-
-    target_name = spec.get("target_name", "<missing target name>")
-    target_type = spec.get("type", "<missing target type>")
-    target_toolset = spec.get("toolset")
-
-    cmake_target_type = cmake_target_type_from_gyp_target_type.get(target_type)
-    if cmake_target_type is None:
-        print(
-            "Target %s has unknown target type %s, skipping."
-            % (target_name, target_type)
-        )
-        return
-
-    SetVariable(output, "TARGET", target_name)
-    SetVariable(output, "TOOLSET", target_toolset)
-
-    cmake_target_name = namer.CreateCMakeTargetName(qualified_target)
-
-    extra_sources = []
-    extra_deps = []
-
-    # Actions must come first, since they can generate more OBJs for use below.
-    if "actions" in spec:
-        WriteActions(
-            cmake_target_name,
-            spec["actions"],
-            extra_sources,
-            extra_deps,
-            path_from_cmakelists_to_gyp,
-            output,
-        )
-
-    # Rules must be early like actions.
-    if "rules" in spec:
-        WriteRules(
-            cmake_target_name,
-            spec["rules"],
-            extra_sources,
-            extra_deps,
-            path_from_cmakelists_to_gyp,
-            output,
-        )
-
-    # Copies
-    if "copies" in spec:
-        WriteCopies(
-            cmake_target_name,
-            spec["copies"],
-            extra_deps,
-            path_from_cmakelists_to_gyp,
-            output,
-        )
-
-    # Target and sources
-    srcs = spec.get("sources", [])
-
-    # Gyp separates the sheep from the goats based on file extensions.
-    # A full separation is done here because of flag handing (see below).
-    s_sources = []
-    c_sources = []
-    cxx_sources = []
-    linkable_sources = []
-    other_sources = []
-    for src in srcs:
-        _, ext = os.path.splitext(src)
-        src_type = COMPILABLE_EXTENSIONS.get(ext, None)
-        src_norm_path = NormjoinPath(path_from_cmakelists_to_gyp, src)
-
-        if src_type == "s":
-            s_sources.append(src_norm_path)
-        elif src_type == "cc":
-            c_sources.append(src_norm_path)
-        elif src_type == "cxx":
-            cxx_sources.append(src_norm_path)
-        elif Linkable(ext):
-            linkable_sources.append(src_norm_path)
-        else:
-            other_sources.append(src_norm_path)
-
-    for extra_source in extra_sources:
-        src, real_source = extra_source
-        _, ext = os.path.splitext(real_source)
-        src_type = COMPILABLE_EXTENSIONS.get(ext, None)
-
-        if src_type == "s":
-            s_sources.append(src)
-        elif src_type == "cc":
-            c_sources.append(src)
-        elif src_type == "cxx":
-            cxx_sources.append(src)
-        elif Linkable(ext):
-            linkable_sources.append(src)
-        else:
-            other_sources.append(src)
-
-    s_sources_name = None
-    if s_sources:
-        s_sources_name = cmake_target_name + "__asm_srcs"
-        SetVariableList(output, s_sources_name, s_sources)
-
-    c_sources_name = None
-    if c_sources:
-        c_sources_name = cmake_target_name + "__c_srcs"
-        SetVariableList(output, c_sources_name, c_sources)
-
-    cxx_sources_name = None
-    if cxx_sources:
-        cxx_sources_name = cmake_target_name + "__cxx_srcs"
-        SetVariableList(output, cxx_sources_name, cxx_sources)
-
-    linkable_sources_name = None
-    if linkable_sources:
-        linkable_sources_name = cmake_target_name + "__linkable_srcs"
-        SetVariableList(output, linkable_sources_name, linkable_sources)
-
-    other_sources_name = None
-    if other_sources:
-        other_sources_name = cmake_target_name + "__other_srcs"
-        SetVariableList(output, other_sources_name, other_sources)
-
-    # CMake gets upset when executable targets provide no sources.
-    # http://www.cmake.org/pipermail/cmake/2010-July/038461.html
-    dummy_sources_name = None
-    has_sources = (
-        s_sources_name
-        or c_sources_name
-        or cxx_sources_name
-        or linkable_sources_name
-        or other_sources_name
-    )
-    if target_type == "executable" and not has_sources:
-        dummy_sources_name = cmake_target_name + "__dummy_srcs"
-        SetVariable(
-            output, dummy_sources_name, "${obj}.${TOOLSET}/${TARGET}/genc/dummy.c"
-        )
-        output.write('if(NOT EXISTS "')
-        WriteVariable(output, dummy_sources_name)
-        output.write('")\n')
-        output.write('  file(WRITE "')
-        WriteVariable(output, dummy_sources_name)
-        output.write('" "")\n')
-        output.write("endif()\n")
-
-    # CMake is opposed to setting linker directories and considers the practice
-    # of setting linker directories dangerous. Instead, it favors the use of
-    # find_library and passing absolute paths to target_link_libraries.
-    # However, CMake does provide the command link_directories, which adds
-    # link directories to targets defined after it is called.
-    # As a result, link_directories must come before the target definition.
-    # CMake unfortunately has no means of removing entries from LINK_DIRECTORIES.
-    library_dirs = config.get("library_dirs")
-    if library_dirs is not None:
-        output.write("link_directories(")
-        for library_dir in library_dirs:
-            output.write(" ")
-            output.write(NormjoinPath(path_from_cmakelists_to_gyp, library_dir))
-            output.write("\n")
-        output.write(")\n")
-
-    output.write(cmake_target_type.command)
-    output.write("(")
-    output.write(cmake_target_name)
-
-    if cmake_target_type.modifier is not None:
-        output.write(" ")
-        output.write(cmake_target_type.modifier)
-
-    if s_sources_name:
-        WriteVariable(output, s_sources_name, " ")
-    if c_sources_name:
-        WriteVariable(output, c_sources_name, " ")
-    if cxx_sources_name:
-        WriteVariable(output, cxx_sources_name, " ")
-    if linkable_sources_name:
-        WriteVariable(output, linkable_sources_name, " ")
-    if other_sources_name:
-        WriteVariable(output, other_sources_name, " ")
-    if dummy_sources_name:
-        WriteVariable(output, dummy_sources_name, " ")
-
-    output.write(")\n")
-
-    # Let CMake know if the 'all' target should depend on this target.
-    exclude_from_all = (
-        "TRUE" if qualified_target not in all_qualified_targets else "FALSE"
-    )
-    SetTargetProperty(output, cmake_target_name, "EXCLUDE_FROM_ALL", exclude_from_all)
-    for extra_target_name in extra_deps:
-        SetTargetProperty(
-            output, extra_target_name, "EXCLUDE_FROM_ALL", exclude_from_all
-        )
-
-    # Output name and location.
-    if target_type != "none":
-        # Link as 'C' if there are no other files
-        if not c_sources and not cxx_sources:
-            SetTargetProperty(output, cmake_target_name, "LINKER_LANGUAGE", ["C"])
-
-        # Mark uncompiled sources as uncompiled.
-        if other_sources_name:
-            output.write("set_source_files_properties(")
-            WriteVariable(output, other_sources_name, "")
-            output.write(' PROPERTIES HEADER_FILE_ONLY "TRUE")\n')
-
-        # Mark object sources as linkable.
-        if linkable_sources_name:
-            output.write("set_source_files_properties(")
-            WriteVariable(output, other_sources_name, "")
-            output.write(' PROPERTIES EXTERNAL_OBJECT "TRUE")\n')
-
-        # Output directory
-        target_output_directory = spec.get("product_dir")
-        if target_output_directory is None:
-            if target_type in ("executable", "loadable_module"):
-                target_output_directory = generator_default_variables["PRODUCT_DIR"]
-            elif target_type == "shared_library":
-                target_output_directory = "${builddir}/lib.${TOOLSET}"
-            elif spec.get("standalone_static_library", False):
-                target_output_directory = generator_default_variables["PRODUCT_DIR"]
-            else:
-                base_path = gyp.common.RelativePath(
-                    os.path.dirname(gyp_file), options.toplevel_dir
-                )
-                target_output_directory = "${obj}.${TOOLSET}"
-                target_output_directory = os.path.join(
-                    target_output_directory, base_path
-                )
-
-        cmake_target_output_directory = NormjoinPathForceCMakeSource(
-            path_from_cmakelists_to_gyp, target_output_directory
-        )
-        SetTargetProperty(
-            output,
-            cmake_target_name,
-            cmake_target_type.property_modifier + "_OUTPUT_DIRECTORY",
-            cmake_target_output_directory,
-        )
-
-        # Output name
-        default_product_prefix = ""
-        default_product_name = target_name
-        default_product_ext = ""
-        if target_type == "static_library":
-            static_library_prefix = generator_default_variables["STATIC_LIB_PREFIX"]
-            default_product_name = RemovePrefix(
-                default_product_name, static_library_prefix
-            )
-            default_product_prefix = static_library_prefix
-            default_product_ext = generator_default_variables["STATIC_LIB_SUFFIX"]
-
-        elif target_type in ("loadable_module", "shared_library"):
-            shared_library_prefix = generator_default_variables["SHARED_LIB_PREFIX"]
-            default_product_name = RemovePrefix(
-                default_product_name, shared_library_prefix
-            )
-            default_product_prefix = shared_library_prefix
-            default_product_ext = generator_default_variables["SHARED_LIB_SUFFIX"]
-
-        elif target_type != "executable":
-            print(
-                "ERROR: What output file should be generated?",
-                "type",
-                target_type,
-                "target",
-                target_name,
-            )
-
-        product_prefix = spec.get("product_prefix", default_product_prefix)
-        product_name = spec.get("product_name", default_product_name)
-        product_ext = spec.get("product_extension")
-        product_ext = "." + product_ext if product_ext else default_product_ext
-
-        SetTargetProperty(output, cmake_target_name, "PREFIX", product_prefix)
-        SetTargetProperty(
-            output,
-            cmake_target_name,
-            cmake_target_type.property_modifier + "_OUTPUT_NAME",
-            product_name,
-        )
-        SetTargetProperty(output, cmake_target_name, "SUFFIX", product_ext)
-
-        # Make the output of this target referenceable as a source.
-        cmake_target_output_basename = product_prefix + product_name + product_ext
-        cmake_target_output = os.path.join(
-            cmake_target_output_directory, cmake_target_output_basename
-        )
-        SetFileProperty(output, cmake_target_output, "GENERATED", ["TRUE"], "")
-
-        # Includes
-        includes = config.get("include_dirs")
-        if includes:
-            # This (target include directories) is what requires CMake 2.8.8
-            includes_name = cmake_target_name + "__include_dirs"
-            SetVariableList(
-                output,
-                includes_name,
-                [
-                    NormjoinPathForceCMakeSource(path_from_cmakelists_to_gyp, include)
-                    for include in includes
-                ],
-            )
-            output.write("set_property(TARGET ")
-            output.write(cmake_target_name)
-            output.write(" APPEND PROPERTY INCLUDE_DIRECTORIES ")
-            WriteVariable(output, includes_name, "")
-            output.write(")\n")
-
-        # Defines
-        defines = config.get("defines")
-        if defines is not None:
-            SetTargetProperty(
-                output, cmake_target_name, "COMPILE_DEFINITIONS", defines, ";"
-            )
-
-        # Compile Flags - http://www.cmake.org/Bug/view.php?id=6493
-        # CMake currently does not have target C and CXX flags.
-        # So, instead of doing...
-
-        # cflags_c = config.get('cflags_c')
-        # if cflags_c is not None:
-        #   SetTargetProperty(output, cmake_target_name,
-        #                       'C_COMPILE_FLAGS', cflags_c, ' ')
-
-        # cflags_cc = config.get('cflags_cc')
-        # if cflags_cc is not None:
-        #   SetTargetProperty(output, cmake_target_name,
-        #                       'CXX_COMPILE_FLAGS', cflags_cc, ' ')
-
-        # Instead we must...
-        cflags = config.get("cflags", [])
-        cflags_c = config.get("cflags_c", [])
-        cflags_cxx = config.get("cflags_cc", [])
-        if xcode_settings:
-            cflags = xcode_settings.GetCflags(config_to_use)
-            cflags_c = xcode_settings.GetCflagsC(config_to_use)
-            cflags_cxx = xcode_settings.GetCflagsCC(config_to_use)
-            # cflags_objc = xcode_settings.GetCflagsObjC(config_to_use)
-            # cflags_objcc = xcode_settings.GetCflagsObjCC(config_to_use)
-
-        if (not cflags_c or not c_sources) and (not cflags_cxx or not cxx_sources):
-            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", cflags, " ")
-
-        elif c_sources and not (s_sources or cxx_sources):
-            flags = []
-            flags.extend(cflags)
-            flags.extend(cflags_c)
-            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", flags, " ")
-
-        elif cxx_sources and not (s_sources or c_sources):
-            flags = []
-            flags.extend(cflags)
-            flags.extend(cflags_cxx)
-            SetTargetProperty(output, cmake_target_name, "COMPILE_FLAGS", flags, " ")
-
-        else:
-            # TODO: This is broken, one cannot generally set properties on files,
-            # as other targets may require different properties on the same files.
-            if s_sources and cflags:
-                SetFilesProperty(output, s_sources_name, "COMPILE_FLAGS", cflags, " ")
-
-            if c_sources and (cflags or cflags_c):
-                flags = []
-                flags.extend(cflags)
-                flags.extend(cflags_c)
-                SetFilesProperty(output, c_sources_name, "COMPILE_FLAGS", flags, " ")
-
-            if cxx_sources and (cflags or cflags_cxx):
-                flags = []
-                flags.extend(cflags)
-                flags.extend(cflags_cxx)
-                SetFilesProperty(output, cxx_sources_name, "COMPILE_FLAGS", flags, " ")
-
-        # Linker flags
-        ldflags = config.get("ldflags")
-        if ldflags is not None:
-            SetTargetProperty(output, cmake_target_name, "LINK_FLAGS", ldflags, " ")
-
-        # XCode settings
-        xcode_settings = config.get("xcode_settings", {})
-        for xcode_setting, xcode_value in xcode_settings.items():
-            SetTargetProperty(
-                output,
-                cmake_target_name,
-                "XCODE_ATTRIBUTE_%s" % xcode_setting,
-                xcode_value,
-                "" if isinstance(xcode_value, str) else " ",
-            )
-
-    # Note on Dependencies and Libraries:
-    # CMake wants to handle link order, resolving the link line up front.
-    # Gyp does not retain or enforce specifying enough information to do so.
-    # So do as other gyp generators and use --start-group and --end-group.
-    # Give CMake as little information as possible so that it doesn't mess it up.
-
-    # Dependencies
-    rawDeps = spec.get("dependencies", [])
-
-    static_deps = []
-    shared_deps = []
-    other_deps = []
-    for rawDep in rawDeps:
-        dep_cmake_name = namer.CreateCMakeTargetName(rawDep)
-        dep_spec = target_dicts.get(rawDep, {})
-        dep_target_type = dep_spec.get("type", None)
-
-        if dep_target_type == "static_library":
-            static_deps.append(dep_cmake_name)
-        elif dep_target_type == "shared_library":
-            shared_deps.append(dep_cmake_name)
-        else:
-            other_deps.append(dep_cmake_name)
-
-    # ensure all external dependencies are complete before internal dependencies
-    # extra_deps currently only depend on their own deps, so otherwise run early
-    if static_deps or shared_deps or other_deps:
-        for extra_dep in extra_deps:
-            output.write("add_dependencies(")
-            output.write(extra_dep)
-            output.write("\n")
-            for deps in (static_deps, shared_deps, other_deps):
-                for dep in gyp.common.uniquer(deps):
-                    output.write("  ")
-                    output.write(dep)
-                    output.write("\n")
-            output.write(")\n")
-
-    linkable = target_type in ("executable", "loadable_module", "shared_library")
-    other_deps.extend(extra_deps)
-    if other_deps or (not linkable and (static_deps or shared_deps)):
-        output.write("add_dependencies(")
-        output.write(cmake_target_name)
-        output.write("\n")
-        for dep in gyp.common.uniquer(other_deps):
-            output.write("  ")
-            output.write(dep)
-            output.write("\n")
-        if not linkable:
-            for deps in (static_deps, shared_deps):
-                for lib_dep in gyp.common.uniquer(deps):
-                    output.write("  ")
-                    output.write(lib_dep)
-                    output.write("\n")
-        output.write(")\n")
-
-    # Libraries
-    if linkable:
-        external_libs = [lib for lib in spec.get("libraries", []) if len(lib) > 0]
-        if external_libs or static_deps or shared_deps:
-            output.write("target_link_libraries(")
-            output.write(cmake_target_name)
-            output.write("\n")
-            if static_deps:
-                write_group = circular_libs and len(static_deps) > 1 and flavor != "mac"
-                if write_group:
-                    output.write("-Wl,--start-group\n")
-                for dep in gyp.common.uniquer(static_deps):
-                    output.write("  ")
-                    output.write(dep)
-                    output.write("\n")
-                if write_group:
-                    output.write("-Wl,--end-group\n")
-            if shared_deps:
-                for dep in gyp.common.uniquer(shared_deps):
-                    output.write("  ")
-                    output.write(dep)
-                    output.write("\n")
-            if external_libs:
-                for lib in gyp.common.uniquer(external_libs):
-                    output.write('  "')
-                    output.write(RemovePrefix(lib, "$(SDKROOT)"))
-                    output.write('"\n')
-
-            output.write(")\n")
-
-    UnsetVariable(output, "TOOLSET")
-    UnsetVariable(output, "TARGET")
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data, params, config_to_use):
-    options = params["options"]
-    generator_flags = params["generator_flags"]
-    flavor = gyp.common.GetFlavor(params)
-
-    # generator_dir: relative path from pwd to where make puts build files.
-    # Makes migrating from make to cmake easier, cmake doesn't put anything here.
-    # Each Gyp configuration creates a different CMakeLists.txt file
-    # to avoid incompatibilities between Gyp and CMake configurations.
-    generator_dir = os.path.relpath(options.generator_output or ".")
-
-    # output_dir: relative path from generator_dir to the build directory.
-    output_dir = generator_flags.get("output_dir", "out")
-
-    # build_dir: relative path from source root to our output files.
-    # e.g. "out/Debug"
-    build_dir = os.path.normpath(os.path.join(generator_dir, output_dir, config_to_use))
-
-    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-
-    output_file = os.path.join(toplevel_build, "CMakeLists.txt")
-    gyp.common.EnsureDirExists(output_file)
-
-    output = open(output_file, "w")
-    output.write("cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)\n")
-    output.write("cmake_policy(VERSION 2.8.8)\n")
-
-    gyp_file, project_target, _ = gyp.common.ParseQualifiedTarget(target_list[-1])
-    output.write("project(")
-    output.write(project_target)
-    output.write(")\n")
-
-    SetVariable(output, "configuration", config_to_use)
-
-    ar = None
-    cc = None
-    cxx = None
-
-    make_global_settings = data[gyp_file].get("make_global_settings", [])
-    build_to_top = gyp.common.InvertRelativePath(build_dir, options.toplevel_dir)
-    for key, value in make_global_settings:
-        if key == "AR":
-            ar = os.path.join(build_to_top, value)
-        if key == "CC":
-            cc = os.path.join(build_to_top, value)
-        if key == "CXX":
-            cxx = os.path.join(build_to_top, value)
-
-    ar = gyp.common.GetEnvironFallback(["AR_target", "AR"], ar)
-    cc = gyp.common.GetEnvironFallback(["CC_target", "CC"], cc)
-    cxx = gyp.common.GetEnvironFallback(["CXX_target", "CXX"], cxx)
-
-    if ar:
-        SetVariable(output, "CMAKE_AR", ar)
-    if cc:
-        SetVariable(output, "CMAKE_C_COMPILER", cc)
-    if cxx:
-        SetVariable(output, "CMAKE_CXX_COMPILER", cxx)
-
-    # The following appears to be as-yet undocumented.
-    # http://public.kitware.com/Bug/view.php?id=8392
-    output.write("enable_language(ASM)\n")
-    # ASM-ATT does not support .S files.
-    # output.write('enable_language(ASM-ATT)\n')
-
-    if cc:
-        SetVariable(output, "CMAKE_ASM_COMPILER", cc)
-
-    SetVariable(output, "builddir", "${CMAKE_CURRENT_BINARY_DIR}")
-    SetVariable(output, "obj", "${builddir}/obj")
-    output.write("\n")
-
-    # TODO: Undocumented/unsupported (the CMake Java generator depends on it).
-    # CMake by default names the object resulting from foo.c to be foo.c.o.
-    # Gyp traditionally names the object resulting from foo.c foo.o.
-    # This should be irrelevant, but some targets extract .o files from .a
-    # and depend on the name of the extracted .o files.
-    output.write("set(CMAKE_C_OUTPUT_EXTENSION_REPLACE 1)\n")
-    output.write("set(CMAKE_CXX_OUTPUT_EXTENSION_REPLACE 1)\n")
-    output.write("\n")
-
-    # Force ninja to use rsp files. Otherwise link and ar lines can get too long,
-    # resulting in 'Argument list too long' errors.
-    # However, rsp files don't work correctly on Mac.
-    if flavor != "mac":
-        output.write("set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)\n")
-    output.write("\n")
-
-    namer = CMakeNamer(target_list)
-
-    # The list of targets upon which the 'all' target should depend.
-    # CMake has it's own implicit 'all' target, one is not created explicitly.
-    all_qualified_targets = set()
-    for build_file in params["build_files"]:
-        for qualified_target in gyp.common.AllTargets(
-            target_list, target_dicts, os.path.normpath(build_file)
-        ):
-            all_qualified_targets.add(qualified_target)
-
-    for qualified_target in target_list:
-        if flavor == "mac":
-            gyp_file, _, _ = gyp.common.ParseQualifiedTarget(qualified_target)
-            spec = target_dicts[qualified_target]
-            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[gyp_file], spec)
-
-        WriteTarget(
-            namer,
-            qualified_target,
-            target_dicts,
-            build_dir,
-            config_to_use,
-            options,
-            generator_flags,
-            all_qualified_targets,
-            flavor,
-            output,
-        )
-
-    output.close()
-
-
-def PerformBuild(data, configurations, params):
-    options = params["options"]
-    generator_flags = params["generator_flags"]
-
-    # generator_dir: relative path from pwd to where make puts build files.
-    # Makes migrating from make to cmake easier, cmake doesn't put anything here.
-    generator_dir = os.path.relpath(options.generator_output or ".")
-
-    # output_dir: relative path from generator_dir to the build directory.
-    output_dir = generator_flags.get("output_dir", "out")
-
-    for config_name in configurations:
-        # build_dir: relative path from source root to our output files.
-        # e.g. "out/Debug"
-        build_dir = os.path.normpath(
-            os.path.join(generator_dir, output_dir, config_name)
-        )
-        arguments = ["cmake", "-G", "Ninja"]
-        print(f"Generating [{config_name}]: {arguments}")
-        subprocess.check_call(arguments, cwd=build_dir)
-
-        arguments = ["ninja", "-C", build_dir]
-        print(f"Building [{config_name}]: {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):
-    user_config = params.get("generator_flags", {}).get("config", None)
-    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
-                )