pnpm 11.23.0 → 11.24.0

package/artifacts/exe/dist/node_modules/node-gyp/gyp/pylib/gyp/generator/compile_commands_json.py

@@ -1,128 +0,0 @@
-# Copyright (c) 2016 Ben Noordhuis <info@bnoordhuis.nl>. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import json
-import os
-
-import gyp.common
-import gyp.xcode_emulation
-
-generator_additional_non_configuration_keys = []
-generator_additional_path_sections = []
-generator_extra_sources_for_rules = []
-generator_filelist_paths = None
-generator_supports_multiple_toolsets = True
-generator_wants_sorted_dependencies = False
-
-# Lifted from make.py.  The actual values don't matter much.
-generator_default_variables = {
-    "CONFIGURATION_NAME": "$(BUILDTYPE)",
-    "EXECUTABLE_PREFIX": "",
-    "EXECUTABLE_SUFFIX": "",
-    "INTERMEDIATE_DIR": "$(obj).$(TOOLSET)/$(TARGET)/geni",
-    "PRODUCT_DIR": "$(builddir)",
-    "RULE_INPUT_DIRNAME": "%(INPUT_DIRNAME)s",
-    "RULE_INPUT_EXT": "$(suffix $<)",
-    "RULE_INPUT_NAME": "$(notdir $<)",
-    "RULE_INPUT_PATH": "$(abspath $<)",
-    "RULE_INPUT_ROOT": "%(INPUT_ROOT)s",
-    "SHARED_INTERMEDIATE_DIR": "$(obj)/gen",
-    "SHARED_LIB_PREFIX": "lib",
-    "STATIC_LIB_PREFIX": "lib",
-    "STATIC_LIB_SUFFIX": ".a",
-}
-
-
-def IsMac(params):
-    return gyp.common.GetFlavor(params) == "mac"
-
-
-def CalculateVariables(default_variables, params):
-    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
-
-
-def AddCommandsForTarget(cwd, target, params, per_config_commands):
-    output_dir = params["generator_flags"].get("output_dir", "out")
-    for configuration_name, configuration in target["configurations"].items():
-        if IsMac(params):
-            xcode_settings = gyp.xcode_emulation.XcodeSettings(target)
-            cflags = xcode_settings.GetCflags(configuration_name)
-            cflags_c = xcode_settings.GetCflagsC(configuration_name)
-            cflags_cc = xcode_settings.GetCflagsCC(configuration_name)
-        else:
-            cflags = configuration.get("cflags", [])
-            cflags_c = configuration.get("cflags_c", [])
-            cflags_cc = configuration.get("cflags_cc", [])
-
-        cflags_c = cflags + cflags_c
-        cflags_cc = cflags + cflags_cc
-
-        defines = configuration.get("defines", [])
-        defines = ["-D" + s for s in defines]
-
-        # TODO(bnoordhuis) Handle generated source files.
-        extensions = (".c", ".cc", ".cpp", ".cxx")
-        sources = [s for s in target.get("sources", []) if s.endswith(extensions)]
-
-        def resolve(filename):
-            return os.path.abspath(os.path.join(cwd, filename))
-
-        # TODO(bnoordhuis) Handle generated header files.
-        include_dirs = configuration.get("include_dirs", [])
-        include_dirs = [s for s in include_dirs if not s.startswith("$(obj)")]
-        includes = ["-I" + resolve(s) for s in include_dirs]
-
-        defines = gyp.common.EncodePOSIXShellList(defines)
-        includes = gyp.common.EncodePOSIXShellList(includes)
-        cflags_c = gyp.common.EncodePOSIXShellList(cflags_c)
-        cflags_cc = gyp.common.EncodePOSIXShellList(cflags_cc)
-
-        commands = per_config_commands.setdefault(configuration_name, [])
-        for source in sources:
-            file = resolve(source)
-            isc = source.endswith(".c")
-            cc = "cc" if isc else "c++"
-            cflags = cflags_c if isc else cflags_cc
-            command = " ".join(
-                (
-                    cc,
-                    defines,
-                    includes,
-                    cflags,
-                    "-c",
-                    gyp.common.EncodePOSIXShellArgument(file),
-                )
-            )
-            commands.append({"command": command, "directory": output_dir, "file": file})
-
-
-def GenerateOutput(target_list, target_dicts, data, params):
-    per_config_commands = {}
-    for qualified_target, target in target_dicts.items():
-        build_file, _target_name, _toolset = gyp.common.ParseQualifiedTarget(
-            qualified_target
-        )
-        if IsMac(params):
-            settings = data[build_file]
-            gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(settings, target)
-        cwd = os.path.dirname(build_file)
-        AddCommandsForTarget(cwd, target, params, per_config_commands)
-
-    output_dir = None
-    try:
-        # generator_output can be `None` on Windows machines, or even not
-        # defined in other cases
-        output_dir = params.get("options").generator_output
-    except AttributeError:
-        pass
-    output_dir = output_dir or params["generator_flags"].get("output_dir", "out")
-    for configuration_name, commands in per_config_commands.items():
-        filename = os.path.join(output_dir, configuration_name, "compile_commands.json")
-        gyp.common.EnsureDirExists(filename)
-        fp = open(filename, "w")
-        json.dump(commands, fp=fp, indent=0, check_circular=False)
-
-
-def PerformBuild(data, configurations, params):
-    pass

