return MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST

class ExternalDependency(Dependency, HasNativeKwarg):

Dependency.__init__(self, type_name, kwargs)

self.env = environment

self.name = type_name # default

tool_name = None

__strip_version = re.compile(r'^[0-9.]*')

self.name = name

self.tools = listify(kwargs.get('tools', self.tools))

sub = type('{}Dependency'.format(name.capitalize()), (cls, ),

{'tools': tools, 'tool_name': tool_name, '__reduce__': reduce, 'finish_init': staticmethod(finish_init)})

@classmethod

def _unpickle(cls):

# We cache all pkg-config subprocess invocations to avoid redundant calls

pkgbin_cache = {}

self.name = name

self.is_libtool = False

# Store a copy of the pkg-config path on the object itself so it is

# one module

return module

# Gather a list of all languages to support

self.language_list = [] # type: T.List[str]

if language is None:

# Ensure that the list is unique

self.language_list = list(set(self.language_list))

self.name = name

self.is_libtool = False

# Store a copy of the CMake path on the object itself so it is

class_dubbin = None

def __init__(self, name, environment, kwargs):

self.name = name

self.compiler = super().get_compiler()

self.module_path = None

class ExternalLibrary(ExternalDependency):

def __init__(self, name, link_args, environment, language, silent=False):

self.name = name

self.language = language

self.is_found = False

class ExtraFrameworkDependency(ExternalDependency):

system_framework_paths = None

self.name = name

# Full path to framework directory

self.framework_path = None

if not self.clib_compiler:

if 'extraframework' == kwargs.get('method', ''):

# On OSX, also try framework dependency detector

if mesonlib.is_osx():

return candidates

# Otherwise, just use the pkgconfig and cmake dependency detector

# On OSX, also try framework dependency detector

if mesonlib.is_osx():

# Only use CMake as a last resort, since it might not work 100% (see #6113)

candidates.append(functools.partial(CMakeDependency, name, env, kwargs))

class BoostDependency(ExternalDependency):

def __init__(self, environment, kwargs):

self.need_static_link = ['boost_exception', 'boost_test_exec_monitor']

self.is_debug = environment.coredata.get_builtin_option('buildtype').startswith('debug')

threading = kwargs.get("threading", "multi")

low-level MPI calls.

