|
|
|
# Copyright 2013-2021 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 .base import Dependency, ExternalDependency, DependencyException, DependencyMethods, NotFoundDependency
|
|
|
|
from .cmake import CMakeDependency
|
|
|
|
from .dub import DubDependency
|
|
|
|
from .framework import ExtraFrameworkDependency
|
|
|
|
from .pkgconfig import PkgConfigDependency
|
|
|
|
|
|
|
|
from ..mesonlib import listify, MachineChoice, PerMachine
|
|
|
|
from .. import mlog
|
|
|
|
import functools
|
|
|
|
import typing as T
|
|
|
|
|
|
|
|
if T.TYPE_CHECKING:
|
|
|
|
from ..environment import Environment
|
|
|
|
from .factory import DependencyFactory, WrappedFactoryFunc, DependencyGenerator
|
|
|
|
|
|
|
|
# These must be defined in this file to avoid cyclical references.
|
|
|
|
packages: T.Dict[
|
|
|
|
str,
|
|
|
|
T.Union[T.Type[ExternalDependency], 'DependencyFactory', 'WrappedFactoryFunc']
|
|
|
|
] = {}
|
|
|
|
_packages_accept_language: T.Set[str] = set()
|
|
|
|
|
|
|
|
if T.TYPE_CHECKING:
|
|
|
|
TV_DepIDEntry = T.Union[str, bool, int, T.Tuple[str, ...]]
|
|
|
|
TV_DepID = T.Tuple[T.Tuple[str, TV_DepIDEntry], ...]
|
|
|
|
|
|
|
|
|
|
|
|
def get_dep_identifier(name: str, kwargs: T.Dict[str, T.Any]) -> 'TV_DepID':
|
|
|
|
identifier: 'TV_DepID' = (('name', name), )
|
|
|
|
from ..interpreter import permitted_dependency_kwargs
|
|
|
|
assert len(permitted_dependency_kwargs) == 19, \
|
|
|
|
'Extra kwargs have been added to dependency(), please review if it makes sense to handle it here'
|
|
|
|
for key, value in kwargs.items():
|
|
|
|
# 'version' is irrelevant for caching; the caller must check version matches
|
|
|
|
# 'native' is handled above with `for_machine`
|
|
|
|
# 'required' is irrelevant for caching; the caller handles it separately
|
|
|
|
# 'fallback' and 'allow_fallback' is not part of the cache because,
|
|
|
|
# once a dependency has been found through a fallback, it should
|
|
|
|
# be used for the rest of the Meson run.
|
|
|
|
# 'default_options' is only used in fallback case
|
|
|
|
# 'not_found_message' has no impact on the dependency lookup
|
|
|
|
# 'include_type' is handled after the dependency lookup
|
|
|
|
if key in ('version', 'native', 'required', 'fallback', 'allow_fallback', 'default_options',
|
|
|
|
'not_found_message', 'include_type'):
|
|
|
|
continue
|
|
|
|
# All keyword arguments are strings, ints, or lists (or lists of lists)
|
|
|
|
if isinstance(value, list):
|
|
|
|
value = frozenset(listify(value))
|
|
|
|
for i in value:
|
|
|
|
assert isinstance(i, str)
|
|
|
|
else:
|
|
|
|
assert isinstance(value, (str, bool, int))
|
|
|
|
identifier += (key, value)
|
|
|
|
return identifier
|
|
|
|
|
|
|
|
display_name_map = {
|
|
|
|
'boost': 'Boost',
|
|
|
|
'cuda': 'CUDA',
|
|
|
|
'dub': 'DUB',
|
|
|
|
'gmock': 'GMock',
|
|
|
|
'gtest': 'GTest',
|
|
|
|
'hdf5': 'HDF5',
|
|
|
|
'llvm': 'LLVM',
|
|
|
|
'mpi': 'MPI',
|
|
|
|
'netcdf': 'NetCDF',
|
|
|
|
'openmp': 'OpenMP',
|
|
|
|
'wxwidgets': 'WxWidgets',
|
|
|
|
}
|
|
|
|
|
|
|
|
def find_external_dependency(name: str, env: 'Environment', kwargs: T.Dict[str, object]) -> T.Union['ExternalDependency', NotFoundDependency]:
|
|
|
|
assert name
|
|
|
|
required = kwargs.get('required', True)
|
|
|
|
if not isinstance(required, bool):
|
|
|
|
raise DependencyException('Keyword "required" must be a boolean.')
|
|
|
|
if not isinstance(kwargs.get('method', ''), str):
|
|
|
|
raise DependencyException('Keyword "method" must be a string.')
|
|
|
|
lname = name.lower()
|
|
|
|
if lname not in _packages_accept_language and 'language' in kwargs:
|
|
|
|
raise DependencyException(f'{name} dependency does not accept "language" keyword argument')
|
|
|
|
if not isinstance(kwargs.get('version', ''), (str, list)):
|
|
|
|
raise DependencyException('Keyword "Version" must be string or list.')
|
|
|
|
|
|
|
|
# display the dependency name with correct casing
|
|
|
|
display_name = display_name_map.get(lname, lname)
|
|
|
|
|
|
|
|
for_machine = MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST
|
|
|
|
|
|
|
|
type_text = PerMachine('Build-time', 'Run-time')[for_machine] + ' dependency'
|
|
|
|
|
|
|
|
# build a list of dependency methods to try
|
|
|
|
candidates = _build_external_dependency_list(name, env, for_machine, kwargs)
|
|
|
|
|
|
|
|
pkg_exc: T.List[DependencyException] = []
|
|
|
|
pkgdep: T.List[ExternalDependency] = []
|
|
|
|
details = ''
|
|
|
|
|
|
|
|
for c in candidates:
|
|
|
|
# try this dependency method
|
|
|
|
try:
|
|
|
|
d = c()
|
|
|
|
d._check_version()
|
|
|
|
pkgdep.append(d)
|
|
|
|
except DependencyException as e:
|
|
|
|
pkg_exc.append(e)
|
|
|
|
mlog.debug(str(e))
|
|
|
|
else:
|
|
|
|
pkg_exc.append(None)
|
|
|
|
details = d.log_details()
|
|
|
|
if details:
|
|
|
|
details = '(' + details + ') '
|
|
|
|
if 'language' in kwargs:
|
|
|
|
details += 'for ' + d.language + ' '
|
|
|
|
|
|
|
|
# if the dependency was found
|
|
|
|
if d.found():
|
|
|
|
|
|
|
|
info: mlog.TV_LoggableList = []
|
|
|
|
if d.version:
|
|
|
|
info.append(mlog.normal_cyan(d.version))
|
|
|
|
|
|
|
|
log_info = d.log_info()
|
|
|
|
if log_info:
|
|
|
|
info.append('(' + log_info + ')')
|
|
|
|
|
|
|
|
mlog.log(type_text, mlog.bold(display_name), details + 'found:', mlog.green('YES'), *info)
|
|
|
|
|
|
|
|
return d
|
|
|
|
|
|
|
|
# otherwise, the dependency could not be found
|
|
|
|
tried_methods = [d.log_tried() for d in pkgdep if d.log_tried()]
|
|
|
|
if tried_methods:
|
|
|
|
tried = '{}'.format(mlog.format_list(tried_methods))
|
|
|
|
else:
|
|
|
|
tried = ''
|
|
|
|
|
|
|
|
mlog.log(type_text, mlog.bold(display_name), details + 'found:', mlog.red('NO'),
|
|
|
|
f'(tried {tried})' if tried else '')
|
|
|
|
|
|
|
|
if required:
|
|
|
|
# if an exception occurred with the first detection method, re-raise it
|
|
|
|
# (on the grounds that it came from the preferred dependency detection
|
|
|
|
# method)
|
|
|
|
if pkg_exc and pkg_exc[0]:
|
|
|
|
raise pkg_exc[0]
|
|
|
|
|
|
|
|
# we have a list of failed ExternalDependency objects, so we can report
|
|
|
|
# the methods we tried to find the dependency
|
|
|
|
raise DependencyException('Dependency "%s" not found' % (name) +
|
|
|
|
(', tried %s' % (tried) if tried else ''))
|
|
|
|
|
|
|
|
return NotFoundDependency(env)
|
|
|
|
|
|
|
|
|
|
|
|
def _build_external_dependency_list(name: str, env: 'Environment', for_machine: MachineChoice,
|
|
|
|
kwargs: T.Dict[str, T.Any]) -> T.List['DependencyGenerator']:
|
|
|
|
# First check if the method is valid
|
|
|
|
if 'method' in kwargs and kwargs['method'] not in [e.value for e in DependencyMethods]:
|
|
|
|
raise DependencyException('method {!r} is invalid'.format(kwargs['method']))
|
|
|
|
|
|
|
|
# Is there a specific dependency detector for this dependency?
|
|
|
|
lname = name.lower()
|
|
|
|
if lname in packages:
|
|
|
|
# Create the list of dependency object constructors using a factory
|
|
|
|
# class method, if one exists, otherwise the list just consists of the
|
|
|
|
# constructor
|
|
|
|
if isinstance(packages[lname], type):
|
|
|
|
entry1 = T.cast(T.Type[ExternalDependency], packages[lname]) # mypy doesn't understand isinstance(..., type)
|
|
|
|
if issubclass(entry1, ExternalDependency):
|
|
|
|
# TODO: somehow make mypy understand that entry1(env, kwargs) is OK...
|
|
|
|
func: T.Callable[[], 'ExternalDependency'] = lambda: entry1(env, kwargs) # type: ignore
|
|
|
|
dep = [func]
|
|
|
|
else:
|
|
|
|
entry2 = T.cast(T.Union['DependencyFactory', 'WrappedFactoryFunc'], packages[lname])
|
|
|
|
dep = entry2(env, for_machine, kwargs)
|
|
|
|
return dep
|
|
|
|
|
|
|
|
candidates: T.List['DependencyGenerator'] = []
|
|
|
|
|
|
|
|
# If it's explicitly requested, use the dub detection method (only)
|
|
|
|
if 'dub' == kwargs.get('method', ''):
|
|
|
|
candidates.append(functools.partial(DubDependency, name, env, kwargs))
|
|
|
|
return candidates
|
|
|
|
|
|
|
|
# If it's explicitly requested, use the pkgconfig detection method (only)
|
|
|
|
if 'pkg-config' == kwargs.get('method', ''):
|
|
|
|
candidates.append(functools.partial(PkgConfigDependency, name, env, kwargs))
|
|
|
|
return candidates
|
|
|
|
|
|
|
|
# If it's explicitly requested, use the CMake detection method (only)
|
|
|
|
if 'cmake' == kwargs.get('method', ''):
|
|
|
|
candidates.append(functools.partial(CMakeDependency, name, env, kwargs))
|
|
|
|
return candidates
|
|
|
|
|
|
|
|
# If it's explicitly requested, use the Extraframework detection method (only)
|
|
|
|
if 'extraframework' == kwargs.get('method', ''):
|
|
|
|
# On OSX, also try framework dependency detector
|
|
|
|
if env.machines[for_machine].is_darwin():
|
|
|
|
candidates.append(functools.partial(ExtraFrameworkDependency, name, env, kwargs))
|
|
|
|
return candidates
|
|
|
|
|
|
|
|
# Otherwise, just use the pkgconfig and cmake dependency detector
|
|
|
|
if 'auto' == kwargs.get('method', 'auto'):
|
|
|
|
candidates.append(functools.partial(PkgConfigDependency, name, env, kwargs))
|
|
|
|
|
|
|
|
# On OSX, also try framework dependency detector
|
|
|
|
if env.machines[for_machine].is_darwin():
|
|
|
|
candidates.append(functools.partial(ExtraFrameworkDependency, name, env, kwargs))
|
|
|
|
|
|
|
|
# Only use CMake as a last resort, since it might not work 100% (see #6113)
|
|
|
|
candidates.append(functools.partial(CMakeDependency, name, env, kwargs))
|
|
|
|
|
|
|
|
return candidates
|