frida 16.2.1 → 16.2.3

package/releng/meson/mesonbuild/modules/sourceset.py

@@ -0,0 +1,291 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+import typing as T
+
+from . import ExtensionModule, ModuleObject, MutableModuleObject, ModuleInfo
+from .. import build
+from .. import dependencies
+from .. import mesonlib
+from ..interpreterbase import (
+    noPosargs, noKwargs,
+    InterpreterException, InvalidArguments, InvalidCode, FeatureNew,
+)
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import OrderedSet
+
+if T.TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from . import ModuleState
+    from ..interpreter import Interpreter
+    from ..interpreterbase import TYPE_var, TYPE_kwargs
+
+    class AddKwargs(TypedDict):
+
+        when: T.List[T.Union[str, dependencies.Dependency]]
+        if_true: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency]]
+        if_false: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]
+
+    class AddAllKw(TypedDict):
+
+        when: T.List[T.Union[str, dependencies.Dependency]]
+        if_true: T.List[SourceSetImpl]
+
+    class ApplyKw(TypedDict):
+
+        strict: bool
+
+
+_WHEN_KW: KwargInfo[T.List[T.Union[str, dependencies.Dependency]]] = KwargInfo(
+    'when',
+    ContainerTypeInfo(list, (str, dependencies.Dependency)),
+    listify=True,
+    default=[],
+)
+
+
+class SourceSetRule(T.NamedTuple):
+    keys: T.List[str]
+    """Configuration keys that enable this rule if true"""
+
+    deps: T.List[dependencies.Dependency]
+    """Dependencies that enable this rule if true"""
+
+    sources: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]
+    """Source files added when this rule's conditions are true"""
+
+    extra_deps: T.List[dependencies.Dependency]
+    """Dependencies added when this rule's conditions are true, but
+       that do not make the condition false if they're absent."""
+
+    sourcesets: T.List[SourceSetImpl]
+    """Other sourcesets added when this rule's conditions are true"""
+
+    if_false: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]
+    """Source files added when this rule's conditions are false"""
+
+
+class SourceFiles(T.NamedTuple):
+    sources: OrderedSet[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]
+    deps: OrderedSet[dependencies.Dependency]
+
+
+class SourceSet:
+    """Base class to avoid circular references.
+
+    Because of error messages, this class is called SourceSet, and the actual
+    implementation is an Impl.
+    """
+
+
+class SourceSetImpl(SourceSet, MutableModuleObject):
+    def __init__(self, interpreter: Interpreter):
+        super().__init__()
+        self.rules: T.List[SourceSetRule] = []
+        self.frozen = False
+        self.methods.update({
+            'add': self.add_method,
+            'add_all': self.add_all_method,
+            'all_sources': self.all_sources_method,
+            'all_dependencies': self.all_dependencies_method,
+            'apply': self.apply_method,
+        })
+
+    def check_source_files(self, args: T.Sequence[T.Union[mesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency]],
+                           ) -> T.Tuple[T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]], T.List[dependencies.Dependency]]:
+        sources: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]] = []
+        deps: T.List[dependencies.Dependency] = []
+        for x in args:
+            if isinstance(x, dependencies.Dependency):
+                deps.append(x)
+            else:
+                sources.append(x)
+        to_check: T.List[str] = []
+
+        # Get the actual output names to check
+        for s in sources:
+            if isinstance(s, str):
+                to_check.append(s)
+            elif isinstance(s, mesonlib.File):
+                to_check.append(s.fname)
+            else:
+                to_check.extend(s.get_outputs())
+        mesonlib.check_direntry_issues(to_check)
+        return sources, deps
+
+    def check_conditions(self, args: T.Sequence[T.Union[str, dependencies.Dependency]]
+                         ) -> T.Tuple[T.List[str], T.List[dependencies.Dependency]]:
+        keys: T.List[str] = []
+        deps: T.List[dependencies.Dependency] = []
+        for x in args:
+            if isinstance(x, str):
+                keys.append(x)
+            else:
+                deps.append(x)
+        return keys, deps
+
+    @typed_pos_args('sourceset.add', varargs=(str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, dependencies.Dependency))
+    @typed_kwargs(
+        'sourceset.add',
+        _WHEN_KW,
+        KwargInfo(
+            'if_true',
+            ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, dependencies.Dependency)),
+            listify=True,
+            default=[],
+        ),
+        KwargInfo(
+            'if_false',
+            ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex)),
+            listify=True,
+            default=[],
+        ),
+    )
+    def add_method(self, state: ModuleState,
+                   args: T.Tuple[T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency]]],
+                   kwargs: AddKwargs) -> None:
+        if self.frozen:
+            raise InvalidCode('Tried to use \'add\' after querying the source set')
+        when = kwargs['when']
+        if_true = kwargs['if_true']
+        if_false = kwargs['if_false']
+        if not any([when, if_true, if_false]):
+            if_true = args[0]
+        elif args[0]:
+            raise InterpreterException('add called with both positional and keyword arguments')
+        keys, dependencies = self.check_conditions(when)
+        sources, extra_deps = self.check_source_files(if_true)
+        if_false, _ = self.check_source_files(if_false)
+        self.rules.append(SourceSetRule(keys, dependencies, sources, extra_deps, [], if_false))
+
+    @typed_pos_args('sourceset.add_all', varargs=SourceSet)
+    @typed_kwargs(
+        'sourceset.add_all',
+        _WHEN_KW,
+        KwargInfo(
+            'if_true',
+            ContainerTypeInfo(list, SourceSet),
+            listify=True,
+            default=[],
+        )
+    )
+    def add_all_method(self, state: ModuleState, args: T.Tuple[T.List[SourceSetImpl]],
+                       kwargs: AddAllKw) -> None:
+        if self.frozen:
+            raise InvalidCode('Tried to use \'add_all\' after querying the source set')
+        when = kwargs['when']
+        if_true = kwargs['if_true']
+        if not when and not if_true:
+            if_true = args[0]
+        elif args[0]:
+            raise InterpreterException('add_all called with both positional and keyword arguments')
+        keys, dependencies = self.check_conditions(when)
+        for s in if_true:
+            s.frozen = True
+        self.rules.append(SourceSetRule(keys, dependencies, [], [], if_true, []))
+
+    def collect(self, enabled_fn: T.Callable[[str], bool],
+                all_sources: bool,
+                into: T.Optional['SourceFiles'] = None) -> SourceFiles:
+        if not into:
+            into = SourceFiles(OrderedSet(), OrderedSet())
+        for entry in self.rules:
+            if all(x.found() for x in entry.deps) and \
+               all(enabled_fn(key) for key in entry.keys):
+                into.sources.update(entry.sources)
+                into.deps.update(entry.deps)
+                into.deps.update(entry.extra_deps)
+                for ss in entry.sourcesets:
+                    ss.collect(enabled_fn, all_sources, into)
+                if not all_sources:
+                    continue
+            into.sources.update(entry.if_false)
+        return into
+
+    @noKwargs
+    @noPosargs
+    def all_sources_method(self, state: ModuleState, args: T.List[TYPE_var], kwargs: TYPE_kwargs
+                           ) -> T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]:
+        self.frozen = True
+        files = self.collect(lambda x: True, True)
+        return list(files.sources)
+
+    @noKwargs
+    @noPosargs
+    @FeatureNew('source_set.all_dependencies() method', '0.52.0')
+    def all_dependencies_method(self, state: ModuleState, args: T.List[TYPE_var], kwargs: TYPE_kwargs
+                                ) -> T.List[dependencies.Dependency]:
+        self.frozen = True
+        files = self.collect(lambda x: True, True)
+        return list(files.deps)
+
+    @typed_pos_args('sourceset.apply', (build.ConfigurationData, dict))
+    @typed_kwargs('sourceset.apply', KwargInfo('strict', bool, default=True))
+    def apply_method(self, state: ModuleState, args: T.Tuple[T.Union[build.ConfigurationData, T.Dict[str, TYPE_var]]], kwargs: ApplyKw) -> SourceFilesObject:
+        config_data = args[0]
+        self.frozen = True
+        strict = kwargs['strict']
+        if isinstance(config_data, dict):
+            def _get_from_config_data(key: str) -> bool:
+                assert isinstance(config_data, dict), 'for mypy'
+                if strict and key not in config_data:
+                    raise InterpreterException(f'Entry {key} not in configuration dictionary.')
+                return bool(config_data.get(key, False))
+        else:
+            config_cache: T.Dict[str, bool] = {}
+
+            def _get_from_config_data(key: str) -> bool:
+                assert isinstance(config_data, build.ConfigurationData), 'for mypy'
+                if key not in config_cache:
+                    if key in config_data:
+                        config_cache[key] = bool(config_data.get(key)[0])
+                    elif strict:
+                        raise InvalidArguments(f'sourceset.apply: key "{key}" not in passed configuration, and strict set.')
+                    else:
+                        config_cache[key] = False
+                return config_cache[key]
+
+        files = self.collect(_get_from_config_data, False)
+        res = SourceFilesObject(files)
+        return res
+
+class SourceFilesObject(ModuleObject):
+    def __init__(self, files: SourceFiles):
+        super().__init__()
+        self.files = files
+        self.methods.update({
+            'sources': self.sources_method,
+            'dependencies': self.dependencies_method,
+        })
+
+    @noPosargs
+    @noKwargs
+    def sources_method(self, state: ModuleState, args: T.List[TYPE_var], kwargs: TYPE_kwargs
+                       ) -> T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]:
+        return list(self.files.sources)
+
+    @noPosargs
+    @noKwargs
+    def dependencies_method(self, state: ModuleState, args: T.List[TYPE_var], kwargs: TYPE_kwargs
+                            ) -> T.List[dependencies.Dependency]:
+        return list(self.files.deps)
+
+class SourceSetModule(ExtensionModule):
+
+    INFO = ModuleInfo('sourceset', '0.51.0')
+
+    def __init__(self, interpreter: Interpreter):
+        super().__init__(interpreter)
+        self.methods.update({
+            'source_set': self.source_set,
+        })
+
+    @noKwargs
+    @noPosargs
+    def source_set(self, state: ModuleState, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> SourceSetImpl:
+        return SourceSetImpl(self.interpreter)
+
+def initialize(interp: Interpreter) -> SourceSetModule:
+    return SourceSetModule(interp)

package/releng/meson/mesonbuild/modules/wayland.py

@@ -0,0 +1,151 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2022 Mark Bolhuis <mark@bolhuis.dev>
+
+from __future__ import annotations
+import os
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from ..build import CustomTarget
+from ..interpreter.type_checking import NoneType, in_set_validator
+from ..interpreterbase import typed_pos_args, typed_kwargs, KwargInfo, FeatureNew
+from ..mesonlib import File, MesonException
+
+if T.TYPE_CHECKING:
+    from typing_extensions import Literal, TypedDict
+
+    from . import ModuleState
+    from ..build import Executable
+    from ..dependencies import Dependency
+    from ..interpreter import Interpreter
+    from ..programs import ExternalProgram
+    from ..mesonlib import FileOrString
+
+    class ScanXML(TypedDict):
+
+        public: bool
+        client: bool
+        server: bool
+        include_core_only: bool
+
+    class FindProtocol(TypedDict):
+
+        state: Literal['stable', 'staging', 'unstable']
+        version: T.Optional[int]
+
+class WaylandModule(ExtensionModule):
+
+    INFO = ModuleInfo('wayland', '0.62.0', unstable=True)
+
+    def __init__(self, interpreter: Interpreter) -> None:
+        super().__init__(interpreter)
+
+        self.protocols_dep: T.Optional[Dependency] = None
+        self.pkgdatadir: T.Optional[str] = None
+        self.scanner_bin: T.Optional[T.Union[ExternalProgram, Executable]] = None
+
+        self.methods.update({
+            'scan_xml': self.scan_xml,
+            'find_protocol': self.find_protocol,
+        })
+
+    @typed_pos_args('wayland.scan_xml', varargs=(str, File), min_varargs=1)
+    @typed_kwargs(
+        'wayland.scan_xml',
+        KwargInfo('public', bool, default=False),
+        KwargInfo('client', bool, default=True),
+        KwargInfo('server', bool, default=False),
+        KwargInfo('include_core_only', bool, default=True, since='0.64.0'),
+    )
+    def scan_xml(self, state: ModuleState, args: T.Tuple[T.List[FileOrString]], kwargs: ScanXML) -> ModuleReturnValue:
+        if self.scanner_bin is None:
+            # wayland-scanner from BUILD machine must have same version as wayland
+            # libraries from HOST machine.
+            dep = state.dependency('wayland-client')
+            self.scanner_bin = state.find_tool('wayland-scanner', 'wayland-scanner', 'wayland_scanner',
+                                               wanted=dep.version)
+
+        scope = 'public' if kwargs['public'] else 'private'
+        # We have to cast because mypy can't deduce these are literals
+        sides = [i for i in T.cast("T.List[Literal['client', 'server']]", ['client', 'server']) if kwargs[i]]
+        if not sides:
+            raise MesonException('At least one of client or server keyword argument must be set to true.')
+
+        xml_files = self.interpreter.source_strings_to_files(args[0])
+        targets: T.List[CustomTarget] = []
+        for xml_file in xml_files:
+            name = os.path.splitext(os.path.basename(xml_file.fname))[0]
+
+            code = CustomTarget(
+                f'{name}-protocol',
+                state.subdir,
+                state.subproject,
+                state.environment,
+                [self.scanner_bin, f'{scope}-code', '@INPUT@', '@OUTPUT@'],
+                [xml_file],
+                [f'{name}-protocol.c'],
+                state.is_build_only_subproject,
+                backend=state.backend,
+            )
+            targets.append(code)
+
+            for side in sides:
+                command = [self.scanner_bin, f'{side}-header', '@INPUT@', '@OUTPUT@']
+                if kwargs['include_core_only']:
+                    command.append('--include-core-only')
+
+                header = CustomTarget(
+                    f'{name}-{side}-protocol',
+                    state.subdir,
+                    state.subproject,
+                    state.environment,
+                    command,
+                    [xml_file],
+                    [f'{name}-{side}-protocol.h'],
+                    state.is_build_only_subproject,
+                    backend=state.backend,
+                )
+                targets.append(header)
+
+        return ModuleReturnValue(targets, targets)
+
+    @typed_pos_args('wayland.find_protocol', str)
+    @typed_kwargs(
+        'wayland.find_protocol',
+        KwargInfo('state', str, default='stable', validator=in_set_validator({'stable', 'staging', 'unstable'})),
+        KwargInfo('version', (int, NoneType)),
+    )
+    def find_protocol(self, state: ModuleState, args: T.Tuple[str], kwargs: FindProtocol) -> File:
+        base_name = args[0]
+        xml_state = kwargs['state']
+        version = kwargs['version']
+
+        if xml_state != 'stable' and version is None:
+            raise MesonException(f'{xml_state} protocols require a version number.')
+
+        if xml_state == 'stable' and version is not None:
+            FeatureNew.single_use('Version number in stable wayland protocol', '1.5.0', state.subproject, location=state.current_node)
+
+        if self.protocols_dep is None:
+            self.protocols_dep = state.dependency('wayland-protocols')
+
+        if self.pkgdatadir is None:
+            self.pkgdatadir = self.protocols_dep.get_variable(pkgconfig='pkgdatadir', internal='pkgdatadir')
+
+        xml_name = base_name
+        if xml_state == 'unstable':
+            xml_name += '-unstable'
+        if version is not None:
+            xml_name += f'-v{version}'
+        xml_name += '.xml'
+
+        path = os.path.join(self.pkgdatadir, xml_state, base_name, xml_name)
+
+        if not os.path.exists(path):
+            raise MesonException(f'The file {path} does not exist.')
+
+        return File.from_absolute_file(path)
+
+
+def initialize(interpreter: Interpreter) -> WaylandModule:
+    return WaylandModule(interpreter)

package/releng/meson/mesonbuild/modules/windows.py

@@ -0,0 +1,207 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2015 The Meson development team
+
+from __future__ import annotations
+
+import enum
+import os
+import re
+import typing as T
+
+
+from . import ExtensionModule, ModuleInfo
+from . import ModuleReturnValue
+from .. import mesonlib, build
+from .. import mlog
+from ..interpreter.type_checking import DEPEND_FILES_KW, DEPENDS_KW, INCLUDE_DIRECTORIES
+from ..interpreterbase.decorators import ContainerTypeInfo, FeatureNew, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import MachineChoice, MesonException
+from ..programs import ExternalProgram
+
+if T.TYPE_CHECKING:
+    from . import ModuleState
+    from ..compilers import Compiler
+    from ..interpreter import Interpreter
+
+    from typing_extensions import TypedDict
+
+    class CompileResources(TypedDict):
+
+        depend_files: T.List[mesonlib.FileOrString]
+        depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]]
+        include_directories: T.List[T.Union[str, build.IncludeDirs]]
+        args: T.List[str]
+
+    class RcKwargs(TypedDict):
+        output: str
+        input: T.List[T.Union[mesonlib.FileOrString, build.CustomTargetIndex]]
+        depfile: T.Optional[str]
+        depend_files: T.List[mesonlib.FileOrString]
+        depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]]
+        command: T.List[T.Union[str, ExternalProgram]]
+
+class ResourceCompilerType(enum.Enum):
+    windres = 1
+    rc = 2
+    wrc = 3
+
+class WindowsModule(ExtensionModule):
+
+    INFO = ModuleInfo('windows')
+
+    def __init__(self, interpreter: 'Interpreter'):
+        super().__init__(interpreter)
+        self._rescomp: T.Optional[T.Tuple[ExternalProgram, ResourceCompilerType]] = None
+        self.methods.update({
+            'compile_resources': self.compile_resources,
+        })
+
+    def detect_compiler(self, compilers: T.Dict[str, 'Compiler']) -> 'Compiler':
+        for l in ('c', 'cpp'):
+            if l in compilers:
+                return compilers[l]
+        raise MesonException('Resource compilation requires a C or C++ compiler.')
+
+    def _find_resource_compiler(self, state: 'ModuleState') -> T.Tuple[ExternalProgram, ResourceCompilerType]:
+        # FIXME: Does not handle `native: true` executables, see
+        # See https://github.com/mesonbuild/meson/issues/1531
+        # Take a parameter instead of the hardcoded definition below
+        for_machine = MachineChoice.HOST
+
+        if self._rescomp:
+            return self._rescomp
+
+        # Will try cross / native file and then env var
+        rescomp = ExternalProgram.from_bin_list(state.environment, for_machine, 'windres')
+
+        if not rescomp or not rescomp.found():
+            comp = self.detect_compiler(state.environment.coredata.compilers[for_machine])
+            if comp.id in {'msvc', 'clang-cl', 'intel-cl'} or (comp.linker and comp.linker.id in {'link', 'lld-link'}):
+                # Microsoft compilers uses rc irrespective of the frontend
+                rescomp = ExternalProgram('rc', silent=True)
+            else:
+                rescomp = ExternalProgram('windres', silent=True)
+
+        if not rescomp.found():
+            raise MesonException('Could not find Windows resource compiler')
+
+        for (arg, match, rc_type) in [
+                ('/?', '^.*Microsoft.*Resource Compiler.*$', ResourceCompilerType.rc),
+                ('/?', 'LLVM Resource Converter.*$', ResourceCompilerType.rc),
+                ('--version', '^.*GNU windres.*$', ResourceCompilerType.windres),
+                ('--version', '^.*Wine Resource Compiler.*$', ResourceCompilerType.wrc),
+        ]:
+            p, o, e = mesonlib.Popen_safe(rescomp.get_command() + [arg])
+            m = re.search(match, o, re.MULTILINE)
+            if m:
+                mlog.log('Windows resource compiler: %s' % m.group())
+                self._rescomp = (rescomp, rc_type)
+                break
+        else:
+            raise MesonException('Could not determine type of Windows resource compiler')
+
+        return self._rescomp
+
+    @typed_pos_args('windows.compile_resources', varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex), min_varargs=1)
+    @typed_kwargs(
+        'windows.compile_resources',
+        DEPEND_FILES_KW.evolve(since='0.47.0'),
+        DEPENDS_KW.evolve(since='0.47.0'),
+        INCLUDE_DIRECTORIES,
+        KwargInfo('args', ContainerTypeInfo(list, str), default=[], listify=True),
+    )
+    def compile_resources(self, state: 'ModuleState',
+                          args: T.Tuple[T.List[T.Union[str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex]]],
+                          kwargs: 'CompileResources') -> ModuleReturnValue:
+        extra_args = kwargs['args'].copy()
+        wrc_depend_files = kwargs['depend_files']
+        wrc_depends = kwargs['depends']
+        for d in wrc_depends:
+            if isinstance(d, build.CustomTarget):
+                extra_args += state.get_include_args([
+                    build.IncludeDirs('', [], False, [os.path.join('@BUILD_ROOT@', self.interpreter.backend.get_target_dir(d))],
+                                      state.is_build_only_subproject)
+                ])
+        extra_args += state.get_include_args(kwargs['include_directories'])
+
+        rescomp, rescomp_type = self._find_resource_compiler(state)
+        if rescomp_type == ResourceCompilerType.rc:
+            # RC is used to generate .res files, a special binary resource
+            # format, which can be passed directly to LINK (apparently LINK uses
+            # CVTRES internally to convert this to a COFF object)
+            suffix = 'res'
+            res_args = extra_args + ['/nologo', '/fo@OUTPUT@', '@INPUT@']
+        elif rescomp_type == ResourceCompilerType.windres:
+            # ld only supports object files, so windres is used to generate a
+            # COFF object
+            suffix = 'o'
+            res_args = extra_args + ['@INPUT@', '@OUTPUT@']
+
+            m = 'Argument {!r} has a space which may not work with windres due to ' \
+                'a MinGW bug: https://sourceware.org/bugzilla/show_bug.cgi?id=4933'
+            for arg in extra_args:
+                if ' ' in arg:
+                    mlog.warning(m.format(arg), fatal=False)
+        else:
+            suffix = 'o'
+            res_args = extra_args + ['@INPUT@', '-o', '@OUTPUT@']
+
+        res_targets: T.List[build.CustomTarget] = []
+
+        def get_names() -> T.Iterable[T.Tuple[str, str, T.Union[str, mesonlib.File, build.CustomTargetIndex]]]:
+            for src in args[0]:
+                if isinstance(src, str):
+                    yield os.path.join(state.subdir, src), src, src
+                elif isinstance(src, mesonlib.File):
+                    yield src.relative_name(), src.fname, src
+                elif isinstance(src, build.CustomTargetIndex):
+                    FeatureNew.single_use('windows.compile_resource CustomTargetIndex in positional arguments', '0.61.0',
+                                          state.subproject, location=state.current_node)
+                    # This dance avoids a case where two indexes of the same
+                    # target are given as separate arguments.
+                    yield (f'{src.get_id()}_{src.target.get_outputs().index(src.output)}',
+                           f'windows_compile_resources_{src.get_filename()}', src)
+                else:
+                    if len(src.get_outputs()) > 1:
+                        FeatureNew.single_use('windows.compile_resource CustomTarget with multiple outputs in positional arguments',
+                                              '0.61.0', state.subproject, location=state.current_node)
+                    for i, out in enumerate(src.get_outputs()):
+                        # Chances are that src.get_filename() is already the name of that
+                        # target, add a prefix to avoid name clash.
+                        yield f'{src.get_id()}_{i}', f'windows_compile_resources_{i}_{out}', src[i]
+
+        for name, name_formatted, src in get_names():
+            # Path separators are not allowed in target names
+            name = name.replace('/', '_').replace('\\', '_').replace(':', '_')
+            name_formatted = name_formatted.replace('/', '_').replace('\\', '_').replace(':', '_')
+            output = f'{name}_@BASENAME@.{suffix}'
+            command: T.List[T.Union[str, ExternalProgram]] = []
+            command.append(rescomp)
+            command.extend(res_args)
+            depfile: T.Optional[str] = None
+            # instruct binutils windres to generate a preprocessor depfile
+            if rescomp_type == ResourceCompilerType.windres:
+                depfile = f'{output}.d'
+                command.extend(['--preprocessor-arg=-MD',
+                                '--preprocessor-arg=-MQ@OUTPUT@',
+                                '--preprocessor-arg=-MF@DEPFILE@'])
+
+            res_targets.append(build.CustomTarget(
+                name_formatted,
+                state.subdir,
+                state.subproject,
+                state.environment,
+                command,
+                [src],
+                [output],
+                state.is_build_only_subproject,
+                depfile=depfile,
+                depend_files=wrc_depend_files,
+                extra_depends=wrc_depends,
+                description='Compiling Windows resource {}'
+            ))
+
+        return ModuleReturnValue(res_targets, [res_targets])
+
+def initialize(interp: 'Interpreter') -> WindowsModule:
+    return WindowsModule(interp)