The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
214 lines
9.6 KiB
214 lines
9.6 KiB
# Copyright 2015 The Meson development team |
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
|
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
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))]) |
|
]) |
|
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], |
|
depfile=depfile, |
|
depend_files=wrc_depend_files, |
|
extra_depends=wrc_depends, |
|
)) |
|
|
|
return ModuleReturnValue(res_targets, [res_targets]) |
|
|
|
def initialize(interp: 'Interpreter') -> WindowsModule: |
|
return WindowsModule(interp)
|
|
|