package/artifacts/exe/dist/node_modules/node-gyp/gyp/pylib/gyp/generator/dump_dependency_json.py

@@ -1,104 +0,0 @@
-# Copyright (c) 2012 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 json
-import os
-
-import gyp
-import gyp.common
-import gyp.msvs_emulation
-
-generator_supports_multiple_toolsets = True
-
-generator_wants_static_library_dependencies_adjusted = False
-
-generator_filelist_paths = {}
-
-generator_default_variables = {}
-for dirname in [
-    "INTERMEDIATE_DIR",
-    "SHARED_INTERMEDIATE_DIR",
-    "PRODUCT_DIR",
-    "LIB_DIR",
-    "SHARED_LIB_DIR",
-]:
-    # Some gyp steps fail if these are empty(!).
-    generator_default_variables[dirname] = "dir"
-for unused in [
-    "RULE_INPUT_PATH",
-    "RULE_INPUT_ROOT",
-    "RULE_INPUT_NAME",
-    "RULE_INPUT_DIRNAME",
-    "RULE_INPUT_EXT",
-    "EXECUTABLE_PREFIX",
-    "EXECUTABLE_SUFFIX",
-    "STATIC_LIB_PREFIX",
-    "STATIC_LIB_SUFFIX",
-    "SHARED_LIB_PREFIX",
-    "SHARED_LIB_SUFFIX",
-    "CONFIGURATION_NAME",
-]:
-    generator_default_variables[unused] = ""
-
-
-def CalculateVariables(default_variables, params):
-    generator_flags = params.get("generator_flags", {})
-    for key, val in generator_flags.items():
-        default_variables.setdefault(key, val)
-    default_variables.setdefault("OS", gyp.common.GetFlavor(params))
-
-    flavor = gyp.common.GetFlavor(params)
-    if flavor == "win":
-        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-
-
-def CalculateGeneratorInputInfo(params):
-    """Calculate the generator specific info that gets fed to input (called by
-    gyp)."""
-    generator_flags = params.get("generator_flags", {})
-    if generator_flags.get("adjust_static_libraries", False):
-        global generator_wants_static_library_dependencies_adjusted
-        generator_wants_static_library_dependencies_adjusted = True
-
-    toplevel = params["options"].toplevel_dir
-    generator_dir = os.path.relpath(params["options"].generator_output or ".")
-    # output_dir: relative path from generator_dir to the build directory.
-    output_dir = generator_flags.get("output_dir", "out")
-    qualified_out_dir = os.path.normpath(
-        os.path.join(toplevel, generator_dir, output_dir, "gypfiles")
-    )
-    global generator_filelist_paths
-    generator_filelist_paths = {
-        "toplevel": toplevel,
-        "qualified_out_dir": qualified_out_dir,
-    }
-
-
-def GenerateOutput(target_list, target_dicts, data, params):
-    # Map of target -> list of targets it depends on.
-    edges = {}
-
-    # Queue of targets to visit.
-    targets_to_visit = target_list[:]
-
-    while len(targets_to_visit) > 0:
-        target = targets_to_visit.pop()
-        if target in edges:
-            continue
-        edges[target] = []
-
-        for dep in target_dicts[target].get("dependencies", []):
-            edges[target].append(dep)
-            targets_to_visit.append(dep)
-
-    try:
-        filepath = params["generator_flags"]["output_dir"]
-    except KeyError:
-        filepath = "."
-    filename = os.path.join(filepath, "dump.json")
-    f = open(filename, "w")
-    json.dump(edges, f)
-    f.close()
-    print("Wrote json to %s." % filename)