"""

def __init__(self, environment, kwargs: dict):

kwargs['required'] = False

kwargs['silent'] = True

self.is_found = False

if language not in self.supported_languages:

raise DependencyException('Language \'{}\' is not supported by the CUDA Toolkit. Supported languages are {}.'.format(language, self.supported_languages))

self.requested_modules = self.get_requested(kwargs)

if 'cudart' not in self.requested_modules:

self.requested_modules = ['cudart'] + self.requested_modules

class GTestDependency(ExternalDependency):

def __init__(self, environment, kwargs):

self.main = kwargs.get('main', False)

self.src_dirs = ['/usr/src/gtest/src', '/usr/src/googletest/googletest/src']

self.detect()

class GMockDependency(ExternalDependency):

def __init__(self, environment, kwargs):

self.main = kwargs.get('main', False)

self._add_sub_dependency(ThreadDependency, environment, kwargs)

# It's necessary for LLVM <= 3.8 to use the C++ linker. For 3.9 and 4.0

# the C linker works fine if only using the C API.

self.provided_modules = []

self.required_modules = set()

self.module_details = []

def __init__(self, env, kwargs):

self.llvm_modules = stringlistify(extract_as_list(kwargs, 'modules'))

self.llvm_opt_modules = stringlistify(extract_as_list(kwargs, 'optional_modules'))

if self.traceparser is None:

return

class LLVMDependency(ExternalDependency):

def __init__(self, env, kwargs):

@classmethod

def _factory(cls, env, kwargs):

def __init__(self, environment, kwargs):

language = kwargs.get('language', 'c')

kwargs['required'] = False

kwargs['silent'] = True

self.is_found = False

def __init__(self, environment, kwargs):

language = kwargs.get('language', 'c')

kwargs['required'] = False

kwargs['silent'] = True

self.is_found = False

def __init__(self, environment, kwargs):

language = kwargs.get('language')

self.is_found = False

if self.clib_compiler.get_id() == 'pgi':

# through at least PGI 19.4, there is no macro defined for OpenMP, but OpenMP 3.1 is supported.

class ThreadDependency(ExternalDependency):

def __init__(self, environment, kwargs):

self.name = 'threads'

self.is_found = False

methods = listify(self.methods)

class BlocksDependency(ExternalDependency):

def __init__(self, environment, kwargs):

self.name = 'blocks'

self.is_found = False

class Python3Dependency(ExternalDependency):

def __init__(self, environment, kwargs):

if not environment.machines.matches_build_machine(self.for_machine):

return

# number in its name.

# There is a python in /System/Library/Frameworks, but that's

# python 2, Python 3 will always be in /Library

candidates.append(functools.partial(

return candidates

class PcapDependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

class CupsDependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

if DependencyMethods.EXTRAFRAMEWORK in methods:

if mesonlib.is_osx():

candidates.append(functools.partial(

if DependencyMethods.CMAKE in methods:

candidates.append(functools.partial(CMakeDependency, 'Cups', environment, kwargs))

class LibWmfDependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

class LibGCryptDependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

class GpgmeDependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

class ShadercDependency(ExternalDependency):

def __init__(self, environment, kwargs):

static_lib = 'shaderc_combined'

shared_lib = 'shaderc_shared'

def __init__(self, environment, kwargs: dict):

language = kwargs.get('language', 'c')

kwargs['required'] = False

kwargs['silent'] = True

self.is_found = False

class AppleFrameworks(ExternalDependency):

def __init__(self, env, kwargs):

modules = kwargs.get('modules', [])

if isinstance(modules, str):

modules = [modules]

class ScalapackDependency(ExternalDependency):

def __init__(self, environment, kwargs: dict):

kwargs['required'] = False

kwargs['silent'] = True

self.is_found = False

import os

import re

import subprocess

from collections import OrderedDict

from .. import mlog

class GLDependency(ExternalDependency):

def __init__(self, environment, kwargs):

if self.env.machines[self.for_machine].is_darwin():

self.is_found = True

tool_name = 'gnustep-config'

def __init__(self, environment, kwargs):

if not self.is_found:

return

self.modules = kwargs.get('modules', [])

os.path.join(private_dir, 'Qt' + module))

class QtExtraFrameworkDependency(ExtraFrameworkDependency):

self.mod_name = name[2:]

def get_compile_args(self, with_private_headers=False, qt_version="0"):

class QtBaseDependency(ExternalDependency):

def __init__(self, name, env, kwargs):

self.qtname = name.capitalize()

self.qtver = name[-1]

if self.qtver == "4":

# ExtraFrameworkDependency doesn't support any methods

fw_kwargs = kwargs.copy()

fw_kwargs.pop('method', None)

for m in modules:

fname = 'Qt' + m

mlog.debug('Looking for qt framework ' + fname)

self.compile_args.append('-F' + libdir)

if fwdep.found():

self.compile_args += fwdep.get_compile_args(with_private_headers=self.private_headers,

# sdl2-config, pkg-config and OSX framework

class SDL2Dependency(ExternalDependency):

def __init__(self, environment, kwargs):

@classmethod

def _factory(cls, environment, kwargs):

if DependencyMethods.EXTRAFRAMEWORK in methods:

if mesonlib.is_osx():

# fwdep.version = '2' # FIXME

return candidates

tool_name = 'wx-config'

def __init__(self, environment, kwargs):

if not self.is_found:

return

self.requested_modules = self.get_requested(kwargs)

class VulkanDependency(ExternalDependency):

def __init__(self, environment, kwargs):

try:

self.vulkan_sdk = os.environ['VULKAN_SDK']

class PythonDependency(ExternalDependency):

def __init__(self, python_holder, environment, kwargs):

self.name = 'python'

self.static = kwargs.get('static', False)

self.embed = kwargs.get('embed', False)