|
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
# Copyright 2013-2021 The Meson development team
|
|
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
|
|
from .base import ExternalDependency, DependencyException, DependencyTypeName
|
|
|
|
from ..mesonlib import is_windows, MesonException, PerMachine, stringlistify, extract_as_list
|
|
|
|
from ..cmake import CMakeExecutor, CMakeTraceParser, CMakeException, CMakeToolchain, CMakeExecScope, check_cmake_args, resolve_cmake_trace_targets, cmake_is_debug
|
|
|
|
from .. import mlog
|
|
|
|
import importlib.resources
|
|
|
|
from pathlib import Path
|
|
|
|
import functools
|
|
|
|
import re
|
|
|
|
import os
|
|
|
|
import shutil
|
|
|
|
import textwrap
|
|
|
|
import typing as T
|
|
|
|
|
|
|
|
if T.TYPE_CHECKING:
|
|
|
|
from ..cmake import CMakeTarget
|
|
|
|
from ..environment import Environment
|
|
|
|
from ..envconfig import MachineInfo
|
|
|
|
from ..interpreter.type_checking import PkgConfigDefineType
|
|
|
|
|
|
|
|
class CMakeInfo(T.NamedTuple):
|
|
|
|
module_paths: T.List[str]
|
|
|
|
cmake_root: str
|
|
|
|
archs: T.List[str]
|
|
|
|
common_paths: T.List[str]
|
|
|
|
|
|
|
|
class CMakeDependency(ExternalDependency):
|
|
|
|
# The class's copy of the CMake path. Avoids having to search for it
|
|
|
|
# multiple times in the same Meson invocation.
|
|
|
|
class_cmakeinfo: PerMachine[T.Optional[CMakeInfo]] = PerMachine(None, None)
|
|
|
|
# Version string for the minimum CMake version
|
|
|
|
class_cmake_version = '>=3.4'
|
|
|
|
# CMake generators to try (empty for no generator)
|
|
|
|
class_cmake_generators = ['', 'Ninja', 'Unix Makefiles', 'Visual Studio 10 2010']
|
|
|
|
class_working_generator: T.Optional[str] = None
|
|
|
|
|
|
|
|
def _gen_exception(self, msg: str) -> DependencyException:
|
|
|
|
return DependencyException(f'Dependency {self.name} not found: {msg}')
|
|
|
|
|
|
|
|
def _main_cmake_file(self) -> str:
|
|
|
|
return 'CMakeLists.txt'
|
|
|
|
|
|
|
|
def _extra_cmake_opts(self) -> T.List[str]:
|
|
|
|
return []
|
|
|
|
|
|
|
|
def _map_module_list(self, modules: T.List[T.Tuple[str, bool]], components: T.List[T.Tuple[str, bool]]) -> T.List[T.Tuple[str, bool]]:
|
|
|
|
# Map the input module list to something else
|
|
|
|
# This function will only be executed AFTER the initial CMake
|
|
|
|
# interpreter pass has completed. Thus variables defined in the
|
|
|
|
# CMakeLists.txt can be accessed here.
|
|
|
|
#
|
|
|
|
# Both the modules and components inputs contain the original lists.
|
|
|
|
return modules
|
|
|
|
|
|
|
|
def _map_component_list(self, modules: T.List[T.Tuple[str, bool]], components: T.List[T.Tuple[str, bool]]) -> T.List[T.Tuple[str, bool]]:
|
|
|
|
# Map the input components list to something else. This
|
|
|
|
# function will be executed BEFORE the initial CMake interpreter
|
|
|
|
# pass. Thus variables from the CMakeLists.txt can NOT be accessed.
|
|
|
|
#
|
|
|
|
# Both the modules and components inputs contain the original lists.
|
|
|
|
return components
|
|
|
|
|
|
|
|
def _original_module_name(self, module: str) -> str:
|
|
|
|
# Reverse the module mapping done by _map_module_list for
|
|
|
|
# one module
|
|
|
|
return module
|
|
|
|
|
|
|
|
def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None, force_use_global_compilers: bool = False) -> None:
|
|
|
|
# Gather a list of all languages to support
|
|
|
|
self.language_list: T.List[str] = []
|
|
|
|
if language is None or force_use_global_compilers:
|
|
|
|
compilers = None
|
|
|
|
if kwargs.get('native', False):
|
|
|
|
compilers = environment.coredata.compilers.build
|
|
|
|
else:
|
|
|
|
compilers = environment.coredata.compilers.host
|
|
|
|
|
|
|
|
candidates = ['c', 'cpp', 'fortran', 'objc', 'objcxx']
|
|
|
|
self.language_list += [x for x in candidates if x in compilers]
|
|
|
|
else:
|
|
|
|
self.language_list += [language]
|
|
|
|
|
|
|
|
# Add additional languages if required
|
|
|
|
if 'fortran' in self.language_list:
|
|
|
|
self.language_list += ['c']
|
|
|
|
|
|
|
|
# Ensure that the list is unique
|
|
|
|
self.language_list = list(set(self.language_list))
|
|
|
|
|
|
|
|
super().__init__(DependencyTypeName('cmake'), environment, kwargs, language=language)
|
|
|
|
self.name = name
|
|
|
|
self.is_libtool = False
|
|
|
|
# Store a copy of the CMake path on the object itself so it is
|
|
|
|
# stored in the pickled coredata and recovered.
|
|
|
|
self.cmakebin: T.Optional[CMakeExecutor] = None
|
|
|
|
self.cmakeinfo: T.Optional[CMakeInfo] = None
|
|
|
|
|
|
|
|
# Where all CMake "build dirs" are located
|
|
|
|
self.cmake_root_dir = environment.scratch_dir
|
|
|
|
|
|
|
|
# T.List of successfully found modules
|
|
|
|
self.found_modules: T.List[str] = []
|
|
|
|
|
|
|
|
# Initialize with None before the first return to avoid
|
|
|
|
# AttributeError exceptions in derived classes
|
|
|
|
self.traceparser: T.Optional[CMakeTraceParser] = None
|
|
|
|
|
|
|
|
# TODO further evaluate always using MachineChoice.BUILD
|
|
|
|
self.cmakebin = CMakeExecutor(environment, CMakeDependency.class_cmake_version, self.for_machine, silent=self.silent)
|
|
|
|
if not self.cmakebin.found():
|
|
|
|
self.cmakebin = None
|
|
|
|
msg = f'CMake binary for machine {self.for_machine} not found. Giving up.'
|
|
|
|
if self.required:
|
|
|
|
raise DependencyException(msg)
|
|
|
|
mlog.debug(msg)
|
|
|
|
return
|
|
|
|
|
|
|
|
# Setup the trace parser
|
|
|
|
self.traceparser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir(), self.env)
|
|
|
|
|
|
|
|
cm_args = stringlistify(extract_as_list(kwargs, 'cmake_args'))
|
|
|
|
cm_args = check_cmake_args(cm_args)
|
|
|
|
if CMakeDependency.class_cmakeinfo[self.for_machine] is None:
|
|
|
|
CMakeDependency.class_cmakeinfo[self.for_machine] = self._get_cmake_info(cm_args)
|
|
|
|
self.cmakeinfo = CMakeDependency.class_cmakeinfo[self.for_machine]
|
|
|
|
if self.cmakeinfo is None:
|
|
|
|
raise self._gen_exception('Unable to obtain CMake system information')
|
|
|
|
|
|
|
|
package_version = kwargs.get('cmake_package_version', '')
|
|
|
|
if not isinstance(package_version, str):
|
|
|
|
raise DependencyException('Keyword "cmake_package_version" must be a string.')
|
|
|
|
components = [(x, True) for x in stringlistify(extract_as_list(kwargs, 'components'))]
|
|
|
|
modules = [(x, True) for x in stringlistify(extract_as_list(kwargs, 'modules'))]
|
|
|
|
modules += [(x, False) for x in stringlistify(extract_as_list(kwargs, 'optional_modules'))]
|
|
|
|
cm_path = stringlistify(extract_as_list(kwargs, 'cmake_module_path'))
|
|
|
|
cm_path = [x if os.path.isabs(x) else os.path.join(environment.get_source_dir(), x) for x in cm_path]
|
|
|
|
if cm_path:
|
|
|
|
cm_args.append('-DCMAKE_MODULE_PATH=' + ';'.join(cm_path))
|
|
|
|
if not self._preliminary_find_check(name, cm_path, self.cmakebin.get_cmake_prefix_paths(), environment.machines[self.for_machine]):
|
|
|
|
mlog.debug('Preliminary CMake check failed. Aborting.')
|
|
|
|
return
|
|
|
|
self._detect_dep(name, package_version, modules, components, cm_args)
|
|
|
|
|
|
|
|
def __repr__(self) -> str:
|
|
|
|
return f'<{self.__class__.__name__} {self.name}: {self.is_found} {self.version_reqs}>'
|
|
|
|
|
|
|
|
def _get_cmake_info(self, cm_args: T.List[str]) -> T.Optional[CMakeInfo]:
|
|
|
|
mlog.debug("Extracting basic cmake information")
|
|
|
|
|
|
|
|
# Try different CMake generators since specifying no generator may fail
|
|
|
|
# in cygwin for some reason
|
|
|
|
gen_list = []
|
|
|
|
# First try the last working generator
|
|
|
|
if CMakeDependency.class_working_generator is not None:
|
|
|
|
gen_list += [CMakeDependency.class_working_generator]
|
|
|
|
gen_list += CMakeDependency.class_cmake_generators
|
|
|
|
|
|
|
|
temp_parser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir(), self.env)
|
|
|
|
toolchain = CMakeToolchain(self.cmakebin, self.env, self.for_machine, CMakeExecScope.DEPENDENCY, self._get_build_dir())
|
|
|
|
toolchain.write()
|
|
|
|
|
|
|
|
for i in gen_list:
|
|
|
|
mlog.debug('Try CMake generator: {}'.format(i if len(i) > 0 else 'auto'))
|
|
|
|
|
|
|
|
# Prepare options
|
|
|
|
cmake_opts = temp_parser.trace_args() + toolchain.get_cmake_args() + ['.']
|
|
|
|
cmake_opts += cm_args
|
|
|
|
if len(i) > 0:
|
|
|
|
cmake_opts = ['-G', i] + cmake_opts
|
|
|
|
|
|
|
|
# Run CMake
|
|
|
|
ret1, out1, err1 = self._call_cmake(cmake_opts, 'CMakePathInfo.txt')
|
|
|
|
|
|
|
|
# Current generator was successful
|
|
|
|
if ret1 == 0:
|
|
|
|
CMakeDependency.class_working_generator = i
|
|
|
|
break
|
|
|
|
|
|
|
|
mlog.debug(f'CMake failed to gather system information for generator {i} with error code {ret1}')
|
|
|
|
mlog.debug(f'OUT:\n{out1}\n\n\nERR:\n{err1}\n\n')
|
|
|
|
|
|
|
|
# Check if any generator succeeded
|
|
|
|
if ret1 != 0:
|
|
|
|
return None
|
|
|
|
|
|
|
|
try:
|
|
|
|
temp_parser.parse(err1)
|
|
|
|
except MesonException:
|
|
|
|
return None
|
|
|
|
|
|
|
|
def process_paths(l: T.List[str]) -> T.Set[str]:
|
|
|
|
if is_windows():
|
|
|
|
# Cannot split on ':' on Windows because its in the drive letter
|
|
|
|
tmp = [x.split(os.pathsep) for x in l]
|
|
|
|
else:
|
|
|
|
# https://github.com/mesonbuild/meson/issues/7294
|
|
|
|
tmp = [re.split(r':|;', x) for x in l]
|
|
|
|
flattened = [x for sublist in tmp for x in sublist]
|
|
|
|
return set(flattened)
|
|
|
|
|
|
|
|
# Extract the variables and sanity check them
|
|
|
|
root_paths_set = process_paths(temp_parser.get_cmake_var('MESON_FIND_ROOT_PATH'))
|
|
|
|
root_paths_set.update(process_paths(temp_parser.get_cmake_var('MESON_CMAKE_SYSROOT')))
|
|
|
|
root_paths = sorted(root_paths_set)
|
|
|
|
root_paths = [x for x in root_paths if os.path.isdir(x)]
|
|
|
|
module_paths_set = process_paths(temp_parser.get_cmake_var('MESON_PATHS_LIST'))
|
|
|
|
rooted_paths: T.List[str] = []
|
|
|
|
for j in [Path(x) for x in root_paths]:
|
|
|
|
for p in [Path(x) for x in module_paths_set]:
|
|
|
|
rooted_paths.append(str(j / p.relative_to(p.anchor)))
|
|
|
|
module_paths = sorted(module_paths_set.union(rooted_paths))
|
|
|
|
module_paths = [x for x in module_paths if os.path.isdir(x)]
|
|
|
|
archs = temp_parser.get_cmake_var('MESON_ARCH_LIST')
|
|
|
|
|
|
|
|
common_paths = ['lib', 'lib32', 'lib64', 'libx32', 'share', '']
|
|
|
|
for i in archs:
|
|
|
|
common_paths += [os.path.join('lib', i)]
|
|
|
|
|
|
|
|
res = CMakeInfo(
|
|
|
|
module_paths=module_paths,
|
|
|
|
cmake_root=temp_parser.get_cmake_var('MESON_CMAKE_ROOT')[0],
|
|
|
|
archs=archs,
|
|
|
|
common_paths=common_paths,
|
|
|
|
)
|
|
|
|
|
|
|
|
mlog.debug(f' -- Module search paths: {res.module_paths}')
|
|
|
|
mlog.debug(f' -- CMake root: {res.cmake_root}')
|
|
|
|
mlog.debug(f' -- CMake architectures: {res.archs}')
|
|
|
|
mlog.debug(f' -- CMake lib search paths: {res.common_paths}')
|
|
|
|
|
|
|
|
return res
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
@functools.lru_cache(maxsize=None)
|
|
|
|
def _cached_listdir(path: str) -> T.Tuple[T.Tuple[str, str], ...]:
|
|
|
|
try:
|
|
|
|
return tuple((x, str(x).lower()) for x in os.listdir(path))
|
|
|
|
except OSError:
|
|
|
|
return tuple()
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
@functools.lru_cache(maxsize=None)
|
|
|
|
def _cached_isdir(path: str) -> bool:
|
|
|
|
try:
|
|
|
|
return os.path.isdir(path)
|
|
|
|
except OSError:
|
|
|
|
return False
|
|
|
|
|
|
|
|
def _preliminary_find_check(self, name: str, module_path: T.List[str], prefix_path: T.List[str], machine: 'MachineInfo') -> bool:
|
|
|
|
lname = str(name).lower()
|
|
|
|
|
|
|
|
# Checks <path>, <path>/cmake, <path>/CMake
|
|
|
|
def find_module(path: str) -> bool:
|
|
|
|
for i in [path, os.path.join(path, 'cmake'), os.path.join(path, 'CMake')]:
|
|
|
|
if not self._cached_isdir(i):
|
|
|
|
continue
|
|
|
|
|
|
|
|
# Check the directory case insensitive
|
|
|
|
content = self._cached_listdir(i)
|
|
|
|
candidates = ['Find{}.cmake', '{}Config.cmake', '{}-config.cmake']
|
|
|
|
candidates = [x.format(name).lower() for x in candidates]
|
|
|
|
if any(x[1] in candidates for x in content):
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
|
|
# Search in <path>/(lib/<arch>|lib*|share) for cmake files
|
|
|
|
def search_lib_dirs(path: str) -> bool:
|
|
|
|
for i in [os.path.join(path, x) for x in self.cmakeinfo.common_paths]:
|
|
|
|
if not self._cached_isdir(i):
|
|
|
|
continue
|
|
|
|
|
|
|
|
# Check <path>/(lib/<arch>|lib*|share)/cmake/<name>*/
|
|
|
|
cm_dir = os.path.join(i, 'cmake')
|
|
|
|
if self._cached_isdir(cm_dir):
|
|
|
|
content = self._cached_listdir(cm_dir)
|
|
|
|
content = tuple(x for x in content if x[1].startswith(lname))
|
|
|
|
for k in content:
|
|
|
|
if find_module(os.path.join(cm_dir, k[0])):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# <path>/(lib/<arch>|lib*|share)/<name>*/
|
|
|
|
# <path>/(lib/<arch>|lib*|share)/<name>*/(cmake|CMake)/
|
|
|
|
content = self._cached_listdir(i)
|
|
|
|
content = tuple(x for x in content if x[1].startswith(lname))
|
|
|
|
for k in content:
|
|
|
|
if find_module(os.path.join(i, k[0])):
|
|
|
|
return True
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
# Check the user provided and system module paths
|
|
|
|
for i in module_path + [os.path.join(self.cmakeinfo.cmake_root, 'Modules')]:
|
|
|
|
if find_module(i):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Check the user provided prefix paths
|
|
|
|
for i in prefix_path:
|
|
|
|
if search_lib_dirs(i):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Check PATH
|
|
|
|
system_env: T.List[str] = []
|
|
|
|
for i in os.environ.get('PATH', '').split(os.pathsep):
|
|
|
|
if i.endswith('/bin') or i.endswith('\\bin'):
|
|
|
|
i = i[:-4]
|
|
|
|
if i.endswith('/sbin') or i.endswith('\\sbin'):
|
|
|
|
i = i[:-5]
|
|
|
|
system_env += [i]
|
|
|
|
|
|
|
|
# Check the system paths
|
|
|
|
for i in self.cmakeinfo.module_paths + system_env:
|
|
|
|
if find_module(i):
|
|
|
|
return True
|
|
|
|
|
|
|
|
if search_lib_dirs(i):
|
|
|
|
return True
|
|
|
|
|
|
|
|
content = self._cached_listdir(i)
|
|
|
|
content = tuple(x for x in content if x[1].startswith(lname))
|
|
|
|
for k in content:
|
|
|
|
if search_lib_dirs(os.path.join(i, k[0])):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Mac framework support
|
|
|
|
if machine.is_darwin():
|
|
|
|
for j in [f'{lname}.framework', f'{lname}.app']:
|
|
|
|
for k in content:
|
|
|
|
if k[1] != j:
|
|
|
|
continue
|
|
|
|
if find_module(os.path.join(i, k[0], 'Resources')) or find_module(os.path.join(i, k[0], 'Version')):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Check the environment path
|
|
|
|
env_path = os.environ.get(f'{name}_DIR')
|
|
|
|
if env_path and find_module(env_path):
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Check the Linux CMake registry
|
|
|
|
linux_reg = Path.home() / '.cmake' / 'packages'
|
|
|
|
for p in [linux_reg / name, linux_reg / lname]:
|
|
|
|
if p.exists():
|
|
|
|
return True
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
|
|
|
def _detect_dep(self, name: str, package_version: str, modules: T.List[T.Tuple[str, bool]], components: T.List[T.Tuple[str, bool]], args: T.List[str]) -> None:
|
|
|
|
# Detect a dependency with CMake using the '--find-package' mode
|
|
|
|
# and the trace output (stderr)
|
|
|
|
#
|
|
|
|
# When the trace output is enabled CMake prints all functions with
|
|
|
|
# parameters to stderr as they are executed. Since CMake 3.4.0
|
|
|
|
# variables ("${VAR}") are also replaced in the trace output.
|
|
|
|
mlog.debug('\nDetermining dependency {!r} with CMake executable '
|
|
|
|
'{!r}'.format(name, self.cmakebin.executable_path()))
|
|
|
|
|
|
|
|
# Try different CMake generators since specifying no generator may fail
|
|
|
|
# in cygwin for some reason
|
|
|
|
gen_list = []
|
|
|
|
# First try the last working generator
|
|
|
|
if CMakeDependency.class_working_generator is not None:
|
|
|
|
gen_list += [CMakeDependency.class_working_generator]
|
|
|
|
gen_list += CMakeDependency.class_cmake_generators
|
|
|
|
|
|
|
|
# Map the components
|
|
|
|
comp_mapped = self._map_component_list(modules, components)
|
|
|
|
toolchain = CMakeToolchain(self.cmakebin, self.env, self.for_machine, CMakeExecScope.DEPENDENCY, self._get_build_dir())
|
|
|
|
toolchain.write()
|
|
|
|
|
|
|
|
for i in gen_list:
|
|
|
|
mlog.debug('Try CMake generator: {}'.format(i if len(i) > 0 else 'auto'))
|
|
|
|
|
|
|
|
# Prepare options
|
|
|
|
cmake_opts = []
|
|
|
|
cmake_opts += [f'-DNAME={name}']
|
|
|
|
cmake_opts += ['-DARCHS={}'.format(';'.join(self.cmakeinfo.archs))]
|
|
|
|
cmake_opts += [f'-DVERSION={package_version}']
|
|
|
|
cmake_opts += ['-DCOMPS={}'.format(';'.join([x[0] for x in comp_mapped]))]
|
|
|
|
cmake_opts += [f'-DSTATIC={self.static}']
|
|
|
|
cmake_opts += args
|
|
|
|
cmake_opts += self.traceparser.trace_args()
|
|
|
|
cmake_opts += toolchain.get_cmake_args()
|
|
|
|
cmake_opts += self._extra_cmake_opts()
|
|
|
|
cmake_opts += ['.']
|
|
|
|
if len(i) > 0:
|
|
|
|
cmake_opts = ['-G', i] + cmake_opts
|
|
|
|
|
|
|
|
# Run CMake
|
|
|
|
ret1, out1, err1 = self._call_cmake(cmake_opts, self._main_cmake_file())
|
|
|
|
|
|
|
|
# Current generator was successful
|
|
|
|
if ret1 == 0:
|
|
|
|
CMakeDependency.class_working_generator = i
|
|
|
|
break
|
|
|
|
|
|
|
|
mlog.debug(f'CMake failed for generator {i} and package {name} with error code {ret1}')
|
|
|
|
mlog.debug(f'OUT:\n{out1}\n\n\nERR:\n{err1}\n\n')
|
|
|
|
|
|
|
|
# Check if any generator succeeded
|
|
|
|
if ret1 != 0:
|
|
|
|
return
|
|
|
|
|
|
|
|
try:
|
|
|
|
self.traceparser.parse(err1)
|
|
|
|
except CMakeException as e:
|
|
|
|
e2 = self._gen_exception(str(e))
|
|
|
|
if self.required:
|
|
|
|
raise
|
|
|
|
else:
|
|
|
|
self.compile_args = []
|
|
|
|
self.link_args = []
|
|
|
|
self.is_found = False
|
|
|
|
self.reason = e2
|
|
|
|
return
|
|
|
|
|
|
|
|
# Whether the package is found or not is always stored in PACKAGE_FOUND
|
|
|
|
self.is_found = self.traceparser.var_to_bool('PACKAGE_FOUND')
|
|
|
|
if not self.is_found:
|
|
|
|
return
|
|
|
|
|
|
|
|
# Try to detect the version
|
|
|
|
vers_raw = self.traceparser.get_cmake_var('PACKAGE_VERSION')
|
|
|
|
|
|
|
|
if len(vers_raw) > 0:
|
|
|
|
self.version = vers_raw[0]
|
|
|
|
self.version.strip('"\' ')
|
|
|
|
|
|
|
|
# Post-process module list. Used in derived classes to modify the
|
|
|
|
# module list (append prepend a string, etc.).
|
|
|
|
modules = self._map_module_list(modules, components)
|
|
|
|
autodetected_module_list = False
|
|
|
|
|
|
|
|
# Try guessing a CMake target if none is provided
|
|
|
|
if len(modules) == 0:
|
|
|
|
for i in self.traceparser.targets:
|
|
|
|
tg = i.lower()
|
|
|
|
lname = name.lower()
|
|
|
|
if f'{lname}::{lname}' == tg or lname == tg.replace('::', ''):
|
|
|
|
mlog.debug(f'Guessed CMake target \'{i}\'')
|
|
|
|
modules = [(i, True)]
|
|
|
|
autodetected_module_list = True
|
|
|
|
break
|
|
|
|
|
|
|
|
# Failed to guess a target --> try the old-style method
|
|
|
|
if len(modules) == 0:
|
|
|
|
# Warn when there might be matching imported targets but no automatic match was used
|
|
|
|
partial_modules: T.List[CMakeTarget] = []
|
|
|
|
for k, v in self.traceparser.targets.items():
|
|
|
|
tg = k.lower()
|
|
|
|
lname = name.lower()
|
|
|
|
if tg.startswith(f'{lname}::'):
|
|
|
|
partial_modules += [v]
|
|
|
|
if partial_modules:
|
|
|
|
mlog.warning(textwrap.dedent(f'''\
|
|
|
|
Could not find and exact match for the CMake dependency {name}.
|
|
|
|
|
|
|
|
However, Meson found the following partial matches:
|
|
|
|
|
|
|
|
{[x.name for x in partial_modules]}
|
|
|
|
|
|
|
|
Using imported is recommended, since this approach is less error prone
|
|
|
|
and better supported by Meson. Consider explicitly specifying one of
|
|
|
|
these in the dependency call with:
|
|
|
|
|
|
|
|
dependency('{name}', modules: ['{name}::<name>', ...])
|
|
|
|
|
|
|
|
Meson will now continue to use the old-style {name}_LIBRARIES CMake
|
|
|
|
variables to extract the dependency information since no explicit
|
|
|
|
target is currently specified.
|
|
|
|
|
|
|
|
'''))
|
|
|
|
mlog.debug('More info for the partial match targets:')
|
|
|
|
for tgt in partial_modules:
|
|
|
|
mlog.debug(tgt)
|
|
|
|
|
|
|
|
incDirs = [x for x in self.traceparser.get_cmake_var('PACKAGE_INCLUDE_DIRS') if x]
|
|
|
|
defs = [x for x in self.traceparser.get_cmake_var('PACKAGE_DEFINITIONS') if x]
|
|
|
|
libs_raw = [x for x in self.traceparser.get_cmake_var('PACKAGE_LIBRARIES') if x]
|
|
|
|
|
|
|
|
# CMake has a "fun" API, where certain keywords describing
|
|
|
|
# configurations can be in the *_LIBRARIES variables. See:
|
|
|
|
# - https://github.com/mesonbuild/meson/issues/9197
|
|
|
|
# - https://gitlab.freedesktop.org/libnice/libnice/-/issues/140
|
|
|
|
# - https://cmake.org/cmake/help/latest/command/target_link_libraries.html#overview (the last point in the section)
|
|
|
|
libs: T.List[str] = []
|
|
|
|
cfg_matches = True
|
|
|
|
is_debug = cmake_is_debug(self.env)
|
|
|
|
cm_tag_map = {'debug': is_debug, 'optimized': not is_debug, 'general': True}
|
|
|
|
for i in libs_raw:
|
|
|
|
if i.lower() in cm_tag_map:
|
|
|
|
cfg_matches = cm_tag_map[i.lower()]
|
|
|
|
continue
|
|
|
|
if cfg_matches:
|
|
|
|
libs += [i]
|
|
|
|
# According to the CMake docs, a keyword only works for the
|
|
|
|
# directly the following item and all items without a keyword
|
|
|
|
# are implicitly `general`
|
|
|
|
cfg_matches = True
|
|
|
|
|
|
|
|
# Try to use old style variables if no module is specified
|
|
|
|
if len(libs) > 0:
|
|
|
|
self.compile_args = [f'-I{x}' for x in incDirs] + defs
|
|
|
|
self.link_args = []
|
|
|
|
for j in libs:
|
|
|
|
rtgt = resolve_cmake_trace_targets(j, self.traceparser, self.env, clib_compiler=self.clib_compiler)
|
|
|
|
self.link_args += rtgt.libraries
|
|
|
|
self.compile_args += [f'-I{x}' for x in rtgt.include_directories]
|
|
|
|
self.compile_args += rtgt.public_compile_opts
|
|
|
|
mlog.debug(f'using old-style CMake variables for dependency {name}')
|
|
|
|
mlog.debug(f'Include Dirs: {incDirs}')
|
|
|
|
mlog.debug(f'Compiler Definitions: {defs}')
|
|
|
|
mlog.debug(f'Libraries: {libs}')
|
|
|
|
return
|
|
|
|
|
|
|
|
# Even the old-style approach failed. Nothing else we can do here
|
|
|
|
self.is_found = False
|
|
|
|
raise self._gen_exception('CMake: failed to guess a CMake target for {}.\n'
|
|
|
|
'Try to explicitly specify one or more targets with the "modules" property.\n'
|
|
|
|
'Valid targets are:\n{}'.format(name, list(self.traceparser.targets.keys())))
|
|
|
|
|
|
|
|
# Set dependencies with CMake targets
|
|
|
|
# recognise arguments we should pass directly to the linker
|
|
|
|
incDirs = []
|
|
|
|
compileOptions = []
|
|
|
|
libraries = []
|
|
|
|
|
|
|
|
for i, required in modules:
|
|
|
|
if i not in self.traceparser.targets:
|
|
|
|
if not required:
|
|
|
|
mlog.warning('CMake: T.Optional module', mlog.bold(self._original_module_name(i)), 'for', mlog.bold(name), 'was not found')
|
|
|
|
continue
|
|
|
|
raise self._gen_exception('CMake: invalid module {} for {}.\n'
|
|
|
|
'Try to explicitly specify one or more targets with the "modules" property.\n'
|
|
|
|
'Valid targets are:\n{}'.format(self._original_module_name(i), name, list(self.traceparser.targets.keys())))
|
|
|
|
|
|
|
|
if not autodetected_module_list:
|
|
|
|
self.found_modules += [i]
|
|
|
|
|
|
|
|
rtgt = resolve_cmake_trace_targets(i, self.traceparser, self.env,
|
|
|
|
clib_compiler=self.clib_compiler,
|
|
|
|
not_found_warning=lambda x:
|
|
|
|
mlog.warning('CMake: Dependency', mlog.bold(x), 'for', mlog.bold(name), 'was not found')
|
|
|
|
)
|
|
|
|
incDirs += rtgt.include_directories
|
|
|
|
compileOptions += rtgt.public_compile_opts
|
|
|
|
libraries += rtgt.libraries + rtgt.link_flags
|
|
|
|
|
|
|
|
# Make sure all elements in the lists are unique and sorted
|
|
|
|
incDirs = sorted(set(incDirs))
|
|
|
|
compileOptions = sorted(set(compileOptions))
|
|
|
|
libraries = sorted(set(libraries))
|
|
|
|
|
|
|
|
mlog.debug(f'Include Dirs: {incDirs}')
|
|
|
|
mlog.debug(f'Compiler Options: {compileOptions}')
|
|
|
|
mlog.debug(f'Libraries: {libraries}')
|
|
|
|
|
|
|
|
self.compile_args = compileOptions + [f'-I{x}' for x in incDirs]
|
|
|
|
self.link_args = libraries
|
|
|
|
|
|
|
|
def _get_build_dir(self) -> Path:
|
|
|
|
build_dir = Path(self.cmake_root_dir) / f'cmake_{self.name}'
|
|
|
|
build_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
return build_dir
|
|
|
|
|
|
|
|
def _setup_cmake_dir(self, cmake_file: str) -> Path:
|
|
|
|
# Setup the CMake build environment and return the "build" directory
|
|
|
|
build_dir = self._get_build_dir()
|
|
|
|
|
|
|
|
# Remove old CMake cache so we can try out multiple generators
|
|
|
|
cmake_cache = build_dir / 'CMakeCache.txt'
|
|
|
|
cmake_files = build_dir / 'CMakeFiles'
|
|
|
|
if cmake_cache.exists():
|
|
|
|
cmake_cache.unlink()
|
|
|
|
shutil.rmtree(cmake_files.as_posix(), ignore_errors=True)
|
|
|
|
|
|
|
|
# Insert language parameters into the CMakeLists.txt and write new CMakeLists.txt
|
|
|
|
cmake_txt = importlib.resources.read_text('mesonbuild.dependencies.data', cmake_file, encoding = 'utf-8')
|
|
|
|
|
|
|
|
# In general, some Fortran CMake find_package() also require C language enabled,
|
|
|
|
# even if nothing from C is directly used. An easy Fortran example that fails
|
|
|
|
# without C language is
|
|
|
|
# find_package(Threads)
|
|
|
|
# To make this general to
|
|
|
|
# any other language that might need this, we use a list for all
|
|
|
|
# languages and expand in the cmake Project(... LANGUAGES ...) statement.
|
|
|
|
from ..cmake import language_map
|
|
|
|
cmake_language = [language_map[x] for x in self.language_list if x in language_map]
|
|
|
|
if not cmake_language:
|
|
|
|
cmake_language += ['NONE']
|
|
|
|
|
|
|
|
cmake_txt = textwrap.dedent("""
|
|
|
|
cmake_minimum_required(VERSION ${{CMAKE_VERSION}})
|
|
|
|
project(MesonTemp LANGUAGES {})
|
|
|
|
""").format(' '.join(cmake_language)) + cmake_txt
|
|
|
|
|
|
|
|
cm_file = build_dir / 'CMakeLists.txt'
|
|
|
|
cm_file.write_text(cmake_txt, encoding='utf-8')
|
|
|
|
mlog.cmd_ci_include(cm_file.absolute().as_posix())
|
|
|
|
|
|
|
|
return build_dir
|
|
|
|
|
|
|
|
def _call_cmake(self,
|
|
|
|
args: T.List[str],
|
|
|
|
cmake_file: str,
|
|
|
|
env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, T.Optional[str], T.Optional[str]]:
|
|
|
|
build_dir = self._setup_cmake_dir(cmake_file)
|
|
|
|
return self.cmakebin.call(args, build_dir, env=env)
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def log_tried() -> str:
|
|
|
|
return 'cmake'
|
|
|
|
|
|
|
|
def log_details(self) -> str:
|
|
|
|
modules = [self._original_module_name(x) for x in self.found_modules]
|
|
|
|
modules = sorted(set(modules))
|
|
|
|
if modules:
|
|
|
|
return 'modules: ' + ', '.join(modules)
|
|
|
|
return ''
|
|
|
|
|
|
|
|
def get_variable(self, *, cmake: T.Optional[str] = None, pkgconfig: T.Optional[str] = None,
|
|
|
|
configtool: T.Optional[str] = None, internal: T.Optional[str] = None,
|
|
|
|
default_value: T.Optional[str] = None,
|
|
|
|
pkgconfig_define: PkgConfigDefineType = None) -> str:
|
|
|
|
if cmake and self.traceparser is not None:
|
|
|
|
try:
|
|
|
|
v = self.traceparser.vars[cmake]
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
# CMake does NOT have a list datatype. We have no idea whether
|
|
|
|
# anything is a string or a string-separated-by-; Internally,
|
|
|
|
# we treat them as the latter and represent everything as a
|
|
|
|
# list, because it is convenient when we are mostly handling
|
|
|
|
# imported targets, which have various properties that are
|
|
|
|
# actually lists.
|
|
|
|
#
|
|
|
|
# As a result we need to convert them back to strings when grabbing
|
|
|
|
# raw variables the user requested.
|
|
|
|
return ';'.join(v)
|
|
|
|
if default_value is not None:
|
|
|
|
return default_value
|
|
|
|
raise DependencyException(f'Could not get cmake variable and no default provided for {self!r}')
|
|
|
|
|
|
|
|
|
|
|
|
class CMakeDependencyFactory:
|
|
|
|
|
|
|
|
def __init__(self, name: T.Optional[str] = None, modules: T.Optional[T.List[str]] = None):
|
|
|
|
self.name = name
|
|
|
|
self.modules = modules
|
|
|
|
|
|
|
|
def __call__(self, name: str, env: Environment, kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None, force_use_global_compilers: bool = False) -> CMakeDependency:
|
|
|
|
if self.modules:
|
|
|
|
kwargs['modules'] = self.modules
|
|
|
|
return CMakeDependency(self.name or name, env, kwargs, language, force_use_global_compilers)
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def log_tried() -> str:
|
|
|
|
return CMakeDependency.log_tried()
|