package/artifacts/exe/dist/node_modules/node-gyp/gyp/pylib/gyp/generator/eclipse.py

@@ -1,461 +0,0 @@
-# Copyright (c) 2012 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.
-
-"""GYP backend that generates Eclipse CDT settings files.
-
-This backend DOES NOT generate Eclipse CDT projects. Instead, it generates XML
-files that can be imported into an Eclipse CDT project. The XML file contains a
-list of include paths and symbols (i.e. defines).
-
-Because a full .cproject definition is not created by this generator, it's not
-possible to properly define the include dirs and symbols for each file
-individually.  Instead, one set of includes/symbols is generated for the entire
-project.  This works fairly well (and is a vast improvement in general), but may
-still result in a few indexer issues here and there.
-
-This generator has no automated tests, so expect it to be broken.
-"""
-
-import os.path
-import shlex
-import subprocess
-import xml.etree.ElementTree as ET
-from xml.sax.saxutils import escape
-
-import gyp
-import gyp.common
-import gyp.msvs_emulation
-
-generator_wants_static_library_dependencies_adjusted = False
-
-generator_default_variables = {}
-
-for dirname in ["INTERMEDIATE_DIR", "PRODUCT_DIR", "LIB_DIR", "SHARED_LIB_DIR"]:
-    # Some gyp steps fail if these are empty(!), so we convert them to variables
-    generator_default_variables[dirname] = "$" + dirname
-
-for unused in [
-    "RULE_INPUT_PATH",
-    "RULE_INPUT_ROOT",
-    "RULE_INPUT_NAME",
-    "RULE_INPUT_DIRNAME",
-    "RULE_INPUT_EXT",
-    "EXECUTABLE_PREFIX",
-    "EXECUTABLE_SUFFIX",
-    "STATIC_LIB_PREFIX",
-    "STATIC_LIB_SUFFIX",
-    "SHARED_LIB_PREFIX",
-    "SHARED_LIB_SUFFIX",
-    "CONFIGURATION_NAME",
-]:
-    generator_default_variables[unused] = ""
-
-# Include dirs will occasionally use the SHARED_INTERMEDIATE_DIR variable as
-# part of the path when dealing with generated headers.  This value will be
-# replaced dynamically for each configuration.
-generator_default_variables["SHARED_INTERMEDIATE_DIR"] = "$SHARED_INTERMEDIATE_DIR"
-
-
-def CalculateVariables(default_variables, params):
-    generator_flags = params.get("generator_flags", {})
-    for key, val in generator_flags.items():
-        default_variables.setdefault(key, val)
-    flavor = gyp.common.GetFlavor(params)
-    default_variables.setdefault("OS", flavor)
-    if flavor == "win":
-        gyp.msvs_emulation.CalculateCommonVariables(default_variables, params)
-
-
-def CalculateGeneratorInputInfo(params):
-    """Calculate the generator specific info that gets fed to input (called by
-    gyp)."""
-    generator_flags = params.get("generator_flags", {})
-    if generator_flags.get("adjust_static_libraries", False):
-        global generator_wants_static_library_dependencies_adjusted
-        generator_wants_static_library_dependencies_adjusted = True
-
-
-def GetAllIncludeDirectories(
-    target_list,
-    target_dicts,
-    shared_intermediate_dirs,
-    config_name,
-    params,
-    compiler_path,
-):
-    """Calculate the set of include directories to be used.
-
-    Returns:
-      A list including all the include_dir's specified for every target followed
-      by any include directories that were added as cflag compiler options.
-    """
-
-    gyp_includes_set = set()
-    compiler_includes_list = []
-
-    # Find compiler's default include dirs.
-    if compiler_path:
-        command = shlex.split(compiler_path)
-        command.extend(["-E", "-xc++", "-v", "-"])
-        proc = subprocess.Popen(
-            args=command,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        output = proc.communicate()[1].decode("utf-8")
-        # Extract the list of include dirs from the output, which has this format:
-        #   ...
-        #   #include "..." search starts here:
-        #   #include <...> search starts here:
-        #    /usr/include/c++/4.6
-        #    /usr/local/include
-        #   End of search list.
-        #   ...
-        in_include_list = False
-        for line in output.splitlines():
-            if line.startswith("#include"):
-                in_include_list = True
-                continue
-            if line.startswith("End of search list."):
-                break
-            if in_include_list:
-                include_dir = line.strip()
-                if include_dir not in compiler_includes_list:
-                    compiler_includes_list.append(include_dir)
-
-    flavor = gyp.common.GetFlavor(params)
-    if flavor == "win":
-        generator_flags = params.get("generator_flags", {})
-    for target_name in target_list:
-        target = target_dicts[target_name]
-        if config_name in target["configurations"]:
-            config = target["configurations"][config_name]
-
-            # Look for any include dirs that were explicitly added via cflags. This
-            # may be done in gyp files to force certain includes to come at the end.
-            # TODO(jgreenwald): Change the gyp files to not abuse cflags for this, and
-            # remove this.
-            if flavor == "win":
-                msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
-                cflags = msvs_settings.GetCflags(config_name)
-            else:
-                cflags = config["cflags"]
-            for cflag in cflags:
-                if cflag.startswith("-I"):
-                    include_dir = cflag[2:]
-                    if include_dir not in compiler_includes_list:
-                        compiler_includes_list.append(include_dir)
-
-            # Find standard gyp include dirs.
-            if "include_dirs" in config:
-                include_dirs = config["include_dirs"]
-                for shared_intermediate_dir in shared_intermediate_dirs:
-                    for include_dir in include_dirs:
-                        include_dir = include_dir.replace(
-                            "$SHARED_INTERMEDIATE_DIR", shared_intermediate_dir
-                        )
-                        if not os.path.isabs(include_dir):
-                            base_dir = os.path.dirname(target_name)
-
-                            include_dir = base_dir + "/" + include_dir
-                            include_dir = os.path.abspath(include_dir)
-
-                        gyp_includes_set.add(include_dir)
-
-    # Generate a list that has all the include dirs.
-    all_includes_list = list(gyp_includes_set)
-    all_includes_list.sort()
-    for compiler_include in compiler_includes_list:
-        if compiler_include not in gyp_includes_set:
-            all_includes_list.append(compiler_include)
-
-    # All done.
-    return all_includes_list
-
-
-def GetCompilerPath(target_list, data, options):
-    """Determine a command that can be used to invoke the compiler.
-
-    Returns:
-      If this is a gyp project that has explicit make settings, try to determine
-      the compiler from that.  Otherwise, see if a compiler was specified via the
-      CC_target environment variable.
-    """
-    # First, see if the compiler is configured in make's settings.
-    build_file, _, _ = gyp.common.ParseQualifiedTarget(target_list[0])
-    make_global_settings_dict = data[build_file].get("make_global_settings", {})
-    for key, value in make_global_settings_dict:
-        if key in ["CC", "CXX"]:
-            return os.path.join(options.toplevel_dir, value)
-
-    # Check to see if the compiler was specified as an environment variable.
-    for key in ["CC_target", "CC", "CXX"]:
-        compiler = os.environ.get(key)
-        if compiler:
-            return compiler
-
-    return "gcc"
-
-
-def GetAllDefines(target_list, target_dicts, data, config_name, params, compiler_path):
-    """Calculate the defines for a project.
-
-    Returns:
-      A dict that includes explicit defines declared in gyp files along with all
-      of the default defines that the compiler uses.
-    """
-
-    # Get defines declared in the gyp files.
-    all_defines = {}
-    flavor = gyp.common.GetFlavor(params)
-    if flavor == "win":
-        generator_flags = params.get("generator_flags", {})
-    for target_name in target_list:
-        target = target_dicts[target_name]
-
-        if flavor == "win":
-            msvs_settings = gyp.msvs_emulation.MsvsSettings(target, generator_flags)
-            extra_defines = msvs_settings.GetComputedDefines(config_name)
-        else:
-            extra_defines = []
-        if config_name in target["configurations"]:
-            config = target["configurations"][config_name]
-            target_defines = config["defines"]
-        else:
-            target_defines = []
-        for define in target_defines + extra_defines:
-            split_define = define.split("=", 1)
-            if len(split_define) == 1:
-                split_define.append("1")
-            if split_define[0].strip() in all_defines:
-                # Already defined
-                continue
-            all_defines[split_define[0].strip()] = split_define[1].strip()
-    # Get default compiler defines (if possible).
-    if flavor == "win":
-        return all_defines  # Default defines already processed in the loop above.
-    if compiler_path:
-        command = shlex.split(compiler_path)
-        command.extend(["-E", "-dM", "-"])
-        cpp_proc = subprocess.Popen(
-            args=command, cwd=".", stdin=subprocess.PIPE, stdout=subprocess.PIPE
-        )
-        cpp_output = cpp_proc.communicate()[0].decode("utf-8")
-        cpp_lines = cpp_output.split("\n")
-        for cpp_line in cpp_lines:
-            if not cpp_line.strip():
-                continue
-            cpp_line_parts = cpp_line.split(" ", 2)
-            key = cpp_line_parts[1]
-            val = cpp_line_parts[2] if len(cpp_line_parts) >= 3 else "1"
-            all_defines[key] = val
-
-    return all_defines
-
-
-def WriteIncludePaths(out, eclipse_langs, include_dirs):
-    """Write the includes section of a CDT settings export file."""
-
-    out.write(
-        '  <section name="org.eclipse.cdt.internal.ui.wizards.'
-        'settingswizards.IncludePaths">\n'
-    )
-    out.write('    <language name="holder for library settings"></language>\n')
-    for lang in eclipse_langs:
-        out.write('    <language name="%s">\n' % lang)
-        for include_dir in include_dirs:
-            out.write(
-                '      <includepath workspace_path="false">%s</includepath>\n'
-                % include_dir
-            )
-        out.write("    </language>\n")
-    out.write("  </section>\n")
-
-
-def WriteMacros(out, eclipse_langs, defines):
-    """Write the macros section of a CDT settings export file."""
-
-    out.write(
-        '  <section name="org.eclipse.cdt.internal.ui.wizards.'
-        'settingswizards.Macros">\n'
-    )
-    out.write('    <language name="holder for library settings"></language>\n')
-    for lang in eclipse_langs:
-        out.write('    <language name="%s">\n' % lang)
-        for key in sorted(defines):
-            out.write(
-                "      <macro><name>%s</name><value>%s</value></macro>\n"
-                % (escape(key), escape(defines[key]))
-            )
-        out.write("    </language>\n")
-    out.write("  </section>\n")
-
-
-def GenerateOutputForConfig(target_list, target_dicts, data, params, config_name):
-    options = params["options"]
-    generator_flags = params.get("generator_flags", {})
-
-    # build_dir: relative path from source root to our output files.
-    # e.g. "out/Debug"
-    build_dir = os.path.join(generator_flags.get("output_dir", "out"), config_name)
-
-    toplevel_build = os.path.join(options.toplevel_dir, build_dir)
-    # Ninja uses out/Debug/gen while make uses out/Debug/obj/gen as the
-    # SHARED_INTERMEDIATE_DIR. Include both possible locations.
-    shared_intermediate_dirs = [
-        os.path.join(toplevel_build, "obj", "gen"),
-        os.path.join(toplevel_build, "gen"),
-    ]
-
-    GenerateCdtSettingsFile(
-        target_list,
-        target_dicts,
-        data,
-        params,
-        config_name,
-        os.path.join(toplevel_build, "eclipse-cdt-settings.xml"),
-        options,
-        shared_intermediate_dirs,
-    )
-    GenerateClasspathFile(
-        target_list,
-        target_dicts,
-        options.toplevel_dir,
-        toplevel_build,
-        os.path.join(toplevel_build, "eclipse-classpath.xml"),
-    )
-
-
-def GenerateCdtSettingsFile(
-    target_list,
-    target_dicts,
-    data,
-    params,
-    config_name,
-    out_name,
-    options,
-    shared_intermediate_dirs,
-):
-    gyp.common.EnsureDirExists(out_name)
-    with open(out_name, "w") as out:
-        out.write('<?xml version="1.0" encoding="UTF-8"?>\n')
-        out.write("<cdtprojectproperties>\n")
-
-        eclipse_langs = [
-            "C++ Source File",
-            "C Source File",
-            "Assembly Source File",
-            "GNU C++",
-            "GNU C",
-            "Assembly",
-        ]
-        compiler_path = GetCompilerPath(target_list, data, options)
-        include_dirs = GetAllIncludeDirectories(
-            target_list,
-            target_dicts,
-            shared_intermediate_dirs,
-            config_name,
-            params,
-            compiler_path,
-        )
-        WriteIncludePaths(out, eclipse_langs, include_dirs)
-        defines = GetAllDefines(
-            target_list, target_dicts, data, config_name, params, compiler_path
-        )
-        WriteMacros(out, eclipse_langs, defines)
-
-        out.write("</cdtprojectproperties>\n")
-
-
-def GenerateClasspathFile(
-    target_list, target_dicts, toplevel_dir, toplevel_build, out_name
-):
-    """Generates a classpath file suitable for symbol navigation and code
-    completion of Java code (such as in Android projects) by finding all
-    .java and .jar files used as action inputs."""
-    gyp.common.EnsureDirExists(out_name)
-    result = ET.Element("classpath")
-
-    def AddElements(kind, paths):
-        # First, we need to normalize the paths so they are all relative to the
-        # toplevel dir.
-        rel_paths = set()
-        for path in paths:
-            if os.path.isabs(path):
-                rel_paths.add(os.path.relpath(path, toplevel_dir))
-            else:
-                rel_paths.add(path)
-
-        for path in sorted(rel_paths):
-            entry_element = ET.SubElement(result, "classpathentry")
-            entry_element.set("kind", kind)
-            entry_element.set("path", path)
-
-    AddElements("lib", GetJavaJars(target_list, target_dicts, toplevel_dir))
-    AddElements("src", GetJavaSourceDirs(target_list, target_dicts, toplevel_dir))
-    # Include the standard JRE container and a dummy out folder
-    AddElements("con", ["org.eclipse.jdt.launching.JRE_CONTAINER"])
-    # Include a dummy out folder so that Eclipse doesn't use the default /bin
-    # folder in the root of the project.
-    AddElements("output", [os.path.join(toplevel_build, ".eclipse-java-build")])
-
-    ET.ElementTree(result).write(out_name)
-
-
-def GetJavaJars(target_list, target_dicts, toplevel_dir):
-    """Generates a sequence of all .jars used as inputs."""
-    for target_name in target_list:
-        target = target_dicts[target_name]
-        for action in target.get("actions", []):
-            for input_ in action["inputs"]:
-                if os.path.splitext(input_)[1] == ".jar" and not input_.startswith("$"):
-                    if os.path.isabs(input_):
-                        yield input_
-                    else:
-                        yield os.path.join(os.path.dirname(target_name), input_)
-
-
-def GetJavaSourceDirs(target_list, target_dicts, toplevel_dir):
-    """Generates a sequence of all likely java package root directories."""
-    for target_name in target_list:
-        target = target_dicts[target_name]
-        for action in target.get("actions", []):
-            for input_ in action["inputs"]:
-                if os.path.splitext(input_)[1] == ".java" and not input_.startswith(
-                    "$"
-                ):
-                    dir_ = os.path.dirname(
-                        os.path.join(os.path.dirname(target_name), input_)
-                    )
-                    # If there is a parent 'src' or 'java' folder, navigate up to it -
-                    # these are canonical package root names in Chromium.  This will
-                    # break if 'src' or 'java' exists in the package structure. This
-                    # could be further improved by inspecting the java file for the
-                    # package name if this proves to be too fragile in practice.
-                    parent_search = dir_
-                    while os.path.basename(parent_search) not in ["src", "java"]:
-                        parent_search, _ = os.path.split(parent_search)
-                        if not parent_search or parent_search == toplevel_dir:
-                            # Didn't find a known root, just return the original path
-                            yield dir_
-                            break
-                    else:
-                        yield parent_search
-
-
-def GenerateOutput(target_list, target_dicts, data, params):
-    """Generate an XML settings file that can be imported into a CDT project."""
-
-    if params["options"].generator_output:
-        raise NotImplementedError("--generator_output not implemented for eclipse")
-
-    if user_config := params.get("generator_flags", {}).get("config", None):
-        GenerateOutputForConfig(target_list, target_dicts, data, params, user_config)
-    else:
-        config_names = target_dicts[target_list[0]]["configurations"]
-        for config_name in config_names:
-            GenerateOutputForConfig(
-                target_list, target_dicts, data, params, config_name
-            )